pi-mcp-adapter 2.3.5 → 2.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mcp-adapter",
-  "version": "2.3.5",
+  "version": "2.4.1",
   "description": "MCP (Model Context Protocol) adapter extension for Pi coding agent",
   "type": "module",
   "license": "MIT",
@@ -45,6 +45,8 @@
     "proxy-modes.ts",
     "direct-tools.ts",
     "commands.ts",
+    "onboarding-state.ts",
+    "mcp-setup-panel.ts",
     "types.ts",
     "ui-stream-types.ts",
     "config.ts",

package/proxy-modes.ts

@@ -7,9 +7,52 @@ import { buildToolMetadata, getToolNames, findToolByName, formatSchema } from ".
 import { transformMcpContent } from "./tool-registrar.js";
 import { maybeStartUiSession, type UiSessionRuntime } from "./ui-session.js";
 import { truncateAtWord } from "./utils.js";
+import { authenticate, supportsOAuth } from "./mcp-auth-flow.js";
 
 type ProxyToolResult = AgentToolResult<Record<string, unknown>>;
 
+type AutoAuthResult =
+  | { status: "skipped" }
+  | { status: "success" }
+  | { status: "failed"; message: string };
+
+function getAuthRequiredMessage(serverName: string): string {
+  return `Server "${serverName}" requires OAuth authentication. Run /mcp-auth ${serverName} first.`;
+}
+
+async function attemptAutoAuth(
+  state: McpExtensionState,
+  serverName: string,
+): Promise<AutoAuthResult> {
+  if (state.config.settings?.autoAuth !== true) {
+    return { status: "skipped" };
+  }
+
+  const definition = state.config.mcpServers[serverName];
+  if (!definition || !supportsOAuth(definition) || !definition.url) {
+    return { status: "skipped" };
+  }
+
+  const grantType = definition.oauth?.grantType ?? "authorization_code";
+  if (!state.ui && grantType !== "client_credentials") {
+    return {
+      status: "failed",
+      message: `Server "${serverName}" requires OAuth authentication. Run /mcp-auth ${serverName} in an interactive session.`,
+    };
+  }
+
+  try {
+    await authenticate(serverName, definition.url, definition);
+    return { status: "success" };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      status: "failed",
+      message: `OAuth authentication failed for "${serverName}": ${message}. Run /mcp-auth ${serverName} first.`,
+    };
+  }
+}
+
 export function executeUiMessages(state: McpExtensionState): ProxyToolResult {
   const sessions = state.completedUiSessions;
 
@@ -376,12 +419,26 @@ export async function executeConnect(state: McpExtensionState, serverName: strin
     if (state.ui) {
       state.ui.setStatus("mcp", `MCP: connecting to ${serverName}...`);
     }
-    const connection = await state.manager.connect(serverName, definition);
+    let connection = await state.manager.connect(serverName, definition);
     if (connection.status === "needs-auth") {
-      return {
-        content: [{ type: "text" as const, text: `Server "${serverName}" requires OAuth authentication. Run /mcp-auth ${serverName} first.` }],
-        details: { mode: "connect", error: "auth_required", server: serverName },
-      };
+      const autoAuth = await attemptAutoAuth(state, serverName);
+      if (autoAuth.status === "failed") {
+        return {
+          content: [{ type: "text" as const, text: autoAuth.message }],
+          details: { mode: "connect", error: "auth_required", server: serverName, message: autoAuth.message },
+        };
+      }
+      if (autoAuth.status === "success") {
+        await state.manager.close(serverName);
+        connection = await state.manager.connect(serverName, definition);
+      }
+      if (connection.status === "needs-auth") {
+        const message = getAuthRequiredMessage(serverName);
+        return {
+          content: [{ type: "text" as const, text: message }],
+          details: { mode: "connect", error: "auth_required", server: serverName, message },
+        };
+      }
     }
     const prefix = state.config.settings?.toolPrefix ?? "server";
     const { metadata } = buildToolMetadata(connection.tools, connection.resources, definition, serverName, prefix);
@@ -409,6 +466,7 @@ export async function executeCall(
 ): Promise<ProxyToolResult> {
   let serverName: string | undefined = serverOverride;
   let toolMeta: ToolMetadata | undefined;
+  let autoAuthAttempted = false;
   const prefixMode = state.config.settings?.toolPrefix ?? "server";
 
   if (serverName && !state.config.mcpServers[serverName]) {
@@ -438,17 +496,48 @@ export async function executeCall(
     } else {
       const needsAuthConnection = state.manager.getConnection(serverName);
       if (needsAuthConnection?.status === "needs-auth") {
-        return {
-          content: [{ type: "text" as const, text: `Server "${serverName}" requires OAuth authentication. Run /mcp-auth ${serverName} first.` }],
-          details: { mode: "call", error: "auth_required", server: serverName },
-        };
+        if (!autoAuthAttempted) {
+          autoAuthAttempted = true;
+          const autoAuth = await attemptAutoAuth(state, serverName);
+          if (autoAuth.status === "failed") {
+            return {
+              content: [{ type: "text" as const, text: autoAuth.message }],
+              details: { mode: "call", error: "auth_required", server: serverName, message: autoAuth.message },
+            };
+          }
+          if (autoAuth.status === "success") {
+            await state.manager.close(serverName);
+            state.failureTracker.delete(serverName);
+            const connectedAfterAuth = await lazyConnect(state, serverName);
+            if (connectedAfterAuth) {
+              toolMeta = findToolByName(state.toolMetadata.get(serverName), toolName);
+              if (!toolMeta) {
+                return {
+                  content: [{ type: "text" as const, text: `Tool "${toolName}" not found on "${serverName}" after reconnect.` }],
+                  details: { mode: "call", error: "tool_not_found_after_reconnect", requestedTool: toolName },
+                };
+              }
+            }
+          }
+        }
+
+        if (!toolMeta && state.manager.getConnection(serverName)?.status === "needs-auth") {
+          const message = getAuthRequiredMessage(serverName);
+          return {
+            content: [{ type: "text" as const, text: message }],
+            details: { mode: "call", error: "auth_required", server: serverName, message },
+          };
+        }
       }
-      const failedAgo = getFailureAgeSeconds(state, serverName);
-      if (failedAgo !== null) {
-        return {
-          content: [{ type: "text" as const, text: `Server "${serverName}" not available (last failed ${failedAgo}s ago)` }],
-          details: { mode: "call", error: "server_backoff", server: serverName },
-        };
+
+      if (!toolMeta) {
+        const failedAgo = getFailureAgeSeconds(state, serverName);
+        if (failedAgo !== null) {
+          return {
+            content: [{ type: "text" as const, text: `Server "${serverName}" not available (last failed ${failedAgo}s ago)` }],
+            details: { mode: "call", error: "server_backoff", server: serverName },
+          };
+        }
       }
     }
   }
@@ -462,9 +551,27 @@ export async function executeCall(
       .sort((a, b) => b.prefix.length - a.prefix.length);
 
     for (const { name: configuredServer } of candidates) {
+      const existingConnection = state.manager.getConnection(configuredServer);
       const failedAgo = getFailureAgeSeconds(state, configuredServer);
-      if (failedAgo !== null) continue;
-      const connected = await lazyConnect(state, configuredServer);
+      if (failedAgo !== null && existingConnection?.status !== "needs-auth") continue;
+
+      let connected = await lazyConnect(state, configuredServer);
+      if (!connected && state.manager.getConnection(configuredServer)?.status === "needs-auth" && !autoAuthAttempted) {
+        autoAuthAttempted = true;
+        const autoAuth = await attemptAutoAuth(state, configuredServer);
+        if (autoAuth.status === "failed") {
+          return {
+            content: [{ type: "text" as const, text: autoAuth.message }],
+            details: { mode: "call", error: "auth_required", server: configuredServer, message: autoAuth.message },
+          };
+        }
+        if (autoAuth.status === "success") {
+          await state.manager.close(configuredServer);
+          state.failureTracker.delete(configuredServer);
+          connected = await lazyConnect(state, configuredServer);
+        }
+      }
+
       if (!connected) continue;
       if (!prefixMatchedServer) prefixMatchedServer = configuredServer;
       toolMeta = findToolByName(state.toolMetadata.get(configuredServer), toolName);
@@ -492,10 +599,29 @@ export async function executeCall(
 
   let connection = state.manager.getConnection(serverName);
   if (connection?.status === "needs-auth") {
-    return {
-      content: [{ type: "text" as const, text: `Server "${serverName}" requires OAuth authentication. Run /mcp-auth ${serverName} first.` }],
-      details: { mode: "call", error: "auth_required", server: serverName },
-    };
+    if (!autoAuthAttempted) {
+      autoAuthAttempted = true;
+      const autoAuth = await attemptAutoAuth(state, serverName);
+      if (autoAuth.status === "failed") {
+        return {
+          content: [{ type: "text" as const, text: autoAuth.message }],
+          details: { mode: "call", error: "auth_required", server: serverName, message: autoAuth.message },
+        };
+      }
+      if (autoAuth.status === "success") {
+        await state.manager.close(serverName);
+        state.failureTracker.delete(serverName);
+        connection = state.manager.getConnection(serverName);
+      }
+    }
+
+    if (connection?.status === "needs-auth") {
+      const message = getAuthRequiredMessage(serverName);
+      return {
+        content: [{ type: "text" as const, text: message }],
+        details: { mode: "call", error: "auth_required", server: serverName, message },
+      };
+    }
   }
   if (!connection || connection.status !== "connected") {
     const failedAgo = getFailureAgeSeconds(state, serverName);
@@ -520,10 +646,28 @@ export async function executeCall(
       }
       connection = await state.manager.connect(serverName, definition);
       if (connection.status === "needs-auth") {
-        return {
-          content: [{ type: "text" as const, text: `Server "${serverName}" requires OAuth authentication. Run /mcp-auth ${serverName} first.` }],
-          details: { mode: "call", error: "auth_required", server: serverName },
-        };
+        if (!autoAuthAttempted) {
+          autoAuthAttempted = true;
+          const autoAuth = await attemptAutoAuth(state, serverName);
+          if (autoAuth.status === "failed") {
+            return {
+              content: [{ type: "text" as const, text: autoAuth.message }],
+              details: { mode: "call", error: "auth_required", server: serverName, message: autoAuth.message },
+            };
+          }
+          if (autoAuth.status === "success") {
+            await state.manager.close(serverName);
+            connection = await state.manager.connect(serverName, definition);
+          }
+        }
+
+        if (connection.status === "needs-auth") {
+          const message = getAuthRequiredMessage(serverName);
+          return {
+            content: [{ type: "text" as const, text: message }],
+            details: { mode: "call", error: "auth_required", server: serverName, message },
+          };
+        }
       }
       state.failureTracker.delete(serverName);
       updateServerMetadata(state, serverName);

package/tool-metadata.ts

@@ -1,7 +1,7 @@
 import { getToolUiResourceUri } from "@modelcontextprotocol/ext-apps/app-bridge";
 import type { McpExtensionState } from "./state.js";
 import type { ToolMetadata, McpTool, McpResource, ServerEntry } from "./types.js";
-import { formatToolName } from "./types.js";
+import { formatToolName, isToolExcluded } from "./types.js";
 import { resourceNameToToolName } from "./resource-tools.js";
 import { extractToolUiStreamMode } from "./utils.js";
 
@@ -20,6 +20,10 @@ export function buildToolMetadata(
       failedTools.push("(unnamed)");
       continue;
     }
+    if (isToolExcluded(tool.name, serverName, prefix, definition.excludeTools)) {
+      continue;
+    }
+
     let uiResourceUri: string | undefined;
     try {
       uiResourceUri = getToolUiResourceUri({ _meta: tool._meta });
@@ -39,6 +43,10 @@ export function buildToolMetadata(
   if (definition.exposeResources !== false) {
     for (const resource of resources) {
       const baseName = `get_${resourceNameToToolName(resource.name)}`;
+      if (isToolExcluded(baseName, serverName, prefix, definition.excludeTools)) {
+        continue;
+      }
+
       metadata.push({
         name: formatToolName(baseName, serverName, prefix),
         originalName: baseName,

package/types.ts

@@ -305,6 +305,8 @@ export interface ServerEntry {
   exposeResources?: boolean;
   // Direct tool registration
   directTools?: boolean | string[];
+  // Exclude specific MCP tools/resources by original or prefixed name
+  excludeTools?: string[];
   // Debug
   debug?: boolean;  // Show server stderr (default: false)
 }
@@ -314,6 +316,8 @@ export interface McpSettings {
   toolPrefix?: "server" | "none" | "short";
   idleTimeout?: number; // minutes, default 10, 0 to disable
   directTools?: boolean;
+  disableProxyTool?: boolean;
+  autoAuth?: boolean;
 }
 
 // Root config
@@ -391,3 +395,32 @@ export function formatToolName(
   const p = getServerPrefix(serverName, prefix);
   return p ? `${p}_${toolName}` : toolName;
 }
+
+function normalizeToolName(value: string): string {
+  return value.replace(/-/g, "_");
+}
+
+export function isToolExcluded(
+  toolName: string,
+  serverName: string,
+  prefix: "server" | "none" | "short",
+  excludeTools?: unknown
+): boolean {
+  if (!Array.isArray(excludeTools) || excludeTools.length === 0) return false;
+
+  const candidates = new Set<string>([
+    normalizeToolName(toolName),
+    normalizeToolName(formatToolName(toolName, serverName, prefix)),
+    normalizeToolName(formatToolName(toolName, serverName, "server")),
+    normalizeToolName(formatToolName(toolName, serverName, "short")),
+  ]);
+
+  for (const excluded of excludeTools) {
+    if (typeof excluded !== "string") continue;
+    if (candidates.has(normalizeToolName(excluded))) {
+      return true;
+    }
+  }
+
+  return false;
+}

package/utils.ts

@@ -1,25 +1,34 @@
 import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
 import { platform } from "node:os";
 
-export async function openUrl(pi: ExtensionAPI, url: string, browser?: string): Promise<void> {
+async function execOpen(pi: ExtensionAPI, target: string, browser?: string) {
   const os = platform();
-  let result;
 
   if (os === "darwin") {
-    result = browser ? await pi.exec("open", ["-a", browser, url]) : await pi.exec("open", [url]);
-  } else if (os === "win32") {
-    result = browser
-      ? await pi.exec("cmd", ["/c", "start", "", browser, url])
-      : await pi.exec("cmd", ["/c", "start", "", url]);
-  } else {
-    result = browser ? await pi.exec(browser, [url]) : await pi.exec("xdg-open", [url]);
+    return browser ? pi.exec("open", ["-a", browser, target]) : pi.exec("open", [target]);
+  }
+  if (os === "win32") {
+    return browser
+      ? pi.exec("cmd", ["/c", "start", "", browser, target])
+      : pi.exec("cmd", ["/c", "start", "", target]);
   }
+  return browser ? pi.exec(browser, [target]) : pi.exec("xdg-open", [target]);
+}
 
+export async function openUrl(pi: ExtensionAPI, url: string, browser?: string): Promise<void> {
+  const result = await execOpen(pi, url, browser);
   if (result.code !== 0) {
     throw new Error(result.stderr || `Failed to open browser (exit code ${result.code})`);
   }
 }
 
+export async function openPath(pi: ExtensionAPI, targetPath: string): Promise<void> {
+  const result = await execOpen(pi, targetPath);
+  if (result.code !== 0) {
+    throw new Error(result.stderr || `Failed to open path (exit code ${result.code})`);
+  }
+}
+
 export async function parallelLimit<T, R>(
   items: T[],
   limit: number,