@clinebot/core 0.0.37 → 0.0.38

package/src/extensions/mcp/client.ts

@@ -1,420 +0,0 @@
-import { type ChildProcessWithoutNullStreams, spawn } from "node:child_process";
-import { StringDecoder } from "node:string_decoder";
-import type {
-	McpServerClient,
-	McpServerClientFactory,
-	McpServerRegistration,
-	McpToolCallResult,
-	McpToolDescriptor,
-} from "./types";
-
-type JsonRpcRequest = {
-	jsonrpc: "2.0";
-	id: number;
-	method: string;
-	params?: Record<string, unknown>;
-};
-
-type JsonRpcMessage = {
-	jsonrpc?: "2.0";
-	id?: number;
-	method?: string;
-	result?: unknown;
-	error?: {
-		code?: number;
-		message?: string;
-		data?: unknown;
-	};
-};
-
-type StdioProtocolMode = "newline" | "framed";
-
-const MCP_PROTOCOL_VERSION = "2024-11-05";
-const MCP_REQUEST_TIMEOUT_MS = 5_000;
-const MCP_CONNECT_TIMEOUT_MS = 1_500;
-
-function toErrorMessage(error: unknown): string {
-	return error instanceof Error ? error.message : String(error);
-}
-
-function encodeFramedMessage(message: Record<string, unknown>): Buffer {
-	const body = Buffer.from(JSON.stringify(message), "utf8");
-	const header = Buffer.from(
-		`Content-Length: ${body.byteLength}\r\n\r\n`,
-		"utf8",
-	);
-	return Buffer.concat([header, body]);
-}
-
-function encodeNewlineMessage(message: Record<string, unknown>): Buffer {
-	return Buffer.from(`${JSON.stringify(message)}\n`, "utf8");
-}
-
-class FramedMessageParser {
-	private buffer = "";
-	private readonly decoder = new StringDecoder("utf8");
-
-	push(chunk: Buffer): string[] {
-		this.buffer += this.decoder.write(chunk);
-		const messages: string[] = [];
-
-		while (true) {
-			const separatorIndex = this.buffer.indexOf("\r\n\r\n");
-			if (separatorIndex < 0) {
-				break;
-			}
-
-			const headerText = this.buffer.slice(0, separatorIndex);
-			const contentLengthMatch = headerText.match(
-				/(?:^|\r\n)Content-Length:\s*(\d+)(?:\r\n|$)/i,
-			);
-			if (!contentLengthMatch) {
-				throw new Error(
-					"Invalid MCP stdio frame: missing Content-Length header.",
-				);
-			}
-
-			const contentLength = Number.parseInt(contentLengthMatch[1], 10);
-			const bodyStart = separatorIndex + 4;
-			const bodyEnd = bodyStart + contentLength;
-			if (this.buffer.length < bodyEnd) {
-				break;
-			}
-
-			messages.push(this.buffer.slice(bodyStart, bodyEnd));
-			this.buffer = this.buffer.slice(bodyEnd);
-		}
-
-		return messages;
-	}
-}
-
-class NewlineMessageParser {
-	private buffer = "";
-	private readonly decoder = new StringDecoder("utf8");
-
-	push(chunk: Buffer): string[] {
-		this.buffer += this.decoder.write(chunk);
-		const messages: string[] = [];
-
-		while (true) {
-			const newlineIndex = this.buffer.indexOf("\n");
-			if (newlineIndex < 0) {
-				break;
-			}
-			const line = this.buffer.slice(0, newlineIndex).trim();
-			this.buffer = this.buffer.slice(newlineIndex + 1);
-			if (line.length > 0) {
-				messages.push(line);
-			}
-		}
-
-		return messages;
-	}
-}
-
-class StdioMcpClient implements McpServerClient {
-	private readonly registration: McpServerRegistration;
-	private process?: ChildProcessWithoutNullStreams;
-	private nextRequestId = 1;
-	private readonly pending = new Map<
-		number,
-		{
-			resolve: (value: unknown) => void;
-			reject: (error: Error) => void;
-			timeout: ReturnType<typeof setTimeout>;
-		}
-	>();
-	private framedParser = new FramedMessageParser();
-	private newlineParser = new NewlineMessageParser();
-	private stderrBuffer = "";
-	private connected = false;
-	private protocolMode: StdioProtocolMode = "newline";
-
-	constructor(registration: McpServerRegistration) {
-		this.registration = registration;
-	}
-
-	async connect(): Promise<void> {
-		if (this.connected) {
-			return;
-		}
-		if (this.registration.transport.type !== "stdio") {
-			throw new Error(
-				`Unsupported MCP transport for "${this.registration.name}": ${this.registration.transport.type}`,
-			);
-		}
-
-		const attempts: StdioProtocolMode[] = ["newline", "framed"];
-		let lastError: Error | undefined;
-
-		for (const protocolMode of attempts) {
-			await this.disconnect().catch(() => {});
-			this.spawnProcess(protocolMode);
-			try {
-				await this.request(
-					"initialize",
-					{
-						protocolVersion: MCP_PROTOCOL_VERSION,
-						capabilities: {},
-						clientInfo: {
-							name: "@clinebot/core",
-							version: "0.0.0",
-						},
-					},
-					MCP_CONNECT_TIMEOUT_MS,
-				);
-				this.notify("notifications/initialized");
-				this.connected = true;
-				this.protocolMode = protocolMode;
-				return;
-			} catch (error) {
-				lastError = error instanceof Error ? error : new Error(String(error));
-			}
-		}
-
-		throw (
-			lastError ??
-			new Error(`Failed to connect to MCP server "${this.registration.name}".`)
-		);
-	}
-
-	async disconnect(): Promise<void> {
-		const child = this.process;
-		this.connected = false;
-		this.process = undefined;
-		this.failAllPending(
-			new Error(`Disconnected from MCP server "${this.registration.name}".`),
-		);
-		if (!child) {
-			return;
-		}
-		child.kill();
-	}
-
-	async listTools(): Promise<readonly McpToolDescriptor[]> {
-		const result = (await this.request("tools/list")) as {
-			tools?: Array<{
-				name?: string;
-				description?: string;
-				inputSchema?: Record<string, unknown>;
-			}>;
-		};
-		return (result.tools ?? [])
-			.filter(
-				(
-					tool,
-				): tool is {
-					name: string;
-					description?: string;
-					inputSchema: Record<string, unknown>;
-				} =>
-					typeof tool?.name === "string" &&
-					typeof tool.inputSchema === "object" &&
-					tool.inputSchema !== null,
-			)
-			.map((tool) => ({
-				name: tool.name,
-				description: tool.description,
-				inputSchema: tool.inputSchema,
-			}));
-	}
-
-	async callTool(request: {
-		name: string;
-		arguments?: Record<string, unknown>;
-	}): Promise<McpToolCallResult> {
-		return this.request("tools/call", {
-			name: request.name,
-			arguments: request.arguments ?? {},
-		});
-	}
-
-	private spawnProcess(protocolMode: StdioProtocolMode): void {
-		const transport = this.registration.transport;
-		if (transport.type !== "stdio") {
-			throw new Error(
-				`Unsupported MCP transport for "${this.registration.name}": ${transport.type}`,
-			);
-		}
-
-		this.framedParser = new FramedMessageParser();
-		this.newlineParser = new NewlineMessageParser();
-		this.stderrBuffer = "";
-		this.protocolMode = protocolMode;
-
-		const child = spawn(transport.command, transport.args ?? [], {
-			cwd: transport.cwd,
-			env: {
-				...process.env,
-				...(transport.env ?? {}),
-			},
-			stdio: ["pipe", "pipe", "pipe"],
-		});
-
-		this.process = child;
-		child.stdout.on("data", (chunk: Buffer) => this.handleStdout(chunk));
-		child.stderr.on("data", (chunk: Buffer) => {
-			if (this.process !== child) {
-				return;
-			}
-			this.stderrBuffer += chunk.toString("utf8");
-			if (this.stderrBuffer.length > 16_384) {
-				this.stderrBuffer = this.stderrBuffer.slice(-16_384);
-			}
-		});
-		child.once("error", (error) => {
-			if (this.process !== child) {
-				return;
-			}
-			this.failAllPending(
-				new Error(`MCP process error: ${toErrorMessage(error)}`),
-			);
-		});
-		child.once("exit", (code, signal) => {
-			if (this.process !== child) {
-				return;
-			}
-			this.connected = false;
-			this.process = undefined;
-			const suffix = this.stderrBuffer.trim()
-				? ` stderr: ${this.stderrBuffer.trim()}`
-				: "";
-			this.failAllPending(
-				new Error(
-					`MCP process exited for "${this.registration.name}" (code=${code ?? "null"}, signal=${signal ?? "null"}).${suffix}`,
-				),
-			);
-		});
-	}
-
-	private handleStdout(chunk: Buffer): void {
-		try {
-			const messages =
-				this.protocolMode === "framed"
-					? this.framedParser.push(chunk)
-					: this.newlineParser.push(chunk);
-
-			for (const messageText of messages) {
-				const message = JSON.parse(messageText) as JsonRpcMessage;
-				if (typeof message.id !== "number") {
-					continue;
-				}
-				const pending = this.pending.get(message.id);
-				if (!pending) {
-					continue;
-				}
-				this.pending.delete(message.id);
-				clearTimeout(pending.timeout);
-				if (message.error) {
-					const errorMessage =
-						message.error.message ||
-						`MCP request failed with code ${message.error.code ?? "unknown"}`;
-					pending.reject(new Error(errorMessage));
-					continue;
-				}
-				pending.resolve(message.result);
-			}
-		} catch (error) {
-			this.handleProtocolFailure(error);
-		}
-	}
-
-	private handleProtocolFailure(error: unknown): void {
-		const child = this.process;
-		if (!child) {
-			return;
-		}
-
-		this.connected = false;
-		this.process = undefined;
-		const stderrSuffix = this.stderrBuffer.trim()
-			? ` stderr: ${this.stderrBuffer.trim()}`
-			: "";
-		this.failAllPending(
-			new Error(
-				`Invalid MCP response from "${this.registration.name}": ${toErrorMessage(error)}.${stderrSuffix}`,
-			),
-		);
-		child.kill();
-	}
-
-	private async request(
-		method: string,
-		params?: Record<string, unknown>,
-		timeoutMs = MCP_REQUEST_TIMEOUT_MS,
-	): Promise<unknown> {
-		const child = this.process;
-		if (!child?.stdin.writable) {
-			throw new Error(
-				`MCP server "${this.registration.name}" is not connected.`,
-			);
-		}
-
-		const id = this.nextRequestId++;
-		const payload: JsonRpcRequest = {
-			jsonrpc: "2.0",
-			id,
-			method,
-			...(params ? { params } : {}),
-		};
-
-		const resultPromise = new Promise<unknown>((resolve, reject) => {
-			const timeout = setTimeout(() => {
-				this.pending.delete(id);
-				reject(
-					new Error(
-						`MCP request timed out for "${this.registration.name}" (${method}).`,
-					),
-				);
-			}, timeoutMs);
-			this.pending.set(id, { resolve, reject, timeout });
-		});
-
-		try {
-			child.stdin.write(
-				this.protocolMode === "framed"
-					? encodeFramedMessage(payload)
-					: encodeNewlineMessage(payload),
-			);
-		} catch (error) {
-			const pending = this.pending.get(id);
-			if (pending) {
-				clearTimeout(pending.timeout);
-				this.pending.delete(id);
-			}
-			throw error;
-		}
-
-		return resultPromise;
-	}
-
-	private notify(method: string, params?: Record<string, unknown>): void {
-		const child = this.process;
-		if (!child?.stdin.writable) {
-			return;
-		}
-		const payload = {
-			jsonrpc: "2.0" as const,
-			method,
-			...(params ? { params } : {}),
-		};
-		child.stdin.write(
-			this.protocolMode === "framed"
-				? encodeFramedMessage(payload)
-				: encodeNewlineMessage(payload),
-		);
-	}
-
-	private failAllPending(error: Error): void {
-		for (const [id, pending] of this.pending) {
-			clearTimeout(pending.timeout);
-			this.pending.delete(id);
-			pending.reject(error);
-		}
-	}
-}
-
-export function createDefaultMcpServerClientFactory(): McpServerClientFactory {
-	return (registration) => new StdioMcpClient(registration);
-}

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

