@clinebot/core 0.0.35 → 0.0.36

package/src/extensions/mcp/manager.test.ts

@@ -1,105 +0,0 @@
-import { describe, expect, it, vi } from "vitest";
-import { InMemoryMcpManager } from "./manager";
-import type { McpServerClient, McpToolDescriptor } from "./types";
-
-function createClient(overrides?: Partial<McpServerClient>): McpServerClient {
-	return {
-		connect: vi.fn(async () => {}),
-		disconnect: vi.fn(async () => {}),
-		listTools: vi.fn(async () => []),
-		callTool: vi.fn(async () => ({ ok: true })),
-		...overrides,
-	};
-}
-
-describe("InMemoryMcpManager", () => {
-	it("registers servers, connects on demand, and calls tools", async () => {
-		const toolDescriptors: readonly McpToolDescriptor[] = [
-			{
-				name: "search",
-				inputSchema: {
-					type: "object",
-					properties: { q: { type: "string" } },
-					required: ["q"],
-				},
-			},
-		];
-		const client = createClient({
-			listTools: vi.fn(async () => toolDescriptors),
-		});
-		const manager = new InMemoryMcpManager({
-			clientFactory: vi.fn(async () => client),
-		});
-
-		await manager.registerServer({
-			name: "docs",
-			transport: {
-				type: "streamableHttp",
-				url: "https://mcp.example.test",
-			},
-		});
-
-		const tools = await manager.listTools("docs");
-		expect(tools).toHaveLength(1);
-
-		await manager.callTool({
-			serverName: "docs",
-			toolName: "search",
-			arguments: { q: "oauth flow" },
-		});
-
-		expect(client.connect).toHaveBeenCalledTimes(1);
-		expect(client.callTool).toHaveBeenCalledWith({
-			name: "search",
-			arguments: { q: "oauth flow" },
-			context: undefined,
-		});
-	});
-
-	it("uses tool list cache to avoid repeated listTools round trips", async () => {
-		const toolDescriptors: readonly McpToolDescriptor[] = [
-			{
-				name: "echo",
-				inputSchema: { type: "object", properties: {} },
-			},
-		];
-		const client = createClient({
-			listTools: vi.fn(async () => toolDescriptors),
-		});
-		const manager = new InMemoryMcpManager({
-			clientFactory: async () => client,
-			toolsCacheTtlMs: 60_000,
-		});
-
-		await manager.registerServer({
-			name: "cache-test",
-			transport: {
-				type: "stdio",
-				command: "node",
-				args: ["./mcp.js"],
-			},
-		});
-
-		await manager.listTools("cache-test");
-		await manager.listTools("cache-test");
-		expect(client.listTools).toHaveBeenCalledTimes(1);
-	});
-
-	it("prevents tool calls on disabled servers", async () => {
-		const manager = new InMemoryMcpManager({
-			clientFactory: async () => createClient(),
-		});
-		await manager.registerServer({
-			name: "disabled",
-			transport: { type: "sse", url: "https://example.test/sse" },
-			disabled: true,
-		});
-
-		await expect(
-			manager.callTool({
-				serverName: "disabled",
-				toolName: "anything",
-			}),
-		).rejects.toThrow(/disabled/i);
-	});
-});

package/src/extensions/plugin/plugin-config-loader.test.ts

