@ai-ecoverse/mcpcat 0.9.0 → 0.10.0

package/dist/host/mcpcat.mjs

@@ -5489,6 +5489,176 @@ function mergeArgs(base, flags) {
   return result;
 }
 
+// node_modules/@earendil-works/pi-mcp/dist/oauth/callback.js
+import { createServer } from "node:http";
+function plainText(page) {
+  if (page.ok)
+    return "Authorization complete. You may close this window.";
+  return page.details ? `${page.message}
+
+${page.details}` : page.message;
+}
+var OAuthCallbackServer = class _OAuthCallbackServer {
+  redirectUrl;
+  server;
+  paths;
+  timeoutMs;
+  renderPage;
+  pending = /* @__PURE__ */ new Map();
+  constructor(server, redirectUrl, paths, timeoutMs, renderPage) {
+    this.server = server;
+    this.redirectUrl = redirectUrl;
+    this.paths = paths;
+    this.timeoutMs = timeoutMs;
+    this.renderPage = renderPage;
+  }
+  static async listen(options = {}) {
+    const host = options.host ?? "127.0.0.1";
+    const redirectHost = options.redirectHost ?? host;
+    const path = options.path ?? "/callback";
+    let instance;
+    const server = createServer((request, response) => instance?.handle(request.url ?? "/", response));
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(options.port ?? 0, host, () => {
+        server.off("error", reject);
+        resolve();
+      });
+    });
+    const address = server.address();
+    if (!address || typeof address === "string")
+      throw new Error("OAuth callback server did not bind to TCP");
+    instance = new _OAuthCallbackServer(server, `http://${redirectHost.includes(":") ? `[${redirectHost}]` : redirectHost}:${address.port}${path}`, [path, ...options.extraPaths ?? []], options.timeoutMs ?? 5 * 6e4, options.renderPage);
+    return instance;
+  }
+  /**
+   * Wait for the authorization response with `state`. With `path`, a response on another path fails, so
+   * a server-specific redirect URI can tell authorization servers apart (RFC 9700 section 4.4.2.2).
+   */
+  waitForCallback(state, path) {
+    if (this.pending.has(state))
+      throw new Error("OAuth state is already pending");
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(state);
+        reject(new Error("OAuth callback timed out"));
+      }, this.timeoutMs);
+      this.pending.set(state, { resolve, reject, timer, path });
+    });
+  }
+  async close() {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new Error("OAuth callback server closed"));
+    }
+    this.pending.clear();
+    await new Promise((resolve, reject) => {
+      this.server.close((error) => error ? reject(error) : resolve());
+    });
+  }
+  reply(response, status, page) {
+    if (this.renderPage) {
+      response.writeHead(status, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store" });
+      response.end(this.renderPage(page));
+    } else {
+      response.writeHead(status, { "content-type": "text/plain; charset=utf-8" }).end(plainText(page));
+    }
+  }
+  handle(rawUrl, response) {
+    const url = new URL(rawUrl, this.redirectUrl);
+    if (!this.paths.includes(url.pathname)) {
+      this.reply(response, 404, { ok: false, message: "Not found" });
+      return;
+    }
+    const state = url.searchParams.get("state");
+    const pending = state ? this.pending.get(state) : void 0;
+    if (!state || !pending) {
+      this.reply(response, 400, { ok: false, message: "Invalid or expired OAuth state" });
+      return;
+    }
+    clearTimeout(pending.timer);
+    this.pending.delete(state);
+    if (pending.path !== void 0 && url.pathname !== pending.path) {
+      pending.reject(new Error("The authorization response arrived on another redirect URI"));
+      this.reply(response, 400, { ok: false, message: "Unexpected redirect URI" });
+      return;
+    }
+    const error = url.searchParams.get("error");
+    if (error) {
+      const description = url.searchParams.get("error_description") ?? error;
+      pending.reject(new Error(description));
+      this.reply(response, 200, {
+        ok: false,
+        message: "Authorization failed. You may close this window.",
+        details: description
+      });
+      return;
+    }
+    const code2 = url.searchParams.get("code");
+    if (!code2) {
+      pending.reject(new Error("OAuth callback did not include an authorization code"));
+      this.reply(response, 400, { ok: false, message: "Missing authorization code" });
+      return;
+    }
+    const iss = url.searchParams.get("iss");
+    pending.resolve({ code: code2, state, ...iss ? { iss } : {} });
+    this.reply(response, 200, { ok: true });
+  }
+};
+
+// node_modules/@earendil-works/pi-mcp/dist/protocol/types.js
+var LATEST_PROTOCOL_VERSION = "2025-11-25";
+var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05"];
+
+// node_modules/@earendil-works/pi-mcp/dist/oauth/errors.js
+var OAuthError = class extends Error {
+  code;
+  errorUri;
+  constructor(code2, message, errorUri) {
+    super(message || code2);
+    this.name = "OAuthError";
+    this.code = code2;
+    this.errorUri = errorUri;
+  }
+};
+var OAuthIssuerMismatchError = class extends Error {
+  /** `undefined` when no authorization server metadata was discovered. */
+  expected;
+  /** `undefined` when an authorization response lacks the `iss` parameter its server promised (RFC 9207). */
+  received;
+  constructor(expected, received) {
+    const format = (issuer) => issuer === void 0 ? "none" : JSON.stringify(issuer);
+    super(`OAuth issuer mismatch: expected ${format(expected)}, received ${format(received)}`);
+    this.name = "OAuthIssuerMismatchError";
+    this.expected = expected;
+    this.received = received;
+  }
+};
+var OAuthInsecureEndpointError = class extends Error {
+  endpoint;
+  constructor(endpoint) {
+    super(`Refusing to send OAuth credentials to non-HTTPS endpoint ${endpoint}`);
+    this.name = "OAuthInsecureEndpointError";
+    this.endpoint = endpoint;
+  }
+};
+var OAuthRegistrationError = class extends Error {
+  status;
+  body;
+  constructor(status, body) {
+    super(`OAuth dynamic client registration failed with status ${status}: ${body}`);
+    this.name = "OAuthRegistrationError";
+    this.status = status;
+    this.body = body;
+  }
+};
+var McpOAuthAuthorizationRequiredError = class extends Error {
+  constructor() {
+    super("MCP OAuth authorization requires user interaction");
+    this.name = "McpOAuthAuthorizationRequiredError";
+  }
+};
+
 // node_modules/@earendil-works/pi-mcp/dist/protocol/jsonrpc.js
 var JSON_RPC_ERROR_CODES = {
   parseError: -32700,
@@ -5557,9 +5727,726 @@ function parseJsonRpcMessage(value) {
   throw new McpError(JSON_RPC_ERROR_CODES.invalidRequest, "Invalid JSON-RPC message");
 }
 
-// node_modules/@earendil-works/pi-mcp/dist/protocol/types.js
-var LATEST_PROTOCOL_VERSION = "2025-11-25";
-var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05"];
+// node_modules/@earendil-works/pi-mcp/dist/oauth/types.js
+function object(value, name) {
+  if (!isObject(value))
+    throw new Error(`Invalid ${name}`);
+  return value;
+}
+function compact(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0));
+}
+function requiredString(value, name) {
+  if (typeof value !== "string" || value.length === 0)
+    throw new Error(`Invalid ${name}`);
+  return value;
+}
+function absent(value) {
+  return value === void 0 || value === null || value === "";
+}
+function optionalString(value, name) {
+  if (absent(value))
+    return void 0;
+  return requiredString(value, name);
+}
+function optionalStrings(value, name) {
+  if (value === void 0 || value === null)
+    return void 0;
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string"))
+    throw new Error(`Invalid ${name}`);
+  return [...value];
+}
+function safeUrl(value, name) {
+  const text = requiredString(value, name);
+  if (!URL.canParse(text))
+    throw new Error(`Invalid ${name}`);
+  const url = new URL(text);
+  if (["javascript:", "data:", "vbscript:"].includes(url.protocol))
+    throw new Error(`Invalid ${name}`);
+  return text;
+}
+function optionalUrl(value, name) {
+  return absent(value) ? void 0 : safeUrl(value, name);
+}
+function parseProtectedResourceMetadata(value) {
+  const input = object(value, "OAuth protected resource metadata");
+  return compact({
+    ...input,
+    resource: safeUrl(input.resource, "OAuth protected resource metadata resource"),
+    authorization_servers: optionalStrings(input.authorization_servers, "authorization_servers")?.map((url) => safeUrl(url, "authorization server URL")),
+    scopes_supported: optionalStrings(input.scopes_supported, "scopes_supported")
+  });
+}
+function parseAuthorizationServerMetadata(value) {
+  const input = object(value, "authorization server metadata");
+  const responseTypes = optionalStrings(input.response_types_supported, "response_types_supported");
+  if (!responseTypes)
+    throw new Error("Invalid response_types_supported");
+  return compact({
+    ...input,
+    issuer: safeUrl(input.issuer, "authorization server issuer"),
+    authorization_endpoint: safeUrl(input.authorization_endpoint, "authorization endpoint"),
+    token_endpoint: safeUrl(input.token_endpoint, "token endpoint"),
+    registration_endpoint: optionalUrl(input.registration_endpoint, "registration endpoint"),
+    scopes_supported: optionalStrings(input.scopes_supported, "scopes_supported"),
+    response_types_supported: responseTypes,
+    grant_types_supported: optionalStrings(input.grant_types_supported, "grant_types_supported"),
+    token_endpoint_auth_methods_supported: optionalStrings(input.token_endpoint_auth_methods_supported, "token_endpoint_auth_methods_supported"),
+    code_challenge_methods_supported: optionalStrings(input.code_challenge_methods_supported, "code_challenge_methods_supported"),
+    client_id_metadata_document_supported: typeof input.client_id_metadata_document_supported === "boolean" ? input.client_id_metadata_document_supported : void 0,
+    authorization_response_iss_parameter_supported: typeof input.authorization_response_iss_parameter_supported === "boolean" ? input.authorization_response_iss_parameter_supported : void 0
+  });
+}
+function parseOAuthTokens(value) {
+  const input = object(value, "OAuth token response");
+  const expires = absent(input.expires_in) ? void 0 : Number(input.expires_in);
+  if (expires !== void 0 && !Number.isFinite(expires))
+    throw new Error("Invalid expires_in");
+  return compact({
+    access_token: requiredString(input.access_token, "access_token"),
+    token_type: requiredString(input.token_type, "token_type"),
+    expires_in: expires,
+    scope: optionalString(input.scope, "scope"),
+    refresh_token: optionalString(input.refresh_token, "refresh_token"),
+    id_token: optionalString(input.id_token, "id_token")
+  });
+}
+function parseClientInformation(value) {
+  const input = object(value, "OAuth client registration response");
+  return compact({
+    ...input,
+    client_id: requiredString(input.client_id, "client_id"),
+    client_secret: optionalString(input.client_secret, "client_secret"),
+    client_id_issued_at: typeof input.client_id_issued_at === "number" ? input.client_id_issued_at : void 0,
+    client_secret_expires_at: typeof input.client_secret_expires_at === "number" ? input.client_secret_expires_at : void 0,
+    redirect_uris: optionalStrings(input.redirect_uris, "redirect_uris") ?? []
+  });
+}
+
+// node_modules/@earendil-works/pi-mcp/dist/oauth/discovery.js
+function discard(response) {
+  void response?.body?.cancel().catch(() => {
+  });
+}
+function isDiscoveryMiss(status) {
+  return status >= 400 && status < 500 || status === 502;
+}
+function pathSuffix(pathname) {
+  return pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
+}
+function field(header, name) {
+  const match = header.match(new RegExp(String.raw`(?:^|[,\s])${name}=(?:"([^"]*)"|([^\s,]+))`, "i"));
+  return match?.[1] || match?.[2] || void 0;
+}
+function parseWwwAuthenticate(header) {
+  if (!header)
+    return {};
+  const scheme = header.trimStart().split(/\s+/, 1)[0]?.toLowerCase();
+  if (scheme !== "bearer" && scheme !== "dpop")
+    return {};
+  const resourceMetadata = field(header, "resource_metadata");
+  let resourceMetadataUrl;
+  if (resourceMetadata) {
+    try {
+      resourceMetadataUrl = new URL(resourceMetadata);
+    } catch {
+    }
+  }
+  return {
+    resourceMetadataUrl,
+    scope: field(header, "scope"),
+    error: field(header, "error"),
+    errorDescription: field(header, "error_description")
+  };
+}
+async function fetchMetadata(url, fetch, protocolVersion, signal) {
+  return fetch(url, {
+    headers: { Accept: "application/json", "MCP-Protocol-Version": protocolVersion },
+    signal
+  });
+}
+async function discoverProtectedResourceMetadata(serverUrl, options = {}) {
+  const server = new URL(serverUrl);
+  const fetch = options.fetch ?? globalThis.fetch;
+  const version = options.protocolVersion ?? LATEST_PROTOCOL_VERSION;
+  let response = await fetchMetadata(options.resourceMetadataUrl ? new URL(options.resourceMetadataUrl) : new URL(`/.well-known/oauth-protected-resource${pathSuffix(server.pathname)}`, server.origin), fetch, version, options.signal);
+  if (!options.resourceMetadataUrl && server.pathname !== "/" && isDiscoveryMiss(response.status)) {
+    discard(response);
+    response = await fetchMetadata(new URL("/.well-known/oauth-protected-resource", server.origin), fetch, version, options.signal);
+  }
+  if (!response.ok) {
+    discard(response);
+    throw new Error(`HTTP ${response.status} loading OAuth protected resource metadata`);
+  }
+  return parseProtectedResourceMetadata(await response.json());
+}
+function buildAuthorizationServerDiscoveryUrls(authorizationServerUrl) {
+  const issuer = new URL(authorizationServerUrl);
+  const path = pathSuffix(issuer.pathname);
+  const urls = [
+    { url: new URL(`/.well-known/oauth-authorization-server${path}`, issuer.origin), type: "oauth" },
+    { url: new URL(`/.well-known/openid-configuration${path}`, issuer.origin), type: "oidc" }
+  ];
+  if (path)
+    urls.push({ url: new URL(`${path}/.well-known/openid-configuration`, issuer.origin), type: "oidc" });
+  return urls;
+}
+async function discoverAuthorizationServerMetadata(authorizationServerUrl, options = {}) {
+  const fetch = options.fetch ?? globalThis.fetch;
+  for (const { url } of buildAuthorizationServerDiscoveryUrls(authorizationServerUrl)) {
+    const response = await fetchMetadata(url, fetch, options.protocolVersion ?? LATEST_PROTOCOL_VERSION, options.signal);
+    if (!response.ok) {
+      discard(response);
+      if (isDiscoveryMiss(response.status))
+        continue;
+      throw new Error(`HTTP ${response.status} loading authorization server metadata from ${url}`);
+    }
+    const metadata = parseAuthorizationServerMetadata(await response.json());
+    if (!options.skipIssuerValidation) {
+      const expected = String(authorizationServerUrl);
+      const trim = (value) => value.endsWith("/") ? value.slice(0, -1) : value;
+      if (trim(metadata.issuer) !== trim(expected))
+        throw new OAuthIssuerMismatchError(expected, metadata.issuer);
+    }
+    return metadata;
+  }
+  return void 0;
+}
+async function discoverOAuthServerInfo(serverUrl, options = {}) {
+  let resourceMetadata;
+  try {
+    resourceMetadata = await discoverProtectedResourceMetadata(serverUrl, {
+      resourceMetadataUrl: options.resourceMetadataUrl,
+      fetch: options.fetch,
+      signal: options.signal
+    });
+  } catch (error) {
+    if (error instanceof TypeError)
+      throw error;
+  }
+  if (options.authorizationServerMetadataUrl) {
+    const url = options.authorizationServerMetadataUrl;
+    const response = await fetchMetadata(url, options.fetch ?? globalThis.fetch, LATEST_PROTOCOL_VERSION, options.signal);
+    if (!response.ok) {
+      discard(response);
+      throw new Error(`HTTP ${response.status} loading authorization server metadata from ${url}`);
+    }
+    const metadata = parseAuthorizationServerMetadata(await response.json());
+    return { authorizationServerUrl: metadata.issuer, authorizationServerMetadata: metadata, resourceMetadata };
+  }
+  const authorizationServerUrl = resourceMetadata?.authorization_servers?.[0] ?? String(new URL("/", serverUrl));
+  return {
+    authorizationServerUrl,
+    authorizationServerMetadata: await discoverAuthorizationServerMetadata(authorizationServerUrl, {
+      fetch: options.fetch,
+      skipIssuerValidation: options.skipIssuerValidation,
+      signal: options.signal
+    }),
+    resourceMetadata
+  };
+}
+function resourceUrlFromServerUrl(value) {
+  const url = new URL(value);
+  url.hash = "";
+  return url;
+}
+function selectResource(serverUrl, metadata) {
+  if (!metadata)
+    return void 0;
+  const requested = resourceUrlFromServerUrl(serverUrl);
+  const configured = new URL(metadata.resource);
+  if (requested.origin !== configured.origin) {
+    throw new Error(`Protected resource ${metadata.resource} does not match MCP server ${requested}`);
+  }
+  const requestedPath = requested.pathname.endsWith("/") ? requested.pathname : `${requested.pathname}/`;
+  const configuredPath = configured.pathname.endsWith("/") ? configured.pathname : `${configured.pathname}/`;
+  if (!requestedPath.startsWith(configuredPath)) {
+    throw new Error(`Protected resource ${metadata.resource} does not match MCP server ${requested}`);
+  }
+  return metadata.resource;
+}
+
+// node_modules/@earendil-works/pi-mcp/dist/oauth/flow.js
+function loopback(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]" || hostname === "::1";
+}
+function applicationType(redirectUris) {
+  const native = redirectUris.some((uri) => {
+    if (!URL.canParse(uri))
+      return false;
+    const url = new URL(uri);
+    return url.protocol !== "http:" && url.protocol !== "https:" || loopback(url.hostname);
+  });
+  return native ? "native" : "web";
+}
+function secureEndpoint(value) {
+  const url = new URL(value);
+  if (url.protocol !== "https:" && !loopback(url.hostname))
+    throw new OAuthInsecureEndpointError(url.href);
+  return url;
+}
+function selectClientAuthMethod(information, supported) {
+  const hinted = "token_endpoint_auth_method" in information ? information.token_endpoint_auth_method : void 0;
+  if (hinted && ["client_secret_basic", "client_secret_post", "none"].includes(hinted) && (supported.length === 0 || supported.includes(hinted))) {
+    return hinted;
+  }
+  if (supported.length === 0)
+    return information.client_secret ? "client_secret_basic" : "none";
+  if (information.client_secret && supported.includes("client_secret_basic"))
+    return "client_secret_basic";
+  if (information.client_secret && supported.includes("client_secret_post"))
+    return "client_secret_post";
+  if (supported.includes("none"))
+    return "none";
+  return information.client_secret ? "client_secret_post" : "none";
+}
+function applyClientAuthentication(method, information, headers, params) {
+  if (method === "client_secret_basic") {
+    if (!information.client_secret)
+      throw new Error("client_secret_basic requires a client secret");
+    headers.set("Authorization", `Basic ${Buffer.from(`${information.client_id}:${information.client_secret}`).toString("base64")}`);
+  } else {
+    params.set("client_id", information.client_id);
+    if (method === "client_secret_post" && information.client_secret)
+      params.set("client_secret", information.client_secret);
+  }
+}
+async function pkce() {
+  const bytes = crypto.getRandomValues(new Uint8Array(32));
+  const verifier = Buffer.from(bytes).toString("base64url");
+  const digest = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(verifier));
+  return { verifier, challenge: Buffer.from(digest).toString("base64url") };
+}
+async function startAuthorization(authorizationServerUrl, options) {
+  const metadata = options.metadata;
+  if (metadata && !metadata.response_types_supported.includes("code")) {
+    throw new Error("Authorization server does not support authorization codes");
+  }
+  if (metadata?.code_challenge_methods_supported && !metadata.code_challenge_methods_supported.includes("S256")) {
+    throw new Error("Authorization server does not support PKCE S256");
+  }
+  const url = new URL(metadata?.authorization_endpoint ?? new URL("/authorize", authorizationServerUrl));
+  const { verifier, challenge } = await pkce();
+  url.searchParams.set("response_type", "code");
+  url.searchParams.set("client_id", options.clientInformation.client_id);
+  url.searchParams.set("code_challenge", challenge);
+  url.searchParams.set("code_challenge_method", "S256");
+  url.searchParams.set("redirect_uri", String(options.redirectUrl));
+  if (options.state)
+    url.searchParams.set("state", options.state);
+  if (options.scope)
+    url.searchParams.set("scope", options.scope);
+  if (options.scope?.split(/\s+/).includes("offline_access"))
+    url.searchParams.set("prompt", "consent");
+  if (options.resource)
+    url.searchParams.set("resource", options.resource);
+  return { authorizationUrl: url, codeVerifier: verifier };
+}
+async function tokenRequest(authorizationServerUrl, options, params) {
+  const url = secureEndpoint(options.metadata?.token_endpoint ?? new URL("/token", authorizationServerUrl));
+  const headers = new Headers({ Accept: "application/json", "content-type": "application/x-www-form-urlencoded" });
+  if (options.resource)
+    params.set("resource", options.resource);
+  if (options.addClientAuthentication) {
+    await options.addClientAuthentication(headers, params, url, options.metadata);
+  } else {
+    applyClientAuthentication(selectClientAuthMethod(options.clientInformation, options.metadata?.token_endpoint_auth_methods_supported ?? []), options.clientInformation, headers, params);
+  }
+  const response = await (options.fetch ?? globalThis.fetch)(url, {
+    method: "POST",
+    headers,
+    body: params,
+    signal: options.signal
+  });
+  const text = await response.text();
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+  }
+  if (isObject(value) && typeof value.error === "string") {
+    throw new OAuthError(value.error, typeof value.error_description === "string" ? value.error_description : value.error, typeof value.error_uri === "string" ? value.error_uri : void 0);
+  }
+  if (!response.ok)
+    throw new OAuthError("server_error", `HTTP ${response.status}: ${text}`);
+  return parseOAuthTokens(value);
+}
+async function registerClient(authorizationServerUrl, options) {
+  const endpoint = options.metadata?.registration_endpoint;
+  if (options.metadata && !endpoint)
+    throw new Error("Authorization server does not support dynamic client registration");
+  const response = await (options.fetch ?? globalThis.fetch)(new URL(endpoint ?? new URL("/register", authorizationServerUrl)), {
+    method: "POST",
+    headers: { Accept: "application/json", "content-type": "application/json" },
+    body: JSON.stringify({
+      ...options.clientMetadata,
+      application_type: options.clientMetadata.application_type ?? applicationType(options.clientMetadata.redirect_uris),
+      ...options.scope ? { scope: options.scope } : {}
+    }),
+    signal: options.signal
+  });
+  if (!response.ok)
+    throw new OAuthRegistrationError(response.status, await response.text());
+  return parseClientInformation(await response.json());
+}
+async function exchangeAuthorizationCode(authorizationServerUrl, options) {
+  return tokenRequest(authorizationServerUrl, options, new URLSearchParams({
+    grant_type: "authorization_code",
+    code: options.code,
+    code_verifier: options.codeVerifier,
+    redirect_uri: String(options.redirectUrl)
+  }));
+}
+async function refreshAuthorization(authorizationServerUrl, options) {
+  const tokens = await tokenRequest(authorizationServerUrl, options, new URLSearchParams({ grant_type: "refresh_token", refresh_token: options.refreshToken }));
+  return { refresh_token: options.refreshToken, ...tokens };
+}
+function withScope(tokens, scope) {
+  return tokens.scope === void 0 && scope ? { ...tokens, scope } : tokens;
+}
+function stepUpScope(granted, challenged) {
+  if (!challenged)
+    return void 0;
+  const scopes = [granted, challenged].flatMap((scope) => scope?.split(/\s+/).filter(Boolean) ?? []);
+  return [...new Set(scopes)].join(" ");
+}
+async function runFlow(provider, options) {
+  const metadataUrl = options.authorizationServerMetadataUrl && secureEndpoint(options.authorizationServerMetadataUrl);
+  const cached = metadataUrl ? void 0 : await provider.discoveryState?.();
+  const discovered = cached?.authorizationServerUrl ? {
+    authorizationServerUrl: cached.authorizationServerUrl,
+    authorizationServerMetadata: cached.authorizationServerMetadata ?? await discoverAuthorizationServerMetadata(cached.authorizationServerUrl, {
+      fetch: options.fetch,
+      skipIssuerValidation: options.skipIssuerValidation,
+      signal: options.signal
+    }),
+    resourceMetadata: cached.resourceMetadata
+  } : await discoverOAuthServerInfo(options.serverUrl, {
+    resourceMetadataUrl: options.resourceMetadataUrl,
+    authorizationServerMetadataUrl: metadataUrl,
+    fetch: options.fetch,
+    skipIssuerValidation: options.skipIssuerValidation,
+    signal: options.signal
+  });
+  if (!metadataUrl) {
+    await provider.saveDiscoveryState?.({
+      ...discovered,
+      ...options.resourceMetadataUrl ? { resourceMetadataUrl: options.resourceMetadataUrl.href } : {}
+    });
+  }
+  const metadata = discovered.authorizationServerMetadata;
+  const resource = selectResource(options.serverUrl, discovered.resourceMetadata);
+  const scope = options.scope || discovered.resourceMetadata?.scopes_supported?.join(" ") || provider.clientMetadata.scope;
+  const stored = await provider.clientInformation();
+  const clientDocument = stored ? void 0 : provider.clientMetadataDocument?.(metadata);
+  if (clientDocument) {
+    const url = new URL(clientDocument.url);
+    if (url.protocol !== "https:" || url.pathname === "/")
+      throw new Error("Invalid OAuth client metadata URL");
+  }
+  let client = stored ?? (clientDocument && { client_id: clientDocument.url });
+  if (!client) {
+    if (options.authorizationCode)
+      throw new Error("OAuth client information is missing during code exchange");
+    if (!provider.saveClientInformation)
+      throw new Error("OAuth client information cannot be persisted");
+    client = await registerClient(discovered.authorizationServerUrl, {
+      metadata,
+      clientMetadata: provider.clientMetadata,
+      scope,
+      fetch: options.fetch,
+      signal: options.signal
+    });
+    await provider.saveClientInformation(client);
+  }
+  const redirectUrl = clientDocument?.redirectUrl ?? provider.redirectUrl;
+  const tokenOptions = {
+    metadata,
+    clientInformation: client,
+    resource,
+    addClientAuthentication: provider.addClientAuthentication,
+    fetch: options.fetch,
+    signal: options.signal
+  };
+  if (options.authorizationCode) {
+    const iss = options.iss;
+    if (iss !== void 0 || metadata?.authorization_response_iss_parameter_supported) {
+      if (iss !== metadata?.issuer)
+        throw new OAuthIssuerMismatchError(metadata?.issuer, iss);
+    }
+    const tokens = await exchangeAuthorizationCode(discovered.authorizationServerUrl, {
+      ...tokenOptions,
+      code: options.authorizationCode,
+      codeVerifier: await provider.codeVerifier(),
+      redirectUrl
+    });
+    await provider.saveTokens(withScope(tokens, scope));
+    return "AUTHORIZED";
+  }
+  const existing = options.skipRefresh ? void 0 : await provider.tokens();
+  if (existing?.refresh_token) {
+    try {
+      const tokens = await refreshAuthorization(discovered.authorizationServerUrl, {
+        ...tokenOptions,
+        refreshToken: existing.refresh_token
+      });
+      await provider.saveTokens(withScope(tokens, existing.scope));
+      return "AUTHORIZED";
+    } catch (error) {
+      if (options.signal?.aborted || error instanceof OAuthInsecureEndpointError)
+        throw error;
+      if (error instanceof OAuthError && error.code !== "server_error")
+        throw error;
+    }
+  }
+  const state = await provider.state?.();
+  const authorization = await startAuthorization(discovered.authorizationServerUrl, {
+    metadata,
+    clientInformation: client,
+    redirectUrl,
+    scope,
+    state,
+    resource
+  });
+  await provider.saveCodeVerifier(authorization.codeVerifier);
+  await provider.redirectToAuthorization(authorization.authorizationUrl);
+  return "REDIRECT";
+}
+async function authorizeMcp(provider, options) {
+  try {
+    return await runFlow(provider, options);
+  } catch (error) {
+    if (error instanceof OAuthError && ["invalid_client", "unauthorized_client"].includes(error.code)) {
+      await provider.invalidateCredentials?.("all");
+      return runFlow(provider, options);
+    }
+    if (error instanceof OAuthError && error.code === "invalid_grant") {
+      await provider.invalidateCredentials?.("tokens");
+      return runFlow(provider, options);
+    }
+    throw error;
+  }
+}
+
+// node_modules/@earendil-works/pi-mcp/dist/oauth/provider.js
+var MemoryOAuthStateStore = class {
+  value;
+  load() {
+    return this.value === void 0 ? void 0 : structuredClone(this.value);
+  }
+  save(state) {
+    this.value = structuredClone(state);
+  }
+};
+var McpOAuthProvider = class {
+  redirectUrl;
+  clientMetadata;
+  clientMetadataDocument;
+  serverUrl;
+  configuredClient;
+  store;
+  onRedirect;
+  writes = Promise.resolve();
+  constructor(options) {
+    this.serverUrl = String(new URL(options.serverUrl));
+    this.redirectUrl = String(options.redirectUrl);
+    this.clientMetadata = {
+      ...options.clientMetadata,
+      redirect_uris: options.clientMetadata.redirect_uris ?? [this.redirectUrl],
+      grant_types: options.clientMetadata.grant_types ?? ["authorization_code", "refresh_token"],
+      response_types: options.clientMetadata.response_types ?? ["code"],
+      token_endpoint_auth_method: options.clientMetadata.token_endpoint_auth_method ?? (options.clientSecret ? "client_secret_post" : "none")
+    };
+    this.clientMetadataDocument = options.clientMetadataDocument;
+    this.configuredClient = options.clientId ? { client_id: options.clientId, ...options.clientSecret ? { client_secret: options.clientSecret } : {} } : void 0;
+    this.store = options.store ?? new MemoryOAuthStateStore();
+    this.onRedirect = options.onRedirect;
+  }
+  async state() {
+    const existing = (await this.load()).oauthState;
+    if (existing)
+      return existing;
+    const state = Buffer.from(crypto.getRandomValues(new Uint8Array(32))).toString("hex");
+    await this.update((value) => ({ ...value, oauthState: state }));
+    return state;
+  }
+  async clientInformation() {
+    return this.configuredClient ?? (await this.load()).clientInformation;
+  }
+  async saveClientInformation(information) {
+    if (this.configuredClient)
+      return;
+    await this.update((value) => ({ ...value, clientInformation: information }));
+  }
+  async tokens() {
+    return (await this.load()).tokens;
+  }
+  async saveTokens(tokens) {
+    const expiresAt = tokens.expires_in === void 0 ? void 0 : Date.now() + tokens.expires_in * 1e3;
+    await this.update((value) => {
+      const next = { ...value, tokens };
+      if (expiresAt === void 0)
+        delete next.tokensExpireAt;
+      else
+        next.tokensExpireAt = expiresAt;
+      return next;
+    });
+  }
+  async redirectToAuthorization(url) {
+    await this.onRedirect(url);
+  }
+  async saveCodeVerifier(verifier) {
+    await this.update((value) => ({ ...value, codeVerifier: verifier }));
+  }
+  async codeVerifier() {
+    const verifier = (await this.load()).codeVerifier;
+    if (!verifier)
+      throw new Error("No OAuth PKCE code verifier is stored");
+    return verifier;
+  }
+  async invalidateCredentials(kind) {
+    await this.update((value) => {
+      const next = { ...value };
+      if (kind === "all" || kind === "client")
+        delete next.clientInformation;
+      if (kind === "all" || kind === "tokens") {
+        delete next.tokens;
+        delete next.tokensExpireAt;
+      }
+      if (kind === "all" || kind === "verifier")
+        delete next.codeVerifier;
+      if (kind === "all" || kind === "discovery")
+        delete next.discovery;
+      if (kind === "all")
+        delete next.oauthState;
+      return next;
+    });
+  }
+  async saveDiscoveryState(discovery) {
+    await this.update((value) => ({ ...value, discovery }));
+  }
+  async discoveryState() {
+    return (await this.load()).discovery;
+  }
+  async load() {
+    await this.writes;
+    return this.own(await this.store.load());
+  }
+  async update(update) {
+    this.writes = this.writes.then(async () => {
+      await this.store.save(update(this.own(await this.store.load())));
+    });
+    await this.writes;
+  }
+  /** Stored state for another server URL is ignored so credentials never leak across servers. */
+  own(state) {
+    return state?.serverUrl === this.serverUrl ? state : { serverUrl: this.serverUrl };
+  }
+};
+
+// src/auth/auth-provider.ts
+var CIMD_URL = "https://mcpcat.sliccy.ai/oauth/client.json";
+var CLIENT_NAME = "mcpcat";
+var CALLBACK_HOST = "127.0.0.1";
+var CALLBACK_PATH = "/callback";
+var REQUEST_TIMEOUT_MS = 15e3;
+var REFRESH_SKEW_MS = 3e4;
+var FALLBACK_REDIRECT_URL = `http://${CALLBACK_HOST}${CALLBACK_PATH}`;
+function timedFetch(fetchImpl) {
+  return (input, init) => {
+    const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
+    return fetchImpl(input, {
+      ...init,
+      signal: init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout
+    });
+  };
+}
+var SourceBackedStore = class {
+  source;
+  name;
+  serverUrl;
+  constructor(source, name, serverUrl) {
+    this.source = source;
+    this.name = name;
+    this.serverUrl = serverUrl;
+  }
+  async load() {
+    return this.source.load(this.name, this.serverUrl);
+  }
+  async save(state) {
+    await this.source.save(this.name, this.serverUrl, state);
+  }
+};
+function cimdFn(redirectUrl) {
+  return (metadata) => {
+    if (!metadata?.client_id_metadata_document_supported) return void 0;
+    if (!metadata.token_endpoint_auth_methods_supported?.includes("none")) return void 0;
+    if (!metadata.authorization_response_iss_parameter_supported) return void 0;
+    return { url: CIMD_URL, redirectUrl };
+  };
+}
+var AuthStepUpError = class extends Error {
+  scope;
+  target;
+  constructor(scope, target) {
+    super(scope ? `insufficient_scope: ${scope}` : "insufficient_scope");
+    this.name = "AuthStepUpError";
+    this.scope = scope;
+    this.target = target;
+  }
+};
+function createMcpAuthProvider(options) {
+  const { name, serverUrl, source, oauth, platform: platform2 } = options;
+  const store = new SourceBackedStore(source, name, serverUrl);
+  let refreshing;
+  const refresh = async (staleToken) => {
+    refreshing ??= (async () => {
+      const state = await store.load();
+      if (state?.tokens?.access_token !== staleToken) return;
+      if (!state?.tokens?.refresh_token) throw new McpOAuthAuthorizationRequiredError();
+      const registered = state.clientInformation && "redirect_uris" in state.clientInformation ? state.clientInformation.redirect_uris : [];
+      const redirectUrl = registered[0] ?? FALLBACK_REDIRECT_URL;
+      const provider = new McpOAuthProvider({
+        serverUrl,
+        redirectUrl,
+        clientMetadata: { client_name: oauth?.clientName ?? CLIENT_NAME },
+        clientMetadataDocument: oauth?.clientId ? void 0 : cimdFn(redirectUrl),
+        clientId: oauth?.clientId,
+        clientSecret: oauth?.clientSecret,
+        store,
+        onRedirect() {
+        }
+      });
+      const result = await authorizeMcp(provider, {
+        serverUrl,
+        authorizationServerMetadataUrl: oauth?.authServerMetadataUrl ? new URL(oauth.authServerMetadataUrl) : void 0,
+        fetch: timedFetch(platform2.fetch)
+      });
+      if (result === "REDIRECT") throw new McpOAuthAuthorizationRequiredError();
+    })().finally(() => {
+      refreshing = void 0;
+    });
+    return refreshing;
+  };
+  return {
+    async token() {
+      await refreshing?.catch(() => void 0);
+      const state = await store.load();
+      const token = state?.tokens?.access_token;
+      const expired = state?.tokensExpireAt !== void 0 && state.tokensExpireAt - REFRESH_SKEW_MS <= Date.now();
+      if (!expired || !state?.tokens?.refresh_token) return token;
+      await refresh(token).catch(() => void 0);
+      return (await store.load())?.tokens?.access_token;
+    },
+    async onUnauthorized(context) {
+      const challenge = parseWwwAuthenticate(context.response.headers.get("www-authenticate"));
+      if (challenge.error === "insufficient_scope") {
+        throw new AuthStepUpError(challenge.scope, options.name);
+      }
+      await refresh(context.token);
+    }
+  };
+}
 
 // node_modules/@earendil-works/pi-mcp/dist/client.js
 var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
