@clinebot/core 0.0.20 → 0.0.22

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

@@ -1,228 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { describe, expect, it } from "vitest";
-import {
-	loadAgentPluginFromPath,
-	loadAgentPluginsFromPaths,
-} from "./plugin-loader";
-
-describe("plugin-loader", () => {
-	it("loads default-exported plugin from path", async () => {
-		const dir = await mkdtemp(join(tmpdir(), "core-plugin-loader-"));
-		try {
-			const pluginPath = join(dir, "plugin-default.mjs");
-			await writeFile(
-				pluginPath,
-				[
-					"export default {",
-					"  name: 'from-default',",
-					"  manifest: { capabilities: ['hooks'], hookStages: ['input'] },",
-					"  onInput: ({ input }) => ({ overrideInput: input })",
-					"};",
-				].join("\n"),
-				"utf8",
-			);
-
-			const plugin = await loadAgentPluginFromPath(pluginPath);
-			expect(plugin.name).toBe("from-default");
-			expect(plugin.manifest.capabilities).toContain("hooks");
-		} finally {
-			await rm(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("loads named plugin export from path", async () => {
-		const dir = await mkdtemp(join(tmpdir(), "core-plugin-loader-"));
-		try {
-			const pluginPath = join(dir, "plugin-named.mjs");
-			await writeFile(
-				pluginPath,
-				[
-					"export const plugin = {",
-					"  name: 'from-named',",
-					"  manifest: { capabilities: ['tools'] },",
-					"};",
-				].join("\n"),
-				"utf8",
-			);
-
-			const plugin = await loadAgentPluginFromPath(pluginPath, {
-				exportName: "plugin",
-			});
-			expect(plugin.name).toBe("from-named");
-		} finally {
-			await rm(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("loads multiple plugins from file paths", async () => {
-		const dir = await mkdtemp(join(tmpdir(), "core-plugin-loader-"));
-		try {
-			const firstPath = join(dir, "plugin-a.mjs");
-			const secondPath = join(dir, "plugin-b.mjs");
-			await writeFile(
-				firstPath,
-				"export default { name: 'plugin-a', manifest: { capabilities: ['tools'] } };",
-				"utf8",
-			);
-			await writeFile(
-				secondPath,
-				"export default { name: 'plugin-b', manifest: { capabilities: ['commands'] } };",
-				"utf8",
-			);
-
-			const plugins = await loadAgentPluginsFromPaths([firstPath, secondPath]);
-			expect(plugins.map((plugin) => plugin.name)).toEqual([
-				"plugin-a",
-				"plugin-b",
-			]);
-		} finally {
-			await rm(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("loads TypeScript plugins from file paths", async () => {
-		const dir = await mkdtemp(join(tmpdir(), "core-plugin-loader-"));
-		try {
-			const pluginPath = join(dir, "plugin-ts.ts");
-			await writeFile(
-				pluginPath,
-				[
-					"const name: string = 'plugin-ts';",
-					"export default {",
-					"  name,",
-					"  manifest: { capabilities: ['tools'] },",
-					"};",
-				].join("\n"),
-				"utf8",
-			);
-
-			const plugin = await loadAgentPluginFromPath(pluginPath);
-			expect(plugin.name).toBe("plugin-ts");
-		} finally {
-			await rm(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("resolves plugin-local dependencies from the plugin path", async () => {
-		const dir = await mkdtemp(join(tmpdir(), "core-plugin-loader-"));
-		try {
-			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",
-			);
-			const pluginPath = join(dir, "plugin-with-dep.ts");
-			await writeFile(
-				pluginPath,
-				[
-					"import { depName } from 'plugin-local-dep';",
-					"export default {",
-					"  name: depName,",
-					"  manifest: { capabilities: ['tools'] },",
-					"};",
-				].join("\n"),
-				"utf8",
-			);
-
-			const plugin = await loadAgentPluginFromPath(pluginPath, { cwd: dir });
-			expect(plugin.name).toBe("plugin-local-dep");
-		} finally {
-			await rm(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("prefers plugin-installed SDK packages over workspace aliases", async () => {
-		const dir = await mkdtemp(join(tmpdir(), "core-plugin-loader-"));
-		try {
-			const depDir = join(dir, "node_modules", "@clinebot", "shared");
-			await mkdir(depDir, { recursive: true });
-			await writeFile(
-				join(depDir, "package.json"),
-				JSON.stringify({
-					name: "@clinebot/shared",
-					type: "module",
-					exports: "./index.js",
-				}),
-				"utf8",
-			);
-			await writeFile(
-				join(depDir, "index.js"),
-				"export const sdkMarker = 'plugin-installed-sdk';\n",
-				"utf8",
-			);
-			const pluginPath = join(dir, "plugin-with-sdk-dep.ts");
-			await writeFile(
-				pluginPath,
-				[
-					"import { sdkMarker } from '@clinebot/shared';",
-					"export default {",
-					"  name: sdkMarker,",
-					"  manifest: { capabilities: ['tools'] },",
-					"};",
-				].join("\n"),
-				"utf8",
-			);
-
-			const plugin = await loadAgentPluginFromPath(pluginPath, { cwd: dir });
-			expect(plugin.name).toBe("plugin-installed-sdk");
-		} finally {
-			await rm(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("requires copied plugins to provide their own non-SDK dependencies", async () => {
-		const dir = await mkdtemp(join(tmpdir(), "core-plugin-loader-copy-"));
-		try {
-			const pluginPath = join(dir, "portable-subagents.ts");
-			await writeFile(
-				pluginPath,
-				[
-					"import { resolveClineDataDir } from '@clinebot/shared/storage';",
-					"import YAML from 'yaml';",
-					"export default {",
-					"  name: typeof resolveClineDataDir === 'function' ? YAML.stringify({ ok: true }) : 'invalid',",
-					"  manifest: { capabilities: ['tools'] },",
-					"};",
-				].join("\n"),
-				"utf8",
-			);
-
-			await expect(
-				loadAgentPluginFromPath(pluginPath, { cwd: dir, useCache: true }),
-			).rejects.toThrow(/Cannot find (package|module) 'yaml'/i);
-		} finally {
-			await rm(dir, { recursive: true, force: true });
-		}
-	});
-
-	it("rejects invalid plugin export missing manifest", async () => {
-		const dir = await mkdtemp(join(tmpdir(), "core-plugin-loader-"));
-		try {
-			const pluginPath = join(dir, "invalid-plugin.mjs");
-			await writeFile(
-				pluginPath,
-				"export default { name: 'invalid-plugin' };",
-				"utf8",
-			);
-
-			await expect(loadAgentPluginFromPath(pluginPath)).rejects.toThrow(
-				/missing required "manifest"/i,
-			);
-		} finally {
-			await rm(dir, { recursive: true, force: true });
-		}
-	});
-});

package/src/agents/plugin-loader.ts

@@ -1,172 +0,0 @@
-import { existsSync } from "node:fs";
-import { builtinModules, createRequire } from "node:module";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import type { AgentConfig } from "@clinebot/agents";
-import createJiti from "jiti";
-
-type AgentPlugin = NonNullable<AgentConfig["extensions"]>[number];
-type PluginLike = {
-	name: string;
-	manifest: {
-		capabilities: string[];
-		hookStages?: string[];
-	};
-};
-
-export interface LoadAgentPluginFromPathOptions {
-	exportName?: string;
-	cwd?: string;
-	useCache?: boolean;
-}
-
-const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
-const WORKSPACE_ALIASES = collectWorkspaceAliases(MODULE_DIR);
-const BUILTIN_MODULES = new Set(
-	builtinModules.flatMap((id) => [id, id.replace(/^node:/, "")]),
-);
-
-function isObject(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null;
-}
-
-function hasValidStringArray(value: unknown): value is string[] {
-	return (
-		Array.isArray(value) && value.every((entry) => typeof entry === "string")
-	);
-}
-
-function validatePluginManifest(
-	plugin: PluginLike,
-	absolutePath: string,
-): void {
-	if (!isObject(plugin.manifest)) {
-		throw new Error(
-			`Invalid plugin module at ${absolutePath}: missing required "manifest"`,
-		);
-	}
-	if (!hasValidStringArray(plugin.manifest.capabilities)) {
-		throw new Error(
-			`Invalid plugin module at ${absolutePath}: manifest.capabilities must be a string array`,
-		);
-	}
-	if (plugin.manifest.capabilities.length === 0) {
-		throw new Error(
-			`Invalid plugin module at ${absolutePath}: manifest.capabilities cannot be empty`,
-		);
-	}
-	if (
-		Object.hasOwn(plugin.manifest, "hookStages") &&
-		!hasValidStringArray(plugin.manifest.hookStages)
-	) {
-		throw new Error(
-			`Invalid plugin module at ${absolutePath}: manifest.hookStages must be a string array when provided`,
-		);
-	}
-}
-
-function validatePluginExport(
-	plugin: unknown,
-	absolutePath: string,
-): asserts plugin is PluginLike {
-	if (!isObject(plugin)) {
-		throw new Error(
-			`Invalid plugin module at ${absolutePath}: expected object export`,
-		);
-	}
-	if (typeof plugin.name !== "string" || plugin.name.length === 0) {
-		throw new Error(
-			`Invalid plugin module at ${absolutePath}: expected non-empty "name"`,
-		);
-	}
-	if (!Object.hasOwn(plugin, "manifest")) {
-		throw new Error(
-			`Invalid plugin module at ${absolutePath}: missing required "manifest"`,
-		);
-	}
-	validatePluginManifest(plugin as PluginLike, absolutePath);
-}
-
-function collectWorkspaceAliases(startDir: string): Record<string, string> {
-	const root = resolve(startDir, "..", "..", "..", "..");
-	const aliases: Record<string, string> = {};
-	const candidates: Record<string, string> = {
-		"@clinebot/agents": resolve(root, "packages/agents/src/index.ts"),
-		"@clinebot/core": resolve(root, "packages/core/src/index.node.ts"),
-		"@clinebot/llms": resolve(root, "packages/llms/src/index.ts"),
-		"@clinebot/rpc": resolve(root, "packages/rpc/src/index.ts"),
-		"@clinebot/scheduler": resolve(root, "packages/scheduler/src/index.ts"),
-		"@clinebot/shared": resolve(root, "packages/shared/src/index.ts"),
-		"@clinebot/shared/storage": resolve(
-			root,
-			"packages/shared/src/storage/index.ts",
-		),
-		"@clinebot/shared/db": resolve(root, "packages/shared/src/db/index.ts"),
-	};
-	for (const [key, value] of Object.entries(candidates)) {
-		if (existsSync(value)) {
-			aliases[key] = value;
-		}
-	}
-	return aliases;
-}
-
-function collectPluginImportAliases(
-	pluginPath: string,
-): Record<string, string> {
-	const pluginRequire = createRequire(pluginPath);
-	const aliases: Record<string, string> = {};
-	for (const [specifier, sourcePath] of Object.entries(WORKSPACE_ALIASES)) {
-		try {
-			pluginRequire.resolve(specifier);
-			continue;
-		} catch {
-			// Use the workspace source only when the plugin package does not provide
-			// its own installed SDK dependency.
-		}
-		aliases[specifier] = sourcePath;
-	}
-	return aliases;
-}
-
-async function importPluginModule(
-	absolutePath: string,
-	options: LoadAgentPluginFromPathOptions = {},
-): Promise<Record<string, unknown>> {
-	const aliases = collectPluginImportAliases(absolutePath);
-	const jiti = createJiti(absolutePath, {
-		alias: aliases,
-		cache: options.useCache,
-		requireCache: options.useCache,
-		esmResolve: true,
-		interopDefault: false,
-		nativeModules: [...BUILTIN_MODULES],
-		transformModules: Object.keys(aliases),
-	});
-	return (await jiti.import(absolutePath, {})) as Record<string, unknown>;
-}
-
-export async function loadAgentPluginFromPath(
-	pluginPath: string,
-	options: LoadAgentPluginFromPathOptions = {},
-): Promise<AgentPlugin> {
-	const absolutePath = resolve(options.cwd ?? process.cwd(), pluginPath);
-	const moduleExports = await importPluginModule(absolutePath, options);
-	const exportName = options.exportName ?? "plugin";
-	const plugin = (moduleExports.default ??
-		moduleExports[exportName]) as unknown;
-
-	validatePluginExport(plugin, absolutePath);
-	return plugin as AgentPlugin;
-}
-
-export async function loadAgentPluginsFromPaths(
-	pluginPaths: string[],
-	options: LoadAgentPluginFromPathOptions = {},
-): Promise<AgentPlugin[]> {
-	const loaded: AgentPlugin[] = [];
-	for (const pluginPath of pluginPaths) {
-		loaded.push(await loadAgentPluginFromPath(pluginPath, options));
-	}
-	return loaded;
-}