@clinebot/core 0.0.37 → 0.0.38

package/src/extensions/mcp/manager.ts

@@ -1,260 +0,0 @@
-import type {
-	McpConnectionStatus,
-	McpManager,
-	McpManagerOptions,
-	McpServerClient,
-	McpServerRegistration,
-	McpServerSnapshot,
-	McpToolCallRequest,
-	McpToolCallResult,
-	McpToolDescriptor,
-} from "./types";
-
-const DEFAULT_TOOLS_CACHE_TTL_MS = 5000;
-
-type ManagedServerState = {
-	registration: McpServerRegistration;
-	client?: McpServerClient;
-	status: McpConnectionStatus;
-	lastError?: string;
-	updatedAt: number;
-	toolCache?: readonly McpToolDescriptor[];
-	toolCacheUpdatedAt?: number;
-};
-
-function nowMs(): number {
-	return Date.now();
-}
-
-function cloneTools(
-	tools: readonly McpToolDescriptor[],
-): readonly McpToolDescriptor[] {
-	return tools.map((tool) => ({
-		name: tool.name,
-		description: tool.description,
-		inputSchema: tool.inputSchema,
-	}));
-}
-
-export class InMemoryMcpManager implements McpManager {
-	private readonly toolsCacheTtlMs: number;
-	private readonly clientFactory: McpManagerOptions["clientFactory"];
-	private readonly servers = new Map<string, ManagedServerState>();
-	private readonly operationLocks = new Map<string, Promise<void>>();
-
-	constructor(options: McpManagerOptions) {
-		this.clientFactory = options.clientFactory;
-		this.toolsCacheTtlMs =
-			options.toolsCacheTtlMs ?? DEFAULT_TOOLS_CACHE_TTL_MS;
-	}
-
-	async registerServer(registration: McpServerRegistration): Promise<void> {
-		await this.runExclusive(registration.name, async () => {
-			const existing = this.servers.get(registration.name);
-			if (!existing) {
-				this.servers.set(registration.name, {
-					registration: { ...registration },
-					status: "disconnected",
-					updatedAt: nowMs(),
-				});
-				return;
-			}
-
-			const didTransportChange =
-				JSON.stringify(existing.registration.transport) !==
-				JSON.stringify(registration.transport);
-			existing.registration = { ...registration };
-			existing.updatedAt = nowMs();
-
-			if (didTransportChange) {
-				await this.disconnectState(existing);
-				existing.client = undefined;
-				existing.toolCache = undefined;
-				existing.toolCacheUpdatedAt = undefined;
-			}
-		});
-	}
-
-	async unregisterServer(serverName: string): Promise<void> {
-		await this.runExclusive(serverName, async () => {
-			const state = this.requireServer(serverName);
-			await this.disconnectState(state);
-			this.servers.delete(serverName);
-		});
-	}
-
-	async connectServer(serverName: string): Promise<void> {
-		await this.runExclusive(serverName, async () => {
-			const state = this.requireServer(serverName);
-			await this.connectState(state);
-		});
-	}
-
-	async disconnectServer(serverName: string): Promise<void> {
-		await this.runExclusive(serverName, async () => {
-			const state = this.requireServer(serverName);
-			await this.disconnectState(state);
-		});
-	}
-
-	async setServerDisabled(
-		serverName: string,
-		disabled: boolean,
-	): Promise<void> {
-		await this.runExclusive(serverName, async () => {
-			const state = this.requireServer(serverName);
-			state.registration = {
-				...state.registration,
-				disabled,
-			};
-			state.updatedAt = nowMs();
-			if (disabled) {
-				await this.disconnectState(state);
-			}
-		});
-	}
-
-	listServers(): readonly McpServerSnapshot[] {
-		return [...this.servers.values()]
-			.map((state) => ({
-				name: state.registration.name,
-				status: state.status,
-				disabled: state.registration.disabled === true,
-				lastError: state.lastError,
-				toolCount: state.toolCache?.length ?? 0,
-				updatedAt: state.updatedAt,
-				metadata: state.registration.metadata,
-			}))
-			.sort((a, b) => a.name.localeCompare(b.name));
-	}
-
-	async listTools(serverName: string): Promise<readonly McpToolDescriptor[]> {
-		const state = this.requireServer(serverName);
-		const fetchedAt = state.toolCacheUpdatedAt ?? 0;
-		if (state.toolCache && nowMs() - fetchedAt <= this.toolsCacheTtlMs) {
-			return state.toolCache;
-		}
-		return this.refreshTools(serverName);
-	}
-
-	async refreshTools(
-		serverName: string,
-	): Promise<readonly McpToolDescriptor[]> {
-		return this.runExclusive(serverName, async () => {
-			const state = this.requireServer(serverName);
-			const client = await this.ensureConnectedClient(state);
-			const tools = await client.listTools();
-			const cloned = cloneTools(tools);
-			state.toolCache = cloned;
-			state.toolCacheUpdatedAt = nowMs();
-			state.updatedAt = nowMs();
-			return cloned;
-		});
-	}
-
-	async callTool(request: McpToolCallRequest): Promise<McpToolCallResult> {
-		return this.runExclusive(request.serverName, async () => {
-			const state = this.requireServer(request.serverName);
-			const client = await this.ensureConnectedClient(state);
-			state.updatedAt = nowMs();
-			return client.callTool({
-				name: request.toolName,
-				arguments: request.arguments,
-				context: request.context,
-			});
-		});
-	}
-
-	async dispose(): Promise<void> {
-		const names = [...this.servers.keys()];
-		for (const name of names) {
-			await this.unregisterServer(name);
-		}
-	}
-
-	private async ensureConnectedClient(
-		state: ManagedServerState,
-	): Promise<McpServerClient> {
-		await this.connectState(state);
-		if (!state.client) {
-			throw new Error(
-				`MCP server "${state.registration.name}" does not have an initialized client.`,
-			);
-		}
-		return state.client;
-	}
-
-	private async connectState(state: ManagedServerState): Promise<void> {
-		if (state.registration.disabled) {
-			throw new Error(
-				`MCP server "${state.registration.name}" is disabled and cannot be connected.`,
-			);
-		}
-		if (state.status === "connected" && state.client) {
-			return;
-		}
-		state.status = "connecting";
-		state.updatedAt = nowMs();
-		try {
-			const client =
-				state.client ?? (await this.clientFactory(state.registration));
-			await client.connect();
-			state.client = client;
-			state.status = "connected";
-			state.lastError = undefined;
-			state.updatedAt = nowMs();
-		} catch (error) {
-			state.status = "disconnected";
-			state.lastError = error instanceof Error ? error.message : String(error);
-			state.updatedAt = nowMs();
-			throw error;
-		}
-	}
-
-	private async disconnectState(state: ManagedServerState): Promise<void> {
-		if (!state.client) {
-			state.status = "disconnected";
-			state.updatedAt = nowMs();
-			return;
-		}
-
-		try {
-			await state.client.disconnect();
-		} finally {
-			state.status = "disconnected";
-			state.updatedAt = nowMs();
-		}
-	}
-
-	private requireServer(serverName: string): ManagedServerState {
-		const state = this.servers.get(serverName);
-		if (!state) {
-			throw new Error(`Unknown MCP server: ${serverName}`);
-		}
-		return state;
-	}
-
-	private async runExclusive<T>(
-		serverName: string,
-		operation: () => Promise<T>,
-	): Promise<T> {
-		const previous = this.operationLocks.get(serverName) ?? Promise.resolve();
-		let releaseCurrent: (() => void) | undefined;
-		const current = new Promise<void>((resolve) => {
-			releaseCurrent = resolve;
-		});
-		const queued = previous.catch(() => undefined).then(() => current);
-		this.operationLocks.set(serverName, queued);
-
-		await previous.catch(() => undefined);
-		try {
-			return await operation();
-		} finally {
-			releaseCurrent?.();
-			const lock = this.operationLocks.get(serverName);
-			if (lock === queued) {
-				this.operationLocks.delete(serverName);
-			}
-		}
-	}
-}

