From 48f524c55426d1bca15ca9b788d2ca29c9777f32 Mon Sep 17 00:00:00 2001 From: Carlos Villela Date: Tue, 6 Jan 2026 23:53:01 -0800 Subject: [PATCH 1/2] Add --no-extensions flag to disable extension discovery Similar to --no-skills, this flag disables extension discovery and loading. Useful for debugging or when extensions are causing issues. --- packages/coding-agent/CHANGELOG.md | 4 ++++ packages/coding-agent/src/cli/args.ts | 4 ++++ packages/coding-agent/src/main.ts | 22 +++++++++++++++------- packages/coding-agent/test/args.test.ts | 14 ++++++++++++++ 4 files changed, 37 insertions(+), 7 deletions(-) diff --git a/packages/coding-agent/CHANGELOG.md b/packages/coding-agent/CHANGELOG.md index 93537565..f2107d55 100644 --- a/packages/coding-agent/CHANGELOG.md +++ b/packages/coding-agent/CHANGELOG.md @@ -2,6 +2,10 @@ ## [Unreleased] +### Added + +- `--no-extensions` flag to disable extension discovery and loading + ## [0.37.8] - 2026-01-07 ## [0.37.7] - 2026-01-07 diff --git a/packages/coding-agent/src/cli/args.ts b/packages/coding-agent/src/cli/args.ts index cbb11a79..e8da9a08 100644 --- a/packages/coding-agent/src/cli/args.ts +++ b/packages/coding-agent/src/cli/args.ts @@ -27,6 +27,7 @@ export interface Args { models?: string[]; tools?: ToolName[]; extensions?: string[]; + noExtensions?: boolean; print?: boolean; export?: string; noSkills?: boolean; @@ -116,6 +117,8 @@ export function parseArgs(args: string[], extensionFlags?: Map Set thinking level: off, minimal, low, medium, high, xhigh --extension, -e Load an extension file (can be used multiple times) + --no-extensions Disable extensions discovery and loading --no-skills Disable skills discovery and loading --skills Comma-separated glob patterns to filter skills (e.g., git-*,docker) --export Export session file to HTML and exit diff --git a/packages/coding-agent/src/main.ts b/packages/coding-agent/src/main.ts index da8d0e6c..d6f2ae9b 100644 --- a/packages/coding-agent/src/main.ts +++ b/packages/coding-agent/src/main.ts @@ -294,8 +294,11 @@ function buildSessionOptions( options.skills = []; } - // Pre-loaded extensions (from early CLI flag discovery) - if (preloadedExtensions && preloadedExtensions.length > 0) { + // Extensions + if (parsed.noExtensions) { + options.extensions = []; + } else if (preloadedExtensions && preloadedExtensions.length > 0) { + // Pre-loaded extensions (from early CLI flag discovery) options.preloadedExtensions = preloadedExtensions; } @@ -317,16 +320,21 @@ export async function main(args: string[]) { const firstPass = parseArgs(args); time("parseArgs-firstPass"); - // Early load extensions to discover their CLI flags + // Early load extensions to discover their CLI flags (unless --no-extensions) const cwd = process.cwd(); const agentDir = getAgentDir(); const eventBus = createEventBus(); const settingsManager = SettingsManager.create(cwd); time("SettingsManager.create"); - // Merge CLI --extension args with settings.json extensions - const extensionPaths = [...settingsManager.getExtensionPaths(), ...(firstPass.extensions ?? [])]; - const { extensions: loadedExtensions } = await discoverAndLoadExtensions(extensionPaths, cwd, agentDir, eventBus); - time("discoverExtensionFlags"); + + let loadedExtensions: LoadedExtension[] = []; + if (!firstPass.noExtensions) { + // Merge CLI --extension args with settings.json extensions + const extensionPaths = [...settingsManager.getExtensionPaths(), ...(firstPass.extensions ?? [])]; + const result = await discoverAndLoadExtensions(extensionPaths, cwd, agentDir, eventBus); + loadedExtensions = result.extensions; + time("discoverExtensionFlags"); + } // Collect all extension flags const extensionFlags = new Map(); diff --git a/packages/coding-agent/test/args.test.ts b/packages/coding-agent/test/args.test.ts index 9f809a51..2b3a8af6 100644 --- a/packages/coding-agent/test/args.test.ts +++ b/packages/coding-agent/test/args.test.ts @@ -150,6 +150,20 @@ describe("parseArgs", () => { }); }); + describe("--no-extensions flag", () => { + test("parses --no-extensions flag", () => { + const result = parseArgs(["--no-extensions"]); + expect(result.noExtensions).toBe(true); + }); + }); + + describe("--no-skills flag", () => { + test("parses --no-skills flag", () => { + const result = parseArgs(["--no-skills"]); + expect(result.noSkills).toBe(true); + }); + }); + describe("messages and file args", () => { test("parses plain text messages", () => { const result = parseArgs(["hello", "world"]); From 499341cdc1fb6cfb84878e40858d785e43abe15d Mon Sep 17 00:00:00 2001 From: Carlos Villela Date: Wed, 7 Jan 2026 02:04:46 -0800 Subject: [PATCH 2/2] feat(coding-agent): allow explicit -e flags with --no-extensions --no-extensions now skips discovery but still loads extensions specified via -e flags. This gives users three modes: 1. Default: auto-discover + any -e additions 2. --no-extensions: no extensions at all 3. --no-extensions -e foo.js: only load foo.js, skip discovery fixes #524 --- packages/coding-agent/src/main.ts | 17 +++++++++-- packages/coding-agent/test/args.test.ts | 6 ++++ .../test/extensions-discovery.test.ts | 30 +++++++++++++++++++ 3 files changed, 51 insertions(+), 2 deletions(-) diff --git a/packages/coding-agent/src/main.ts b/packages/coding-agent/src/main.ts index d6f2ae9b..33e9d938 100644 --- a/packages/coding-agent/src/main.ts +++ b/packages/coding-agent/src/main.ts @@ -18,7 +18,12 @@ import type { AgentSession } from "./core/agent-session.js"; import { createEventBus } from "./core/event-bus.js"; import { exportFromFile } from "./core/export-html/index.js"; -import { discoverAndLoadExtensions, type ExtensionUIContext, type LoadedExtension } from "./core/extensions/index.js"; +import { + discoverAndLoadExtensions, + type ExtensionUIContext, + type LoadedExtension, + loadExtensions, +} from "./core/extensions/index.js"; import type { ModelRegistry } from "./core/model-registry.js"; import { resolveModelScope, type ScopedModel } from "./core/model-resolver.js"; import { type CreateAgentSessionOptions, createAgentSession, discoverAuthStorage, discoverModels } from "./core/sdk.js"; @@ -328,7 +333,15 @@ export async function main(args: string[]) { time("SettingsManager.create"); let loadedExtensions: LoadedExtension[] = []; - if (!firstPass.noExtensions) { + if (firstPass.noExtensions) { + // --no-extensions disables discovery, but explicit -e flags still work + const explicitPaths = firstPass.extensions ?? []; + if (explicitPaths.length > 0) { + const result = await loadExtensions(explicitPaths, cwd, eventBus); + loadedExtensions = result.extensions; + time("loadExtensions"); + } + } else { // Merge CLI --extension args with settings.json extensions const extensionPaths = [...settingsManager.getExtensionPaths(), ...(firstPass.extensions ?? [])]; const result = await discoverAndLoadExtensions(extensionPaths, cwd, agentDir, eventBus); diff --git a/packages/coding-agent/test/args.test.ts b/packages/coding-agent/test/args.test.ts index 2b3a8af6..bb9e7862 100644 --- a/packages/coding-agent/test/args.test.ts +++ b/packages/coding-agent/test/args.test.ts @@ -155,6 +155,12 @@ describe("parseArgs", () => { const result = parseArgs(["--no-extensions"]); expect(result.noExtensions).toBe(true); }); + + test("parses --no-extensions with explicit -e flags", () => { + const result = parseArgs(["--no-extensions", "-e", "foo.ts", "-e", "bar.ts"]); + expect(result.noExtensions).toBe(true); + expect(result.extensions).toEqual(["foo.ts", "bar.ts"]); + }); }); describe("--no-skills flag", () => { diff --git a/packages/coding-agent/test/extensions-discovery.test.ts b/packages/coding-agent/test/extensions-discovery.test.ts index fa2edf88..2db8e7bb 100644 --- a/packages/coding-agent/test/extensions-discovery.test.ts +++ b/packages/coding-agent/test/extensions-discovery.test.ts @@ -443,4 +443,34 @@ describe("extensions discovery", () => { expect(result.extensions).toHaveLength(1); expect(result.extensions[0].flags.has("--my-flag")).toBe(true); }); + + it("loadExtensions only loads explicit paths without discovery", async () => { + // Create discoverable extensions (would be found by discoverAndLoadExtensions) + fs.writeFileSync(path.join(extensionsDir, "discovered.ts"), extensionCodeWithTool("discovered")); + + // Create explicit extension outside discovery path + const explicitPath = path.join(tempDir, "explicit.ts"); + fs.writeFileSync(explicitPath, extensionCodeWithTool("explicit")); + + // Use loadExtensions directly to skip discovery + const { loadExtensions } = await import("../src/core/extensions/loader.js"); + const result = await loadExtensions([explicitPath], tempDir); + + expect(result.errors).toHaveLength(0); + expect(result.extensions).toHaveLength(1); + expect(result.extensions[0].tools.has("explicit")).toBe(true); + expect(result.extensions[0].tools.has("discovered")).toBe(false); + }); + + it("loadExtensions with no paths loads nothing", async () => { + // Create discoverable extensions (would be found by discoverAndLoadExtensions) + fs.writeFileSync(path.join(extensionsDir, "discovered.ts"), extensionCode); + + // Use loadExtensions directly with empty paths + const { loadExtensions } = await import("../src/core/extensions/loader.js"); + const result = await loadExtensions([], tempDir); + + expect(result.errors).toHaveLength(0); + expect(result.extensions).toHaveLength(0); + }); });