@clinebot/core 0.0.0

package/src/mcp/manager.ts

@@ -0,0 +1,262 @@
+import type {
+	McpToolCallRequest,
+	McpToolCallResult,
+	McpToolDescriptor,
+} from "@clinebot/agents";
+import type {
+	McpConnectionStatus,
+	McpManager,
+	McpManagerOptions,
+	McpServerClient,
+	McpServerRegistration,
+	McpServerSnapshot,
+} 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/mcp/types.ts

@@ -0,0 +1,88 @@
+import type {
+	McpToolCallRequest,
+	McpToolCallResult,
+	McpToolDescriptor,
+	McpToolProvider,
+	ToolContext,
+} from "@clinebot/agents";
+
+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/runtime/hook-file-hooks.test.ts

@@ -0,0 +1,106 @@
+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 { createHookConfigFileHooks } from "./hook-file-hooks";
+
+async function createWorkspaceWithHook(
+	fileName: string,
+	body: string,
+): Promise<{ workspace: string; hookPath: string }> {
+	const workspace = await mkdtemp(join(tmpdir(), "hooks-workspace-"));
+	const hooksDir = join(workspace, ".clinerules", "hooks");
+	await mkdir(hooksDir, { recursive: true });
+	const hookPath = join(hooksDir, fileName);
+	await writeFile(hookPath, body, "utf8");
+	return { workspace, hookPath };
+}
+
+describe("createHookConfigFileHooks", () => {
+	it("executes extensionless legacy hook files via bash fallback", async () => {
+		const { workspace } = await createWorkspaceWithHook(
+			"PreToolUse",
+			'echo \'HOOK_CONTROL\t{"cancel":true,"context":"legacy-ok"}\'\n',
+		);
+		try {
+			const hooks = createHookConfigFileHooks({
+				cwd: workspace,
+				workspacePath: workspace,
+			});
+			expect(hooks?.onToolCallStart).toBeTypeOf("function");
+			const control = await hooks?.onToolCallStart?.({
+				agentId: "agent_1",
+				conversationId: "conv_1",
+				parentAgentId: null,
+				iteration: 1,
+				call: {
+					id: "call_1",
+					name: "read_file",
+					input: { path: "README.md" },
+				},
+			});
+			expect(control).toMatchObject({ cancel: true, context: "legacy-ok" });
+		} finally {
+			await rm(workspace, { recursive: true, force: true });
+		}
+	});
+
+	it("honors shebang interpreter when present", async () => {
+		const { workspace } = await createWorkspaceWithHook(
+			"PreToolUse",
+			'#!/usr/bin/env bash\necho \'HOOK_CONTROL\t{"cancel":false,"context":"shebang-ok"}\'\n',
+		);
+		try {
+			const hooks = createHookConfigFileHooks({
+				cwd: workspace,
+				workspacePath: workspace,
+			});
+			expect(hooks?.onToolCallStart).toBeTypeOf("function");
+			const control = await hooks?.onToolCallStart?.({
+				agentId: "agent_1",
+				conversationId: "conv_1",
+				parentAgentId: null,
+				iteration: 1,
+				call: {
+					id: "call_1",
+					name: "read_file",
+					input: { path: "README.md" },
+				},
+			});
+			expect(control).toMatchObject({ cancel: false, context: "shebang-ok" });
+		} finally {
+			await rm(workspace, { recursive: true, force: true });
+		}
+	});
+
+	it("parses review control from hook output", async () => {
+		const { workspace } = await createWorkspaceWithHook(
+			"PreToolUse.ts",
+			'console.log(\'HOOK_CONTROL\\t{"review":true,"context":"needs-review"}\')\n',
+		);
+		try {
+			const hooks = createHookConfigFileHooks({
+				cwd: workspace,
+				workspacePath: workspace,
+			});
+			expect(hooks?.onToolCallStart).toBeTypeOf("function");
+			const control = await hooks?.onToolCallStart?.({
+				agentId: "agent_1",
+				conversationId: "conv_1",
+				parentAgentId: null,
+				iteration: 1,
+				call: {
+					id: "call_1",
+					name: "run_commands",
+					input: { commands: ["git status"] },
+				},
+			});
+			expect(control).toMatchObject({
+				review: true,
+				context: "needs-review",
+			});
+		} finally {
+			await rm(workspace, { recursive: true, force: true });
+		}
+	});
+});