package/src/extensions/mcp/name-transform.ts

@@ -1,33 +0,0 @@
-import { createHash } from "node:crypto";
-import type { McpToolNameTransform } from "./types";
-
-const MAX_MCP_TOOL_NAME_LENGTH = 128;
-const INVALID_MCP_TOOL_NAME_CHARACTERS = /[^a-zA-Z0-9_-]+/g;
-const HASH_LENGTH = 8;
-const HASH_SEPARATOR_LENGTH = 1;
-const FALLBACK_BASE_NAME = "mcp_tool";
-
-function buildMcpToolNameHash(value: string): string {
-	return createHash("sha1").update(value).digest("hex").slice(0, HASH_LENGTH);
-}
-
-function sanitizeMcpToolNameCandidate(value: string): string {
-	return value.replace(INVALID_MCP_TOOL_NAME_CHARACTERS, "_");
-}
-
-export const defaultMcpToolNameTransform: McpToolNameTransform = ({
-	serverName,
-	toolName,
-}): string => {
-	const rawName = `${serverName}__${toolName}`;
-	const sanitizedName = sanitizeMcpToolNameCandidate(rawName);
-	if (sanitizedName === rawName && rawName.length <= MAX_MCP_TOOL_NAME_LENGTH) {
-		return rawName;
-	}
-
-	const hash = buildMcpToolNameHash(rawName);
-	const maxBaseLength =
-		MAX_MCP_TOOL_NAME_LENGTH - HASH_SEPARATOR_LENGTH - HASH_LENGTH;
-	const baseName = sanitizedName.slice(0, maxBaseLength) || FALLBACK_BASE_NAME;
-	return `${baseName}_${hash}`;
-};

