pi-mcp-adapter 2.1.2 → 2.2.1

package/cli.js

@@ -26,7 +26,6 @@ const FILES = [
   "tsconfig.json",
   "README.md",
   "CHANGELOG.md",
-  "ARCHITECTURE.md",
   "LICENSE",
 ];
 

package/commands.ts

@@ -0,0 +1,210 @@
+import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { McpExtensionState } from "./state.js";
+import type { McpConfig, ServerEntry, McpPanelCallbacks, McpPanelResult } from "./types.js";
+import { getServerProvenance, writeDirectToolsConfig } from "./config.js";
+import { lazyConnect, updateMetadataCache, updateStatusBar, getFailureAgeSeconds } from "./init.js";
+import { loadMetadataCache } from "./metadata-cache.js";
+import { getStoredTokens } from "./oauth-handler.js";
+import { buildToolMetadata } from "./tool-metadata.js";
+
+export async function showStatus(state: McpExtensionState, ctx: ExtensionContext): Promise<void> {
+  if (!ctx.hasUI) return;
+
+  const lines: string[] = ["MCP Server Status:", ""];
+
+  for (const name of Object.keys(state.config.mcpServers)) {
+    const connection = state.manager.getConnection(name);
+    const metadata = state.toolMetadata.get(name);
+    const toolCount = metadata?.length ?? 0;
+    const failedAgo = getFailureAgeSeconds(state, name);
+    let status = "not connected";
+    let statusIcon = "○";
+    let failed = false;
+
+    if (connection?.status === "connected") {
+      status = "connected";
+      statusIcon = "✓";
+    } else if (failedAgo !== null) {
+      status = `failed ${failedAgo}s ago`;
+      statusIcon = "✗";
+      failed = true;
+    } else if (metadata !== undefined) {
+      status = "cached";
+    }
+
+    const toolSuffix = failed ? "" : ` (${toolCount} tools${status === "cached" ? ", cached" : ""})`;
+    lines.push(`${statusIcon} ${name}: ${status}${toolSuffix}`);
+  }
+
+  if (Object.keys(state.config.mcpServers).length === 0) {
+    lines.push("No MCP servers configured");
+  }
+
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+
+export async function showTools(state: McpExtensionState, ctx: ExtensionContext): Promise<void> {
+  if (!ctx.hasUI) return;
+
+  const allTools = [...state.toolMetadata.values()].flat().map(m => m.name);
+
+  if (allTools.length === 0) {
+    ctx.ui.notify("No MCP tools available", "info");
+    return;
+  }
+
+  const lines = [
+    "MCP Tools:",
+    "",
+    ...allTools.map(t => `  ${t}`),
+    "",
+    `Total: ${allTools.length} tools`,
+  ];
+
+  ctx.ui.notify(lines.join("\n"), "info");
+}
+
+export async function reconnectServers(
+  state: McpExtensionState,
+  ctx: ExtensionContext,
+  targetServer?: string
+): Promise<void> {
+  if (targetServer && !state.config.mcpServers[targetServer]) {
+    if (ctx.hasUI) {
+      ctx.ui.notify(`Server "${targetServer}" not found in config`, "error");
+    }
+    return;
+  }
+
+  const entries = targetServer
+    ? [[targetServer, state.config.mcpServers[targetServer]] as [string, ServerEntry]]
+    : Object.entries(state.config.mcpServers);
+
+  for (const [name, definition] of entries) {
+    try {
+      await state.manager.close(name);
+
+      const connection = await state.manager.connect(name, definition);
+      const prefix = state.config.settings?.toolPrefix ?? "server";
+
+      const { metadata, failedTools } = buildToolMetadata(connection.tools, connection.resources, definition, name, prefix);
+      state.toolMetadata.set(name, metadata);
+      updateMetadataCache(state, name);
+      state.failureTracker.delete(name);
+
+      if (ctx.hasUI) {
+        ctx.ui.notify(
+          `MCP: Reconnected to ${name} (${connection.tools.length} tools, ${connection.resources.length} resources)`,
+          "info"
+        );
+        if (failedTools.length > 0) {
+          ctx.ui.notify(`MCP: ${name} - ${failedTools.length} tools skipped`, "warning");
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      state.failureTracker.set(name, Date.now());
+      if (ctx.hasUI) {
+        ctx.ui.notify(`MCP: Failed to reconnect to ${name}: ${message}`, "error");
+      }
+    }
+  }
+
+  updateStatusBar(state);
+}
+
+export async function authenticateServer(
+  serverName: string,
+  config: McpConfig,
+  ctx: ExtensionContext
+): Promise<void> {
+  if (!ctx.hasUI) return;
+
+  const definition = config.mcpServers[serverName];
+  if (!definition) {
+    ctx.ui.notify(`Server "${serverName}" not found in config`, "error");
+    return;
+  }
+
+  if (definition.auth !== "oauth") {
+    ctx.ui.notify(
+      `Server "${serverName}" does not use OAuth authentication.\n` +
+      `Current auth mode: ${definition.auth ?? "none"}`,
+      "error"
+    );
+    return;
+  }
+
+  if (!definition.url) {
+    ctx.ui.notify(
+      `Server "${serverName}" has no URL configured (OAuth requires HTTP transport)`,
+      "error"
+    );
+    return;
+  }
+
+  const tokenPath = `~/.pi/agent/mcp-oauth/${serverName}/tokens.json`;
+
+  ctx.ui.notify(
+    `OAuth setup for "${serverName}":\n\n` +
+    `1. Obtain an access token from your OAuth provider\n` +
+    `2. Create the token file:\n` +
+    `   ${tokenPath}\n\n` +
+    `3. Add your token:\n` +
+    `   {\n` +
+    `     "access_token": "your-token-here",\n` +
+    `     "token_type": "bearer"\n` +
+    `   }\n\n` +
+    `4. Run /mcp reconnect to connect with the token`,
+    "info"
+  );
+}
+
+export async function openMcpPanel(
+  state: McpExtensionState,
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  configOverridePath?: string,
+): Promise<void> {
+  const config = state.config;
+  const cache = loadMetadataCache();
+  const provenanceMap = getServerProvenance(pi.getFlag("mcp-config") as string | undefined ?? configOverridePath);
+
+  const callbacks: McpPanelCallbacks = {
+    reconnect: async (serverName: string) => {
+      return lazyConnect(state, serverName);
+    },
+    getConnectionStatus: (serverName: string) => {
+      const definition = config.mcpServers[serverName];
+      if (definition?.auth === "oauth" && getStoredTokens(serverName) === undefined) {
+        return "needs-auth";
+      }
+      const connection = state.manager.getConnection(serverName);
+      if (connection?.status === "connected") return "connected";
+      if (getFailureAgeSeconds(state, serverName) !== null) return "failed";
+      return "idle";
+    },
+    refreshCacheAfterReconnect: (serverName: string) => {
+      const freshCache = loadMetadataCache();
+      return freshCache?.servers?.[serverName] ?? null;
+    },
+  };
+
+  const { createMcpPanel } = await import("./mcp-panel.js");
+
+  return new Promise<void>((resolve) => {
+    ctx.ui.custom(
+      (tui, _theme, _keybindings, done) => {
+        return createMcpPanel(config, cache, provenanceMap, callbacks, tui, (result: McpPanelResult) => {
+          if (!result.cancelled && result.changes.size > 0) {
+            writeDirectToolsConfig(result.changes, provenanceMap, config);
+            ctx.ui.notify("Direct tools updated. Restart pi to apply.", "info");
+          }
+          done();
+          resolve();
+        });
+      },
+      { overlay: true, overlayOptions: { anchor: "center", width: 82 } },
+    );
+  });
+}

package/consent-manager.ts

@@ -0,0 +1,64 @@
+import { ConsentError } from "./errors.js";
+import { logger } from "./logger.js";
+
+export type ToolConsentMode = "never" | "once-per-server" | "always";
+
+export class ConsentManager {
+  private approvedServers = new Set<string>();
+  private deniedServers = new Set<string>();
+  private log = logger.child({ component: "ConsentManager" });
+
+  constructor(private mode: ToolConsentMode = "once-per-server") {
+    this.log.debug("Initialized", { mode });
+  }
+
+  requiresPrompt(serverName: string): boolean {
+    if (this.mode === "never") return false;
+    if (this.deniedServers.has(serverName)) return true;
+    if (this.mode === "always") return true;
+    return !this.approvedServers.has(serverName);
+  }
+
+  shouldCacheConsent(): boolean {
+    return this.mode !== "always";
+  }
+
+  registerDecision(serverName: string, approved: boolean): void {
+    this.deniedServers.delete(serverName);
+    this.approvedServers.delete(serverName);
+
+    if (approved) {
+      this.approvedServers.add(serverName);
+      this.log.debug("Consent granted", { server: serverName });
+      return;
+    }
+
+    this.deniedServers.add(serverName);
+    this.log.debug("Consent denied", { server: serverName });
+  }
+
+  ensureApproved(serverName: string): void {
+    if (this.mode === "never") return;
+    if (this.deniedServers.has(serverName)) {
+      throw new ConsentError(serverName, { denied: true });
+    }
+    if (!this.approvedServers.has(serverName)) {
+      throw new ConsentError(serverName, { requiresApproval: true });
+    }
+    if (this.mode === "always") {
+      this.approvedServers.delete(serverName);
+    }
+  }
+
+  clear(serverName?: string): void {
+    if (serverName) {
+      this.approvedServers.delete(serverName);
+      this.deniedServers.delete(serverName);
+      this.log.debug("Cleared consent for server", { server: serverName });
+      return;
+    }
+    this.approvedServers.clear();
+    this.deniedServers.clear();
+    this.log.debug("Cleared all consent records");
+  }
+}

package/direct-tools.ts

@@ -0,0 +1,301 @@
+import type { ToolDefinition } from "@mariozechner/pi-coding-agent";
+import type { McpExtensionState } from "./state.js";
+import type { DirectToolSpec, McpConfig, McpContent } from "./types.js";
+import type { MetadataCache } from "./metadata-cache.js";
+import { lazyConnect, getFailureAgeSeconds } from "./init.js";
+import { isServerCacheValid } from "./metadata-cache.js";
+import { formatSchema } from "./tool-metadata.js";
+import { transformMcpContent } from "./tool-registrar.js";
+import { maybeStartUiSession, type UiSessionRuntime } from "./ui-session.js";
+import { formatToolName } from "./types.js";
+import { resourceNameToToolName } from "./resource-tools.js";
+
+const BUILTIN_NAMES = new Set(["read", "bash", "edit", "write", "grep", "find", "ls", "mcp"]);
+
+export function resolveDirectTools(
+  config: McpConfig,
+  cache: MetadataCache | null,
+  prefix: "server" | "none" | "short",
+  envOverride?: string[],
+): DirectToolSpec[] {
+  const specs: DirectToolSpec[] = [];
+  if (!cache) return specs;
+
+  const seenNames = new Set<string>();
+
+  const envServers = new Set<string>();
+  const envTools = new Map<string, Set<string>>();
+  if (envOverride) {
+    for (let item of envOverride) {
+      item = item.replace(/\/+$/, "");
+      if (item.includes("/")) {
+        const [server, tool] = item.split("/", 2);
+        if (server && tool) {
+          if (!envTools.has(server)) envTools.set(server, new Set());
+          envTools.get(server)!.add(tool);
+        } else if (server) {
+          envServers.add(server);
+        }
+      } else if (item) {
+        envServers.add(item);
+      }
+    }
+  }
+
+  const globalDirect = config.settings?.directTools;
+
+  for (const [serverName, definition] of Object.entries(config.mcpServers)) {
+    const serverCache = cache.servers[serverName];
+    if (!serverCache || !isServerCacheValid(serverCache, definition)) continue;
+
+    let toolFilter: true | string[] | false = false;
+
+    if (envOverride) {
+      if (envServers.has(serverName)) {
+        toolFilter = true;
+      } else if (envTools.has(serverName)) {
+        toolFilter = [...envTools.get(serverName)!];
+      }
+    } else {
+      if (definition.directTools !== undefined) {
+        toolFilter = definition.directTools;
+      } else if (globalDirect) {
+        toolFilter = globalDirect;
+      }
+    }
+
+    if (!toolFilter) continue;
+
+    for (const tool of serverCache.tools ?? []) {
+      if (toolFilter !== true && !toolFilter.includes(tool.name)) continue;
+      const prefixedName = formatToolName(tool.name, serverName, prefix);
+      if (BUILTIN_NAMES.has(prefixedName)) {
+        console.warn(`MCP: skipping direct tool "${prefixedName}" (collides with builtin)`);
+        continue;
+      }
+      if (seenNames.has(prefixedName)) {
+        console.warn(`MCP: skipping duplicate direct tool "${prefixedName}" from "${serverName}"`);
+        continue;
+      }
+      seenNames.add(prefixedName);
+      specs.push({
+        serverName,
+        originalName: tool.name,
+        prefixedName,
+        description: tool.description ?? "",
+        inputSchema: tool.inputSchema,
+        uiResourceUri: tool.uiResourceUri,
+        uiStreamMode: tool.uiStreamMode,
+      });
+    }
+
+    if (definition.exposeResources !== false) {
+      for (const resource of serverCache.resources ?? []) {
+        const baseName = `get_${resourceNameToToolName(resource.name)}`;
+        if (toolFilter !== true && !toolFilter.includes(baseName)) continue;
+        const prefixedName = formatToolName(baseName, serverName, prefix);
+        if (BUILTIN_NAMES.has(prefixedName)) {
+          console.warn(`MCP: skipping direct resource tool "${prefixedName}" (collides with builtin)`);
+          continue;
+        }
+        if (seenNames.has(prefixedName)) {
+          console.warn(`MCP: skipping duplicate direct resource tool "${prefixedName}" from "${serverName}"`);
+          continue;
+        }
+        seenNames.add(prefixedName);
+        specs.push({
+          serverName,
+          originalName: baseName,
+          prefixedName,
+          description: resource.description ?? `Read resource: ${resource.uri}`,
+          resourceUri: resource.uri,
+        });
+      }
+    }
+  }
+
+  return specs;
+}
+
+export function buildProxyDescription(
+  config: McpConfig,
+  cache: MetadataCache | null,
+  directSpecs: DirectToolSpec[],
+): string {
+  let desc = `MCP gateway - connect to MCP servers and call their tools.\n`;
+
+  const directByServer = new Map<string, number>();
+  for (const spec of directSpecs) {
+    directByServer.set(spec.serverName, (directByServer.get(spec.serverName) ?? 0) + 1);
+  }
+  if (directByServer.size > 0) {
+    const parts = [...directByServer.entries()].map(
+      ([server, count]) => `${server} (${count})`,
+    );
+    desc += `\nDirect tools available (call as normal tools): ${parts.join(", ")}\n`;
+  }
+
+  const serverSummaries: string[] = [];
+  for (const serverName of Object.keys(config.mcpServers)) {
+    const entry = cache?.servers?.[serverName];
+    const definition = config.mcpServers[serverName];
+    const toolCount = entry?.tools?.length ?? 0;
+    const resourceCount = definition?.exposeResources !== false ? (entry?.resources?.length ?? 0) : 0;
+    const totalItems = toolCount + resourceCount;
+    if (totalItems === 0) continue;
+    const directCount = directByServer.get(serverName) ?? 0;
+    const proxyCount = totalItems - directCount;
+    if (proxyCount > 0) {
+      serverSummaries.push(`${serverName} (${proxyCount} tools)`);
+    }
+  }
+
+  if (serverSummaries.length > 0) {
+    desc += `\nServers: ${serverSummaries.join(", ")}\n`;
+  }
+
+  desc += `\nUsage:\n`;
+  desc += `  mcp({ })                              → Show server status\n`;
+  desc += `  mcp({ server: "name" })               → List tools from server\n`;
+  desc += `  mcp({ search: "query" })              → Search for tools (MCP + pi, space-separated words OR'd)\n`;
+  desc += `  mcp({ describe: "tool_name" })        → Show tool details and parameters\n`;
+  desc += `  mcp({ connect: "server-name" })       → Connect to a server and refresh metadata\n`;
+  desc += `  mcp({ tool: "name", args: '{"key": "value"}' })    → Call a tool (args is JSON string)\n`;
+  desc += `  mcp({ action: "ui-messages" })        → Retrieve accumulated messages from completed UI sessions\n`;
+  desc += `\nMode: tool (call) > connect > describe > search > server (list) > action > nothing (status)`;
+
+  return desc;
+}
+
+type DirectToolExecute = ToolDefinition["execute"];
+
+export function createDirectToolExecutor(
+  getState: () => McpExtensionState | null,
+  getInitPromise: () => Promise<McpExtensionState> | null,
+  spec: DirectToolSpec
+): DirectToolExecute {
+  return async function execute(_toolCallId, params) {
+    let state = getState();
+    const initPromise = getInitPromise();
+
+    if (!state && initPromise) {
+      try {
+        state = await initPromise;
+      } catch {
+        return {
+          content: [{ type: "text" as const, text: "MCP initialization failed" }],
+          details: { error: "init_failed" },
+        };
+      }
+    }
+    if (!state) {
+      return {
+        content: [{ type: "text" as const, text: "MCP not initialized" }],
+        details: { error: "not_initialized" },
+      };
+    }
+
+    const connected = await lazyConnect(state, spec.serverName);
+    if (!connected) {
+      const failedAgo = getFailureAgeSeconds(state, spec.serverName);
+      return {
+        content: [{ type: "text" as const, text: `MCP server "${spec.serverName}" not available${failedAgo !== null ? ` (failed ${failedAgo}s ago)` : ""}` }],
+        details: { error: "server_unavailable", server: spec.serverName },
+      };
+    }
+
+    const connection = state.manager.getConnection(spec.serverName);
+    if (!connection || connection.status !== "connected") {
+      return {
+        content: [{ type: "text" as const, text: `MCP server "${spec.serverName}" not connected` }],
+        details: { error: "not_connected", server: spec.serverName },
+      };
+    }
+
+    let uiSession: UiSessionRuntime | null = null;
+
+    try {
+      state.manager.touch(spec.serverName);
+      state.manager.incrementInFlight(spec.serverName);
+
+      if (spec.resourceUri) {
+        const result = await connection.client.readResource({ uri: spec.resourceUri });
+        const content = (result.contents ?? []).map(c => ({
+          type: "text" as const,
+          text: "text" in c ? c.text : ("blob" in c ? `[Binary data: ${(c as { mimeType?: string }).mimeType ?? "unknown"}]` : JSON.stringify(c)),
+        }));
+        return {
+          content: content.length > 0 ? content : [{ type: "text" as const, text: "(empty resource)" }],
+          details: { server: spec.serverName, resourceUri: spec.resourceUri },
+        };
+      }
+
+      const hasUi = !!spec.uiResourceUri;
+      uiSession = hasUi
+        ? await maybeStartUiSession(state, {
+            serverName: spec.serverName,
+            toolName: spec.originalName,
+            toolArgs: params ?? {},
+            uiResourceUri: spec.uiResourceUri!,
+            streamMode: spec.uiStreamMode,
+          })
+        : null;
+
+      const resultPromise = connection.client.callTool({
+        name: spec.originalName,
+        arguments: params ?? {},
+        _meta: uiSession?.requestMeta,
+      });
+
+      const result = await resultPromise;
+      uiSession?.sendToolResult(result as unknown as import("@modelcontextprotocol/sdk/types.js").CallToolResult);
+
+      const mcpContent = (result.content ?? []) as McpContent[];
+      const content = transformMcpContent(mcpContent);
+
+      if (result.isError) {
+        let errorText = content.filter(c => c.type === "text").map(c => (c as { text: string }).text).join("\n") || "Tool execution failed";
+        if (spec.inputSchema) {
+          errorText += `\n\nExpected parameters:\n${formatSchema(spec.inputSchema)}`;
+        }
+        return {
+          content: [{ type: "text" as const, text: `Error: ${errorText}` }],
+          details: { error: "tool_error", server: spec.serverName },
+        };
+      }
+
+      const resultText = content.filter(c => c.type === "text").map(c => (c as { text: string }).text).join("\n") || "(empty result)";
+      if (hasUi) {
+        const uiMessage = uiSession?.reused
+          ? "Updated the open UI."
+          : "📺 Interactive UI is now open in your browser. I'll respond to your prompts and intents as you interact with it.";
+        return {
+          content: [{ type: "text" as const, text: `${resultText}\n\n${uiMessage}` }],
+          details: { server: spec.serverName, tool: spec.originalName, uiOpen: true },
+        };
+      }
+
+      return {
+        content: content.length > 0 ? content : [{ type: "text" as const, text: "(empty result)" }],
+        details: { server: spec.serverName, tool: spec.originalName },
+      };
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      uiSession?.sendToolCancelled(message);
+      let errorText = `Failed to call tool: ${message}`;
+      if (spec.inputSchema) {
+        errorText += `\n\nExpected parameters:\n${formatSchema(spec.inputSchema)}`;
+      }
+      return {
+        content: [{ type: "text" as const, text: errorText }],
+        details: { error: "call_failed", server: spec.serverName },
+      };
+    } finally {
+      if (uiSession?.reused) {
+        uiSession.close();
+      }
+      state.manager.decrementInFlight(spec.serverName);
+      state.manager.touch(spec.serverName);
+    }
+  };
+}