@fitchmultz/pi-mcp-adapter 5.0.0 → 7.0.0

package/index.ts

@@ -1,900 +0,0 @@
-import type { AgentToolUpdateCallback, ExtensionAPI, ExtensionContext, ToolInfo } from "@earendil-works/pi-coding-agent";
-import type { McpExtensionState } from "./state.ts";
-import type { DirectToolSpec, McpAdapterOptions, McpConfig, PromptMetadata } from "./types.ts";
-import type { McpOAuthRuntime } from "./mcp-auth-flow.ts";
-import { Type } from "typebox";
-import { showStatus, showTools, showPrompts, reconnectServer, reconnectServers, authenticateServer, logoutServer, openMcpAuthPanel, openMcpPanel, openMcpSetup } from "./commands.ts";
-import { cloneMcpConfig, isPathInsideProject, loadMcpConfig, writeProjectServerDisabledOverride } from "./config.ts";
-import { buildProxyDescription, createDirectToolExecutor, getMissingConfiguredDirectToolServers, resolveDirectTools } from "./direct-tools.ts";
-import { flushMetadataCache, initializeMcp, updateStatusBar } from "./init.ts";
-import { getMetadataCachePath, loadMetadataCache, type MetadataCache } from "./metadata-cache.ts";
-import { createPromptCommand, resolveCachedPrompts } from "./prompts.ts";
-import { logger } from "./logger.ts";
-import { executeAuthComplete, executeAuthStart, executeCall, executeConnect, executeDescribe, executeInstructions, executeList, executeSearch, executeStatus, executeUiMessages } from "./proxy-modes.ts";
-import { formatTerminalError, normalizeDirectToolInputSchema, truncateAtWord } from "./utils.ts";
-import { createOAuthRuntime, shutdownOAuth } from "./mcp-auth-flow.ts";
-import { createMcpDirectToolCallRenderer, renderMcpProxyToolCall, renderMcpToolResult } from "./tool-result-renderer.ts";
-import { toolErrorOverride } from "./error-signal.ts";
-import { createMcpRuntimeOwner, createOwnedUi, isAbortError, type McpRuntimeOwner } from "./runtime-owner.ts";
-import { publishMcpStatusShutdown } from "./mcp-status.ts";
-import { DEFAULT_MCP_SCRIPT_TIMEOUT_MS, runMcpScript } from "./mcp-code.ts";
-import { MAX_PAGE_SIZE, MAX_TOOL_NAME_LENGTH } from "./search-ranking.ts";
-import { abortable } from "./abort.ts";
-import { onSessionCheckpoint, prepareMcpCheckpoint } from "./checkpoint.ts";
-
-export type { McpAdapterOptions, McpOperationContext, McpToolCallEvent, McpToolCallIdentity } from "./types.ts";
-export {
-  MCP_STATUS_EVENT,
-  MCP_STATUS_SNAPSHOT_VERSION,
-  type McpServerRuntimeStatus,
-  type McpServerStatusSnapshot,
-  type McpStatusSnapshot,
-} from "./types.ts";
-
-const INIT_WAIT_TIMEOUT_MS = 30_000;
-const INIT_WAIT_TIMED_OUT: unique symbol = Symbol("init-wait-timed-out");
-const inactiveDirectToolsKey = Symbol.for("fitch-mcp-adapter.inactive-direct-tools");
-const inactiveDirectToolsBySession = (() => {
-  const shared = globalThis as typeof globalThis & {
-    [inactiveDirectToolsKey]?: Map<string, Set<string>>;
-  };
-  return shared[inactiveDirectToolsKey] ??= new Map<string, Set<string>>();
-})();
-
-async function awaitWithTimeout<T>(promise: Promise<T>, timeoutMs: number): Promise<T | typeof INIT_WAIT_TIMED_OUT> {
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  try {
-    return await Promise.race([
-      promise,
-      new Promise<typeof INIT_WAIT_TIMED_OUT>((resolve) => {
-        timer = setTimeout(() => resolve(INIT_WAIT_TIMED_OUT), timeoutMs);
-        timer.unref?.();
-      }),
-    ]);
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-function installMcpAdapter(pi: ExtensionAPI, options: McpAdapterOptions) {
-  const beforeExecute = options.beforeExecute;
-  const sessionConfig = options.config !== undefined ? cloneMcpConfig(options.config) : undefined;
-  const programmaticConfig = sessionConfig !== undefined;
-  let state: McpExtensionState | null = null;
-  let initPromise: Promise<McpExtensionState> | null = null;
-  let currentOwner: McpRuntimeOwner | null = null;
-  let currentOAuthRuntime: McpOAuthRuntime | null = null;
-  let lifecycleGeneration = 0;
-  let currentConfigPath: string | undefined;
-
-  async function shutdownState(currentState: McpExtensionState | null, reason: string): Promise<void> {
-    if (!currentState) {
-      publishMcpStatusShutdown(pi.events);
-      return;
-    }
-
-    const failures: unknown[] = [];
-    try { publishMcpStatusShutdown(currentState.statusEvents); } catch (error) { failures.push(error); }
-    try { currentState.uiServer?.close(reason); } catch (error) { failures.push(error); }
-    currentState.uiServer = null;
-    try { flushMetadataCache(currentState); } catch (error) { failures.push(error); }
-    try {
-      if (currentState.owner) await currentState.owner.stop(reason);
-      else await currentState.lifecycle.gracefulShutdown();
-    } catch (error) { failures.push(error); }
-    if (failures.length) throw new AggregateError(failures, "MCP state persistence/cleanup failed");
-  }
-
-  const earlyConfig = programmaticConfig
-    ? cloneMcpConfig(sessionConfig)
-    : { mcpServers: {} };
-  const earlyCache: MetadataCache | null = null;
-  const envRaw = process.env.MCP_DIRECT_TOOLS;
-  const envDirectToolOverride = envRaw?.split(",").map(s => s.trim()).filter(Boolean);
-  const registeredDirectTools = new Map<string, string>();
-  const deactivatedTools = new Set<string>();
-  const preservedInactiveTools = new Set<string>();
-  let activationKey: string | null = null;
-  let proxyToolRegistered = false;
-  let proxyToolDescription: string | null = null;
-  let directToolsFrozen = false;
-
-  function directToolFingerprint(spec: DirectToolSpec): string {
-    return JSON.stringify({
-      serverName: spec.serverName,
-      originalName: spec.originalName,
-      prefixedName: spec.prefixedName,
-      description: spec.description,
-      inputSchema: spec.inputSchema,
-      annotations: spec.annotations,
-      resourceUri: spec.resourceUri,
-      uiResourceUri: spec.uiResourceUri,
-      uiStreamMode: spec.uiStreamMode,
-    });
-  }
-
-  function registerDirectTool(spec: DirectToolSpec): void {
-    const execute = createDirectToolExecutor(() => state, () => initPromise, spec, beforeExecute);
-    pi.registerTool({
-      ...(beforeExecute ? { executionMode: "sequential" as const } : {}),
-      name: spec.prefixedName,
-      label: `MCP: ${spec.originalName}`,
-      description: spec.description || "(no description)",
-      promptSnippet: truncateAtWord(spec.description, 100) || `MCP tool from ${spec.serverName}`,
-      parameters: Type.Unsafe<Record<string, unknown>>(normalizeDirectToolInputSchema(spec.inputSchema)),
-      execute,
-      renderCall: createMcpDirectToolCallRenderer(spec.prefixedName),
-      renderResult: renderMcpToolResult,
-    });
-    if (preservedInactiveTools.has(spec.prefixedName)) {
-      const activeTools = pi.getActiveTools();
-      if (activeTools.includes(spec.prefixedName)) {
-        pi.setActiveTools(activeTools.filter((name) => name !== spec.prefixedName));
-      }
-    }
-  }
-
-  function resolveCurrentDirectTools(config: McpConfig, cache: MetadataCache | null): DirectToolSpec[] {
-    if (envRaw === "__none__") return [];
-    const prefix = config.settings?.toolPrefix ?? "server";
-    return resolveDirectTools(config, cache, prefix, envDirectToolOverride);
-  }
-
-  function deactivateTools(toolNames: string[]): void {
-    if (toolNames.length === 0) return;
-    const remove = new Set(toolNames);
-    const activeTools = pi.getActiveTools();
-    for (const toolName of toolNames) {
-      if (activeTools.includes(toolName)) deactivatedTools.add(toolName);
-    }
-    const nextActiveTools = activeTools.filter((name) => !remove.has(name));
-    if (nextActiveTools.length !== activeTools.length) {
-      pi.setActiveTools(nextActiveTools);
-    }
-  }
-
-  function syncDirectTools(config: McpConfig, cache: MetadataCache | null): {
-    specs: DirectToolSpec[];
-    added: string[];
-    updated: string[];
-    deactivated: string[];
-  } {
-    const specs = resolveCurrentDirectTools(config, cache);
-    const nextNames = new Set(specs.map((spec) => spec.prefixedName));
-    const added: string[] = [];
-    const updated: string[] = [];
-    const deactivated: string[] = [];
-
-    for (const spec of specs) {
-      const fingerprint = directToolFingerprint(spec);
-      const previous = registeredDirectTools.get(spec.prefixedName);
-      if (previous !== fingerprint) {
-        registerDirectTool(spec);
-        registeredDirectTools.set(spec.prefixedName, fingerprint);
-        if (deactivatedTools.delete(spec.prefixedName)) {
-          const activeTools = pi.getActiveTools();
-          if (!activeTools.includes(spec.prefixedName)) {
-            pi.setActiveTools([...activeTools, spec.prefixedName]);
-          }
-        }
-        (previous ? updated : added).push(spec.prefixedName);
-      }
-    }
-
-    for (const toolName of [...registeredDirectTools.keys()]) {
-      if (nextNames.has(toolName)) continue;
-      registeredDirectTools.delete(toolName);
-      deactivated.push(toolName);
-    }
-
-    deactivateTools(deactivated);
-    return { specs, added, updated, deactivated };
-  }
-
-  function applyDirectToolConfigChanges(changes: Map<string, true | string[] | false>): void {
-    if (!state) return;
-    for (const [serverName, value] of changes) {
-      const definition = state.config.mcpServers[serverName];
-      if (!definition) continue;
-      state.config.mcpServers[serverName] = { ...definition, directTools: value };
-    }
-  }
-
-  function syncToolSurface(ctx?: ExtensionContext): void {
-    const config = state?.config ?? earlyConfig;
-    const cache = loadMetadataCache(state?.metadataCacheEnabled ?? false);
-    const result = syncDirectTools(config, cache);
-    syncProxyTool(config, cache, result.specs);
-    syncScriptTool(config);
-    const changed = result.added.length + result.updated.length + result.deactivated.length;
-    if (changed > 0 && ctx?.hasUI) {
-      ctx.ui.notify(
-        `MCP: direct tools refreshed (+${result.added.length}, ~${result.updated.length}, -${result.deactivated.length})`,
-        "info",
-      );
-    }
-  }
-
-  const registeredPromptCommands = new Set<string>();
-
-  function registerPromptCommands(specs: Iterable<PromptMetadata>): void {
-    for (const spec of specs) {
-      if (registeredPromptCommands.has(spec.commandName)) {
-        logger.debug(`MCP: prompt "${spec.originalName}" on ${spec.serverName} skipped; /${spec.commandName} is already registered`);
-        continue;
-      }
-      registeredPromptCommands.add(spec.commandName);
-      pi.registerCommand(spec.commandName, createPromptCommand(pi, () => state, spec));
-    }
-  }
-
-  function syncPromptCommands(): void {
-    registerPromptCommands([...(state?.promptMetadata?.values() ?? [])].flat());
-  }
-
-  if (!options.transformConfig) registerPromptCommands(resolveCachedPrompts(earlyConfig, false));
-
-  const getPiTools = (): ToolInfo[] => pi.getAllTools();
-
-  pi.registerFlag("mcp-config", {
-    description: "Path to MCP config file",
-    type: "string",
-  });
-
-  function startInitialization(
-    ctx: ExtensionContext,
-    owner: McpRuntimeOwner,
-    oauthRuntime: McpOAuthRuntime,
-    runtimeConfig: McpConfig,
-    generation: number,
-  ): Promise<void> {
-    const promise = initializeMcp(pi, ctx, owner, {
-      ...(programmaticConfig ? { config: runtimeConfig } : { resolvedConfig: runtimeConfig }),
-      ...(options.outputDirectory !== undefined ? { outputDirectory: options.outputDirectory } : {}),
-      oauthRuntime,
-      statusEvents: pi.events,
-      ...(options.onToolCall ? { onToolCall: options.onToolCall } : {}),
-    });
-    initPromise = promise;
-
-    return promise.then(async (nextState) => {
-      if (!owner.isActive() || generation !== lifecycleGeneration || initPromise !== promise) {
-        try {
-          await shutdownState(nextState, "stale_session_start");
-        } catch (error) {
-          console.error(`MCP: failed to clean stale initialization state: ${formatTerminalError(error)}`);
-        }
-        return;
-      }
-
-      state = nextState;
-      nextState.onToolMetadataUpdated = (_serverName, _reason) => {
-        if (state !== nextState || !owner.isActive()) return;
-        syncPromptCommands();
-        if (directToolsFrozen) {
-          logger.debug(`MCP: metadata update for ${_serverName} (${_reason}) skipped — directTools frozen`);
-          return;
-        }
-        syncToolSurface(ctx);
-      };
-      syncPromptCommands();
-      syncToolSurface(ctx);
-      updateStatusBar(nextState);
-      initPromise = null;
-      if (nextState.config.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");
-      }
-    }).catch(async err => {
-      if (!owner.isActive() || generation !== lifecycleGeneration) {
-        return;
-      }
-      if (initPromise !== promise && initPromise !== null) {
-        return;
-      }
-      console.error(`MCP initialization failed: ${formatTerminalError(err)}`);
-      initPromise = null;
-      if (state) return;
-
-      try {
-        await Promise.all([
-          owner.stop("MCP initialization failed"),
-          shutdownOAuth(oauthRuntime),
-        ]);
-      } catch (error) {
-        console.error(`MCP: failed to clean rejected initialization: ${formatTerminalError(error)}`);
-      }
-    });
-  }
-
-  pi.on("session_start", async (_event, ctx) => {
-    const generation = ++lifecycleGeneration;
-    const previousState = state;
-    const previousOwner = currentOwner;
-    const previousOAuthRuntime = currentOAuthRuntime;
-    const owner = createMcpRuntimeOwner();
-    const oauthRuntime = createOAuthRuntime(owner.signal);
-    currentOwner = owner;
-    currentOAuthRuntime = oauthRuntime;
-    state = null;
-    initPromise = null;
-
-    // Abort synchronously before awaiting cleanup so old callbacks and startup
-    // work cannot resume into a stale ExtensionContext.
-    const stopPrevious = previousOwner?.stop("MCP extension session restarted") ?? Promise.resolve();
-    try {
-      await Promise.all([
-        stopPrevious,
-        shutdownState(previousState, "session_restart"),
-        previousOAuthRuntime ? shutdownOAuth(previousOAuthRuntime) : Promise.resolve(),
-      ]);
-    } catch (error) {
-      console.error(`MCP: failed to shut down previous session state: ${formatTerminalError(error)}`);
-    }
-
-    if (generation !== lifecycleGeneration || !owner.isActive()) return;
-
-    let runtimeConfig: McpConfig;
-    if (programmaticConfig) {
-      currentConfigPath = undefined;
-      runtimeConfig = cloneMcpConfig(sessionConfig);
-    } else {
-      const registeredConfigPath = pi.getFlag("mcp-config");
-      currentConfigPath = options.configPath
-        ?? (typeof registeredConfigPath === "string" ? registeredConfigPath : undefined);
-      runtimeConfig = loadMcpConfig(
-        currentConfigPath,
-        ctx.cwd,
-        { includeProject: ctx.isProjectTrusted() },
-      );
-    }
-    if (options.transformConfig) {
-      runtimeConfig = cloneMcpConfig(options.transformConfig(cloneMcpConfig(runtimeConfig), ctx));
-    }
-    const metadataCacheEnabled = ctx.isProjectTrusted()
-      || !isPathInsideProject(getMetadataCachePath(), ctx.cwd);
-    activationKey = `${ctx.cwd}\0${currentConfigPath ?? ""}`;
-    preservedInactiveTools.clear();
-    for (const toolName of inactiveDirectToolsBySession.get(activationKey) ?? []) {
-      preservedInactiveTools.add(toolName);
-    }
-    registerPromptCommands(resolveCachedPrompts(runtimeConfig, metadataCacheEnabled));
-    const runtimeCache = loadMetadataCache(metadataCacheEnabled);
-    const cachedDirectTools = syncDirectTools(runtimeConfig, runtimeCache).specs;
-    syncProxyTool(runtimeConfig, runtimeCache, cachedDirectTools);
-    syncScriptTool(runtimeConfig);
-
-    const initialization = startInitialization(ctx, owner, oauthRuntime, runtimeConfig, generation);
-    if (envRaw !== undefined && envRaw !== "__none__") {
-      const missingEnvDirectTools = getMissingConfiguredDirectToolServers(
-        runtimeConfig,
-        runtimeCache,
-        envDirectToolOverride,
-      );
-      if (missingEnvDirectTools.length > 0) {
-        await initialization;
-      }
-    }
-  });
-
-  onSessionCheckpoint(pi, async event => {
-    if (initPromise) return { sleepReady: false, reason: "MCP initialization is active" };
-    if (!state || !currentOwner?.isActive()) return { sleepReady: false, reason: "MCP runtime is not initialized" };
-    return prepareMcpCheckpoint(state, event);
-  });
-
-  pi.on("session_shutdown", async () => {
-    if (activationKey) {
-      const activeTools = new Set(pi.getActiveTools());
-      const inactiveTools = new Set(
-        [...registeredDirectTools.keys()].filter((name) => !activeTools.has(name)),
-      );
-      if (inactiveTools.size > 0) inactiveDirectToolsBySession.set(activationKey, inactiveTools);
-      else inactiveDirectToolsBySession.delete(activationKey);
-    }
-    ++lifecycleGeneration;
-    const currentState = state;
-    const owner = currentOwner;
-    const oauthRuntime = currentOAuthRuntime;
-    currentOwner = null;
-    currentOAuthRuntime = null;
-    state = null;
-    initPromise = null;
-
-    // Abort before awaiting cleanup so delayed initialization cannot touch stale
-    // Pi context after session shutdown.
-    const stopOwner = owner?.stop("MCP extension session shutdown") ?? Promise.resolve();
-    const results = await Promise.allSettled([
-      stopOwner,
-      shutdownState(currentState, "session_shutdown"),
-      oauthRuntime ? shutdownOAuth(oauthRuntime) : Promise.resolve(),
-    ]);
-    const failures = results.flatMap(result => result.status === "rejected" ? [result.reason] : []);
-    // Ordinary extension error handling owns reporting. Strict clean-exit hosts must see failure.
-    if (failures.length) throw new AggregateError(failures, "MCP session shutdown persistence/cleanup failed");
-  });
-
-  // Re-flag returned MCP tool failures so pi registers them as errors (see toolErrorOverride).
-  pi.on("tool_result", (event) => toolErrorOverride(event.details));
-
-  function createCommandContext(ctx: ExtensionContext): {
-    owner: McpRuntimeOwner | null;
-    context: ExtensionContext;
-  } {
-    const owner = currentOwner;
-    const hasUI = ctx.hasUI;
-    const projectTrusted = ctx.isProjectTrusted();
-    return {
-      owner,
-      context: {
-        hasUI,
-        ui: hasUI ? (owner ? createOwnedUi(ctx.ui, owner) : ctx.ui) : undefined,
-        cwd: ctx.cwd,
-        mode: ctx.mode,
-        signal: owner?.signal ?? ctx.signal,
-        isProjectTrusted: () => projectTrusted,
-      } as unknown as ExtensionContext,
-    };
-  }
-
-  async function ensureCommandState(owner: McpRuntimeOwner | null, ctx: ExtensionContext): Promise<McpExtensionState | null> {
-    if (!state && initPromise) {
-      try {
-        const initialized = await initPromise;
-        owner?.throwIfInactive();
-        state = initialized;
-      } catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        ctx.ui?.notify(`MCP initialization failed: ${message}`, "error");
-        return null;
-      }
-    }
-    if (!state) ctx.ui?.notify("MCP not initialized", "error");
-    return state;
-  }
-
-  pi.registerCommand("mcp", {
-    description: "Show MCP server status",
-    getArgumentCompletions: (prefix: string) => {
-      const normalized = prefix.trimStart();
-      const argumentMatch = normalized.match(/^(\S+)\s+(.*)$/);
-      if (!argumentMatch) {
-        const subcommands = [
-          { value: "reconnect", label: "reconnect — Reconnect servers" },
-          { value: "tools", label: "tools — List all tools" },
-          { value: "prompts", label: "prompts — List all MCP prompts" },
-          { value: "setup", label: "setup — Configure MCP servers" },
-          { value: "logout", label: "logout — Clear server credentials" },
-          { value: "disable", label: "disable — Disable a server" },
-          { value: "enable", label: "enable — Enable a server" },
-          { value: "status", label: "status — Show server status" },
-        ].filter(({ value }) => value.startsWith(normalized));
-        return subcommands.length > 0 ? subcommands : null;
-      }
-
-      const [, subcommand, argumentPrefix] = argumentMatch;
-      if (
-        (subcommand !== "reconnect" && subcommand !== "logout" && subcommand !== "disable" && subcommand !== "enable")
-        || argumentPrefix === undefined
-        || !state
-      ) return null;
-
-      const servers = Object.keys(state.config.mcpServers)
-        .filter((serverName) => serverName.startsWith(argumentPrefix.trimStart()))
-        .map((serverName) => ({ value: `${subcommand} ${serverName}`, label: serverName }));
-      return servers.length > 0 ? servers : null;
-    },
-    handler: async (args, ctx) => {
-      const { owner: commandOwner, context: commandCtx } = createCommandContext(ctx);
-      const commandProjectTrusted = commandCtx.isProjectTrusted();
-      const commandState = await ensureCommandState(commandOwner, commandCtx);
-      if (!commandState) return;
-
-      const parts = args?.trim()?.split(/\s+/) ?? [];
-      const subcommand = parts[0] ?? "";
-      const targetServer = parts[1];
-      const rest = parts.slice(1).join(" ");
-
-      switch (subcommand) {
-        case "reconnect":
-          commandOwner?.throwIfInactive();
-          await reconnectServers(commandState, commandCtx, targetServer);
-          if (directToolsFrozen) syncToolSurface(commandCtx);
-          break;
-        case "tools":
-          await showTools(commandState, commandCtx);
-          break;
-        case "prompts":
-          await showPrompts(commandState, commandCtx);
-          break;
-        case "setup": {
-          commandOwner?.throwIfInactive();
-          if (programmaticConfig) {
-            commandCtx.ui?.notify("MCP setup is unavailable when config is supplied by createMcpAdapter().", "info");
-            break;
-          }
-          const result = await openMcpSetup(commandState, pi, commandCtx, currentConfigPath, "setup");
-          if (result?.configChanged) {
-            commandOwner?.throwIfInactive();
-            await ctx.reload();
-            return;
-          }
-          break;
-        }
-        case "logout": {
-          const serverName = rest;
-          if (!serverName) {
-            if (commandCtx.hasUI) commandCtx.ui?.notify("Usage: /mcp logout <server>", "error");
-            return;
-          }
-          commandOwner?.throwIfInactive();
-          await logoutServer(serverName, commandState, commandCtx);
-          break;
-        }
-        case "disable":
-        case "enable": {
-          const serverName = rest;
-          if (!commandProjectTrusted) {
-            commandCtx.ui?.notify("Project MCP changes are unavailable until this project is trusted.", "warning");
-            break;
-          }
-          if (programmaticConfig) {
-            commandCtx.ui?.notify(`/mcp ${subcommand} is unavailable when config is supplied by createMcpAdapter().`, "info");
-            break;
-          }
-          if (!serverName) {
-            commandCtx.ui?.notify(`Usage: /mcp ${subcommand} <server>`, "error");
-            break;
-          }
-          if (!commandState.config.mcpServers[serverName]) {
-            commandCtx.ui?.notify(`Server "${serverName}" not found in effective config`, "error");
-            break;
-          }
-          commandOwner?.throwIfInactive();
-          const result = writeProjectServerDisabledOverride(currentConfigPath, commandCtx.cwd, serverName, subcommand === "disable");
-          if (result.changed) {
-            commandCtx.ui?.notify(`${subcommand === "disable" ? "Disabled" : "Enabled"} server "${serverName}" in ${result.path} — run /reload to apply`, "info");
-          } else {
-            commandCtx.ui?.notify(`Server "${serverName}" is already ${subcommand === "disable" ? "disabled" : "enabled"}`, "info");
-          }
-          break;
-        }
-        case "status":
-        case "":
-        default:
-          if (commandCtx.hasUI) {
-            commandOwner?.throwIfInactive();
-            if (programmaticConfig) {
-              commandCtx.ui?.notify("MCP status is shown from the in-memory SDK config; configuration discovery is unavailable.", "info");
-              await showStatus(commandState, commandCtx);
-              break;
-            }
-            const result = await openMcpPanel(commandState, pi, commandCtx, currentConfigPath, (changes) => {
-              applyDirectToolConfigChanges(changes);
-              syncToolSurface(commandCtx);
-            });
-            if (result?.configChanged) {
-              commandOwner?.throwIfInactive();
-              await ctx.reload();
-              return;
-            }
-          } else {
-            await showStatus(commandState, commandCtx);
-          }
-          break;
-      }
-    },
-  });
-
-  pi.registerCommand("mcp-auth", {
-    description: "Authenticate with an MCP server (OAuth)",
-    handler: async (args, ctx) => {
-      const { owner: commandOwner, context: commandCtx } = createCommandContext(ctx);
-      const serverName = args?.trim();
-      if (!serverName && !commandCtx.hasUI) {
-        return;
-      }
-
-      const commandState = await ensureCommandState(commandOwner, commandCtx);
-      if (!commandState) return;
-
-      if (!serverName) {
-        if (programmaticConfig) {
-          commandCtx.ui?.notify("Use /mcp-auth <server> to authenticate a server from the in-memory SDK config.", "info");
-          return;
-        }
-        await openMcpAuthPanel(commandState, commandCtx, currentConfigPath);
-        return;
-      }
-
-      const result = await authenticateServer(serverName, commandState.config, commandCtx, commandCtx.signal, commandState.oauthRuntime);
-      if (result.ok) {
-        commandOwner?.throwIfInactive();
-        await reconnectServer(commandState, commandCtx, serverName, true);
-      }
-    },
-  });
-
-  let scriptToolRegistered = false;
-
-  function registerScriptTool(): void {
-    if (scriptToolRegistered) return;
-    pi.registerTool({
-      ...(beforeExecute ? { executionMode: "sequential" as const } : {}),
-      name: "mcp_script",
-      label: "MCP Script",
-      description: "Run trusted JavaScript that makes multiple MCP tool calls in one request — loop, filter, chain, or fan out between calls. For a single MCP call, search, describe, status check, or auth action, use the mcp tool instead. Discover with await tools.search({ query }) — resolves to { items: [{ path, name, server, description? }], total, hasMore, nextOffset }, not an { ok, data } envelope. Inspect with await tools.describe({ path }) — resolves to the tool descriptor with inputTypeScript when representable, otherwise the original JSON inputSchema, or { path, error: { code, message, suggestions } }. Then call tools.call(path, args) — resolves to { ok: true, data } or { ok: false, error: { code, message } }; data is the raw MCP result: tool calls usually return { content, structuredContent? }, while resource reads return { contents }. The sandbox has no Node, filesystem, or network globals. Use direct flat calls when the name is already known; use emit(value) for user-visible output. Load the mcp-scripting skill for the full workflow guide.",
-      promptSnippet: "Batch multiple MCP tool calls in one JavaScript request (loop, filter, chain)",
-      parameters: Type.Object({
-        code: Type.String({ description: "Trusted JavaScript MCP script. Use tools.<prefixedToolName>(args) and emit(value)." }),
-        timeoutMs: Type.Optional(Type.Number({ minimum: 1, description: options.defaultScriptTimeoutMs === null
-          ? "Execution timeout in milliseconds (no default deadline)"
-          : `Execution timeout in milliseconds (default: ${options.defaultScriptTimeoutMs ?? DEFAULT_MCP_SCRIPT_TIMEOUT_MS})` })),
-      }),
-      renderResult: renderMcpToolResult,
-      async execute(toolCallId: string, params: { code: string; timeoutMs?: number }, signal: AbortSignal | undefined, _onUpdate: AgentToolUpdateCallback<Record<string, unknown>> | undefined, ctx: ExtensionContext) {
-        const executeOwner = currentOwner;
-        if (!state && initPromise) {
-          try {
-            const initialized = await awaitWithTimeout(abortable(initPromise, signal), INIT_WAIT_TIMEOUT_MS);
-            if (initialized === INIT_WAIT_TIMED_OUT) {
-              return {
-                content: [{ type: "text" as const, text: "MCP initialization is still in progress. Try again shortly." }],
-                details: { mode: "script", error: "init_timeout", timeoutMs: INIT_WAIT_TIMEOUT_MS },
-              };
-            }
-            executeOwner?.throwIfInactive();
-            state = initialized;
-          } catch (error) {
-            if (signal?.aborted || (executeOwner && isAbortError(error, executeOwner.signal))) throw error;
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-              content: [{ type: "text" as const, text: `MCP initialization failed: ${message}` }],
-              details: { mode: "script", error: "init_failed", message },
-            };
-          }
-        }
-        if (!state) {
-          return {
-            content: [{ type: "text" as const, text: "MCP not initialized" }],
-            details: { mode: "script", error: "not_initialized" },
-          };
-        }
-        executeOwner?.throwIfInactive();
-        return runMcpScript(state, params.code, params.timeoutMs ?? options.defaultScriptTimeoutMs, getPiTools, signal, toolCallId,
-          beforeExecute ? (callSignal, operation) => beforeExecute(toolCallId, { ...ctx, signal: callSignal }, operation) : undefined);
-      },
-    });
-    scriptToolRegistered = true;
-  }
-
-  function syncScriptTool(config: McpConfig): void {
-    if (config.settings?.scriptMode === false) {
-      if (scriptToolRegistered) deactivateTools(["mcp_script"]);
-      return;
-    }
-
-    registerScriptTool();
-    if (deactivatedTools.delete("mcp_script")) {
-      const activeTools = pi.getActiveTools();
-      if (!activeTools.includes("mcp_script")) pi.setActiveTools([...activeTools, "mcp_script"]);
-    }
-  }
-
-  function registerProxyTool(description: string): void {
-    pi.registerTool({
-      ...(beforeExecute ? { executionMode: "sequential" as const } : {}),
-      name: "mcp",
-      label: "MCP",
-      description,
-      promptSnippet: "MCP gateway — status, search, describe, auth, and single MCP tool calls",
-      renderCall: renderMcpProxyToolCall,
-      parameters: Type.Object({
-        tool: Type.Optional(Type.String({ maxLength: MAX_TOOL_NAME_LENGTH, description: "Tool name to call (e.g., 'xcodebuild_list_sims')" })),
-        args: Type.Optional(Type.Union([
-          Type.String({ description: "Arguments as a JSON string (e.g., '{\"key\": \"value\"}')" }),
-          Type.Object({}, {
-            additionalProperties: true,
-            description: 'Arguments as a JSON object (e.g., { "key": "value" })',
-          }),
-        ], { description: "Tool arguments as a JSON object, or as a JSON string encoding one" })),
-        connect: Type.Optional(Type.String({ description: "Server name to connect (lazy connect + metadata refresh)" })),
-        describe: Type.Optional(Type.String({ maxLength: MAX_TOOL_NAME_LENGTH, description: "Tool name to describe (shows parameters)" })),
-        instructions: Type.Optional(Type.String({ description: "Server name to show that server's usage instructions" })),
-        search: Type.Optional(Type.String({ description: "Search tools by name/description" })),
-        includeSchemas: Type.Optional(Type.Boolean({ description: "Include parameter schemas in search results (default: true)" })),
-        limit: Type.Optional(Type.Number({ minimum: 1, maximum: MAX_PAGE_SIZE, description: "Maximum search or server-list results to return (default: 12, max: 100)" })),
-        offset: Type.Optional(Type.Number({ minimum: 0, description: "Search or server-list result offset (default: 0)" })),
-        server: Type.Optional(Type.String({ description: "Filter to specific server (also disambiguates tool calls)" })),
-        action: Type.Optional(Type.String({ description: "Action: 'ui-messages', 'auth-start', or 'auth-complete'" })),
-      }),
-      renderResult: renderMcpToolResult,
-      async execute(toolCallId: string, params: {
-        tool?: string;
-        args?: string | Record<string, unknown>;
-        connect?: string;
-        describe?: string;
-        instructions?: string;
-        search?: string;
-        includeSchemas?: boolean;
-        limit?: number;
-        offset?: number;
-        server?: string;
-        action?: string;
-      }, signal: AbortSignal | undefined, _onUpdate: AgentToolUpdateCallback<Record<string, unknown>> | undefined, ctx: ExtensionContext) {
-        // Non-call modes have no resolved MCP operation; hosts keep their conservative policy.
-        if (!params.tool || params.action === "ui-messages" || params.action === "auth-start" || params.action === "auth-complete") {
-          if (beforeExecute) {
-            if (currentOwner) await currentOwner.runCallback("beforeExecute", () => beforeExecute(toolCallId, ctx));
-            else await beforeExecute(toolCallId, ctx);
-          }
-        }
-        const executeOwner = currentOwner;
-        let parsedArgs: Record<string, unknown> | undefined;
-        if (params.args !== undefined && params.args !== "") {
-          let args: unknown;
-          if (typeof params.args === "string") {
-            try {
-              args = JSON.parse(params.args);
-            } catch (error) {
-              if (error instanceof SyntaxError) {
-                throw new Error(`Invalid args JSON: ${error.message}`, { cause: error });
-              }
-              throw error;
-            }
-          } else {
-            args = params.args;
-          }
-
-          if (typeof args !== "object" || args === null || Array.isArray(args)) {
-            const gotType = Array.isArray(args) ? "array" : args === null ? "null" : typeof args;
-            throw new Error(`Invalid args: expected a JSON object, got ${gotType}`);
-          }
-          parsedArgs = args as Record<string, unknown>;
-        }
-
-        if (!state && initPromise) {
-          try {
-            const initialized = await awaitWithTimeout(abortable(initPromise, signal), INIT_WAIT_TIMEOUT_MS);
-            if (initialized === INIT_WAIT_TIMED_OUT) {
-              return {
-                content: [{ type: "text" as const, text: "MCP initialization is still in progress. Try again shortly." }],
-                details: { error: "init_timeout", timeoutMs: INIT_WAIT_TIMEOUT_MS },
-              };
-            }
-            executeOwner?.throwIfInactive();
-            state = initialized;
-          } catch (error) {
-            if (signal?.aborted || (executeOwner && isAbortError(error, executeOwner.signal))) throw error;
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-              content: [{ type: "text" as const, text: `MCP initialization failed: ${message}` }],
-              details: { error: "init_failed", message },
-            };
-          }
-        }
-        if (!state) {
-          return {
-            content: [{ type: "text" as const, text: "MCP not initialized" }],
-            details: { error: "not_initialized" },
-          };
-        }
-        executeOwner?.throwIfInactive();
-
-        if (params.action === "ui-messages") {
-          return executeUiMessages(state);
-        }
-        if (params.action === "auth-start") {
-          if (!params.server) {
-            return {
-              content: [{ type: "text" as const, text: "auth-start requires `server`. Example: mcp({ action: \"auth-start\", server: \"linear-server\" })" }],
-              details: { mode: "auth-start", error: "missing_server" },
-            };
-          }
-          return signal
-            ? executeAuthStart(state, params.server, signal)
-            : executeAuthStart(state, params.server);
-        }
-        if (params.action === "auth-complete") {
-          if (!params.server) {
-            return {
-              content: [{ type: "text" as const, text: "auth-complete requires `server`." }],
-              details: { mode: "auth-complete", error: "missing_server" },
-            };
-          }
-          const input = parsedArgs?.redirectUrl ?? parsedArgs?.code ?? parsedArgs?.input;
-          if (input !== undefined && (typeof input !== "string" || input.trim().length === 0)) {
-            return {
-              content: [{ type: "text" as const, text: "auth-complete accepts a non-empty `redirectUrl`, `code`, or `input`, or no args to use the browser callback." }],
-              details: { mode: "auth-complete", error: "missing_input" },
-            };
-          }
-          return signal
-            ? executeAuthComplete(state, params.server, input, signal)
-            : executeAuthComplete(state, params.server, input);
-        }
-        if (params.tool) {
-          return executeCall(state, params.tool, parsedArgs, params.server, getPiTools, signal, undefined, { toolCallId },
-            beforeExecute ? (callSignal, operation) => beforeExecute(toolCallId, { ...ctx, signal: callSignal }, operation) : undefined);
-        }
-        if (params.connect) {
-          const result = await executeConnect(state, params.connect, signal, params.limit, params.offset);
-          syncToolSurface(ctx);
-          return result;
-        }
-        if (params.describe) {
-          return executeDescribe(state, params.describe);
-        }
-        if (params.instructions) {
-          return executeInstructions(state, params.instructions);
-        }
-        if (params.search !== undefined) {
-          return executeSearch(state, params.search, params.server, params.includeSchemas, params.limit, params.offset);
-        }
-        if (params.server) {
-          return executeList(state, params.server, params.limit, params.offset);
-        }
-        return executeStatus(state);
-      },
-    });
-    proxyToolRegistered = true;
-    proxyToolDescription = description;
-  }
-
-  function syncProxyTool(config: McpConfig, cache: MetadataCache | null, directSpecs: DirectToolSpec[]): void {
-    const missingConfiguredDirectToolServers = getMissingConfiguredDirectToolServers(
-      config,
-      cache,
-      envRaw === undefined || envRaw === "__none__" ? undefined : envDirectToolOverride,
-    );
-    const shouldRegisterProxyTool =
-      config.settings?.disableProxyTool !== true
-      || directSpecs.length === 0
-      || missingConfiguredDirectToolServers.length > 0;
-
-    if (shouldRegisterProxyTool) {
-      const description = buildProxyDescription(config);
-      if (!proxyToolRegistered || proxyToolDescription !== description) {
-        registerProxyTool(description);
-      }
-      if (deactivatedTools.delete("mcp")) {
-        const activeTools = pi.getActiveTools();
-        if (!activeTools.includes("mcp")) {
-          pi.setActiveTools([...activeTools, "mcp"]);
-        }
-      }
-      return;
-    }
-
-    if (proxyToolRegistered) deactivateTools(["mcp"]);
-  }
-
-  // A transform needs the session context before any configured tool surface is registered.
-  if (!options.transformConfig) {
-    const initialDirectTools = syncDirectTools(earlyConfig, earlyCache).specs;
-    syncProxyTool(earlyConfig, earlyCache, initialDirectTools);
-    syncScriptTool(earlyConfig);
-  }
-}
-
-export function createMcpAdapter(options: McpAdapterOptions = {}) {
-  const { defaultScriptTimeoutMs } = options;
-  if (defaultScriptTimeoutMs !== undefined && defaultScriptTimeoutMs !== null
-    && (!Number.isInteger(defaultScriptTimeoutMs) || defaultScriptTimeoutMs < 1 || defaultScriptTimeoutMs > 2_147_483_647)) {
-    throw new RangeError("defaultScriptTimeoutMs must be an integer from 1 to 2147483647, or null");
-  }
-  const factoryConfig = options.config !== undefined ? cloneMcpConfig(options.config) : undefined;
-  return function mcpAdapter(pi: ExtensionAPI) {
-    installMcpAdapter(pi, {
-      ...(options.configPath !== undefined ? { configPath: options.configPath } : {}),
-      ...(defaultScriptTimeoutMs !== undefined ? { defaultScriptTimeoutMs } : {}),
-      ...(options.outputDirectory !== undefined ? { outputDirectory: options.outputDirectory } : {}),
-      ...(factoryConfig !== undefined ? { config: cloneMcpConfig(factoryConfig) } : {}),
-      ...(options.beforeExecute ? { beforeExecute: options.beforeExecute } : {}),
-      ...(options.transformConfig ? { transformConfig: options.transformConfig } : {}),
-      ...(options.onToolCall ? { onToolCall: options.onToolCall } : {}),
-    });
-  };
-}
-
-export default createMcpAdapter();