package/src/extensions/mcp/policies.ts

@@ -1,47 +0,0 @@
-import type { ToolPolicy } from "@clinebot/shared";
-import { defaultMcpToolNameTransform } from "./name-transform";
-import type { McpToolNameTransform } from "./types";
-
-export interface CreateDisabledMcpToolPolicyOptions {
-	serverName: string;
-	toolName: string;
-	nameTransform?: McpToolNameTransform;
-}
-
-export interface CreateDisabledMcpToolPoliciesOptions {
-	serverName: string;
-	toolNames: readonly string[];
-	nameTransform?: McpToolNameTransform;
-}
-
-export function createDisabledMcpToolPolicy(
-	options: CreateDisabledMcpToolPolicyOptions,
-): Record<string, ToolPolicy> {
-	const nameTransform = options.nameTransform ?? defaultMcpToolNameTransform;
-	const name = nameTransform({
-		serverName: options.serverName,
-		toolName: options.toolName,
-	});
-	return {
-		[name]: {
-			enabled: false,
-		},
-	};
-}
-
-export function createDisabledMcpToolPolicies(
-	options: CreateDisabledMcpToolPoliciesOptions,
-): Record<string, ToolPolicy> {
-	const policies: Record<string, ToolPolicy> = {};
-	for (const toolName of options.toolNames) {
-		Object.assign(
-			policies,
-			createDisabledMcpToolPolicy({
-				serverName: options.serverName,
-				toolName,
-				nameTransform: options.nameTransform,
-			}),
-		);
-	}
-	return policies;
-}

package/src/extensions/mcp/tools.ts

@@ -1,47 +0,0 @@
-import { createTool, type Tool } from "@clinebot/shared";
-import { defaultMcpToolNameTransform } from "./name-transform";
-import type { CreateMcpToolsOptions, McpToolDescriptor } from "./types";
-
-function defaultMcpDescription(
-	serverName: string,
-	tool: McpToolDescriptor,
-): string {
-	const base = tool.description?.trim();
-	if (base) {
-		return base;
-	}
-	return `Execute MCP tool "${tool.name}" from server "${serverName}".`;
-}
-
-export async function createMcpTools(
-	options: CreateMcpToolsOptions,
-): Promise<Tool[]> {
-	const descriptors = await options.provider.listTools(options.serverName);
-	const nameTransform = options.nameTransform ?? defaultMcpToolNameTransform;
-
-	return descriptors.map((descriptor) => {
-		const agentToolName = nameTransform({
-			serverName: options.serverName,
-			toolName: descriptor.name,
-		});
-
-		return createTool({
-			name: agentToolName,
-			description: defaultMcpDescription(options.serverName, descriptor),
-			inputSchema: descriptor.inputSchema,
-			timeoutMs: options.timeoutMs,
-			retryable: options.retryable,
-			maxRetries: options.maxRetries,
-			execute: async (input: unknown, context) =>
-				options.provider.callTool({
-					serverName: options.serverName,
-					toolName: descriptor.name,
-					arguments:
-						input && typeof input === "object" && !Array.isArray(input)
-							? (input as Record<string, unknown>)
-							: undefined,
-					context,
-				}),
-		});
-	});
-}

package/src/extensions/mcp/types.ts

