@yagni-app/code 1.0.4 → 1.0.6

package/dist/extension/mcp/manager.js

@@ -0,0 +1,273 @@
+/**
+ * The MCP manager: owns one live client per configured server, tracks
+ * connection state, and exposes connect/reconnect/disconnect operations used
+ * by both the /mcp panel and session startup. Connection state is what the
+ * panel renders; tool/prompt registration is layered on top by tools.ts /
+ * prompts.ts once a server connects.
+ *
+ * Everything here is fail-soft: a server that fails to connect lands in
+ * `failed` with its error message, never blocking the session or the other
+ * servers. `MCP_TIMEOUT` (connect, ms) and `MCP_TOOL_TIMEOUT` (call, ms) are
+ * honored per Claude Code's env parity.
+ */
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { UnauthorizedError } from "@modelcontextprotocol/sdk/client/auth.js";
+import { expandServerEnv } from "./config.js";
+import { DEFAULT_CONNECT_TIMEOUT_MS, transportFor } from "./transports.js";
+import { authenticate, authProviderForServer, instrumentOAuthFetch, AuthenticationCancelledError } from "./auth.js";
+export function connectTimeoutFromEnv(env, fallback = DEFAULT_CONNECT_TIMEOUT_MS) {
+    const raw = env.MCP_TIMEOUT;
+    if (!raw)
+        return fallback;
+    const n = Number(raw);
+    return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+export function toolTimeoutFromEnv(env) {
+    const raw = env.MCP_TOOL_TIMEOUT;
+    if (!raw)
+        return undefined;
+    const n = Number(raw);
+    return Number.isFinite(n) && n > 0 ? n : undefined;
+}
+export class McpManager {
+    servers = new Map();
+    events;
+    connectTimeoutMs;
+    env;
+    closed = false;
+    constructor(opts = {}) {
+        this.events = opts.events ?? {};
+        this.connectTimeoutMs = opts.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+        this.env = opts.env ?? process.env;
+    }
+    list() {
+        return [...this.servers.values()];
+    }
+    get(name) {
+        return this.servers.get(name);
+    }
+    /** Registers a server without connecting (panel listing, kill-switch states). */
+    register(name, scope, config, status = "disabled") {
+        const existing = this.servers.get(name);
+        if (existing)
+            return existing;
+        const server = { name, scope, config, status };
+        this.servers.set(name, server);
+        return server;
+    }
+    async connect(name) {
+        if (this.closed)
+            return undefined;
+        const server = this.servers.get(name);
+        if (!server)
+            return undefined;
+        if (server.status === "connected")
+            return server;
+        this.setStatus(server, "connecting");
+        // Expand ${VAR} at connect time only: the stored config (panel display,
+        // OAuth auth-store keys) stays raw; the wire gets the resolved values.
+        // A missing var fails fast with a clear error instead of sending a
+        // literal "${VAR}" header (which the SDK retries until timeout).
+        const expanded = expandServerEnv(server.config, this.env);
+        if (expanded.missingVars.length > 0) {
+            server.error = `missing environment variable(s): ${expanded.missingVars.join(", ")} — set ${expanded.missingVars.join(", ")} and reconnect via /mcp`;
+            this.setStatus(server, "failed");
+            return server;
+        }
+        const oauth = isOAuthServer(server.config);
+        const authProvider = oauth ? authProviderForServer(name, server.config) : undefined;
+        const fetchImpl = oauth ? instrumentOAuthFetch(name, fetch) : undefined;
+        const client = new Client({ name: "yagni-code", version: "1.0" });
+        let transport;
+        try {
+            // Inside the try: an expanded URL that is not a valid URL throws from
+            // `new URL()` in transportFor and must land in `failed`, not escape the
+            // manager. Errors are sanitized before display — an expanded value that
+            // an SDK error echoes back must never reach the panel verbatim.
+            transport = transportFor(expanded.config, authProvider, fetchImpl);
+            await withTimeout(client.connect(transport), this.connectTimeoutMs, `connect timed out after ${this.connectTimeoutMs}ms`);
+        }
+        catch (err) {
+            await safeClose(client);
+            const message = err instanceof Error ? err.message : String(err);
+            server.error = sanitizeError(message);
+            this.setStatus(server, err instanceof UnauthorizedError ? "needs_auth" : classifyFailure(message));
+            return server;
+        }
+        server.client = client;
+        server.transport = transport;
+        server.connectedAt = Date.now();
+        server.error = undefined;
+        this.setStatus(server, "connected");
+        return server;
+    }
+    async disconnect(name) {
+        const server = this.servers.get(name);
+        if (!server)
+            return;
+        if (server.client)
+            await safeClose(server.client);
+        server.client = undefined;
+        server.transport = undefined;
+        if (server.status !== "disabled")
+            this.setStatus(server, "disabled");
+    }
+    /** Reconnect with bounded attempts, panel-visible progress. */
+    async reconnect(name, maxAttempts = 3) {
+        const server = this.servers.get(name);
+        if (!server)
+            return undefined;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            server.reconnectAttempt = attempt;
+            this.setStatus(server, "reconnecting");
+            const result = await this.connect(name);
+            if (result && result.status === "connected") {
+                server.reconnectAttempt = undefined;
+                return result;
+            }
+            await sleep(Math.min(500 * 2 ** (attempt - 1), 2000));
+        }
+        server.reconnectAttempt = undefined;
+        return server;
+    }
+    /**
+     * Drive the interactive OAuth flow for a `needs_auth` server, then reconnect.
+     * The flow opens a browser and returns once tokens are persisted; a cancelled
+     * or failed flow leaves the server in `needs_auth` and returns its error.
+     * `signal` cancels the loopback wait (Esc / session abort) instead of holding
+     * the command handler for the full 5-minute timeout. `authDeps` is the same
+     * seam `authenticate` takes (openUrl/fetch) so tests drive the real path
+     * without a browser or network.
+     */
+    async authenticateServer(name, signal, authDeps = {}) {
+        const server = this.servers.get(name);
+        if (!server)
+            return undefined;
+        if (!isOAuthServer(server.config)) {
+            server.error = "this server does not use OAuth (stdio servers have no auth flow)";
+            this.setStatus(server, "failed");
+            return server;
+        }
+        // OAuth discovery + token exchange must hit the ${VAR}-expanded URL (the
+        // literal reference is not a resolvable endpoint); the raw config is still
+        // what authenticate() keys the auth store with. Missing vars fail here the
+        // same way connect() does — names only.
+        const expanded = expandServerEnv(server.config, this.env);
+        if (expanded.missingVars.length > 0) {
+            server.error = `missing environment variable(s): ${expanded.missingVars.join(", ")} — set ${expanded.missingVars.join(", ")} and reconnect via /mcp`;
+            this.setStatus(server, "failed");
+            return server;
+        }
+        try {
+            await authenticate(name, server.config, authDeps, {
+                signal,
+                serverUrl: expanded.config.url,
+            });
+        }
+        catch (err) {
+            if (err instanceof AuthenticationCancelledError) {
+                server.error = undefined;
+            }
+            else {
+                server.error = err instanceof Error ? err.message : String(err);
+            }
+            this.setStatus(server, "needs_auth");
+            return server;
+        }
+        return this.connect(name);
+    }
+    /** Closes every connected client. Called on session_shutdown (any reason). */
+    async closeAll() {
+        this.closed = true;
+        await Promise.all([...this.servers.keys()].map((name) => this.disconnect(name)));
+    }
+    setStatus(server, status) {
+        server.status = status;
+        this.events.onStateChange?.(server);
+        this.events.onLog?.(JSON.stringify({
+            ts: new Date().toISOString(),
+            server: server.name,
+            scope: server.scope,
+            status,
+            ...(server.error ? { error: sanitizeError(server.error) } : {}),
+        }));
+    }
+}
+/**
+ * One-off health check for a configured server, used by `yagni mcp list` /
+ * `get` and `yagni doctor`. Does NOT mutate manager state: it builds a fresh
+ * transport + client, connect()s against it, classifies the result, and closes
+ * the client. OAuth-capable (http/sse) servers get an auth provider so a fresh
+ * token (or the redirect-required `needs_auth`) is reported faithfully.
+ *
+ * Callers apply the approval gate themselves: a project-scope server that is
+ * undecided/disabled must be reported as such WITHOUT connecting (fail-closed,
+ * never spawn a process the user has not approved), so `probeServer` never
+ * asks about approval — it only ever connects what it is given.
+ */
+export async function probeServer(name, config, opts = {}) {
+    const timeoutMs = opts.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+    const expanded = expandServerEnv(config, opts.env ?? process.env);
+    if (expanded.missingVars.length > 0) {
+        return {
+            status: "failed",
+            error: `missing environment variable(s): ${expanded.missingVars.join(", ")} — set ${expanded.missingVars.join(", ")} and try again`,
+        };
+    }
+    const oauth = isOAuthServer(config);
+    const authProvider = oauth ? authProviderForServer(name, config) : undefined;
+    const fetchImpl = oauth ? instrumentOAuthFetch(name, fetch) : undefined;
+    const client = new Client({ name: "yagni-code", version: "1.0" });
+    try {
+        // transportFor inside the try: `new URL()` on a bad expanded URL must
+        // report `failed`, not throw out of the probe.
+        const transport = transportFor(expanded.config, authProvider, fetchImpl);
+        await withTimeout(client.connect(transport), timeoutMs, `connect timed out after ${timeoutMs}ms`);
+        return { status: "connected" };
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        const status = err instanceof UnauthorizedError ? "needs_auth" : classifyFailure(message);
+        return { status, error: sanitizeError(message) };
+    }
+    finally {
+        await safeClose(client);
+    }
+}
+/** 401/403 → needs_auth; everything else → failed. */
+export function classifyFailure(message) {
+    if (/\b(401|403)\b/.test(message) || /unauthorized|forbidden/i.test(message))
+        return "needs_auth";
+    return "failed";
+}
+export function sanitizeError(message) {
+    return message.replace(/(bearer|token|key|secret|password)[^\s]*/gi, "$1=REDACTED").slice(0, 500);
+}
+/** HTTP/SSE servers support OAuth; stdio servers do not. */
+function isOAuthServer(config) {
+    return config.type === "http" || config.type === "sse";
+}
+async function safeClose(client) {
+    try {
+        await client.close();
+    }
+    catch {
+        // best-effort close
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function withTimeout(promise, ms, message) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(message)), ms);
+        promise.then((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        }, (err) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}
+//# sourceMappingURL=manager.js.map

