@modelcontextprotocol/inspector 2.9.0 → 2.10.0

package/clients/mcpdo/build/mcp-bin.js

@@ -0,0 +1,3990 @@
+#!/usr/bin/env node
+import {
+  AUTH_HELPER_COMMAND,
+  CallbackNavigation,
+  CliExitCodeError,
+  DAEMON_DIR_ENV,
+  DAEMON_TOKEN_ENV,
+  DEFAULT_MAX_FETCH_REQUESTS,
+  DEFAULT_TASK_TTL_MS,
+  EXIT_CODES,
+  InMemorySecretStore,
+  NodeOAuthStorage,
+  PENDING_AUTH_TTL_MS,
+  PLAIN,
+  assertSocketPathWithinLimit,
+  authorizeInFrontend,
+  awaitableError,
+  awaitableLog,
+  clearAllOAuthClientState,
+  clearEmaIdpSession,
+  createPrivateDaemonDir,
+  disallowMemorySecretStoreFallback,
+  emaLogin,
+  emaLogout,
+  encodeRequest,
+  ensureDaemonDir,
+  generateDaemonToken,
+  getDaemonDir,
+  getDaemonLogPath,
+  getDaemonSocketPath,
+  getDaemonTokenFromEnv,
+  getEmaIdpLoginState,
+  getEmaStatus,
+  getSecretStorageInfo,
+  getStateFilePath,
+  handleError,
+  idpOAuthStorageKey,
+  isCliAutoOpenForced,
+  isSafeLinkTarget,
+  loadEmaIdpConfig,
+  loadServerEntries,
+  normalizeIdpIssuer,
+  obtainPendingAuthUrl,
+  obtainPendingUrlForKey,
+  parseHeaderPair,
+  parseIdpOAuthStorageKey,
+  parseKeyValuePair,
+  pendingAuthMarkerPath,
+  readDaemonTokenFile,
+  readInspectorVersion,
+  readOAuthStore,
+  removeOwnPendingAuthMarker,
+  requireIdp,
+  resetNodeOAuthStorageCache,
+  resolveServerSource,
+  runAuthHelper,
+  runEmaIdpInteractiveFlow,
+  sanitizeDeep,
+  sanitizeText,
+  selectServerEntry,
+  setSecretStorageWarningsQuiet,
+  styleFromOpts,
+  warnAboutSecretStorage,
+  withDefaultCatalogPath,
+  writePendingAuthMarker
+} from "./chunk-2E5EZYNU.js";
+
+// src/mcp-bin.ts
+import { realpathSync } from "fs";
+import { resolve as resolve2 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+
+// src/connection/mcp.ts
+import { Command } from "commander";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import path4 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { getDefaultEnvironment } from "@modelcontextprotocol/client/stdio";
+import { LoggingLevelSchema } from "@modelcontextprotocol/core";
+
+// src/daemon/client.ts
+import { randomUUID } from "crypto";
+import * as net from "net";
+import * as path from "path";
+function daemonTokenDir(options) {
+  if (options.dir !== void 0) return options.dir;
+  if (options.socketPath !== void 0 && !options.socketPath.startsWith("\\\\.\\pipe\\")) {
+    return path.dirname(options.socketPath);
+  }
+  return getDaemonDir();
+}
+async function callDaemon(op, params, options = {}) {
+  const socketPath = options.socketPath ?? getDaemonSocketPath();
+  const timeoutMs = options.timeoutMs ?? 6e4;
+  const id = randomUUID();
+  const token = options.token ?? getDaemonTokenFromEnv() ?? readDaemonTokenFile(daemonTokenDir(options));
+  const request = { id, op, params };
+  if (token !== void 0) request.token = token;
+  return new Promise((resolve3, reject) => {
+    let settled = false;
+    let buffer = "";
+    let queue = Promise.resolve();
+    let timer;
+    const socket = new net.Socket();
+    socket.setEncoding("utf8");
+    function settle(fn) {
+      if (settled) return;
+      settled = true;
+      if (timer !== void 0) clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+      socket.removeAllListeners();
+      socket.on("error", () => {
+      });
+      fn();
+    }
+    function onAbort() {
+      fail(
+        new CliExitCodeError(EXIT_CODES.USAGE, `'${op}' cancelled.`, {
+          code: "cancelled"
+        })
+      );
+    }
+    function fail(error) {
+      settle(() => {
+        socket.destroy();
+        reject(error);
+      });
+    }
+    function succeed(value) {
+      settle(() => {
+        socket.end();
+        resolve3(value);
+      });
+    }
+    function handleLine(line) {
+      const trimmed = line.trim();
+      if (!trimmed) return Promise.resolve();
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch (error) {
+        fail(error);
+        return Promise.resolve();
+      }
+      if (parsed !== null && typeof parsed === "object" && "kind" in parsed && parsed.kind === "elicitation-request") {
+        return handleElicitationRequest(parsed);
+      }
+      handleResponse(parsed);
+      return Promise.resolve();
+    }
+    async function handleElicitationRequest(frame) {
+      if (frame.id !== id) return;
+      if (timer !== void 0) {
+        clearTimeout(timer);
+        timer = void 0;
+      }
+      const answer = options.onElicitation ? await options.onElicitation(frame) : {
+        id: frame.id,
+        kind: "elicitation-response",
+        elicitationId: frame.elicitationId,
+        action: "cancel"
+      };
+      if (settled || socket.destroyed) return;
+      socket.write(JSON.stringify(answer) + "\n");
+    }
+    function handleResponse(response) {
+      if (response.id !== id && response.id !== "?") {
+        return;
+      }
+      if (!response.ok) {
+        fail(
+          new CliExitCodeError(
+            response.error.exitCode ?? EXIT_CODES.USAGE,
+            // Daemon error text can embed server-supplied strings; sanitize
+            // before it reaches a terminal via the shared error handler.
+            sanitizeText(response.error.message),
+            { code: response.error.code }
+          )
+        );
+        return;
+      }
+      succeed(response.result);
+    }
+    socket.on("error", (err) => {
+      fail(
+        new CliExitCodeError(
+          EXIT_CODES.UNREACHABLE,
+          `Cannot reach connection daemon at ${socketPath}: ${err.message}`,
+          { code: "daemon_unreachable" }
+        )
+      );
+    });
+    socket.on("close", () => {
+      if (!settled) {
+        fail(
+          new CliExitCodeError(
+            EXIT_CODES.UNREACHABLE,
+            `Connection daemon closed the connection during '${op}'`,
+            { code: "daemon_unreachable" }
+          )
+        );
+      }
+    });
+    timer = timeoutMs > 0 ? setTimeout(() => {
+      fail(
+        new CliExitCodeError(
+          EXIT_CODES.UNREACHABLE,
+          `Daemon request '${op}' timed out after ${timeoutMs}ms`,
+          { code: "daemon_timeout" }
+        )
+      );
+    }, timeoutMs) : void 0;
+    if (options.signal?.aborted) {
+      onAbort();
+    } else {
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+    }
+    socket.once("connect", () => {
+      socket.write(encodeRequest(request));
+    });
+    socket.on("data", (chunk) => {
+      buffer += String(chunk);
+      let idx;
+      while ((idx = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, idx);
+        buffer = buffer.slice(idx + 1);
+        queue = queue.then(() => handleLine(line)).catch((error) => fail(error));
+      }
+    });
+    if (!settled) socket.connect(socketPath);
+  });
+}
+
+// src/daemon/stream-client.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import * as net2 from "net";
+async function streamDaemon(params, options) {
+  const socketPath = options.socketPath ?? getDaemonSocketPath();
+  const timeoutMs = options.timeoutMs ?? 6e4;
+  const id = randomUUID2();
+  const token = options.token ?? getDaemonTokenFromEnv() ?? readDaemonTokenFile(daemonTokenDir(options));
+  const request = { id, op: "stream", params };
+  if (token !== void 0) request.token = token;
+  return new Promise((resolve3, reject) => {
+    let settled = false;
+    let buffer = "";
+    let streaming = false;
+    let pendingCallbacks = 0;
+    let timer;
+    const socket = new net2.Socket();
+    socket.setEncoding("utf8");
+    function settle(fn) {
+      if (settled) return;
+      settled = true;
+      if (timer !== void 0) clearTimeout(timer);
+      options.signal?.removeEventListener("abort", onAbort);
+      socket.removeAllListeners();
+      socket.on("error", () => {
+      });
+      fn();
+    }
+    function fail(error) {
+      settle(() => {
+        socket.destroy();
+        reject(error);
+      });
+    }
+    function succeed() {
+      settle(() => {
+        socket.destroy();
+        resolve3();
+      });
+    }
+    function onAbort() {
+      succeed();
+    }
+    function handleLine(line) {
+      const trimmed = line.trim();
+      if (!trimmed) return;
+      if (!streaming) {
+        let response;
+        try {
+          response = JSON.parse(trimmed);
+        } catch (error) {
+          fail(error);
+          return;
+        }
+        if (response.id !== id && response.id !== "?") return;
+        if (!response.ok) {
+          fail(
+            new CliExitCodeError(
+              response.error.exitCode ?? EXIT_CODES.USAGE,
+              sanitizeText(response.error.message),
+              { code: response.error.code }
+            )
+          );
+          return;
+        }
+        streaming = true;
+        if (timer !== void 0) {
+          clearTimeout(timer);
+          timer = void 0;
+        }
+        return;
+      }
+      let frame;
+      try {
+        frame = JSON.parse(trimmed);
+      } catch (error) {
+        fail(error);
+        return;
+      }
+      if (frame.id !== id) return;
+      if (frame.stream === "data") {
+        const result = options.onData(frame.data);
+        if (result !== void 0 && typeof result.then === "function") {
+          pendingCallbacks++;
+          socket.pause();
+          void Promise.resolve(result).catch(() => {
+          }).finally(() => {
+            pendingCallbacks--;
+            if (pendingCallbacks === 0 && !settled) socket.resume();
+          });
+        }
+        return;
+      }
+      if (frame.stream === "end") {
+        succeed();
+      }
+    }
+    socket.on("error", (err) => {
+      if (streaming) {
+        fail(
+          new CliExitCodeError(
+            EXIT_CODES.UNREACHABLE,
+            `Connection daemon stream failed: ${err.message}`,
+            { code: "daemon_unreachable" }
+          )
+        );
+        return;
+      }
+      fail(
+        new CliExitCodeError(
+          EXIT_CODES.UNREACHABLE,
+          `Cannot reach connection daemon at ${socketPath}: ${err.message}`,
+          { code: "daemon_unreachable" }
+        )
+      );
+    });
+    socket.on("close", () => {
+      if (settled) return;
+      if (streaming) {
+        fail(
+          new CliExitCodeError(
+            EXIT_CODES.UNREACHABLE,
+            `Connection daemon closed the stream before it ended`,
+            { code: "daemon_unreachable" }
+          )
+        );
+        return;
+      }
+      fail(
+        new CliExitCodeError(
+          EXIT_CODES.UNREACHABLE,
+          `Connection daemon closed the connection before the stream opened`,
+          { code: "daemon_unreachable" }
+        )
+      );
+    });
+    timer = timeoutMs > 0 ? setTimeout(() => {
+      fail(
+        new CliExitCodeError(
+          EXIT_CODES.UNREACHABLE,
+          `Daemon stream open timed out after ${timeoutMs}ms`,
+          { code: "daemon_timeout" }
+        )
+      );
+    }, timeoutMs) : void 0;
+    if (options.signal?.aborted) {
+      onAbort();
+    } else {
+      options.signal?.addEventListener("abort", onAbort, { once: true });
+    }
+    socket.once("connect", () => {
+      socket.write(encodeRequest(request));
+    });
+    socket.on("data", (chunk) => {
+      buffer += String(chunk);
+      let idx;
+      while ((idx = buffer.indexOf("\n")) >= 0) {
+        const line = buffer.slice(0, idx);
+        buffer = buffer.slice(idx + 1);
+        handleLine(line);
+      }
+    });
+    if (!settled) socket.connect(socketPath);
+  });
+}
+
+// src/daemon/ensure.ts
+import { spawn } from "child_process";
+import * as fs from "fs";
+import * as net3 from "net";
+import * as path2 from "path";
+import { fileURLToPath } from "url";
+var READY_TIMEOUT_MS = 1e4;
+var READY_POLL_MS = 50;
+function resolveDaemonScriptPath() {
+  const here = path2.dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    path2.resolve(here, "mcpdod.js"),
+    path2.resolve(here, "../mcpdod.js"),
+    path2.resolve(here, "../../build/mcpdod.js"),
+    path2.resolve(here, "../build/mcpdod.js")
+  ];
+  for (const candidate of candidates) {
+    if (fs.existsSync(candidate)) return candidate;
+  }
+  throw new CliExitCodeError(
+    EXIT_CODES.USAGE,
+    `Connection daemon bundle not found (looked for mcpdod.js near ${here}). Run npm run build in clients/mcpdo.`,
+    { code: "daemon_not_built" }
+  );
+}
+async function isDaemonReachable(socketPath) {
+  return new Promise((resolve3) => {
+    let settled = false;
+    const socket = new net3.Socket();
+    const done = (ok) => {
+      if (settled) return;
+      settled = true;
+      socket.removeAllListeners();
+      socket.on("error", () => {
+      });
+      socket.destroy();
+      resolve3(ok);
+    };
+    socket.on("error", () => done(false));
+    socket.setTimeout(500);
+    socket.once("connect", () => done(true));
+    socket.once("timeout", () => done(false));
+    socket.connect(socketPath);
+  });
+}
+async function waitForDaemon(socketPath, token, logPath, opts) {
+  const deadline = Date.now() + (opts?.timeoutMs ?? READY_TIMEOUT_MS);
+  while (Date.now() < deadline) {
+    if (await isDaemonReachable(socketPath)) {
+      const effectiveToken = opts?.rereadTokenDir ? readDaemonTokenFile(opts.rereadTokenDir) ?? token : token;
+      try {
+        await callDaemon(
+          "ping",
+          {},
+          { socketPath, timeoutMs: 2e3, token: effectiveToken }
+        );
+        return;
+      } catch {
+      }
+    }
+    await new Promise((r) => setTimeout(r, READY_POLL_MS));
+  }
+  const logTail = readLogTail(logPath);
+  throw new CliExitCodeError(
+    EXIT_CODES.UNREACHABLE,
+    `Timed out waiting for connection daemon at ${socketPath}` + (logTail ? `
+Daemon log (${logPath}):
+${logTail}` : ""),
+    { code: "daemon_start_timeout" }
+  );
+}
+function readLogTail(logPath, maxLines = 10) {
+  try {
+    const text = fs.readFileSync(logPath, "utf8");
+    return text.trimEnd().split("\n").slice(-maxLines).join("\n");
+  } catch {
+    return "";
+  }
+}
+var STOPPING_EXIT_TIMEOUT_MS = 1e4;
+var STOPPING_POLL_MS = 100;
+function pidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+async function waitForDaemonExit(pid, socketPath, timeoutMs = STOPPING_EXIT_TIMEOUT_MS, pollMs = STOPPING_POLL_MS) {
+  const deadline = Date.now() + timeoutMs;
+  for (; ; ) {
+    const gone = pid !== void 0 ? !pidAlive(pid) : !await isDaemonReachable(socketPath);
+    if (gone) return;
+    if (Date.now() >= deadline) {
+      throw new CliExitCodeError(
+        EXIT_CODES.UNREACHABLE,
+        "Connection daemon is shutting down but did not exit in time; retry shortly.",
+        { code: "daemon_stopping" }
+      );
+    }
+    await new Promise((r) => setTimeout(r, pollMs));
+  }
+}
+async function ensureDaemon(options) {
+  const dir = options?.dir ?? getDaemonDir();
+  let token = options?.token ?? getDaemonTokenFromEnv();
+  ensureDaemonDir(dir);
+  const socketPath = getDaemonSocketPath(dir);
+  assertSocketPathWithinLimit(socketPath);
+  if (await isDaemonReachable(socketPath)) {
+    token ??= readDaemonTokenFile(dir);
+    const pong = await callDaemon("ping", {}, { socketPath, timeoutMs: 2e3, token });
+    if (pong?.stopping !== true) {
+      return { socketPath, spawned: false };
+    }
+    await waitForDaemonExit(pong.pid, socketPath);
+  }
+  const tokenWasGenerated = token === void 0;
+  token ??= generateDaemonToken();
+  const script = options?.daemonScript ?? resolveDaemonScriptPath();
+  const childEnv = {
+    ...process.env,
+    // Pin the socket directory explicitly so parent and child agree even when
+    // MCP_STORAGE_DIR is unset (default ~/.mcp-inspector).
+    [DAEMON_DIR_ENV]: dir,
+    [DAEMON_TOKEN_ENV]: token
+  };
+  const logPath = getDaemonLogPath(dir);
+  let stderrTarget = "ignore";
+  try {
+    fs.rmSync(logPath, { force: true });
+    stderrTarget = fs.openSync(logPath, "ax", 384);
+  } catch {
+  }
+  const child = spawn(process.execPath, [script], {
+    detached: true,
+    stdio: ["ignore", "ignore", stderrTarget],
+    env: childEnv
+  });
+  child.unref();
+  if (typeof stderrTarget === "number") {
+    fs.closeSync(stderrTarget);
+  }
+  await waitForDaemon(socketPath, token, logPath, {
+    timeoutMs: options?.readyTimeoutMs,
+    rereadTokenDir: tokenWasGenerated ? dir : void 0
+  });
+  return { socketPath, spawned: true };
+}
+
+// ../../core/cli/handlers/servers-list.ts
+function resolveServerListSource(serverOptions = {}) {
+  const source = resolveServerSource(withDefaultCatalogPath(serverOptions));
+  if (!source) return null;
+  return { kind: source.writable ? "catalog" : "config", path: source.path };
+}
+function annotateServerEntriesWithConnections(entries, connections) {
+  if (connections.length === 0) return entries;
+  const byName = new Map(connections.map((s) => [s.name, s]));
+  return entries.map((entry) => {
+    const connection = byName.get(entry.name);
+    if (!connection) return entry;
+    return {
+      ...entry,
+      connection: connection.name,
+      ...connection.isMru === true ? { isMru: true } : {}
+    };
+  });
+}
+var REDACTED = "[redacted]";
+function summarizeServerConfig(config) {
+  if (config.type === "sse" || config.type === "streamable-http") {
+    return { type: config.type, detail: config.url ?? "" };
+  }
+  const args = config.args?.length ? ` ${config.args.join(" ")}` : "";
+  return { type: "stdio", detail: `${config.command}${args}` };
+}
+async function listServerEntries(serverOptions = {}) {
+  const entries = await loadServerEntries({
+    ...serverOptions,
+    secretStore: serverOptions.secretStore ?? new InMemorySecretStore()
+  });
+  return Object.entries(entries).map(([name, resolved]) => {
+    const { type, detail } = summarizeServerConfig(resolved.config);
+    return { name, type, detail };
+  }).sort((a, b) => a.name.localeCompare(b.name));
+}
+async function showServerEntry(serverName, serverOptions = {}) {
+  const name = serverName.trim();
+  if (!name) {
+    throw new Error("servers/show requires a server name.");
+  }
+  const entries = await loadServerEntries(serverOptions);
+  const selected = selectServerEntry(entries, name);
+  const { type, detail } = summarizeServerConfig(selected.config);
+  const result = {
+    name,
+    type,
+    detail,
+    config: sanitizeServerConfig(selected.config)
+  };
+  if (selected.settings) {
+    result.settings = sanitizeServerSettings(selected.settings);
+  }
+  return result;
+}
+function sanitizeServerConfig(config) {
+  const out = { ...config };
+  if ("env" in config && config.env) {
+    out.env = redactStringRecord(config.env);
+  }
+  if ("requestInit" in config && isPlainObject(config.requestInit)) {
+    out.requestInit = sanitizeInitRecord(config.requestInit);
+  }
+  if ("eventSourceInit" in config && isPlainObject(config.eventSourceInit)) {
+    out.eventSourceInit = sanitizeInitRecord(config.eventSourceInit);
+  }
+  return out;
+}
+function sanitizeServerSettings(settings) {
+  const out = {
+    ...settings,
+    headers: (settings.headers ?? []).map((h) => ({
+      key: h.key,
+      value: isSensitiveHeader(h.key) ? REDACTED : h.value
+    })),
+    // Metadata values may be any JSON (#1910), so the redaction has to descend:
+    // a top-level key that is not itself sensitive can hold a nested one that
+    // is. See `redactMetadataValue`.
+    metadata: redactMetadataValue(settings.metadata ?? {}),
+    env: (settings.env ?? []).map((e) => ({
+      key: e.key,
+      value: REDACTED
+    }))
+  };
+  if (settings.oauthClientSecret !== void 0) {
+    out.oauthClientSecret = REDACTED;
+  }
+  return out;
+}
+function redactStringRecord(record) {
+  return Object.fromEntries(Object.keys(record).map((key) => [key, REDACTED]));
+}
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function sanitizeInitRecord(init) {
+  const out = { ...init };
+  if (isPlainObject(init.headers)) {
+    out.headers = Object.fromEntries(
+      Object.entries(init.headers).map(([key, value]) => [
+        key,
+        isSensitiveHeader(key) ? REDACTED : value
+      ])
+    );
+  } else if (Array.isArray(init.headers)) {
+    out.headers = init.headers.map((entry) => {
+      if (Array.isArray(entry) && entry.length >= 2 && typeof entry[0] === "string") {
+        const key = entry[0];
+        const value = entry[1];
+        return [key, isSensitiveHeader(key) ? REDACTED : value];
+      }
+      return entry;
+    });
+  }
+  return out;
+}
+function redactMetadataValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(redactMetadataValue);
+  }
+  if (value !== null && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, member]) => [
+        key,
+        isSensitiveHeader(key) ? REDACTED : redactMetadataValue(member)
+      ])
+    );
+  }
+  return value;
+}
+function isSensitiveHeader(key) {
+  const k = key.toLowerCase();
+  return k.includes("auth") || k.includes("cookie") || k.includes("secret") || k.includes("token") || k.includes("password") || k.includes("api-key") || k.includes("apikey");
+}
+
+// ../../core/cli/handlers/connect-timeout.ts
+var DEFAULT_CONNECT_TIMEOUT_MS = 15e3;
+function withConnectTimeout(settings, connectionTimeout) {
+  if (connectionTimeout === void 0) return settings;
+  if (settings) return { ...settings, connectionTimeout };
+  return {
+    headers: [],
+    metadata: {},
+    env: [],
+    connectionTimeout,
+    requestTimeout: 0,
+    taskTtl: DEFAULT_TASK_TTL_MS,
+    maxFetchRequests: DEFAULT_MAX_FETCH_REQUESTS,
+    autoRefreshOnListChanged: false,
+    paginatedLists: false,
+    roots: []
+  };
+}
+
+// ../../core/cli/handlers/method-types.ts
+var CONNECTION_RPC_METHODS = [
+  "tools/list",
+  "tools/call",
+  "resources/list",
+  "resources/read",
+  "resources/templates/list",
+  "resources/directory/read",
+  "resources/subscribe",
+  "resources/unsubscribe",
+  "prompts/list",
+  "prompts/get",
+  "prompts/complete",
+  "logging/setLevel",
+  "logging/tail",
+  "tasks/list",
+  "tasks/get",
+  "tasks/cancel",
+  "tasks/result",
+  "tasks/update",
+  "roots/list",
+  "roots/set",
+  "skills/list",
+  "skills/get"
+];
+
+// src/connection/ema-login-helper.ts
+var EMA_LOGIN_HELPER_COMMAND = "auth/complete-ema-login";
+function emaLoginMarkerKey(issuer) {
+  return `ema-idp:${issuer}`;
+}
+async function startPendingEmaLogin(options) {
+  const { idp, enabled } = await loadEmaIdpConfig();
+  const active = requireIdp(idp, enabled);
+  const issuer = normalizeIdpIssuer(active.issuer);
+  const storage = new NodeOAuthStorage();
+  if (options?.relogin) {
+    await clearEmaIdpSession(storage, active.issuer);
+  } else if (await getEmaIdpLoginState(storage, active.issuer) === "logged_in") {
+    return { issuer, loginState: "logged_in", alreadyLoggedIn: true };
+  }
+  const authUrl = await obtainPendingUrlForKey(
+    emaLoginMarkerKey(issuer),
+    EMA_LOGIN_HELPER_COMMAND,
+    // The helper re-reads config itself; params document is empty.
+    {},
+    options
+  );
+  return {
+    issuer,
+    loginState: await getEmaIdpLoginState(storage, active.issuer),
+    alreadyLoggedIn: false,
+    pendingLogin: true,
+    authUrl
+  };
+}
+async function runEmaLoginHelper() {
+  const emit = (event) => {
+    try {
+      process.stdout.write(`${JSON.stringify(event)}
+`);
+    } catch {
+    }
+  };
+  process.stdout.on("error", () => {
+  });
+  let markerPath;
+  try {
+    const { idp, enabled } = await loadEmaIdpConfig();
+    const active = requireIdp(idp, enabled);
+    const issuer = normalizeIdpIssuer(active.issuer);
+    const storage = new NodeOAuthStorage();
+    await runEmaIdpInteractiveFlow(
+      active,
+      storage,
+      new CallbackNavigation(async (url) => {
+        markerPath = pendingAuthMarkerPath(emaLoginMarkerKey(issuer));
+        writePendingAuthMarker(markerPath, {
+          url: url.href,
+          pid: process.pid,
+          expiresAt: Date.now() + PENDING_AUTH_TTL_MS
+        });
+        emit({ event: "auth_url", url: url.href });
+      })
+    );
+    emit({ event: "done" });
+  } catch (error) {
+    emit({
+      event: "error",
+      message: error instanceof Error ? error.message : String(error)
+    });
+    throw error;
+  } finally {
+    if (markerPath !== void 0) removeOwnPendingAuthMarker(markerPath);
+  }
+}
+
+// src/connection/parse-tool-args.ts
+function assertJsonRoundTrips(value, context) {
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    throw new Error(
+      `Invalid ${context}: ${value} has no JSON representation (it would silently reach the tool as null).`
+    );
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) assertJsonRoundTrips(item, context);
+  } else if (value !== null && typeof value === "object") {
+    for (const item of Object.values(value)) {
+      assertJsonRoundTrips(item, context);
+    }
+  }
+}
+function parseToolCallPositionals(args) {
+  if (args.length === 0) return {};
+  const first = args[0];
+  if (first.startsWith("{") || first.startsWith("[")) {
+    if (args.length > 1) {
+      throw new Error(
+        "When using inline JSON, only one argument is allowed after the tool name."
+      );
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(first);
+    } catch (e) {
+      throw new Error(
+        `Invalid JSON tool arguments: ${e instanceof Error ? e.message : String(e)}`,
+        { cause: e }
+      );
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      throw new Error("Inline JSON tool arguments must be a JSON object.");
+    }
+    assertJsonRoundTrips(parsed, "inline JSON tool arguments");
+    return parsed;
+  }
+  const out = /* @__PURE__ */ Object.create(null);
+  for (const pair of args) {
+    const sep = pair.indexOf(":=");
+    if (sep === -1) {
+      throw new Error(
+        `Invalid tool argument "${pair}". Use key:=value pairs or a JSON object.
+Examples: message:=hello count:=10 '{"message":"hello"}'`
+      );
+    }
+    const key = pair.slice(0, sep);
+    const rawValue = pair.slice(sep + 2);
+    if (!key) {
+      throw new Error(
+        `Invalid tool argument "${pair}" \u2014 missing key before :=`
+      );
+    }
+    out[key] = autoParseValue(rawValue, `tool argument "${pair}"`);
+  }
+  return out;
+}
+function autoParseValue(raw, context) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return raw;
+  }
+  assertJsonRoundTrips(parsed, context);
+  return parsed;
+}
+function resolveToolCallArgs(input) {
+  const flagArgs = input.toolArgFlag ?? {};
+  const hasFlagArgs = Object.keys(flagArgs).length > 0;
+  const hasJson = input.toolArgsJson !== void 0;
+  let toolName = input.toolNameFlag ?? input.toolNamePos;
+  let positionals = [...input.toolArgsPos ?? []];
+  if (input.toolNameFlag && input.toolNamePos) {
+    positionals = [input.toolNamePos, ...positionals];
+    toolName = input.toolNameFlag;
+  }
+  const hasPositionals = positionals.length > 0;
+  const styles = [hasPositionals, hasFlagArgs, hasJson].filter(Boolean).length;
+  if (styles > 1) {
+    throw new Error(
+      "Tool arguments must use one style: key:=value / JSON positionals, --tool-arg, or --tool-args-json."
+    );
+  }
+  if (hasJson) {
+    return {
+      toolName,
+      toolArg: parseJsonObject(input.toolArgsJson, "--tool-args-json")
+    };
+  }
+  if (hasPositionals) {
+    return { toolName, toolArg: parseToolCallPositionals(positionals) };
+  }
+  return { toolName, toolArg: flagArgs };
+}
+function parseJsonObject(raw, flag) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (e) {
+    throw new Error(
+      `${flag} is not valid JSON: ${e instanceof Error ? e.message : String(e)}`,
+      { cause: e }
+    );
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${flag} must be a JSON object.`);
+  }
+  assertJsonRoundTrips(parsed, flag);
+  return parsed;
+}
+
+// src/connection/resolve-command.ts
+import fs2 from "fs";
+import path3 from "path";
+function resolveCommandPath(command, env = process.env) {
+  if (!command || command.includes("/") || command.includes(path3.sep)) {
+    return command;
+  }
+  const pathVar = env.PATH ?? "";
+  const extensions = process.platform === "win32" ? (
+    // cmd.exe-like: an already-suffixed name ("node.exe") is tried as-is
+    // before PATHEXT variants — otherwise only "node.exe.EXE" etc. would
+    // be searched and resolution would silently fall to the daemon's PATH.
+    [
+      ...path3.extname(command) ? [""] : [],
+      ...(env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD").split(";")
+    ]
+  ) : [""];
+  for (const dir of pathVar.split(path3.delimiter)) {
+    for (const ext of extensions) {
+      const candidate = path3.resolve(dir === "" ? "." : dir, command + ext);
+      try {
+        const stat = fs2.statSync(candidate);
+        if (!stat.isFile()) continue;
+        fs2.accessSync(candidate, fs2.constants.X_OK);
+        return candidate;
+      } catch {
+      }
+    }
+  }
+  return command;
+}
+
+// src/connection/form-schema.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseChoicesFromEnum(value) {
+  if (!Array.isArray(value) || value.length === 0 || value.some((v) => typeof v !== "string")) {
+    return void 0;
+  }
+  return value.map((v) => ({ value: v, label: v }));
+}
+function parseChoicesFromOneOf(value) {
+  if (!Array.isArray(value) || value.length === 0) return void 0;
+  const choices = [];
+  for (const entry of value) {
+    if (!isRecord(entry) || typeof entry.const !== "string") return void 0;
+    choices.push({
+      value: entry.const,
+      label: typeof entry.title === "string" ? entry.title : entry.const
+    });
+  }
+  return choices;
+}
+function isValidCount(value) {
+  return value === void 0 || Number.isInteger(value) && value >= 0;
+}
+function codePointLength(value) {
+  return [...value].length;
+}
+function isConsistent(field) {
+  switch (field.kind) {
+    case "boolean":
+      return true;
+    case "number":
+      if (field.minimum !== void 0 && field.maximum !== void 0 && field.minimum > field.maximum) {
+        return false;
+      }
+      if (field.default !== void 0) {
+        if (field.integer && !Number.isInteger(field.default)) return false;
+        if (field.minimum !== void 0 && field.default < field.minimum)
+          return false;
+        if (field.maximum !== void 0 && field.default > field.maximum)
+          return false;
+      }
+      return true;
+    case "string":
+      if (!isValidCount(field.minLength) || !isValidCount(field.maxLength)) {
+        return false;
+      }
+      if (field.minLength !== void 0 && field.maxLength !== void 0 && field.minLength > field.maxLength) {
+        return false;
+      }
+      if (field.default !== void 0) {
+        if (field.minLength !== void 0 && codePointLength(field.default) < field.minLength) {
+          return false;
+        }
+        if (field.maxLength !== void 0 && codePointLength(field.default) > field.maxLength) {
+          return false;
+        }
+      }
+      return true;
+    case "enum":
+      return field.default === void 0 || field.choices.some((c) => c.value === field.default);
+    case "multiselect": {
+      if (!isValidCount(field.minItems) || !isValidCount(field.maxItems)) {
+        return false;
+      }
+      if (field.minItems !== void 0 && field.maxItems !== void 0 && field.minItems > field.maxItems) {
+        return false;
+      }
+      if (field.minItems !== void 0 && field.minItems > field.choices.length) {
+        return false;
+      }
+      const def = field.default;
+      if (def !== void 0) {
+        if (!def.every((v) => field.choices.some((c) => c.value === v))) {
+          return false;
+        }
+        if (field.minItems !== void 0 && def.length < field.minItems)
+          return false;
+        if (field.maxItems !== void 0 && def.length > field.maxItems)
+          return false;
+      }
+      return true;
+    }
+  }
+}
+function parseField(prop) {
+  const parsed = parseFieldShape(prop);
+  if (!parsed || !isConsistent(parsed)) return null;
+  return parsed;
+}
+function parseFieldShape(prop) {
+  if (!isRecord(prop)) return null;
+  const type = prop.type;
+  if (type === "boolean") {
+    return {
+      kind: "boolean",
+      default: typeof prop.default === "boolean" ? prop.default : void 0
+    };
+  }
+  if (type === "number" || type === "integer") {
+    return {
+      kind: "number",
+      integer: type === "integer",
+      minimum: typeof prop.minimum === "number" ? prop.minimum : void 0,
+      maximum: typeof prop.maximum === "number" ? prop.maximum : void 0,
+      default: typeof prop.default === "number" ? prop.default : void 0
+    };
+  }
+  if (type === "string") {
+    if (prop.enum !== void 0) {
+      const enumChoices = parseChoicesFromEnum(prop.enum);
+      if (!enumChoices) return null;
+      return {
+        kind: "enum",
+        choices: enumChoices,
+        default: typeof prop.default === "string" ? prop.default : void 0
+      };
+    }
+    if (prop.oneOf !== void 0) {
+      const oneOfChoices = parseChoicesFromOneOf(prop.oneOf);
+      if (!oneOfChoices) return null;
+      return {
+        kind: "enum",
+        choices: oneOfChoices,
+        default: typeof prop.default === "string" ? prop.default : void 0
+      };
+    }
+    return {
+      kind: "string",
+      minLength: typeof prop.minLength === "number" ? prop.minLength : void 0,
+      maxLength: typeof prop.maxLength === "number" ? prop.maxLength : void 0,
+      format: typeof prop.format === "string" ? prop.format : void 0,
+      default: typeof prop.default === "string" ? prop.default : void 0
+    };
+  }
+  if (type === "array") {
+    const items = prop.items;
+    if (!isRecord(items)) return null;
+    const choices = parseChoicesFromEnum(items.enum) ?? parseChoicesFromOneOf(items.anyOf);
+    if (!choices) return null;
+    const defaultValue = Array.isArray(prop.default) && prop.default.every((v) => typeof v === "string") ? prop.default : void 0;
+    return {
+      kind: "multiselect",
+      choices,
+      minItems: typeof prop.minItems === "number" ? prop.minItems : void 0,
+      maxItems: typeof prop.maxItems === "number" ? prop.maxItems : void 0,
+      default: defaultValue
+    };
+  }
+  return null;
+}
+function parseFormSchema(schema) {
+  if (!isRecord(schema)) return null;
+  const properties = schema.properties;
+  if (!isRecord(properties)) return null;
+  const required = Array.isArray(schema.required) ? schema.required.filter((v) => typeof v === "string") : [];
+  const fields = [];
+  for (const [name, prop] of Object.entries(properties)) {
+    const parsed = parseField(prop);
+    if (!parsed) return null;
+    const title = isRecord(prop) && typeof prop.title === "string" ? prop.title : name;
+    const description = isRecord(prop) && typeof prop.description === "string" ? prop.description : void 0;
+    fields.push({
+      name,
+      required: required.includes(name),
+      title,
+      description,
+      ...parsed
+    });
+  }
+  return fields;
+}
+
+// src/connection/format-human.ts
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function shortType(schema) {
+  if (!schema || typeof schema !== "object") return "any";
+  const s = schema;
+  const t = s.type;
+  if (t === "array") {
+    if (s.items) return `[${shortType(s.items)}]`;
+    return "[any]";
+  }
+  if (Array.isArray(t)) {
+    const filtered = t.filter((x) => x !== "null");
+    if (filtered.length === 1) return shortTypeName(String(filtered[0]));
+    return filtered.map((x) => shortTypeName(String(x))).join(" | ");
+  }
+  if (Array.isArray(s.enum)) return "enum";
+  if (typeof t === "string") return shortTypeName(t);
+  return "any";
+}
+function shortTypeName(type) {
+  const map = {
+    string: "str",
+    number: "num",
+    integer: "int",
+    boolean: "bool",
+    object: "obj",
+    array: "[any]"
+  };
+  return map[type] ?? type;
+}
+function formatToolParamsInline(schema) {
+  if (!schema || typeof schema !== "object") return "()";
+  const s = schema;
+  const properties = s.properties;
+  if (!properties || Object.keys(properties).length === 0) return "()";
+  const required = new Set(asArray(s.required));
+  const names = Object.keys(properties);
+  const ordered = [
+    ...names.filter((n) => required.has(n)),
+    ...names.filter((n) => !required.has(n))
+  ];
+  const shown = ordered.slice(0, 3);
+  const hidden = ordered.length - shown.length;
+  const parts = shown.map((name) => {
+    const typeStr = shortType(properties[name]);
+    return required.has(name) ? `${name}:${typeStr}` : `${name}?:${typeStr}`;
+  });
+  if (hidden > 0) parts.push("\u2026");
+  return `(${parts.join(", ")})`;
+}
+function toolHints(tool) {
+  const ann = tool.annotations;
+  if (!ann) return void 0;
+  const hints = [];
+  if (ann.readOnlyHint === true) hints.push("read-only");
+  if (ann.destructiveHint === true) hints.push("destructive");
+  if (ann.idempotentHint === true) hints.push("idempotent");
+  if (ann.openWorldHint === true) hints.push("open-world");
+  return hints.length > 0 ? hints.join(", ") : void 0;
+}
+function code(style, name) {
+  return `\`${style.bold(name)}\``;
+}
+function heading(style, text) {
+  return style.bold(text);
+}
+function descSuffix(style, description) {
+  if (typeof description !== "string" || !description.trim()) return "";
+  return style.dim(` \u2014 ${description.trim().split("\n")[0]}`);
+}
+function formatUri(style, uri) {
+  if (!uri) return uri;
+  if (isSafeLinkTarget(uri)) return style.link(uri);
+  return style.cyan(uri);
+}
+function colorLevel(style, level) {
+  switch (level) {
+    case "error":
+    case "critical":
+    case "alert":
+    case "emergency":
+      return style.red(level);
+    case "warning":
+      return style.yellow(level);
+    case "debug":
+    case "notice":
+      return style.dim(level);
+    default:
+      return style.cyan(level);
+  }
+}
+function formatToolsHuman(tools, style = PLAIN) {
+  const lines = [heading(style, `Tools (${tools.length}):`)];
+  for (const raw of tools) {
+    const tool = raw;
+    const name = String(tool.name ?? "?");
+    const params = formatToolParamsInline(tool.inputSchema);
+    const hints = toolHints(tool);
+    const hintSuffix = hints ? style.dim(` [${hints}]`) : "";
+    lines.push(
+      `* \`${style.bold(name)}${style.cyan(params)}\`${hintSuffix}${descSuffix(style, tool.description)}`
+    );
+  }
+  if (tools.length === 0) lines.push(style.dim("(none)"));
+  return lines.join("\n");
+}
+function formatResourcesHuman(resources, style = PLAIN) {
+  const lines = [heading(style, `Resources (${resources.length}):`)];
+  for (const raw of resources) {
+    const r = raw;
+    const name = typeof r.name === "string" ? r.name : String(r.uri ?? "?");
+    const uri = typeof r.uri === "string" ? r.uri : "";
+    const uriPart = uri ? ` (${formatUri(style, uri)})` : "";
+    lines.push(
+      `* ${code(style, name)}${uriPart}${descSuffix(style, r.description)}`
+    );
+  }
+  if (resources.length === 0) lines.push(style.dim("(none)"));
+  return lines.join("\n");
+}
+function formatResourceTemplatesHuman(templates, style = PLAIN) {
+  const lines = [heading(style, `Resource templates (${templates.length}):`)];
+  for (const raw of templates) {
+    const t = raw;
+    const name = String(t.name ?? "?");
+    const uri = typeof t.uriTemplate === "string" ? t.uriTemplate : "";
+    const uriPart = uri ? ` (${formatUri(style, uri)})` : "";
+    lines.push(
+      `* ${code(style, name)}${uriPart}${descSuffix(style, t.description)}`
+    );
+  }
+  if (templates.length === 0) lines.push(style.dim("(none)"));
+  return lines.join("\n");
+}
+function formatPromptsHuman(prompts, style = PLAIN) {
+  const lines = [heading(style, `Prompts (${prompts.length}):`)];
+  for (const raw of prompts) {
+    const p = raw;
+    const name = String(p.name ?? "?");
+    lines.push(`* ${code(style, name)}${descSuffix(style, p.description)}`);
+  }
+  if (prompts.length === 0) lines.push(style.dim("(none)"));
+  return lines.join("\n");
+}
+function formatContentBlock(block, style) {
+  const lines = [];
+  switch (block.type) {
+    case "text":
+      lines.push("````");
+      lines.push(String(block.text ?? ""));
+      lines.push("````");
+      break;
+    case "resource_link":
+      lines.push(heading(style, "Resource link"));
+      lines.push(`* URI: ${formatUri(style, String(block.uri ?? ""))}`);
+      if (block.name) lines.push(`* Name: ${String(block.name)}`);
+      if (block.description)
+        lines.push(`* Description: ${String(block.description)}`);
+      if (block.mimeType) lines.push(`* MIME type: ${String(block.mimeType)}`);
+      break;
+    case "image":
+      lines.push(
+        style.dim(
+          `[Image: ${String(block.mimeType ?? "unknown")}${typeof block.data === "string" ? `, ${block.data.length} chars base64` : ""}]`
+        )
+      );
+      break;
+    case "audio":
+      lines.push(
+        style.dim(
+          `[Audio: ${String(block.mimeType ?? "unknown")}${typeof block.data === "string" ? `, ${block.data.length} chars base64` : ""}]`
+        )
+      );
+      break;
+    case "resource": {
+      lines.push(heading(style, "Embedded resource"));
+      const res = block.resource;
+      if (res) {
+        lines.push(`* URI: ${formatUri(style, String(res.uri ?? ""))}`);
+        if (res.mimeType) lines.push(`* MIME type: ${String(res.mimeType)}`);
+        if (typeof res.text === "string") {
+          lines.push("````");
+          lines.push(res.text);
+          lines.push("````");
+        }
+      }
+      break;
+    }
+    default:
+      lines.push(JSON.stringify(block, null, 2));
+  }
+  return lines;
+}
+function findDuplicateTextBlocks(content, structuredContent) {
+  const dupes = /* @__PURE__ */ new Set();
+  const canonical = JSON.stringify(structuredContent);
+  for (let i = 0; i < content.length; i++) {
+    const block = content[i];
+    if (!block || block.type !== "text" || typeof block.text !== "string")
+      continue;
+    try {
+      const parsed = JSON.parse(block.text.trim());
+      if (JSON.stringify(parsed) === canonical) dupes.add(i);
+    } catch {
+    }
+  }
+  return dupes;
+}
+function formatCallToolResultHuman(result, style = PLAIN) {
+  const lines = [];
+  if (result.isError === true) {
+    lines.push(style.red(heading(style, "Tool error:")));
+  }
+  const sc = result.structuredContent;
+  const hasStructuredContent = !!sc && Object.keys(sc).length > 0;
+  const content = asArray(result.content);
+  const skipIndices = hasStructuredContent ? findDuplicateTextBlocks(content, sc) : /* @__PURE__ */ new Set();
+  const visible = content.filter((_, i) => !skipIndices.has(i));
+  if (visible.length > 0) {
+    lines.push(heading(style, "Content:"));
+    for (let i = 0; i < visible.length; i++) {
+      if (i > 0) lines.push("");
+      lines.push(...formatContentBlock(visible[i], style));
+    }
+  }
+  if (hasStructuredContent) {
+    if (lines.length > 0) lines.push("");
+    lines.push(heading(style, "Structured content:"));
+    lines.push(JSON.stringify(sc, null, 2));
+  }
+  const meta = result._meta;
+  if (meta && Object.keys(meta).length > 0) {
+    if (lines.length > 0) lines.push("");
+    lines.push(style.dim("Metadata:"));
+    lines.push(style.dim(JSON.stringify(meta, null, 2)));
+  }
+  if (lines.length === 0) return style.dim("(no content)");
+  return lines.join("\n");
+}
+function formatResourceReadHuman(result, style = PLAIN) {
+  const contents = asArray(result.contents);
+  if (contents.length === 0) return style.dim("(empty resource)");
+  const lines = [
+    heading(style, `Resource contents (${contents.length}):`)
+  ];
+  for (const c of contents) {
+    lines.push("");
+    lines.push(`URI: ${formatUri(style, String(c.uri ?? ""))}`);
+    if (c.mimeType) lines.push(style.dim(`MIME: ${String(c.mimeType)}`));
+    if (typeof c.text === "string") {
+      lines.push("````");
+      lines.push(c.text);
+      lines.push("````");
+    } else if (typeof c.blob === "string") {
+      lines.push(style.dim(`[Blob: ${c.blob.length} chars base64]`));
+    }
+  }
+  return lines.join("\n");
+}
+function formatPromptResultHuman(result, style = PLAIN) {
+  const description = typeof result.description === "string" ? result.description : void 0;
+  const messages = asArray(result.messages);
+  const lines = [];
+  if (description) {
+    lines.push(style.dim(description));
+    lines.push("");
+  }
+  lines.push(heading(style, `Messages (${messages.length}):`));
+  for (const msg of messages) {
+    const role = String(msg.role ?? "?");
+    lines.push("");
+    lines.push(style.cyan(`[${role}]`));
+    const content = msg.content;
+    if (typeof content === "string") {
+      lines.push("````");
+      lines.push(content);
+      lines.push("````");
+    } else if (content && typeof content === "object") {
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          lines.push(...formatContentBlock(block, style));
+        }
+      } else {
+        lines.push(...formatContentBlock(content, style));
+      }
+    }
+  }
+  if (messages.length === 0 && !description) return style.dim("(empty prompt)");
+  return lines.join("\n");
+}
+function formatCompletionsHuman(result, style = PLAIN) {
+  const values = asArray(result.values);
+  const lines = [heading(style, `Completions (${values.length}):`)];
+  for (const v of values) lines.push(`* ${v}`);
+  if (values.length === 0) lines.push(style.dim("(none)"));
+  if (result.hasMore === true) lines.push(style.dim("(more available)"));
+  return lines.join("\n");
+}
+function formatTasksHuman(tasks, style = PLAIN) {
+  const lines = [heading(style, `Tasks (${tasks.length}):`)];
+  for (const raw of tasks) {
+    const t = raw;
+    const id = String(t.taskId ?? t.id ?? "?");
+    const status = String(t.status ?? "?");
+    const msg = typeof t.statusMessage === "string" ? style.dim(` \u2014 ${t.statusMessage}`) : "";
+    lines.push(`* ${code(style, id)} ${status}${msg}`);
+  }
+  if (tasks.length === 0) lines.push(style.dim("(none)"));
+  return lines.join("\n");
+}
+function formatTaskHuman(task, style = PLAIN) {
+  const t = task ?? {};
+  const lines = [
+    `${heading(style, "Task:")} ${code(style, String(t.taskId ?? t.id ?? "?"))}`,
+    `Status: ${String(t.status ?? "?")}`
+  ];
+  if (typeof t.statusMessage === "string") {
+    lines.push(`Message: ${t.statusMessage}`);
+  }
+  if (t.createdAt) lines.push(style.dim(`Created: ${String(t.createdAt)}`));
+  if (t.lastUpdatedAt)
+    lines.push(style.dim(`Updated: ${String(t.lastUpdatedAt)}`));
+  return lines.join("\n");
+}
+function formatInitializeHuman(result, style = PLAIN) {
+  const info = result.serverInfo ?? {};
+  const lines = [
+    `${heading(style, "Server:")} ${style.bold(String(info.name ?? "(unknown)"))}${info.version ? style.dim(` v${String(info.version)}`) : ""}`
+  ];
+  if (result.protocolVersion) {
+    lines.push(`Protocol: ${String(result.protocolVersion)}`);
+  }
+  if (typeof result.instructions === "string" && result.instructions.trim()) {
+    lines.push("");
+    lines.push(heading(style, "Instructions:"));
+    lines.push(result.instructions.trim());
+  }
+  const caps = result.capabilities;
+  if (caps && typeof caps === "object") {
+    const keys = Object.keys(caps);
+    if (keys.length > 0) {
+      lines.push("");
+      lines.push(`${heading(style, "Capabilities:")} ${keys.join(", ")}`);
+    }
+  }
+  return lines.join("\n");
+}
+function formatRootsHuman(roots, style = PLAIN) {
+  const lines = [heading(style, `Roots (${roots.length}):`)];
+  for (const raw of roots) {
+    const r = raw;
+    const name = typeof r.name === "string" ? style.dim(` (${r.name})`) : "";
+    lines.push(`* ${formatUri(style, String(r.uri ?? "?"))}${name}`);
+  }
+  if (roots.length === 0) lines.push(style.dim("(none)"));
+  return lines.join("\n");
+}
+function formatAuthListHuman(list, style = PLAIN) {
+  const servers = Array.isArray(list.servers) ? list.servers : [];
+  const lines = [
+    heading(style, `Stored auth (${servers.length}):`),
+    style.dim(String(list.oauthStatePath ?? ""))
+  ];
+  for (const raw of servers) {
+    const s = raw;
+    const flags = [];
+    if (s.hasTokens === true) flags.push("tokens");
+    if (s.hasRefreshToken === true) flags.push("refresh");
+    const flagText = flags.length > 0 ? style.dim(` (${flags.join(", ")})`) : style.dim(" (no tokens)");
+    if (s.idp === true && typeof s.issuer === "string") {
+      lines.push(
+        `* ${code(style, s.issuer)}${flagText}${style.dim(
+          "  enterprise IdP login"
+        )}`
+      );
+      continue;
+    }
+    const knownAs = Array.isArray(s.knownAs) ? s.knownAs.map((n) => String(n)) : [];
+    const nameText = knownAs.length > 0 ? style.dim(`  known as: ${knownAs.join(", ")}`) : style.dim("  (no local name)");
+    const liveText = s.live === true ? ` ${style.green("\u25CF live")}` : "";
+    lines.push(
+      `* ${code(style, String(s.url))}${flagText}${nameText}${liveText}`
+    );
+  }
+  if (servers.length === 0) lines.push(style.dim("(none)"));
+  return lines.join("\n");
+}
+function formatEmaStatusHuman(status, style = PLAIN) {
+  const lines = [heading(style, "EMA (enterprise-managed auth):")];
+  lines.push(style.dim(String(status.clientConfigPath ?? "")));
+  if (status.configured !== true) {
+    lines.push(
+      "IdP: " + style.dim(
+        "(not configured \u2014 set enterpriseManagedAuth in client.json or the web Inspector's Client Settings)"
+      )
+    );
+    return lines.join("\n");
+  }
+  const client = status.clientId ? style.dim(` (client: ${status.clientId})`) : "";
+  lines.push(`IdP: ${code(style, String(status.issuer ?? "?"))}${client}`);
+  lines.push(`Enabled: ${status.enabled === true ? "yes" : style.dim("no")}`);
+  const loginState = String(status.loginState ?? "none");
+  const stateText = loginState === "logged_in" ? style.green(loginState) : style.dim(loginState);
+  lines.push(`IdP session: ${stateText}`);
+  return lines.join("\n");
+}
+function formatServersListHuman(servers, style = PLAIN, source) {
+  const lines = [heading(style, `Servers (${servers.length}):`)];
+  if (source) {
+    lines.push(`Source: ${style.dim(`${source.kind} ${source.path}`)}`);
+  }
+  for (const raw of servers) {
+    const s = raw;
+    const connectionName = typeof s.connection === "string" && s.connection.length > 0 ? s.connection : void 0;
+    const connectionMark = connectionName ? ` ${style.green(`@${connectionName}`)}${s.isMru === true ? style.green(" (MRU)") : ""}` : "";
+    lines.push(
+      `* ${code(style, String(s.name))} ${style.dim(`[${String(s.type)}]`)} ${style.dim(String(s.detail ?? ""))}${connectionMark}`
+    );
+  }
+  if (servers.length === 0) lines.push(style.dim("(none)"));
+  return lines.join("\n");
+}
+function formatServerShowHuman(server, style = PLAIN, source) {
+  const name = String(server.name ?? "?");
+  const type = String(server.type ?? "?");
+  const detail = String(server.detail ?? "");
+  const header = `${heading(style, "Server")} ${code(style, name)} ${style.dim(`[${type}]`)}`;
+  const body = {};
+  if (server.config && typeof server.config === "object") {
+    body.config = server.config;
+  }
+  if (server.settings && typeof server.settings === "object") {
+    body.settings = server.settings;
+  }
+  return [
+    header,
+    detail ? style.dim(detail) : style.dim("(no detail)"),
+    // Same provenance line as servers/list — which file the entry came from.
+    ...source ? [`Source: ${style.dim(`${source.kind} ${source.path}`)}`] : [],
+    JSON.stringify(body, null, 2)
+  ].join("\n");
+}
+function formatElicitationPendingHuman(elicitation, style = PLAIN) {
+  const id = elicitation.elicitationId;
+  const mode = elicitation.mode === "url" ? "url" : "form";
+  const message = elicitation.message;
+  const lines = [
+    `${heading(style, "Input required")} \u2014 ${code(style, elicitation.method)}${typeof elicitation.toolName === "string" ? ` (tool ${code(style, elicitation.toolName)})` : ""} on ${code(style, `@${elicitation.connection}`)} is waiting on the user:`,
+    `  ${message}`
+  ];
+  if (mode === "url") {
+    const url = typeof elicitation.url === "string" ? elicitation.url : "";
+    lines.push(
+      "",
+      "The user needs to open this link and complete it:",
+      // Only allowlisted schemes render as a clickable OSC 8 link; a server
+      // supplying file:/custom-handler URLs gets plain text (see sanitize.ts).
+      `  ${isSafeLinkTarget(url) ? style.link(url, url) : url}`,
+      "",
+      `When they're done, run: ${code(style, `elicitation/respond ${id} --done`)}`,
+      style.dim(`To give up instead: elicitation/respond ${id} --cancel`)
+    );
+  } else {
+    const fields = parseFormSchema(elicitation.requestedSchema);
+    if (fields && fields.length > 0) {
+      lines.push("", heading(style, `Fields (${fields.length}):`));
+      for (const field of fields) {
+        const kind = field.kind === "number" && field.integer ? "integer" : field.kind;
+        const flags = field.required ? `${kind}, required` : kind;
+        const choices = field.kind === "enum" || field.kind === "multiselect" ? ` [${field.choices.map((c) => c.value).join(", ")}]` : "";
+        lines.push(
+          `  ${style.bold(field.name)} (${flags})${choices}${descSuffix(style, field.description)}`
+        );
+      }
+    }
+    lines.push(
+      "",
+      `Answer with: ${code(style, `elicitation/respond ${id} field:=value ...`)}`,
+      style.dim(`Or: elicitation/respond ${id} --decline | --cancel`)
+    );
+  }
+  const expiresAt = Number(elicitation.expiresAt ?? 0);
+  if (Number.isFinite(expiresAt) && expiresAt > Date.now()) {
+    const minutes = Math.max(1, Math.round((expiresAt - Date.now()) / 6e4));
+    lines.push(
+      style.dim(
+        `Unanswered, this expires (auto-cancels) in about ${minutes} minute${minutes === 1 ? "" : "s"}.`
+      )
+    );
+  }
+  return lines.join("\n");
+}
+function formatConnectionsListHuman(connections, style = PLAIN) {
+  const lines = [heading(style, `Connections (${connections.length}):`)];
+  for (const raw of connections) {
+    const s = raw;
+    const mru = s.isMru === true ? style.green(" (MRU)") : "";
+    const era = s.protocolEra !== void 0 ? style.dim(` [${String(s.protocolEra)}]`) : "";
+    const pending = s.pendingAuth === true ? s.pendingAuthSignedIn === true ? style.yellow(" (signed in \u2014 completing on next use)") : style.yellow(" (sign-in pending)") : "";
+    lines.push(
+      `* ${code(style, `@${String(s.name)}`)}${mru}${style.dim(` \u2014 ${String(s.serverIdentity ?? "")}`)}${era}${pending}`
+    );
+  }
+  if (connections.length === 0) lines.push(style.dim("(none \u2014 connect first)"));
+  return lines.join("\n");
+}
+function formatConnectionInfoHuman(connection, style = PLAIN) {
+  const mru = connection.isMru === true ? style.green(" (MRU)") : "";
+  const lines = [
+    `${heading(style, "Connection")} ${code(style, `@${String(connection.name)}`)}${mru}`,
+    `Server: ${style.dim(String(connection.serverIdentity ?? ""))}`
+  ];
+  const era = connection.protocolEra;
+  const protocolVersion = connection.protocolVersion;
+  if (era !== void 0 || protocolVersion !== void 0) {
+    const versionSuffix = protocolVersion !== void 0 ? ` (${String(protocolVersion)})` : "";
+    lines.push(
+      `Era: ${style.dim(`${String(era ?? "unknown")}${versionSuffix}`)}`
+    );
+  }
+  const auth = connection.auth;
+  if (auth !== void 0) {
+    const method = auth.method === "ema" ? "EMA" : "OAuth";
+    const parts = [auth.authorized === true ? "authorized" : "not authorized"];
+    if (typeof auth.scope === "string" && auth.scope !== "") {
+      parts.push(`scope: ${auth.scope}`);
+    }
+    if (typeof auth.clientId === "string" && auth.clientId !== "") {
+      parts.push(`client: ${auth.clientId}`);
+    }
+    if (typeof auth.idpSession === "string") {
+      parts.push(`IdP session: ${auth.idpSession}`);
+    }
+    lines.push(`Auth: ${method} ${style.dim(`(${parts.join("; ")})`)}`);
+  }
+  if (connection.pendingAuth === true) {
+    lines.push(
+      connection.pendingAuthSignedIn === true ? `Sign-in: ${style.green("completed")} ${style.dim("(connection finishes on next use)")}` : `Sign-in: ${style.yellow("pending")} ${style.dim("(completes automatically after the user signs in)")}`
+    );
+  }
+  if (typeof connection.transport === "string") {
+    const detail = connection.transport === "dormant" ? "dormant (reconnects on next use)" : connection.transport;
+    lines.push(`Transport: ${style.dim(detail)}`);
+  }
+  const serverInfo = connection.serverInfo;
+  if (serverInfo?.name !== void 0) {
+    const version = serverInfo.version !== void 0 ? ` v${String(serverInfo.version)}` : "";
+    lines.push(
+      `Server info: ${style.dim(`${String(serverInfo.name)}${version}`)}`
+    );
+  }
+  const capabilities = connection.capabilities;
+  if (capabilities !== void 0) {
+    const keys = Object.keys(capabilities);
+    lines.push(
+      `Capabilities: ${style.dim(keys.length > 0 ? keys.join(", ") : "(none)")}`
+    );
+  }
+  const supportedVersions = connection.supportedVersions;
+  if (Array.isArray(supportedVersions) && supportedVersions.length > 0) {
+    lines.push(
+      `Supported versions: ${style.dim(supportedVersions.join(", "))}`
+    );
+  }
+  if (typeof connection.instructions === "string" && connection.instructions !== "") {
+    lines.push(`Instructions: ${style.dim(connection.instructions)}`);
+  }
+  return lines.join("\n");
+}
+function formatAppInfoListHuman(lines, style = PLAIN) {
+  const out = [heading(style, `App info (${lines.length} tools):`)];
+  for (const raw of lines) {
+    const info = raw;
+    const name = String(info.toolName ?? "?");
+    if (info.hasApp === true) {
+      const uri = String(info.resourceUri ?? "ui://?");
+      out.push(
+        `* ${code(style, name)} \u2014 ${style.green("app")} (${formatUri(style, uri)})`
+      );
+    } else {
+      const err = typeof info.resourceError === "string" ? style.dim(` \u2014 ${info.resourceError}`) : style.dim(" \u2014 no app");
+      out.push(`* ${code(style, name)}${err}`);
+    }
+  }
+  return out.join("\n");
+}
+function formatSkillsHuman(skills, style = PLAIN) {
+  const lines = [heading(style, `Skills (${skills.length}):`)];
+  for (const raw of skills) {
+    lines.push(formatSkillEntryLine(raw, style));
+  }
+  if (skills.length === 0) lines.push(style.dim("(none)"));
+  return lines.join("\n");
+}
+function formatSkillGetHuman(result, style = PLAIN) {
+  const skill = result.skill ?? {};
+  const lines = [heading(style, "Skill:"), formatSkillEntryLine(skill, style)];
+  if (result.ttlMs !== void 0)
+    lines.push(style.dim(`ttlMs: ${String(result.ttlMs)}`));
+  if (result.cacheScope !== void 0)
+    lines.push(style.dim(`cacheScope: ${String(result.cacheScope)}`));
+  return lines.join("\n");
+}
+function formatSkillEntryLine(skill, style) {
+  const frontmatter = skill.frontmatter ?? {};
+  const name = String(frontmatter.name ?? "?");
+  const uri = String(skill.uri ?? "");
+  const resources = skill.resources;
+  const manifest = resources === "dynamic" ? style.dim(" \u2014 dynamic resources") : Array.isArray(resources) ? style.dim(` \u2014 ${resources.length} file(s)`) : "";
+  return `* ${code(style, name)} (${formatUri(style, uri)})${descSuffix(style, frontmatter.description)}${manifest}`;
+}
+function formatSkillVerifyListHuman(lines, style = PLAIN) {
+  const out = [heading(style, `Skill verification (${lines.length}):`)];
+  for (const raw of lines) {
+    const report = raw;
+    const name = String(report.name ?? "?");
+    const uri = String(report.uri ?? "");
+    const outcome = report.outcome;
+    const conformance = asArray(report.conformance);
+    const frontmatter = asArray(report.frontmatter);
+    const files = asArray(report.files);
+    const errorCount = [...conformance, ...frontmatter].filter(
+      (issue) => issue.severity === "error"
+    ).length;
+    const mismatchCount = files.filter(
+      (file) => file.status === "mismatch" || file.status === "read-error"
+    ).length;
+    const verdict = outcome === "verified" ? style.green("verified") : outcome === "incomplete" ? style.dim("incomplete") : outcome === "unverifiable" ? style.dim("unverifiable") : style.red("failed");
+    const detail = outcome === "verified" ? "" : outcome === "incomplete" ? style.dim(
+      ` \u2014 ${String(report.incomplete ?? "read bounds cut the walk short")}`
+    ) : outcome === "unverifiable" ? (
+      // Nothing was checked, so "0 issue(s)" would misread as a pass
+      // narrowly missed; name the actual condition instead (#2405).
+      style.dim(
+        ` \u2014 advertised no digests (resources: "dynamic"), so integrity was not checked`
+      )
+    ) : style.dim(
+      ` \u2014 ${errorCount} issue(s), ${mismatchCount} file mismatch(es)`
+    );
+    out.push(
+      `* ${code(style, name)} (${formatUri(style, uri)}) \u2014 ${verdict}${detail}`
+    );
+  }
+  return out.join("\n");
+}
+function formatAppInfoHuman(info, style = PLAIN) {
+  const name = String(info.toolName ?? "?");
+  if (info.hasApp === true) {
+    const lines = [
+      `Tool ${code(style, name)} ${style.green("has an MCP App")}`,
+      `Resource: ${formatUri(style, String(info.resourceUri ?? ""))}`
+    ];
+    if (info.csp) lines.push(style.dim(`CSP: ${JSON.stringify(info.csp)}`));
+    return lines.join("\n");
+  }
+  const err = typeof info.resourceError === "string" ? info.resourceError : "No MCP App UI resource (_meta.ui.resourceUri).";
+  return `Tool ${code(style, name)} ${style.red("has no MCP App")}
+${style.dim(err)}`;
+}
+function formatStreamEventHuman(data, style = PLAIN) {
+  if (!data || typeof data !== "object") return String(data);
+  const ev = data;
+  if (ev.type === "subscribed") {
+    return `${heading(style, "Subscribed:")} ${formatUri(style, String(ev.uri ?? ""))}`;
+  }
+  if (ev.type === "resources/updated") {
+    return `${heading(style, "Resource updated:")} ${formatUri(style, String(ev.uri ?? ""))}`;
+  }
+  if (ev.direction === "notification" && ev.message) {
+    const msg = ev.message;
+    const params = msg.params ?? {};
+    const level = String(params.level ?? "info");
+    const logger = params.logger ? style.dim(` ${String(params.logger)}:`) : "";
+    const raw = params.data ?? params.message ?? params;
+    const text = typeof raw === "string" ? raw : JSON.stringify(raw);
+    return `[${colorLevel(style, level)}]${logger} ${text}`;
+  }
+  return JSON.stringify(ev, null, 2);
+}
+function formatRpcResultHuman(method, result, style = PLAIN) {
+  switch (method) {
+    case "tools/list":
+      return formatToolsHuman(asArray(result.tools), style);
+    case "tools/call":
+      return formatCallToolResultHuman(result, style);
+    case "resources/list":
+      return formatResourcesHuman(asArray(result.resources), style);
+    case "resources/read":
+      return formatResourceReadHuman(result, style);
+    case "resources/templates/list":
+      return formatResourceTemplatesHuman(
+        asArray(result.resourceTemplates),
+        style
+      );
+    case "resources/unsubscribe":
+      return `${heading(style, "Unsubscribed:")} ${formatUri(style, String(result.uri ?? ""))}`;
+    case "prompts/list":
+      return formatPromptsHuman(asArray(result.prompts), style);
+    case "prompts/get":
+      return formatPromptResultHuman(result, style);
+    case "prompts/complete":
+      return formatCompletionsHuman(result, style);
+    case "initialize":
+      return formatInitializeHuman(result, style);
+    case "logging/setLevel":
+      return style.green("Logging level updated.");
+    case "tasks/list":
+      return formatTasksHuman(asArray(result.tasks), style);
+    case "tasks/get":
+      return formatTaskHuman(result.task, style);
+    case "tasks/cancel":
+      return `${heading(style, "Cancelled task:")} ${String(result.taskId ?? "")}`;
+    case "tasks/result":
+      return formatCallToolResultHuman(result, style);
+    case "roots/list":
+    case "roots/set":
+      return formatRootsHuman(asArray(result.roots), style);
+    case "skills/list":
+      return formatSkillsHuman(asArray(result.skills), style);
+    case "skills/get":
+      return formatSkillGetHuman(result, style);
+    default:
+      return null;
+  }
+}
+
+// src/connection/format-connection.ts
+function formatConnectionJson(data) {
+  return JSON.stringify(data, null, 2).replace(
+    /[\u0080-\u009F]/g,
+    (ch) => `\\u${ch.charCodeAt(0).toString(16).padStart(4, "0")}`
+  ) + "\n";
+}
+async function writeConnectionOutput(opts, payload) {
+  const format = opts.format === "json" ? "json" : "text";
+  const style = opts.style ?? PLAIN;
+  const interactive = opts.interactive === true;
+  if (format === "json") {
+    await awaitableLog(formatConnectionJson(jsonPayload(payload)));
+    await writeNdjsonSummary(payload);
+    applyExitCodes(payload);
+    return;
+  }
+  await awaitableLog(
+    humanPayload(sanitizeDeep(payload), style, interactive) + "\n"
+  );
+  await writeNdjsonSummary(payload);
+  applyExitCodes(payload);
+}
+async function writeNdjsonSummary(payload) {
+  if (payload.kind === "ndjson" && payload.summary) {
+    await awaitableError(`${sanitizeText(payload.summary)}
+`);
+  }
+}
+function jsonPayload(payload) {
+  switch (payload.kind) {
+    case "rpc":
+      return payload.result;
+    case "ndjson":
+      return payload.lines;
+    case "stream-event":
+      return payload.data;
+    case "servers/list":
+      return {
+        servers: payload.servers,
+        ...payload.source && { source: payload.source }
+      };
+    case "servers/show":
+      return payload.source ? { ...payload.server, source: payload.source } : payload.server;
+    case "connections/list":
+      return { connections: payload.connections };
+    case "connection":
+      return payload.authUrl !== void 0 ? { ...payload.connection, authUrl: payload.authUrl } : payload.connection;
+    case "elicitation-pending":
+      return { elicitationPending: payload.elicitation };
+    case "disconnect":
+      return {
+        name: payload.name,
+        ...payload.clearedAuthUrl && {
+          clearedAuthUrl: payload.clearedAuthUrl
+        }
+      };
+    case "daemon/status":
+      return payload.status;
+    case "daemon/stop":
+      return payload.result;
+    case "auth/list":
+      return payload.list;
+    case "auth/clear":
+      return payload.result;
+    case "auth/ema-status":
+      return payload.status;
+    case "auth/ema-login":
+      return payload.result;
+    case "auth/ema-logout":
+      return payload.result;
+    case "generic":
+      return payload.data;
+  }
+}
+function signInHeadline() {
+  return "Sign-in required. Open this link in a browser to authenticate:";
+}
+function agentSignInBlock(url, subject, resumeCmd, finishPhrase) {
+  return [
+    `Sign-in required for ${subject}. This command exited 0, but ${subject} is not usable yet until the user signs in \u2014 this is not an error and not success.`,
+    "",
+    `Show the sign-in URL below to the user as literal plain text (make it the last thing in your reply), ask them to open it and sign in, and wait for them to confirm before continuing. Do not retry, poll, sleep, or run another command this turn \u2014 the user cannot see your reply until the turn ends.`,
+    "",
+    "Sign-in URL (show this to the user):",
+    "",
+    `  ${url}`,
+    "",
+    `Once the user confirms they have signed in, run \`mcpdo ${resumeCmd}\` to ${finishPhrase}.`
+  ].join("\n");
+}
+function humanPayload(payload, style, interactive) {
+  switch (payload.kind) {
+    case "rpc": {
+      if (asAppInfoProbe(payload.result)) {
+        return formatAppInfoHuman(payload.result, style);
+      }
+      const formatted = formatRpcResultHuman(
+        payload.method,
+        payload.result,
+        style
+      );
+      return formatted ?? JSON.stringify(payload.result, null, 2);
+    }
+    case "ndjson":
+      return payload.variant === "skill-verify" ? formatSkillVerifyListHuman(payload.lines, style) : formatAppInfoListHuman(payload.lines, style);
+    case "stream-event":
+      return formatStreamEventHuman(payload.data, style);
+    case "servers/list":
+      return formatServersListHuman(payload.servers, style, payload.source);
+    case "servers/show":
+      return formatServerShowHuman(payload.server, style, payload.source);
+    case "connections/list":
+      return formatConnectionsListHuman(payload.connections, style);
+    case "connection": {
+      const info = formatConnectionInfoHuman(
+        payload.connection,
+        style
+      );
+      if (payload.authUrl === void 0) return info;
+      const name = String(payload.connection.name ?? "");
+      if (!interactive) {
+        return [
+          info,
+          "",
+          agentSignInBlock(
+            payload.authUrl,
+            `@${name}`,
+            `connections/show @${name}`,
+            "finish the connection"
+          )
+        ].join("\n");
+      }
+      return [
+        info,
+        "",
+        signInHeadline(),
+        // The URL comes from server-controlled OAuth metadata: only
+        // allowlisted schemes become clickable OSC 8 links (same gate as
+        // every other server-supplied link — see sanitize.ts).
+        `  ${isSafeLinkTarget(payload.authUrl) ? style.link(payload.authUrl) : payload.authUrl}`,
+        style.dim(
+          `The connection completes automatically after sign-in \u2014 check with \`connections/show @${name}\`, or just run the next command.`
+        )
+      ].join("\n");
+    }
+    case "elicitation-pending":
+      return formatElicitationPendingHuman(payload.elicitation, style);
+    case "disconnect": {
+      const line = `${style.bold("Disconnected")} ${`\`${style.bold(`@${payload.name}`)}\``}`;
+      if (!payload.clearedAuthUrl) return line;
+      return [
+        line,
+        style.dim(
+          `Cleared stored auth for ${payload.clearedAuthUrl} \u2014 the next connect will re-trigger sign-in.`
+        )
+      ].join("\n");
+    }
+    case "daemon/status": {
+      const s = payload.status;
+      if (s.running === false) {
+        return String(s.message ?? "Daemon is not running.");
+      }
+      const connections = Array.isArray(s.connections) ? s.connections : [];
+      return [
+        `${style.bold("Daemon")} pid ${String(s.pid)}` + (s.stopping === true ? ` ${style.yellow("(shutting down)")}` : ""),
+        style.dim(`Socket: ${String(s.socketPath ?? "")}`),
+        formatConnectionsListHuman(connections, style)
+      ].join("\n");
+    }
+    case "daemon/stop":
+      if (payload.result.stopping === false) {
+        return String(payload.result.message ?? "Daemon was not running.");
+      }
+      return style.green("Daemon stopping.");
+    case "auth/list":
+      return formatAuthListHuman(payload.list, style);
+    case "auth/clear":
+      if (payload.result.all === true) {
+        return style.green(
+          `Cleared ${String(payload.result.cleared ?? 0)} stored auth entr${payload.result.cleared === 1 ? "y" : "ies"}.`
+        );
+      }
+      return `${style.green("Cleared")} \`${style.bold(String(payload.result.url ?? ""))}\`${payload.result.clearedByName ? style.dim(` (${String(payload.result.clearedByName)})`) : ""}`;
+    case "auth/ema-status":
+      return formatEmaStatusHuman(payload.status, style);
+    case "auth/ema-login":
+      if (payload.result.alreadyLoggedIn) {
+        return `${style.green("Already signed in")} to \`${style.bold(payload.result.issuer)}\` ${style.dim("(use auth/ema-login --relogin for a fresh connection)")}`;
+      }
+      if (payload.result.pendingLogin === true && payload.result.authUrl) {
+        if (!interactive) {
+          return agentSignInBlock(
+            payload.result.authUrl,
+            "enterprise IdP login",
+            "auth/ema-status",
+            "finish the login"
+          );
+        }
+        return [
+          signInHeadline(),
+          // Same OSC 8 allowlist gate as the connection authUrl above.
+          `  ${isSafeLinkTarget(payload.result.authUrl) ? style.link(payload.result.authUrl) : payload.result.authUrl}`,
+          style.dim(
+            "The sign-in completes in the background \u2014 check with `auth/ema-status` (loginState becomes logged_in)."
+          )
+        ].join("\n");
+      }
+      return `${style.green("Signed in")} to \`${style.bold(payload.result.issuer)}\``;
+    case "auth/ema-logout": {
+      const signedOut = `${style.green("Signed out")} of \`${style.bold(payload.result.issuer)}\` ${style.dim("(EMA server tokens cleared)")}`;
+      if (payload.result.endSessionUrl === void 0) return signedOut;
+      return [
+        signedOut,
+        "To end your IdP browser session, navigate to:",
+        // Same OSC 8 allowlist gate as the sign-in URLs above, so the logout
+        // link renders clickable in a terminal instead of as plain text.
+        `  ${isSafeLinkTarget(payload.result.endSessionUrl) ? style.link(payload.result.endSessionUrl) : payload.result.endSessionUrl}`
+      ].join("\n");
+    }
+    case "generic": {
+      if (payload.title) {
+        return `${style.bold(payload.title)}
+${JSON.stringify(payload.data, null, 2)}`;
+      }
+      return JSON.stringify(payload.data, null, 2);
+    }
+  }
+}
+function asAppInfoProbe(result) {
+  if (typeof result.hasApp !== "boolean" || typeof result.toolName !== "string" || result.content !== void 0 || result.tools !== void 0) {
+    return void 0;
+  }
+  return result;
+}
+function applyExitCodes(payload) {
+  if (payload.kind === "ndjson" && payload.exitCode) {
+    throw new CliExitCodeError(payload.exitCode, payload.summary ?? "", {
+      code: payload.exitCode === EXIT_CODES.SKILL_INCOMPLETE ? "skills_incomplete" : "skills_nonconformant"
+    });
+  }
+  if (payload.kind === "rpc") {
+    const info = asAppInfoProbe(payload.result);
+    if (info) {
+      if (!info.hasApp) {
+        throw new CliExitCodeError(
+          EXIT_CODES.NO_APP,
+          // toolName echoes server-influenced text into a terminal-bound
+          // error message; sanitize like the success path does.
+          `Tool '${sanitizeText(info.toolName)}' has no MCP App UI resource (_meta.ui.resourceUri).`
+        );
+      }
+      return;
+    }
+    if (payload.result.isError === true) {
+      throw new CliExitCodeError(
+        EXIT_CODES.TOOL_ERROR,
+        `Tool '${sanitizeText(payload.toolName ?? "tool")}' returned isError:true.`,
+        { code: "tool_is_error" }
+      );
+    }
+  }
+}
+
+// src/connection/form-prompt.ts
+function watchForClose(rl) {
+  return new Promise((_, reject) => {
+    rl.once(
+      "close",
+      () => reject(new Error("stdin closed before an answer was given"))
+    );
+  });
+}
+function ask(rl, closed, prompt) {
+  return Promise.race([rl.question(prompt), closed]);
+}
+function formatDefault(field) {
+  if (field.default === void 0) return void 0;
+  if (field.kind === "multiselect") {
+    return field.default.join(", ");
+  }
+  return String(field.default);
+}
+function describeField(field, style) {
+  const req = field.required ? style.yellow(" (required)") : "";
+  const desc = field.description ? ` \u2014 ${sanitizeText(field.description)}` : "";
+  const def = formatDefault(field);
+  const defHint = def !== void 0 ? style.dim(` [default: ${sanitizeText(def)}]`) : "";
+  return `${style.bold(sanitizeText(field.title))}${req}${desc}${defHint}`;
+}
+async function promptField(rl, closed, field, style) {
+  for (; ; ) {
+    if (field.kind === "boolean") {
+      const def2 = field.default;
+      const hint = def2 === void 0 ? "y/n" : def2 ? "Y/n" : "y/N";
+      const raw2 = (await ask(rl, closed, `${describeField(field, style)}
+  [${hint}]: `)).trim().toLowerCase();
+      if (raw2 === "" && def2 !== void 0) return def2;
+      if (raw2 === "y" || raw2 === "yes") return true;
+      if (raw2 === "n" || raw2 === "no") return false;
+      if (raw2 === "" && !field.required) return void 0;
+      process.stderr.write(style.red("  Please answer y or n.\n"));
+      continue;
+    }
+    if (field.kind === "enum" || field.kind === "multiselect") {
+      const lines = field.choices.map(
+        (choice, i) => `    ${i + 1}. ${sanitizeText(choice.label)}`
+      );
+      const multi = field.kind === "multiselect";
+      const prompt = multi ? "Enter one or more numbers separated by commas" : "Enter a number";
+      const raw2 = (await ask(
+        rl,
+        closed,
+        `${describeField(field, style)}
+${lines.join("\n")}
+  ${prompt}: `
+      )).trim();
+      if (raw2 === "") {
+        if (field.default !== void 0) return field.default;
+        if (!field.required) return void 0;
+        if (multi) {
+          const m = field;
+          if ((m.minItems ?? 0) === 0) return [];
+          process.stderr.write(style.red(`  Select at least ${m.minItems}.
+`));
+          continue;
+        }
+        process.stderr.write(style.red("  This field is required.\n"));
+        continue;
+      }
+      const tokens = raw2.split(",").map((s) => s.trim());
+      const indices = tokens.map(
+        (s) => /^\d+$/.test(s) ? Number.parseInt(s, 10) : Number.NaN
+      );
+      if (indices.some(
+        (n) => !Number.isInteger(n) || n < 1 || n > field.choices.length
+      )) {
+        process.stderr.write(
+          style.red(
+            `  Enter a number between 1 and ${field.choices.length}.
+`
+          )
+        );
+        continue;
+      }
+      if (!multi && indices.length !== 1) {
+        process.stderr.write(style.red("  Enter exactly one number.\n"));
+        continue;
+      }
+      const values = indices.map((n) => field.choices[n - 1].value);
+      if (multi) {
+        const m = field;
+        if (m.minItems !== void 0 && values.length < m.minItems) {
+          process.stderr.write(style.red(`  Select at least ${m.minItems}.
+`));
+          continue;
+        }
+        if (m.maxItems !== void 0 && values.length > m.maxItems) {
+          process.stderr.write(style.red(`  Select at most ${m.maxItems}.
+`));
+          continue;
+        }
+        return values;
+      }
+      return values[0];
+    }
+    if (field.kind === "number") {
+      const def2 = field.default;
+      const raw2 = (await ask(
+        rl,
+        closed,
+        `${describeField(field, style)}
+  ${def2 !== void 0 ? `[${def2}]` : ""}: `
+      )).trim();
+      if (raw2 === "") {
+        if (def2 !== void 0) return def2;
+        if (!field.required) return void 0;
+        process.stderr.write(style.red("  This field is required.\n"));
+        continue;
+      }
+      const n = Number(raw2);
+      if (
+        // isFinite (not isNaN): "Infinity" is not a valid JSON number and
+        // would serialize as null in the response frame.
+        !Number.isFinite(n) || field.integer && !Number.isInteger(n) || field.minimum !== void 0 && n < field.minimum || field.maximum !== void 0 && n > field.maximum
+      ) {
+        const range = field.minimum !== void 0 || field.maximum !== void 0 ? ` (${field.minimum ?? "-\u221E"}..${field.maximum ?? "\u221E"})` : "";
+        process.stderr.write(
+          style.red(
+            `  Enter a valid ${field.integer ? "integer" : "number"}${range}.
+`
+          )
+        );
+        continue;
+      }
+      return n;
+    }
+    const def = field.default;
+    const raw = await ask(
+      rl,
+      closed,
+      `${describeField(field, style)}
+  ${def !== void 0 ? `[${sanitizeText(def)}]` : ""}: `
+    );
+    if (raw === "" && def !== void 0) return def;
+    if (raw === "" && !field.required) return void 0;
+    const value = raw;
+    const length = codePointLength(value);
+    if (field.minLength !== void 0 && length < field.minLength) {
+      process.stderr.write(
+        style.red(`  Must be at least ${field.minLength} characters.
+`)
+      );
+      continue;
+    }
+    if (field.maxLength !== void 0 && length > field.maxLength) {
+      process.stderr.write(
+        style.red(`  Must be at most ${field.maxLength} characters.
+`)
+      );
+      continue;
+    }
+    return value;
+  }
+}
+async function promptForm(rl, message, fields, style) {
+  process.stderr.write(`
+${style.bold("Input requested: ")}${message}
+
+`);
+  const closed = watchForClose(rl);
+  const values = /* @__PURE__ */ new Map();
+  for (const field of fields) {
+    values.set(field.name, await promptField(rl, closed, field, style));
+  }
+  for (; ; ) {
+    process.stderr.write(`
+${style.bold("Review your answers:")}
+`);
+    for (const field2 of fields) {
+      const v = values.get(field2.name);
+      const label = field2.title === field2.name ? field2.title : `${field2.title} (${field2.name})`;
+      process.stderr.write(
+        `  ${sanitizeText(label)}: ${v === void 0 ? style.dim("(none)") : sanitizeText(String(v))}
+`
+      );
+    }
+    const answer = (await ask(
+      rl,
+      closed,
+      "\nPress Enter to submit, type a field name to edit it, or 'c' to cancel: "
+    )).trim();
+    if (answer === "") {
+      const content = /* @__PURE__ */ Object.create(null);
+      for (const field2 of fields) {
+        const v = values.get(field2.name);
+        if (v !== void 0) content[field2.name] = v;
+      }
+      return { action: "accept", content };
+    }
+    if (answer.toLowerCase() === "c") {
+      return { action: "cancel" };
+    }
+    const field = fields.find((f) => f.name === answer) ?? fields.find((f) => f.title === answer);
+    if (!field) {
+      process.stderr.write(
+        style.red(`  Unknown field "${answer}". Try again.
+`)
+      );
+      continue;
+    }
+    values.set(field.name, await promptField(rl, closed, field, style));
+  }
+}
+
+// src/connection/prompt-reader.ts
+import * as readline from "readline";
+function exhaustedError() {
+  return new Error("stdin closed before an answer was given");
+}
+var PromptReader = class {
+  rl;
+  input;
+  output;
+  queued = [];
+  waiter;
+  closeListeners = [];
+  eof = false;
+  exhaustedNotified = false;
+  constructor(input = process.stdin, output = process.stderr) {
+    this.input = input;
+    this.output = output;
+    this.rl = readline.createInterface({ input, output });
+    this.rl.on("line", (line) => {
+      const waiter = this.waiter;
+      if (waiter) {
+        this.waiter = void 0;
+        this.park();
+        waiter.resolve(line);
+      } else {
+        this.queued.push(line);
+      }
+    });
+    this.rl.once("close", () => {
+      this.eof = true;
+      const waiter = this.waiter;
+      if (waiter) {
+        this.waiter = void 0;
+        this.notifyExhausted();
+        waiter.reject(exhaustedError());
+      }
+    });
+    this.park();
+  }
+  /**
+   * Write `prompt` and resolve with the next input line — a queued one
+   * first, else the next to arrive. Rejects once input is exhausted (EOF
+   * with nothing queued).
+   */
+  question(prompt) {
+    this.output.write(prompt);
+    const queued = this.queued.shift();
+    if (queued !== void 0) return Promise.resolve(queued);
+    if (this.eof) {
+      this.notifyExhausted();
+      return Promise.reject(exhaustedError());
+    }
+    this.engage();
+    return new Promise((resolve3, reject) => {
+      this.waiter = { resolve: resolve3, reject };
+    });
+  }
+  /**
+   * `close` here means input is exhausted: EOF *and* no queued line left to
+   * answer with. A raw stream close while answers are still queued must not
+   * cancel a form those answers can complete.
+   */
+  once(event, listener) {
+    if (event === "close") {
+      if (this.exhaustedNotified) listener();
+      else this.closeListeners.push(listener);
+    }
+    return this;
+  }
+  /** Tear down the underlying interface (tests / process cleanup). Restores
+   * cooked mode first so a disposed/exiting reader never leaves the terminal
+   * raw (where Ctrl-C would stay dead in the user's next shell). */
+  dispose() {
+    if (this.input.isTTY) this.input.setRawMode?.(false);
+    this.rl.close();
+  }
+  notifyExhausted() {
+    if (this.exhaustedNotified) return;
+    this.exhaustedNotified = true;
+    const listeners = this.closeListeners;
+    this.closeListeners = [];
+    for (const listener of listeners) listener();
+  }
+  /** Actively waiting for a line: let the stream flow and hold the loop. On a
+   * TTY, re-enter raw mode so readline can do line editing while a question is
+   * pending (the counterpart to {@link park} restoring cooked mode). */
+  engage() {
+    this.input.ref?.();
+    if (this.input.isTTY) this.input.setRawMode?.(true);
+    this.rl.resume();
+  }
+  /** Idle between questions: stop reading and release the event loop. On a TTY,
+   * restore cooked mode so the terminal is not left raw between prompts — raw
+   * mode disables the kernel's Ctrl-C (SIGINT), and a persistent reader that
+   * stayed raw while parked left Ctrl-C dead in the gap between rounds. */
+  park() {
+    this.rl.pause();
+    if (this.input.isTTY) this.input.setRawMode?.(false);
+    this.input.unref?.();
+  }
+};
+var shared;
+function getSharedPromptReader() {
+  shared ??= new PromptReader();
+  return shared;
+}
+
+// src/connection/elicitation-prompt.ts
+function cancelResponse(frame) {
+  return {
+    id: frame.id,
+    kind: "elicitation-response",
+    elicitationId: frame.elicitationId,
+    action: "cancel"
+  };
+}
+function declineResponse(frame) {
+  return {
+    id: frame.id,
+    kind: "elicitation-response",
+    elicitationId: frame.elicitationId,
+    action: "decline"
+  };
+}
+async function promptElicitation(frame, opts) {
+  const { style } = opts;
+  const message = sanitizeText(frame.message);
+  const url = frame.url === void 0 ? void 0 : sanitizeText(frame.url);
+  if (frame.mode === "form") {
+    const fields = parseFormSchema(frame.requestedSchema);
+    if (!fields) {
+      process.stderr.write(
+        style.yellow(
+          "This server's form request uses a schema mcpdo doesn't support \u2014 declining.\n"
+        ) + `  ${message}
+`
+      );
+      return declineResponse(frame);
+    }
+    if (!opts.interactive) {
+      process.stderr.write(
+        style.yellow(
+          "This server is asking for form input, which isn't supported with --format json \u2014 declining.\n"
+        ) + `  ${message}
+`
+      );
+      return declineResponse(frame);
+    }
+    const rl2 = getSharedPromptReader();
+    try {
+      const outcome = await promptForm(rl2, message, fields, style);
+      if (outcome.action === "accept") {
+        return {
+          id: frame.id,
+          kind: "elicitation-response",
+          elicitationId: frame.elicitationId,
+          action: "accept",
+          content: outcome.content
+        };
+      }
+      if (outcome.action === "decline") return declineResponse(frame);
+      return cancelResponse(frame);
+    } catch {
+      return cancelResponse(frame);
+    }
+  }
+  if (!opts.interactive) {
+    process.stderr.write(
+      style.yellow(
+        "This server is asking for input via a URL (elicitation), which isn't supported with --format json \u2014 cancelling.\n"
+      ) + `  ${message}
+` + (url ? `  ${url}
+` : "")
+    );
+    return cancelResponse(frame);
+  }
+  process.stderr.write(
+    "\n" + style.bold("Action required: ") + message + "\n  " + // Only allowlisted schemes render as a clickable OSC 8 link; a server
+    // supplying file:/custom-handler URLs gets plain text (see sanitize.ts).
+    (url !== void 0 && isSafeLinkTarget(url) ? style.link(url, url) : url ?? "") + "\n\n"
+  );
+  const rl = getSharedPromptReader();
+  try {
+    const answer = await Promise.race([
+      rl.question(
+        "Open the URL above, complete it, then press Enter to continue (or type 'c' to cancel): "
+      ),
+      watchForClose(rl)
+    ]);
+    if (answer.trim().toLowerCase() === "c") {
+      return cancelResponse(frame);
+    }
+    return {
+      id: frame.id,
+      kind: "elicitation-response",
+      elicitationId: frame.elicitationId,
+      action: "accept"
+    };
+  } catch {
+    return cancelResponse(frame);
+  }
+}
+
+// src/connection/dispatch.ts
+var STREAM_METHODS = /* @__PURE__ */ new Set(["logging/tail", "resources/subscribe"]);
+var NDJSON_VARIANTS = /* @__PURE__ */ new Set(["skills/list", "skills/get"]);
+async function dispatchConnectionRpc(method, methodArgs, opts) {
+  const format = opts.format ?? "text";
+  const style = styleFromOpts({ plain: opts.plain, format });
+  const params = {
+    ...methodArgs,
+    // `format` stays frontend-only: forwarding it would make the daemon's
+    // runMethod treat `format: "json"` tool calls as app-info requests and
+    // issue a hidden extra resources/read whose result we discard. The
+    // daemon also strips it defensively (see stripConnectionFields).
+    method,
+    name: stripAt(opts.connection),
+    requireExplicit: opts.requireExplicit
+  };
+  const { socketPath } = await ensureDaemon();
+  if (STREAM_METHODS.has(method)) {
+    const ac2 = new AbortController();
+    const onSignal2 = () => ac2.abort();
+    process.on("SIGINT", onSignal2);
+    process.on("SIGTERM", onSignal2);
+    let writeChain = Promise.resolve();
+    try {
+      await streamDaemon(params, {
+        socketPath,
+        // Core enforces the configured MCP request timeout daemon-side; a
+        // fixed local deadline would falsely fail stream setups (e.g. a
+        // subscribe against a slow server) that are still valid.
+        timeoutMs: 0,
+        signal: ac2.signal,
+        onData: (data) => {
+          writeChain = writeChain.then(
+            () => writeConnectionOutput(
+              { format, style },
+              {
+                kind: "stream-event",
+                data
+              }
+            )
+          ).catch(() => {
+          });
+          return writeChain;
+        }
+      });
+    } finally {
+      process.off("SIGINT", onSignal2);
+      process.off("SIGTERM", onSignal2);
+      await writeChain.catch(() => {
+      });
+    }
+    return;
+  }
+  const ac = new AbortController();
+  const onSignal = () => ac.abort();
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  const interactive = format === "text" && (process.stdin.isTTY === true || process.stderr.isTTY === true);
+  params.interactive = interactive;
+  let outcome;
+  try {
+    outcome = await callDaemon("rpc", params, {
+      socketPath,
+      // Core enforces the configured MCP request timeout daemon-side; a
+      // fixed local deadline would falsely fail long-running tool calls.
+      timeoutMs: 0,
+      signal: ac.signal,
+      onElicitation: (frame) => promptElicitation(frame, {
+        style,
+        // Prompting only needs a readable stdin and a text-based reply
+        // channel; parked (non-interactive) callers never receive frames,
+        // so this only ever runs interactively.
+        interactive
+      })
+    });
+  } finally {
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+  }
+  await writeRpcOutcome(
+    { format, style },
+    method,
+    methodArgs.toolName,
+    outcome
+  );
+}
+async function writeRpcOutcome(out, method, toolName, outcome) {
+  const { format, style } = out;
+  if (outcome.kind === "elicitation-pending") {
+    await writeConnectionOutput(
+      { format, style },
+      { kind: "elicitation-pending", elicitation: outcome.elicitation }
+    );
+    return;
+  }
+  if (outcome.kind === "ndjson") {
+    await writeConnectionOutput(
+      { format, style },
+      {
+        kind: "ndjson",
+        lines: outcome.lines,
+        variant: NDJSON_VARIANTS.has(method) ? "skill-verify" : "app-info",
+        summary: outcome.summary,
+        exitCode: outcome.exitCode
+      }
+    );
+    return;
+  }
+  await writeConnectionOutput(
+    { format, style },
+    {
+      kind: "rpc",
+      method,
+      result: outcome.result,
+      appInfo: outcome.appInfo,
+      toolName
+    }
+  );
+}
+function stripAt(name) {
+  if (!name) return void 0;
+  return name.startsWith("@") ? name.slice(1) : name;
+}
+function requireExplicitConnection() {
+  if (process.env.MCP_ALLOW_DEFAULT_CONNECTION === "1") return false;
+  return process.stdin.isTTY !== true;
+}
+var VALUE_TAKING_GLOBALS = /* @__PURE__ */ new Set([
+  "--format",
+  "--connection",
+  "--catalog",
+  "--config"
+]);
+var AT_CONNECTION_RE = /^@[A-Za-z0-9_.-]+$/;
+function hoistAtConnection(argv) {
+  const start = 2;
+  for (let i = start; i < argv.length; i++) {
+    const token = argv[i];
+    if (token === "--") break;
+    if (AT_CONNECTION_RE.test(token)) {
+      return {
+        argv: [...argv.slice(0, i), ...argv.slice(i + 1)],
+        connectionFromAt: token.slice(1)
+      };
+    }
+    if (token.startsWith("-")) {
+      if (!token.includes("=") && VALUE_TAKING_GLOBALS.has(token)) i++;
+      continue;
+    }
+    break;
+  }
+  return { argv };
+}
+
+// src/connection/private-env.ts
+import { randomBytes } from "crypto";
+function createPrivateBinding() {
+  const dir = createPrivateDaemonDir();
+  const token = randomBytes(32).toString("base64url");
+  return { dir, token };
+}
+function formatPrivateEnvExports(binding) {
+  return [
+    `export ${DAEMON_DIR_ENV}=${shellSingleQuote(binding.dir)}`,
+    `export ${DAEMON_TOKEN_ENV}=${shellSingleQuote(binding.token)}`,
+    ""
+  ].join("\n");
+}
+function shellSingleQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+
+// src/connection/stored-auth.ts
+function normalizeServerUrl(serverUrl) {
+  try {
+    return new URL(serverUrl).href;
+  } catch {
+    return serverUrl;
+  }
+}
+function tokenFlagsFromState(state) {
+  if (state == null || typeof state !== "object") {
+    return { hasTokens: false, hasRefreshToken: false };
+  }
+  const s = state;
+  let hasTokens = Boolean(s.tokens?.access_token);
+  let hasRefreshToken = hasTokens && Boolean(s.tokens?.refresh_token);
+  for (const slot of Object.values(s.byIssuer ?? {})) {
+    if (slot?.tokens?.access_token) {
+      hasTokens = true;
+      if (slot.tokens.refresh_token) hasRefreshToken = true;
+    }
+  }
+  return { hasTokens, hasRefreshToken };
+}
+async function readServersMap(statePath) {
+  const snapshot = await readOAuthStore(statePath);
+  if (snapshot?.servers && typeof snapshot.servers === "object") {
+    return snapshot.servers;
+  }
+  return {};
+}
+async function listStoredAuth() {
+  const oauthStatePath = getStateFilePath();
+  const servers = await readServersMap(oauthStatePath);
+  const entries = Object.keys(servers).sort((a, b) => a.localeCompare(b)).map((url) => ({
+    url,
+    ...tokenFlagsFromState(servers[url])
+  }));
+  return { oauthStatePath, servers: entries };
+}
+async function resolveStoredAuthKey(key) {
+  const trimmed = key.trim();
+  if (!trimmed) {
+    throw new CliExitCodeError(
+      EXIT_CODES.USAGE,
+      "auth/clear requires a server URL key (from auth/list) or --all",
+      { code: "usage" }
+    );
+  }
+  const { servers } = await listStoredAuth();
+  const urls = servers.map((s) => s.url);
+  if (urls.includes(trimmed)) return trimmed;
+  const normalized = normalizeServerUrl(trimmed);
+  if (urls.includes(normalized)) return normalized;
+  if (normalized !== trimmed || /^https?:\/\//i.test(trimmed)) {
+    return normalized;
+  }
+  throw new CliExitCodeError(
+    EXIT_CODES.USAGE,
+    `No stored auth entry for '${trimmed}'. Use auth/list to see keys.`,
+    { code: "usage" }
+  );
+}
+async function clearStoredAuth(key) {
+  const url = await resolveStoredAuthKey(key);
+  const storage = new NodeOAuthStorage();
+  await storage.clear(url);
+  resetNodeOAuthStorageCache();
+  return { url };
+}
+async function clearAllStoredAuth() {
+  const before = await listStoredAuth();
+  await clearAllOAuthClientState();
+  resetNodeOAuthStorageCache();
+  return { cleared: before.servers.length };
+}
+async function clearStoredAuthForRelogin(serverUrl) {
+  if (!serverUrl?.trim()) return;
+  const url = normalizeServerUrl(serverUrl.trim());
+  const storage = new NodeOAuthStorage();
+  await storage.clear(url);
+  resetNodeOAuthStorageCache();
+}
+
+// src/connection/auth-names.ts
+function urlIfHttp(value) {
+  if (value && /^https?:\/\//i.test(value)) return normalizeServerUrl(value);
+  return void 0;
+}
+function buildAuthNameIndex(entries, connections) {
+  const urlToNames = /* @__PURE__ */ new Map();
+  const nameToUrls = /* @__PURE__ */ new Map();
+  const knownNames = /* @__PURE__ */ new Set();
+  const add = (name, url, source, isLive) => {
+    knownNames.add(name);
+    if (!url) return;
+    let urls = nameToUrls.get(name);
+    if (!urls) {
+      urls = /* @__PURE__ */ new Set();
+      nameToUrls.set(name, urls);
+    }
+    urls.add(url);
+    let refs = urlToNames.get(url);
+    if (!refs) {
+      refs = [];
+      urlToNames.set(url, refs);
+    }
+    const existing = refs.find((r) => r.name === name);
+    if (existing) {
+      if (isLive) existing.isLive = true;
+      return;
+    }
+    refs.push({ name, source, isLive });
+  };
+  for (const entry of entries) {
+    add(entry.name, urlIfHttp(entry.detail), "catalog", false);
+  }
+  for (const conn of connections) {
+    add(conn.name, urlIfHttp(conn.serverIdentity), "connection", true);
+  }
+  return index(urlToNames, nameToUrls, knownNames);
+}
+function index(urlToNames, nameToUrls, knownNames) {
+  for (const refs of urlToNames.values()) {
+    refs.sort(
+      (a, b) => Number(b.isLive) - Number(a.isLive) || a.name.localeCompare(b.name)
+    );
+  }
+  return { urlToNames, nameToUrls, knownNames };
+}
+function resolveFriendlyName(name, index2) {
+  const urls = index2.nameToUrls.get(name);
+  if (urls && urls.size === 1) {
+    return { kind: "url", url: [...urls][0] };
+  }
+  if (urls && urls.size > 1) {
+    return { kind: "ambiguous", name, urls: [...urls].sort() };
+  }
+  if (index2.knownNames.has(name)) {
+    return { kind: "no-url", name };
+  }
+  return { kind: "unknown", name };
+}
+
+// src/connection/mcp.ts
+import { createInterface as createInterface2 } from "readline/promises";
+function isDaemonUnreachable(error) {
+  return error instanceof CliExitCodeError && error.envelope?.code === "daemon_unreachable";
+}
+async function resolveMruEntryName() {
+  if (requireExplicitConnection()) {
+    throw new CliExitCodeError(
+      EXIT_CODES.USAGE,
+      "servers/show requires an entry name in non-interactive mode. Pass one (see mcpdo servers/list).",
+      { code: "server_name_required" }
+    );
+  }
+  let connections = [];
+  try {
+    const result = await callDaemon(
+      "connections/list",
+      {}
+    );
+    connections = result.connections;
+  } catch (error) {
+    if (!isDaemonUnreachable(error)) throw error;
+  }
+  const mru = connections.find((c) => c.isMru);
+  if (!mru) {
+    throw new CliExitCodeError(
+      EXIT_CODES.USAGE,
+      "No entry name given and there is no most-recently-used connection to infer one from. Pass a catalog entry name (see mcpdo servers/list).",
+      { code: "server_name_required" }
+    );
+  }
+  return mru.name;
+}
+function describeServerShowNotFound(error, entryName, inferredFromMru, source) {
+  if (!(error instanceof Error) || !error.message.startsWith(`Server '${entryName}' not found`)) {
+    return error;
+  }
+  const where = source ? `${source.kind} ${source.path}` : "the resolved server list";
+  if (inferredFromMru) {
+    return new CliExitCodeError(
+      EXIT_CODES.USAGE,
+      `The most-recently-used connection '${entryName}' has no entry in ${where}. Connections and catalog entries are separate \u2014 it may have been connected ad-hoc or from a different catalog. Pass an entry name (see mcpdo servers/list).`,
+      { code: "server_not_found" }
+    );
+  }
+  return new CliExitCodeError(EXIT_CODES.USAGE, `${error.message} (${where})`, {
+    code: "server_not_found"
+  });
+}
+function isCommanderDisplayOnly(error) {
+  if (error == null || typeof error !== "object") return false;
+  const code2 = error.code;
+  return code2 === "commander.help" || code2 === "commander.helpDisplayed" || code2 === "commander.version";
+}
+function outOpts(opts) {
+  return {
+    format: opts.format,
+    style: styleFromOpts({ plain: opts.plain === true, format: opts.format }),
+    // Matches dispatch.ts: a human is "present" only when output is text and a
+    // TTY is attached. `--format json` or no TTY means an agent is reading, so
+    // sign-in prompts switch to relay framing (see ConnectionWriteOpts).
+    interactive: opts.format !== "json" && (process.stdin.isTTY === true || process.stderr.isTTY === true)
+  };
+}
+var validLogLevels = Object.values(LoggingLevelSchema.enum);
+function expandConnAlias(argv) {
+  const sep = argv.indexOf("--");
+  const end = sep === -1 ? argv.length : sep;
+  return argv.map(
+    (arg, i) => i >= end ? arg : arg === "--conn" ? "--connection" : arg.startsWith("--conn=") ? `--connection=${arg.slice("--conn=".length)}` : arg
+  );
+}
+async function surfaceSecretStorageAtConnect() {
+  const info = await getSecretStorageInfo();
+  warnAboutSecretStorage(info, { force: true });
+  if (info.kind === "memory") {
+    process.stderr.write(
+      `[mcpdo] MCP_INSPECTOR_SECRET_STORE=memory keeps secrets only in this process's memory. mcpdo runs the daemon and the OAuth sign-in helper as separate processes, so a token saved by one is invisible to the others and sign-in cannot complete (you will see a credential-refresh failure after signing in). Use "file" or "keyring" to persist across mcpdo's processes.
+`
+    );
+  }
+}
+function pinStdioConfigToCaller(config) {
+  if (config.type === "sse" || config.type === "streamable-http") return config;
+  const resolved = resolveCommandPath(config.command);
+  return {
+    ...config,
+    cwd: path4.resolve(config.cwd ?? process.cwd()),
+    ...resolved !== config.command ? { command: resolved } : {},
+    // The SDK transport spawns with {...getDefaultEnvironment(), ...env}
+    // evaluated in the DAEMON process; snapshotting the same default set
+    // here makes those fallbacks the caller's.
+    env: { ...getDefaultEnvironment(), ...config.env }
+  };
+}
+async function runMcp(argv) {
+  const raw = argv ?? process.argv;
+  const { argv: rewritten, connectionFromAt } = hoistAtConnection(
+    expandConnAlias(raw)
+  );
+  const program = new Command();
+  program.configureOutput({ outputError: () => {
+  } });
+  program.exitOverride((err) => {
+    if (isCommanderDisplayOnly(err)) throw err;
+    if (err.exitCode !== 0) {
+      throw new CliExitCodeError(
+        EXIT_CODES.USAGE,
+        err.message.replace(/^error: /, ""),
+        { code: "usage" }
+      );
+    }
+  });
+  program.name("mcpdo").description(
+    "MCP Inspector connection CLI \u2014 connect once, run many commands against a named connection.\n\nAgent skill for mcpdo: install with `npx skills add modelcontextprotocol/inspector --skill mcpdo`, or see `agent-help` below."
+  ).helpOption("-h, --help", "Display help for command").helpCommand("help [command]", "Display help for command").version(readInspectorVersion(import.meta.url), "--version").option(
+    "--format <format>",
+    "Output format: text (default; human-readable) or json (pretty-printed)",
+    (v) => {
+      if (v !== "text" && v !== "json") {
+        throw new Error(`--format must be 'text' or 'json'.`);
+      }
+      return v;
+    }
+  ).option(
+    "--plain",
+    "Disable ANSI styling (color, bold/dim, hyperlinks) in human text output"
+  ).option(
+    "--connection <name>",
+    "Connection name (without required @). Overrides MRU / positional @name. `--conn` is a supported shorthand."
+  ).option(
+    "--catalog <path>",
+    "Writable catalog file (default: ~/.mcp-inspector/mcp.json or MCP_CATALOG_PATH)"
+  ).option(
+    "--config <path>",
+    "Read-only connection config file (never written or seeded)"
+  ).option(
+    "--stored-auth-only",
+    "Never start interactive OAuth; use the shared store if present, otherwise fail."
+  );
+  if (connectionFromAt) {
+    program.setOptionValue("connection", connectionFromAt);
+  }
+  program.command("servers/list").description(
+    "List catalog/config server entries (marks live connections when the daemon is running; no MCP connection)"
+  ).action(async () => {
+    const opts = program.opts();
+    const envCatalog = process.env.MCP_CATALOG_PATH;
+    const serverOptions = {
+      catalogPath: opts.catalog?.trim() || envCatalog,
+      configPath: opts.config?.trim() || void 0
+    };
+    const entries = await listServerEntries(serverOptions);
+    const source = resolveServerListSource(serverOptions);
+    let connections = [];
+    try {
+      const result = await callDaemon(
+        "connections/list",
+        {}
+      );
+      connections = result.connections;
+    } catch (error) {
+      if (!isDaemonUnreachable(error)) throw error;
+    }
+    await writeConnectionOutput(outOpts(opts), {
+      kind: "servers/list",
+      servers: annotateServerEntriesWithConnections(entries, connections),
+      ...source && { source }
+    });
+  });
+  program.command("servers/show").description(
+    "Show one catalog/config entry in detail (no MCP connection; secrets redacted)"
+  ).argument(
+    "[name]",
+    "Catalog entry name (defaults to the MRU connection's entry on an interactive TTY)"
+  ).action(async (name) => {
+    const opts = program.opts();
+    const envCatalog = process.env.MCP_CATALOG_PATH;
+    const serverOptions = {
+      catalogPath: opts.catalog?.trim() || envCatalog,
+      configPath: opts.config?.trim() || void 0
+    };
+    const explicitName = stripAt(name?.trim() || void 0);
+    const entryName = explicitName ?? await resolveMruEntryName();
+    const source = resolveServerListSource(serverOptions);
+    let entry;
+    try {
+      entry = await showServerEntry(entryName, serverOptions);
+    } catch (error) {
+      throw describeServerShowNotFound(
+        error,
+        entryName,
+        explicitName === void 0,
+        source
+      );
+    }
+    await writeConnectionOutput(outOpts(opts), {
+      kind: "servers/show",
+      server: entry,
+      ...source && { source }
+    });
+  });
+  registerConnect(program);
+  registerConnectionAdmin(program);
+  registerAuthCommands(program);
+  registerRpcCommands(program);
+  registerElicitationCommands(program);
+  registerDaemonCommands(program);
+  registerPrivateCommand(program);
+  registerAgentHelpCommand(program);
+  try {
+    await program.parseAsync(rewritten);
+  } catch (error) {
+    if (isCommanderDisplayOnly(error)) return;
+    throw error;
+  }
+}
+function registerConnect(program) {
+  program.command("connect").description(
+    "Connect a catalog entry or ad-hoc target as a named connection"
+  ).argument(
+    "[target...]",
+    "Catalog entry name, or command/URL (use -- for command args). A single bare word is a catalog name; a URL, a path (contains / or starts with . or ~), multiple tokens, or --transport force an ad-hoc target."
+  ).option("--server <name>", "Server name from catalog/config").option(
+    "-e <env>",
+    "Environment variables for the server (KEY=VALUE)",
+    parseKeyValuePair,
+    {}
+  ).option("--cwd <path>", "Working directory for stdio server process").option(
+    "--transport <type>",
+    "Transport type (sse, http, or stdio)",
+    (value) => {
+      const valid = ["sse", "http", "stdio"];
+      if (!valid.includes(value)) {
+        throw new Error(`Invalid transport type: ${value}`);
+      }
+      return value;
+    }
+  ).option("--server-url <url>", "Server URL for SSE/HTTP transport").option(
+    "--header <headers...>",
+    'HTTP headers as "HeaderName: Value" pairs',
+    parseHeaderPair,
+    {}
+  ).option(
+    "--connect-timeout <ms>",
+    `Connection timeout in ms (default ${DEFAULT_CONNECT_TIMEOUT_MS} for ad-hoc)`,
+    (v) => {
+      const n = Number(v);
+      if (!Number.isFinite(n) || n < 0) {
+        throw new Error(`--connect-timeout must be a non-negative number.`);
+      }
+      return n;
+    }
+  ).option(
+    "--era <era>",
+    "Protocol era to negotiate: legacy (default), auto, or modern. Overrides the catalog/config entry's protocolEra; the only way to set it for an ad-hoc target, which has no config entry of its own.",
+    (value) => {
+      const valid = ["legacy", "auto", "modern"];
+      if (!valid.includes(value)) {
+        throw new Error(
+          `Invalid --era: ${value}. Use legacy, auto, or modern.`
+        );
+      }
+      return value;
+    }
+  ).option(
+    "-r, --relogin",
+    "Ignore stored OAuth for this connect (HTTP/SSE URL keys only); interactive login runs only if the server requires auth. No-op for stdio / servers with no stored entry"
+  ).option(
+    "--elicit <mode>",
+    "Elicitation capability to advertise: off, url, form, or both (default). Overrides the catalog/config entry's elicitCapability; the only way to set it for an ad-hoc target, which has no config entry of its own. Use off when the caller of mcpdo can't handle an elicitation request, so the server sees no elicitation capability and can fall back on its own.",
+    (value) => {
+      const valid = ["off", "url", "form", "both"];
+      if (!valid.includes(value)) {
+        throw new Error(
+          `Invalid --elicit: ${value}. Use off, url, form, or both.`
+        );
+      }
+      return value;
+    }
+  ).option(
+    "--ema",
+    "Treat the server as enterprise-managed (EMA): mint tokens from the signed-in enterprise IdP session instead of standard OAuth. Overrides the catalog/config entry's oauth.enterpriseManaged. Requires install-level IdP config (see auth/ema-status) and per-server OAuth client id/secret from the catalog entry, so it cannot be used with an ad-hoc target."
+  ).action(async (target, cmdOpts) => {
+    const opts = program.opts();
+    const { name: positionalConnection, rest } = splitConnectionTarget(target);
+    const connectionName = stripAt(opts.connection) ?? positionalConnection ?? cmdOpts.server?.trim() ?? rest[0];
+    if (!connectionName) {
+      throw new CliExitCodeError(
+        EXIT_CODES.USAGE,
+        "connect requires a catalog entry name, --server <name>, or an ad-hoc target.",
+        { code: "usage" }
+      );
+    }
+    await surfaceSecretStorageAtConnect();
+    const relogin = cmdOpts.relogin === true;
+    if (relogin && opts.storedAuthOnly) {
+      throw new CliExitCodeError(
+        EXIT_CODES.USAGE,
+        "--relogin cannot be combined with --stored-auth-only",
+        { code: "usage" }
+      );
+    }
+    const adHoc = rest.length > 1 || Boolean(cmdOpts.transport) || Boolean(cmdOpts.serverUrl?.trim()) || rest.length === 1 && (looksLikeUrl(rest[0]) || looksLikePath(rest[0]));
+    if (cmdOpts.ema === true && adHoc) {
+      throw new CliExitCodeError(
+        EXIT_CODES.USAGE,
+        "--ema cannot be used with an ad-hoc target: EMA requires per-server OAuth client id/secret from a catalog entry. Add the server to a catalog with oauth.clientId and oauth.clientSecret (and oauth.enterpriseManaged), then connect by entry name.",
+        { code: "usage" }
+      );
+    }
+    const envCatalog = adHoc ? void 0 : process.env.MCP_CATALOG_PATH;
+    const serverOptions = {
+      catalogPath: opts.catalog?.trim() || envCatalog,
+      configPath: opts.config?.trim() || void 0,
+      target: adHoc ? rest.length > 0 ? rest : void 0 : void 0,
+      transport: cmdOpts.transport,
+      serverUrl: cmdOpts.serverUrl,
+      // Resolve --cwd against the CALLER's working directory. The daemon
+      // that spawns the stdio server inherits an unrelated cwd (see
+      // daemon/run.ts), so a relative --cwd must be pinned here.
+      cwd: cmdOpts.cwd ? path4.resolve(cmdOpts.cwd) : void 0,
+      env: cmdOpts.e,
+      headers: cmdOpts.header
+    };
+    const selectName = adHoc ? void 0 : cmdOpts.server?.trim() ?? rest[0];
+    const entries = await loadServerEntries(serverOptions);
+    const selected = selectServerEntry(entries, selectName);
+    const serverConfig = pinStdioConfigToCaller(selected.config);
+    const serverSettings = withEmaOverride(
+      withElicitOverride(
+        withEraOverride(
+          withConnectTimeout(
+            selected.settings,
+            cmdOpts.connectTimeout ?? (adHoc ? DEFAULT_CONNECT_TIMEOUT_MS : void 0)
+          ),
+          cmdOpts.era
+        ),
+        cmdOpts.elicit
+      ),
+      cmdOpts.ema === true ? true : void 0
+    );
+    const { detail } = summarizeServerConfig(serverConfig);
+    const name = stripAt(connectionName);
+    if (relogin && "url" in serverConfig && serverConfig.url) {
+      await clearStoredAuthForRelogin(serverConfig.url);
+    }
+    const { socketPath } = await ensureDaemon();
+    const connectParams = {
+      name,
+      serverConfig,
+      serverSettings,
+      serverIdentity: detail
+    };
+    let result;
+    try {
+      result = await callDaemon("connect", connectParams, {
+        socketPath,
+        // The daemon enforces the configured connect timeout (which may be
+        // 0 = unlimited or exceed 60s); no fixed local deadline.
+        timeoutMs: 0
+      });
+    } catch (error) {
+      if (!(error instanceof CliExitCodeError) || error.envelope?.code !== "auth_required") {
+        throw error;
+      }
+      if (opts.storedAuthOnly) {
+        throw error;
+      }
+      const humanPresent = process.stdin.isTTY === true || process.stderr.isTTY === true;
+      if (!humanPresent && !isCliAutoOpenForced()) {
+        const authUrl = await obtainPendingAuthUrl(
+          serverConfig,
+          serverSettings
+        );
+        const { socketPath: pendingSocketPath } = await ensureDaemon();
+        const pending = await callDaemon(
+          "connect",
+          { ...connectParams, pendingOnAuthRequired: true },
+          { socketPath: pendingSocketPath, timeoutMs: 0 }
+        );
+        await writeConnectionOutput(outOpts(opts), {
+          kind: "connection",
+          connection: pending,
+          ...pending.pendingAuth === true && { authUrl }
+        });
+        return;
+      }
+      await authorizeInFrontend(serverConfig, serverSettings, {
+        storedAuthOnly: false
+      });
+      const { socketPath: freshSocketPath } = await ensureDaemon();
+      result = await callDaemon("connect", connectParams, {
+        socketPath: freshSocketPath,
+        timeoutMs: 0
+      });
+    }
+    await writeConnectionOutput(outOpts(opts), {
+      kind: "connection",
+      connection: result
+    });
+  });
+}
+async function collectAuthNameIndex(opts) {
+  const envCatalog = process.env.MCP_CATALOG_PATH;
+  const serverOptions = {
+    catalogPath: opts.catalog?.trim() || envCatalog,
+    configPath: opts.config?.trim() || void 0
+  };
+  const entries = await listServerEntries(serverOptions);
+  let connections = [];
+  try {
+    const result = await callDaemon(
+      "connections/list",
+      {}
+    );
+    connections = result.connections;
+  } catch (error) {
+    if (!isDaemonUnreachable(error)) throw error;
+  }
+  return buildAuthNameIndex(entries, connections);
+}
+function registerAuthCommands(program) {
+  program.command(AUTH_HELPER_COMMAND, { hidden: true }).description("Internal: complete an OAuth sign-in (params JSON on stdin)").action(async () => {
+    await runAuthHelper();
+  });
+  program.command(EMA_LOGIN_HELPER_COMMAND, { hidden: true }).description("Internal: complete an EMA IdP sign-in").action(async () => {
+    await runEmaLoginHelper();
+  });
+  program.command("auth/list").description(
+    "List servers in the shared OAuth store, annotated with catalog/connection names"
+  ).action(async () => {
+    const opts = program.opts();
+    const list = await listStoredAuth();
+    const index2 = await collectAuthNameIndex(opts);
+    const servers = list.servers.map((s) => {
+      const issuer = parseIdpOAuthStorageKey(s.url);
+      if (issuer !== null) {
+        return { ...s, idp: true, issuer };
+      }
+      const refs = index2.urlToNames.get(s.url) ?? [];
+      return {
+        ...s,
+        ...refs.length > 0 && { knownAs: refs.map((r) => r.name) },
+        ...refs.some((r) => r.isLive) && { live: true }
+      };
+    });
+    await writeConnectionOutput(outOpts(opts), {
+      kind: "auth/list",
+      list: { oauthStatePath: list.oauthStatePath, servers }
+    });
+  });
+  program.command("auth/clear").description(
+    "Clear stored OAuth state for one server (URL or catalog/connection name from auth/list) or all entries"
+  ).argument("[key]", "Server URL or catalog/connection name from auth/list").option("--all", "Clear every stored OAuth server entry").option("--yes", "Skip confirmation when using --all").action(async (key, cmdOpts) => {
+    const opts = program.opts();
+    const all = cmdOpts.all === true;
+    if (all && key?.trim()) {
+      throw new CliExitCodeError(
+        EXIT_CODES.USAGE,
+        "auth/clear: pass a key or --all, not both",
+        { code: "usage" }
+      );
+    }
+    if (!all && !key?.trim()) {
+      throw new CliExitCodeError(
+        EXIT_CODES.USAGE,
+        "auth/clear requires a server URL key (from auth/list) or --all",
+        { code: "usage" }
+      );
+    }
+    if (all) {
+      if (!cmdOpts.yes) {
+        if (!process.stdin.isTTY || !process.stdout.isTTY) {
+          throw new CliExitCodeError(
+            EXIT_CODES.USAGE,
+            "auth/clear --all requires --yes in non-interactive mode",
+            { code: "usage" }
+          );
+        }
+        const rl = createInterface2({
+          input: process.stdin,
+          output: process.stderr
+        });
+        try {
+          const answer = await rl.question(
+            "Clear ALL stored OAuth credentials? [y/N] "
+          );
+          const ok = answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+          if (!ok) {
+            throw new CliExitCodeError(
+              EXIT_CODES.USAGE,
+              "auth/clear --all cancelled",
+              { code: "usage" }
+            );
+          }
+        } finally {
+          rl.close();
+        }
+      }
+      const result = await clearAllStoredAuth();
+      await writeConnectionOutput(outOpts(opts), {
+        kind: "auth/clear",
+        result: { all: true, cleared: result.cleared }
+      });
+      return;
+    }
+    const trimmed = key.trim();
+    const storedKeys = (await listStoredAuth()).servers.map((s) => s.url);
+    if (storedKeys.includes(trimmed)) {
+      const result = await clearStoredAuth(trimmed);
+      await writeConnectionOutput(outOpts(opts), {
+        kind: "auth/clear",
+        result: { url: result.url }
+      });
+      return;
+    }
+    if (/^https?:\/\//i.test(trimmed)) {
+      const idpKey = idpOAuthStorageKey(trimmed);
+      const target = storedKeys.includes(idpKey) && !storedKeys.includes(normalizeServerUrl(trimmed)) ? idpKey : trimmed;
+      const result = await clearStoredAuth(target);
+      await writeConnectionOutput(outOpts(opts), {
+        kind: "auth/clear",
+        result: { url: result.url }
+      });
+      return;
+    }
+    const index2 = await collectAuthNameIndex(opts);
+    const resolution = resolveFriendlyName(trimmed, index2);
+    switch (resolution.kind) {
+      case "no-url":
+        throw new CliExitCodeError(
+          EXIT_CODES.USAGE,
+          `'${trimmed}' is a stdio server \u2014 it has no stored OAuth entry to clear.`,
+          { code: "usage" }
+        );
+      case "ambiguous":
+        throw new CliExitCodeError(
+          EXIT_CODES.USAGE,
+          `'${trimmed}' maps to multiple server URLs (${resolution.urls.join(
+            ", "
+          )}). Pass the explicit URL from auth/list.`,
+          { code: "usage" }
+        );
+      case "unknown":
+        throw new CliExitCodeError(
+          EXIT_CODES.USAGE,
+          `No server named '${trimmed}'. Use auth/list or servers/list to see names, or pass a URL.`,
+          { code: "usage" }
+        );
+      case "url": {
+        const result = await clearStoredAuth(resolution.url);
+        await writeConnectionOutput(outOpts(opts), {
+          kind: "auth/clear",
+          result: { url: result.url, clearedByName: trimmed }
+        });
+        return;
+      }
+    }
+  });
+  program.command("auth/ema-status").description(
+    "Show enterprise-managed auth (EMA) configuration and IdP login state"
+  ).action(async () => {
+    const opts = program.opts();
+    const status = await getEmaStatus();
+    await writeConnectionOutput(outOpts(opts), {
+      kind: "auth/ema-status",
+      status
+    });
+  });
+  program.command("auth/ema-login").description(
+    "Sign in to the enterprise IdP (EMA); subsequent connects to EMA servers mint tokens silently from this connection"
+  ).option(
+    "-r, --relogin",
+    "Clear the existing IdP session (and EMA server tokens) and sign in fresh"
+  ).action(async (cmdOpts) => {
+    const opts = program.opts();
+    const relogin = cmdOpts.relogin === true;
+    const humanPresent = process.stdin.isTTY === true || process.stderr.isTTY === true;
+    const result = !humanPresent && !isCliAutoOpenForced() ? await startPendingEmaLogin({ relogin }) : await emaLogin({ relogin });
+    await writeConnectionOutput(outOpts(opts), {
+      kind: "auth/ema-login",
+      result
+    });
+  });
+  program.command("auth/ema-logout").description(
+    "Sign out of the enterprise IdP locally and clear EMA-minted server tokens (prints the IdP end-session URL when available)"
+  ).action(async () => {
+    const opts = program.opts();
+    const result = await emaLogout();
+    await writeConnectionOutput(outOpts(opts), {
+      kind: "auth/ema-logout",
+      result
+    });
+  });
+}
+function registerConnectionAdmin(program) {
+  program.command("disconnect").description("Disconnect a connection (MRU when omitted on a TTY)").argument("[connection]", "Optional @name / name to disconnect").option(
+    "-c, --clear-auth",
+    "Also clear this server's stored OAuth tokens so the next connect re-triggers sign-in (HTTP/SSE URL keys only; no-op for stdio / no stored entry)"
+  ).action(async (connectionArg, cmdOpts) => {
+    const opts = program.opts();
+    const name = stripAt(opts.connection) ?? stripAt(connectionArg);
+    const { socketPath } = await ensureDaemon();
+    const result = await callDaemon(
+      "disconnect",
+      {
+        name,
+        requireExplicit: requireExplicitConnection()
+      },
+      { socketPath }
+    );
+    let clearedAuthUrl;
+    if (cmdOpts.clearAuth === true && result.serverUrl) {
+      await clearStoredAuthForRelogin(result.serverUrl);
+      clearedAuthUrl = result.serverUrl;
+    }
+    await writeConnectionOutput(outOpts(opts), {
+      kind: "disconnect",
+      name: result.name,
+      ...clearedAuthUrl && { clearedAuthUrl }
+    });
+  });
+  program.command("connections/list").description("List open connections (marks MRU); does not start the daemon").action(async () => {
+    const opts = program.opts();
+    try {
+      const result = await callDaemon(
+        "connections/list",
+        {}
+      );
+      await writeConnectionOutput(outOpts(opts), {
+        kind: "connections/list",
+        connections: result.connections
+      });
+    } catch (error) {
+      if (isDaemonUnreachable(error)) {
+        await writeConnectionOutput(outOpts(opts), {
+          kind: "connections/list",
+          connections: []
+        });
+        return;
+      }
+      throw error;
+    }
+  });
+  program.command("connections/use").description("Set the MRU connection without an MCP RPC").argument("<connection>", "Connection @name / name").action(async (connectionArg) => {
+    const opts = program.opts();
+    const name = stripAt(opts.connection) ?? stripAt(connectionArg);
+    if (!name) {
+      throw new CliExitCodeError(
+        EXIT_CODES.USAGE,
+        "connections/use requires a connection name",
+        { code: "usage" }
+      );
+    }
+    const { socketPath } = await ensureDaemon();
+    const result = await callDaemon(
+      "connections/use",
+      { name },
+      { socketPath }
+    );
+    await writeConnectionOutput(outOpts(opts), {
+      kind: "connection",
+      connection: result
+    });
+  });
+  program.command("connections/show").description(
+    "Show connection + connection details: server info, capabilities, negotiated protocol era (defaults to MRU)"
+  ).argument("[connection]", "Connection @name / name (defaults to MRU)").action(async (connectionArg) => {
+    const opts = program.opts();
+    const name = stripAt(opts.connection) ?? stripAt(connectionArg);
+    const { socketPath } = await ensureDaemon();
+    const result = await callDaemon(
+      "connections/show",
+      { name, requireExplicit: requireExplicitConnection() },
+      { socketPath }
+    );
+    const humanPresent = process.stdin.isTTY === true || process.stderr.isTTY === true;
+    await writeConnectionOutput(outOpts(opts), {
+      kind: "connection",
+      connection: result,
+      ...!humanPresent && result.authUrl && { authUrl: result.authUrl }
+    });
+  });
+}
+function registerDaemonCommands(program) {
+  const daemon = program.command("daemon").description("Daemon control");
+  daemon.command("status").description("Show daemon pid, socket, and connections (does not start it)").action(async () => {
+    const opts = program.opts();
+    try {
+      const result = await callDaemon("daemon/status", {});
+      await writeConnectionOutput(outOpts(opts), {
+        kind: "daemon/status",
+        status: result
+      });
+    } catch (error) {
+      if (isDaemonUnreachable(error)) {
+        await writeConnectionOutput(outOpts(opts), {
+          kind: "daemon/status",
+          status: {
+            running: false,
+            message: "Daemon is not running."
+          }
+        });
+        return;
+      }
+      throw error;
+    }
+  });
+  daemon.command("stop").description("Stop the daemon and disconnect all connections").action(async () => {
+    const opts = program.opts();
+    try {
+      const result = await callDaemon("daemon/stop", {});
+      await writeConnectionOutput(outOpts(opts), {
+        kind: "daemon/stop",
+        result
+      });
+    } catch (error) {
+      if (isDaemonUnreachable(error)) {
+        await writeConnectionOutput(outOpts(opts), {
+          kind: "daemon/stop",
+          result: {
+            stopping: false,
+            message: "Daemon was not running."
+          }
+        });
+        return;
+      }
+      throw error;
+    }
+  });
+}
+function registerPrivateCommand(program) {
+  program.command("private").description(
+    'Print shell exports for a private daemon (eval "$(mcpdo private)"). Later mcpdo commands in that shell use an isolated, token-gated daemon.'
+  ).action(async () => {
+    const binding = createPrivateBinding();
+    await awaitableLog(formatPrivateEnvExports(binding));
+  });
+}
+function resolveAgentSkillPath() {
+  const here = path4.dirname(fileURLToPath2(import.meta.url));
+  const candidates = [
+    path4.resolve(here, "../../../skills/mcpdo/SKILL.md"),
+    path4.resolve(here, "../../../../skills/mcpdo/SKILL.md")
+  ];
+  return candidates.find((candidate) => existsSync2(candidate));
+}
+var AGENT_INSTRUCTIONS_SNIPPET = "mcpdo manages connections to additional MCP servers. Treat the tools, resources, and prompts on its open connections (`mcpdo connections/list`) as part of your available toolset \u2014 check them before deciding a task can't be done, and include them when asked what tools or MCP servers you have. Run `mcpdo agent-help` for the usage guide.\n";
+function stripFrontmatter(content) {
+  if (!content.startsWith("---\n")) return content;
+  const end = content.indexOf("\n---\n", 4);
+  if (end === -1) return content;
+  return content.slice(end + 5).replace(/^\n+/, "");
+}
+function registerAgentHelpCommand(program) {
+  program.command("agent-help").description(
+    "Print an agent-oriented usage guide, comparable to the mcpdo SKILL. Agents should read this before using other mcpdo commands."
+  ).option(
+    "--skill",
+    "Print the full usage guide \u2014 the mcpdo SKILL.md body, usable as if the skill had been loaded (default when no option is given)"
+  ).option(
+    "--instructions",
+    "Print a short snippet to append to a project's CLAUDE.md/AGENTS.md so agents treat mcpdo connections as part of their toolset on every turn (skills and this guide load only on demand). Pipeable: mcpdo agent-help --instructions >> AGENTS.md"
+  ).option(
+    "--skill-path",
+    "Print the path of the installable SKILL.md file \u2014 this guide plus its skill frontmatter \u2014 for skill runtimes (e.g. copy into ~/.claude/skills/mcpdo/)"
+  ).action(
+    async (o) => {
+      const picked = [o.skill, o.instructions, o.skillPath].filter(
+        (v) => v === true
+      ).length;
+      if (picked > 1) {
+        throw new CliExitCodeError(
+          EXIT_CODES.USAGE,
+          "--skill, --instructions, and --skill-path are mutually exclusive.",
+          { code: "agent_help_flag_conflict" }
+        );
+      }
+      if (o.instructions === true) {
+        await awaitableLog(AGENT_INSTRUCTIONS_SNIPPET);
+        return;
+      }
+      const skillPath = resolveAgentSkillPath();
+      if (!skillPath) {
+        throw new CliExitCodeError(
+          EXIT_CODES.USAGE,
+          "Could not locate skills/mcpdo/SKILL.md relative to this install.",
+          { code: "agent_help_not_found" }
+        );
+      }
+      if (o.skillPath === true) {
+        await awaitableLog(skillPath + "\n");
+        return;
+      }
+      await awaitableLog(stripFrontmatter(readFileSync2(skillPath, "utf8")));
+    }
+  );
+}
+function registerRpcCommands(program) {
+  for (const method of CONNECTION_RPC_METHODS) {
+    const cmd = program.command(method).description(`MCP ${method} against the current connection`);
+    cmd.option(
+      "--metadata <pairs...>",
+      "General metadata as key=value pairs",
+      parseKeyValue,
+      {}
+    );
+    switch (method) {
+      case "tools/list":
+        cmd.option("--app-info", "Emit one NDJSON app-info line per tool");
+        cmd.action(async (o) => {
+          await runRpc(program, method, {
+            appInfo: o.appInfo === true,
+            metadata: o.metadata
+          });
+        });
+        break;
+      case "tools/call":
+        cmd.argument("[toolName]", "Tool name").argument(
+          "[toolArgs...]",
+          "Arguments as key:=value pairs or a JSON object"
+        ).option("--tool-name <name>", "Tool name").option(
+          "--tool-arg <pairs...>",
+          "Tool argument as key=value pair (alternative to key:=value positionals)",
+          parseKeyValue,
+          {}
+        ).option(
+          "--tool-args-json <json>",
+          "Tool arguments as a JSON object (alternative to inline JSON positional)"
+        ).option(
+          "--tool-metadata <pairs...>",
+          "Tool-specific metadata",
+          parseKeyValue,
+          {}
+        ).option("--task", "Task-augmented tool call (callToolStream)").option("--app-info", "Probe MCP App metadata only");
+        cmd.action(
+          async (toolNamePos, toolArgsPos, o) => {
+            const { toolName, toolArg } = resolveToolCallArgs({
+              toolNameFlag: o.toolName,
+              toolNamePos,
+              toolArgsPos,
+              toolArgFlag: o.toolArg ?? {},
+              toolArgsJson: o.toolArgsJson
+            });
+            await runRpc(program, method, {
+              toolName,
+              toolArg,
+              toolMeta: o.toolMetadata,
+              metadata: o.metadata,
+              task: o.task === true,
+              appInfo: o.appInfo === true
+            });
+          }
+        );
+        break;
+      case "resources/read":
+      case "resources/subscribe":
+      case "resources/unsubscribe":
+        cmd.argument("[uri]", "Resource URI").option("--uri <uri>", "Resource URI");
+        cmd.action(async (uriPos, o) => {
+          await runRpc(program, method, {
+            uri: o.uri ?? uriPos,
+            metadata: o.metadata
+          });
+        });
+        break;
+      case "skills/list":
+        cmd.option(
+          "--verify",
+          "Run the SEP-2640 conformance and digest checks over every skill returned"
+        );
+        cmd.action(async (o) => {
+          await runRpc(program, method, {
+            verify: o.verify === true,
+            metadata: o.metadata
+          });
+        });
+        break;
+      case "skills/get":
+        cmd.argument("[uri]", "Skill URI").option("--uri <uri>", "Skill URI").option(
+          "--verify",
+          "Run the SEP-2640 conformance and digest checks over this skill"
+        );
+        cmd.action(async (uriPos, o) => {
+          await runRpc(program, method, {
+            uri: o.uri ?? uriPos,
+            verify: o.verify === true,
+            metadata: o.metadata
+          });
+        });
+        break;
+      case "prompts/get":
+        cmd.argument("[promptName]", "Prompt name").option("--prompt-name <name>", "Prompt name").option(
+          "--prompt-args <pairs...>",
+          "Prompt arguments",
+          parseKeyValue,
+          {}
+        );
+        cmd.action(async (promptPos, o) => {
+          await runRpc(program, method, {
+            promptName: o.promptName ?? promptPos,
+            promptArgs: o.promptArgs ?? {},
+            metadata: o.metadata
+          });
+        });
+        break;
+      case "prompts/complete":
+        cmd.option("--complete-ref-type <type>", "ref/prompt or ref/resource").option("--complete-ref <ref>", "Prompt name or resource URI").option("--complete-arg-name <name>", "Argument name").option("--complete-arg-value <value>", "Partial value", "");
+        cmd.action(async (o) => {
+          const refType = o.completeRefType;
+          if (refType !== "ref/prompt" && refType !== "ref/resource") {
+            throw new CliExitCodeError(
+              EXIT_CODES.USAGE,
+              "prompts/complete requires --complete-ref-type ref/prompt|ref/resource",
+              { code: "usage" }
+            );
+          }
+          await runRpc(program, method, {
+            completeRefType: refType,
+            completeRef: o.completeRef,
+            completeArgName: o.completeArgName,
+            completeArgValue: o.completeArgValue ?? "",
+            metadata: o.metadata
+          });
+        });
+        break;
+      case "logging/setLevel":
+        cmd.argument("[level]", "Logging level").option("--log-level <level>", "Logging level");
+        cmd.action(async (levelPos, o) => {
+          const level = o.logLevel ?? levelPos;
+          if (level && !validLogLevels.includes(level)) {
+            throw new Error(
+              `Invalid log level: ${level}. Valid: ${validLogLevels.join(", ")}`
+            );
+          }
+          await runRpc(program, method, {
+            logLevel: level,
+            metadata: o.metadata
+          });
+        });
+        break;
+      case "tasks/get":
+      case "tasks/cancel":
+      case "tasks/result":
+        cmd.argument("[taskId]", "Task id").option("--task-id <id>", "Task id");
+        cmd.action(async (taskPos, o) => {
+          await runRpc(program, method, {
+            taskId: o.taskId ?? taskPos,
+            metadata: o.metadata
+          });
+        });
+        break;
+      case "tasks/update":
+        cmd.argument("[taskId]", "Task id").option("--task-id <id>", "Task id").option(
+          "--input-responses <json>",
+          "JSON object keyed by the server's inputRequests id"
+        );
+        cmd.action(async (taskPos, o) => {
+          await runRpc(program, method, {
+            taskId: o.taskId ?? taskPos,
+            inputResponsesJson: o.inputResponses,
+            metadata: o.metadata
+          });
+        });
+        break;
+      case "roots/set":
+        cmd.option("--roots-json <json>", "JSON array of {uri, name?}");
+        cmd.action(async (o) => {
+          await runRpc(program, method, {
+            rootsJson: o.rootsJson,
+            metadata: o.metadata
+          });
+        });
+        break;
+      default:
+        cmd.action(async (o) => {
+          await runRpc(program, method, {
+            metadata: o.metadata
+          });
+        });
+        break;
+    }
+  }
+}
+function registerElicitationCommands(program) {
+  program.command("elicitation/respond").description(
+    "Answer a pending server elicitation (from elicitationPending output): form answers as key:=value pairs / JSON, --done for URL mode, or --decline / --cancel"
+  ).argument("<elicitationId>", "Id from the elicitationPending payload").argument(
+    "[fields...]",
+    "Form answers as key:=value pairs or one JSON object (accepts)"
+  ).option(
+    "--done",
+    "URL mode: report the linked interaction as finished (accept)"
+  ).option("--decline", "Decline the request (form mode only)").option("--cancel", "Cancel the elicitation").action(async (elicitationId, fields, o) => {
+    const opts = program.opts();
+    const flags = [
+      o.done === true && "--done",
+      o.decline === true && "--decline",
+      o.cancel === true && "--cancel"
+    ].filter(Boolean);
+    const hasFields = (fields?.length ?? 0) > 0;
+    if (flags.length > 1 || flags.length === 1 && hasFields) {
+      throw new CliExitCodeError(
+        EXIT_CODES.USAGE,
+        `Provide field values, or exactly one of --done / --decline / --cancel \u2014 not ${[...hasFields ? ["field values"] : [], ...flags].join(" and ")}.`,
+        { code: "usage" }
+      );
+    }
+    if (flags.length === 0 && !hasFields) {
+      throw new CliExitCodeError(
+        EXIT_CODES.USAGE,
+        "Provide form answers as key:=value pairs (or one JSON object), or one of --done / --decline / --cancel.",
+        { code: "usage" }
+      );
+    }
+    const params = o.cancel ? { elicitationId, action: "cancel" } : o.decline ? { elicitationId, action: "decline" } : hasFields ? {
+      elicitationId,
+      action: "accept",
+      content: parseToolCallPositionals(fields)
+    } : { elicitationId, action: "accept" };
+    const { socketPath } = await ensureDaemon();
+    const result = await callDaemon(
+      "elicitation/respond",
+      params,
+      // The resumed call's duration is governed by MCP timeouts the
+      // daemon enforces; a fixed local deadline would falsely fail it.
+      { socketPath, timeoutMs: 0 }
+    );
+    await writeRpcOutcome(
+      outOpts(opts),
+      result.method,
+      result.toolName,
+      result.outcome
+    );
+  });
+}
+async function runRpc(program, method, methodArgs) {
+  const opts = program.opts();
+  await dispatchConnectionRpc(method, methodArgs, {
+    format: opts.format,
+    plain: opts.plain === true,
+    connection: opts.connection,
+    requireExplicit: requireExplicitConnection()
+  });
+}
+function withEraOverride(settings, era) {
+  if (era === void 0) return settings;
+  if (settings) return { ...settings, protocolEra: era };
+  return {
+    headers: [],
+    metadata: {},
+    env: [],
+    connectionTimeout: DEFAULT_CONNECT_TIMEOUT_MS,
+    requestTimeout: 0,
+    taskTtl: DEFAULT_TASK_TTL_MS,
+    maxFetchRequests: DEFAULT_MAX_FETCH_REQUESTS,
+    autoRefreshOnListChanged: false,
+    paginatedLists: false,
+    roots: [],
+    protocolEra: era
+  };
+}
+function withElicitOverride(settings, elicit) {
+  if (elicit === void 0) return settings;
+  if (settings) return { ...settings, elicitCapability: elicit };
+  return {
+    headers: [],
+    metadata: {},
+    env: [],
+    connectionTimeout: DEFAULT_CONNECT_TIMEOUT_MS,
+    requestTimeout: 0,
+    taskTtl: DEFAULT_TASK_TTL_MS,
+    maxFetchRequests: DEFAULT_MAX_FETCH_REQUESTS,
+    autoRefreshOnListChanged: false,
+    paginatedLists: false,
+    roots: [],
+    elicitCapability: elicit
+  };
+}
+function withEmaOverride(settings, ema) {
+  if (ema === void 0) return settings;
+  if (settings) return { ...settings, enterpriseManaged: true };
+  return {
+    headers: [],
+    metadata: {},
+    env: [],
+    connectionTimeout: DEFAULT_CONNECT_TIMEOUT_MS,
+    requestTimeout: 0,
+    taskTtl: DEFAULT_TASK_TTL_MS,
+    maxFetchRequests: DEFAULT_MAX_FETCH_REQUESTS,
+    autoRefreshOnListChanged: false,
+    paginatedLists: false,
+    roots: [],
+    enterpriseManaged: true
+  };
+}
+function parseKeyValue(value, previous = {}) {
+  const parts = value.split("=");
+  const key = parts[0];
+  const val = parts.slice(1).join("=");
+  if (!key || val === void 0 || val === "") {
+    throw new Error(
+      `Invalid parameter format: ${value}. Use key=value format.`
+    );
+  }
+  let parsedValue;
+  try {
+    parsedValue = JSON.parse(val);
+  } catch {
+    parsedValue = val;
+  }
+  assertJsonRoundTrips(parsedValue, `parameter "${value}"`);
+  return { ...previous, [key]: parsedValue };
+}
+function looksLikeUrl(value) {
+  return /^https?:\/\//i.test(value);
+}
+function looksLikePath(value) {
+  return value.includes("/") || value.includes("\\") || value.startsWith(".") || value.startsWith("~");
+}
+function splitConnectionTarget(target) {
+  if (target.length > 0 && target[0].startsWith("@")) {
+    return { name: stripAt(target[0]), rest: target.slice(1) };
+  }
+  return { name: void 0, rest: target };
+}
+
+// src/mcp-bin.ts
+disallowMemorySecretStoreFallback();
+setSecretStorageWarningsQuiet(true);
+var __filename = fileURLToPath3(import.meta.url);
+function isMainModule() {
+  const entry = process.argv[1];
+  if (entry === void 0) return false;
+  try {
+    return realpathSync(resolve2(entry)) === realpathSync(resolve2(__filename));
+  } catch {
+    return resolve2(entry) === resolve2(__filename);
+  }
+}
+if (isMainModule()) {
+  runMcp(process.argv).then(() => process.exit(0)).catch(handleError);
+}
+export {
+  runMcp
+};