@cnwenf/occ 2.1.340 → 2.1.341

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-globalThis.MACRO={"VERSION":"2.1.340","BINARY_NAME":"occ","BUILD_TIME":"2026-09-17T20:08:32.450Z","FEEDBACK_CHANNEL":"","ISSUES_EXPLAINER":"","NATIVE_PACKAGE_URL":"","PACKAGE_URL":"@cnwenf/occ","VERSION_CHANGELOG":""};
+globalThis.MACRO={"VERSION":"2.1.341","BINARY_NAME":"occ","BUILD_TIME":"2026-09-18T01:06:37.948Z","FEEDBACK_CHANNEL":"","ISSUES_EXPLAINER":"","NATIVE_PACKAGE_URL":"","PACKAGE_URL":"@cnwenf/occ","VERSION_CHANGELOG":""};
 // @bun
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
@@ -627164,6 +627164,52 @@ async function fetchAuthServerMetadata(serverName, serverUrl, configuredMetadata
     ...fetchFn && { fetchFn }
   });
 }
+function getOAuthCallbackSubmitter(serverName) {
+  return oauthCallbackSubmitters.get(serverName);
+}
+function setActiveOAuthPromise(serverName, promise3) {
+  activeOAuthFlows.set(serverName, promise3);
+  promise3.finally(() => {
+    if (activeOAuthFlows.get(serverName) === promise3) {
+      activeOAuthFlows.delete(serverName);
+    }
+  }).catch(() => {});
+}
+function getActiveOAuthPromise(serverName) {
+  return activeOAuthFlows.get(serverName);
+}
+function createManualCallbackSubmitter(serverName, oauthState, hooks) {
+  return (callbackUrl) => {
+    try {
+      const parsed = new URL(callbackUrl);
+      const code = parsed.searchParams.get("code");
+      const state3 = parsed.searchParams.get("state");
+      const error52 = parsed.searchParams.get("error");
+      if (!code && !error52) {
+        return false;
+      }
+      if (state3 !== oauthState) {
+        logMCPDebug(serverName, "Ignoring manual callback URL whose state belongs to a different flow");
+        return false;
+      }
+      if (error52) {
+        const errorDescription = parsed.searchParams.get("error_description") || "";
+        hooks.cleanup();
+        hooks.rejectFlow(new Error(`OAuth error: ${error52} - ${errorDescription}`));
+        return true;
+      }
+      if (!code) {
+        return false;
+      }
+      logMCPDebug(serverName, "Received auth code via manual callback URL");
+      hooks.cleanup();
+      hooks.resolveCode(code);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+}
 function getServerKey(serverName, serverConfig) {
   const configJson = jsonStringify({
     type: serverConfig.type,
@@ -627521,6 +627567,7 @@ async function performMCPOAuthFlow(serverName, serverConfig, onAuthorizationUrl,
     let server = null;
     let timeoutId = null;
     let abortHandler = null;
+    let manualSubmitter = null;
     const cleanup2 = () => {
       if (server) {
         server.removeAllListeners();
@@ -627536,6 +627583,13 @@ async function performMCPOAuthFlow(serverName, serverConfig, onAuthorizationUrl,
         abortSignal.removeEventListener("abort", abortHandler);
         abortHandler = null;
       }
+      if (manualSubmitter && oauthCallbackSubmitters.get(serverName) === manualSubmitter) {
+        oauthCallbackSubmitters.delete(serverName);
+      }
+      if (manualSubmitter && oauthFlowRecords.get(serverName)?.submitter === manualSubmitter) {
+        oauthFlowRecords.delete(serverName);
+      }
+      manualSubmitter = null;
       logMCPDebug(serverName, `MCP OAuth server cleaned up`);
     };
     const authorizationCode = await new Promise((resolve53, reject2) => {
@@ -627563,32 +627617,37 @@ async function performMCPOAuthFlow(serverName, serverConfig, onAuthorizationUrl,
         }
         abortSignal.addEventListener("abort", abortHandler);
       }
-      if (options?.onWaitingForCallback) {
-        options.onWaitingForCallback((callbackUrl) => {
-          try {
-            const parsed = new URL(callbackUrl);
-            const code = parsed.searchParams.get("code");
-            const state3 = parsed.searchParams.get("state");
-            const error52 = parsed.searchParams.get("error");
-            if (error52) {
-              const errorDescription = parsed.searchParams.get("error_description") || "";
-              cleanup2();
-              rejectOnce(new Error(`OAuth error: ${error52} - ${errorDescription}`));
-              return;
-            }
-            if (!code) {
-              return;
-            }
-            if (state3 !== oauthState) {
-              cleanup2();
-              rejectOnce(new Error("OAuth state mismatch - possible CSRF attack"));
-              return;
-            }
-            logMCPDebug(serverName, `Received auth code via manual callback URL`);
-            cleanup2();
-            resolveOnce(code);
-          } catch {}
-        });
+      manualSubmitter = createManualCallbackSubmitter(serverName, oauthState, {
+        cleanup: cleanup2,
+        resolveCode: resolveOnce,
+        rejectFlow: rejectOnce
+      });
+      const supersededFlow = oauthFlowRecords.get(serverName);
+      if (supersededFlow) {
+        logMCPDebug(serverName, `Cancelling superseded OAuth flow (epoch ${supersededFlow.epoch}) \u2014 a newer flow is taking over`);
+        supersededFlow.cancel();
+      }
+      const flowRecord = {
+        epoch: ++oauthFlowEpochCounter,
+        submitter: manualSubmitter,
+        cancel: () => {
+          cleanup2();
+          rejectOnce(new AuthenticationCancelledError);
+        }
+      };
+      oauthFlowRecords.set(serverName, flowRecord);
+      oauthCallbackSubmitters.set(serverName, manualSubmitter);
+      try {
+        options?.onWaitingForCallback?.(manualSubmitter, redirectUri, oauthState);
+      } catch (callbackError) {
+        if (oauthCallbackSubmitters.get(serverName) === manualSubmitter) {
+          oauthCallbackSubmitters.delete(serverName);
+        }
+        if (oauthFlowRecords.get(serverName) === flowRecord) {
+          oauthFlowRecords.delete(serverName);
+        }
+        manualSubmitter = null;
+        throw callbackError;
       }
       server = createServer6((req, res) => {
         const parsedUrl = parse14(req.url || "", true);
@@ -628428,7 +628487,7 @@ function getScopeFromMetadata(metadata) {
   }
   return;
 }
-var import_xss2, AUTH_REQUEST_TIMEOUT_MS = 30000, MAX_LOCK_RETRIES = 5, SENSITIVE_OAUTH_PARAMS, NONSTANDARD_INVALID_GRANT_ALIASES, AuthenticationCancelledError;
+var import_xss2, AUTH_REQUEST_TIMEOUT_MS = 30000, MAX_LOCK_RETRIES = 5, SENSITIVE_OAUTH_PARAMS, NONSTANDARD_INVALID_GRANT_ALIASES, AuthenticationCancelledError, oauthCallbackSubmitters, activeOAuthFlows, oauthFlowRecords, oauthFlowEpochCounter = 0;
 var init_auth11 = __esm(() => {
   init_auth10();
   init_errors12();
@@ -628468,6 +628527,9 @@ var init_auth11 = __esm(() => {
       this.name = "AuthenticationCancelledError";
     }
   };
+  oauthCallbackSubmitters = new Map;
+  activeOAuthFlows = new Map;
+  oauthFlowRecords = new Map;
 });
 
 // src/services/mcp/displaySanitize.ts
@@ -628532,20 +628594,205 @@ var init_displaySanitize = __esm(() => {
   INVISIBLE_PATTERN = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}\p{Default_Ignorable_Code_Point}\u2800]|(?!\u0020)\p{Zs}/gu;
 });
 
+// src/tools/McpAuthTool/mcpAuthStubShared.ts
+function isRemoteOAuthSession() {
+  return env4.isSSH() || isEnvTruthy(process.env.CLAUDE_CODE_REMOTE);
+}
+function extractOAuthRedirectUri(authUrl) {
+  try {
+    const redirectUri = new URL(authUrl).searchParams.get("redirect_uri");
+    if (redirectUri) {
+      return redirectUri;
+    }
+  } catch {}
+  return "http://localhost:<port>/callback";
+}
+var MCP_AUTH_TOOL_SUFFIX = "authenticate", MCP_COMPLETE_AUTH_TOOL_SUFFIX = "complete_authentication", TOOLS_BECOME_AVAILABLE_TEXT = "available automatically", TOOLS_NOW_AVAILABLE_SENTENCE = "The server's tools should now be available.";
+var init_mcpAuthStubShared = __esm(() => {
+  init_env();
+  init_envUtils();
+});
+
+// src/tools/McpAuthTool/McpCompleteAuthTool.ts
+function buildMcpCompleteAuthToolDescription(serverName) {
+  const authenticateToolName = buildMcpToolName(serverName, MCP_AUTH_TOOL_SUFFIX);
+  return `Complete an in-progress OAuth flow for the "${sanitizeServerNameForDisplay(serverName)}" MCP server by submitting the callback URL. Call \`${authenticateToolName}\` first to start the flow and get the authorization URL. ` + "After the user authorizes in their browser, the browser is redirected to a `http://localhost:<port>/callback?code=...&state=...` URL \u2014 " + "on remote sessions that page fails to load, but the URL in the address bar is still valid. Pass that full URL here as `callback_url`.";
+}
+function createMcpCompleteAuthTool(serverName, config7, resolveUnexpanded = resolveUnexpandedMcpServers) {
+  const description = buildMcpCompleteAuthToolDescription(serverName);
+  return {
+    name: buildMcpToolName(serverName, MCP_COMPLETE_AUTH_TOOL_SUFFIX),
+    isMcp: true,
+    mcpInfo: { serverName, toolName: MCP_COMPLETE_AUTH_TOOL_SUFFIX },
+    isEnabled: () => true,
+    isConcurrencySafe: () => false,
+    isReadOnly: () => false,
+    toAutoClassifierInput: () => serverName,
+    userFacingName: () => `${serverName} - complete authentication (MCP)`,
+    maxResultSizeChars: 1e4,
+    renderToolUseMessage: () => `Complete authentication for ${serverName} MCP server`,
+    async description() {
+      return description;
+    },
+    async prompt() {
+      return description;
+    },
+    get inputSchema() {
+      return inputSchema45();
+    },
+    async checkPermissions(input2) {
+      return { behavior: "allow", updatedInput: input2 };
+    },
+    async call(input2) {
+      const { callback_url: callbackUrl } = input2;
+      const displayName = sanitizeServerNameForDisplay(serverName);
+      const authenticateToolName = buildMcpToolName(serverName, MCP_AUTH_TOOL_SUFFIX);
+      const submitter = getOAuthCallbackSubmitter(serverName);
+      if (!submitter) {
+        return {
+          data: {
+            status: "error",
+            message: `No OAuth flow is in progress for ${displayName}. Call \`${authenticateToolName}\` first, then retry with the callback URL.`
+          }
+        };
+      }
+      let hasCodeOrError = false;
+      try {
+        const parsed = new URL(callbackUrl);
+        hasCodeOrError = parsed.searchParams.has("code") || parsed.searchParams.has("error");
+      } catch {}
+      if (!hasCodeOrError) {
+        return {
+          data: {
+            status: "error",
+            message: "Invalid callback URL: missing authorization code. Ask the user to paste the full redirect URL from their browser's address bar, including the `?code=...&state=...` query string."
+          }
+        };
+      }
+      if (!submitter(callbackUrl)) {
+        return {
+          data: {
+            status: "error",
+            message: `That callback URL belongs to a different sign-in attempt for ${displayName} (its state does not match the flow in progress), or carries no authorization code. The current flow is still waiting: ask the user for the URL from the page this sign-in opened, then retry.`
+          }
+        };
+      }
+      const activeFlow = getActiveOAuthPromise(serverName);
+      if (!activeFlow) {
+        return {
+          data: {
+            status: "error",
+            message: `The callback URL was accepted by the in-progress OAuth flow for ${displayName}, but that flow was started outside this session's tool path (e.g. \`occ mcp login\` or a headless control channel), so its token exchange cannot be tracked here. The surface that started the flow will report completion \u2014 do not retry this tool.`
+          }
+        };
+      }
+      try {
+        await activeFlow;
+        return {
+          data: {
+            status: "success",
+            message: `Authentication complete for ${displayName}. ${TOOLS_NOW_AVAILABLE_SENTENCE}`
+          }
+        };
+      } catch (err2) {
+        if (err2 instanceof AuthenticationCancelledError) {
+          return {
+            data: {
+              status: "error",
+              message: `The OAuth flow for ${displayName} was cancelled (a newer attempt may have superseded it). Call \`${authenticateToolName}\` again to restart.`
+            }
+          };
+        }
+        return {
+          data: {
+            status: "error",
+            message: `Authentication failed for ${displayName}: ${sanitizeForDisplay(redactMcpErrorDetail(serverName, config7, errorMessage(err2), resolveUnexpanded))}`
+          }
+        };
+      }
+    },
+    mapToolResultToToolResultBlockParam(data, toolUseID) {
+      return {
+        tool_use_id: toolUseID,
+        type: "tool_result",
+        content: data.message
+      };
+    }
+  };
+}
+var inputSchema45;
+var init_McpCompleteAuthTool = __esm(() => {
+  init_v4();
+  init_auth11();
+  init_displaySanitize();
+  init_mcpStringUtils();
+  init_redaction();
+  init_utils9();
+  init_errors();
+  init_mcpAuthStubShared();
+  inputSchema45 = lazySchema(() => exports_external.object({
+    callback_url: exports_external.string().describe("The full callback URL from the browser address bar after authorizing, e.g. http://localhost:<port>/callback?code=...&state=...")
+  }));
+});
+
 // src/tools/McpAuthTool/McpAuthTool.ts
+function normalizeHostnameForMatch(hostname4) {
+  return hostname4.toLowerCase().replace(/\.$/, "");
+}
+function isAnthropicHostedMcpUrl(url3) {
+  if (!url3) {
+    return false;
+  }
+  try {
+    const blocked = new Set(ANTHROPIC_HOSTED_OAUTH_BLOCKED_HOSTS.map(normalizeHostnameForMatch));
+    return blocked.has(normalizeHostnameForMatch(new URL(url3).hostname));
+  } catch {
+    return false;
+  }
+}
+function renderMcpRemoveCommand(serverName) {
+  if (!COMMAND_ARG_SAFE_PATTERN.test(serverName)) {
+    return null;
+  }
+  return `occ mcp remove ${serverName}`;
+}
+function buildAnthropicHostedMessage(serverName, scope) {
+  const base2 = `"${sanitizeServerNameForDisplay(serverName)}" is Anthropic-hosted and doesn't support local OAuth. ` + "Connect it via Settings \u2192 Connectors on claude.ai (requires " + "`claude login`), then it'll be available here automatically.";
+  const removeCommand = scope === "local" || scope === "project" || scope === "user" ? renderMcpRemoveCommand(serverName) : null;
+  if (!removeCommand) {
+    return base2;
+  }
+  const withRemove = `${base2} Remove the stale entry with: \`${removeCommand}\``;
+  return [...withRemove].length <= 1024 ? withRemove : base2;
+}
+function classifyMcpServerAuthBlock(serverName, config7) {
+  if (!isMcpServerAllowedByPolicy(serverName, config7)) {
+    return "managed-policy";
+  }
+  if (config7.scope === "project" && getProjectMcpServerStatus(serverName) !== "approved") {
+    return "project-approval";
+  }
+  return null;
+}
+function managedPolicyBlockMessage(serverName) {
+  return `"${sanitizeServerNameForDisplay(serverName)}" is blocked by your organization's managed policy \u2014 it can't be authenticated or reconnected here`;
+}
+function projectApprovalBlockMessage(serverName) {
+  return `"${sanitizeServerNameForDisplay(serverName)}" is a project-scope MCP server (.mcp.json) that is not approved for this project \u2014 approve it via /mcp first, then authenticate or reconnect it`;
+}
 function buildMcpAuthToolDescription(serverName, config7, resolveUnexpanded = resolveUnexpandedMcpServers) {
   const transport = config7.type ?? "stdio";
   const displayOrigin = getMcpErrorEndpoint(serverName, config7, { detail: "origin" }, resolveUnexpanded);
   const location = displayOrigin && displayOrigin !== transport ? `${transport} at ${sanitizeDisplayUrl(displayOrigin, 256)}` : transport;
-  return `The "${sanitizeServerNameForDisplay(serverName)}" MCP server (${location}) is installed but requires authentication. ` + `Call this tool to start the OAuth flow \u2014 you'll receive an authorization URL to share with the user. ` + `Once the user completes authorization in their browser, the server's real tools will become available automatically.`;
+  return `The "${sanitizeServerNameForDisplay(serverName)}" MCP server (${location}) is installed but requires authentication. ` + `Call this tool to start the OAuth flow \u2014 you'll receive an authorization URL to share with the user. ` + `Once the user completes authorization in their browser, the server's real tools will become ${TOOLS_BECOME_AVAILABLE_TEXT}.`;
 }
 function createMcpAuthTool(serverName, config7, resolveUnexpanded = resolveUnexpandedMcpServers) {
   const transport = config7.type ?? "stdio";
   const description = buildMcpAuthToolDescription(serverName, config7, resolveUnexpanded);
   return {
-    name: buildMcpToolName(serverName, "authenticate"),
+    name: buildMcpToolName(serverName, MCP_AUTH_TOOL_SUFFIX),
     isMcp: true,
-    mcpInfo: { serverName, toolName: "authenticate" },
+    mcpInfo: { serverName, toolName: MCP_AUTH_TOOL_SUFFIX },
     isEnabled: () => true,
     isConcurrencySafe: () => false,
     isReadOnly: () => false,
@@ -628560,17 +628807,43 @@ function createMcpAuthTool(serverName, config7, resolveUnexpanded = resolveUnexp
       return description;
     },
     get inputSchema() {
-      return inputSchema45();
+      return inputSchema46();
     },
     async checkPermissions(input2) {
       return { behavior: "allow", updatedInput: input2 };
     },
     async call(_input, context7) {
+      const displayName = sanitizeServerNameForDisplay(serverName);
+      const policyBlock = classifyMcpServerAuthBlock(serverName, config7);
+      if (policyBlock === "managed-policy") {
+        return {
+          data: {
+            status: "error",
+            message: `${managedPolicyBlockMessage(serverName)}. Only an organization admin can change this; do not retry or ask the user to enable it.`
+          }
+        };
+      }
+      if (isMcpServerDisabled(serverName)) {
+        return {
+          data: {
+            status: "error",
+            message: `MCP server ${displayName} is disabled. Ask the user to enable it in /mcp before authenticating.`
+          }
+        };
+      }
+      if (policyBlock === "project-approval") {
+        return {
+          data: {
+            status: "error",
+            message: `${projectApprovalBlockMessage(serverName)}. Ask the user to approve it; do not retry until they have.`
+          }
+        };
+      }
       if (config7.type === "claudeai-proxy") {
         return {
           data: {
             status: "unsupported",
-            message: `This is a claude.ai MCP connector. Ask the user to run /mcp and select "${serverName}" to authenticate.`
+            message: `This is a claude.ai MCP connector. Ask the user to run /mcp and select "${displayName}" to authenticate.`
           }
         };
       }
@@ -628578,7 +628851,15 @@ function createMcpAuthTool(serverName, config7, resolveUnexpanded = resolveUnexp
         return {
           data: {
             status: "unsupported",
-            message: `Server "${serverName}" uses ${transport} transport which does not support OAuth from this tool. Ask the user to run /mcp and authenticate manually.`
+            message: `Server "${displayName}" uses ${transport} transport which does not support OAuth from this tool. Ask the user to run /mcp and authenticate manually.`
+          }
+        };
+      }
+      if (isAnthropicHostedMcpUrl(config7.url)) {
+        return {
+          data: {
+            status: "unsupported",
+            message: sanitizeForDisplay(buildAnthropicHostedMessage(serverName, config7.scope), 1024, "none")
           }
         };
       }
@@ -628587,11 +628868,15 @@ function createMcpAuthTool(serverName, config7, resolveUnexpanded = resolveUnexp
       const authUrlPromise = new Promise((resolve53) => {
         resolveAuthUrl = resolve53;
       });
-      const controller = new AbortController;
       const { setAppState } = context7;
-      const oauthPromise = performMCPOAuthFlow(serverName, sseOrHttpConfig, (u7) => resolveAuthUrl?.(u7), controller.signal, { skipBrowserOpen: true });
+      const oauthPromise = performMCPOAuthFlow(serverName, sseOrHttpConfig, (u7) => resolveAuthUrl?.(u7), undefined, { skipBrowserOpen: true });
+      setActiveOAuthPromise(serverName, oauthPromise);
       oauthPromise.then(async () => {
         clearMcpAuthCache();
+        if (isMcpServerDisabled(serverName) || !isMcpServerAllowedByPolicy(serverName, config7)) {
+          logMCPDebug(serverName, "OAuth completed but the server is now disabled or policy-blocked; not reconnecting");
+          return;
+        }
         const result = await reconnectMcpServerImpl(serverName, config7);
         const prefix = getMcpPrefix(serverName);
         setAppState((prev) => ({
@@ -628612,7 +628897,7 @@ function createMcpAuthTool(serverName, config7, resolveUnexpanded = resolveUnexp
         }));
         logMCPDebug(serverName, `OAuth complete, reconnected with ${result.tools.length} tool(s)`);
       }).catch((err2) => {
-        logMCPError(serverName, `OAuth flow failed after tool-triggered start: ${errorMessage(err2)}`);
+        logMCPError(serverName, `OAuth flow failed after tool-triggered start: ${sanitizeForDisplay(redactMcpErrorDetail(serverName, config7, errorMessage(err2), resolveUnexpanded), 2000)}`);
       });
       try {
         const authUrl = await Promise.race([
@@ -628620,29 +628905,37 @@ function createMcpAuthTool(serverName, config7, resolveUnexpanded = resolveUnexp
           oauthPromise.then(() => null)
         ]);
         if (authUrl) {
+          const completeAuthToolName = buildMcpToolName(serverName, MCP_COMPLETE_AUTH_TOOL_SUFFIX);
+          const redirectUri = extractOAuthRedirectUri(authUrl);
+          const callbackGuidance = isRemoteOAuthSession() ? `
+
+This session is remote, so after authorizing the browser will try to load \`${redirectUri}?code=...\` and show a connection error \u2014 that's expected. Ask the user to copy the full URL from the browser's address bar and paste it into chat, then call \`${completeAuthToolName}\` with that URL as \`callback_url\`.` : `
+
+If the browser shows a connection error on the redirect page, ask the user to paste the full URL from the address bar and call \`${completeAuthToolName}\` with it.`;
           return {
             data: {
               status: "auth_url",
               authUrl,
-              message: `Ask the user to open this URL in their browser to authorize the ${serverName} MCP server:
+              message: `Ask the user to open this URL in their browser to authorize the ${displayName} MCP server:
 
 ${authUrl}
 
-Once they complete the flow, the server's tools will become available automatically.`
+Once they complete the flow, the server's tools will become ${TOOLS_BECOME_AVAILABLE_TEXT}.${callbackGuidance}`
             }
           };
         }
         return {
           data: {
             status: "auth_url",
-            message: `Authentication completed silently for ${serverName}. The server's tools should now be available.`
+            message: `Authentication completed silently for ${displayName}. ${TOOLS_NOW_AVAILABLE_SENTENCE}`
           }
         };
       } catch (err2) {
+        const failureDetail = sanitizeForDisplay(redactMcpErrorDetail(serverName, config7, errorMessage(err2), resolveUnexpanded));
         return {
           data: {
             status: "error",
-            message: `Failed to start OAuth flow for ${serverName}: ${errorMessage(err2)}. Ask the user to run /mcp and authenticate manually.`
+            message: `Failed to start OAuth flow for ${displayName}: ${failureDetail}. Ask the user to run /mcp and authenticate manually.`
           }
         };
       }
@@ -628656,19 +628949,38 @@ Once they complete the flow, the server's tools will become available automatica
     }
   };
 }
-var inputSchema45;
+function createMcpAuthStubTools(serverName, config7, resolveUnexpanded = resolveUnexpandedMcpServers) {
+  if (getIsNonInteractiveSession()) {
+    return [];
+  }
+  return [
+    createMcpAuthTool(serverName, config7, resolveUnexpanded),
+    createMcpCompleteAuthTool(serverName, config7, resolveUnexpanded)
+  ];
+}
+var inputSchema46, ANTHROPIC_HOSTED_OAUTH_BLOCKED_HOSTS, COMMAND_ARG_SAFE_PATTERN;
 var init_McpAuthTool = __esm(() => {
   init_reject2();
   init_v4();
+  init_state();
   init_auth11();
   init_client12();
+  init_config6();
   init_displaySanitize();
   init_mcpStringUtils();
   init_redaction();
   init_utils9();
   init_errors();
   init_log3();
-  inputSchema45 = lazySchema(() => exports_external.object({}));
+  init_McpCompleteAuthTool();
+  init_mcpAuthStubShared();
+  inputSchema46 = lazySchema(() => exports_external.object({}));
+  ANTHROPIC_HOSTED_OAUTH_BLOCKED_HOSTS = [
+    "microsoft365.mcp.claude.com",
+    "gmail.mcp.claude.com",
+    "gcal.mcp.claude.com"
+  ];
+  COMMAND_ARG_SAFE_PATTERN = /^\w[\w.@-]*$/;
 });
 
 // src/utils/mcpWebSocketTransport.ts
@@ -631869,7 +632181,7 @@ async function getMcpToolsCommandsAndResources(onConnectionAttempt, mcpConfigs)
         logMCPDebug(name3, `Skipping connection (cached needs-auth)`);
         onConnectionAttempt({
           client: { name: name3, type: "needs-auth", config: config7 },
-          tools: [createMcpAuthTool(name3, config7)],
+          tools: createMcpAuthStubTools(name3, config7),
           commands: []
         });
         return;
@@ -631878,7 +632190,7 @@ async function getMcpToolsCommandsAndResources(onConnectionAttempt, mcpConfigs)
       if (client8.type !== "connected") {
         onConnectionAttempt({
           client: client8,
-          tools: client8.type === "needs-auth" ? [createMcpAuthTool(name3, config7)] : [],
+          tools: client8.type === "needs-auth" ? createMcpAuthStubTools(name3, config7) : [],
           commands: []
         });
         return;
@@ -793589,6 +793901,7 @@ var exports_toolPool = {};
 __export(exports_toolPool, {
   mergeAndFilterTools: () => mergeAndFilterTools,
   isPrActivitySubscriptionTool: () => isPrActivitySubscriptionTool,
+  deferInitialMcpToolsToLiveState: () => deferInitialMcpToolsToLiveState,
   applyCoordinatorToolFilter: () => applyCoordinatorToolFilter
 });
 function isPrActivitySubscriptionTool(name3) {
@@ -793608,18 +793921,48 @@ function mergeAndFilterTools(initialTools, assembled, mode) {
   }
   return tools;
 }
-var PR_ACTIVITY_TOOL_SUFFIXES, coordinatorModeModule2;
+function isMcpAuthStubName(name3) {
+  return name3.endsWith(`__${MCP_AUTH_TOOL_SUFFIX}`) || name3.endsWith(`__${MCP_COMPLETE_AUTH_TOOL_SUFFIX}`);
+}
+function deferInitialMcpToolsToLiveState(initialTools, liveClients, liveTools = []) {
+  if (liveClients.length === 0) {
+    return initialTools;
+  }
+  const clientsWithPrefix = liveClients.map((client8) => ({
+    prefix: getMcpPrefix(client8.name),
+    type: client8.type
+  }));
+  const allPrefixes = clientsWithPrefix.map((entry) => entry.prefix);
+  const prefixesWithLiveTools = new Set(clientsWithPrefix.filter(({ prefix }) => liveTools.some((t4) => t4.name?.startsWith(prefix))).map(({ prefix }) => prefix));
+  const stubPreservingPrefixes = new Set(clientsWithPrefix.filter(({ prefix, type }) => type !== undefined && AUTH_STUB_PRESERVING_STATES.has(type) && !prefixesWithLiveTools.has(prefix)).map(({ prefix }) => prefix));
+  return initialTools.filter((tool) => {
+    const name3 = tool.name;
+    if (name3 === undefined) {
+      return true;
+    }
+    for (const prefix of stubPreservingPrefixes) {
+      if (name3.startsWith(prefix) && isMcpAuthStubName(name3)) {
+        return true;
+      }
+    }
+    return !allPrefixes.some((prefix) => name3.startsWith(prefix));
+  });
+}
+var PR_ACTIVITY_TOOL_SUFFIXES, coordinatorModeModule2, AUTH_STUB_PRESERVING_STATES;
 var init_toolPool = __esm(() => {
   init_featureFlags();
   init_partition();
   init_uniqBy();
   init_tools();
+  init_mcpStringUtils();
   init_utils9();
+  init_mcpAuthStubShared();
   PR_ACTIVITY_TOOL_SUFFIXES = [
     "subscribe_pr_activity",
     "unsubscribe_pr_activity"
   ];
   coordinatorModeModule2 = feature("COORDINATOR_MODE") ? (init_coordinatorMode(), __toCommonJS(exports_coordinatorMode)) : null;
+  AUTH_STUB_PRESERVING_STATES = new Set(["failed", "disabled"]);
 });
 
 // src/hooks/useMergedTools.ts
@@ -798942,13 +799285,13 @@ function permissionPromptToolResultToPermissionDecision(result, tool, input2, to
     decisionReason
   };
 }
-var inputSchema46, decisionClassificationField, PermissionAllowResultSchema, PermissionDenyResultSchema, outputSchema41;
+var inputSchema47, decisionClassificationField, PermissionAllowResultSchema, PermissionDenyResultSchema, outputSchema41;
 var init_PermissionPromptToolResultSchema = __esm(() => {
   init_v4();
   init_debug();
   init_PermissionUpdate();
   init_PermissionUpdateSchema();
-  inputSchema46 = lazySchema(() => v4_default.object({
+  inputSchema47 = lazySchema(() => v4_default.object({
     tool_name: v4_default.string().describe("The name of the tool requesting permission"),
     input: v4_default.record(v4_default.string(), v4_default.unknown()).describe("The input for the tool"),
     tool_use_id: v4_default.string().optional().describe("The unique tool use request ID")
@@ -805689,6 +806032,7 @@ function REPL({
   const combinedInitialTools = import_react321.useMemo(() => {
     return [...localTools, ...initialTools];
   }, [localTools, initialTools]);
+  const effectiveInitialTools = import_react321.useMemo(() => deferInitialMcpToolsToLiveState(combinedInitialTools, mcp2.clients, mcp2.tools), [combinedInitialTools, mcp2.clients, mcp2.tools]);
   useManagePlugins({
     enabled: !isRemoteSession
   });
@@ -805710,7 +806054,7 @@ function REPL({
   useSwarmInitialization(setAppState, initialMessages, {
     enabled: !isRemoteSession
   });
-  const mergedTools = useMergedTools(combinedInitialTools, mcp2.tools, toolPermissionContext);
+  const mergedTools = useMergedTools(effectiveInitialTools, mcp2.tools, toolPermissionContext);
   const {
     tools,
     allowedAgentTypes
@@ -806726,7 +807070,7 @@ Error: sandbox required but unavailable: ${reason}
     const computeTools = () => {
       const state4 = store.getState();
       const assembled = assembleToolPool(state4.toolPermissionContext, state4.mcp.tools);
-      const merged = mergeAndFilterTools(combinedInitialTools, assembled, state4.toolPermissionContext.mode);
+      const merged = mergeAndFilterTools(deferInitialMcpToolsToLiveState(combinedInitialTools, state4.mcp.clients, state4.mcp.tools), assembled, state4.toolPermissionContext.mode);
       if (!mainThreadAgentDefinition)
         return merged;
       return resolveAgentTools(mainThreadAgentDefinition, merged, false, true).resolvedTools;
@@ -820057,6 +820401,42 @@ var init_remoteIO = __esm(() => {
   };
 });
 
+// src/cli/mcpOAuthCallbackControl.ts
+async function handleOAuthCallbackUrlControl(serverName, callbackUrl, deps) {
+  const submit = deps.getSubmitter(serverName);
+  if (!submit) {
+    deps.respondError(`No active OAuth flow for server: ${serverName}`);
+    return;
+  }
+  let hasCodeOrError = false;
+  try {
+    const parsed = new URL(callbackUrl);
+    hasCodeOrError = parsed.searchParams.has("code") || parsed.searchParams.has("error");
+  } catch {}
+  if (!hasCodeOrError) {
+    deps.respondError(CALLBACK_MISSING_CODE_MESSAGE);
+    return;
+  }
+  const accepted = submit(callbackUrl);
+  if (!accepted) {
+    deps.respondError(CALLBACK_NOT_ACCEPTED_MESSAGE);
+    return;
+  }
+  deps.markManualCallbackUsed(serverName);
+  const authPromise = deps.getAuthPromise(serverName);
+  if (!authPromise) {
+    deps.respondSuccess();
+    return;
+  }
+  try {
+    await authPromise;
+    deps.respondSuccess();
+  } catch (error52) {
+    deps.respondError(error52 instanceof Error ? error52.message : "OAuth authentication failed");
+  }
+}
+var CALLBACK_NOT_ACCEPTED_MESSAGE = "Callback URL was not accepted: its state does not match the flow in progress (or it carries no authorization code). The OAuth flow is still waiting \u2014 send the redirect URL from the authorization page this flow opened.", CALLBACK_MISSING_CODE_MESSAGE = "Invalid callback URL: missing authorization code. Please paste the full redirect URL including the code parameter.";
+
 // src/utils/streamlinedTransform.ts
 function categorizeToolName(toolName) {
   if (SEARCH_TOOLS2.some((t4) => toolName.startsWith(t4)))
@@ -822162,7 +822542,7 @@ function runHeadlessStreaming(structuredIO, mcpClients, commands7, tools, initia
   };
   const buildAllTools = (appState) => {
     const assembledTools = assembleToolPool(appState.toolPermissionContext, appState.mcp.tools);
-    let allTools = uniqBy_default(mergeAndFilterTools([...tools, ...sdkTools, ...dynamicMcpState.tools], assembledTools, appState.toolPermissionContext.mode), "name");
+    let allTools = uniqBy_default(mergeAndFilterTools(deferInitialMcpToolsToLiveState([...tools, ...sdkTools, ...dynamicMcpState.tools], appState.mcp.clients, appState.mcp.tools), assembledTools, appState.toolPermissionContext.mode), "name");
     if (options.permissionPromptToolName) {
       allTools = allTools.filter((tool) => !toolMatchesName(tool, options.permissionPromptToolName));
     }
@@ -822910,8 +823290,8 @@ ${m5.text}
       }
     });
   });
-  const activeOAuthFlows = new Map;
-  const oauthCallbackSubmitters = new Map;
+  const activeOAuthFlows2 = new Map;
+  const oauthCallbackSubmitters2 = new Map;
   const oauthManualCallbackUsed = new Set;
   const oauthAuthPromises = new Map;
   let claudeOAuth = null;
@@ -823245,9 +823625,9 @@ ${m5.text}
             sendControlResponseError(message, `Server type "${config8.type}" does not support OAuth authentication`);
           } else {
             try {
-              activeOAuthFlows.get(serverName)?.abort();
+              activeOAuthFlows2.get(serverName)?.abort();
               const controller = new AbortController;
-              activeOAuthFlows.set(serverName, controller);
+              activeOAuthFlows2.set(serverName, controller);
               let resolveAuthUrl;
               const authUrlPromise = new Promise((resolve63) => {
                 resolveAuthUrl = resolve63;
@@ -823255,7 +823635,7 @@ ${m5.text}
               const oauthPromise = performMCPOAuthFlow(serverName, config8, (url3) => resolveAuthUrl(url3), controller.signal, {
                 skipBrowserOpen: true,
                 onWaitingForCallback: (submit) => {
-                  oauthCallbackSubmitters.set(serverName, submit);
+                  oauthCallbackSubmitters2.set(serverName, submit);
                 }
               });
               const authUrl = await Promise.race([
@@ -823315,9 +823695,9 @@ ${m5.text}
               }).catch((error52) => {
                 logForDebugging(`MCP OAuth failed for ${serverName}: ${error52}`, { level: "error" });
               }).finally(() => {
-                if (activeOAuthFlows.get(serverName) === controller) {
-                  activeOAuthFlows.delete(serverName);
-                  oauthCallbackSubmitters.delete(serverName);
+                if (activeOAuthFlows2.get(serverName) === controller) {
+                  activeOAuthFlows2.delete(serverName);
+                  oauthCallbackSubmitters2.delete(serverName);
                   oauthManualCallbackUsed.delete(serverName);
                   oauthAuthPromises.delete(serverName);
                 }
@@ -823328,33 +823708,15 @@ ${m5.text}
           }
         } else if (message.request.subtype === "mcp_oauth_callback_url") {
           const { serverName, callbackUrl } = message.request;
-          const submit = oauthCallbackSubmitters.get(serverName);
-          if (submit) {
-            let hasCodeOrError = false;
-            try {
-              const parsed = new URL(callbackUrl);
-              hasCodeOrError = parsed.searchParams.has("code") || parsed.searchParams.has("error");
-            } catch {}
-            if (!hasCodeOrError) {
-              sendControlResponseError(message, "Invalid callback URL: missing authorization code. Please paste the full redirect URL including the code parameter.");
-            } else {
-              oauthManualCallbackUsed.add(serverName);
-              submit(callbackUrl);
-              const authPromise = oauthAuthPromises.get(serverName);
-              if (authPromise) {
-                try {
-                  await authPromise;
-                  sendControlResponseSuccess(message);
-                } catch (error52) {
-                  sendControlResponseError(message, error52 instanceof Error ? error52.message : "OAuth authentication failed");
-                }
-              } else {
-                sendControlResponseSuccess(message);
-              }
-            }
-          } else {
-            sendControlResponseError(message, `No active OAuth flow for server: ${serverName}`);
-          }
+          await handleOAuthCallbackUrlControl(serverName, callbackUrl, {
+            getSubmitter: (name3) => oauthCallbackSubmitters2.get(name3),
+            getAuthPromise: (name3) => oauthAuthPromises.get(name3),
+            markManualCallbackUsed: (name3) => {
+              oauthManualCallbackUsed.add(name3);
+            },
+            respondError: (errorMessageText) => sendControlResponseError(message, errorMessageText),
+            respondSuccess: () => sendControlResponseSuccess(message)
+          });
         } else if (message.request.subtype === "claude_authenticate") {
           const { loginWithClaudeAi } = message.request;
           claudeOAuth?.service.cleanup();
@@ -825220,6 +825582,22 @@ var init_MCPServerDesktopImportDialog = __esm(() => {
   jsx_runtime498 = __toESM(require_jsx_runtime(), 1);
 });
 
+// src/cli/mcpOAuthPrompt.ts
+function promptForCallbackUrlWithRetry(io, submit) {
+  const ask2 = () => {
+    io.question("> ", (answer) => {
+      if (submit(answer.trim())) {
+        io.close();
+        return;
+      }
+      io.notify(CALLBACK_REJECTED_RETRY_HINT);
+      ask2();
+    });
+  };
+  ask2();
+}
+var CALLBACK_REJECTED_RETRY_HINT = "That URL was not accepted: its state does not match the flow in progress (or it carries no authorization code). The flow is still waiting \u2014 paste the full redirect URL from the browser page this login opened:";
+
 // node_modules/.bun/@modelcontextprotocol+sdk@1.29.0/node_modules/@modelcontextprotocol/sdk/dist/esm/experimental/tasks/server.js
 class ExperimentalServerTasks {
   constructor(_server) {
@@ -826213,10 +826591,17 @@ ${url3}`);
     console.log(`
 After authorizing, paste the full redirect URL here and press Enter:`);
     const rl = readline5.createInterface({ input: process.stdin });
-    rl.question("> ", (answer) => {
-      rl.close();
-      submit(answer.trim());
-    });
+    promptForCallbackUrlWithRetry({
+      question: (prompt, onAnswer) => {
+        rl.question(prompt, onAnswer);
+      },
+      close: () => {
+        rl.close();
+      },
+      notify: (message) => {
+        console.log(message);
+      }
+    }, submit);
   } : undefined;
   try {
     await performMCPOAuthFlow(name3, server, onAuthorizationUrl, undefined, {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cnwenf/occ",
-  "version": "2.1.340",
+  "version": "2.1.341",
   "license": "MIT",
   "type": "module",
   "bin": {