@clinebot/core 0.0.11 → 0.0.13

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

@@ -1,19 +1,13 @@
-import { existsSync, readdirSync, statSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { existsSync } from "node:fs";
 import type { AgentConfig } from "@clinebot/agents";
-import { resolvePluginConfigSearchPaths as resolvePluginConfigSearchPathsFromShared } from "@clinebot/shared/storage";
+import {
+	discoverPluginModulePaths as discoverPluginModulePathsFromShared,
+	resolveConfiguredPluginModulePaths,
+	resolvePluginConfigSearchPaths as resolvePluginConfigSearchPathsFromShared,
+} from "@clinebot/shared/storage";
 import { loadAgentPluginsFromPaths } from "./plugin-loader";
 import { loadSandboxedPlugins } from "./plugin-sandbox";
 
-const PLUGIN_MODULE_EXTENSIONS = new Set([
-	".js",
-	".mjs",
-	".cjs",
-	".ts",
-	".mts",
-	".cts",
-]);
-
 type AgentPlugin = NonNullable<AgentConfig["extensions"]>[number];
 
 export function resolvePluginConfigSearchPaths(
@@ -22,67 +16,8 @@ export function resolvePluginConfigSearchPaths(
 	return resolvePluginConfigSearchPathsFromShared(workspacePath);
 }
 
-function hasPluginModuleExtension(path: string): boolean {
-	const dot = path.lastIndexOf(".");
-	if (dot === -1) {
-		return false;
-	}
-	return PLUGIN_MODULE_EXTENSIONS.has(path.slice(dot));
-}
-
 export function discoverPluginModulePaths(directoryPath: string): string[] {
-	const root = resolve(directoryPath);
-	if (!existsSync(root)) {
-		return [];
-	}
-	const discovered: string[] = [];
-	const stack = [root];
-	while (stack.length > 0) {
-		const current = stack.pop();
-		if (!current) {
-			continue;
-		}
-		for (const entry of readdirSync(current, { withFileTypes: true })) {
-			const candidate = join(current, entry.name);
-			if (entry.isDirectory()) {
-				stack.push(candidate);
-				continue;
-			}
-			if (entry.isFile() && hasPluginModuleExtension(candidate)) {
-				discovered.push(candidate);
-			}
-		}
-	}
-	return discovered.sort((a, b) => a.localeCompare(b));
-}
-
-function resolveConfiguredPluginPaths(
-	pluginPaths: ReadonlyArray<string>,
-	cwd: string,
-): string[] {
-	const resolvedPaths: string[] = [];
-	for (const pluginPath of pluginPaths) {
-		const trimmed = pluginPath.trim();
-		if (!trimmed) {
-			continue;
-		}
-		const absolutePath = resolve(cwd, trimmed);
-		if (!existsSync(absolutePath)) {
-			throw new Error(`Plugin path does not exist: ${absolutePath}`);
-		}
-		const stats = statSync(absolutePath);
-		if (stats.isDirectory()) {
-			resolvedPaths.push(...discoverPluginModulePaths(absolutePath));
-			continue;
-		}
-		if (!hasPluginModuleExtension(absolutePath)) {
-			throw new Error(
-				`Plugin file must use a supported extension (${[...PLUGIN_MODULE_EXTENSIONS].join(", ")}): ${absolutePath}`,
-			);
-		}
-		resolvedPaths.push(absolutePath);
-	}
-	return resolvedPaths;
+	return discoverPluginModulePathsFromShared(directoryPath);
 }
 
 export interface ResolveAgentPluginPathsOptions {
@@ -100,7 +35,7 @@ export function resolveAgentPluginPaths(
 	)
 		.flatMap((directoryPath) => discoverPluginModulePaths(directoryPath))
 		.filter((path) => existsSync(path));
-	const configuredPaths = resolveConfiguredPluginPaths(
+	const configuredPaths = resolveConfiguredPluginModulePaths(
 		options.pluginPaths ?? [],
 		cwd,
 	);
@@ -124,6 +59,7 @@ export interface ResolveAndLoadAgentPluginsOptions
 	importTimeoutMs?: number;
 	hookTimeoutMs?: number;
 	contributionTimeoutMs?: number;
+	onEvent?: (event: { name: string; payload?: unknown }) => void;
 }
 
 export async function resolveAndLoadAgentPlugins(
@@ -152,6 +88,7 @@ export async function resolveAndLoadAgentPlugins(
 		importTimeoutMs: options.importTimeoutMs,
 		hookTimeoutMs: options.hookTimeoutMs,
 		contributionTimeoutMs: options.contributionTimeoutMs,
+		onEvent: options.onEvent,
 	});
 	return {
 		extensions: sandboxed.extensions ?? [],

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

@@ -1,4 +1,4 @@
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
+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";
@@ -82,6 +82,132 @@ describe("plugin-loader", () => {
 		}
 	});
 
+	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 {

package/src/agents/plugin-loader.ts

@@ -1,6 +1,9 @@
-import { resolve } from "node:path";
-import { pathToFileURL } from "node:url";
+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 = {
@@ -14,8 +17,15 @@ type PluginLike = {
 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;
 }
@@ -77,14 +87,71 @@ function validatePluginExport(
 	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 import(
-		pathToFileURL(absolutePath).href
-	)) as Record<string, unknown>;
+	const moduleExports = await importPluginModule(absolutePath, options);
 	const exportName = options.exportName ?? "plugin";
 	const plugin = (moduleExports.default ??
 		moduleExports[exportName]) as unknown;