pi-mcp-extension 1.8.0 → 1.9.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-mcp-extension",
-  "version": "1.8.0",
+  "version": "1.9.1",
   "description": "MCP (Model Context Protocol) client extension for the Pi coding agent — connect Pi to any MCP server",
   "type": "module",
   "keywords": [
@@ -37,8 +37,8 @@
     "zod": "^3.25.0"
   },
   "peerDependencies": {
-    "@mariozechner/pi-ai": "*",
-    "@mariozechner/pi-coding-agent": "*",
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
     "typebox": "*"
   },
   "devDependencies": {

package/src/config.ts

@@ -40,64 +40,100 @@ const AuthConfigSchema = z.object({
   clientSecret: z.string().optional(),
 });
 
-const ServerConfigSchema = z
-  .object({
-    /** Executable to spawn (e.g. "npx", "node", "uvx"). Required for stdio. */
-    command: z.string().optional(),
-    /** Arguments passed to command. */
-    args: z.array(z.string()).default([]),
-    /**
-     * Extra environment variables passed to the child process as literals.
-     * These merge with process.env; project env overrides parent env.
-     * No ${VAR} interpolation — set vars in your shell environment instead.
-     */
-    env: z.record(z.string()).optional(),
-    /** Transport protocol. Default: "stdio". */
-    transport: z.enum(["stdio", "streamable-http", "sse"]).default("stdio"),
-    /**
-     * URL for streamable-http or sse transports.
-     * Must be a valid URL (e.g. "https://my-mcp-server.example.com/mcp").
-     */
-    url: z.string().url().optional(),
-    /**
-     * Static HTTP headers to include with every request (streamable-http / sse only).
-     * Useful for API-key-based auth (e.g. { "Authorization": "Bearer <key>" }).
-     * For OAuth2, use the "auth" field instead.
-     */
-    headers: z.record(z.string()).optional(),
-    /**
-     * OAuth2 configuration for servers that require authorization.
-     * When set, the transport will use the SDK's OAuth flow (discovery,
-     * dynamic client registration, PKCE, token refresh).
-     * Only applies to streamable-http and sse transports.
-     */
-    auth: AuthConfigSchema.optional(),
-    /**
-     * "eager" — start at session_start.
-     * "lazy"  — start manually via /mcp:start command.
-     */
-    lifecycle: z.enum(["eager", "lazy"]).default("lazy"),
-    /** Per-request timeout in ms. Overrides global setting. Default: 30000. */
-    requestTimeoutMs: z.number().positive().optional(),
-    /**
-     * Opt-in heartbeat interval (ping) in ms.
-     * Only useful for long-lived connections where you want proactive liveness checks.
-     * Default: disabled.
-     */
-    healthCheckIntervalMs: z.number().positive().optional(),
-  })
-  .refine(
-    (cfg) => {
-      if (cfg.transport === "stdio") return cfg.command !== undefined;
-      return cfg.url !== undefined;
-    },
-    (cfg) => ({
-      message:
-        cfg.transport === "stdio"
-          ? `"command" is required for stdio transport`
-          : `"url" is required for ${cfg.transport} transport`,
-    }),
-  );
+export const ServerConfigSchema = z.preprocess(
+  (raw) => {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return raw;
+    const obj = { ...(raw as Record<string, unknown>) };
+    const rawTransport = obj.transport ?? obj.type;
+    if (rawTransport === "http") {
+      obj.transport = "streamable-http";
+    } else if (obj.transport === undefined && rawTransport !== undefined) {
+      obj.transport = rawTransport;
+    } else if (obj.transport === undefined && obj.url !== undefined && obj.command === undefined) {
+      obj.transport = "streamable-http";
+    }
+    if (obj.auth === undefined && obj.oauth && typeof obj.oauth === "object" && !Array.isArray(obj.oauth)) {
+      const oauth = obj.oauth as Record<string, unknown>;
+      const redirectUrl =
+        typeof oauth.redirectUrl === "string"
+          ? oauth.redirectUrl
+          : typeof oauth.callbackUrl === "string"
+            ? oauth.callbackUrl
+            : typeof oauth.callbackPort === "number"
+              ? `http://127.0.0.1:${oauth.callbackPort}/callback`
+              : undefined;
+      obj.auth = {
+        type: "oauth",
+        ...(redirectUrl !== undefined ? { redirectUrl } : {}),
+        ...(typeof oauth.scope === "string" ? { scope: oauth.scope } : {}),
+        ...(typeof oauth.clientId === "string" ? { clientId: oauth.clientId } : {}),
+        ...(typeof oauth.clientSecret === "string" ? { clientSecret: oauth.clientSecret } : {}),
+      };
+    }
+    if (obj.requestTimeoutMs === undefined && typeof obj.timeout === "number" && obj.timeout > 0) {
+      obj.requestTimeoutMs = obj.timeout * 1000;
+    }
+    return obj;
+  },
+  z
+    .object({
+      /** Executable to spawn (e.g. "npx", "node", "uvx"). Required for stdio. */
+      command: z.string().optional(),
+      /** Arguments passed to command. */
+      args: z.array(z.string()).default([]),
+      /**
+       * Extra environment variables passed to the child process as literals.
+       * These merge with process.env; project env overrides parent env.
+       * No ${VAR} interpolation — set vars in your shell environment instead.
+       */
+      env: z.record(z.string()).optional(),
+      /** Transport protocol. Default: "stdio" (or "streamable-http" when "url" is provided). */
+      transport: z.enum(["stdio", "streamable-http", "sse"]).default("stdio"),
+      /**
+       * URL for streamable-http or sse transports.
+       * Must be a valid URL (e.g. "https://my-mcp-server.example.com/mcp").
+       */
+      url: z.string().url().optional(),
+      /**
+       * Static HTTP headers to include with every request (streamable-http / sse only).
+       * Useful for API-key-based auth (e.g. { "Authorization": "Bearer <key>" }).
+       * For OAuth2, use the "auth" field instead.
+       */
+      headers: z.record(z.string()).optional(),
+      /**
+       * OAuth2 configuration for servers that require authorization.
+       * When set, the transport will use the SDK's OAuth flow (discovery,
+       * dynamic client registration, PKCE, token refresh).
+       * Only applies to streamable-http and sse transports.
+       */
+      auth: AuthConfigSchema.optional(),
+      /**
+       * "eager" — start at session_start.
+       * "lazy"  — start manually via /mcp:start command.
+       */
+      lifecycle: z.enum(["eager", "lazy"]).default("lazy"),
+      /** Per-request timeout in ms. Overrides global setting. Default: 30000. */
+      requestTimeoutMs: z.number().positive().optional(),
+      /**
+       * Opt-in heartbeat interval (ping) in ms.
+       * Only useful for long-lived connections where you want proactive liveness checks.
+       * Default: disabled.
+       */
+      healthCheckIntervalMs: z.number().positive().optional(),
+    })
+    .refine(
+      (cfg) => {
+        if (cfg.transport === "stdio") return cfg.command !== undefined;
+        return cfg.url !== undefined;
+      },
+      (cfg) => ({
+        message:
+          cfg.transport === "stdio"
+            ? `"command" is required for stdio transport`
+            : `"url" is required for ${cfg.transport} transport`,
+      }),
+    ),
+);
 
 const SettingsSchema = z.object({
   /**
@@ -145,6 +181,16 @@ export type ServerConfig = z.output<typeof ServerConfigSchema>;
 export type Settings = z.output<typeof SettingsSchema>;
 export type McpConfig = z.output<typeof McpConfigSchema>;
 
+export interface LoadConfigOptions {
+  /**
+   * Whether to read project-level `<cwd>/.pi/mcp.json`.
+   * Set to `false` when the project is untrusted (`ctx.isProjectTrusted() === false`)
+   * or during bootstrap before session trust is resolved.
+   * Default: `true`.
+   */
+  includeProjectConfig?: boolean;
+}
+
 // ─── Loader ───────────────────────────────────────────────────────────────────
 
 async function readJsonFile(path: string): Promise<unknown | null> {
@@ -181,6 +227,36 @@ function parseWith<S extends z.ZodTypeAny>(
   return result.data;
 }
 
+/**
+ * Parse and normalize a server configuration registered via `pi.registerMcpServer()`.
+ * Extension-registered servers default to `lifecycle: "eager"` (unless `enabled: false`
+ * or `lifecycle` is explicitly specified) so they connect on `session_start` / `mcp_servers_change`.
+ */
+export function parseRegisteredServerConfig(
+  name: string,
+  raw: unknown,
+  sourcePath = "<extension>",
+): ServerConfig {
+  const rawObj = raw && typeof raw === "object" && !Array.isArray(raw)
+    ? (raw as Record<string, unknown>)
+    : undefined;
+  const withLifecycle = rawObj && rawObj.lifecycle === undefined
+    ? { ...rawObj, lifecycle: rawObj.enabled === false ? "lazy" : "eager" }
+    : raw;
+  const result = ServerConfigSchema.safeParse(withLifecycle);
+  if (!result.success) {
+    const issues = result.error.issues
+      .map((i) => `  mcpServers.${name}${i.path.length ? `.${i.path.join(".")}` : ""}: ${i.message}`)
+      .join("\n");
+    throw new McpError(
+      `Invalid MCP server "${name}" from ${sourcePath}:\n${issues}`,
+      name,
+      "config",
+    );
+  }
+  return result.data;
+}
+
 function mergeConfigs(
   globalCfg: McpConfig,
   projectCfg: ProjectConfig,
@@ -199,7 +275,7 @@ function mergeConfigs(
 
 /**
  * Pi's agent directory, resolved the way Pi resolves it (`getAgentDir()` in
- * @mariozechner/pi-coding-agent): $PI_CODING_AGENT_DIR when set (tilde expanded), else
+ * @earendil-works/pi-coding-agent): $PI_CODING_AGENT_DIR when set (tilde expanded), else
  * ~/.pi/agent. Pi profiles and alternative agent dirs only work through that variable.
  */
 export function agentDir(env: NodeJS.ProcessEnv = process.env): string {
@@ -214,15 +290,20 @@ export function agentDir(env: NodeJS.ProcessEnv = process.env): string {
 
 /**
  * Load and merge global (<agent dir>/mcp.json) and project (<cwd>/.pi/mcp.json) configs.
- * Project config takes precedence over global config.
+ * Project config takes precedence over global config when `options.includeProjectConfig !== false`.
  * Returns a fully validated, merged config.
  */
-export async function loadConfig(cwd: string, globalPath = join(agentDir(), "mcp.json")): Promise<McpConfig> {
+export async function loadConfig(
+  cwd: string,
+  globalPath = join(agentDir(), "mcp.json"),
+  options?: LoadConfigOptions,
+): Promise<McpConfig> {
+  const includeProjectConfig = options?.includeProjectConfig !== false;
   const projectPath = join(cwd, ".pi", "mcp.json");
 
   const [globalRaw, projectRaw] = await Promise.all([
     readJsonFile(globalPath),
-    readJsonFile(projectPath),
+    includeProjectConfig ? readJsonFile(projectPath) : Promise.resolve(null),
   ]);
 
   // If neither file exists, return an empty valid config

package/src/index.ts

@@ -7,8 +7,14 @@
  * Wires together: config → server manager → tool bridge → Pi API.
  */
 
-import type { ExtensionAPI, ExtensionContext, ExtensionCommandContext, ExtensionUIContext } from "@mariozechner/pi-coding-agent";
-import { loadConfig, type McpConfig } from "./config.js";
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+  ExtensionCommandContext,
+  ExtensionUIContext,
+  RegisteredMcpServer,
+} from "@earendil-works/pi-coding-agent";
+import { loadConfig, parseRegisteredServerConfig, type McpConfig, type ServerConfig } from "./config.js";
 import { ServerManager } from "./server-manager.js";
 import { AuthLockError, AuthRequiredError } from "./oauth-provider.js";
 import * as Type from "typebox";
@@ -80,6 +86,13 @@ export class AuthCancelledError extends Error {
 export const authRetryOption = "Retry: open browser again";
 export const authPasteOption = "Paste redirect URL";
 export const authCancelOption = "Cancel authentication";
+export const startupAuthNowOption = "Authorize now";
+export const startupAuthLaterOption = "Not now";
+
+function formatErrorMessage(err: unknown): string {
+  const msg = err instanceof McpError ? err.userMessage : err instanceof Error ? err.message : String(err);
+  return msg.replace(/^AuthRequiredError:\s*/, "");
+}
 
 interface OAuthCallbackResult {
   type: "callback";
@@ -274,33 +287,199 @@ export function serverNameCompletions(
   return completions.length > 0 ? completions : null;
 }
 
+function collectRegisteredServers(
+  entries: readonly RegisteredMcpServer[],
+  fileServers: Record<string, ServerConfig>,
+  onError?: (err: unknown) => void,
+): Record<string, ServerConfig> {
+  const registered: Record<string, ServerConfig> = {};
+  for (const entry of entries) {
+    // Servers configured in mcp.json take precedence over extension-registered servers.
+    if (Object.prototype.hasOwnProperty.call(fileServers, entry.name)) {
+      continue;
+    }
+    try {
+      registered[entry.name] = parseRegisteredServerConfig(
+        entry.name,
+        entry.config,
+        entry.extensionPath || "<extension>",
+      );
+    } catch (err) {
+      onError?.(err);
+    }
+  }
+  return registered;
+}
+
+function mergeWithRegisteredServers(
+  fileConfig: McpConfig,
+  registeredServers: Record<string, ServerConfig>,
+): McpConfig {
+  return {
+    settings: fileConfig.settings,
+    mcpServers: {
+      ...registeredServers,
+      ...fileConfig.mcpServers,
+    },
+  };
+}
+
 export default async function (pi: ExtensionAPI, paths: { bootstrapCwd?: string; globalConfigPath?: string; authStorageDir?: string; browserOpen?: (url: string) => void | Promise<void> } = {}): Promise<void> {
   // ── 1. Load and validate config ──────────────────────────────────────────
-  // cwd is available on the ExtensionContext passed to event handlers.
-  // We load config lazily on session_start to get the correct per-session cwd.
-  // For the initial load we use process.cwd() as a bootstrap path to detect
-  // whether any config exists at all.
-  let config: McpConfig;
+  // cwd and project trust are available on the ExtensionContext passed to event handlers.
+  // At bootstrap (before session_start) we load ONLY the global config so untrusted
+  // <cwd>/.pi/mcp.json files are never read before ctx.isProjectTrusted() is checked.
+  let fileConfig: McpConfig = {
+    settings: { toolPrefix: "mcp", requestTimeoutMs: 30000, maxRetries: 5 },
+    mcpServers: {},
+  };
   try {
-    config = await loadConfig(paths.bootstrapCwd ?? process.cwd(), paths.globalConfigPath);
+    fileConfig = await loadConfig(paths.bootstrapCwd ?? process.cwd(), paths.globalConfigPath, {
+      includeProjectConfig: false,
+    });
   } catch (err) {
     // Can't notify yet (no ctx), so log to stderr. The session_start handler
     // will re-try with the real cwd and surface errors properly.
     console.error(`[pi-mcp] Config error: ${err instanceof McpError ? err.message : String(err)}`);
-    return;
   }
 
-  if (Object.keys(config.mcpServers).length === 0) {
-    // No servers configured — silently exit. Users can create mcp.json later.
-    return;
-  }
+  const getRegisteredEntries = (): RegisteredMcpServer[] =>
+    typeof (pi as { getMcpServers?: () => RegisteredMcpServer[] }).getMcpServers === "function"
+      ? pi.getMcpServers()
+      : [];
+
+  let extensionServers = collectRegisteredServers(
+    getRegisteredEntries(),
+    fileConfig.mcpServers,
+    (err) => console.error(`[pi-mcp] Config error: ${err instanceof McpError ? err.message : String(err)}`),
+  );
+  let config: McpConfig = mergeWithRegisteredServers(fileConfig, extensionServers);
 
   // ── 2. Initialize bridge components ──────────────────────────────────────
   const manager = new ServerManager(config, undefined, paths.authStorageDir);
   const bridge = new ToolBridge(config.settings, pi);
   const connectAttempts = new Map<string, { promise: Promise<void>; controller: AbortController; reset: boolean; waiters: number }>();
+  const declinedStartupAuth = new Set<string>();
+  const startupPromptControllers = new Map<string, AbortController>();
   let authQueue: Promise<void> = Promise.resolve();
 
+  function enqueueStartupAuthPrompt(name: string, ctx: ExtensionContext): void {
+    let release!: () => void;
+    const previous = authQueue;
+    authQueue = new Promise<void>((resolve) => {
+      release = resolve;
+    });
+    void (async () => {
+      try {
+        await previous;
+        if (
+          declinedStartupAuth.has(name) ||
+          manager.getServer(name)?.state === "ready" ||
+          connectAttempts.has(name)
+        ) {
+          return;
+        }
+        const promptController = new AbortController();
+        startupPromptControllers.set(name, promptController);
+        let choice: string | undefined;
+        try {
+          choice = await new Promise<string | undefined>((resolve, reject) => {
+            if (promptController.signal.aborted) {
+              resolve(undefined);
+              return;
+            }
+            const onAbort = () => resolve(undefined);
+            promptController.signal.addEventListener("abort", onAbort, { once: true });
+            ctx.ui
+              .select(
+                `${name} needs authorization`,
+                [startupAuthNowOption, startupAuthLaterOption],
+                { signal: promptController.signal },
+              )
+              .then(
+                (value) => {
+                  promptController.signal.removeEventListener("abort", onAbort);
+                  resolve(value);
+                },
+                (err) => {
+                  promptController.signal.removeEventListener("abort", onAbort);
+                  if (promptController.signal.aborted) resolve(undefined);
+                  else reject(err);
+                },
+              );
+          });
+        } finally {
+          if (startupPromptControllers.get(name) === promptController) {
+            startupPromptControllers.delete(name);
+          }
+        }
+        if (
+          promptController.signal.aborted ||
+          manager.getServer(name)?.state === "ready" ||
+          connectAttempts.has(name)
+        ) {
+          return;
+        }
+        if (choice === startupAuthNowOption) {
+          try {
+            await connectRequested(name, ctx, undefined, false, true);
+          } catch (err) {
+            if (!(err instanceof AuthCancelledError)) {
+              const msg = formatErrorMessage(err);
+              ctx.ui.notify(`pi-mcp: Failed to start ${name} — ${msg}`, "error");
+            }
+          }
+        } else {
+          declinedStartupAuth.add(name);
+          ctx.ui.setStatus?.("pi-mcp", `run /mcp:auth ${name}`);
+        }
+      } catch (err) {
+        if (!(err instanceof AuthCancelledError)) {
+          const msg = formatErrorMessage(err);
+          ctx.ui.notify(`pi-mcp: Failed to start ${name} — ${msg}`, "error");
+        }
+      } finally {
+        release();
+      }
+    })();
+  }
+
+  async function startEagerServers(
+    serversToStart: Array<[string, ServerConfig]>,
+    ctx: ExtensionContext,
+  ): Promise<void> {
+    const authRequiredServers = new Set<string>();
+
+    // Start all eager servers concurrently
+    await Promise.allSettled(
+      serversToStart.map(async ([name, cfg]) => {
+        try {
+          await manager.startServer(name, ctx.cwd);
+        } catch (err) {
+          if (err instanceof AuthRequiredError && cfg.auth && ctx.hasUI) {
+            authRequiredServers.add(name);
+            return;
+          }
+          const msg = formatErrorMessage(err);
+          ctx.ui.notify(`pi-mcp: Failed to start ${name} — ${msg}`, "error");
+        }
+      }),
+    );
+
+    for (const [name] of serversToStart) {
+      if (!authRequiredServers.has(name)) continue;
+      if (declinedStartupAuth.has(name)) {
+        ctx.ui.setStatus?.("pi-mcp", `run /mcp:auth ${name}`);
+        continue;
+      }
+      enqueueStartupAuthPrompt(name, ctx);
+    }
+
+    for (let i = 0; i < 4 * authRequiredServers.size; i++) {
+      await Promise.resolve();
+    }
+  }
+
   manager.setToolRefreshCallback(async (serverName, client) => {
     await bridge.refreshTools(serverName, client, () => {
       const server = manager.getServer(serverName);
@@ -311,19 +490,40 @@ export default async function (pi: ExtensionAPI, paths: { bootstrapCwd?: string;
 
   // ── 3. Session lifecycle ──────────────────────────────────────────────────
   pi.on("session_start", async (_event, ctx: ExtensionContext) => {
-    // Reload config with the real session cwd (project config may differ)
-    let sessionConfig = config;
+    // Only load project-level <cwd>/.pi/mcp.json when the project is trusted.
+    const includeProjectConfig =
+      typeof (ctx as { isProjectTrusted?: () => boolean }).isProjectTrusted === "function"
+        ? (ctx as { isProjectTrusted: () => boolean }).isProjectTrusted()
+        : true;
+
+    let nextFileConfig = fileConfig;
     try {
-      sessionConfig = await loadConfig(ctx.cwd, paths.globalConfigPath);
+      nextFileConfig = await loadConfig(ctx.cwd, paths.globalConfigPath, { includeProjectConfig });
     } catch (err) {
-      const msg = err instanceof McpError ? err.userMessage : String(err);
+      const msg = formatErrorMessage(err);
       ctx.ui.notify(`pi-mcp: Config error — ${msg}`, "error");
       return;
     }
 
-    // If config changed (different cwd with project-level overrides),
+    fileConfig = nextFileConfig;
+    extensionServers = collectRegisteredServers(
+      getRegisteredEntries(),
+      fileConfig.mcpServers,
+      (err) => {
+        const msg = formatErrorMessage(err);
+        ctx.ui.notify(`pi-mcp: Config error — ${msg}`, "error");
+      },
+    );
+    const sessionConfig = mergeWithRegisteredServers(fileConfig, extensionServers);
+
+    // If config changed (different cwd with project-level overrides or registered servers),
     // shut down old servers and rebuild the manager's server list
     if (JSON.stringify(sessionConfig) !== JSON.stringify(config)) {
+      declinedStartupAuth.clear();
+      for (const controller of startupPromptControllers.values()) {
+        controller.abort();
+      }
+      startupPromptControllers.clear();
       // Deactivate and remove all tools from old config
       for (const server of manager.getAllServers()) {
         bridge.removeServer(server.name);
@@ -331,6 +531,7 @@ export default async function (pi: ExtensionAPI, paths: { bootstrapCwd?: string;
       // Shut down all running servers
       await manager.shutdownAll();
       // Rebuild server entries from new config
+      bridge.updateSettings(sessionConfig.settings);
       manager.rebuildServers(sessionConfig);
       config = sessionConfig;
     }
@@ -339,20 +540,62 @@ export default async function (pi: ExtensionAPI, paths: { bootstrapCwd?: string;
       ([, cfg]) => cfg.lifecycle === "eager",
     );
 
-    // Start all eager servers concurrently
-    await Promise.allSettled(
-      eagerServers.map(async ([name]) => {
-        try {
-          await manager.startServer(name, ctx.cwd);
-        } catch (err) {
-          const msg = err instanceof McpError ? err.userMessage : String(err);
-          ctx.ui.notify(`pi-mcp: Failed to start ${name} — ${msg}`, "error");
-        }
-      }),
+    await startEagerServers(eagerServers, ctx);
+  });
+
+  // Connect or disconnect MCP servers registered dynamically via pi.registerMcpServer().
+  pi.on("mcp_servers_change", async (event, ctx: ExtensionContext) => {
+    const entries = Array.isArray((event as { servers?: unknown })?.servers)
+      ? ((event as { servers: RegisteredMcpServer[] }).servers)
+      : getRegisteredEntries();
+
+    const nextExtensionServers = collectRegisteredServers(
+      entries,
+      fileConfig.mcpServers,
+      (err) => {
+        const msg = formatErrorMessage(err);
+        ctx.ui.notify(`pi-mcp: Config error — ${msg}`, "error");
+      },
     );
+
+    const removedOrChanged: string[] = [];
+    for (const [name, prevCfg] of Object.entries(extensionServers)) {
+      const nextCfg = nextExtensionServers[name];
+      if (!nextCfg || JSON.stringify(prevCfg) !== JSON.stringify(nextCfg)) {
+        removedOrChanged.push(name);
+      }
+    }
+
+    for (const name of removedOrChanged) {
+      declinedStartupAuth.delete(name);
+      startupPromptControllers.get(name)?.abort();
+      startupPromptControllers.delete(name);
+      connectAttempts.get(name)?.controller.abort();
+      bridge.removeServer(name);
+      await manager.removeServer(name);
+    }
+
+    const addedEager: Array<[string, ServerConfig]> = [];
+    for (const [name, nextCfg] of Object.entries(nextExtensionServers)) {
+      if (!manager.getServer(name)) {
+        manager.setServer(name, nextCfg);
+        if (nextCfg.lifecycle === "eager") {
+          addedEager.push([name, nextCfg]);
+        }
+      }
+    }
+
+    extensionServers = nextExtensionServers;
+    config = mergeWithRegisteredServers(fileConfig, extensionServers);
+
+    if (addedEager.length > 0) {
+      await startEagerServers(addedEager, ctx);
+    }
   });
 
   pi.on("session_shutdown", async (_event, _ctx: ExtensionContext) => {
+    for (const controller of startupPromptControllers.values()) controller.abort();
+    startupPromptControllers.clear();
     for (const attempt of connectAttempts.values()) attempt.controller.abort();
     await stopCallbackServer().catch(() => {});
 
@@ -410,6 +653,7 @@ export default async function (pi: ExtensionAPI, paths: { bootstrapCwd?: string;
         ctx.ui.notify(`pi-mcp: No server named "${serverName}"`, "error");
         return;
       }
+      startupPromptControllers.get(serverName)?.abort();
       connectAttempts.get(serverName)?.controller.abort();
       bridge.deactivateServer(serverName);
       await manager.stopServer(serverName);
@@ -435,7 +679,7 @@ export default async function (pi: ExtensionAPI, paths: { bootstrapCwd?: string;
         await connectRequested(serverName, ctx);
         ctx.ui.notify(`pi-mcp: Started ${serverName}`, "info");
       } catch (err) {
-        const msg = err instanceof McpError ? err.userMessage : String(err);
+        const msg = formatErrorMessage(err);
         ctx.ui.notify(`pi-mcp: Failed to start ${serverName} — ${msg}`, "error");
       }
     },
@@ -653,12 +897,21 @@ export default async function (pi: ExtensionAPI, paths: { bootstrapCwd?: string;
     }
   }
 
-  async function connectRequested(serverName: string, ctx: ExtensionContext, signal?: AbortSignal, reset = false): Promise<void> {
+  async function connectRequested(
+    serverName: string,
+    ctx: ExtensionContext,
+    signal?: AbortSignal,
+    reset = false,
+    alreadyQueued = false,
+  ): Promise<void> {
     const server = manager.getServer(serverName);
     if (!server) throw new McpError(`Unknown server "${serverName}"`, serverName, "config");
     if (signal?.aborted) throw new AuthCancelledError(serverName);
     if (reset && !server.config.auth) throw new McpError(`Server "${serverName}" has no OAuth configuration`, serverName, "config");
     if (reset && !ctx.hasUI) throw new AuthRequiredError(serverName);
+    if (!alreadyQueued) {
+      startupPromptControllers.get(serverName)?.abort();
+    }
 
     const waitForAttempt = async (entry: { promise: Promise<void>; controller: AbortController; reset: boolean; waiters: number }): Promise<void> => {
       entry.waiters++;
@@ -725,24 +978,35 @@ export default async function (pi: ExtensionAPI, paths: { bootstrapCwd?: string;
         if (!reset) await manager.startServer(serverName, ctx.cwd);
         else throw new AuthRequiredError(serverName);
         if (controller.signal.aborted) { await manager.stopServer(serverName); throw new AuthCancelledError(serverName); }
+        declinedStartupAuth.delete(serverName);
+        if (declinedStartupAuth.size === 0) ctx.ui.setStatus?.("pi-mcp", undefined);
         return;
       } catch (err) {
         if (!(err instanceof AuthRequiredError) || !server.config.auth) throw err;
       }
       if (!ctx.hasUI) throw new AuthRequiredError(serverName);
-      let release!: () => void;
-      const previous = authQueue;
-      authQueue = new Promise<void>((resolve) => { release = resolve; });
-      try {
-        await previous;
+      const runInteractiveAuth = async (): Promise<void> => {
         if (controller.signal.aborted) throw new AuthCancelledError(serverName);
         await authorize(serverName, ctx, controller.signal, reset);
         if (controller.signal.aborted) throw new AuthCancelledError(serverName);
         await manager.startServer(serverName, ctx.cwd);
         if (controller.signal.aborted) { await manager.stopServer(serverName); throw new AuthCancelledError(serverName); }
-      } finally {
-        release();
+      };
+      if (alreadyQueued) {
+        await runInteractiveAuth();
+      } else {
+        let release!: () => void;
+        const previous = authQueue;
+        authQueue = new Promise<void>((resolve) => { release = resolve; });
+        try {
+          await previous;
+          await runInteractiveAuth();
+        } finally {
+          release();
+        }
       }
+      declinedStartupAuth.delete(serverName);
+      if (declinedStartupAuth.size === 0) ctx.ui.setStatus?.("pi-mcp", undefined);
     })().catch((err: unknown) => {
       if (controller.signal.aborted) throw new AuthCancelledError(serverName);
       throw err;

package/src/oauth-provider.ts

@@ -263,6 +263,7 @@ export class McpOAuthProvider implements OAuthClientProvider {
         ...(state.clientInfo.client_secret && { client_secret: state.clientInfo.client_secret }),
       };
     }
+    if (this.silent) throw new AuthRequiredError(this.serverName);
     return undefined;
   }
 

package/src/server-manager.ts

@@ -256,6 +256,30 @@ export class ServerManager {
     );
   }
 
+  /** Add or replace a stopped server entry in the manager. */
+  setServer(name: string, serverConfig: ServerConfig): void {
+    this.servers.set(name, {
+      name,
+      config: serverConfig,
+      state: "stopped",
+      client: null,
+      childPid: null,
+      retryCount: 0,
+      lastError: null,
+      stderrLog: [],
+      healthCheckTimer: null,
+      retryTimer: null,
+    });
+  }
+
+  /** Shut down and remove a server entry from the manager. */
+  async removeServer(name: string): Promise<void> {
+    const server = this.servers.get(name);
+    if (!server) return;
+    await this._shutdown(server);
+    this.servers.delete(name);
+  }
+
   /**
    * Rebuild the server map from a new config.
    * Must only be called after shutdownAll() — old servers are discarded.
@@ -266,18 +290,7 @@ export class ServerManager {
     this.settings = config.settings;
     this.servers.clear();
     for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
-      this.servers.set(name, {
-        name,
-        config: serverConfig,
-        state: "stopped",
-        client: null,
-        childPid: null,
-        retryCount: 0,
-        lastError: null,
-        stderrLog: [],
-        healthCheckTimer: null,
-        retryTimer: null,
-      });
+      this.setServer(name, serverConfig);
     }
   }
 

package/src/tool-bridge.ts

@@ -16,7 +16,7 @@ import { Client } from "@modelcontextprotocol/sdk/client/index.js";
 import { CallToolResultSchema, ListToolsResultSchema } from "@modelcontextprotocol/sdk/types.js";
 import * as Type from "typebox";
 import type { TSchema } from "typebox";
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { McpError } from "./errors.js";
 import type { Settings } from "./config.js";
 
@@ -313,7 +313,7 @@ export async function listAllTools(
  * Tools are registered once and activated/deactivated as servers connect/disconnect.
  */
 export class ToolBridge {
-  private readonly settings: Settings;
+  private settings: Settings;
   private readonly pi: PiExtensionAPI;
   /** Tracks which Pi tool names belong to which MCP server. */
   private readonly serverToolNames = new Map<string, Set<string>>();
@@ -323,6 +323,11 @@ export class ToolBridge {
     this.pi = pi;
   }
 
+  /** Update bridge settings when session config is reloaded on session_start. */
+  updateSettings(settings: Settings): void {
+    this.settings = settings;
+  }
+
   /**
    * Refresh tools for a server — called on initial connect and on list_changed.
    * Always re-registers tools with the current client reference so that