@@ -6257,21 +7144,21 @@ async function consumeSseStream(stream, options) {
     if (line.startsWith(":"))
       return;
     const colon = line.indexOf(":");
-    const field = colon < 0 ? line : line.slice(0, colon);
+    const field2 = colon < 0 ? line : line.slice(0, colon);
     let value = colon < 0 ? "" : line.slice(colon + 1);
     if (value.startsWith(" "))
       value = value.slice(1);
-    if (field === "data") {
+    if (field2 === "data") {
       dataBytes += Buffer.byteLength(value) + (dataLines.length > 0 ? 1 : 0);
       if (dataBytes > maxEventBytes)
         throw new Error(`MCP SSE event exceeds ${maxEventBytes} bytes`);
       dataLines.push(value);
-    } else if (field === "event")
+    } else if (field2 === "event")
       eventName = value;
-    else if (field === "id" && !value.includes("\0")) {
+    else if (field2 === "id" && !value.includes("\0")) {
       eventId = value;
       options.onId?.(value);
-    } else if (field === "retry" && /^\d+$/.test(value))
+    } else if (field2 === "retry" && /^\d+$/.test(value))
       options.onRetry?.(Number(value));
   };
   try {
@@ -6334,7 +7221,7 @@ function needsAuthorization(response) {
 function isTransientStatus(status) {
   return status === 408 || status === 429 || status >= 500;
 }
-function discard(response) {
+function discard2(response) {
   return response.body?.cancel().catch(() => {
   }) ?? Promise.resolve();
 }
@@ -6385,7 +7272,7 @@ var StreamableHttpTransport = class extends TransportEvents {
     await this.checkResponse(response);
     this.captureSession(response);
     if (!isJsonRpcRequest(message)) {
-      await discard(response);
+      await discard2(response);
       if ("method" in message && message.method === "notifications/initialized")
         this.startGetStream();
       return;
@@ -6404,7 +7291,7 @@ var StreamableHttpTransport = class extends TransportEvents {
       void this.consumeResponseStream(response.body, message.id);
       return;
     }
-    await discard(response);
+    await discard2(response);
     throw new McpHttpError(response.status, `Unsupported MCP response content type: ${type ?? "missing"}`);
   }
   async close() {
@@ -6419,7 +7306,7 @@ var StreamableHttpTransport = class extends TransportEvents {
           headers: this.buildHeaders({}, this.lastToken),
           signal: AbortSignal.timeout(1e3)
         });
-        await discard(response);
+        await discard2(response);
       } catch {
       }
     }
@@ -6450,7 +7337,7 @@ var StreamableHttpTransport = class extends TransportEvents {
       try {
         await onUnauthorized({ response, serverUrl: this.url, fetch: this.fetch, token });
       } finally {
-        await discard(response);
+        await discard2(response);
       }
     }
   }
@@ -6607,14 +7494,14 @@ var StreamableHttpTransport = class extends TransportEvents {
       }
     });
     if (response.status === 405) {
-      await discard(response);
+      await discard2(response);
       return void 0;
     }
     await this.checkResponse(response);
     this.captureSession(response);
     const type = contentType(response);
     if (type !== "text/event-stream" || !response.body) {
-      await discard(response);
+      await discard2(response);
       throw new McpHttpError(response.status, `Unsupported MCP GET response content type: ${type ?? "missing"}`);
     }
     return response.body;
