@clinebot/core 0.0.32 → 0.0.34

package/src/extensions/plugin/plugin-sandbox-bootstrap.ts

@@ -84,6 +84,7 @@ interface ContributionDescriptor {
 
 interface PluginDescriptor {
 	pluginId: string;
+	pluginPath: string;
 	name: string;
 	manifest: Record<string, unknown>;
 	contributions: {
@@ -96,6 +97,28 @@ interface PluginDescriptor {
 	};
 }
 
+interface PluginInitializationFailure {
+	pluginPath: string;
+	pluginName?: string;
+	phase: "load" | "setup";
+	message: string;
+	stack?: string;
+}
+
+interface PluginInitializationWarning {
+	type: "duplicate_plugin_override";
+	pluginPath: string;
+	pluginName: string;
+	overriddenPluginPath: string;
+	message: string;
+}
+
+interface InitializeResult {
+	plugins: PluginDescriptor[];
+	failures: PluginInitializationFailure[];
+	warnings: PluginInitializationWarning[];
+}
+
 interface PluginState {
 	plugin: PluginModule;
 	handlers: {
@@ -191,104 +214,153 @@ function getPlugin(pluginId: string): PluginState {
 async function initialize(args: {
 	pluginPaths?: string[];
 	exportName?: string;
-}): Promise<PluginDescriptor[]> {
+}): Promise<InitializeResult> {
 	pluginState.clear();
 	pluginCounter = 0;
 	contributionCounters.clear();
 
 	const descriptors: PluginDescriptor[] = [];
+	const failures: PluginInitializationFailure[] = [];
+	const warnings: PluginInitializationWarning[] = [];
 	const exportName = args.exportName || "plugin";
+	const pluginIndexByName = new Map<string, number>();
 
 	for (const pluginPath of args.pluginPaths || []) {
-		const moduleExports = await importPluginModule(pluginPath);
-		const plugin = (moduleExports.default ??
-			moduleExports[exportName]) as unknown;
-		assertValidPluginModule(plugin, pluginPath);
-
-		const pluginId = `plugin_${++pluginCounter}`;
-		const contributions: PluginDescriptor["contributions"] = {
-			tools: [],
-			commands: [],
-			shortcuts: [],
-			flags: [],
-			messageBuilders: [],
-			providers: [],
-		};
-		const handlers: PluginState["handlers"] = {
-			tools: new Map(),
-			commands: new Map(),
-			messageBuilders: new Map(),
-		};
-
-		const api: PluginApi = {
-			registerTool: (tool) => {
-				const id = makeId(pluginId, "tool");
-				handlers.tools.set(id, tool.execute);
-				contributions.tools.push({
-					id,
-					name: tool.name,
-					description: tool.description,
-					inputSchema: tool.inputSchema,
-					timeoutMs: tool.timeoutMs,
-					retryable: tool.retryable,
-				});
-			},
-			registerCommand: (command) => {
-				const id = makeId(pluginId, "command");
-				if (typeof command.handler === "function") {
-					handlers.commands.set(id, command.handler);
+		let plugin: PluginModule | undefined;
+		try {
+			const moduleExports = await importPluginModule(pluginPath);
+			plugin = (moduleExports.default ??
+				moduleExports[exportName]) as unknown as PluginModule;
+			assertValidPluginModule(plugin, pluginPath);
+
+			const pluginId = `plugin_${++pluginCounter}`;
+			const contributions: PluginDescriptor["contributions"] = {
+				tools: [],
+				commands: [],
+				shortcuts: [],
+				flags: [],
+				messageBuilders: [],
+				providers: [],
+			};
+			const handlers: PluginState["handlers"] = {
+				tools: new Map(),
+				commands: new Map(),
+				messageBuilders: new Map(),
+			};
+
+			const api: PluginApi = {
+				registerTool: (tool) => {
+					const id = makeId(pluginId, "tool");
+					handlers.tools.set(id, tool.execute);
+					contributions.tools.push({
+						id,
+						name: tool.name,
+						description: tool.description,
+						inputSchema: tool.inputSchema,
+						timeoutMs: tool.timeoutMs,
+						retryable: tool.retryable,
+					});
+				},
+				registerCommand: (command) => {
+					const id = makeId(pluginId, "command");
+					if (typeof command.handler === "function") {
+						handlers.commands.set(id, command.handler);
+					}
+					contributions.commands.push({
+						id,
+						name: command.name,
+						description: command.description,
+					});
+				},
+				registerShortcut: (shortcut) => {
+					contributions.shortcuts.push({
+						id: makeId(pluginId, "shortcut"),
+						name: shortcut.name,
+						value: shortcut.value,
+						description: shortcut.description,
+					});
+				},
+				registerFlag: (flag) => {
+					contributions.flags.push({
+						id: makeId(pluginId, "flag"),
+						name: flag.name,
+						description: flag.description,
+						defaultValue: flag.defaultValue,
+					});
+				},
+				registerMessageBuilder: (builder) => {
+					const id = makeId(pluginId, "builder");
+					handlers.messageBuilders.set(id, builder.build);
+					contributions.messageBuilders.push({ id, name: builder.name });
+				},
+				registerProvider: (provider) => {
+					contributions.providers.push({
+						id: makeId(pluginId, "provider"),
+						name: provider.name,
+						description: provider.description,
+						metadata: sanitizeObject(provider.metadata),
+					});
+				},
+			};
+
+			if (typeof plugin.setup === "function") {
+				try {
+					await plugin.setup(api);
+				} catch (error) {
+					failures.push({
+						pluginPath,
+						pluginName: plugin.name,
+						phase: "setup",
+						message: error instanceof Error ? error.message : String(error),
+						stack: error instanceof Error ? error.stack : undefined,
+					});
+					continue;
+				}
+			}
+
+			const previousIndex = pluginIndexByName.get(plugin.name);
+			if (previousIndex !== undefined) {
+				const previous = descriptors[previousIndex];
+				if (!previous) {
+					pluginIndexByName.delete(plugin.name);
+				} else {
+					warnings.push({
+						type: "duplicate_plugin_override",
+						pluginName: plugin.name,
+						pluginPath,
+						overriddenPluginPath: previous.pluginPath,
+						message: `Plugin "${plugin.name}" from ${pluginPath} overrides ${previous.pluginPath}`,
+					});
+					pluginState.delete(previous.pluginId);
+					descriptors.splice(previousIndex, 1);
+					pluginIndexByName.clear();
+					for (const [index, descriptor] of descriptors.entries()) {
+						pluginIndexByName.set(descriptor.name, index);
+					}
 				}
-				contributions.commands.push({
-					id,
-					name: command.name,
-					description: command.description,
-				});
-			},
-			registerShortcut: (shortcut) => {
-				contributions.shortcuts.push({
-					id: makeId(pluginId, "shortcut"),
-					name: shortcut.name,
-					value: shortcut.value,
-					description: shortcut.description,
-				});
-			},
-			registerFlag: (flag) => {
-				contributions.flags.push({
-					id: makeId(pluginId, "flag"),
-					name: flag.name,
-					description: flag.description,
-					defaultValue: flag.defaultValue,
-				});
-			},
-			registerMessageBuilder: (builder) => {
-				const id = makeId(pluginId, "builder");
-				handlers.messageBuilders.set(id, builder.build);
-				contributions.messageBuilders.push({ id, name: builder.name });
-			},
-			registerProvider: (provider) => {
-				contributions.providers.push({
-					id: makeId(pluginId, "provider"),
-					name: provider.name,
-					description: provider.description,
-					metadata: sanitizeObject(provider.metadata),
-				});
-			},
-		};
-
-		if (typeof plugin.setup === "function") {
-			await plugin.setup(api);
+			}
+
+			pluginState.set(pluginId, { plugin, handlers });
+			pluginIndexByName.set(plugin.name, descriptors.length);
+			descriptors.push({
+				pluginId,
+				pluginPath,
+				name: plugin.name,
+				manifest: plugin.manifest,
+				contributions,
+			});
+		} catch (error) {
+			failures.push({
+				pluginPath,
+				pluginName: plugin?.name,
+				phase: "load",
+				message: error instanceof Error ? error.message : String(error),
+				stack: error instanceof Error ? error.stack : undefined,
+			});
 		}
-
-		pluginState.set(pluginId, { plugin, handlers });
-		descriptors.push({
-			pluginId,
-			name: plugin.name,
-			manifest: plugin.manifest,
-			contributions,
-		});
 	}
 
-	return descriptors;
+	return { plugins: descriptors, failures, warnings };
 }
 
 async function invokeHook(args: {

package/src/extensions/plugin/plugin-sandbox.test.ts

@@ -184,6 +184,31 @@ describe("plugin-sandbox", () => {
 			"utf8",
 		);
 
+		await writeFile(
+			join(dir, "plugin-broken-setup.mjs"),
+			[
+				"export default {",
+				"  name: 'sandbox-broken-setup',",
+				"  manifest: { capabilities: ['tools'] },",
+				"  async setup() {",
+				"    throw new Error('broken setup');",
+				"  },",
+				"};",
+			].join("\n"),
+			"utf8",
+		);
+
+		await writeFile(
+			join(dir, "plugin-duplicate-a.mjs"),
+			"export default { name: 'sandbox-duplicate', manifest: { capabilities: ['tools'] } };",
+			"utf8",
+		);
+		await writeFile(
+			join(dir, "plugin-duplicate-b.mjs"),
+			"export default { name: 'sandbox-duplicate', manifest: { capabilities: ['commands'] } };",
+			"utf8",
+		);
+
 		sharedSandbox = await loadSandboxedPlugins({
 			pluginPaths: [
 				join(dir, "plugin.mjs"),
@@ -321,6 +346,51 @@ describe("plugin-sandbox", () => {
 		expect(result).toEqual({ echoed: "ok" });
 	});
 
+	it("continues loading remaining sandbox plugins when one setup fails", async () => {
+		const sandboxed = await loadSandboxedPlugins({
+			pluginPaths: [
+				join(dir, "plugin.mjs"),
+				join(dir, "plugin-broken-setup.mjs"),
+				join(dir, "plugin-events.mjs"),
+			],
+		});
+
+		try {
+			expect(sandboxed.extensions?.map((extension) => extension.name)).toEqual([
+				"sandbox-test",
+				"sandbox-events",
+			]);
+			expect(sandboxed.failures).toHaveLength(1);
+			expect(sandboxed.failures[0]?.pluginName).toBe("sandbox-broken-setup");
+			expect(sandboxed.failures[0]?.phase).toBe("setup");
+		} finally {
+			await sandboxed.shutdown();
+		}
+	});
+
+	it("keeps the later duplicate sandbox plugin and reports the override", async () => {
+		const sandboxed = await loadSandboxedPlugins({
+			pluginPaths: [
+				join(dir, "plugin-duplicate-a.mjs"),
+				join(dir, "plugin-duplicate-b.mjs"),
+			],
+		});
+
+		try {
+			expect(sandboxed.extensions).toHaveLength(1);
+			expect(sandboxed.extensions?.[0]?.name).toBe("sandbox-duplicate");
+			expect(sandboxed.extensions?.[0]?.manifest.capabilities).toEqual([
+				"commands",
+			]);
+			expect(sandboxed.warnings).toHaveLength(1);
+			expect(sandboxed.warnings[0]?.overriddenPluginPath).toBe(
+				join(dir, "plugin-duplicate-a.mjs"),
+			);
+		} finally {
+			await sandboxed.shutdown();
+		}
+	});
+
 	it("resolves plugin-local dependencies in the sandbox process", async () => {
 		expect(sharedExtensions.get("sandbox-local-dep")?.name).toBe(
 			"sandbox-local-dep",

package/src/extensions/plugin/plugin-sandbox.ts

@@ -4,6 +4,7 @@ import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import type { AgentConfig, HookStage, Tool } from "@clinebot/shared";
 import { SubprocessSandbox } from "../../runtime/subprocess-sandbox";
+import type { PluginLoadDiagnostics } from "./plugin-load-report";
 
 export interface PluginSandboxOptions {
 	pluginPaths: string[];
@@ -31,6 +32,7 @@ type SandboxedContributionDescriptor = {
 
 type SandboxedPluginDescriptor = {
 	pluginId: string;
+	pluginPath: string;
 	name: string;
 	manifest: AgentExtension["manifest"];
 	contributions: {
@@ -43,6 +45,10 @@ type SandboxedPluginDescriptor = {
 	};
 };
 
+type SandboxedInitializeResult = {
+	plugins: SandboxedPluginDescriptor[];
+} & PluginLoadDiagnostics;
+
 function isUnknownPluginIdError(error: unknown): boolean {
 	const message = error instanceof Error ? error.message : String(error);
 	return message.includes("Unknown sandbox plugin id:");
@@ -153,10 +159,12 @@ function withTimeoutFallback(
 
 export async function loadSandboxedPlugins(
 	options: PluginSandboxOptions,
-): Promise<{
-	extensions: AgentConfig["extensions"];
-	shutdown: () => Promise<void>;
-}> {
+): Promise<
+	{
+		extensions: AgentConfig["extensions"];
+		shutdown: () => Promise<void>;
+	} & PluginLoadDiagnostics
+> {
 	const sandbox = new SubprocessSandbox({
 		name: "plugin-sandbox",
 		...("file" in BOOTSTRAP
@@ -187,9 +195,9 @@ export async function loadSandboxedPlugins(
 		return reinitPromise;
 	};
 
-	let descriptors: SandboxedPluginDescriptor[];
+	let initialized: SandboxedInitializeResult;
 	try {
-		descriptors = await sandbox.call<SandboxedPluginDescriptor[]>(
+		initialized = await sandbox.call<SandboxedInitializeResult>(
 			"initialize",
 			initArgs,
 			{ timeoutMs: importTimeoutMs },
@@ -200,6 +208,7 @@ export async function loadSandboxedPlugins(
 		});
 		throw error;
 	}
+	const descriptors = initialized.plugins;
 
 	const extensions: NonNullable<AgentConfig["extensions"]> = descriptors.map(
 		(descriptor) => {
@@ -239,9 +248,11 @@ export async function loadSandboxedPlugins(
 
 	return {
 		extensions,
+		failures: initialized.failures,
 		shutdown: async () => {
 			await sandbox.shutdown();
 		},
+		warnings: initialized.warnings,
 	};
 }
 

package/src/index.ts

@@ -128,6 +128,13 @@ export {
 	OCI_HEADER_OPC_REQUEST_ID,
 	refreshOcaToken,
 } from "./auth/oca";
+export type {
+	LocalOAuthServer,
+	LocalOAuthServerOptions,
+	OAuthCallbackPayload,
+	OAuthServerCloseInfo,
+	OAuthServerListeningInfo,
+} from "./auth/server";
 export { startLocalOAuthServer } from "./auth/server";
 export type {
 	OAuthCredentials,
@@ -163,12 +170,16 @@ export {
 } from "./chat/chat-schema";
 export type {
 	LoadAgentPluginFromPathOptions,
+	PluginInitializationFailure,
+	PluginInitializationWarning,
+	PluginLoadDiagnostics,
 	ResolveAgentPluginPathsOptions,
 } from "./extensions";
 export {
 	discoverPluginModulePaths,
 	loadAgentPluginFromPath,
 	loadAgentPluginsFromPaths,
+	loadAgentPluginsFromPathsWithDiagnostics,
 	resolveAgentPluginPaths,
 	resolveAndLoadAgentPlugins,
 	resolvePluginConfigSearchPaths,

package/src/providers/local-provider-service.test.ts

@@ -922,7 +922,7 @@ describe("listLocalProviders", () => {
 		).toBe(true);
 	});
 
-	it("uses the same built-in model list for cline as vercel-ai-gateway", async () => {
+	it("uses the same built-in model list for cline as openrouter", async () => {
 		manager.saveProviderSettings(
 			{
 				provider: "cline",
@@ -935,12 +935,12 @@ describe("listLocalProviders", () => {
 
 		const { providers } = await listLocalProviders(manager);
 		const cline = providers.find((provider) => provider.id === "cline");
-		const gateway = providers.find(
-			(provider) => provider.id === "vercel-ai-gateway",
+		const openrouter = providers.find(
+			(provider) => provider.id === "openrouter",
 		);
 
 		expect(cline?.modelList?.length).toBeGreaterThan(0);
-		expect(cline?.modelList).toEqual(gateway?.modelList);
+		expect(cline?.modelList).toEqual(openrouter?.modelList);
 	});
 
 	it("does not eagerly fetch LiteLLM private models while listing providers", async () => {

package/src/runtime/hook-file-hooks.test.ts

@@ -50,7 +50,12 @@ describe("createHookConfigFileHooks", () => {
 			});
 			expect(hooks).toBeUndefined();
 		} finally {
-			await rm(workspace, { recursive: true, force: true });
+			await rm(workspace, {
+				recursive: true,
+				force: true,
+				maxRetries: 3,
+				retryDelay: 250,
+			});
 		}
 	});
 
@@ -78,7 +83,12 @@ describe("createHookConfigFileHooks", () => {
 			});
 			expect(control).toMatchObject({ cancel: true, context: "legacy-ok" });
 		} finally {
-			await rm(workspace, { recursive: true, force: true });
+			await rm(workspace, {
+				recursive: true,
+				force: true,
+				maxRetries: 3,
+				retryDelay: 250,
+			});
 		}
 	});
 
@@ -106,7 +116,12 @@ describe("createHookConfigFileHooks", () => {
 			});
 			expect(control).toMatchObject({ cancel: false, context: "shebang-ok" });
 		} finally {
-			await rm(workspace, { recursive: true, force: true });
+			await rm(workspace, {
+				recursive: true,
+				force: true,
+				maxRetries: 3,
+				retryDelay: 250,
+			});
 		}
 	});
 
@@ -137,7 +152,12 @@ describe("createHookConfigFileHooks", () => {
 				context: "needs-review",
 			});
 		} finally {
-			await rm(workspace, { recursive: true, force: true });
+			await rm(workspace, {
+				recursive: true,
+				force: true,
+				maxRetries: 3,
+				retryDelay: 250,
+			});
 		}
 	});
 
@@ -168,7 +188,12 @@ describe("createHookConfigFileHooks", () => {
 				context: "python-ok",
 			});
 		} finally {
-			await rm(workspace, { recursive: true, force: true });
+			await rm(workspace, {
+				recursive: true,
+				force: true,
+				maxRetries: 3,
+				retryDelay: 250,
+			});
 		}
 	});
 
@@ -201,7 +226,12 @@ describe("createHookConfigFileHooks", () => {
 					context: "powershell-ok",
 				});
 			} finally {
-				await rm(workspace, { recursive: true, force: true });
+				await rm(workspace, {
+					recursive: true,
+					force: true,
+					maxRetries: 3,
+					retryDelay: 250,
+				});
 			}
 		},
 	);
@@ -231,7 +261,12 @@ describe("createHookConfigFileHooks", () => {
 			expect(payload.hookName).toBe("agent_error");
 			expect(payload.error?.message).toBe("401 unauthorized");
 		} finally {
-			await rm(workspace, { recursive: true, force: true });
+			await rm(workspace, {
+				recursive: true,
+				force: true,
+				maxRetries: 3,
+				retryDelay: 250,
+			});
 		}
 	});
 

package/src/runtime/runtime-builder.test.ts

@@ -186,6 +186,22 @@ describe("DefaultRuntimeBuilder", () => {
 		expect(runtime.tools).toEqual([]);
 	});
 
+	it("omits tools disabled by policy from the advertised runtime tool list", async () => {
+		const runtime = await new DefaultRuntimeBuilder().build({
+			config: makeBaseConfig({
+				toolPolicies: {
+					run_commands: { enabled: false },
+					read_files: { enabled: false },
+				},
+			}),
+		});
+
+		const names = runtime.tools.map((tool) => tool.name);
+		expect(names).not.toContain("run_commands");
+		expect(names).not.toContain("read_files");
+		expect(names).toContain("search_codebase");
+	});
+
 	it("adds spawn tool when enabled", async () => {
 		const runtime = await new DefaultRuntimeBuilder().build({
 			config: makeBaseConfig({
@@ -284,6 +300,88 @@ process.stdin.on("data", (chunk) => {
 		}
 	});
 
+	it("skips MCP settings tools when disableMcpSettingsTools is true", async () => {
+		const tempRoot = mkdtempSync(
+			join(tmpdir(), "runtime-builder-mcp-disabled-"),
+		);
+		const serverPath = join(tempRoot, "mock-mcp-server.js");
+		const settingsPath = join(tempRoot, "cline_mcp_settings.json");
+		const previousSettingsPath = process.env.CLINE_MCP_SETTINGS_PATH;
+
+		writeFileSync(
+			serverPath,
+			`let buffer = "";
+function write(payload) {
+  const body = JSON.stringify(payload);
+  process.stdout.write("Content-Length: " + Buffer.byteLength(body, "utf8") + "\\r\\n\\r\\n" + body);
+}
+function handle(message) {
+  if (message.method === "initialize") {
+    write({ jsonrpc: "2.0", id: message.id, result: { protocolVersion: "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "mock", version: "1.0.0" } } });
+    return;
+  }
+  if (message.method === "tools/list") {
+    write({ jsonrpc: "2.0", id: message.id, result: { tools: [{ name: "echo", description: "Echo tool", inputSchema: { type: "object", properties: { value: { type: "string" } }, required: [] } }] } });
+    return;
+  }
+  if (message.method === "tools/call") {
+    write({ jsonrpc: "2.0", id: message.id, result: { echoed: message.params?.arguments?.value ?? null } });
+  }
+}
+process.stdin.on("data", (chunk) => {
+  buffer += chunk.toString("utf8");
+  while (true) {
+    const separator = buffer.indexOf("\\r\\n\\r\\n");
+    if (separator < 0) break;
+    const header = buffer.slice(0, separator);
+    const match = header.match(/Content-Length:\\s*(\\d+)/i);
+    if (!match) throw new Error("missing content length");
+    const length = Number(match[1]);
+    const start = separator + 4;
+    const end = start + length;
+    if (buffer.length < end) break;
+    const body = buffer.slice(start, end);
+    buffer = buffer.slice(end);
+    const message = JSON.parse(body);
+    if (message.method === "notifications/initialized") continue;
+    handle(message);
+  }
+});`,
+			"utf8",
+		);
+		writeFileSync(
+			settingsPath,
+			JSON.stringify(
+				{
+					mcpServers: {
+						mock: {
+							command: process.execPath,
+							args: [serverPath],
+						},
+					},
+				},
+				null,
+				2,
+			),
+			"utf8",
+		);
+
+		process.env.CLINE_MCP_SETTINGS_PATH = settingsPath;
+		try {
+			const runtime = await new DefaultRuntimeBuilder().build({
+				config: makeBaseConfig({
+					disableMcpSettingsTools: true,
+				}),
+			});
+			expect(runtime.tools.map((tool) => tool.name)).not.toContain(
+				"mock__echo",
+			);
+			await runtime.shutdown("test");
+		} finally {
+			process.env.CLINE_MCP_SETTINGS_PATH = previousSettingsPath;
+		}
+	});
+
 	it("skips broken MCP servers without crashing", async () => {
 		const tempRoot = mkdtempSync(join(tmpdir(), "runtime-builder-mcp-bad-"));
 		const serverPath = join(tempRoot, "malformed-mcp-server.js");