lsd-pi 1.3.9 → 1.3.10

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

@@ -1,8 +1,8 @@
 /**
  * MCP Client Extension — Native MCP server integration for pi
  *
- * Provides on-demand access to MCP servers configured in project files
- * (.mcp.json, .lsd/mcp.json, with legacy .gsd/mcp.json fallback) using the
+ * Provides on-demand access to MCP servers configured in global (~/.lsd/mcp.json)
+ * and project files (.mcp.json, .lsd/mcp.json, with legacy .gsd/mcp.json fallback) using the
  * @modelcontextprotocol/sdk Client directly — no external CLI dependency
  * required.
  *
@@ -18,7 +18,9 @@ import { Client } from "@modelcontextprotocol/sdk/client";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
+import { McpManagerComponent } from "./mcp-manager-component.js";
 // ─── Connection Manager ───────────────────────────────────────────────────────
 const connections = new Map();
 let configCache = null;
@@ -99,6 +101,7 @@ function readConfigs() {
         join(process.cwd(), ".mcp.json"),
         join(process.cwd(), ".lsd", "mcp.json"),
         join(process.cwd(), ".gsd", "mcp.json"),
+        join(homedir(), ".lsd", "mcp.json"),
     ];
     for (const configPath of configPaths) {
         try {
@@ -177,8 +180,6 @@ async function getOrConnect(name, signal) {
         throw new Error(`Unknown MCP server: "${name}". Use mcp_servers to list available servers.`);
     if (!config.enabled)
         throw new Error(`Server "${config.name}" is disabled. Use /mcp enable ${config.name}.`);
-    // Always use config.name as the canonical cache key so that variant
-    // casing / whitespace still hits the same connection.
     const existing = connections.get(config.name);
     if (existing)
         return existing.client;
@@ -206,6 +207,97 @@ async function getOrConnect(name, signal) {
     connections.set(config.name, { client, transport });
     return client;
 }
+function mapToolSchemas(tools) {
+    return tools.map((tool) => ({
+        name: tool.name,
+        description: tool.description ?? "",
+        inputSchema: tool.inputSchema,
+    }));
+}
+function shouldRetryMcpOperation(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/unknown mcp server/i.test(message))
+        return false;
+    if (/is disabled/i.test(message))
+        return false;
+    if (/unsupported transport/i.test(message))
+        return false;
+    if (/abort|cancel/i.test(message))
+        return false;
+    return true;
+}
+async function listServerTools(name, signal, options) {
+    const canonicalName = getCanonicalServerName(name);
+    if (options?.useCache !== false) {
+        const cached = toolCache.get(canonicalName);
+        if (cached) {
+            return { canonicalName, tools: cached, cached: true };
+        }
+    }
+    let attempt = 0;
+    while (attempt < 2) {
+        try {
+            if (attempt === 0 && options?.forceReconnect) {
+                await closeServerConnection(canonicalName);
+            }
+            if (attempt > 0) {
+                await closeServerConnection(canonicalName);
+            }
+            const client = await getOrConnect(canonicalName, signal);
+            const result = await client.listTools(undefined, { signal, timeout: 30000 });
+            const tools = mapToolSchemas(result.tools ?? []);
+            toolCache.set(canonicalName, tools);
+            return { canonicalName, tools, cached: false };
+        }
+        catch (error) {
+            attempt += 1;
+            await closeServerConnection(canonicalName);
+            if (attempt >= 2 || !shouldRetryMcpOperation(error)) {
+                throw error;
+            }
+        }
+    }
+    throw new Error(`Failed to list tools for ${canonicalName}`);
+}
+async function callServerTool(serverName, toolName, args, signal) {
+    const canonicalServer = getCanonicalServerName(serverName);
+    let attempt = 0;
+    while (attempt < 2) {
+        try {
+            if (attempt > 0) {
+                await closeServerConnection(canonicalServer);
+            }
+            const client = await getOrConnect(canonicalServer, signal);
+            const result = await client.callTool({ name: toolName, arguments: args }, undefined, { signal, timeout: 60000 });
+            return { canonicalServer, result };
+        }
+        catch (error) {
+            attempt += 1;
+            await closeServerConnection(canonicalServer);
+            if (attempt >= 2 || !shouldRetryMcpOperation(error)) {
+                throw error;
+            }
+        }
+    }
+    throw new Error(`Failed to call ${canonicalServer}.${toolName}`);
+}
+async function warmupServer(name, signal) {
+    try {
+        const { canonicalName, tools } = await listServerTools(name, signal, { useCache: false });
+        return {
+            name: canonicalName,
+            status: "connected",
+            toolCount: tools.length,
+        };
+    }
+    catch (error) {
+        return {
+            name: getCanonicalServerName(name),
+            status: "error",
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
 async function warmupEnabledServers() {
     if (warmupPromise)
         return warmupPromise;
@@ -213,31 +305,7 @@ async function warmupEnabledServers() {
         const enabledServers = readConfigs().filter((server) => server.enabled);
         if (enabledServers.length === 0)
             return [];
-        const results = await Promise.allSettled(enabledServers.map(async (server) => {
-            const client = await getOrConnect(server.name);
-            const result = await client.listTools(undefined, { timeout: 30000 });
-            const tools = (result.tools ?? []).map((tool) => ({
-                name: tool.name,
-                description: tool.description ?? "",
-                inputSchema: tool.inputSchema,
-            }));
-            toolCache.set(server.name, tools);
-            return {
-                name: server.name,
-                status: "connected",
-                toolCount: tools.length,
-            };
-        }));
-        return results.map((result, index) => {
-            if (result.status === "fulfilled") {
-                return result.value;
-            }
-            return {
-                name: enabledServers[index]?.name ?? `server-${index + 1}`,
-                status: "error",
-                error: result.reason instanceof Error ? result.reason.message : String(result.reason),
-            };
-        });
+        return Promise.all(enabledServers.map((server) => warmupServer(server.name)));
     })();
     try {
         return await warmupPromise;
@@ -264,10 +332,41 @@ async function reloadMcpState() {
     await closeAll();
     configCache = null;
 }
+function getSourceLabel(sourcePath) {
+    if (!sourcePath)
+        return "";
+    return sourcePath.startsWith(homedir()) ? "global" : "project";
+}
+function getManagerServerInfo() {
+    return readConfigs().map((server) => ({
+        name: server.name,
+        enabled: server.enabled,
+        connected: connections.has(server.name),
+        transport: server.transport,
+        toolCount: toolCache.get(server.name)?.length ?? 0,
+        sourceLabel: getSourceLabel(server.sourcePath),
+    }));
+}
 // ─── Formatters ───────────────────────────────────────────────────────────────
 function formatServerList(servers) {
-    if (servers.length === 0)
-        return "No MCP servers configured. Add servers to .mcp.json or .lsd/mcp.json.";
+    if (servers.length === 0) {
+        return [
+            "No MCP servers configured.\n",
+            "Configuration guide:",
+            "  Global (all projects):   ~/.lsd/mcp.json",
+            "  Project-level:           .mcp.json or .lsd/mcp.json\n",
+            'Example ~/.lsd/mcp.json:',
+            '{',
+            '  "mcpServers": {',
+            '    "my-server": {',
+            '      "command": "path/to/server",',
+            '      "args": ["--working-dir", "."]',
+            '    }',
+            '  }',
+            '}\n',
+            "After editing, run: /mcp reload",
+        ].join("\n");
+    }
     const lines = ["MCP servers\n"];
     for (const s of servers) {
         const connected = connections.has(s.name) ? "yes" : "no";
@@ -278,11 +377,13 @@ function formatServerList(servers) {
         lines.push(`  connected: ${connected}`);
         lines.push(`  transport: ${s.transport}`);
         lines.push(`  tools: ${tools}`);
-        if (s.sourcePath)
-            lines.push(`  source: ${basename(s.sourcePath)}`);
+        if (s.sourcePath) {
+            lines.push(`  source: ${getSourceLabel(s.sourcePath)} — ${basename(s.sourcePath)}`);
+        }
         lines.push("");
     }
     lines.push("Hints:");
+    lines.push("  /mcp");
     lines.push("  /mcp inspect <server>");
     lines.push("  /mcp enable <server>");
     lines.push("  /mcp disable <server>");
@@ -319,6 +420,39 @@ function formatMcpCommandHelp() {
         "  /mcp reload",
     ].join("\n");
 }
+async function openMcpManager(ctx) {
+    await ctx.ui.custom((tui, theme, _keybindings, done) => new McpManagerComponent({
+        getServers: () => getManagerServerInfo(),
+        onToggle: async (name) => {
+            const config = getServerConfig(name);
+            if (!config)
+                return null;
+            const result = await setServerEnabled(name, !config.enabled);
+            const updated = getServerConfig(result.canonicalName);
+            if (updated?.enabled) {
+                await warmupServer(updated.name);
+            }
+            return getManagerServerInfo().find((server) => server.name === result.canonicalName) ?? null;
+        },
+        onInspect: async (name) => {
+            const { canonicalName, tools } = await listServerTools(name, undefined, { useCache: true });
+            return formatToolList(canonicalName, tools);
+        },
+        onReconnect: async (name) => {
+            const { canonicalName } = await listServerTools(name, undefined, { forceReconnect: true, useCache: false });
+            return getManagerServerInfo().find((server) => server.name === canonicalName) ?? null;
+        },
+        onClose: () => done(undefined),
+        requestRender: () => tui.requestRender(),
+    }, theme), {
+        overlay: true,
+        overlayOptions: {
+            width: "80%",
+            maxHeight: "70%",
+            anchor: "center",
+        },
+    });
+}
 async function handleMcpCommand(args, ctx) {
     const trimmed = args.trim();
     const parts = trimmed.split(/\s+/).filter(Boolean);
@@ -339,20 +473,8 @@ async function handleMcpCommand(args, ctx) {
             return;
         }
         const canonicalName = config.name;
-        const cached = toolCache.get(canonicalName);
-        if (cached) {
-            ctx.ui.notify(formatToolList(canonicalName, cached), "info");
-            return;
-        }
         try {
-            const client = await getOrConnect(canonicalName);
-            const result = await client.listTools(undefined, { timeout: 30000 });
-            const tools = (result.tools ?? []).map((tool) => ({
-                name: tool.name,
-                description: tool.description ?? "",
-                inputSchema: tool.inputSchema,
-            }));
-            toolCache.set(canonicalName, tools);
+            const { tools } = await listServerTools(canonicalName, undefined, { useCache: true });
             ctx.ui.notify(formatToolList(canonicalName, tools), "info");
         }
         catch (error) {
@@ -374,9 +496,8 @@ async function handleMcpCommand(args, ctx) {
             const changeText = result.changed ? action : `already ${action}`;
             ctx.ui.notify(`MCP server ${result.canonicalName} ${changeText}.`, "info");
             if (enabled) {
-                const warmupResults = await warmupEnabledServers();
-                const warmupResult = warmupResults.find((entry) => entry.name === result.canonicalName);
-                if (warmupResult?.status === "error") {
+                const warmupResult = await warmupServer(result.canonicalName);
+                if (warmupResult.status === "error") {
                     ctx.ui.notify(`Failed to connect ${result.canonicalName}: ${warmupResult.error}`, "error");
                 }
             }
@@ -446,6 +567,10 @@ export default function (pi) {
             return [];
         },
         handler: async (args, ctx) => {
+            if (!args.trim() && typeof ctx.ui.custom === "function") {
+                await openMcpManager(ctx);
+                return;
+            }
             await handleMcpCommand(args, ctx);
         },
     });
@@ -453,7 +578,8 @@ export default function (pi) {
     pi.registerTool({
         name: "mcp_servers",
         label: "MCP Servers",
-        description: "List all available MCP servers configured in project files (.mcp.json, .lsd/mcp.json, legacy .gsd/mcp.json). " +
+        description: "List all available MCP servers from global (~/.lsd/mcp.json) and project-level " +
+            "(.mcp.json, .lsd/mcp.json, legacy .gsd/mcp.json) config files. " +
             "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: [
@@ -510,29 +636,7 @@ export default function (pi) {
         }),
         async execute(_id, params, signal) {
             try {
-                const canonicalServer = getCanonicalServerName(params.server);
-                // Return cached tools if available
-                const cached = toolCache.get(canonicalServer);
-                if (cached) {
-                    const text = formatToolList(canonicalServer, 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: canonicalServer, toolCount: cached.length, cached: true },
-                    };
-                }
-                const client = await getOrConnect(canonicalServer, signal);
-                const result = await client.listTools(undefined, { signal, timeout: 30000 });
-                const tools = (result.tools ?? []).map((t) => ({
-                    name: t.name,
-                    description: t.description ?? "",
-                    inputSchema: t.inputSchema,
-                }));
-                toolCache.set(canonicalServer, tools);
+                const { canonicalName: canonicalServer, tools, cached } = await listServerTools(params.server, signal, { useCache: true });
                 const text = formatToolList(canonicalServer, tools);
                 const truncation = truncateHead(text, { maxLines: DEFAULT_MAX_LINES, maxBytes: DEFAULT_MAX_BYTES });
                 let finalText = truncation.content;
@@ -541,7 +645,7 @@ export default function (pi) {
                 }
                 return {
                     content: [{ type: "text", text: finalText }],
-                    details: { server: canonicalServer, toolCount: tools.length, cached: false },
+                    details: { server: canonicalServer, toolCount: tools.length, cached },
                 };
             }
             catch (err) {
@@ -588,10 +692,7 @@ export default function (pi) {
         }),
         async execute(_id, params, signal) {
             try {
-                const canonicalServer = getCanonicalServerName(params.server);
-                const client = await getOrConnect(canonicalServer, signal);
-                const result = await client.callTool({ name: params.tool, arguments: params.args ?? {} }, undefined, { signal, timeout: 60000 });
-                // Serialize result content to text
+                const { canonicalServer, result } = await callServerTool(params.server, params.tool, params.args ?? {}, signal);
                 const contentItems = result.content;
                 const raw = contentItems
                     .map((c) => (c.type === "text" ? c.text ?? "" : JSON.stringify(c)))
@@ -654,20 +755,27 @@ export default function (pi) {
         const servers = readConfigs();
         const enabledServers = servers.filter((server) => server.enabled);
         if (servers.length > 0) {
-            ctx.ui.notify(`MCP client ready — ${enabledServers.length}/${servers.length} server(s) enabled`, "info");
+            ctx.ui.notify(`MCP client ready — ${enabledServers.length}/${servers.length} server(s) enabled, warming up…`, "info");
         }
         if (enabledServers.length === 0)
             return;
-        void warmupEnabledServers().then((results) => {
+        try {
+            const warmupTimeout = new Promise((_, reject) => setTimeout(() => reject(new Error("warmup timed out after 30s")), 30_000));
+            const results = await Promise.race([warmupEnabledServers(), warmupTimeout]);
+            const succeeded = results.filter((entry) => entry.status === "connected");
             const failed = results.filter((entry) => entry.status === "error");
+            if (succeeded.length > 0) {
+                ctx.ui.notify(`MCP autoconnect complete — ${succeeded.length} server(s) connected`, "success");
+            }
             if (failed.length > 0) {
                 const failureSummary = failed.map((entry) => `${entry.name}: ${entry.error}`).join("; ");
                 ctx.ui.notify(`MCP autoconnect partial failure — ${failureSummary}`, "warning");
             }
-        }).catch((error) => {
+        }
+        catch (error) {
             const message = error instanceof Error ? error.message : String(error);
             ctx.ui.notify(`MCP autoconnect failed: ${message}`, "warning");
-        });
+        }
     });
     pi.on("session_shutdown", async () => {
         warmupPromise = null;
@@ -675,6 +783,6 @@ export default function (pi) {
     });
     pi.on("session_switch", async () => {
         await reloadMcpState();
-        void warmupEnabledServers();
+        await warmupEnabledServers();
     });
 }

package/dist/resources/extensions/mcp-client/mcp-manager-component.js

@@ -0,0 +1,220 @@
+import { Key, SelectList, matchesKey, truncateToWidth } from "@gsd/pi-tui";
+function getSelectListTheme(theme) {
+    return {
+        selectedPrefix: (text) => theme.fg("accent", text),
+        selectedText: (text) => theme.fg("accent", text),
+        description: (text) => theme.fg("muted", text),
+        scrollInfo: (text) => theme.fg("dim", text),
+        noMatch: (text) => theme.fg("warning", text),
+    };
+}
+function serversToItems(servers) {
+    return servers.map((server) => ({
+        value: server.name,
+        label: server.name,
+        description: [
+            server.enabled ? "enabled" : "disabled",
+            server.transport,
+            server.connected ? "● connected" : "○ offline",
+            `${server.toolCount} tools`,
+            server.sourceLabel || undefined,
+        ].filter(Boolean).join("  "),
+    }));
+}
+export class McpManagerComponent {
+    theme;
+    callbacks;
+    selectList;
+    mode = "list";
+    inspectServerName = "";
+    inspectLines = [];
+    inspectScrollOffset = 0;
+    statusMessage = "";
+    busy = false;
+    statusTimeout = null;
+    constructor(callbacks, theme) {
+        this.callbacks = callbacks;
+        this.theme = theme;
+        this.selectList = new SelectList([], 8, getSelectListTheme(theme));
+        this.bindSelectList();
+        this.refreshList();
+    }
+    invalidate() {
+        this.selectList.invalidate();
+    }
+    dispose() {
+        if (this.statusTimeout) {
+            clearTimeout(this.statusTimeout);
+            this.statusTimeout = null;
+        }
+    }
+    getMode() {
+        return this.mode;
+    }
+    handleInput(data) {
+        if (this.mode === "inspect") {
+            this.handleInspectInput(data);
+            return;
+        }
+        if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c"))) {
+            this.callbacks.onClose();
+            return;
+        }
+        if (data === "i") {
+            void this.handleInspect();
+            return;
+        }
+        if (data === "r") {
+            void this.handleReconnect();
+            return;
+        }
+        this.selectList.handleInput(data);
+        this.callbacks.requestRender();
+    }
+    render(width) {
+        const lines = [];
+        const add = (line = "") => lines.push(truncateToWidth(line, width));
+        const divider = this.theme.fg("border", "─".repeat(Math.max(width, 1)));
+        add(divider);
+        if (this.mode === "inspect") {
+            add(this.theme.bold(this.theme.fg("toolTitle", ` MCP Tools · ${this.inspectServerName}`)) +
+                this.theme.fg("dim", "  esc/q: back  ↑↓/pgup/pgdn/home/end: scroll"));
+            add("");
+            const bodyHeight = Math.max(8, width > 0 ? 18 : 8);
+            const maxOffset = Math.max(0, this.inspectLines.length - bodyHeight);
+            this.inspectScrollOffset = Math.max(0, Math.min(this.inspectScrollOffset, maxOffset));
+            const visibleLines = this.inspectLines.slice(this.inspectScrollOffset, this.inspectScrollOffset + bodyHeight);
+            for (const line of visibleLines)
+                add(line);
+            if (visibleLines.length === 0)
+                add(this.theme.fg("dim", "  No tool information"));
+            add("");
+            add(divider);
+            add(this.theme.fg("dim", ` ${this.inspectLines.length} lines`));
+            return lines;
+        }
+        add(this.theme.bold(this.theme.fg("toolTitle", " MCP Servers")) +
+            this.theme.fg("dim", "  ↑↓ navigate  enter: toggle  i: inspect  r: reconnect  esc: close"));
+        add("");
+        lines.push(...this.selectList.render(width));
+        add("");
+        add(divider);
+        const servers = this.callbacks.getServers();
+        const enabled = servers.filter((server) => server.enabled).length;
+        let footer = this.theme.fg("dim", ` ${servers.length} servers · ${enabled} enabled`);
+        if (this.busy)
+            footer += this.theme.fg("accent", " · working…");
+        if (this.statusMessage)
+            footer += this.theme.fg("accent", ` — ${this.statusMessage}`);
+        add(footer);
+        return lines;
+    }
+    bindSelectList() {
+        this.selectList.onSelect = () => {
+            void this.handleToggle();
+        };
+        this.selectList.onCancel = () => {
+            this.callbacks.onClose();
+        };
+    }
+    refreshList(preferredName) {
+        const currentSelected = preferredName ?? this.selectList.getSelectedItem()?.value;
+        this.selectList = new SelectList(serversToItems(this.callbacks.getServers()), 8, getSelectListTheme(this.theme));
+        this.bindSelectList();
+        if (currentSelected) {
+            const items = this.callbacks.getServers();
+            const index = items.findIndex((item) => item.name === currentSelected);
+            if (index >= 0)
+                this.selectList.setSelectedIndex(index);
+        }
+        this.callbacks.requestRender();
+    }
+    setStatus(message) {
+        this.statusMessage = message;
+        this.callbacks.requestRender();
+        if (this.statusTimeout)
+            clearTimeout(this.statusTimeout);
+        if (!message)
+            return;
+        this.statusTimeout = setTimeout(() => {
+            this.statusMessage = "";
+            this.callbacks.requestRender();
+        }, 3000);
+        this.statusTimeout.unref?.();
+    }
+    getSelectedName() {
+        return this.selectList.getSelectedItem()?.value;
+    }
+    async runBusy(task) {
+        if (this.busy)
+            return;
+        this.busy = true;
+        this.callbacks.requestRender();
+        try {
+            await task();
+        }
+        finally {
+            this.busy = false;
+            this.callbacks.requestRender();
+        }
+    }
+    async handleToggle() {
+        const name = this.getSelectedName();
+        if (!name)
+            return;
+        await this.runBusy(async () => {
+            this.setStatus(`Toggling ${name}...`);
+            const updated = await this.callbacks.onToggle(name);
+            this.refreshList(updated?.name ?? name);
+            if (updated) {
+                this.setStatus(`${updated.name}: ${updated.enabled ? "enabled" : "disabled"}`);
+            }
+        });
+    }
+    async handleInspect() {
+        const name = this.getSelectedName();
+        if (!name)
+            return;
+        await this.runBusy(async () => {
+            this.setStatus(`Loading tools for ${name}...`);
+            const text = await this.callbacks.onInspect(name);
+            this.inspectServerName = name;
+            this.inspectLines = text.split("\n");
+            this.inspectScrollOffset = 0;
+            this.mode = "inspect";
+            this.setStatus("");
+        });
+    }
+    async handleReconnect() {
+        const name = this.getSelectedName();
+        if (!name)
+            return;
+        await this.runBusy(async () => {
+            this.setStatus(`Reconnecting ${name}...`);
+            const updated = await this.callbacks.onReconnect(name);
+            this.refreshList(updated?.name ?? name);
+            this.setStatus(updated ? `${updated.name}: reconnected` : `${name}: reconnect failed`);
+        });
+    }
+    handleInspectInput(data) {
+        if (matchesKey(data, Key.escape) || data === "q") {
+            this.mode = "list";
+            this.callbacks.requestRender();
+            return;
+        }
+        const page = 12;
+        if (matchesKey(data, Key.up))
+            this.inspectScrollOffset -= 1;
+        else if (matchesKey(data, Key.down))
+            this.inspectScrollOffset += 1;
+        else if (matchesKey(data, Key.pageUp))
+            this.inspectScrollOffset -= page;
+        else if (matchesKey(data, Key.pageDown))
+            this.inspectScrollOffset += page;
+        else if (matchesKey(data, Key.home))
+            this.inspectScrollOffset = 0;
+        else if (matchesKey(data, Key.end))
+            this.inspectScrollOffset = Number.MAX_SAFE_INTEGER;
+        this.callbacks.requestRender();
+    }
+}