gsd-pi 2.29.0-dev.49d972f → 2.29.0-dev.77f06e2

package/dist/resources/extensions/mcp-client/index.ts

@@ -0,0 +1,459 @@
+/**
+ * MCP Client Extension — Native MCP server integration for pi
+ *
+ * Provides on-demand access to MCP servers configured in project files
+ * (.mcp.json, .gsd/mcp.json) using the @modelcontextprotocol/sdk Client
+ * directly — no external CLI dependency required.
+ *
+ * Three tools:
+ *   mcp_servers   — List available MCP servers from config files
+ *   mcp_discover  — Get tool signatures for a specific server (lazy connect)
+ *   mcp_call      — Call a tool on an MCP server (lazy connect)
+ */
+
+import type { ExtensionAPI } from "@gsd/pi-coding-agent";
+import {
+	truncateHead,
+	DEFAULT_MAX_BYTES,
+	DEFAULT_MAX_LINES,
+	formatSize,
+} from "@gsd/pi-coding-agent";
+import { Text } from "@gsd/pi-tui";
+import { Type } from "@sinclair/typebox";
+import { Client } from "@modelcontextprotocol/sdk/client";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+// ─── Types ────────────────────────────────────────────────────────────────────
+
+interface McpServerConfig {
+	name: string;
+	transport: "stdio" | "http" | "unknown";
+	command?: string;
+	args?: string[];
+	env?: Record<string, string>;
+	url?: string;
+	cwd?: string;
+}
+
+interface McpToolSchema {
+	name: string;
+	description: string;
+	inputSchema?: Record<string, unknown>;
+}
+
+interface ManagedConnection {
+	client: Client;
+	transport: StdioClientTransport | StreamableHTTPClientTransport;
+}
+
+// ─── Connection Manager ───────────────────────────────────────────────────────
+
+const connections = new Map<string, ManagedConnection>();
+let configCache: McpServerConfig[] | null = null;
+const toolCache = new Map<string, McpToolSchema[]>();
+
+function readConfigs(): McpServerConfig[] {
+	if (configCache) return configCache;
+
+	const servers: McpServerConfig[] = [];
+	const seen = new Set<string>();
+	const configPaths = [
+		join(process.cwd(), ".mcp.json"),
+		join(process.cwd(), ".gsd", "mcp.json"),
+	];
+
+	for (const configPath of configPaths) {
+		try {
+			if (!existsSync(configPath)) continue;
+			const raw = readFileSync(configPath, "utf-8");
+			const data = JSON.parse(raw) as Record<string, unknown>;
+			const mcpServers = (data.mcpServers ?? data.servers) as
+				| Record<string, Record<string, unknown>>
+				| undefined;
+			if (!mcpServers || typeof mcpServers !== "object") continue;
+
+			for (const [name, config] of Object.entries(mcpServers)) {
+				if (seen.has(name)) continue;
+				seen.add(name);
+
+				const hasCommand = typeof config.command === "string";
+				const hasUrl = typeof config.url === "string";
+				const transport: McpServerConfig["transport"] = hasCommand
+					? "stdio"
+					: hasUrl
+						? "http"
+						: "unknown";
+
+				servers.push({
+					name,
+					transport,
+					...(hasCommand && {
+						command: config.command as string,
+						args: Array.isArray(config.args) ? (config.args as string[]) : undefined,
+						env: config.env && typeof config.env === "object"
+							? (config.env as Record<string, string>)
+							: undefined,
+						cwd: typeof config.cwd === "string" ? config.cwd : undefined,
+					}),
+					...(hasUrl && { url: config.url as string }),
+				});
+			}
+		} catch {
+			// Non-fatal — config file may not exist or be malformed
+		}
+	}
+
+	configCache = servers;
+	return servers;
+}
+
+function getServerConfig(name: string): McpServerConfig | undefined {
+	return readConfigs().find((s) => s.name === name);
+}
+
+async function getOrConnect(name: string, signal?: AbortSignal): Promise<Client> {
+	const existing = connections.get(name);
+	if (existing) return existing.client;
+
+	const config = getServerConfig(name);
+	if (!config) throw new Error(`Unknown MCP server: "${name}". Use mcp_servers to list available servers.`);
+
+	const client = new Client({ name: "gsd", version: "1.0.0" });
+	let transport: StdioClientTransport | StreamableHTTPClientTransport;
+
+	if (config.transport === "stdio" && config.command) {
+		transport = new StdioClientTransport({
+			command: config.command,
+			args: config.args,
+			env: config.env ? { ...process.env, ...config.env } as Record<string, string> : undefined,
+			cwd: config.cwd,
+			stderr: "pipe",
+		});
+	} else if (config.transport === "http" && config.url) {
+		transport = new StreamableHTTPClientTransport(new URL(config.url));
+	} else {
+		throw new Error(`Server "${name}" has unsupported transport: ${config.transport}`);
+	}
+
+	await client.connect(transport, { signal, timeout: 30000 });
+	connections.set(name, { client, transport });
+	return client;
+}
+
+async function closeAll(): Promise<void> {
+	const closing = Array.from(connections.entries()).map(async ([name, conn]) => {
+		try {
+			await conn.client.close();
+		} catch {
+			// Best-effort cleanup
+		}
+		connections.delete(name);
+	});
+	await Promise.allSettled(closing);
+	toolCache.clear();
+}
+
+// ─── Formatters ───────────────────────────────────────────────────────────────
+
+function formatServerList(servers: McpServerConfig[]): string {
+	if (servers.length === 0) return "No MCP servers configured. Add servers to .mcp.json or .gsd/mcp.json.";
+
+	const lines: string[] = [`${servers.length} MCP servers configured:\n`];
+
+	for (const s of servers) {
+		const connected = connections.has(s.name) ? "✓" : "○";
+		const cached = toolCache.get(s.name);
+		const toolCount = cached ? ` — ${cached.length} tools` : "";
+		lines.push(`${connected} ${s.name} (${s.transport})${toolCount}`);
+	}
+
+	lines.push("\nUse mcp_discover to see full tool schemas for a specific server.");
+	lines.push("Use mcp_call to invoke a tool: mcp_call(server, tool, args).");
+	return lines.join("\n");
+}
+
+function formatToolList(serverName: string, tools: McpToolSchema[]): string {
+	const lines: string[] = [`${serverName} — ${tools.length} tools:\n`];
+
+	for (const tool of tools) {
+		lines.push(`## ${tool.name}`);
+		if (tool.description) lines.push(tool.description);
+		if (tool.inputSchema) {
+			lines.push("```json");
+			lines.push(JSON.stringify(tool.inputSchema, null, 2));
+			lines.push("```");
+		}
+		lines.push("");
+	}
+
+	lines.push(`Call with: mcp_call(server="${serverName}", tool="<tool_name>", args={...})`);
+	return lines.join("\n");
+}
+
+// ─── Extension ────────────────────────────────────────────────────────────────
+
+export default function (pi: ExtensionAPI) {
+	// ── mcp_servers ──────────────────────────────────────────────────────────
+
+	pi.registerTool({
+		name: "mcp_servers",
+		label: "MCP Servers",
+		description:
+			"List all available MCP servers configured in project files (.mcp.json, .gsd/mcp.json). " +
+			"Shows server names, transport type, and connection status. Use mcp_discover to get full tool schemas for a server.",
+		promptSnippet:
+			"List available MCP servers from project configuration",
+		promptGuidelines: [
+			"Call mcp_servers to see what MCP servers are available before trying to use one.",
+			"MCP servers provide external integrations (Twitter, Linear, Railway, etc.) via the Model Context Protocol.",
+			"After listing, use mcp_discover(server) to get tool schemas, then mcp_call(server, tool, args) to invoke.",
+		],
+		parameters: Type.Object({
+			refresh: Type.Optional(
+				Type.Boolean({ description: "Force refresh the server list (default: use cache)" }),
+			),
+		}),
+
+		async execute(_id, params) {
+			if (params.refresh) configCache = null;
+
+			const servers = readConfigs();
+			return {
+				content: [{ type: "text", text: formatServerList(servers) }],
+				details: {
+					serverCount: servers.length,
+					cached: !params.refresh && configCache !== null,
+				},
+			};
+		},
+
+		renderCall(args, theme) {
+			let text = theme.fg("toolTitle", theme.bold("mcp_servers"));
+			if (args.refresh) text += theme.fg("warning", " (refresh)");
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { isPartial }, theme) {
+			if (isPartial) return new Text(theme.fg("warning", "Reading MCP config..."), 0, 0);
+			const d = result.details as { serverCount: number } | undefined;
+			return new Text(
+				theme.fg("success", `${d?.serverCount ?? 0} servers configured`),
+				0,
+				0,
+			);
+		},
+	});
+
+	// ── mcp_discover ─────────────────────────────────────────────────────────
+
+	pi.registerTool({
+		name: "mcp_discover",
+		label: "MCP Discover",
+		description:
+			"Get detailed tool signatures and JSON schemas for a specific MCP server. " +
+			"Connects to the server on first call (lazy connection). " +
+			"Use this to understand what tools a server provides and what arguments they accept " +
+			"before calling them with mcp_call.",
+		promptSnippet:
+			"Get tool schemas for a specific MCP server before calling its tools",
+		promptGuidelines: [
+			"Call mcp_discover with a server name to see the full tool signatures before calling mcp_call.",
+			"The schemas show required and optional parameters with types and descriptions.",
+		],
+		parameters: Type.Object({
+			server: Type.String({
+				description:
+					"MCP server name (from mcp_servers output), e.g. 'railway', 'twitter-mcp', 'linear'",
+			}),
+		}),
+
+		async execute(_id, params, signal) {
+			try {
+				// Return cached tools if available
+				const cached = toolCache.get(params.server);
+				if (cached) {
+					const text = formatToolList(params.server, cached);
+					const truncation = truncateHead(text, { maxLines: DEFAULT_MAX_LINES, maxBytes: DEFAULT_MAX_BYTES });
+					let finalText = truncation.content;
+					if (truncation.truncated) {
+						finalText += `\n\n[Truncated: ${truncation.outputLines}/${truncation.totalLines} lines (${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)})]`;
+					}
+					return {
+						content: [{ type: "text", text: finalText }],
+						details: { server: params.server, toolCount: cached.length, cached: true },
+					};
+				}
+
+				const client = await getOrConnect(params.server, signal);
+				const result = await client.listTools(undefined, { signal, timeout: 30000 });
+				const tools: McpToolSchema[] = (result.tools ?? []).map((t) => ({
+					name: t.name,
+					description: t.description ?? "",
+					inputSchema: t.inputSchema as Record<string, unknown> | undefined,
+				}));
+				toolCache.set(params.server, tools);
+
+				const text = formatToolList(params.server, tools);
+				const truncation = truncateHead(text, { maxLines: DEFAULT_MAX_LINES, maxBytes: DEFAULT_MAX_BYTES });
+				let finalText = truncation.content;
+				if (truncation.truncated) {
+					finalText += `\n\n[Truncated: ${truncation.outputLines}/${truncation.totalLines} lines (${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)})]`;
+				}
+
+				return {
+					content: [{ type: "text", text: finalText }],
+					details: { server: params.server, toolCount: tools.length, cached: false },
+				};
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				throw new Error(`Failed to discover tools for "${params.server}": ${msg}`);
+			}
+		},
+
+		renderCall(args, theme) {
+			let text = theme.fg("toolTitle", theme.bold("mcp_discover "));
+			text += theme.fg("accent", args.server);
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { isPartial }, theme) {
+			if (isPartial)
+				return new Text(theme.fg("warning", "Discovering tools..."), 0, 0);
+			const d = result.details as { server: string; toolCount: number } | undefined;
+			return new Text(
+				theme.fg("success", `${d?.toolCount ?? 0} tools`) +
+					theme.fg("dim", ` · ${d?.server}`),
+				0,
+				0,
+			);
+		},
+	});
+
+	// ── mcp_call ─────────────────────────────────────────────────────────────
+
+	pi.registerTool({
+		name: "mcp_call",
+		label: "MCP Call",
+		description:
+			"Call a tool on an MCP server. Provide the server name, tool name, and arguments. " +
+			"Connects to the server on first call (lazy connection). " +
+			"Use mcp_discover first to see available tools and their required arguments.",
+		promptSnippet: "Call a tool on an MCP server",
+		promptGuidelines: [
+			"Always use mcp_discover first to understand the tool's parameters before calling mcp_call.",
+			"Arguments are passed as a JSON object matching the tool's input schema.",
+		],
+		parameters: Type.Object({
+			server: Type.String({
+				description: "MCP server name, e.g. 'railway', 'twitter-mcp'",
+			}),
+			tool: Type.String({
+				description: "Tool name on that server, e.g. 'railway_list_projects'",
+			}),
+			args: Type.Optional(
+				Type.Record(Type.String(), Type.Unknown(), {
+					description:
+						"Tool arguments as key-value pairs matching the tool's input schema",
+				}),
+			),
+		}),
+
+		async execute(_id, params, signal) {
+			try {
+				const client = await getOrConnect(params.server, signal);
+				const result = await client.callTool(
+					{ name: params.tool, arguments: params.args ?? {} },
+					undefined,
+					{ signal, timeout: 60000 },
+				);
+
+				// Serialize result content to text
+				const contentItems = result.content as Array<{ type: string; text?: string }>;
+				const raw = contentItems
+					.map((c) => (c.type === "text" ? c.text ?? "" : JSON.stringify(c)))
+					.join("\n");
+
+				const truncation = truncateHead(raw, { maxLines: DEFAULT_MAX_LINES, maxBytes: DEFAULT_MAX_BYTES });
+				let finalText = truncation.content;
+				if (truncation.truncated) {
+					finalText += `\n\n[Output truncated: ${truncation.outputLines}/${truncation.totalLines} lines (${formatSize(truncation.outputBytes)} of ${formatSize(truncation.totalBytes)})]`;
+				}
+
+				return {
+					content: [{ type: "text", text: finalText }],
+					details: {
+						server: params.server,
+						tool: params.tool,
+						charCount: finalText.length,
+						truncated: truncation.truncated,
+					},
+				};
+			} catch (err: unknown) {
+				const msg = err instanceof Error ? err.message : String(err);
+				throw new Error(`MCP call failed: ${params.server}.${params.tool}\n${msg}`);
+			}
+		},
+
+		renderCall(args, theme) {
+			let text = theme.fg("toolTitle", theme.bold("mcp_call "));
+			text += theme.fg("accent", `${args.server}.${args.tool}`);
+			if (args.args && Object.keys(args.args).length > 0) {
+				const preview = Object.entries(args.args)
+					.slice(0, 3)
+					.map(([k, v]) => {
+						const val = typeof v === "string" ? v : JSON.stringify(v);
+						return `${k}:${val.length > 30 ? val.slice(0, 30) + "…" : val}`;
+					})
+					.join(" ");
+				text += " " + theme.fg("muted", preview);
+			}
+			return new Text(text, 0, 0);
+		},
+
+		renderResult(result, { isPartial, expanded }, theme) {
+			if (isPartial) return new Text(theme.fg("warning", "Calling MCP tool..."), 0, 0);
+
+			const d = result.details as {
+				server: string;
+				tool: string;
+				charCount: number;
+				truncated: boolean;
+			} | undefined;
+
+			let text = theme.fg("success", `✓ ${d?.server}.${d?.tool}`);
+			text += theme.fg("dim", ` · ${(d?.charCount ?? 0).toLocaleString()} chars`);
+			if (d?.truncated) text += theme.fg("warning", " · truncated");
+
+			if (expanded) {
+				const content = result.content[0];
+				if (content?.type === "text") {
+					const preview = content.text.split("\n").slice(0, 15).join("\n");
+					text += "\n\n" + theme.fg("dim", preview);
+				}
+			}
+
+			return new Text(text, 0, 0);
+		},
+	});
+
+	// ── Lifecycle ─────────────────────────────────────────────────────────────
+
+	pi.on("session_start", async (_event, ctx) => {
+		const servers = readConfigs();
+		if (servers.length > 0) {
+			ctx.ui.notify(`MCP client ready — ${servers.length} server(s) configured`, "info");
+		}
+	});
+
+	pi.on("session_shutdown", async () => {
+		await closeAll();
+	});
+
+	pi.on("session_switch", async () => {
+		await closeAll();
+		configCache = null;
+	});
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.29.0-dev.49d972f",
+  "version": "2.29.0-dev.77f06e2",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {

package/packages/pi-coding-agent/dist/core/extensions/loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../src/core/extensions/loader.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAsBH,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAIhE,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAChG,OAAO,KAAK,EACX,SAAS,EAET,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EAKpB,MAAM,YAAY,CAAC;AA6FpB;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,gBAAgB,CAkCzD;AA6LD;;GAEG;AACH,wBAAsB,wBAAwB,CAC7C,OAAO,EAAE,gBAAgB,EACzB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,gBAAgB,EACzB,aAAa,SAAa,GACxB,OAAO,CAAC,SAAS,CAAC,CAKpB;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAyBrH;AA+GD;;GAEG;AACH,wBAAsB,yBAAyB,CAC9C,eAAe,EAAE,MAAM,EAAE,EACzB,GAAG,EAAE,MAAM,EACX,QAAQ,GAAE,MAAsB,EAChC,QAAQ,CAAC,EAAE,QAAQ,GACjB,OAAO,CAAC,oBAAoB,CAAC,CAoD/B"}
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../../src/core/extensions/loader.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAyBH,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAIhE,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,0BAA0B,EAAE,MAAM,oBAAoB,CAAC;AAChG,OAAO,KAAK,EACX,SAAS,EAET,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EAKpB,MAAM,YAAY,CAAC;AAuGpB;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,gBAAgB,CAkCzD;AA6LD;;GAEG;AACH,wBAAsB,wBAAwB,CAC7C,OAAO,EAAE,gBAAgB,EACzB,GAAG,EAAE,MAAM,EACX,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,gBAAgB,EACzB,aAAa,SAAa,GACxB,OAAO,CAAC,SAAS,CAAC,CAKpB;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAyBrH;AA+GD;;GAEG;AACH,wBAAsB,yBAAyB,CAC9C,eAAe,EAAE,MAAM,EAAE,EACzB,GAAG,EAAE,MAAM,EACX,QAAQ,GAAE,MAAsB,EAChC,QAAQ,CAAC,EAAE,QAAQ,GACjB,OAAO,CAAC,oBAAoB,CAAC,CAoD/B"}

package/packages/pi-coding-agent/dist/core/extensions/loader.js

@@ -18,6 +18,9 @@ import * as _bundledPiTui from "@gsd/pi-tui";
 // The virtualModules option then makes them available to extensions.
 import * as _bundledTypebox from "@sinclair/typebox";
 import * as _bundledYaml from "yaml";
+import * as _bundledMcpClient from "@modelcontextprotocol/sdk/client";
+import * as _bundledMcpStdio from "@modelcontextprotocol/sdk/client/stdio.js";
+import * as _bundledMcpStreamableHttp from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { getAgentDir, isBunBinary } from "../../config.js";
 // NOTE: This import works because loader.ts exports are NOT re-exported from index.ts,
 // avoiding a circular dependency. Extensions can import from @gsd/pi-coding-agent.
@@ -35,6 +38,11 @@ const VIRTUAL_MODULES = {
     "@gsd/pi-ai/oauth": _bundledPiAiOauth,
     "@gsd/pi-coding-agent": _bundledPiCodingAgent,
     "yaml": _bundledYaml,
+    "@modelcontextprotocol/sdk/client": _bundledMcpClient,
+    "@modelcontextprotocol/sdk/client/stdio": _bundledMcpStdio,
+    "@modelcontextprotocol/sdk/client/stdio.js": _bundledMcpStdio,
+    "@modelcontextprotocol/sdk/client/streamableHttp": _bundledMcpStreamableHttp,
+    "@modelcontextprotocol/sdk/client/streamableHttp.js": _bundledMcpStreamableHttp,
     // Aliases for external PI ecosystem packages that import from the original scope
     "@mariozechner/pi-agent-core": _bundledPiAgentCore,
     "@mariozechner/pi-tui": _bundledPiTui,
@@ -73,6 +81,11 @@ function getAliases() {
         "@gsd/pi-ai/oauth": resolveWorkspaceOrImport("ai/dist/oauth.js", "@gsd/pi-ai/oauth"),
         "@sinclair/typebox": typeboxRoot,
         "yaml": yamlRoot,
+        "@modelcontextprotocol/sdk/client": require.resolve("@modelcontextprotocol/sdk/client"),
+        "@modelcontextprotocol/sdk/client/stdio": require.resolve("@modelcontextprotocol/sdk/client/stdio.js"),
+        "@modelcontextprotocol/sdk/client/stdio.js": require.resolve("@modelcontextprotocol/sdk/client/stdio.js"),
+        "@modelcontextprotocol/sdk/client/streamableHttp": require.resolve("@modelcontextprotocol/sdk/client/streamableHttp.js"),
+        "@modelcontextprotocol/sdk/client/streamableHttp.js": require.resolve("@modelcontextprotocol/sdk/client/streamableHttp.js"),
         // Aliases for external PI ecosystem packages that import from the original scope
         "@mariozechner/pi-coding-agent": packageIndex,
         "@mariozechner/pi-agent-core": resolveWorkspaceOrImport("agent/dist/index.js", "@gsd/pi-agent-core"),