@@ -1,116 +0,0 @@
-import type { ToolContext } from "@clinebot/shared";
-
-export interface McpToolDescriptor {
-	name: string;
-	description?: string;
-	inputSchema: Record<string, unknown>;
-}
-
-export interface McpToolCallRequest {
-	serverName: string;
-	toolName: string;
-	arguments?: Record<string, unknown>;
-	context?: ToolContext;
-}
-
-export type McpToolCallResult = unknown;
-
-export interface McpToolProvider {
-	listTools(serverName: string): Promise<readonly McpToolDescriptor[]>;
-	callTool(request: McpToolCallRequest): Promise<McpToolCallResult>;
-}
-
-export type McpToolNameTransform = (input: {
-	serverName: string;
-	toolName: string;
-}) => string;
-
-export interface CreateMcpToolsOptions {
-	serverName: string;
-	provider: McpToolProvider;
-	nameTransform?: McpToolNameTransform;
-	timeoutMs?: number;
-	retryable?: boolean;
-	maxRetries?: number;
-}
-
-export type McpConnectionStatus = "disconnected" | "connecting" | "connected";
-
-export interface McpStdioTransportConfig {
-	type: "stdio";
-	command: string;
-	args?: string[];
-	cwd?: string;
-	env?: Record<string, string>;
-}
-
-export interface McpSseTransportConfig {
-	type: "sse";
-	url: string;
-	headers?: Record<string, string>;
-}
-
-export interface McpStreamableHttpTransportConfig {
-	type: "streamableHttp";
-	url: string;
-	headers?: Record<string, string>;
-}
-
-export type McpServerTransportConfig =
-	| McpStdioTransportConfig
-	| McpSseTransportConfig
-	| McpStreamableHttpTransportConfig;
-
-export interface McpServerRegistration {
-	name: string;
-	transport: McpServerTransportConfig;
-	disabled?: boolean;
-	metadata?: Record<string, unknown>;
-}
-
-export interface McpServerSnapshot {
-	name: string;
-	status: McpConnectionStatus;
-	disabled: boolean;
-	lastError?: string;
-	toolCount: number;
-	updatedAt: number;
-	metadata?: Record<string, unknown>;
-}
-
-export interface McpServerClient {
-	connect(): Promise<void>;
-	disconnect(): Promise<void>;
-	listTools(): Promise<readonly McpToolDescriptor[]>;
-	callTool(request: {
-		name: string;
-		arguments?: Record<string, unknown>;
-		context?: ToolContext;
-	}): Promise<McpToolCallResult>;
-}
-
-export type McpServerClientFactory = (
-	registration: McpServerRegistration,
-) => Promise<McpServerClient> | McpServerClient;
-
-export interface McpManagerOptions {
-	clientFactory: McpServerClientFactory;
-	/**
-	 * Cache TTL for tools/list responses.
-	 * A short cache avoids repeated list requests while keeping server metadata fresh.
-	 * @default 5000
-	 */
-	toolsCacheTtlMs?: number;
-}
-
-export interface McpManager extends McpToolProvider {
-	registerServer(registration: McpServerRegistration): Promise<void>;
-	unregisterServer(serverName: string): Promise<void>;
-	connectServer(serverName: string): Promise<void>;
-	disconnectServer(serverName: string): Promise<void>;
-	setServerDisabled(serverName: string, disabled: boolean): Promise<void>;
-	listServers(): readonly McpServerSnapshot[];
-	refreshTools(serverName: string): Promise<readonly McpToolDescriptor[]>;
-	callTool(request: McpToolCallRequest): Promise<McpToolCallResult>;
-	dispose(): Promise<void>;
-}

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