@@ -1,219 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { resolveMcpSettingsPath } from "@clinebot/shared/storage";
-import { z } from "zod";
-import type { McpManager, McpServerRegistration } from "./types";
-
-const stringRecordSchema = z.record(z.string(), z.string());
-const metadataSchema = z.record(z.string(), z.unknown());
-
-const stdioTransportSchema = z.object({
-	type: z.literal("stdio"),
-	command: z.string().min(1),
-	args: z.array(z.string()).optional(),
-	cwd: z.string().min(1).optional(),
-	env: stringRecordSchema.optional(),
-});
-
-const sseTransportSchema = z.object({
-	type: z.literal("sse"),
-	url: z.string().url(),
-	headers: stringRecordSchema.optional(),
-});
-
-const streamableHttpTransportSchema = z.object({
-	type: z.literal("streamableHttp"),
-	url: z.string().url(),
-	headers: stringRecordSchema.optional(),
-});
-
-const mcpTransportSchema = z.discriminatedUnion("type", [
-	stdioTransportSchema,
-	sseTransportSchema,
-	streamableHttpTransportSchema,
-]);
-
-const nestedRegistrationBodySchema = z.object({
-	transport: mcpTransportSchema,
-	disabled: z.boolean().optional(),
-	metadata: metadataSchema.optional(),
-});
-
-const legacyTransportTypeSchema = z
-	.enum(["stdio", "sse", "http", "streamableHttp"])
-	.optional();
-
-const legacyRegistrationBaseSchema = z.object({
-	type: z.enum(["stdio", "sse", "streamableHttp"]).optional(),
-	transportType: legacyTransportTypeSchema,
-	disabled: z.boolean().optional(),
-	metadata: metadataSchema.optional(),
-});
-
-function mapLegacyTransportType(
-	transportType: z.infer<typeof legacyTransportTypeSchema>,
-): "stdio" | "sse" | "streamableHttp" | undefined {
-	if (!transportType) {
-		return undefined;
-	}
-	if (transportType === "http") {
-		return "streamableHttp";
-	}
-	return transportType;
-}
-
-const legacyStdioRegistrationSchema = legacyRegistrationBaseSchema
-	.extend({
-		command: z.string().min(1),
-		args: z.array(z.string()).optional(),
-		cwd: z.string().min(1).optional(),
-		env: stringRecordSchema.optional(),
-	})
-	.superRefine((value, ctx) => {
-		const resolvedType =
-			value.type ?? mapLegacyTransportType(value.transportType);
-		if (resolvedType && resolvedType !== "stdio") {
-			ctx.addIssue({
-				code: z.ZodIssueCode.custom,
-				message: 'Expected type "stdio" for command-based MCP server',
-				path: ["type"],
-			});
-		}
-	})
-	.transform((value) => ({
-		transport: {
-			type: "stdio" as const,
-			command: value.command,
-			args: value.args,
-			cwd: value.cwd,
-			env: value.env,
-		},
-		disabled: value.disabled,
-		metadata: value.metadata,
-	}));
-
-const legacyUrlRegistrationSchema = legacyRegistrationBaseSchema
-	.extend({
-		url: z.string().url(),
-		headers: stringRecordSchema.optional(),
-	})
-	.superRefine((value, ctx) => {
-		const resolvedType =
-			value.type ?? mapLegacyTransportType(value.transportType) ?? "sse";
-		if (resolvedType !== "sse" && resolvedType !== "streamableHttp") {
-			ctx.addIssue({
-				code: z.ZodIssueCode.custom,
-				message:
-					'Expected type "sse" or "streamableHttp" for URL-based MCP server',
-				path: ["type"],
-			});
-		}
-	})
-	.transform((value) => {
-		const resolvedType =
-			value.type ?? mapLegacyTransportType(value.transportType) ?? "sse";
-		if (resolvedType === "streamableHttp") {
-			return {
-				transport: {
-					type: "streamableHttp" as const,
-					url: value.url,
-					headers: value.headers,
-				},
-				disabled: value.disabled,
-				metadata: value.metadata,
-			};
-		}
-		return {
-			transport: {
-				type: "sse" as const,
-				url: value.url,
-				headers: value.headers,
-			},
-			disabled: value.disabled,
-			metadata: value.metadata,
-		};
-	});
-
-const mcpRegistrationBodySchema = z.union([
-	nestedRegistrationBodySchema,
-	legacyStdioRegistrationSchema,
-	legacyUrlRegistrationSchema,
-]);
-
-const mcpSettingsSchema = z
-	.object({
-		mcpServers: z.record(z.string(), mcpRegistrationBodySchema),
-	})
-	.strict();
-
-export interface McpSettingsFile {
-	mcpServers: Record<string, Omit<McpServerRegistration, "name">>;
-}
-
-export interface LoadMcpSettingsOptions {
-	filePath?: string;
-}
-
-export interface RegisterMcpServersFromSettingsOptions {
-	filePath?: string;
-}
-
-export function resolveDefaultMcpSettingsPath(): string {
-	return resolveMcpSettingsPath();
-}
-
-export function loadMcpSettingsFile(
-	options: LoadMcpSettingsOptions = {},
-): McpSettingsFile {
-	const filePath = options.filePath ?? resolveDefaultMcpSettingsPath();
-	const raw = readFileSync(filePath, "utf8");
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(raw);
-	} catch (error) {
-		const details = error instanceof Error ? error.message : String(error);
-		throw new Error(
-			`Failed to parse MCP settings JSON at "${filePath}": ${details}`,
-		);
-	}
-	const result = mcpSettingsSchema.safeParse(parsed);
-	if (!result.success) {
-		const details = result.error.issues
-			.map((issue) => {
-				const path = issue.path.join(".");
-				return path ? `${path}: ${issue.message}` : issue.message;
-			})
-			.join("; ");
-		throw new Error(`Invalid MCP settings at "${filePath}": ${details}`);
-	}
-	return result.data;
-}
-
-export function hasMcpSettingsFile(
-	options: LoadMcpSettingsOptions = {},
-): boolean {
-	const filePath = options.filePath ?? resolveDefaultMcpSettingsPath();
-	return existsSync(filePath);
-}
-
-export function resolveMcpServerRegistrations(
-	options: LoadMcpSettingsOptions = {},
-): McpServerRegistration[] {
-	const config = loadMcpSettingsFile(options);
-	return Object.entries(config.mcpServers).map(([name, value]) => ({
-		name,
-		transport: value.transport,
-		disabled: value.disabled,
-		metadata: value.metadata,
-	}));
-}
-
-export async function registerMcpServersFromSettingsFile(
-	manager: Pick<McpManager, "registerServer">,
-	options: RegisterMcpServersFromSettingsOptions = {},
-): Promise<McpServerRegistration[]> {
-	const registrations = resolveMcpServerRegistrations(options);
-	for (const registration of registrations) {
-		await manager.registerServer(registration);
-	}
-	return registrations;
-}

