@cnwenf/occ 2.1.340 → 2.1.342

package/README.md

@@ -5,7 +5,7 @@
 [![npm version](https://img.shields.io/npm/v/@cnwenf/occ.svg)](https://www.npmjs.com/package/@cnwenf/occ)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
 [![Runtime: Bun](https://img.shields.io/badge/Runtime-Bun-%23000000.svg)](https://bun.sh/)
-[![Tracks: Claude Code 2.1.274](https://img.shields.io/badge/Tracks-Claude%20Code%202.1.274-blueviolet.svg)](https://docs.anthropic.com/en/docs/claude-code)
+[![Tracks: Claude Code 2.1.276](https://img.shields.io/badge/Tracks-Claude%20Code%202.1.276-blueviolet.svg)](https://docs.anthropic.com/en/docs/claude-code)
 
 [简体中文](./README.zh-CN.md) · **English**
 
@@ -13,7 +13,7 @@
 
 ## What is OCC
 
-**Open C Code (OCC)** is an open-source coding agent. Its capabilities are aligned with [Claude Code](https://docs.anthropic.com/en/docs/claude-code) (currently tracking `2.1.274` — 2.1.270 fully aligned; 2.1.271–2.1.274 partial: the latest OCC-127 round landed the 2.1.274 MCP auth-stub description secret-leak fix — the byte-verified display-sanitizer family (NFKC + invisible-character stripping, quote/angle-bracket neutralization, bearer/token-family redaction, code-point-safe truncation) with the origin-only unexpanded endpoint — and confirmed NO-OP with behavioral tests for the 2.1.274 bash special-variable assignment/loop and worktree nested-expansion hardening (OCC's existing guards already ask/refuse every risky vector, byte-verified parity with the official); prior rounds landed the 2.1.273 gateway-hint request headers (default on for the first-party api.anthropic.com endpoint, off for third-party/custom endpoints; tri-bool `CLAUDE_CODE_GATEWAY_HINT_HEADERS` override), the spinner doubled-ellipsis guard, the shell-mode `!` insert fix, and the subshell-hidden dangerous-`rm` bypass fix (per-segment analysis in the always-on catastrophic-rm deny guard), per `docs/upstream-version-gap-occ127.md`; remaining 2.1.273/2.1.274 entries are triaged there as NO-OP (surfaces OCC trims) or STAGED (per-site forensics needed); still not landed from the 2.1.270→2.1.272 delta: `/config` panel fullscreen mouse support (PORTABLE-LARGE scope) and the spinner status ladder "deep in thought"/"picking the thought back up" (STAGED), plus the pre-existing sandbox per-command `allowed_domains` gap; prior alignment through 2.1.270 landed via OCC-122/OCC-123/OCC-84/OCC-124/OCC-85/OCC-125/OCC-126). The code is fully open, auditable, backdoor-free, and your data stays under your control.
+**Open C Code (OCC)** is an open-source coding agent. Its capabilities are aligned with [Claude Code](https://docs.anthropic.com/en/docs/claude-code) (currently tracking `2.1.276` — 2.1.276 fully aligned; 2.1.271–2.1.275 partial: the latest OCC-90 round landed the byte-verified 2.1.276 advisor proxy-400 fix — advisor-model resolution now gated on a first-party `ANTHROPIC_BASE_URL` (official module #489 `!Ia()||` gate), the growthbook experiment key corrected to `tengu_sage_compass2`, strict firstParty advisor enablement with the `CLAUDE_CODE_ENABLE_EXPERIMENTAL_ADVISOR_TOOL` env override and the `_CLAUDE_CODE_ASSUME_FIRST_PARTY_BASE_URL` arm — plus removal of the dead `src/services/api/src/` stub tree and a full 96-entry triage of 2.1.275, per `docs/upstream-version-gap-occ129.md`; prior rounds landed the 2.1.274 MCP auth-stub description secret-leak fix (byte-verified display-sanitizer family port) with NO-OP behavioral verification of the 2.1.274 bash special-variable and worktree nested-expansion hardening (OCC-127), the 2.1.273 gateway-hint request headers, the spinner doubled-ellipsis guard, the shell-mode `!` insert fix, and the subshell-hidden dangerous-`rm` bypass fix, per `docs/upstream-version-gap-occ127.md`; still not landed from the 2.1.270→2.1.272 delta: `/config` panel fullscreen mouse support (PORTABLE-LARGE) and the spinner status ladder (STAGED), plus the pre-existing sandbox per-command `allowed_domains` gap; prior alignment through 2.1.270 landed via OCC-122/OCC-123/OCC-84/OCC-124/OCC-85/OCC-125/OCC-126). The code is fully open, auditable, backdoor-free, and your data stays under your control.
 
 If you worry that a closed-source CLI might hide backdoors, or that your code and credentials are uploaded to unauditable services, OCC is for you: all source is open and unobfuscated, the build is reproducible from source, and API credentials are sent only to endpoints you configure.
 
@@ -62,7 +62,7 @@ Requires a valid Anthropic API Key (or AWS Bedrock / Google Vertex / Azure Found
 | **Auditability** | Line-by-line reviewable | No |
 | **Telemetry** | Minimal (analytics stubbed) | Standard |
 | **Data sovereignty** | Credentials stay on your machine; requests only to endpoints you configure | Anthropic endpoints |
-| **Capability parity** | Tracks CC `2.1.274` (2.1.270 fully aligned; 2.1.271–2.1.274 partial) | Reference implementation |
+| **Capability parity** | Tracks CC `2.1.276` (2.1.276 fully aligned; 2.1.271–2.1.275 partial) | Reference implementation |
 | **Providers** | Anthropic Direct, Bedrock, Vertex, Azure | Anthropic, Bedrock, Vertex |
 | **Cost** | Free & open-source (MIT) | Subscription |
 | **Build** | Reproducible from source | N/A |
@@ -143,7 +143,7 @@ Requires [Bun](https://bun.sh/) >= 1.3.11 (use `bun upgrade` — older Bun cause
 
 ```bash
 bun install
-bun run dev          # run from source; version prints 2.1.274 (dev polyfill; build overrides with pkg.version) when working
+bun run dev          # run from source; version prints 2.1.276 (dev polyfill; build overrides with pkg.version) when working
 bun run build        # output: dist/cli.js (~26 MB, single-file bundle)
 bun test             # test suite (Bun test runner)
 bun run lint         # Biome lint (formatter disabled to avoid large diffs)
@@ -157,7 +157,7 @@ For architecture, entry/bootstrap, tool system, UI layer, and module-status deta
 
 ## Status
 
-- Tracks Claude Code **`2.1.274`** (2.1.270 fully aligned; 2.1.271–2.1.274 partial — the latest OCC-127 round landed the 2.1.274 MCP auth-stub description secret-leak fix (byte-verified display-sanitizer family port) and verified the 2.1.274 bash special-variable and worktree nested-expansion hardening as NO-OP with behavioral tests; prior rounds landed the 2.1.273 gateway-hint request headers, the spinner doubled-ellipsis guard, the shell-mode `!` insert fix, and the subshell-hidden dangerous-`rm` bypass fix — see `docs/upstream-version-gap-occ127.md`; remaining 2.1.273/2.1.274 entries are triaged there as NO-OP or STAGED; still not landed from the 2.1.270→2.1.272 delta: `/config` fullscreen mouse support (PORTABLE-LARGE) and the spinner status ladder (STAGED), plus the pre-existing sandbox per-command `allowed_domains` gap; prior alignment through 2.1.270 landed via OCC-122/OCC-123/OCC-84, OCC-124 + OCC-85, OCC-125, and OCC-126 — see `docs/upstream-version-gap-occ124.md`, `docs/upstream-version-gap-occ125.md`, and `docs/upstream-version-gap-occ126.md`).
+- Tracks Claude Code **`2.1.276`** (2.1.276 fully aligned; 2.1.271–2.1.275 partial — the latest OCC-90 round landed the byte-verified 2.1.276 advisor proxy-400 fix (first-party `ANTHROPIC_BASE_URL` gate on advisor resolution, `tengu_sage_compass2` growthbook key, strict firstParty enablement, `_CLAUDE_CODE_ASSUME_FIRST_PARTY_BASE_URL` arm) and removed the dead `src/services/api/src/` stub tree — see `docs/upstream-version-gap-occ129.md`; prior rounds landed the 2.1.274 MCP auth-stub description secret-leak fix with NO-OP verification of the bash special-variable and worktree nested-expansion hardening (OCC-127, `docs/upstream-version-gap-occ127.md`), the 2.1.273 gateway-hint request headers, the spinner doubled-ellipsis guard, the shell-mode `!` insert fix, and the subshell-hidden dangerous-`rm` bypass fix; still not landed from the 2.1.270→2.1.272 delta: `/config` fullscreen mouse support (PORTABLE-LARGE) and the spinner status ladder (STAGED), plus the pre-existing sandbox per-command `allowed_domains` gap; prior alignment through 2.1.270 landed via OCC-122/OCC-123/OCC-84, OCC-124 + OCC-85, OCC-125, and OCC-126 — see `docs/upstream-version-gap-occ124.md`, `docs/upstream-version-gap-occ125.md`, and `docs/upstream-version-gap-occ126.md`).
 - Published to npm as [`@cnwenf/occ`](https://www.npmjs.com/package/@cnwenf/occ).
 - Many modules are intentionally stubbed or feature-flagged off — see "Disabled / stubbed" above.
 

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.342","BINARY_NAME":"occ","BUILD_TIME":"2026-09-18T19:34:48.042Z","FEEDBACK_CHANNEL":"","ISSUES_EXPLAINER":"","NATIVE_PACKAGE_URL":"","PACKAGE_URL":"@cnwenf/occ","VERSION_CHANGELOG":""};
 // @bun
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
@@ -96737,6 +96737,9 @@ function getAPIProviderForStatsig() {
   return getAPIProvider();
 }
 function isFirstPartyAnthropicBaseUrl() {
+  if (isEnvTruthy(process.env._CLAUDE_CODE_ASSUME_FIRST_PARTY_BASE_URL)) {
+    return true;
+  }
   const baseUrl = process.env.ANTHROPIC_BASE_URL;
   if (!baseUrl) {
     return true;
@@ -264309,15 +264312,21 @@ function isAdvisorBlock(param) {
   return param.type === "advisor_tool_result" || param.type === "server_tool_use" && param.name === "advisor";
 }
 function getAdvisorConfig() {
-  return getFeatureValue_CACHED_MAY_BE_STALE("tengu_sage_compass", {});
+  return getFeatureValue_CACHED_MAY_BE_STALE("tengu_sage_compass2", {});
 }
 function isAdvisorEnabled() {
   if (isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_ADVISOR_TOOL)) {
     return false;
   }
-  if (!shouldIncludeFirstPartyOnlyBetas()) {
+  if (getAPIProvider() !== "firstParty") {
     return false;
   }
+  if (isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS)) {
+    return false;
+  }
+  if (isEnvTruthy(process.env.CLAUDE_CODE_ENABLE_EXPERIMENTAL_ADVISOR_TOOL)) {
+    return true;
+  }
   return getAdvisorConfig().enabled ?? false;
 }
 function canUserConfigureAdvisor() {
@@ -264366,8 +264375,8 @@ Give the advice serious weight. If you follow a step and it fails empirically, o
 If you've already retrieved data pointing one way and the advisor points another: don't silently switch. Surface the conflict in one more advisor call -- "I found X, you suggest Y, which constraint breaks the tie?" The advisor saw your evidence but may have underweighted it; a reconcile call is cheaper than committing to the wrong branch.`;
 var init_advisor = __esm(() => {
   init_growthbook();
-  init_betas2();
   init_envUtils();
+  init_providers();
   init_settings2();
 });
 
@@ -627164,6 +627173,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 +627576,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 +627592,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 +627626,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 +628496,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 +628536,9 @@ var init_auth11 = __esm(() => {
       this.name = "AuthenticationCancelledError";
     }
   };
+  oauthCallbackSubmitters = new Map;
+  activeOAuthFlows = new Map;
+  oauthFlowRecords = new Map;
 });
 
 // src/services/mcp/displaySanitize.ts
@@ -628532,20 +628603,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 +628816,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 +628860,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 +628877,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 +628906,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 +628914,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 +628958,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 +632190,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 +632199,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;
@@ -634624,7 +634945,7 @@ async function* queryModel(messages, systemPrompt, thinkingConfig, tools, signal
     betas.push(ADVISOR_BETA_HEADER);
   }
   let advisorModel;
-  if (isAgenticQuery && isAdvisorEnabled()) {
+  if (isAgenticQuery && isAdvisorEnabled() && isFirstPartyAnthropicBaseUrl()) {
     let advisorOption = options.advisorModel;
     const advisorExperiment = getExperimentAdvisorModels();
     if (advisorExperiment !== undefined) {
@@ -793589,6 +793910,7 @@ var exports_toolPool = {};
 __export(exports_toolPool, {
   mergeAndFilterTools: () => mergeAndFilterTools,
   isPrActivitySubscriptionTool: () => isPrActivitySubscriptionTool,
+  deferInitialMcpToolsToLiveState: () => deferInitialMcpToolsToLiveState,
   applyCoordinatorToolFilter: () => applyCoordinatorToolFilter
 });
 function isPrActivitySubscriptionTool(name3) {
@@ -793608,18 +793930,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 +799294,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 +806041,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 +806063,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 +807079,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 +820410,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 +822551,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 +823299,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 +823634,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 +823644,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 +823704,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 +823717,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 +825591,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 +826600,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, {
@@ -831945,7 +832339,7 @@ var _FEATURE_ALLOWLIST = new Set([
 var feature2 = (name3) => _FEATURE_ALLOWLIST.has(name3);
 if (typeof globalThis.MACRO === "undefined") {
   globalThis.MACRO = {
-    VERSION: "2.1.274",
+    VERSION: "2.1.276",
     BINARY_NAME: "occ",
     BUILD_TIME: new Date().toISOString(),
     FEEDBACK_CHANNEL: "",

package/package.json

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