@@ -1,140 +0,0 @@
-import { existsSync } from "node:fs";
-import type {
-	AgentConfig,
-	PluginSetupContext,
-	WorkspaceInfo,
-} from "@clinebot/shared";
-import {
-	discoverPluginModulePaths as discoverPluginModulePathsFromShared,
-	resolveConfiguredPluginModulePaths,
-	resolvePluginConfigSearchPaths as resolvePluginConfigSearchPathsFromShared,
-} from "@clinebot/shared/storage";
-import type { PluginLoadDiagnostics } from "./plugin-load-report";
-import { loadAgentPluginsFromPathsWithDiagnostics } from "./plugin-loader";
-import { loadSandboxedPlugins } from "./plugin-sandbox";
-import type { PluginTargeting } from "./plugin-targeting";
-
-type AgentPlugin = NonNullable<AgentConfig["extensions"]>[number];
-
-export function resolvePluginConfigSearchPaths(
-	workspacePath?: string,
-): string[] {
-	return resolvePluginConfigSearchPathsFromShared(workspacePath);
-}
-
-export function discoverPluginModulePaths(directoryPath: string): string[] {
-	return discoverPluginModulePathsFromShared(directoryPath);
-}
-
-export interface ResolveAgentPluginPathsOptions {
-	pluginPaths?: ReadonlyArray<string>;
-	workspacePath?: string;
-	cwd?: string;
-}
-
-export function resolveAgentPluginPaths(
-	options: ResolveAgentPluginPathsOptions = {},
-): string[] {
-	const cwd = options.cwd ?? process.cwd();
-	const discoveredFromSearchPaths = resolvePluginConfigSearchPaths(
-		options.workspacePath,
-	)
-		.flatMap((directoryPath) => discoverPluginModulePaths(directoryPath))
-		.filter((path) => existsSync(path));
-	const configuredPaths = resolveConfiguredPluginModulePaths(
-		options.pluginPaths ?? [],
-		cwd,
-	);
-
-	const deduped: string[] = [];
-	const seen = new Set<string>();
-	for (const path of [...configuredPaths, ...discoveredFromSearchPaths]) {
-		if (seen.has(path)) {
-			continue;
-		}
-		seen.add(path);
-		deduped.push(path);
-	}
-	return deduped;
-}
-
-export interface ResolveAndLoadAgentPluginsOptions
-	extends ResolveAgentPluginPathsOptions,
-		PluginTargeting {
-	mode?: "sandbox" | "in_process";
-	exportName?: string;
-	importTimeoutMs?: number;
-	hookTimeoutMs?: number;
-	contributionTimeoutMs?: number;
-	onEvent?: (event: { name: string; payload?: unknown }) => void;
-	/**
-	 * Structured workspace and git metadata. Forwarded to sandboxed plugins
-	 * via PluginSetupCtx.workspaceInfo and made available to in-process plugins
-	 * in the extension context.
-	 */
-	workspaceInfo?: WorkspaceInfo;
-	session?: PluginSetupContext["session"];
-	client?: PluginSetupContext["client"];
-	user?: PluginSetupContext["user"];
-	automation?: PluginSetupContext["automation"];
-	logger?: PluginSetupContext["logger"];
-	telemetry?: PluginSetupContext["telemetry"];
-}
-
-export async function resolveAndLoadAgentPlugins(
-	options: ResolveAndLoadAgentPluginsOptions = {},
-): Promise<
-	{
-		extensions: AgentPlugin[];
-		shutdown?: () => Promise<void>;
-	} & PluginLoadDiagnostics
-> {
-	const paths = resolveAgentPluginPaths(options);
-	if (paths.length === 0) {
-		return { extensions: [], failures: [], warnings: [] };
-	}
-
-	if (options.mode === "in_process") {
-		const report = await loadAgentPluginsFromPathsWithDiagnostics(paths, {
-			cwd: options.cwd,
-			exportName: options.exportName,
-			providerId: options.providerId,
-			modelId: options.modelId,
-			session: options.session,
-			client: options.client,
-			user: options.user,
-			workspaceInfo: options.workspaceInfo,
-			automation: options.automation,
-			logger: options.logger,
-			telemetry: options.telemetry,
-		});
-		return {
-			extensions: report.plugins,
-			failures: report.failures,
-			warnings: report.warnings,
-		};
-	}
-
-	const sandboxed = await loadSandboxedPlugins({
-		pluginPaths: paths,
-		exportName: options.exportName,
-		importTimeoutMs: options.importTimeoutMs,
-		hookTimeoutMs: options.hookTimeoutMs,
-		contributionTimeoutMs: options.contributionTimeoutMs,
-		onEvent: options.onEvent,
-		providerId: options.providerId,
-		modelId: options.modelId,
-		cwd: options.cwd,
-		session: options.session,
-		client: options.client,
-		user: options.user,
-		workspaceInfo: options.workspaceInfo,
-		logger: options.logger,
-	});
-	return {
-		extensions: sandboxed.extensions ?? [],
-		shutdown: sandboxed.shutdown,
-		failures: sandboxed.failures,
-		warnings: sandboxed.warnings,
-	};
-}

package/src/extensions/plugin/plugin-load-report.ts

@@ -1,20 +0,0 @@
-export interface PluginInitializationFailure {
-	pluginPath: string;
-	pluginName?: string;
-	phase: "load" | "setup";
-	message: string;
-	stack?: string;
-}
-
-export interface PluginInitializationWarning {
-	type: "duplicate_plugin_override";
-	pluginPath: string;
-	pluginName: string;
-	overriddenPluginPath: string;
-	message: string;
-}
-
-export interface PluginLoadDiagnostics {
-	failures: PluginInitializationFailure[];
-	warnings: PluginInitializationWarning[];
-}