package/dist/extension/mcp/names.d.ts

@@ -0,0 +1,25 @@
+/**
+ * MCP server/tool name normalization + qualified-name building, ported from
+ * Claude Code's `services/mcp/{normalization,mcpStringUtils}.ts` so tool names
+ * (`mcp__<server>__<tool>`) are byte-identical across the two agents — a
+ * permission rule written for one works for the other.
+ *
+ * Known limitation (inherited from Claude Code, documented there too): if a
+ * server name contains `__`, `mcpInfoFromString` splits on the first segment.
+ */
+/** Replace characters an MCP tool name cannot carry with `_` (Claude Code parity). */
+export declare function normalizeNameForMCP(name: string): string;
+/** Whether a raw server/tool name is usable as-is (matches Claude Code's validity pattern). */
+export declare function isValidMcpName(name: string): boolean;
+/** The `mcp__<server>__` prefix for a server name. */
+export declare function getMcpPrefix(serverName: string): string;
+/** Fully qualified tool name, e.g. `mcp__linear__get_issue`. */
+export declare function buildMcpToolName(serverName: string, toolName: string): string;
+/** Fully qualified prompt/slash-command name, e.g. `mcp__linear__issue_prompt`. */
+export declare function buildMcpPromptName(serverName: string, promptName: string): string;
+/** Parse `mcp__<server>__<tool>` back into its parts; null when not an MCP name. */
+export declare function mcpInfoFromString(toolString: string): {
+    serverName: string;
+    toolName: string | undefined;
+} | null;
+//# sourceMappingURL=names.d.ts.map