@@ -1,184 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { setHomeDir } from "@clinebot/shared/storage";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-	discoverPluginModulePaths,
-	resolveAgentPluginPaths,
-	resolveAndLoadAgentPlugins,
-	resolvePluginConfigSearchPaths,
-} from "./plugin-config-loader";
-
-describe("plugin-config-loader", () => {
-	const envSnapshot = {
-		HOME: process.env.HOME,
-	};
-
-	afterEach(() => {
-		process.env.HOME = envSnapshot.HOME;
-		setHomeDir(envSnapshot.HOME ?? "~");
-	});
-
-	it("discovers plugin modules recursively", async () => {
-		const root = await mkdtemp(join(tmpdir(), "core-plugin-config-loader-"));
-		try {
-			const nested = join(root, "nested");
-			await mkdir(nested, { recursive: true });
-			await writeFile(join(root, "a.js"), "export default {}", "utf8");
-			await writeFile(join(nested, "b.ts"), "export default {}", "utf8");
-			await writeFile(
-				join(root, ".a.js.cline-plugin.js"),
-				"export default {}",
-				"utf8",
-			);
-			await writeFile(join(root, "ignore.txt"), "noop", "utf8");
-
-			const discovered = discoverPluginModulePaths(root);
-			expect(discovered).toEqual([join(root, "a.js"), join(nested, "b.ts")]);
-		} finally {
-			await rm(root, { recursive: true, force: true });
-		}
-	});
-
-	it("resolves plugin paths from explicit files/directories", async () => {
-		const root = await mkdtemp(join(tmpdir(), "core-plugin-config-loader-"));
-		try {
-			process.env.HOME = root;
-			setHomeDir(root);
-			const pluginsDir = join(root, "plugins");
-			await mkdir(pluginsDir, { recursive: true });
-			const filePath = join(root, "direct.js");
-			const dirPluginPath = join(pluginsDir, "dir-plugin.js");
-			await writeFile(filePath, "export default {}", "utf8");
-			await writeFile(dirPluginPath, "export default {}", "utf8");
-
-			const resolved = resolveAgentPluginPaths({
-				pluginPaths: ["./direct.js", "./plugins"],
-				workspacePath: join(root, "workspace"),
-				cwd: root,
-			});
-
-			expect(resolved).toEqual([filePath, dirPluginPath]);
-		} finally {
-			await rm(root, { recursive: true, force: true });
-		}
-	});
-
-	it("prefers package manifest plugin entries for configured directories", async () => {
-		const root = await mkdtemp(join(tmpdir(), "core-plugin-config-loader-"));
-		try {
-			const pluginDir = join(root, "plugin-package");
-			const srcDir = join(pluginDir, "src");
-			await mkdir(srcDir, { recursive: true });
-			const declaredEntry = join(srcDir, "index.ts");
-			const ignoredEntry = join(pluginDir, "ignored.js");
-			await writeFile(
-				join(pluginDir, "package.json"),
-				JSON.stringify({
-					name: "plugin-package",
-					private: true,
-					cline: {
-						plugins: [
-							{
-								paths: ["./src/index.ts"],
-								capabilities: ["tools"],
-							},
-						],
-					},
-				}),
-				"utf8",
-			);
-			await writeFile(declaredEntry, "export default {}", "utf8");
-			await writeFile(ignoredEntry, "export default {}", "utf8");
-
-			const resolved = resolveAgentPluginPaths({
-				pluginPaths: ["./plugin-package"],
-				cwd: root,
-				workspacePath: join(root, "workspace"),
-			});
-
-			expect(resolved).toContain(declaredEntry);
-			expect(resolved).not.toContain(ignoredEntry);
-		} finally {
-			await rm(root, { recursive: true, force: true });
-		}
-	});
-
-	it("includes shared search-path plugins", async () => {
-		const home = await mkdtemp(
-			join(tmpdir(), "core-plugin-config-loader-home-"),
-		);
-		const workspace = await mkdtemp(
-			join(tmpdir(), "core-plugin-config-loader-workspace-"),
-		);
-		try {
-			process.env.HOME = home;
-			setHomeDir(home);
-			const workspacePlugins = join(workspace, ".cline", "plugins");
-			const userPlugins = join(home, ".cline", "plugins");
-			const documentsPlugins = join(home, "Documents", "Cline", "Plugins");
-			await mkdir(workspacePlugins, { recursive: true });
-			await mkdir(userPlugins, { recursive: true });
-			await mkdir(documentsPlugins, { recursive: true });
-			const workspacePlugin = join(workspacePlugins, "workspace.js");
-			const userPlugin = join(userPlugins, "user.js");
-			const documentsPlugin = join(documentsPlugins, "documents.js");
-			await writeFile(workspacePlugin, "export default {}", "utf8");
-			await writeFile(userPlugin, "export default {}", "utf8");
-			await writeFile(documentsPlugin, "export default {}", "utf8");
-
-			const searchPaths = resolvePluginConfigSearchPaths(workspace);
-			expect(searchPaths).toHaveLength(3);
-			expect(searchPaths).toContain(workspacePlugins);
-			expect(searchPaths).toContain(userPlugins);
-			expect(searchPaths).toContain(documentsPlugins);
-
-			const resolved = resolveAgentPluginPaths({ workspacePath: workspace });
-			expect(resolved).toContain(workspacePlugin);
-			expect(resolved).toContain(userPlugin);
-			expect(resolved).toContain(documentsPlugin);
-		} finally {
-			await rm(home, { recursive: true, force: true });
-			await rm(workspace, { recursive: true, force: true });
-		}
-	});
-
-	it("loads valid plugins while reporting failures and duplicate overrides", async () => {
-		const root = await mkdtemp(join(tmpdir(), "core-plugin-config-loader-"));
-		try {
-			const first = join(root, "duplicate-one.js");
-			const second = join(root, "duplicate-two.js");
-			const invalid = join(root, "invalid.js");
-			await writeFile(
-				first,
-				"export default { name: 'duplicate-plugin', manifest: { capabilities: ['tools'] } };",
-				"utf8",
-			);
-			await writeFile(
-				second,
-				"export default { name: 'duplicate-plugin', manifest: { capabilities: ['commands'] } };",
-				"utf8",
-			);
-			await writeFile(invalid, "export default { name: 'broken' };", "utf8");
-
-			const loaded = await resolveAndLoadAgentPlugins({
-				mode: "in_process",
-				pluginPaths: [first, invalid, second],
-				cwd: root,
-			});
-
-			// Filter to only our test plugins to ignore any discovered system plugins
-			const testPlugins = loaded.extensions.filter(
-				(plugin) => plugin.name === "duplicate-plugin",
-			);
-			expect(testPlugins).toHaveLength(1);
-			expect(testPlugins[0]?.manifest.capabilities).toEqual(["commands"]);
-			expect(loaded.failures).toHaveLength(1);
-			expect(loaded.warnings).toHaveLength(1);
-			expect(loaded.warnings[0]?.overriddenPluginPath).toBe(first);
-		} finally {
-			await rm(root, { recursive: true, force: true });
-		}
-	});
-});

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