@@ -7085,7 +7972,8 @@ function buildTransport(options) {
     return new StreamableHttpTransport({
       url: options.url,
       headers: options.headers,
-      fetch: options.fetchImpl
+      fetch: options.fetchImpl,
+      authProvider: options.authProvider
     });
   }
   if (!options.command) throw new Error("PiConnection requires either a url or a command");
@@ -7197,6 +8085,18 @@ async function connect(platform2, options) {
     });
   }
   if (!options.url) throw new Error("connect requires either a url or a command");
+  if (options.authProvider) {
+    const token = await options.authProvider.token();
+    if (token) {
+      return createPiConnection({
+        url: options.url,
+        headers: options.headers,
+        fetchImpl: platform2.fetch,
+        authProvider: options.authProvider,
+        ...shared
+      });
+    }
+  }
   if (options.protocolVersion && !options.protocolVersion.startsWith("2026")) {
     return createPiConnection({
       url: options.url,
@@ -7223,6 +8123,7 @@ async function connect(platform2, options) {
         url: options.url,
         headers: options.headers,
         fetchImpl: platform2.fetch,
+        authProvider: options.authProvider,
         ...shared
       });
     }
@@ -7697,8 +8598,8 @@ async function formatOutput(platform2, result, json) {
   return result.ok ? 0 : isTimeout ? 124 : 1;
 }
 async function createSandbox(platform2, tools, globals, timeoutMs) {
-  const isKernel = platform2.packageDir !== void 0;
-  if (isKernel) {
+  const isKernel2 = platform2.packageDir !== void 0;
+  if (isKernel2) {
     const { InlineCodemodeSandbox: InlineCodemodeSandbox2 } = await Promise.resolve().then(() => (init_portable(), portable_exports));
     const wasm = await loadWasmKernel(platform2);
     return new InlineCodemodeSandbox2({ tools, globals, timeoutMs, wasm });
@@ -7823,8 +8724,8 @@ function resolveAliases(value) {
   }
   return out;
 }
-function fail(server, message, field) {
-  return { server, ...field ? { field } : {}, message };
+function fail(server, message, field2) {
+  return { server, ...field2 ? { field: field2 } : {}, message };
 }
 function validateCommon(name, value) {
   const exposures = EXPOSURES.map((e) => `"${e}"`).join(", ");
@@ -9245,7 +10146,7 @@ function argvForCommand(command, args2) {
   if (args2.error) return { error: args2.error };
   const argv = [...command.path];
   for (const positional of command.positionals) {
-    const found = args2.fields.find((field) => field.name === positional.name);
+    const found = args2.fields.find((field2) => field2.name === positional.name);
     if (!found) {
       if (positional.required) return { error: `missing ${positional.name}` };
       continue;
@@ -9264,7 +10165,7 @@ function argvForCommand(command, args2) {
 function appendFlags(flags, fields) {
   const argv = [];
   for (const flag of flags) {
-    const found = fields.find((field) => field.name === flag.name);
+    const found = fields.find((field2) => field2.name === flag.name);
     if (!found || found.value === false) continue;
     const encoded = encodeFlag(flag, found.value);
     if ("error" in encoded) return encoded;
@@ -10973,6 +11874,478 @@ async function handleMcpRequest(request, tools, call, serverName, version, allow
   };
 }
 
+// src/auth/oauth.ts
+var CALLBACK_HOST2 = "127.0.0.1";
+var CALLBACK_PATH2 = "/callback";
+var CIMD_URL2 = "https://mcpcat.sliccy.ai/oauth/client.json";
+var CLIENT_NAME2 = "mcpcat";
+var REQUEST_TIMEOUT_MS2 = 15e3;
+function timedFetch2(fetchImpl) {
+  return (input, init) => {
+    const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS2);
+    return fetchImpl(input, {
+      ...init,
+      signal: init?.signal ? AbortSignal.any([init.signal, timeout]) : timeout
+    });
+  };
+}
+function callbackSettings(oauth) {
+  const raw = oauth?.callbackUrl ?? `http://${CALLBACK_HOST2}${CALLBACK_PATH2}`;
+  const url = new URL(raw);
+  const address = url.hostname.replace(/^\[|\]$/g, "");
+  const port = url.port ? Number(url.port) : oauth?.callbackPort;
+  let fixedRedirectUrl;
+  if (url.port) fixedRedirectUrl = oauth?.callbackUrl;
+  else if (port !== void 0) {
+    url.port = String(port);
+    fixedRedirectUrl = url.href;
+  }
+  return {
+    host: address === "localhost" ? CALLBACK_HOST2 : address,
+    redirectHost: address,
+    port,
+    path: url.pathname,
+    fixedRedirectUrl
+  };
+}
+function cimdForServer(metadata, redirectUrl) {
+  if (!metadata?.client_id_metadata_document_supported) return void 0;
+  if (!metadata.token_endpoint_auth_methods_supported?.includes("none")) return void 0;
+  if (!metadata.authorization_response_iss_parameter_supported) return void 0;
+  return {
+    url: CIMD_URL2,
+    redirectUrl
+  };
+}
+function buildClientMetadataDocumentFn(oauth, redirectUrl) {
+  if (oauth?.clientRegistration === "dcr") return void 0;
+  if (oauth?.clientId) return void 0;
+  return (metadata) => {
+    if (oauth?.clientRegistration === "cimd") {
+      if (!metadata?.client_id_metadata_document_supported || !metadata.token_endpoint_auth_methods_supported?.includes("none")) {
+        return void 0;
+      }
+      if (!metadata.authorization_response_iss_parameter_supported) return void 0;
+      return { url: CIMD_URL2, redirectUrl };
+    }
+    return cimdForServer(metadata, redirectUrl);
+  };
+}
+function createProvider(serverUrl, store, oauth, redirectUrl, onRedirect) {
+  const cimdFn2 = buildClientMetadataDocumentFn(oauth, redirectUrl);
+  return new McpOAuthProvider({
+    serverUrl,
+    redirectUrl,
+    clientMetadata: { client_name: oauth?.clientName ?? CLIENT_NAME2 },
+    clientMetadataDocument: cimdFn2,
+    clientId: oauth?.clientId,
+    clientSecret: oauth?.clientSecret,
+    store,
+    onRedirect
+  });
+}
+var SourceBackedStateStore = class {
+  source;
+  name;
+  serverUrl;
+  constructor(source, name, serverUrl) {
+    this.source = source;
+    this.name = name;
+    this.serverUrl = serverUrl;
+  }
+  async load() {
+    return this.source.load(this.name, this.serverUrl);
+  }
+  async save(state) {
+    await this.source.save(this.name, this.serverUrl, state);
+  }
+};
+var SignInCancelledError = class extends Error {
+  constructor() {
+    super("Sign-in cancelled");
+    this.name = "SignInCancelledError";
+  }
+};
+function responseFromRedirectUrl(input, state, redirectUrl) {
+  let url;
+  try {
+    url = new URL(input.trim());
+  } catch {
+    throw new Error("Expected the full redirect URL from the browser address bar");
+  }
+  if (url.origin !== redirectUrl.origin || url.pathname !== redirectUrl.pathname) {
+    throw new Error("The redirect URL does not match this sign-in's redirect URI");
+  }
+  const error = url.searchParams.get("error");
+  if (error) throw new Error(url.searchParams.get("error_description") ?? error);
+  if (url.searchParams.get("state") !== state) {
+    throw new Error("The redirect URL belongs to a different sign-in");
+  }
+  const code2 = url.searchParams.get("code");
+  if (!code2) throw new Error("The redirect URL does not contain an authorization code");
+  return { code: code2, iss: url.searchParams.get("iss") ?? void 0 };
+}
+async function waitForAuthorizationResponse(callback, state, redirectUrl, prompt, signal) {
+  const controller = new AbortController();
+  const promptSignal = signal ? AbortSignal.any([controller.signal, signal]) : controller.signal;
+  const fromBrowser = callback.waitForCallback(state, redirectUrl.pathname);
+  const fromUser = prompt.promptForRedirectUrl(promptSignal).then((input) => {
+    if (!input?.trim()) throw new SignInCancelledError();
+    return responseFromRedirectUrl(input, state, redirectUrl);
+  });
+  try {
+    return await Promise.race([fromBrowser, fromUser]);
+  } finally {
+    controller.abort();
+    fromBrowser.catch(() => void 0);
+    fromUser.catch(() => void 0);
+  }
+}
+function mergeScopes(...scopes) {
+  const merged = [...new Set(scopes.flatMap((s) => s?.split(/\s+/).filter(Boolean) ?? []))];
+  return merged.length > 0 ? merged.join(" ") : void 0;
+}
+async function signIn(options) {
+  const { name, serverUrl, source, oauth, prompt, platform: platform2, signal } = options;
+  if (signal?.aborted) throw new SignInCancelledError();
+  const store = new SourceBackedStateStore(source, name, serverUrl);
+  const stored = await store.load();
+  const cbSettings = callbackSettings(oauth);
+  const registered = stored?.clientInformation && "redirect_uris" in stored.clientInformation ? stored.clientInformation.redirect_uris : [];
+  const preferredPort = cbSettings.port ?? (registered[0] ? Number(new URL(registered[0]).port) || void 0 : void 0);
+  const callback = await OAuthCallbackServer.listen({
+    host: cbSettings.host,
+    redirectHost: cbSettings.redirectHost,
+    port: preferredPort ?? 0,
+    path: cbSettings.path
+  });
+  const redirectUrl = cbSettings.fixedRedirectUrl ?? callback.redirectUrl;
+  try {
+    if (stored) {
+      const next = { ...stored };
+      delete next.oauthState;
+      const hasCimd = buildClientMetadataDocumentFn(oauth, redirectUrl) !== void 0;
+      const keepClient = oauth?.clientId || (hasCimd ? !stored.clientInformation : registered.includes(redirectUrl));
+      if (!keepClient) {
+        delete next.clientInformation;
+        delete next.tokens;
+        delete next.tokensExpireAt;
+      }
+      await store.save(next);
+    }
+    let authorizationUrl;
+    const provider = createProvider(serverUrl, store, oauth, redirectUrl, (url) => {
+      authorizationUrl = url;
+    });
+    const flow = {
+      serverUrl,
+      fetch: timedFetch2(platform2.fetch),
+      signal,
+      authorizationServerMetadataUrl: oauth?.authServerMetadataUrl ? new URL(oauth.authServerMetadataUrl) : void 0,
+      scope: mergeScopes(
+        oauth?.scope,
+        options.stepUp ? stepUpScope(stored?.tokens?.scope, options.scope) : options.scope
+      )
+    };
+    const skipRefresh = options.stepUp === true;
+    if (await authorizeMcp(provider, { ...flow, skipRefresh }) === "AUTHORIZED") return;
+    if (!authorizationUrl) throw new Error("OAuth flow did not produce an authorization URL");
+    const state = await provider.state();
+    const authRedirectUrl = new URL(
+      authorizationUrl.searchParams.get("redirect_uri") ?? redirectUrl
+    );
+    prompt.showAuthorizationUrl(authorizationUrl);
+    const { code: code2, iss } = await waitForAuthorizationResponse(
+      callback,
+      state,
+      authRedirectUrl,
+      prompt,
+      signal
+    );
+    await authorizeMcp(provider, { ...flow, authorizationCode: code2, iss });
+  } catch (err) {
+    if (signal?.aborted) throw new SignInCancelledError();
+    throw err;
+  } finally {
+    await callback.close();
+  }
+}
+
+// src/auth/token-source.ts
+function mcpNamespace(server) {
+  return `mcp__${server.replace(/-/g, "_")}`;
+}
+function storeKey(name, serverUrl) {
+  const ns = mcpNamespace(name);
+  const url = String(new URL(serverUrl));
+  return `${ns}|${url}`;
+}
+function isKernel(platform2) {
+  return platform2.kind === "kernel";
+}
+
+// src/auth/pi-store.ts
+var AUTH_FILE = "mcp-auth.json";
+var FILE_MODE = 384;
+function parseStates(raw) {
+  if (!raw?.trim()) return {};
+  const parsed = JSON.parse(raw);
+  return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : {};
+}
+function serializeStates(states) {
+  return `${JSON.stringify(states, null, 2)}
+`;
+}
+function legacyKey(serverUrl) {
+  return String(new URL(serverUrl));
+}
+var PiFileTokenSource = class {
+  platform;
+  authPath;
+  dirPath;
+  constructor(platform2) {
+    this.platform = platform2;
+    this.dirPath = userConfigDir(platform2);
+    this.authPath = `${this.dirPath}/${AUTH_FILE}`;
+  }
+  get path() {
+    return this.authPath;
+  }
+  async getToken(name, serverUrl) {
+    const state = await this.load(name, serverUrl);
+    if (!state?.tokens?.access_token) return void 0;
+    return {
+      accessToken: state.tokens.access_token,
+      expiresAt: state.tokensExpireAt
+    };
+  }
+  async load(name, serverUrl) {
+    const key = storeKey(name, serverUrl);
+    const legacy = legacyKey(serverUrl);
+    const release = await this.acquireLock();
+    try {
+      const raw = await this.readRaw();
+      const states = parseStates(raw);
+      if (states[key]) return states[key];
+      if (states[legacy]) {
+        states[key] = states[legacy];
+        delete states[legacy];
+        await this.writeStates(states);
+        return states[key];
+      }
+      return void 0;
+    } finally {
+      await release();
+    }
+  }
+  async save(name, serverUrl, state) {
+    const key = storeKey(name, serverUrl);
+    const release = await this.acquireLock();
+    try {
+      const raw = await this.readRaw();
+      const states = parseStates(raw);
+      states[key] = state;
+      await this.writeStates(states);
+    } finally {
+      await release();
+    }
+  }
+  async remove(name, serverUrl) {
+    const key = storeKey(name, serverUrl);
+    const legacy = legacyKey(serverUrl);
+    const release = await this.acquireLock();
+    try {
+      const raw = await this.readRaw();
+      const states = parseStates(raw);
+      const stored = key in states ? key : legacy in states ? legacy : void 0;
+      if (!stored) return false;
+      delete states[stored];
+      await this.writeStates(states);
+      return true;
+    } finally {
+      await release();
+    }
+  }
+  async acquireLock() {
+    await this.ensureDir();
+    return acquireLock(this.platform.fs, this.authPath);
+  }
+  async ensureDir() {
+    try {
+      await this.platform.fs.mkdir(this.dirPath);
+    } catch {
+    }
+  }
+  async readRaw() {
+    try {
+      const data = await this.platform.fs.readFile(this.authPath);
+      return new TextDecoder().decode(data);
+    } catch {
+      return void 0;
+    }
+  }
+  async writeStates(states) {
+    await this.platform.fs.writeFile(this.authPath, serializeStates(states), { mode: FILE_MODE });
+  }
+};
+
+// src/cli/auth-verbs.ts
+function createTokenSource(platform2) {
+  return new PiFileTokenSource(platform2);
+}
+function resolveServerName(target) {
+  try {
+    const u = new URL(target.startsWith("http") ? target : `https://${target}`);
+    if (target.includes(".") || target.includes(":")) {
+      return { name: `url:${u.origin}${u.pathname}`, isUrl: true };
+    }
+  } catch {
+  }
+  return { name: target, isUrl: false };
+}
+async function resolveLoginTarget(platform2, target) {
+  const config = await MergedConfigSource.load(platform2);
+  const entry = config.entry(target);
+  if (entry && "url" in entry.config && entry.config.url) {
+    const httpConfig = entry.config;
+    return {
+      name: target,
+      serverUrl: httpConfig.url,
+      oauth: httpConfig.oauth
+    };
+  }
+  const resolved = resolveServerName(target);
+  if (resolved.isUrl) {
+    const url = target.startsWith("http") ? target : `https://${target}`;
+    return { name: resolved.name, serverUrl: url, oauth: void 0 };
+  }
+  throw new Error(`unknown target '${target}': not a URL and not found in mcp.json`);
+}
+async function runLogin(platform2, args2, source) {
+  if (isKernel(platform2)) {
+    await platform2.write(
+      2,
+      "mcpcat: login is not available in seven. Use the agent's MCP sign-in in Settings, or run mcpcat login on the host.\n"
+    );
+    return 4;
+  }
+  const noBrowser = args2.includes("--no-browser");
+  const positional = args2.filter((a) => !a.startsWith("-"));
+  if (positional.length === 0) {
+    await platform2.write(2, "mcpcat: login requires a target\n");
+    return 2;
+  }
+  const target = positional[0];
+  let resolved;
+  try {
+    resolved = await resolveLoginTarget(platform2, target);
+  } catch (err) {
+    await platform2.write(2, `mcpcat: ${err.message}
+`);
+    return 2;
+  }
+  try {
+    await signIn({
+      name: resolved.name,
+      serverUrl: resolved.serverUrl,
+      source,
+      oauth: resolved.oauth,
+      platform: platform2,
+      prompt: {
+        showAuthorizationUrl(url) {
+          if (!noBrowser && platform2.openUrl) {
+            platform2.openUrl(url.href).catch(() => {
+            });
+          }
+          void platform2.write(2, `Open this URL to sign in:
+${url.href}
+`);
+          if (noBrowser || !platform2.openUrl) {
+            void platform2.write(2, "\nPaste the redirect URL from your browser address bar:\n");
+          }
+        },
+        async promptForRedirectUrl(signal) {
+          if (!noBrowser && platform2.openUrl) {
+            return new Promise((_resolve, reject) => {
+              signal.addEventListener("abort", () => reject(new SignInCancelledError()));
+            });
+          }
+          const reader = platform2.stdin.getReader();
+          const chunks = [];
+          try {
+            while (true) {
+              const read = reader.read();
+              const result = await Promise.race([
+                read,
+                new Promise((_, reject) => {
+                  signal.addEventListener("abort", () => reject(new SignInCancelledError()));
+                })
+              ]);
+              if (result.done) break;
+              chunks.push(result.value);
+              const text = new TextDecoder().decode(concatUint8Arrays(chunks));
+              if (text.includes("\n")) return text.trim();
+            }
+          } finally {
+            reader.releaseLock();
+          }
+          return new TextDecoder().decode(concatUint8Arrays(chunks)).trim() || void 0;
+        }
+      }
+    });
+    await platform2.write(1, `Signed in to ${target}
+`);
+    return 0;
+  } catch (err) {
+    if (err instanceof SignInCancelledError) {
+      await platform2.write(2, "mcpcat: sign-in cancelled\n");
+      return 1;
+    }
+    await platform2.write(2, `mcpcat: login failed: ${err.message}
+`);
+    return 4;
+  }
+}
+async function runLogout(platform2, args2, source) {
+  if (isKernel(platform2)) {
+    await platform2.write(2, "mcpcat: logout is not available in seven.\n");
+    return 4;
+  }
+  const positional = args2.filter((a) => !a.startsWith("-"));
+  if (positional.length === 0) {
+    await platform2.write(2, "mcpcat: logout requires a target\n");
+    return 2;
+  }
+  const target = positional[0];
+  let resolved;
+  try {
+    resolved = await resolveLoginTarget(platform2, target);
+  } catch (err) {
+    await platform2.write(2, `mcpcat: ${err.message}
+`);
+    return 2;
+  }
+  const removed = await source.remove(resolved.name, resolved.serverUrl);
+  if (removed) {
+    await platform2.write(1, `Signed out of ${target}
+`);
+  } else {
+    await platform2.write(1, `No credentials stored for ${target}
+`);
+  }
+  return 0;
+}
+function concatUint8Arrays(arrays) {
+  const total = arrays.reduce((s, a) => s + a.length, 0);
+  const result = new Uint8Array(total);
+  let offset = 0;
+  for (const a of arrays) {
+    result.set(a, offset);
+    offset += a.length;
+  }
+  return result;
+}
+
 // src/config/import.ts
 function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -11916,16 +13289,7 @@ var CONFIG_VERBS = {
   exposure: true,
   import: true
 };
-var UNIMPLEMENTED_VERBS = /* @__PURE__ */ new Set([
-  "resources",
-  "read",
-  "prompts",
-  "prompt",
-  "complete",
-  "task",
-  "login",
-  "logout"
-]);
+var UNIMPLEMENTED_VERBS = /* @__PURE__ */ new Set(["resources", "read", "prompts", "prompt", "complete", "task"]);
 var CLIENT_VERBS = /* @__PURE__ */ new Set(["info", "tools", "call", "describe", "serve"]);
 function helpText(version) {
   return `mcpcat ${version} \u2013 a curl for the Model Context Protocol
@@ -11949,8 +13313,8 @@ Configuration verbs:
   enable|disable <name>      Toggle a server
   exposure <name> <mode>     Set exposure mode
   import <file>              Import from other configs
-  login <target>             OAuth sign-in (not implemented yet)
-  logout <target>            Remove tokens (not implemented yet)
+  login <target>             OAuth sign-in
+  logout <target>            Remove stored tokens
 
 Server and code verbs:
   serve [--stdio|--http] \u2026   Expose commands or proxy upstream as MCP server
@@ -12541,6 +13905,14 @@ async function run(platform2, version, args2) {
   }
   const discResult = await dispatchDiscoveryVerb(platform2, parsed, args2);
   if (discResult !== void 0) return discResult;
+  if (parsed.verb === "login") {
+    const source = createTokenSource(platform2);
+    return runLogin(platform2, args2.slice(1), source);
+  }
+  if (parsed.verb === "logout") {
+    const source = createTokenSource(platform2);
+    return runLogout(platform2, args2.slice(1), source);
+  }
   if (UNIMPLEMENTED_VERBS.has(parsed.verb)) {
     await platform2.write(2, `mcpcat: '${parsed.verb}' is not implemented yet
 `);
@@ -12589,6 +13961,17 @@ function classifyError(err) {
   if (err instanceof McpAuthError) {
     return { code: EXIT_AUTH, kind: "auth", msg: err.message };
   }
+  if (err instanceof AuthStepUpError) {
+    const scopeHint = err.scope ? ` --scope ${err.scope}` : "";
+    return {
+      code: EXIT_AUTH,
+      kind: "auth",
+      msg: `insufficient scope. Run: mcpcat login ${err.target ?? "<target>"}${scopeHint}`
+    };
+  }
+  if (err.name === "McpOAuthAuthorizationRequiredError" || err.name === "McpAuthRequiredError") {
+    return { code: EXIT_AUTH, kind: "auth", msg: err.message };
+  }
   if (err instanceof McpcatError) {
     return { code: err.exitCode, kind: "error", msg: err.message };
   }
@@ -12599,6 +13982,14 @@ function classifyError(err) {
   }
   return { code: EXIT_RPC_ERROR, kind: "rpc_error", msg };
 }
+function resolveAuthProvider(platform2, hasAuthHeader, url, target, config) {
+  if (hasAuthHeader || !url) return void 0;
+  const source = createTokenSource(platform2);
+  const entry = config.entry(target);
+  const oauth = entry && "url" in entry.config ? entry.config.oauth : void 0;
+  const name = entry ? target : `url:${new URL(url).origin}${new URL(url).pathname}`;
+  return createMcpAuthProvider({ name, serverUrl: url, source, oauth, platform: platform2 });
+}
 async function runClientVerb(platform2, version, parsed) {
   const { expanded, secrets } = expandAndCollect(parsed.headers, platform2.env);
   const verbose = createVerboseLogger(platform2, parsed.verbose);
@@ -12628,6 +14019,8 @@ async function runClientVerb(platform2, version, parsed) {
     await writeErr(platform2, parsed.jsonOutput, "usage", err.message);
     return EXIT_USAGE;
   }
+  const hasAuthHeader = "Authorization" in expanded;
+  const authProvider = resolveAuthProvider(platform2, hasAuthHeader, resolved.url, target, config);
   let conn;
   try {
     conn = await connect(platform2, {
@@ -12637,11 +14030,22 @@ async function runClientVerb(platform2, version, parsed) {
       version,
       timeoutMs,
       signal: sigintController.signal,
-      verbose
+      verbose,
+      authProvider
     });
   } catch (err) {
-    if (err instanceof McpAuthError) {
-      await writeErr(platform2, parsed.jsonOutput, "auth", err.message);
+    if (err instanceof McpAuthError || err instanceof AuthStepUpError) {
+      const e = classifyError(err);
+      await writeErr(platform2, parsed.jsonOutput, e.kind, e.msg);
+      return EXIT_AUTH;
+    }
+    if (err.name === "McpOAuthAuthorizationRequiredError" || err.name === "McpAuthRequiredError") {
+      await writeErr(
+        platform2,
+        parsed.jsonOutput,
+        "auth",
+        `unauthorized. Run: mcpcat login ${target}`
+      );
       return EXIT_AUTH;
     }
     const msg = transportHint(err) ?? `connection failed: ${err.message}`;
@@ -12677,7 +14081,7 @@ async function writeErr(p, json, kind, msg) {
 import { spawn as cpSpawn } from "node:child_process";
 import { constants } from "node:fs";
 import { access, mkdir, readFile as readFile3, rename, rmdir, stat, writeFile } from "node:fs/promises";
-import { createServer } from "node:net";
+import { createServer as createServer2 } from "node:net";
 import { Readable, Writable } from "node:stream";
 import * as tty from "node:tty";
 var USE_PROCESS_GROUPS2 = process.platform !== "win32";
@@ -12736,8 +14140,8 @@ var hostFs = {
   async readFile(path) {
     return new Uint8Array(await readFile3(path));
   },
-  async writeFile(path, data) {
-    await writeFile(path, data);
+  async writeFile(path, data, options) {
+    await writeFile(path, data, options?.mode !== void 0 ? { mode: options.mode } : void 0);
   },
   async mkdir(path) {
     await mkdir(path, { recursive: true });
@@ -12775,7 +14179,7 @@ function createStderrStream() {
 }
 function nodeListen(options) {
   return new Promise((resolve, reject) => {
-    const server = createServer();
+    const server = createServer2();
     const pending = [];
     const ready = [];
     let closed = false;
@@ -12873,5 +14277,5 @@ function createHostPlatform() {
 // src/host.ts
 var platform = createHostPlatform();
 var args = process.argv.slice(2);
-var code = await run(platform, "0.9.0", args);
+var code = await run(platform, "0.10.0", args);
 process.exit(code);