package/dist/extension/mcp/names.js

@@ -0,0 +1,40 @@
+/**
+ * MCP server/tool name normalization + qualified-name building, ported from
+ * Claude Code's `services/mcp/{normalization,mcpStringUtils}.ts` so tool names
+ * (`mcp__<server>__<tool>`) are byte-identical across the two agents — a
+ * permission rule written for one works for the other.
+ *
+ * Known limitation (inherited from Claude Code, documented there too): if a
+ * server name contains `__`, `mcpInfoFromString` splits on the first segment.
+ */
+const NAME_PATTERN = /^[a-zA-Z0-9_-]{1,64}$/;
+/** Replace characters an MCP tool name cannot carry with `_` (Claude Code parity). */
+export function normalizeNameForMCP(name) {
+    return name.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+/** Whether a raw server/tool name is usable as-is (matches Claude Code's validity pattern). */
+export function isValidMcpName(name) {
+    return NAME_PATTERN.test(name);
+}
+/** The `mcp__<server>__` prefix for a server name. */
+export function getMcpPrefix(serverName) {
+    return `mcp__${normalizeNameForMCP(serverName)}__`;
+}
+/** Fully qualified tool name, e.g. `mcp__linear__get_issue`. */
+export function buildMcpToolName(serverName, toolName) {
+    return `${getMcpPrefix(serverName)}${normalizeNameForMCP(toolName)}`;
+}
+/** Fully qualified prompt/slash-command name, e.g. `mcp__linear__issue_prompt`. */
+export function buildMcpPromptName(serverName, promptName) {
+    return buildMcpToolName(serverName, promptName);
+}
+/** Parse `mcp__<server>__<tool>` back into its parts; null when not an MCP name. */
+export function mcpInfoFromString(toolString) {
+    const parts = toolString.split("__");
+    const [mcpPart, serverName, ...toolNameParts] = parts;
+    if (mcpPart !== "mcp" || !serverName)
+        return null;
+    const toolName = toolNameParts.length > 0 ? toolNameParts.join("__") : undefined;
+    return { serverName, toolName };
+}
+//# sourceMappingURL=names.js.map

package/dist/extension/mcp/panel.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The /mcp interactive panel (Claude Code parity): a two-level select —
+ * server list grouped by scope, then a per-server detail menu — plus a
+ * plain-text listing fallback for print/headless mode and for `args` given
+ * directly to /mcp (e.g. `/mcp tools <name>`).
+ *
+ * Enable/disable persists through ~/.yagni-code/mcp.json using Claude Code's
+ * own key names (enabledMcpjsonServers / disabledMcpjsonServers for project
+ * servers; the local-scope `disabled` convention for user/local servers via
+ * a `disabledMcpServers` list under projects[absPath]). A disable/enable
+ * toggle reconnects or disconnects the live client and refreshes tools.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { ManagedServer, McpManager } from "./manager.js";
+export interface PanelServerInfo {
+    name: string;
+    scope: string;
+    status: string;
+    statusIcon: string;
+    detail: string;
+}
+export declare function statusIcon(status: string): string;
+export declare function statusText(server: ManagedServer): string;
+/** Plain-text listing, mirroring CC's `claude mcp list` and panel states. */
+export declare function renderPanelListing(servers: ManagedServer[], errors: string[]): string;
+export interface PanelDeps {
+    cwd: string;
+    hasUI: boolean;
+}
+/** Wire the /mcp command + subcommands. */
+export declare function registerMcpPanel(pi: ExtensionAPI, manager: McpManager, configErrors: () => string[]): void;
+/** Read the persisted disabled list for a repo root (exported for tests). */
+export declare function readDisabledServers(repoRoot: string): string[];
+//# sourceMappingURL=panel.d.ts.map

package/dist/extension/mcp/panel.js

@@ -0,0 +1,258 @@
+/**
+ * The /mcp interactive panel (Claude Code parity): a two-level select —
+ * server list grouped by scope, then a per-server detail menu — plus a
+ * plain-text listing fallback for print/headless mode and for `args` given
+ * directly to /mcp (e.g. `/mcp tools <name>`).
+ *
+ * Enable/disable persists through ~/.yagni-code/mcp.json using Claude Code's
+ * own key names (enabledMcpjsonServers / disabledMcpjsonServers for project
+ * servers; the local-scope `disabled` convention for user/local servers via
+ * a `disabledMcpServers` list under projects[absPath]). A disable/enable
+ * toggle reconnects or disconnects the live client and refreshes tools.
+ */
+import { readUserMcpConfig, resolveProjectRoot, writeUserMcpConfig } from "./config.js";
+import { registerServerPrompts } from "./prompts.js";
+import { registerServerTools } from "./tools.js";
+const STATUS_ICONS = {
+    connected: "✓",
+    connecting: "…",
+    reconnecting: "…",
+    failed: "✗",
+    needs_auth: "⚠",
+    disabled: "○",
+};
+const STATUS_TEXT = {
+    connected: "connected",
+    connecting: "connecting…",
+    reconnecting: "reconnecting",
+    failed: "failed to connect",
+    needs_auth: "needs authentication",
+    disabled: "disabled",
+};
+export function statusIcon(status) {
+    return STATUS_ICONS[status] ?? "○";
+}
+export function statusText(server) {
+    if (server.status === "reconnecting" && server.reconnectAttempt) {
+        return `reconnecting (${server.reconnectAttempt}/3)…`;
+    }
+    return STATUS_TEXT[server.status] ?? server.status;
+}
+/** Plain-text listing, mirroring CC's `claude mcp list` and panel states. */
+export function renderPanelListing(servers, errors) {
+    if (servers.length === 0 && errors.length === 0) {
+        return [
+            "No MCP servers configured.",
+            "Use `yagni mcp add` to add a server, or `/doctor` if this is unexpected.",
+        ].join("\n");
+    }
+    const lines = [];
+    const byScope = { user: [], project: [], local: [] };
+    for (const s of servers)
+        (byScope[s.scope] ??= []).push(s);
+    for (const scope of ["local", "project", "user"]) {
+        const group = byScope[scope];
+        if (!group?.length)
+            continue;
+        lines.push(`${scope === "local" ? "Local" : scope === "project" ? "Project" : "User"} servers:`);
+        for (const s of group) {
+            lines.push(`  ${s.name} · ${statusIcon(s.status)} ${statusText(s)}${s.error ? ` — ${s.error}` : ""}`);
+        }
+    }
+    for (const err of errors) {
+        lines.push(`  ⚠ ${err}`);
+    }
+    return lines.join("\n");
+}
+/** Wire the /mcp command + subcommands. */
+export function registerMcpPanel(pi, manager, configErrors) {
+    const repoRoot = () => resolveProjectRoot(deps.cwd);
+    let deps = { cwd: process.cwd(), hasUI: true };
+    const persistDisabled = (name, disabled) => {
+        const { file } = readUserMcpConfig();
+        const root = repoRoot();
+        const entry = (file.projects ??= {})[root] ??= {};
+        const list = entry.disabledMcpServers ?? [];
+        const next = disabled ? [...new Set([...list, name])] : list.filter((n) => n !== name);
+        if (next.length !== list.length || disabled)
+            entry.disabledMcpServers = next;
+        writeUserMcpConfig(file);
+    };
+    const isPersistedDisabled = (name) => {
+        const { file } = readUserMcpConfig();
+        const entry = (file.projects ?? {})[repoRoot()];
+        return (entry?.disabledMcpServers ?? []).includes(name);
+    };
+    const refreshForServer = async (serverName) => {
+        const server = manager.get(serverName);
+        if (server?.client) {
+            await registerServerTools(pi, manager, serverName);
+            await registerServerPrompts(pi, manager, serverName);
+        }
+    };
+    pi.registerCommand("mcp", {
+        description: "Manage MCP servers: status, tools, reconnect, enable/disable.",
+        handler: async (args, ctx) => {
+            deps = { cwd: ctx.cwd, hasUI: ctx.hasUI };
+            const sub = args.trim().split(/\s+/).filter(Boolean);
+            // Text paths that work in every mode:
+            if (sub[0] === "tools" && sub[1]) {
+                ctx.ui.notify(await renderToolsFor(sub[1], manager), "info");
+                return;
+            }
+            if (sub[0] === "reconnect" && sub[1]) {
+                await doReconnect(sub[1], ctx.ui);
+                return;
+            }
+            if (sub[0] === "enable" || sub[0] === "disable") {
+                await doToggle(sub[0], sub.slice(1), ctx.ui);
+                return;
+            }
+            if (!ctx.hasUI) {
+                ctx.ui.notify(renderPanelListing(manager.list(), configErrors()), "info");
+                return;
+            }
+            await interactivePanel(ctx.ui, ctx.signal);
+        },
+    });
+    async function doAuthenticate(name, ui, signal) {
+        const server = manager.get(name);
+        if (!server) {
+            ui.notify(`No MCP server named "${name}".`, "error");
+            return;
+        }
+        ui.notify(`Starting OAuth for ${name} — your browser will open…`, "info");
+        const result = await manager.authenticateServer(name, signal);
+        if (result?.status === "connected") {
+            await refreshForServer(name);
+            ui.notify(`✓ ${name} authenticated and connected`, "info");
+        }
+        else if (result && result.error === undefined && signal?.aborted) {
+            // A user-initiated cancel is not an error — quiet, no warning.
+            ui.notify(`○ ${name} authentication cancelled`, "info");
+        }
+        else {
+            ui.notify(`⚠ ${name} authentication did not complete${result?.error ? ` — ${result.error}` : ""}`, "warning");
+        }
+    }
+    async function doReconnect(name, ui) {
+        const server = manager.get(name);
+        if (!server) {
+            ui.notify(`No MCP server named "${name}".`, "error");
+            return;
+        }
+        ui.notify(`Reconnecting ${name}…`, "info");
+        const result = await manager.reconnect(name);
+        if (result?.status === "connected") {
+            await refreshForServer(name);
+            ui.notify(`✓ ${name} reconnected`, "info");
+        }
+        else {
+            ui.notify(`✗ ${name} failed to reconnect${result?.error ? ` — ${result.error}` : ""}`, "error");
+        }
+    }
+    async function doToggle(action, names, ui) {
+        const targets = names.length > 0 ? names : manager.list().map((s) => s.name);
+        if (names.length === 0 && targets.length === 0) {
+            ui.notify("No MCP servers configured.", "warning");
+            return;
+        }
+        for (const name of targets) {
+            const server = manager.get(name);
+            if (!server) {
+                ui.notify(`No MCP server named "${name}".`, "error");
+                continue;
+            }
+            if (action === "disable") {
+                await manager.disconnect(name);
+                persistDisabled(name, true);
+                ui.notify(`○ ${name} disabled`, "info");
+            }
+            else {
+                persistDisabled(name, false);
+                const result = await manager.connect(name);
+                if (result?.status === "connected") {
+                    await refreshForServer(name);
+                    ui.notify(`✓ ${name} enabled and connected`, "info");
+                }
+                else {
+                    ui.notify(`⚠ ${name} enabled but failed to connect${result?.error ? ` — ${result.error}` : ""}`, "warning");
+                }
+            }
+        }
+    }
+    async function renderToolsFor(name, m) {
+        const server = m.get(name);
+        if (!server)
+            return `No MCP server named "${name}".`;
+        if (!server.client)
+            return `${name} is ${statusText(server)} — no tools available (try /mcp reconnect ${name}).`;
+        try {
+            const list = await server.client.listTools();
+            if (!list.tools?.length)
+                return `${name} exposes no tools.`;
+            return [
+                `${name} — ${list.tools.length} tool(s):`,
+                ...list.tools.map((t) => `  mcp__${name}__${t.name}${t.description ? ` — ${t.description.slice(0, 120)}` : ""}`),
+            ].join("\n");
+        }
+        catch (err) {
+            return `${name}: listTools failed — ${err instanceof Error ? err.message : String(err)}`;
+        }
+    }
+    async function interactivePanel(ui, signal) {
+        // Level 1: server list
+        const servers = manager.list();
+        if (servers.length === 0) {
+            ui.notify(renderPanelListing(servers, configErrors()), "info");
+            return;
+        }
+        const options = servers.map((s) => `${s.name} · ${statusIcon(s.status)} ${statusText(s)}`);
+        const choice = await ui.select("MCP servers", [...options, "Exit"], signal ? { signal } : undefined);
+        if (!choice || choice === "Exit")
+            return;
+        const name = choice.split(" ·")[0];
+        await serverDetail(name, ui, signal);
+    }
+    async function serverDetail(name, ui, signal) {
+        const server = manager.get(name);
+        if (!server)
+            return;
+        const header = `${name} · ${statusIcon(server.status)} ${statusText(server)}`;
+        const actions = ["View tools", "Reconnect", "Back"];
+        if (server.status === "disabled" || isPersistedDisabled(name))
+            actions.unshift("Enable");
+        else
+            actions.unshift("Disable");
+        if (server.status === "needs_auth")
+            actions.unshift("Authenticate");
+        const choice = await ui.select(header, actions, signal ? { signal } : undefined);
+        if (!choice || choice === "Back")
+            return;
+        switch (choice) {
+            case "Authenticate":
+                await doAuthenticate(name, ui, signal);
+                return;
+            case "View tools":
+                ui.notify(await renderToolsFor(name, manager), "info");
+                return;
+            case "Reconnect":
+                await doReconnect(name, ui);
+                return;
+            case "Enable":
+                await doToggle("enable", [name], ui);
+                return;
+            case "Disable":
+                await doToggle("disable", [name], ui);
+                return;
+        }
+        await serverDetail(name, ui, signal);
+    }
+}
+/** Read the persisted disabled list for a repo root (exported for tests). */
+export function readDisabledServers(repoRoot) {
+    const { file } = readUserMcpConfig();
+    const entry = (file.projects ?? {})[repoRoot];
+    return (entry?.disabledMcpServers ?? []).slice();
+}
+//# sourceMappingURL=panel.js.map

package/dist/extension/mcp/prompts.d.ts

@@ -0,0 +1,23 @@
+/**
+ * MCP prompts as dynamically-registered pi slash commands: every prompt a
+ * server exposes becomes `/mcp__<server>__<prompt> [args]` whose handler
+ * fetches the rendered messages and injects them as the next user turn via
+ * pi.sendUserMessage. pi prompt templates are file-only, so runtime
+ * registration is the only path — commands are resolved live on each
+ * getRegisteredCommands() call.
+ */
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import type { McpManager } from "./manager.js";
+export interface PromptRegistrationResult {
+    commands: {
+        command: string;
+        serverName: string;
+        promptName: string;
+        description: string;
+    }[];
+    warnings: string[];
+}
+export declare function registerServerPrompts(pi: ExtensionAPI, manager: McpManager, serverName: string): Promise<PromptRegistrationResult>;
+/** "a=1 b=two" → { a: "1", b: "two" }; quotes group spaces. */
+export declare function parsePromptArgs(args: string): Record<string, string>;
+//# sourceMappingURL=prompts.d.ts.map