@fitchmultz/pi-mcp-adapter 5.0.0

package/dist/prompts.js

@@ -0,0 +1,284 @@
+import { isServerDisabled } from "./types.js";
+import { lazyConnect } from "./init.js";
+import { isServerCacheValid, loadMetadataCache, reconstructPromptMetadata } from "./metadata-cache.js";
+import { logger } from "./logger.js";
+import { truncateAtWord } from "./utils.js";
+/**
+ * Resolve prompt metadata for slash-command registration at extension load
+ * time. Mirrors `resolveDirectTools`: reads the persistent metadata cache so
+ * commands are available before any server connects.
+ */
+export function resolveCachedPrompts(config, cacheEnabled = true) {
+    const cache = loadMetadataCache(cacheEnabled);
+    if (!cache?.servers)
+        return [];
+    const prefix = config.settings?.toolPrefix ?? "server";
+    const specs = [];
+    for (const [serverName, entry] of Object.entries(cache.servers)) {
+        const definition = config.mcpServers[serverName];
+        if (!definition || isServerDisabled(definition))
+            continue;
+        if (!entry?.prompts?.length || !isServerCacheValid(entry, definition))
+            continue;
+        specs.push(...reconstructPromptMetadata(serverName, entry.prompts, prefix, definition));
+    }
+    return specs;
+}
+/**
+ * Parse a slash-command argument string into positional and named MCP prompt
+ * arguments. Supports bash-style quoting so callers can pass values with
+ * spaces:
+ *
+ *   /mcp__demo__brief today "important tasks"
+ *   /mcp__demo__brief day=today topic="important tasks"
+ */
+export function parsePromptArgs(input) {
+    const positional = [];
+    const named = {};
+    const tokens = tokenizeArgs(input);
+    for (const token of tokens) {
+        const eq = findUnquotedEquals(token);
+        if (eq > 0) {
+            const key = token.slice(0, eq).trim();
+            const value = stripQuotes(token.slice(eq + 1).trim());
+            if (key) {
+                named[key] = value;
+                continue;
+            }
+        }
+        positional.push(stripQuotes(token));
+    }
+    return { positional, named };
+}
+function tokenizeArgs(input) {
+    const tokens = [];
+    let current = "";
+    let quote = null;
+    let escaped = false;
+    for (const char of input) {
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === "\\" && quote !== "'") {
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            current += char;
+            if (char === quote)
+                quote = null;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            quote = char;
+            current += char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (current.length > 0) {
+                tokens.push(current);
+                current = "";
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (current.length > 0)
+        tokens.push(current);
+    return tokens;
+}
+function findUnquotedEquals(token) {
+    let quote = null;
+    for (let i = 0; i < token.length; i++) {
+        const ch = token[i];
+        if (quote) {
+            if (ch === quote)
+                quote = null;
+            continue;
+        }
+        if (ch === '"' || ch === "'")
+            quote = ch;
+        else if (ch === "=")
+            return i;
+    }
+    return -1;
+}
+function stripQuotes(value) {
+    if (value.length >= 2 && (value.startsWith('"') || value.startsWith("'")) && value.endsWith(value.charAt(0))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+/**
+ * Map positional and named arguments onto the prompt's declared argument
+ * list. Named arguments win over positional when both target the same slot.
+ * Missing required arguments produce a helpful usage message that the
+ * command handler surfaces via `ctx.ui.notify`.
+ */
+export function resolvePromptArgs(metadata, parsed) {
+    const args = {};
+    const declared = metadata.arguments;
+    let positionalIndex = 0;
+    for (const argDef of declared) {
+        const value = parsed.named[argDef.name] ?? parsed.positional[positionalIndex++];
+        if (value !== undefined && value !== "") {
+            args[argDef.name] = value;
+        }
+    }
+    // Preserve named arguments the prompt did not declare so servers with
+    // permissive schemas still receive them. The MCP spec allows arbitrary
+    // string key/values in `prompts/get` params.arguments.
+    for (const [key, value] of Object.entries(parsed.named)) {
+        if (!(key in args))
+            args[key] = value;
+    }
+    const missing = declared.filter(a => a.required && (args[a.name] === undefined || args[a.name] === ""));
+    if (missing.length > 0) {
+        return { ok: false, error: buildUsageMessage(metadata, missing) };
+    }
+    return { ok: true, args };
+}
+function buildUsageMessage(metadata, missing) {
+    const usage = metadata.arguments
+        .map(a => (a.required ? `<${a.name}>` : `[${a.name}]`))
+        .join(" ");
+    const missingList = missing.map(a => a.name).join(", ");
+    return `Missing required argument${missing.length > 1 ? "s" : ""}: ${missingList}.\nUsage: /${metadata.commandName} ${usage}`.trim();
+}
+/**
+ * Flatten a `GetPromptResult` into a single string suitable for
+ * `pi.sendUserMessage`. MCP prompts can contain multiple messages with
+ * mixed roles; we preserve role attribution as inline markers so the model
+ * still sees the intended conversational shape without needing a
+ * multi-message replay API on the pi side.
+ */
+export function formatPromptResult(result) {
+    const lines = [];
+    for (const message of result.messages) {
+        const text = extractMessageText(message);
+        if (!text)
+            continue;
+        if (message.role === "user" && result.messages.length === 1) {
+            lines.push(text);
+        }
+        else {
+            lines.push(`[${message.role}] ${text}`);
+        }
+    }
+    return lines.join("\n\n").trim();
+}
+function extractMessageText(message) {
+    const content = message.content;
+    if (!content || typeof content !== "object")
+        return "";
+    switch (content.type) {
+        case "text":
+            return content.text ?? "";
+        case "resource": {
+            const resource = content.resource;
+            if (!resource)
+                return "";
+            if ("text" in resource && typeof resource.text === "string") {
+                return `[resource ${resource.uri}]\n${resource.text}`;
+            }
+            return `[resource ${resource.uri}]`;
+        }
+        case "resource_link":
+            return `[resource_link ${content.uri ?? ""}${content.name ? ` — ${content.name}` : ""}]`;
+        case "image":
+            return `[image ${content.mimeType ?? "unknown"}${content.data ? " (embedded)" : ""}]`;
+        case "audio":
+            return `[audio ${content.mimeType ?? "unknown"}]`;
+        default:
+            return "";
+    }
+}
+/**
+ * Build the pi command definition for a single MCP prompt. Registered once
+ * per prompt at extension load time from the metadata cache; the same
+ * factory is reused by tests to invoke the handler without a running pi.
+ */
+export function createPromptCommand(pi, getState, metadata) {
+    const description = buildCommandDescription(metadata);
+    return {
+        description,
+        handler: async (args, ctx) => {
+            const state = getState();
+            if (!state) {
+                if (ctx.hasUI)
+                    ctx.ui.notify("MCP not initialized", "error");
+                return;
+            }
+            const liveMetadata = findLivePromptMetadata(state, metadata.serverName, metadata.originalName);
+            if (state.promptMetadataLive?.has(metadata.serverName) && !liveMetadata) {
+                if (ctx.hasUI) {
+                    ctx.ui.notify(`MCP prompt "${metadata.originalName}" is no longer advertised by server "${metadata.serverName}". Run /mcp reconnect to refresh.`, "error");
+                }
+                return;
+            }
+            const live = liveMetadata ?? metadata;
+            const parsed = parsePromptArgs(args ?? "");
+            const resolved = resolvePromptArgs(live, parsed);
+            if (!resolved.ok) {
+                if (ctx.hasUI)
+                    ctx.ui.notify(resolved.error ?? "Invalid prompt arguments", "error");
+                return;
+            }
+            const promptArgs = resolved.args ?? {};
+            if (!state.config.mcpServers[metadata.serverName]) {
+                if (ctx.hasUI) {
+                    ctx.ui.notify(`MCP prompt "${live.originalName}" is no longer configured. Run /mcp reconnect to refresh.`, "error");
+                }
+                return;
+            }
+            const connected = await lazyConnect(state, metadata.serverName, ctx.signal);
+            if (!connected) {
+                if (ctx.hasUI) {
+                    const conn = state.manager.getConnection(metadata.serverName);
+                    const message = conn?.status === "needs-auth"
+                        ? `MCP server "${metadata.serverName}" needs authentication. Run /mcp-auth ${metadata.serverName}.`
+                        : `MCP server "${metadata.serverName}" is not available. Run /mcp reconnect ${metadata.serverName}.`;
+                    ctx.ui.notify(message, "error");
+                }
+                return;
+            }
+            const refreshed = findLivePromptMetadata(state, metadata.serverName, metadata.originalName);
+            if (state.promptMetadataLive?.has(metadata.serverName) && !refreshed) {
+                if (ctx.hasUI) {
+                    ctx.ui.notify(`MCP prompt "${metadata.originalName}" is no longer advertised by server "${metadata.serverName}". Run /mcp reconnect to refresh.`, "error");
+                }
+                return;
+            }
+            const dispatchMetadata = refreshed ?? live;
+            let result;
+            try {
+                result = await state.manager.getPrompt(metadata.serverName, dispatchMetadata.originalName, Object.keys(promptArgs).length > 0 ? promptArgs : undefined, ctx.signal);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                logger.debug(`MCP prompt "${live.originalName}" on ${metadata.serverName} failed: ${message}`);
+                if (ctx.hasUI) {
+                    ctx.ui.notify(`MCP prompt "${live.originalName}" failed: ${message}`, "error");
+                }
+                return;
+            }
+            const text = formatPromptResult(result);
+            if (!text) {
+                if (ctx.hasUI) {
+                    ctx.ui.notify(`MCP prompt "${live.originalName}" returned no text content.`, "warning");
+                }
+                return;
+            }
+            pi.sendUserMessage(text);
+        },
+    };
+}
+function findLivePromptMetadata(state, serverName, originalName) {
+    return state.promptMetadata?.get(serverName)?.find(p => p.originalName === originalName);
+}
+function buildCommandDescription(metadata) {
+    const base = metadata.description || metadata.title || `MCP prompt from ${metadata.serverName}`;
+    return truncateAtWord(`MCP: ${base}`, 120) || `MCP prompt from ${metadata.serverName}`;
+}

package/dist/proxy-modes.d.ts

@@ -0,0 +1,38 @@
+import type { AgentToolResult, ToolInfo } from "@earendil-works/pi-coding-agent";
+import type { McpExtensionState } from "./state.ts";
+import type { ToolMetadata, McpOperationContext, McpToolCallIdentity } from "./types.ts";
+import { type SessionRecoveryDeps } from "./session-recovery.ts";
+type ProxyToolResult = AgentToolResult<Record<string, unknown>>;
+export declare function executeUiMessages(state: McpExtensionState): ProxyToolResult;
+export declare function executeStatus(state: McpExtensionState): ProxyToolResult;
+export declare function executeAuthStart(state: McpExtensionState, serverName: string, signal?: AbortSignal): Promise<ProxyToolResult>;
+export declare function executeAuthComplete(state: McpExtensionState, serverName: string, input?: string, signal?: AbortSignal): Promise<ProxyToolResult>;
+export declare function executeDescribe(state: McpExtensionState, toolName: string): ProxyToolResult;
+export declare function executeSearch(state: McpExtensionState, query: string, server?: string, includeSchemas?: boolean, limit?: number, offset?: number): ProxyToolResult;
+export declare function executeList(state: McpExtensionState, server: string, limit?: number, offset?: number): ProxyToolResult;
+export declare function executeInstructions(state: McpExtensionState, server: string): ProxyToolResult;
+export declare function executeConnect(state: McpExtensionState, serverName: string, signal?: AbortSignal, limit?: number, offset?: number): Promise<ProxyToolResult>;
+/** The part of a tool call that is identical for proxy and direct tools. */
+type ToolCallTarget = Pick<ToolMetadata, "originalName" | "inputSchema" | "annotations" | "resourceUri" | "uiResourceUri" | "uiStreamMode">;
+interface ToolCallOptions extends McpToolCallIdentity {
+    beforeDispatch?: (signal: AbortSignal | undefined, operation: McpOperationContext) => Promise<void>;
+    /** Spread into every details payload: identity, and `mode` for proxy calls. */
+    detailsBase: Record<string, unknown>;
+    ownedSignal: AbortSignal | undefined;
+    /** Caller-supplied signal, passed to the UI session rather than the MCP call. */
+    signal: AbortSignal | undefined;
+    recoverAuthConnection: NonNullable<SessionRecoveryDeps["onNeedsAuth"]>;
+    authRequiredMessage: () => string;
+    autoAuthAttempted: () => boolean;
+    onRawResult?: (result: unknown) => void;
+}
+/**
+ * Executes an already-approved tool call against a connected server.
+ *
+ * Both the `mcp` proxy and direct tools reach this with a resolved target and a
+ * live connection; everything before this point (name resolution, connect and
+ * auth strategy, approval) differs between them and stays with the caller.
+ */
+export declare function runToolCall(state: McpExtensionState, serverName: string, target: ToolCallTarget, args: Record<string, unknown> | undefined, options: ToolCallOptions): Promise<ProxyToolResult>;
+export declare function executeCall(state: McpExtensionState, toolName: string, args?: Record<string, unknown>, serverOverride?: string, getPiTools?: () => ToolInfo[], signal?: AbortSignal, onRawResult?: (result: unknown) => void, identity?: McpToolCallIdentity, beforeDispatch?: (signal: AbortSignal | undefined, operation: McpOperationContext) => Promise<void>): Promise<ProxyToolResult>;
+export {};