@@ -1,292 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterAll, beforeAll, describe, expect, it } from "vitest";
-import {
-	loadAgentPluginFromPath,
-	loadAgentPluginsFromPaths,
-	loadAgentPluginsFromPathsWithDiagnostics,
-} from "./plugin-loader";
-
-describe("plugin-loader", () => {
-	let dir = "";
-	let copyDir = "";
-
-	beforeAll(async () => {
-		dir = await mkdtemp(join(tmpdir(), "core-plugin-loader-"));
-		copyDir = await mkdtemp(join(tmpdir(), "core-plugin-loader-copy-"));
-
-		await writeFile(
-			join(dir, "plugin-default.mjs"),
-			[
-				"export default {",
-				"  name: 'from-default',",
-				"  manifest: { capabilities: ['hooks'], hookStages: ['input'] },",
-				"  onInput: ({ input }) => ({ overrideInput: input })",
-				"};",
-			].join("\n"),
-			"utf8",
-		);
-		await writeFile(
-			join(dir, "plugin-named.mjs"),
-			[
-				"export const plugin = {",
-				"  name: 'from-named',",
-				"  manifest: { capabilities: ['tools'] },",
-				"};",
-			].join("\n"),
-			"utf8",
-		);
-		await writeFile(
-			join(dir, "plugin-a.mjs"),
-			"export default { name: 'plugin-a', manifest: { capabilities: ['tools'] } };",
-			"utf8",
-		);
-		await writeFile(
-			join(dir, "plugin-b.mjs"),
-			"export default { name: 'plugin-b', manifest: { capabilities: ['commands'] } };",
-			"utf8",
-		);
-		await writeFile(
-			join(dir, "plugin-ts.ts"),
-			[
-				"const name: string = 'plugin-ts';",
-				"export default {",
-				"  name,",
-				"  manifest: { capabilities: ['tools'] },",
-				"};",
-			].join("\n"),
-			"utf8",
-		);
-
-		const depDir = join(dir, "node_modules", "plugin-local-dep");
-		await mkdir(depDir, { recursive: true });
-		await writeFile(
-			join(depDir, "package.json"),
-			JSON.stringify({
-				name: "plugin-local-dep",
-				type: "module",
-				exports: "./index.js",
-			}),
-			"utf8",
-		);
-		await writeFile(
-			join(depDir, "index.js"),
-			"export const depName = 'plugin-local-dep';\n",
-			"utf8",
-		);
-		await writeFile(
-			join(dir, "plugin-with-dep.ts"),
-			[
-				"import { depName } from 'plugin-local-dep';",
-				"export default {",
-				"  name: depName,",
-				"  manifest: { capabilities: ['tools'] },",
-				"};",
-			].join("\n"),
-			"utf8",
-		);
-
-		const sdkDir = join(dir, "node_modules", "@clinebot", "shared");
-		await mkdir(sdkDir, { recursive: true });
-		await writeFile(
-			join(sdkDir, "package.json"),
-			JSON.stringify({
-				name: "@clinebot/shared",
-				type: "module",
-				exports: "./index.js",
-			}),
-			"utf8",
-		);
-		await writeFile(
-			join(sdkDir, "index.js"),
-			"export const sdkMarker = 'plugin-installed-sdk';\n",
-			"utf8",
-		);
-		await writeFile(
-			join(dir, "plugin-with-sdk-dep.ts"),
-			[
-				"import { sdkMarker } from '@clinebot/shared';",
-				"export default {",
-				"  name: sdkMarker,",
-				"  manifest: { capabilities: ['tools'] },",
-				"};",
-			].join("\n"),
-			"utf8",
-		);
-
-		await writeFile(
-			join(copyDir, "portable-subagents.ts"),
-			[
-				"import { safeJsonStringify } from '@clinebot/shared';",
-				"import { resolveClineDataDir } from '@clinebot/shared/storage';",
-				"import YAML from 'yaml';",
-				"export default {",
-				"  name: typeof safeJsonStringify === 'function' ? YAML.stringify({ ok: !!resolveClineDataDir() }) : 'invalid',",
-				"  manifest: { capabilities: ['tools'] },",
-				"};",
-			].join("\n"),
-			"utf8",
-		);
-
-		const packagedCopyDir = join(copyDir, "packaged-plugin");
-		await mkdir(packagedCopyDir, { recursive: true });
-		await writeFile(
-			join(packagedCopyDir, "package.json"),
-			JSON.stringify({
-				name: "packaged-plugin",
-				type: "module",
-				cline: {
-					plugins: ["index.ts"],
-				},
-			}),
-			"utf8",
-		);
-		await writeFile(
-			join(packagedCopyDir, "index.ts"),
-			[
-				"import YAML from 'yaml';",
-				"export default {",
-				"  name: YAML.stringify({ ok: true }),",
-				"  manifest: { capabilities: ['tools'] },",
-				"};",
-			].join("\n"),
-			"utf8",
-		);
-
-		await writeFile(
-			join(dir, "invalid-plugin.mjs"),
-			"export default { name: 'invalid-plugin' };",
-			"utf8",
-		);
-
-		await writeFile(
-			join(dir, "duplicate-one.mjs"),
-			"export default { name: 'duplicate-plugin', manifest: { capabilities: ['tools'] } };",
-			"utf8",
-		);
-		await writeFile(
-			join(dir, "duplicate-two.mjs"),
-			"export default { name: 'duplicate-plugin', manifest: { capabilities: ['commands'] } };",
-			"utf8",
-		);
-	});
-
-	afterAll(async () => {
-		if (dir) {
-			await rm(dir, { recursive: true, force: true });
-		}
-		if (copyDir) {
-			await rm(copyDir, { recursive: true, force: true });
-		}
-	});
-
-	it("loads default-exported plugin from path", async () => {
-		const plugin = await loadAgentPluginFromPath(
-			join(dir, "plugin-default.mjs"),
-		);
-		expect(plugin.name).toBe("from-default");
-		expect(plugin.manifest.capabilities).toContain("hooks");
-	});
-
-	it("loads named plugin export from path", async () => {
-		const plugin = await loadAgentPluginFromPath(
-			join(dir, "plugin-named.mjs"),
-			{
-				exportName: "plugin",
-			},
-		);
-		expect(plugin.name).toBe("from-named");
-	});
-
-	it("loads multiple plugins from file paths", async () => {
-		const plugins = await loadAgentPluginsFromPaths([
-			join(dir, "plugin-a.mjs"),
-			join(dir, "plugin-b.mjs"),
-		]);
-		expect(plugins.map((plugin) => plugin.name)).toEqual([
-			"plugin-a",
-			"plugin-b",
-		]);
-	});
-
-	it("loads TypeScript plugins from file paths", async () => {
-		const plugin = await loadAgentPluginFromPath(join(dir, "plugin-ts.ts"));
-		expect(plugin.name).toBe("plugin-ts");
-	});
-
-	it("resolves plugin-local dependencies from the plugin path", async () => {
-		const plugin = await loadAgentPluginFromPath(
-			join(dir, "plugin-with-dep.ts"),
-			{ cwd: dir },
-		);
-		expect(plugin.name).toBe("plugin-local-dep");
-	});
-
-	it("prefers plugin-installed SDK packages over workspace aliases", async () => {
-		const plugin = await loadAgentPluginFromPath(
-			join(dir, "plugin-with-sdk-dep.ts"),
-			{ cwd: dir },
-		);
-		expect(plugin.name).toBe("plugin-installed-sdk");
-	});
-
-	it("allows standalone file plugins to use host runtime dependencies", async () => {
-		const plugin = await loadAgentPluginFromPath(
-			join(copyDir, "portable-subagents.ts"),
-			{
-				cwd: copyDir,
-				useCache: true,
-			},
-		);
-		expect(plugin.name).toMatch(/ok: true/i);
-	});
-
-	it("requires package-based plugins to provide their own non-SDK dependencies", async () => {
-		await expect(
-			loadAgentPluginFromPath(join(copyDir, "packaged-plugin", "index.ts"), {
-				cwd: join(copyDir, "packaged-plugin"),
-				useCache: true,
-			}),
-		).rejects.toThrow(/Cannot find (package|module) 'yaml'/i);
-	});
-
-	it("rejects invalid plugin export missing manifest", async () => {
-		await expect(
-			loadAgentPluginFromPath(join(dir, "invalid-plugin.mjs")),
-		).rejects.toThrow(/missing required "manifest"/i);
-	});
-
-	it("continues loading valid plugins when one plugin fails", async () => {
-		const report = await loadAgentPluginsFromPathsWithDiagnostics([
-			join(dir, "plugin-a.mjs"),
-			join(dir, "invalid-plugin.mjs"),
-			join(dir, "plugin-b.mjs"),
-		]);
-
-		expect(report.plugins.map((plugin) => plugin.name)).toEqual([
-			"plugin-a",
-			"plugin-b",
-		]);
-		expect(report.failures).toHaveLength(1);
-		expect(report.failures[0]?.pluginPath).toBe(
-			join(dir, "invalid-plugin.mjs"),
-		);
-		expect(report.warnings).toEqual([]);
-	});
-
-	it("keeps the later duplicate plugin and reports the override", async () => {
-		const report = await loadAgentPluginsFromPathsWithDiagnostics([
-			join(dir, "duplicate-one.mjs"),
-			join(dir, "duplicate-two.mjs"),
-		]);
-
-		expect(report.plugins).toHaveLength(1);
-		expect(report.plugins[0]?.name).toBe("duplicate-plugin");
-		expect(report.plugins[0]?.manifest.capabilities).toEqual(["commands"]);
-		expect(report.warnings).toHaveLength(1);
-		expect(report.warnings[0]?.overriddenPluginPath).toBe(
-			join(dir, "duplicate-one.mjs"),
-		);
-	});
-});