npm - @herbertgao/pi-extensions - Versions diffs - 2026.8.14 → 2026.9.0 - Mend

@herbertgao/pi-extensions 2026.8.14 → 2026.9.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (270) hide show

package/node_modules/pi-mcp-adapter/host-html-template.ts CHANGED Viewed

@@ -3,6 +3,8 @@ import type { UiHostContext, UiResourceContent, UiResourceCsp } from "./types.ts
 // Use locally bundled AppBridge to avoid CDN Zod bundling issues
 const DEFAULT_APP_BRIDGE_MODULE_URL = "/app-bridge.bundle.js";
 const APP_SANDBOX = "allow-scripts allow-forms allow-modals allow-popups allow-downloads";
+const APP_PROXY_SANDBOX = `${APP_SANDBOX} allow-same-origin`;
+const APP_INNER_SANDBOX = APP_PROXY_SANDBOX;
 export interface HostHtmlTemplateInput {
   sessionToken: string;
@@ -16,6 +18,7 @@ export interface HostHtmlTemplateInput {
   cacheToolConsent: boolean;
   hostContext?: UiHostContext;
   appBridgeModuleUrl?: string;
+  sandboxProxyUrl: string;
 }
 export function buildHostHtmlTemplate(input: HostHtmlTemplateInput): string {
@@ -31,6 +34,9 @@ export function buildHostHtmlTemplate(input: HostHtmlTemplateInput): string {
   const requireToolConsent = safeInlineJSON(input.requireToolConsent);
   const cacheToolConsent = safeInlineJSON(input.cacheToolConsent);
   const moduleUrl = safeInlineJSON(input.appBridgeModuleUrl ?? DEFAULT_APP_BRIDGE_MODULE_URL);
+  const sandboxProxyUrl = safeInlineJSON(input.sandboxProxyUrl);
+  const resourceCsp = safeInlineJSON(input.resource.meta.csp);
+  const resourcePermissions = safeInlineJSON(input.resource.meta.permissions);
   return `<!doctype html>
 <html lang="en">
@@ -112,7 +118,7 @@ export function buildHostHtmlTemplate(input: HostHtmlTemplateInput): string {
     </div>
   </header>
   <main>
-    <iframe id="mcp-app" sandbox="${APP_SANDBOX}" referrerpolicy="no-referrer"></iframe>
+    <iframe id="mcp-app" sandbox="${APP_PROXY_SANDBOX}" referrerpolicy="no-referrer"></iframe>
   </main>
   <div class="overlay" id="error-overlay">
     <div class="panel">
@@ -138,6 +144,10 @@ export function buildHostHtmlTemplate(input: HostHtmlTemplateInput): string {
     const ALLOW_ATTRIBUTE = ${allowAttribute};
     const REQUIRE_TOOL_CONSENT = ${requireToolConsent};
     const CACHE_TOOL_CONSENT = ${cacheToolConsent};
+    const SANDBOX_PROXY_URL = ${sandboxProxyUrl};
+    const RESOURCE_CSP = ${resourceCsp};
+    const RESOURCE_PERMISSIONS = ${resourcePermissions};
+    const INNER_SANDBOX = ${safeInlineJSON(APP_INNER_SANDBOX)};
     const STREAM_CONTEXT_KEY = "pi-mcp-adapter/stream";
     const STREAM_PATCH_METHOD = "notifications/pi-mcp-adapter/ui-result-patch";
@@ -148,6 +158,7 @@ export function buildHostHtmlTemplate(input: HostHtmlTemplateInput): string {
     const errorOverlay = document.getElementById("error-overlay");
     const completionOverlay = document.getElementById("completion-overlay");
     const errorMessage = document.getElementById("error-message");
+    const sandboxProxyOrigin = new URL(SANDBOX_PROXY_URL).origin;
     document.getElementById("server-name").textContent = SERVER_NAME;
     document.getElementById("tool-name").textContent = TOOL_NAME;
@@ -205,10 +216,41 @@ export function buildHostHtmlTemplate(input: HostHtmlTemplateInput): string {
     const bridge = new AppBridge(
       null,
       { name: "pi", version: "1.0.0" },
-      { serverTools: {}, openLinks: {}, logging: {}, updateModelContext: {}, message: {} },
+      {
+        serverTools: {},
+        openLinks: {},
+        logging: {},
+        updateModelContext: {},
+        message: {},
+        sandbox: {
+          ...(RESOURCE_CSP ? { csp: RESOURCE_CSP } : {}),
+          ...(RESOURCE_PERMISSIONS ? { permissions: RESOURCE_PERMISSIONS } : {}),
+        },
+      },
       { hostContext: HOST_CONTEXT }
     );
+    let sandboxResourceSent = false;
+    bridge.onsandboxready = async () => {
+      if (sandboxResourceSent) return;
+      sandboxResourceSent = true;
+      try {
+        const response = await fetch("/ui-app?resource=" + encodeURIComponent(UI_RESOURCE_TOKEN), {
+          headers: { Accept: "text/html" },
+        });
+        if (!response.ok) throw new Error("UI resource request failed: HTTP " + response.status);
+        const html = await response.text();
+        await bridge.sendSandboxResourceReady({
+          html,
+          sandbox: INNER_SANDBOX,
+          ...(RESOURCE_CSP ? { csp: RESOURCE_CSP } : {}),
+          ...(RESOURCE_PERMISSIONS ? { permissions: RESOURCE_PERMISSIONS } : {}),
+        });
+      } catch (error) {
+        showError("Failed to load MCP App resource: " + String(error));
+      }
+    };
     bridge.oncalltool = async (params) => {
       if (!consentGranted) {
         const accepted = window.confirm("Allow this UI to call server tools for this session?");
@@ -240,7 +282,7 @@ export function buildHostHtmlTemplate(input: HostHtmlTemplateInput): string {
     // Also listen for raw postMessage events with custom types (notify, prompt, intent, etc.)
     // These bypass the AppBridge protocol but are used by some MCP UI implementations
     window.addEventListener("message", async (event) => {
-      if (event.source !== iframe.contentWindow) return;
+      if (event.source !== iframe.contentWindow || event.origin !== sandboxProxyOrigin) return;
       const data = event.data;
       if (!data || typeof data !== "object") return;
@@ -304,6 +346,12 @@ export function buildHostHtmlTemplate(input: HostHtmlTemplateInput): string {
     }
     // Connect bridge BEFORE loading iframe to ensure we're listening when the app sends ui/initialize
+    const sandboxMessageGuard = (event) => {
+      if (event.source === iframe.contentWindow && event.origin !== sandboxProxyOrigin) {
+        event.stopImmediatePropagation();
+      }
+    };
+    window.addEventListener("message", sandboxMessageGuard, true);
     try {
       const transport = new PostMessageTransport(iframe.contentWindow, iframe.contentWindow);
       await bridge.connect(transport);
@@ -315,7 +363,7 @@ export function buildHostHtmlTemplate(input: HostHtmlTemplateInput): string {
     const iframeLoaded = new Promise((resolve) => {
       iframe.onload = resolve;
     });
-    iframe.src = "/ui-app?resource=" + encodeURIComponent(UI_RESOURCE_TOKEN);
+    iframe.src = SANDBOX_PROXY_URL;
     await iframeLoaded;
     const eventSource = new EventSource("/events?session=" + encodeURIComponent(SESSION_TOKEN));
@@ -340,6 +388,9 @@ export function buildHostHtmlTemplate(input: HostHtmlTemplateInput): string {
         showError("Failed to forward cancellation: " + String(error));
       }
     });
+    eventSource.addEventListener("resource-updated", () => {
+      setStatus("Resource updated on the server. Reopen this UI to load the latest version.");
+    });
     eventSource.addEventListener("result-patch", async (event) => {
       try {
         await bridge.notification({
@@ -443,7 +494,9 @@ function sanitizeCspDomains(domains: unknown): string[] {
 }
 function safeInlineJSON(value: unknown): string {
-  return JSON.stringify(value)
+  const json = JSON.stringify(value);
+  if (json === undefined) return "undefined";
+  return json
     .replace(/</g, "\\u003c")
     .replace(/>/g, "\\u003e")
     .replace(/&/g, "\\u0026")

package/node_modules/pi-mcp-adapter/index.ts CHANGED Viewed

@@ -590,7 +590,7 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
       initPromise = null;
       if (earlyConfig.settings?.freezeDirectTools === true) {
         directToolsFrozen = true;
-        logger.info("MCP: direct tools frozen after initial sync — reconnects won't rebuild the system prompt; use mcp({ connect: \"server\" }) to rediscover");
+        logger.info("MCP: direct tools frozen after initial sync — metadata can refresh without rebuilding the active tool surface");
       }
     }).catch(async err => {
       if (!owner.isActive() || generation !== lifecycleGeneration) {
@@ -817,7 +817,6 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
         case "reconnect":
           commandOwner?.throwIfInactive();
           await reconnectServers(state, commandCtx, targetServer);
-          if (directToolsFrozen) syncToolSurface(commandCtx);
           break;
         case "tools":
           await showTools(state, commandCtx);
@@ -1168,7 +1167,7 @@ function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
         }
         if (params.connect) {
           const result = await executeConnect(state, params.connect, signal);
-          syncToolSurface(_ctx as ExtensionContext);
+          if (!directToolsFrozen) syncToolSurface(_ctx as ExtensionContext);
           return result;
         }
         if (params.describe) {

package/node_modules/pi-mcp-adapter/init.ts CHANGED Viewed

@@ -215,6 +215,10 @@ export async function initializeMcp(
     notifyToolMetadataUpdated(state, serverName, reason);
     updateStatusBar(state);
   });
+  manager.setListenStateChangedListener?.(() => {
+    if (!owner.isActive()) return;
+    updateStatusBar(state);
+  });
   owner.addCleanup(() => lifecycle.gracefulShutdown());
   owner.addCleanup(() => {
     if (state.uiServer) {
@@ -641,6 +645,7 @@ export async function lazyConnect(state: McpExtensionState, serverName: string,
     return false;
   }
   if (connection?.status === "connected") {
+    await state.manager.ensureListen?.(serverName, connection);
     updateServerMetadata(state, serverName);
     markKeepAliveAfterConnect(state, serverName);
     return true;

package/node_modules/pi-mcp-adapter/mcp-auth-flow.ts CHANGED Viewed

@@ -75,6 +75,8 @@ type PendingAuth = {
   authProvider: McpOAuthProvider
   serverUrl: string
   authorizationUrl: string
+  manualRedirect: boolean
+  manualCompletionController?: AbortController
   discovery: AuthDiscovery
   authStorageOptions: AuthStorageOptions
 }
@@ -307,7 +309,11 @@ async function probeAuthDiscovery(serverUrl: string, definition?: ServerEntry, s
   }
 }
-function parseOAuthRedirectUri(redirectUri: string): { port: number; callbackHost: string; callbackPath: string } {
+type OAuthRedirectTarget =
+  | { mode: "local"; port: number; callbackHost: string; callbackPath: string }
+  | { mode: "manual" }
+function parseOAuthRedirectUri(redirectUri: string): OAuthRedirectTarget {
   let url: URL
   try {
     url = new URL(redirectUri)
@@ -315,12 +321,6 @@ function parseOAuthRedirectUri(redirectUri: string): { port: number; callbackHos
     throw new Error(`Invalid OAuth redirectUri: ${redirectUri}`, { cause: error })
   }
-  const hostname = url.hostname.toLowerCase()
-  const isLocalhost = hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]" || hostname === "::1"
-  if (url.protocol !== "http:" || !isLocalhost) {
-    throw new Error("OAuth redirectUri must be an http:// localhost or loopback URI")
-  }
   if (url.username || url.password) {
     throw new Error("OAuth redirectUri must not include username or password")
   }
@@ -329,17 +329,32 @@ function parseOAuthRedirectUri(redirectUri: string): { port: number; callbackHos
     throw new Error("OAuth redirectUri must not include a fragment")
   }
+  const hostname = url.hostname.toLowerCase()
+  const isLocalhost = hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]" || hostname === "::1"
+  if (url.port) {
+    const parsedPort = Number.parseInt(url.port, 10)
+    if (!Number.isInteger(parsedPort) || parsedPort <= 0 || parsedPort > 65535) {
+      throw new Error("OAuth redirectUri port must be a positive numeric port")
+    }
+  }
+  if (url.protocol === "https:" && !isLocalhost) {
+    return { mode: "manual" }
+  }
+  if (url.protocol !== "http:" || !isLocalhost) {
+    throw new Error("OAuth redirectUri must be an https:// URI or an http:// localhost or loopback URI")
+  }
   if (!url.port) {
-    throw new Error("OAuth redirectUri must include an explicit numeric port")
+    throw new Error("OAuth localhost redirectUri must include an explicit numeric port")
   }
   const port = Number.parseInt(url.port, 10)
   if (!Number.isInteger(port) || port <= 0 || port > 65535) {
-    throw new Error("OAuth redirectUri must include an explicit numeric port")
+    throw new Error("OAuth localhost redirectUri must include an explicit numeric port")
   }
   const callbackHost = hostname === "[::1]" ? "::1" : hostname
-  return { port, callbackHost, callbackPath: url.pathname }
+  return { mode: "local", port, callbackHost, callbackPath: url.pathname }
 }
 /**
@@ -393,25 +408,30 @@ export async function startAuth(
     return { authorizationUrl: existingPendingAuth.authorizationUrl }
   }
-  const redirectCallback = config.redirectUri !== undefined ? parseOAuthRedirectUri(config.redirectUri) : undefined
+  const redirectTarget = config.redirectUri !== undefined ? parseOAuthRedirectUri(config.redirectUri) : undefined
+  const manualRedirect = redirectTarget?.mode === "manual"
   const oauthState = generateState()
-  try {
-    await ensureCallbackServer({
-      strictPort: Boolean(config.clientId) || config.redirectUri !== undefined,
-      oauthState,
-      reserveState: true,
-      ...(redirectCallback ? { port: redirectCallback.port, callbackHost: redirectCallback.callbackHost, callbackPath: redirectCallback.callbackPath } : {}),
-    })
-    throwIfAborted(signal)
-  } catch (error) {
-    releaseCallbackServer(oauthState)
+  if (!manualRedirect) {
     try {
-      await cleanupAndReleaseCallbackServerIfIdle(() => clearOAuthState(serverName, authStorageOptions))
-    } catch (cleanupError) {
-      throw new AggregateError([error, cleanupError], "OAuth startup cleanup failed")
+      await ensureCallbackServer({
+        strictPort: Boolean(config.clientId) || config.redirectUri !== undefined,
+        oauthState,
+        reserveState: true,
+        ...(redirectTarget?.mode === "local"
+          ? { port: redirectTarget.port, callbackHost: redirectTarget.callbackHost, callbackPath: redirectTarget.callbackPath }
+          : {}),
+      })
+      throwIfAborted(signal)
+    } catch (error) {
+      releaseCallbackServer(oauthState)
+      try {
+        await cleanupAndReleaseCallbackServerIfIdle(() => clearOAuthState(serverName, authStorageOptions))
+      } catch (cleanupError) {
+        throw new AggregateError([error, cleanupError], "OAuth startup cleanup failed")
+      }
+      throw error
     }
-    throw error
   }
   let capturedUrl: URL | undefined
@@ -455,7 +475,16 @@ export async function startAuth(
     if (!capturedUrl) {
       throw new UnauthorizedError("OAuth authorization URL was not provided")
     }
-    await setPendingAuth(runtime, serverName, { serverName, authProvider, serverUrl, authorizationUrl: capturedUrl.toString(), discovery, authStorageOptions }, oauthState, signal, generation)
+    await setPendingAuth(runtime, serverName, {
+      serverName,
+      authProvider,
+      serverUrl,
+      authorizationUrl: capturedUrl.toString(),
+      manualRedirect,
+      ...(manualRedirect ? { manualCompletionController: new AbortController() } : {}),
+      discovery,
+      authStorageOptions,
+    }, oauthState, signal, generation)
     return { authorizationUrl: capturedUrl.toString() }
   } catch (error) {
     authProvider.deactivate()
@@ -484,7 +513,13 @@ async function setPendingAuth(
   state.pendingAuths.set(key, pendingAuth)
   state.pendingAuthStates.set(key, oauthState)
   const cleanupTimer = setTimeout(() => {
-    void clearPendingAuthAndReleaseIfIdle(runtime, serverName, oauthState, pendingAuth.authStorageOptions).catch(error => {
+    void clearPendingAuthAndReleaseIfIdle(
+      runtime,
+      serverName,
+      oauthState,
+      pendingAuth.authStorageOptions,
+      new Error("OAuth authorization timeout - authorization took too long"),
+    ).catch(error => {
       console.error(`MCP Auth: Timed-out flow cleanup failed: ${formatTerminalError(error)}`)
     })
   }, MANUAL_AUTH_TIMEOUT_MS)
@@ -492,7 +527,13 @@ async function setPendingAuth(
   state.pendingAuthCleanupTimers.set(key, cleanupTimer)
 }
-async function clearPendingAuth(runtime: McpOAuthRuntime, serverName: string, oauthState?: string, fallbackStorageOptions: AuthStorageOptions = {}): Promise<void> {
+async function clearPendingAuth(
+  runtime: McpOAuthRuntime,
+  serverName: string,
+  oauthState?: string,
+  fallbackStorageOptions: AuthStorageOptions = {},
+  reason: Error = new Error("Authorization cancelled"),
+): Promise<void> {
   const state = getRuntimeState(runtime)
   const key = getPendingAuthKey(serverName, fallbackStorageOptions)
   const pendingAuth = state.pendingAuths.get(key)
@@ -506,6 +547,7 @@ async function clearPendingAuth(runtime: McpOAuthRuntime, serverName: string, oa
     state.pendingAuthCleanupTimers.delete(key)
   }
+  pendingAuth?.manualCompletionController?.abort(reason)
   pendingAuth?.authProvider.deactivate()
   state.pendingAuths.delete(key)
   state.pendingAuthStates.delete(key)
@@ -524,9 +566,10 @@ async function clearPendingAuthAndReleaseIfIdle(
   serverName: string,
   oauthState: string | undefined,
   fallbackStorageOptions: AuthStorageOptions = {},
+  reason?: Error,
 ): Promise<void> {
   await cleanupAndReleaseCallbackServerIfIdle(
-    () => clearPendingAuth(runtime, serverName, oauthState, fallbackStorageOptions),
+    () => clearPendingAuth(runtime, serverName, oauthState, fallbackStorageOptions, reason),
   )
 }
@@ -629,6 +672,19 @@ type AuthorizationResponse = {
   source: "callback" | "manual"
 }
+function waitForManualCompletionCancellation(signal: AbortSignal): Promise<AuthorizationCodeInput> {
+  return new Promise((_, reject) => {
+    const rejectFromSignal = () => {
+      reject(signal.reason instanceof Error ? signal.reason : new Error("Authorization cancelled"))
+    }
+    if (signal.aborted) {
+      rejectFromSignal()
+      return
+    }
+    signal.addEventListener("abort", rejectFromSignal, { once: true })
+  })
+}
 /**
  * Wait for either the localhost callback or a manually pasted redirect URL.
  * The manual input prompt is dismissed as soon as either path finishes.
@@ -686,7 +742,11 @@ export async function completeAuthFromInput(
   throwIfAborted(signal)
   const key = getPendingAuthKey(serverName, fallbackAuthStorageOptions)
   const oauthState = runtimeState.pendingAuthStates.get(key)
+  const pendingAuth = runtimeState.pendingAuths.get(key)
   throwIfAborted(signal)
+  if (pendingAuth?.manualRedirect && !getSearchParamsFromInput(input.trim())) {
+    throw new Error("Paste the full OAuth callback URL, including its code and state parameters")
+  }
   const parsed = parseAuthorizationRedirectInput(input, oauthState)
   return completeAuth(serverName, parsed, options)
 }
@@ -805,15 +865,28 @@ export async function authenticate(
     try {
       // Get the state that was already generated and stored in startAuth().
       // Keep this lookup and its abort check inside the cleanup boundary because
-      // startAuth has already reserved callback state at this point.
+      // startAuth already owns the pending flow at this point.
       oauthState = runtimeState.pendingAuthStates.get(getPendingAuthKey(serverName, authStorageOptions))
       throwIfAborted(signal)
       if (!oauthState) {
         throw new Error("OAuth state not found - this should not happen")
       }
-      // Register the callback BEFORE opening the browser.
-      const callbackPromise = waitForCallback(oauthState)
+      const pendingAuth = runtimeState.pendingAuths.get(getPendingAuthKey(serverName, authStorageOptions))
+      if (!pendingAuth) {
+        throw new Error(`No pending OAuth flow for server: ${serverName}`)
+      }
+      if (pendingAuth.manualRedirect && !options.onAuthorizationInput) {
+        throw new Error(
+          `OAuth for ${serverName} uses a remote redirect URI. Complete it with auth-start/auth-complete or /mcp-auth.`,
+        )
+      }
+      // Register the localhost callback before opening the browser. Remote
+      // pre-registered callbacks are completed by pasting their full URL.
+      const callbackPromise: Promise<AuthorizationCodeInput> = pendingAuth.manualRedirect
+        ? waitForManualCompletionCancellation(pendingAuth.manualCompletionController!.signal)
+        : waitForCallback(oauthState)
       void callbackPromise.catch(() => {})
       // Open browser. Always surface the URL first so remote/headless users can copy it

package/node_modules/pi-mcp-adapter/mcp-panel.ts CHANGED Viewed

@@ -134,6 +134,8 @@ interface ServerState {
   includeTools?: string[];
   excludeTools?: string[];
   exposeResources: boolean;
+  disabled: boolean;
+  wasDisabled: boolean;
   connectionStatus: ConnectionStatus;
   failureMessage?: string | null;
   tools: ToolState[];
@@ -243,6 +245,7 @@ class McpPanel {
       const status = callbacks.getConnectionStatus(serverName);
       const failureMessage = callbacks.getFailureMessage?.(serverName) ?? null;
+      const serverDisabled = isServerDisabled(definition);
       let directCount = 0;
       let directTokens = 0;
       for (const tool of tools) {
@@ -258,6 +261,8 @@ class McpPanel {
         ...(definition.includeTools !== undefined ? { includeTools: definition.includeTools } : {}),
         ...(definition.excludeTools !== undefined ? { excludeTools: definition.excludeTools } : {}),
         exposeResources: definition.exposeResources !== false,
+        disabled: serverDisabled,
+        wasDisabled: serverDisabled,
         connectionStatus: status,
         failureMessage,
         tools,
@@ -275,7 +280,7 @@ class McpPanel {
     if (this.inactivityTimeout) clearTimeout(this.inactivityTimeout);
     this.inactivityTimeout = setTimeout(() => {
       this.cleanup();
-      this.done({ cancelled: true, changes: new Map() });
+      this.done({ cancelled: true, changes: new Map(), disabledChanges: new Map() });
     }, McpPanel.INACTIVITY_MS);
   }
@@ -334,12 +339,16 @@ class McpPanel {
   }
   private updateDirty(): void {
-    this.dirty = this.servers.some((s) => s.tools.some((t) => t.isDirect !== t.wasDirect));
+    this.dirty = this.servers.some((s) => s.disabled !== s.wasDisabled || s.tools.some((t) => t.isDirect !== t.wasDirect));
   }
   private buildResult(): McpPanelResult {
     const changes = new Map<string, true | string[] | false>();
+    const disabledChanges = new Map<string, boolean>();
     for (const server of this.servers) {
+      if (server.disabled !== server.wasDisabled) {
+        disabledChanges.set(server.name, server.disabled);
+      }
       const changed = server.tools.some((t) => t.isDirect !== t.wasDirect);
       if (!changed) continue;
       const directTools = server.tools.filter((t) => t.isDirect);
@@ -351,7 +360,7 @@ class McpPanel {
         changes.set(server.name, directTools.map((t) => t.name));
       }
     }
-    return { changes, cancelled: false };
+    return { changes, disabledChanges, cancelled: false };
   }
   handleInput(data: string): void {
@@ -367,7 +376,7 @@ class McpPanel {
     // Global shortcuts — always work, even during desc search
     if (matchesKey(data, "ctrl+c")) {
       this.cleanup();
-      this.done({ cancelled: true, changes: new Map() });
+      this.done({ cancelled: true, changes: new Map(), disabledChanges: new Map() });
       return;
     }
@@ -424,7 +433,7 @@ class McpPanel {
         return;
       }
       this.cleanup();
-      this.done({ cancelled: true, changes: new Map() });
+      this.done({ cancelled: true, changes: new Map(), disabledChanges: new Map() });
       return;
     }
@@ -477,6 +486,17 @@ class McpPanel {
       return;
     }
+    if (matchesKey(data, "ctrl+d")) {
+      const item = this.visibleItems[this.cursorIndex];
+      if (!item || item.type !== "server" || this.authOnly) return;
+      const server = this.servers[item.serverIndex];
+      if (!server) return;
+      server.disabled = !server.disabled;
+      this.updateDirty();
+      this.tui.requestRender();
+      return;
+    }
     if (matchesKey(data, "ctrl+y")) {
       const item = this.visibleItems[this.cursorIndex];
       if (!item) return;
@@ -632,7 +652,7 @@ class McpPanel {
   private handleDiscardInput(data: string): void {
     if (matchesKey(data, "ctrl+c")) {
       this.cleanup();
-      this.done({ cancelled: true, changes: new Map() });
+      this.done({ cancelled: true, changes: new Map(), disabledChanges: new Map() });
       return;
     }
     if (matchesKey(data, "escape") || data === "n" || data === "N") {
@@ -642,7 +662,7 @@ class McpPanel {
     if (this.keys.selectConfirm(data)) {
       this.cleanup();
       if (this.discardSelected === 0) {
-        this.done({ cancelled: true, changes: new Map() });
+        this.done({ cancelled: true, changes: new Map(), disabledChanges: new Map() });
       } else {
         this.done(this.buildResult());
       }
@@ -650,7 +670,7 @@ class McpPanel {
     }
     if (data === "y" || data === "Y") {
       this.cleanup();
-      this.done({ cancelled: true, changes: new Map() });
+      this.done({ cancelled: true, changes: new Map(), disabledChanges: new Map() });
       return;
     }
     if (matchesKey(data, "left") || matchesKey(data, "right") || matchesKey(data, "tab")) {
@@ -883,6 +903,7 @@ class McpPanel {
           italic("⏎") + " expand/auth",
           italic("ctrl+a") + " auth",
           italic("ctrl+r") + " reconnect",
+          italic("ctrl+d") + " disable/enable",
           ...(this.selectedServerHasFailureMessage() ? [italic("ctrl+y") + " copy error"] : []),
           italic("?") + " desc search",
           ...(saveLabel ? [italic(saveLabel) + " save"] : []),
@@ -995,7 +1016,7 @@ class McpPanel {
   private renderConnectionStatus(server: ServerState): string {
     const t = this.t;
     if (this.authInFlight === server.name) return `  ${fg(t.needsAuth, "authenticating")}`;
-    if (server.connectionStatus === "disabled") return `  ${fg(t.description, "disabled")}`;
+    if (server.disabled) return `  ${fg(t.description, "disabled")}`;
     if (server.connectionStatus === "needs-auth") return `  ${fg(t.needsAuth, "needs auth")}`;
     if (server.connectionStatus === "connecting") return `  ${fg(t.needsAuth, "connecting")}`;
     if (server.connectionStatus === "failed") return `  ${fg(t.cancel, "failed")}`;