package/src/extensions/mcp/index.ts

@@ -1,42 +0,0 @@
-export { createDefaultMcpServerClientFactory } from "./client";
-export type {
-	LoadMcpSettingsOptions,
-	McpSettingsFile,
-	RegisterMcpServersFromSettingsOptions,
-} from "./config-loader";
-export {
-	hasMcpSettingsFile,
-	loadMcpSettingsFile,
-	registerMcpServersFromSettingsFile,
-	resolveDefaultMcpSettingsPath,
-	resolveMcpServerRegistrations,
-} from "./config-loader";
-export { InMemoryMcpManager } from "./manager";
-export type {
-	CreateDisabledMcpToolPoliciesOptions,
-	CreateDisabledMcpToolPolicyOptions,
-} from "./policies";
-export {
-	createDisabledMcpToolPolicies,
-	createDisabledMcpToolPolicy,
-} from "./policies";
-export { createMcpTools } from "./tools";
-export type {
-	CreateMcpToolsOptions,
-	McpConnectionStatus,
-	McpManager,
-	McpManagerOptions,
-	McpServerClient,
-	McpServerClientFactory,
-	McpServerRegistration,
-	McpServerSnapshot,
-	McpServerTransportConfig,
-	McpSseTransportConfig,
-	McpStdioTransportConfig,
-	McpStreamableHttpTransportConfig,
-	McpToolCallRequest,
-	McpToolCallResult,
-	McpToolDescriptor,
-	McpToolNameTransform,
-	McpToolProvider,
-} from "./types";