@clinebot/core 0.0.37 → 0.0.38

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

@@ -1,220 +0,0 @@
-import { resolve } from "node:path";
-import type { AgentExtension, PluginSetupContext } from "@clinebot/shared";
-import { normalizePluginManifest } from "@clinebot/shared";
-import type {
-	PluginInitializationFailure,
-	PluginInitializationWarning,
-} from "./plugin-load-report";
-import { importPluginModule } from "./plugin-module-import";
-import {
-	matchesPluginManifestTargeting,
-	type PluginTargeting,
-} from "./plugin-targeting";
-
-type PluginLike = {
-	name: string;
-	manifest: {
-		capabilities: string[];
-		hookStages?: string[];
-		providerIds?: string[];
-		modelIds?: string[];
-	};
-};
-
-export interface LoadAgentPluginFromPathOptions {
-	exportName?: string;
-	cwd?: string;
-	useCache?: boolean;
-	session?: PluginSetupContext["session"];
-	client?: PluginSetupContext["client"];
-	user?: PluginSetupContext["user"];
-	workspaceInfo?: PluginSetupContext["workspaceInfo"];
-	automation?: PluginSetupContext["automation"];
-	logger?: PluginSetupContext["logger"];
-	telemetry?: PluginSetupContext["telemetry"];
-}
-
-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`,
-		);
-	}
-	if (
-		Object.hasOwn(plugin.manifest, "providerIds") &&
-		!hasValidStringArray(plugin.manifest.providerIds)
-	) {
-		throw new Error(
-			`Invalid plugin module at ${absolutePath}: manifest.providerIds must be a string array when provided`,
-		);
-	}
-	if (
-		Object.hasOwn(plugin.manifest, "modelIds") &&
-		!hasValidStringArray(plugin.manifest.modelIds)
-	) {
-		throw new Error(
-			`Invalid plugin module at ${absolutePath}: manifest.modelIds 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);
-}
-
-export async function loadAgentPluginFromPath(
-	pluginPath: string,
-	options: LoadAgentPluginFromPathOptions = {},
-): Promise<AgentExtension> {
-	const absolutePath = resolve(options.cwd ?? process.cwd(), pluginPath);
-	const moduleExports = await importPluginModule(absolutePath, {
-		useCache: options.useCache,
-	});
-	const exportName = options.exportName ?? "plugin";
-	const plugin = (moduleExports.default ??
-		moduleExports[exportName]) as unknown;
-
-	validatePluginExport(plugin, absolutePath);
-	const pluginTyped = plugin as AgentExtension;
-	const originalSetup = pluginTyped.setup;
-
-	// Wrap setup to inject workspace context
-	const setupWithContext: AgentExtension["setup"] = originalSetup
-		? (api, _ctx) => {
-				const session = {
-					...options.session,
-					..._ctx.session,
-				};
-				const ctx = {
-					..._ctx,
-					session: Object.keys(session).length > 0 ? session : undefined,
-					client: options.client ?? _ctx.client,
-					user: options.user ?? _ctx.user,
-					workspaceInfo: options.workspaceInfo ?? _ctx.workspaceInfo,
-					automation: options.automation ?? _ctx.automation,
-					logger: options.logger ?? _ctx.logger,
-					telemetry: options.telemetry ?? _ctx.telemetry,
-				};
-				return originalSetup(api, ctx);
-			}
-		: undefined;
-
-	return {
-		...pluginTyped,
-		manifest: normalizePluginManifest(pluginTyped.manifest),
-		setup: setupWithContext,
-	};
-}
-
-export async function loadAgentPluginsFromPaths(
-	pluginPaths: string[],
-	options: LoadAgentPluginFromPathOptions & PluginTargeting = {},
-): Promise<AgentExtension[]> {
-	const report = await loadAgentPluginsFromPathsWithDiagnostics(
-		pluginPaths,
-		options,
-	);
-	return report.plugins;
-}
-
-export async function loadAgentPluginsFromPathsWithDiagnostics(
-	pluginPaths: string[],
-	options: LoadAgentPluginFromPathOptions & PluginTargeting = {},
-): Promise<{
-	plugins: AgentExtension[];
-	failures: PluginInitializationFailure[];
-	warnings: PluginInitializationWarning[];
-}> {
-	const failures: PluginInitializationFailure[] = [];
-	const warnings: PluginInitializationWarning[] = [];
-	const loadedByName = new Map<
-		string,
-		{ plugin: AgentExtension; pluginPath: string; order: number }
-	>();
-	let order = 0;
-
-	for (const pluginPath of pluginPaths) {
-		try {
-			const plugin = await loadAgentPluginFromPath(pluginPath, options);
-			if (!matchesPluginManifestTargeting(plugin.manifest, options)) {
-				continue;
-			}
-			const existing = loadedByName.get(plugin.name);
-			if (existing) {
-				warnings.push({
-					type: "duplicate_plugin_override",
-					pluginName: plugin.name,
-					pluginPath,
-					overriddenPluginPath: existing.pluginPath,
-					message: `Plugin "${plugin.name}" from ${pluginPath} overrides ${existing.pluginPath}`,
-				});
-			}
-			loadedByName.set(plugin.name, { plugin, pluginPath, order: order++ });
-		} catch (error) {
-			const message = error instanceof Error ? error.message : String(error);
-			failures.push({
-				pluginPath,
-				phase: "load",
-				message,
-				stack: error instanceof Error ? error.stack : undefined,
-			});
-		}
-	}
-
-	return {
-		plugins: [...loadedByName.values()]
-			.sort((left, right) => left.order - right.order)
-			.map((entry) => entry.plugin),
-		failures,
-		warnings,
-	};
-}

package/src/extensions/plugin/plugin-module-import.ts

@@ -1,276 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { builtinModules, createRequire } from "node:module";
-import { dirname, extname, isAbsolute, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { PLUGIN_FILE_EXTENSIONS } from "@clinebot/shared";
-import createJiti from "jiti";
-
-const MODULE_DIR = dirname(fileURLToPath(import.meta.url));
-const HOST_REQUIRE = createRequire(import.meta.url);
-// `plugin-module-import.ts` lives at `packages/core/src/extensions/plugin`, so
-// walking up five levels lands at the repo root.
-const WORKSPACE_ROOT = resolve(MODULE_DIR, "..", "..", "..", "..", "..");
-const WORKSPACE_ALIASES = collectWorkspaceAliases(WORKSPACE_ROOT);
-const BUILTIN_MODULES = new Set(
-	builtinModules.flatMap((id) => [id, id.replace(/^node:/, "")]),
-);
-const SUPPORTED_PLUGIN_EXTENSIONS = new Set(PLUGIN_FILE_EXTENSIONS);
-
-export interface ImportPluginModuleOptions {
-	useCache?: boolean;
-}
-
-function collectWorkspaceAliases(root: string): Record<string, string> {
-	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.ts"),
-		"@clinebot/llms": resolve(root, "packages/llms/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 isBareSpecifier(specifier: string): boolean {
-	return !(
-		specifier.startsWith(".") ||
-		specifier.startsWith("/") ||
-		specifier.startsWith("file:") ||
-		specifier.startsWith("data:") ||
-		specifier.startsWith("http:") ||
-		specifier.startsWith("https:")
-	);
-}
-
-function getPackageName(specifier: string): string {
-	if (specifier.startsWith("@")) {
-		const [scope, name] = specifier.split("/", 3);
-		return name ? `${scope}/${name}` : specifier;
-	}
-	return specifier.split("/", 1)[0] ?? specifier;
-}
-
-function hasInstalledDependency(
-	pluginFilePath: string,
-	specifier: string,
-): boolean {
-	const packageName = getPackageName(specifier);
-	let current = dirname(pluginFilePath);
-	while (true) {
-		const packageDir = resolve(current, "node_modules", packageName);
-		if (
-			existsSync(packageDir) ||
-			existsSync(resolve(packageDir, "package.json"))
-		) {
-			return true;
-		}
-		const parent = resolve(current, "..");
-		if (parent === current) {
-			return false;
-		}
-		current = parent;
-	}
-}
-
-function resolvesFromHostRuntime(specifier: string): boolean {
-	try {
-		HOST_REQUIRE.resolve(specifier);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-function resolveFromHostRuntime(specifier: string): string | null {
-	try {
-		return HOST_REQUIRE.resolve(specifier);
-	} catch {
-		return null;
-	}
-}
-
-function isPackageBasedPlugin(pluginFilePath: string): boolean {
-	// Walk up from the plugin file looking for a package.json with a `cline`
-	// manifest.  Stop at the first package.json we encounter — if it doesn't
-	// declare `cline` we've left the plugin boundary (e.g. hit the workspace
-	// root).  Also cap the traversal so we never wander far from the plugin
-	// search root (.cline/plugins).
-	const MAX_DEPTH = 4;
-	let current = dirname(pluginFilePath);
-	for (let depth = 0; depth < MAX_DEPTH; depth++) {
-		const packageJsonPath = resolve(current, "package.json");
-		if (existsSync(packageJsonPath)) {
-			try {
-				const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-				return pkg != null && typeof pkg === "object" && "cline" in pkg;
-			} catch {
-				return false;
-			}
-		}
-		const parent = resolve(current, "..");
-		if (parent === current) {
-			return false;
-		}
-		current = parent;
-	}
-	return false;
-}
-
-function resolveRelativeImportPath(
-	fromPath: string,
-	specifier: string,
-): string | null {
-	const resolvedBase = specifier.startsWith("file:")
-		? fileURLToPath(specifier)
-		: isAbsolute(specifier)
-			? specifier
-			: resolve(dirname(fromPath), specifier);
-	if (
-		existsSync(resolvedBase) &&
-		SUPPORTED_PLUGIN_EXTENSIONS.has(extname(resolvedBase))
-	) {
-		return resolvedBase;
-	}
-	for (const extension of SUPPORTED_PLUGIN_EXTENSIONS) {
-		const withExtension = `${resolvedBase}${extension}`;
-		if (existsSync(withExtension)) {
-			return withExtension;
-		}
-	}
-	for (const extension of SUPPORTED_PLUGIN_EXTENSIONS) {
-		const indexPath = resolve(resolvedBase, `index${extension}`);
-		if (existsSync(indexPath)) {
-			return indexPath;
-		}
-	}
-	return null;
-}
-
-function collectStaticModuleSpecifiers(source: string): string[] {
-	const specifiers = new Set<string>();
-	const patterns = [
-		/\bimport\s+(?:type\s+)?[^"'`]*?\bfrom\s*["'`]([^"'`]+)["'`]/g,
-		/\bexport\s+[^"'`]*?\bfrom\s*["'`]([^"'`]+)["'`]/g,
-		/\bimport\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g,
-		/\brequire\s*\(\s*["'`]([^"'`]+)["'`]\s*\)/g,
-	];
-	for (const pattern of patterns) {
-		for (const match of source.matchAll(pattern)) {
-			const specifier = match[1];
-			if (specifier) {
-				specifiers.add(specifier);
-			}
-		}
-	}
-	return [...specifiers];
-}
-
-function assertPluginDependenciesInstalled(
-	pluginPath: string,
-	preferHostRuntimeDependencies: boolean,
-	seen = new Set<string>(),
-): void {
-	if (seen.has(pluginPath) || !existsSync(pluginPath)) {
-		return;
-	}
-	seen.add(pluginPath);
-
-	if (!SUPPORTED_PLUGIN_EXTENSIONS.has(extname(pluginPath))) {
-		return;
-	}
-
-	const source = readFileSync(pluginPath, "utf8");
-	for (const specifier of collectStaticModuleSpecifiers(source)) {
-		if (specifier.startsWith("node:") || BUILTIN_MODULES.has(specifier)) {
-			continue;
-		}
-		if (isBareSpecifier(specifier)) {
-			if (
-				Object.hasOwn(WORKSPACE_ALIASES, specifier) ||
-				Object.hasOwn(WORKSPACE_ALIASES, getPackageName(specifier)) ||
-				hasInstalledDependency(pluginPath, specifier) ||
-				(preferHostRuntimeDependencies && resolvesFromHostRuntime(specifier))
-			) {
-				continue;
-			}
-			throw new Error(`Cannot find module '${getPackageName(specifier)}'`);
-		}
-		const resolvedPath = resolveRelativeImportPath(pluginPath, specifier);
-		if (resolvedPath) {
-			assertPluginDependenciesInstalled(
-				resolvedPath,
-				preferHostRuntimeDependencies,
-				seen,
-			);
-		}
-	}
-}
-
-function collectPluginImportAliases(
-	pluginPath: string,
-	preferHostRuntimeDependencies: boolean,
-): 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;
-	}
-	if (preferHostRuntimeDependencies) {
-		const source = readFileSync(pluginPath, "utf8");
-		for (const specifier of collectStaticModuleSpecifiers(source)) {
-			if (
-				!isBareSpecifier(specifier) ||
-				specifier.startsWith("node:") ||
-				BUILTIN_MODULES.has(specifier) ||
-				Object.hasOwn(aliases, specifier) ||
-				hasInstalledDependency(pluginPath, specifier)
-			) {
-				continue;
-			}
-			const resolved = resolveFromHostRuntime(specifier);
-			if (resolved) {
-				aliases[specifier] = resolved;
-			}
-		}
-	}
-	return aliases;
-}
-
-export async function importPluginModule(
-	pluginPath: string,
-	options: ImportPluginModuleOptions = {},
-): Promise<Record<string, unknown>> {
-	const preferHostRuntimeDependencies = !isPackageBasedPlugin(pluginPath);
-	assertPluginDependenciesInstalled(pluginPath, preferHostRuntimeDependencies);
-	const aliases = collectPluginImportAliases(
-		pluginPath,
-		preferHostRuntimeDependencies,
-	);
-	const jiti = createJiti(pluginPath, {
-		alias: aliases,
-		cache: options.useCache,
-		requireCache: options.useCache,
-		esmResolve: true,
-		interopDefault: false,
-		nativeModules: [...BUILTIN_MODULES],
-		transformModules: Object.keys(aliases),
-	});
-	return (await jiti.import(pluginPath, {})) as Record<string, unknown>;
-}