toolcraft 0.0.315 → 0.0.317

package/node_modules/tiny-mcp-client/dist/index.js

@@ -3395,1296 +3395,1444 @@ var SubscriptionManager = class {
   }
 };
 
-// ../mcp-oauth/dist/client/scope.js
-function normalizeOAuthScope(scope) {
-  if (scope === void 0)
-    return void 0;
-  if (typeof scope !== "string" || [...scope].some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) > 126 || char === '"' || char === "\\"))
-    throw new Error("Invalid OAuth scope syntax");
-  const normalized = [...new Set(scope.split(" ").filter(Boolean))].sort().join(" ");
-  return normalized || void 0;
-}
+// ../mcp-oauth/dist/client/loopback-authorization.js
+import http from "node:http";
 
-// ../mcp-oauth/dist/client/token-auth-method.js
-function normalizeOAuthTokenEndpointAuthMethod(value) {
-  if (value === void 0 || value === null)
-    return void 0;
-  if (value !== "none" && value !== "client_secret_post" && value !== "client_secret_basic")
-    throw new Error("Unsupported OAuth token endpoint authentication method");
-  return value;
+// ../mcp-oauth/dist/client/authorization-state.js
+import crypto from "node:crypto";
+function createAuthorizationState(input) {
+  const payload = {
+    v: 1,
+    n: crypto.randomBytes(16).toString("base64url"),
+    i: input.issuer,
+    r: input.requireIssuer
+  };
+  return Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
 }
-
-// ../mcp-oauth/dist/client/client-registration.js
-function parseOAuthClientRegistration(value) {
-  const invalid = () => new Error("Invalid OAuth client registration metadata");
-  let nodes = 0;
-  function copy(input, depth) {
-    if (++nodes > 2e4 || depth > 64)
-      throw invalid();
-    if (input === null || typeof input === "boolean" || typeof input === "string")
-      return input;
-    if (typeof input === "number" && Number.isFinite(input))
-      return input;
-    if (typeof input !== "object" || input === null)
-      throw invalid();
-    const descriptors = Object.getOwnPropertyDescriptors(input);
-    if (Array.isArray(input)) {
-      const length = descriptors.length?.value;
-      if (length > 2e4)
-        throw invalid();
-      const result2 = [];
-      for (let index = 0; index < length; index++) {
-        const descriptor = descriptors[String(index)];
-        if (descriptor === void 0 || !Object.hasOwn(descriptor, "value"))
-          throw invalid();
-        result2.push(copy(descriptor.value, depth + 1));
-      }
-      return result2;
-    }
-    if (Object.getPrototypeOf(input) !== Object.prototype && Object.getPrototypeOf(input) !== null)
-      throw invalid();
-    return Object.fromEntries(Object.entries(descriptors).filter(([, descriptor]) => descriptor.enumerable).map(([key2, descriptor]) => {
-      if (!Object.hasOwn(descriptor, "value"))
-        throw invalid();
-      return [key2, copy(descriptor.value, depth + 1)];
-    }));
-  }
-  let result;
-  try {
-    result = copy(value, 0);
-  } catch {
-    throw invalid();
-  }
-  if (typeof result !== "object" || result === null || Array.isArray(result))
-    throw invalid();
-  const record2 = result;
-  if (!Object.hasOwn(record2, "client_id") || typeof record2.client_id !== "string" || record2.client_id.trim() === "")
-    throw new Error("OAuth client registration response missing client_id");
-  for (const key2 of [
-    "client_id",
-    "client_secret",
-    "token_endpoint_auth_method",
-    "application_type",
-    "client_name",
-    "client_uri",
-    "logo_uri",
-    "scope",
-    "tos_uri",
-    "policy_uri",
-    "jwks_uri",
-    "software_id",
-    "software_version",
-    "software_statement",
-    "registration_access_token",
-    "registration_client_uri",
-    "issuer"
-  ]) {
-    if (Object.hasOwn(record2, key2) && record2[key2] !== null && typeof record2[key2] !== "string")
-      throw invalid();
-  }
-  if (typeof record2.client_secret === "string" && record2.client_secret.trim() === "")
-    throw invalid();
-  for (const key2 of ["redirect_uris", "grant_types", "response_types", "contacts"]) {
-    const entry = record2[key2];
-    if (Object.hasOwn(record2, key2) && entry !== null && (!Array.isArray(entry) || entry.some((item) => typeof item !== "string")))
-      throw invalid();
-  }
-  for (const key2 of ["client_id_issued_at", "client_secret_expires_at"]) {
-    const entry = record2[key2];
-    if (Object.hasOwn(record2, key2) && entry !== null && (typeof entry !== "number" || !Number.isSafeInteger(entry) || entry < 0))
-      throw invalid();
+function parseAuthorizationState(value) {
+  if (value === null || value.length === 0) {
+    return null;
   }
   try {
-    normalizeOAuthScope(Object.hasOwn(record2, "scope") && record2.scope !== null ? record2.scope : void 0);
+    const decoded = Buffer.from(value, "base64url").toString("utf8");
+    const parsed = JSON.parse(decoded);
+    if (!isObjectRecord(parsed)) {
+      return null;
+    }
+    const version = getOwnEntry(parsed, "v");
+    const nonce = getOwnEntry(parsed, "n");
+    const issuer = getOwnEntry(parsed, "i");
+    const requireIssuer = getOwnEntry(parsed, "r");
+    if (version !== 1 || typeof nonce !== "string" || nonce.length === 0 || typeof issuer !== "string" || issuer.length === 0 || typeof requireIssuer !== "boolean") {
+      return null;
+    }
+    return {
+      issuer,
+      requireIssuer
+    };
   } catch {
-    throw invalid();
-  }
-  if (Buffer.byteLength(JSON.stringify(record2), "utf8") > 64 * 1024)
-    throw invalid();
-  return record2;
-}
-function normalizeStoredOAuthClient(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value))
-    return null;
-  const record2 = value;
-  const clientId = Object.hasOwn(record2, "clientId") ? record2.clientId : void 0;
-  const clientSecret = Object.hasOwn(record2, "clientSecret") ? record2.clientSecret : void 0;
-  if (typeof clientId !== "string" || clientId.trim() === "" || clientSecret !== void 0 && (typeof clientSecret !== "string" || clientSecret.trim() === ""))
     return null;
-  const client = { clientId: clientId.trim(), ...clientSecret === void 0 ? {} : { clientSecret: clientSecret.trim() } };
-  const method = normalizeOAuthTokenEndpointAuthMethod(Object.hasOwn(record2, "tokenEndpointAuthMethod") ? record2.tokenEndpointAuthMethod : void 0);
-  if (Object.hasOwn(record2, "registration") && record2.registration !== void 0) {
-    const registration = parseOAuthClientRegistration(record2.registration);
-    const registeredSecret = Object.hasOwn(registration, "client_secret") ? registration.client_secret?.trim() : void 0;
-    if (registration.client_id.trim() !== client.clientId || registeredSecret !== client.clientSecret)
-      throw new Error("OAuth client registration does not match the client identity");
-    client.registration = registration;
-    const registrationMethod = normalizeOAuthTokenEndpointAuthMethod(Object.hasOwn(registration, "token_endpoint_auth_method") ? registration.token_endpoint_auth_method : void 0);
-    if (method !== void 0 && registrationMethod !== void 0 && method !== registrationMethod)
-      throw new Error("OAuth token endpoint authentication conflicts with the client registration");
-    if (registrationMethod !== void 0)
-      client.tokenEndpointAuthMethod = registrationMethod;
   }
-  if (method !== void 0)
-    client.tokenEndpointAuthMethod = method;
-  return client;
 }
-
-// ../mcp-oauth/dist/client/auth-store-session-store.js
-import crypto from "node:crypto";
-import path4 from "node:path";
-
-// ../auth-store/dist/encrypted-file-store.js
-import { createCipheriv, createDecipheriv, randomBytes, randomUUID as randomUUID2, scrypt } from "node:crypto";
-import { promises as fs } from "node:fs";
-import { homedir, hostname, userInfo } from "node:os";
-import path2 from "node:path";
-
-// ../auth-store/dist/error-codes.js
-function hasOwnErrorCode(error, code) {
-  return error instanceof Error && Object.prototype.hasOwnProperty.call(error, "code") && error.code === code;
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getOwnEntry(record2, key2) {
+  return Object.prototype.hasOwnProperty.call(record2, key2) ? record2[key2] : void 0;
 }
 
-// ../auth-store/dist/transaction-lock.js
-import { randomUUID } from "node:crypto";
-import path from "node:path";
-async function withSecretStoreFileLock(fs2, lockDirectory, operation, options = {}) {
-  const timeoutMs = options.timeoutMs ?? 3e4;
-  if (!Number.isFinite(timeoutMs) || timeoutMs < 0 || timeoutMs > 2147483647)
-    throw new Error("Invalid secret-store transaction lock timeout");
+// ../mcp-oauth/dist/client/loopback-authorization.js
+async function createLoopbackAuthorizationSession(options = {}) {
   options.signal?.throwIfAborted();
-  const deadline = performance.now() + timeoutMs;
-  const directory = path.resolve(lockDirectory);
-  await assertLockDirectoryPath(fs2, directory);
-  await fs2.mkdir(directory, { recursive: true, mode: 448 });
-  await assertLockDirectoryPath(fs2, directory);
-  const name = `${process.pid}-${randomUUID()}.claim`;
-  const claimPath = path.join(directory, name);
-  const temporaryPath = `${claimPath}.tmp`;
-  let claimed = true;
-  let temporaryCreated = false;
-  let outcome;
+  const timeoutMs = options.timeoutMs ?? 12e4;
+  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2147483647)
+    throw new Error("OAuth authorization timeoutMs must be a positive supported timer interval");
+  const target = loopbackTarget(options);
+  const server = options.createServer ? options.createServer() : http.createServer();
+  const controller = new AbortController();
+  let closed = false;
+  let used = false;
+  const callerAbort = () => controller.abort(options.signal?.reason);
+  const teardown = () => {
+    if (closed)
+      return;
+    closed = true;
+    clearTimeout(timer);
+    options.signal?.removeEventListener("abort", callerAbort);
+    server.closeAllConnections?.();
+    server.close();
+  };
+  const timer = setTimeout(() => controller.abort(new Error("OAuth authorization timed out")), timeoutMs);
+  timer.unref?.();
+  controller.signal.addEventListener("abort", teardown, { once: true });
+  options.signal?.addEventListener("abort", callerAbort, { once: true });
+  if (options.signal?.aborted)
+    callerAbort();
+  let port;
   try {
-    try {
-      await fs2.writeFile(claimPath, JSON.stringify({ ticket: null }), { encoding: "utf8", flag: "wx", mode: 384 });
-    } catch (error) {
-      if (hasOwnErrorCode(error, "EEXIST"))
-        claimed = false;
-      throw error;
+    port = await startServer(server, target.port, target.host, controller.signal);
+  } catch (error) {
+    controller.abort(error);
+    throw error;
+  }
+  const redirectUri = options.redirectUri ?? `http://127.0.0.1:${port}${target.callbackPath}`;
+  return {
+    redirectUri,
+    async waitForCode(authorizationUrl) {
+      controller.signal.throwIfAborted();
+      if (used)
+        throw new Error("OAuth authorization session has already been used");
+      used = true;
+      try {
+        return await waitForAuthorizationCode(server, authorizationUrl, options, target.callbackPath, controller.signal);
+      } finally {
+        clearTimeout(timer);
+      }
+    },
+    close() {
+      controller.abort(new Error("OAuth authorization session closed"));
     }
-    const existing = await readClaims(fs2, directory, name);
-    const ticket = existing.reduce((max, claim) => Math.max(max, claim.ticket ?? 0), 0) + 1;
-    if (!Number.isSafeInteger(ticket))
-      throw new Error("Secret-store transaction lock ticket overflow");
-    temporaryCreated = true;
+  };
+}
+function loopbackTarget(options) {
+  if (options.redirectUri !== void 0) {
+    let url;
     try {
-      await fs2.writeFile(temporaryPath, JSON.stringify({ ticket }), { encoding: "utf8", flag: "wx", mode: 384 });
-    } catch (error) {
-      if (hasOwnErrorCode(error, "EEXIST"))
-        temporaryCreated = false;
-      throw error;
-    }
-    await fs2.rename(temporaryPath, claimPath);
-    temporaryCreated = false;
-    for (; ; ) {
-      options.signal?.throwIfAborted();
-      const peers = await readClaims(fs2, directory, name);
-      if (!peers.some((peer) => peer.ticket === null || peer.ticket < ticket || peer.ticket === ticket && peer.name < name))
-        break;
-      const remaining = deadline - performance.now();
-      if (remaining <= 0)
-        throw new Error("Timed out waiting for secret-store transaction lock");
-      await new Promise((resolve, reject) => {
-        const abort = () => {
-          clearTimeout(timer);
-          options.signal?.removeEventListener("abort", abort);
-          reject(options.signal?.reason);
-        };
-        const timer = setTimeout(() => {
-          options.signal?.removeEventListener("abort", abort);
-          resolve();
-        }, Math.min(10, remaining));
-        options.signal?.addEventListener("abort", abort, { once: true });
-        if (options.signal?.aborted)
-          abort();
-      });
+      url = new URL(options.redirectUri);
+    } catch (cause) {
+      throw new Error("Invalid OAuth loopback redirect URI", { cause });
     }
-    options.signal?.throwIfAborted();
-    outcome = { result: await operation() };
-  } catch (error) {
-    outcome = { error };
+    const forbiddenQuery = ["code", "state", "error", "error_description", "iss"];
+    if (url.protocol !== "http:" || !["localhost", "127.0.0.1", "[::1]"].includes(url.hostname) || url.username || url.password || url.hash || url.port === "0" || forbiddenQuery.some((name) => url.searchParams.has(name)) || [...options.redirectUri].some((char) => char.codePointAt(0) <= 32) || options.callbackPath !== void 0 && options.callbackPath !== url.pathname)
+      throw new Error("Invalid OAuth loopback redirect URI");
+    return { port: url.port ? Number(url.port) : 80, host: url.hostname === "[::1]" ? "::1" : url.hostname, callbackPath: url.pathname };
   }
-  const cleanup = [];
-  for (const target of [...temporaryCreated ? [temporaryPath] : [], ...claimed ? [claimPath] : []]) {
+  const callbackPath = options.callbackPath ?? "/callback";
+  const parsed = new URL(callbackPath, "http://127.0.0.1");
+  if (!callbackPath.startsWith("/") || parsed.origin !== "http://127.0.0.1" || parsed.pathname !== callbackPath || parsed.search || parsed.hash)
+    throw new Error("Invalid OAuth loopback callback path");
+  return { port: 0, host: "127.0.0.1", callbackPath };
+}
+async function startServer(server, port, host, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      server.off("error", handleError);
+      signal.removeEventListener("abort", aborted);
+    };
+    const handleError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const aborted = () => {
+      cleanup();
+      reject(signal.reason);
+    };
+    server.once("error", handleError);
+    signal.addEventListener("abort", aborted, { once: true });
     try {
-      await fs2.unlink(target);
+      server.listen(port, host, () => {
+        cleanup();
+        if (signal.aborted) {
+          server.close();
+          reject(signal.reason);
+          return;
+        }
+        const address = server.address();
+        if (address === null || typeof address === "string") {
+          reject(new Error("OAuth listener has no TCP address"));
+          return;
+        }
+        resolve(address.port);
+      });
     } catch (error) {
-      if (!hasOwnErrorCode(error, "ENOENT"))
-        cleanup.push(error);
+      cleanup();
+      reject(error);
     }
-  }
-  if (cleanup.length)
-    throw new AggregateError([..."error" in outcome ? [outcome.error] : [], ...cleanup], "Secret-store transaction lock cleanup failed");
-  if ("error" in outcome)
-    throw outcome.error;
-  return outcome.result;
+  });
 }
-async function assertNoSymbolicLink(fs2, target) {
+function waitForAuthorizationCode(server, authorizationUrl, options, callbackPath, signal) {
+  signal.throwIfAborted();
+  const expectedAuthorization = readExpectedAuthorizationCallback(authorizationUrl);
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const settle = (fn) => {
+      if (settled)
+        return;
+      settled = true;
+      server.off("request", request);
+      signal.removeEventListener("abort", aborted);
+      fn();
+    };
+    const aborted = () => settle(() => reject(signal.reason));
+    const request = (req, res) => {
+      let url;
+      try {
+        url = new URL(req.url ?? "/", "http://127.0.0.1");
+      } catch {
+        res.writeHead(400);
+        res.end("Invalid callback URL");
+        return;
+      }
+      if (url.pathname !== callbackPath) {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      const callbackParameters = {
+        code: url.searchParams.get("code"),
+        error: url.searchParams.get("error"),
+        errorDescription: url.searchParams.get("error_description"),
+        state: url.searchParams.get("state"),
+        iss: url.searchParams.get("iss")
+      };
+      try {
+        validateAuthorizationCallbackBinding(callbackParameters, expectedAuthorization);
+        if (callbackParameters.error !== null)
+          throw createAuthorizationError(callbackParameters.error, callbackParameters.errorDescription ?? callbackParameters.error);
+        const code = validateAuthorizationCallbackParameters(callbackParameters, expectedAuthorization);
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(buildSuccessPage(options.landingPage));
+        settle(() => resolve(code));
+      } catch (error) {
+        res.writeHead(400);
+        res.end(error instanceof Error ? error.message : "Invalid OAuth callback");
+        settle(() => reject(error));
+      }
+    };
+    server.on("request", request);
+    signal.addEventListener("abort", aborted, { once: true });
+    if (options.readLine !== void 0) {
+      void Promise.resolve().then(() => settled ? void 0 : options.readLine()).then((input) => {
+        if (settled)
+          return;
+        const callbackParameters = extractCallbackParametersFromInput(input);
+        if (callbackParameters === null)
+          throw new Error("OAuth callback missing authorization code");
+        validateAuthorizationCallbackBinding(callbackParameters, expectedAuthorization);
+        if (callbackParameters.error !== null)
+          throw createAuthorizationError(callbackParameters.error, callbackParameters.errorDescription ?? callbackParameters.error);
+        const code = validateAuthorizationCallbackParameters(callbackParameters, expectedAuthorization);
+        settle(() => resolve(code));
+      }).catch((error) => settle(() => reject(error)));
+    }
+    if (options.openBrowser !== void 0) {
+      void Promise.resolve().then(() => settled ? void 0 : options.openBrowser(authorizationUrl)).catch((error) => settle(() => reject(error)));
+    }
+  });
+}
+function extractCallbackParametersFromInput(input) {
+  const trimmed = input.replaceAll("\r", "").replaceAll("\n", "").trim();
+  if (trimmed.length === 0) {
+    return null;
+  }
   try {
-    if ((await fs2.lstat(target)).isSymbolicLink())
-      throw new Error("Refusing secret-store transaction lock through symbolic link");
-  } catch (error) {
-    if (!hasOwnErrorCode(error, "ENOENT"))
-      throw error;
+    const url = new URL(trimmed);
+    return {
+      code: url.searchParams.get("code"),
+      error: url.searchParams.get("error"),
+      errorDescription: url.searchParams.get("error_description"),
+      state: url.searchParams.get("state"),
+      iss: url.searchParams.get("iss")
+    };
+  } catch {
+    return {
+      code: trimmed,
+      error: null,
+      errorDescription: null,
+      state: null,
+      iss: null
+    };
   }
 }
-async function assertLockDirectoryPath(fs2, directory) {
-  const root = path.parse(directory).root;
-  const segments = directory.slice(root.length).split(path.sep).filter(Boolean);
-  let current = root;
-  for (const [index, segment] of segments.entries()) {
-    current = path.join(current, segment);
-    if (index > 0 || segments.length === 1)
-      await assertNoSymbolicLink(fs2, current);
+function readExpectedAuthorizationCallback(authorizationUrl) {
+  const url = new URL(authorizationUrl);
+  const state = url.searchParams.get("state");
+  const parsedState = parseAuthorizationState(state);
+  return {
+    state,
+    issuer: parsedState?.issuer ?? null,
+    requireIssuer: parsedState?.requireIssuer ?? false
+  };
+}
+function validateAuthorizationCallbackParameters(callback, expected) {
+  validateAuthorizationCallbackBinding(callback, expected);
+  if (callback.code === null || callback.code.length === 0) {
+    throw new Error("OAuth callback missing authorization code");
   }
+  return callback.code;
 }
-async function readClaims(fs2, directory, ownName) {
-  const claims = [];
-  for (const name of await fs2.readdir(directory)) {
-    if (name === ownName || !name.endsWith(".claim"))
-      continue;
-    const pidText = name.slice(0, name.indexOf("-"));
-    const pid = Number(pidText);
-    if (!Number.isSafeInteger(pid) || pid < 1 || String(pid) !== pidText)
-      throw new Error("Malformed secret-store transaction lock owner");
-    const target = path.join(directory, name);
-    await assertNoSymbolicLink(fs2, target);
-    let alive = true;
-    try {
-      process.kill(pid, 0);
-    } catch (error) {
-      alive = !hasOwnErrorCode(error, "ESRCH");
-    }
-    if (!alive) {
-      try {
-        await fs2.unlink(target);
-      } catch (error) {
-        if (!hasOwnErrorCode(error, "ENOENT"))
-          throw error;
-      }
-      continue;
-    }
-    let ticket = null;
-    let raw;
-    try {
-      raw = await fs2.readFile(target, "utf8");
-    } catch (error) {
-      if (hasOwnErrorCode(error, "ENOENT"))
-        continue;
-      throw error;
+function validateAuthorizationCallbackBinding(callback, expected) {
+  if (expected.state !== null) {
+    if (callback.state === null || callback.state.length === 0) {
+      throw new Error("OAuth callback missing state");
     }
-    try {
-      const value = JSON.parse(raw);
-      if (value !== null && typeof value === "object" && "ticket" in value && typeof value.ticket === "number" && Number.isSafeInteger(value.ticket) && value.ticket > 0)
-        ticket = value.ticket;
-    } catch {
+    if (callback.state !== expected.state) {
+      throw new Error("OAuth callback state mismatch");
     }
-    claims.push({ name, ticket });
   }
-  return claims;
-}
-
-// ../auth-store/dist/encrypted-file-store.js
-var derivedKeyCache = /* @__PURE__ */ new Map();
-var ENCRYPTION_ALGORITHM = "aes-256-gcm";
-var ENCRYPTION_VERSION = 1;
-var ENCRYPTION_KEY_BYTES = 32;
-var ENCRYPTION_IV_BYTES = 12;
-var ENCRYPTION_AUTH_TAG_BYTES = 16;
-var ENCRYPTION_FILE_MODE = 384;
-var EncryptedFileStore = class {
-  fs;
-  filePath;
-  symbolicLinkCheckStartPath;
-  salt;
-  getMachineIdentity;
-  getRandomBytes;
-  keyPromise = null;
-  throwOnInvalidDocument;
-  constructor(input) {
-    this.fs = input.fs ?? fs;
-    this.salt = input.salt;
-    if (input.filePath === void 0) {
-      const homeDirectory = (input.getHomeDirectory ?? homedir)();
-      const defaultDirectory = input.defaultDirectory ?? ".auth-store";
-      const defaultFileName = input.defaultFileName ?? "credentials.enc";
-      assertSafeDefaultDirectory(defaultDirectory);
-      assertSafeDefaultFileName(defaultFileName);
-      this.filePath = path2.join(homeDirectory, defaultDirectory, defaultFileName);
-      this.symbolicLinkCheckStartPath = resolveDefaultDirectoryCheckStart(homeDirectory, defaultDirectory);
-    } else {
-      this.filePath = input.filePath;
-      this.symbolicLinkCheckStartPath = null;
-    }
-    this.getMachineIdentity = input.getMachineIdentity ?? defaultMachineIdentity;
-    this.getRandomBytes = input.getRandomBytes ?? randomBytes;
-    this.throwOnInvalidDocument = input.throwOnInvalidDocument ?? false;
-  }
-  async get() {
-    await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
-    let rawDocument;
-    try {
-      rawDocument = await this.fs.readFile(this.filePath, "utf8");
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        return null;
-      }
-      throw error;
-    }
-    const document = parseEncryptedDocument(rawDocument);
-    if (!document) {
-      if (this.throwOnInvalidDocument)
-        throw new Error("Invalid encrypted credential document; reset the store explicitly to recover");
-      return null;
-    }
-    const key2 = await this.getEncryptionKey();
-    try {
-      const iv = Buffer.from(document.iv, "base64");
-      const authTag = Buffer.from(document.authTag, "base64");
-      const ciphertext = Buffer.from(document.ciphertext, "base64");
-      if (iv.byteLength !== ENCRYPTION_IV_BYTES || authTag.byteLength !== ENCRYPTION_AUTH_TAG_BYTES) {
-        if (this.throwOnInvalidDocument)
-          throw new Error("Invalid encrypted credential document; reset the store explicitly to recover");
-        return null;
-      }
-      const decipher = createDecipheriv(ENCRYPTION_ALGORITHM, key2, iv);
-      decipher.setAuthTag(authTag);
-      const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
-      return plaintext.toString("utf8");
-    } catch {
-      if (this.throwOnInvalidDocument)
-        throw new Error("Invalid encrypted credential document; reset the store explicitly to recover");
-      return null;
-    }
-  }
-  async withLock(operation, options = {}) {
-    await this.assertCredentialPathHasNoSymbolicLinks(`${this.filePath}.lock`);
-    if (this.fs.readdir === void 0)
-      throw new Error("Secret-store transaction locks require filesystem readdir support");
-    return withSecretStoreFileLock(this.fs, `${this.filePath}.lock`, operation, options);
-  }
-  async set(value) {
-    await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
-    const key2 = await this.getEncryptionKey();
-    const iv = this.getRandomBytes(ENCRYPTION_IV_BYTES);
-    const cipher = createCipheriv(ENCRYPTION_ALGORITHM, key2, iv);
-    const ciphertext = Buffer.concat([
-      cipher.update(value, "utf8"),
-      cipher.final()
-    ]);
-    const authTag = cipher.getAuthTag();
-    const document = {
-      version: ENCRYPTION_VERSION,
-      iv: iv.toString("base64"),
-      authTag: authTag.toString("base64"),
-      ciphertext: ciphertext.toString("base64")
-    };
-    await this.fs.mkdir(path2.dirname(this.filePath), { recursive: true });
-    await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
-    const temporaryPath = `${this.filePath}.${process.pid}.${randomUUID2()}.tmp`;
-    let temporaryCreated = false;
-    try {
-      await this.assertCredentialPathHasNoSymbolicLinks(temporaryPath);
-      await this.fs.writeFile(temporaryPath, JSON.stringify(document), {
-        encoding: "utf8",
-        flag: "wx",
-        mode: ENCRYPTION_FILE_MODE
-      });
-      temporaryCreated = true;
-      await this.fs.chmod(temporaryPath, ENCRYPTION_FILE_MODE);
-      await this.fs.rename(temporaryPath, this.filePath);
-    } catch (error) {
-      if (temporaryCreated || !isAlreadyExistsError(error)) {
-        await removeIfPresent(this.fs, temporaryPath).catch(() => void 0);
-      }
-      throw error;
+  if (expected.requireIssuer) {
+    if (callback.iss === null || callback.iss.length === 0) {
+      throw new Error("OAuth callback missing issuer");
     }
   }
-  async delete() {
-    await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
-    try {
-      await this.fs.unlink(this.filePath);
-    } catch (error) {
-      if (!isNotFoundError(error)) {
-        throw error;
-      }
-    }
+  if (callback.iss !== null && callback.iss.length > 0 && expected.issuer !== null && callback.iss !== expected.issuer) {
+    throw new Error("OAuth callback issuer mismatch");
   }
-  async assertCredentialPathHasNoSymbolicLinks(targetPath) {
-    const resolvedPath = path2.resolve(targetPath);
-    const protectedPaths = getProtectedCredentialPaths(resolvedPath, this.symbolicLinkCheckStartPath);
-    for (const currentPath of protectedPaths) {
-      try {
-        const stats = await this.fs.lstat(currentPath);
-        if (stats.isSymbolicLink()) {
-          throw new Error(`Refusing to use encrypted credential path through symbolic link: ${currentPath}`);
-        }
-      } catch (error) {
-        if (isNotFoundError(error)) {
-          return;
-        }
-        throw error;
+}
+function createAuthorizationError(error, description) {
+  return new Error(`OAuth authorization failed: ${error} \u2014 ${description}`);
+}
+function escapeHtml(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+}
+function buildSuccessPage(landingPage) {
+  const title = landingPage?.title ?? "Connected";
+  const body = landingPage?.body ?? "You can close this tab and return to your terminal.";
+  return [
+    "<!DOCTYPE html>",
+    `<html><head><meta charset=utf-8><title>${escapeHtml(title)}</title></head>`,
+    '<body style="font-family:system-ui,sans-serif;display:flex;align-items:center;justify-content:center;min-height:100vh;margin:0">',
+    '<div style="text-align:center">',
+    `<h1>${escapeHtml(title)}</h1>`,
+    `<p style="color:#666">${escapeHtml(body)}</p>`,
+    "</div></body></html>"
+  ].join("");
+}
+
+// ../mcp-oauth/dist/client/scope.js
+function normalizeOAuthScope(scope) {
+  if (scope === void 0)
+    return void 0;
+  if (typeof scope !== "string" || [...scope].some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) > 126 || char === '"' || char === "\\"))
+    throw new Error("Invalid OAuth scope syntax");
+  const normalized = [...new Set(scope.split(" ").filter(Boolean))].sort().join(" ");
+  return normalized || void 0;
+}
+
+// ../mcp-oauth/dist/client/token-auth-method.js
+function normalizeOAuthTokenEndpointAuthMethod(value) {
+  if (value === void 0 || value === null)
+    return void 0;
+  if (value !== "none" && value !== "client_secret_post" && value !== "client_secret_basic")
+    throw new Error("Unsupported OAuth token endpoint authentication method");
+  return value;
+}
+
+// ../mcp-oauth/dist/client/client-registration.js
+function parseOAuthClientRegistration(value) {
+  const invalid = () => new Error("Invalid OAuth client registration metadata");
+  let nodes = 0;
+  function copy(input, depth) {
+    if (++nodes > 2e4 || depth > 64)
+      throw invalid();
+    if (input === null || typeof input === "boolean" || typeof input === "string")
+      return input;
+    if (typeof input === "number" && Number.isFinite(input))
+      return input;
+    if (typeof input !== "object" || input === null)
+      throw invalid();
+    const descriptors = Object.getOwnPropertyDescriptors(input);
+    if (Array.isArray(input)) {
+      const length = descriptors.length?.value;
+      if (length > 2e4)
+        throw invalid();
+      const result2 = [];
+      for (let index = 0; index < length; index++) {
+        const descriptor = descriptors[String(index)];
+        if (descriptor === void 0 || !Object.hasOwn(descriptor, "value"))
+          throw invalid();
+        result2.push(copy(descriptor.value, depth + 1));
       }
+      return result2;
     }
+    if (Object.getPrototypeOf(input) !== Object.prototype && Object.getPrototypeOf(input) !== null)
+      throw invalid();
+    return Object.fromEntries(Object.entries(descriptors).filter(([, descriptor]) => descriptor.enumerable).map(([key2, descriptor]) => {
+      if (!Object.hasOwn(descriptor, "value"))
+        throw invalid();
+      return [key2, copy(descriptor.value, depth + 1)];
+    }));
   }
-  getEncryptionKey() {
-    if (!this.keyPromise) {
-      const retryableKeyPromise = deriveEncryptionKey(this.getMachineIdentity, this.salt).catch((error) => {
-        if (this.keyPromise === retryableKeyPromise) {
-          this.keyPromise = null;
-        }
-        throw error;
-      });
-      this.keyPromise = retryableKeyPromise;
-    }
-    return this.keyPromise;
-  }
-};
-function resolveDefaultDirectoryCheckStart(homeDirectory, defaultDirectory) {
-  const [firstSegment] = defaultDirectory.split(/[\\/]+/).filter(Boolean);
-  return path2.resolve(homeDirectory, firstSegment ?? ".");
-}
-function getProtectedCredentialPaths(resolvedPath, symbolicLinkCheckStartPath) {
-  if (symbolicLinkCheckStartPath === null) {
-    return getExplicitProtectedCredentialPaths(resolvedPath);
-  }
-  const resolvedStartPath = path2.resolve(symbolicLinkCheckStartPath);
-  if (!isPathInsideOrEqual(resolvedPath, resolvedStartPath)) {
-    return [path2.dirname(resolvedPath), resolvedPath];
+  let result;
+  try {
+    result = copy(value, 0);
+  } catch {
+    throw invalid();
   }
-  const protectedPaths = [resolvedStartPath];
-  let currentPath = resolvedStartPath;
-  for (const segment of path2.relative(resolvedStartPath, resolvedPath).split(path2.sep).filter(Boolean)) {
-    currentPath = path2.join(currentPath, segment);
-    protectedPaths.push(currentPath);
+  if (typeof result !== "object" || result === null || Array.isArray(result))
+    throw invalid();
+  const record2 = result;
+  if (!Object.hasOwn(record2, "client_id") || typeof record2.client_id !== "string" || record2.client_id.trim() === "")
+    throw new Error("OAuth client registration response missing client_id");
+  for (const key2 of [
+    "client_id",
+    "client_secret",
+    "token_endpoint_auth_method",
+    "application_type",
+    "client_name",
+    "client_uri",
+    "logo_uri",
+    "scope",
+    "tos_uri",
+    "policy_uri",
+    "jwks_uri",
+    "software_id",
+    "software_version",
+    "software_statement",
+    "registration_access_token",
+    "registration_client_uri",
+    "issuer"
+  ]) {
+    if (Object.hasOwn(record2, key2) && record2[key2] !== null && typeof record2[key2] !== "string")
+      throw invalid();
   }
-  return protectedPaths;
-}
-function assertSafeDefaultDirectory(defaultDirectory) {
-  if (path2.isAbsolute(defaultDirectory) || path2.win32.isAbsolute(defaultDirectory)) {
-    throw new Error("defaultDirectory must be a relative path inside the home directory");
+  if (typeof record2.client_secret === "string" && record2.client_secret.trim() === "")
+    throw invalid();
+  for (const key2 of ["redirect_uris", "grant_types", "response_types", "contacts"]) {
+    const entry = record2[key2];
+    if (Object.hasOwn(record2, key2) && entry !== null && (!Array.isArray(entry) || entry.some((item) => typeof item !== "string")))
+      throw invalid();
   }
-  for (const segment of splitPathSegments(defaultDirectory)) {
-    if (segment === "..") {
-      throw new Error("defaultDirectory must be a relative path inside the home directory");
-    }
+  for (const key2 of ["client_id_issued_at", "client_secret_expires_at"]) {
+    const entry = record2[key2];
+    if (Object.hasOwn(record2, key2) && entry !== null && (typeof entry !== "number" || !Number.isSafeInteger(entry) || entry < 0))
+      throw invalid();
   }
-}
-function assertSafeDefaultFileName(defaultFileName) {
-  if (defaultFileName.trim().length === 0 || defaultFileName === "." || defaultFileName === ".." || splitPathSegments(defaultFileName).length !== 1) {
-    throw new Error("defaultFileName must be a file name without path separators");
+  try {
+    normalizeOAuthScope(Object.hasOwn(record2, "scope") && record2.scope !== null ? record2.scope : void 0);
+  } catch {
+    throw invalid();
   }
+  if (Buffer.byteLength(JSON.stringify(record2), "utf8") > 64 * 1024)
+    throw invalid();
+  return record2;
 }
-function splitPathSegments(value) {
-  return value.split("/").flatMap((segment) => segment.split("\\")).filter((segment) => segment.length > 0);
-}
-function getExplicitProtectedCredentialPaths(resolvedPath) {
-  const parsed = path2.parse(resolvedPath);
-  const segments = resolvedPath.slice(parsed.root.length).split(path2.sep).filter((segment) => segment.length > 0);
-  if (segments.length <= 1) {
-    return [resolvedPath];
-  }
-  const protectedPaths = [];
-  let currentPath = parsed.root;
-  for (const [index, segment] of segments.entries()) {
-    currentPath = path2.join(currentPath, segment);
-    if (index === 0) {
-      continue;
+function normalizeStoredOAuthClient(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return null;
+  const record2 = value;
+  const clientId = Object.hasOwn(record2, "clientId") ? record2.clientId : void 0;
+  const clientSecret = Object.hasOwn(record2, "clientSecret") ? record2.clientSecret : void 0;
+  if (typeof clientId !== "string" || clientId.trim() === "" || clientSecret !== void 0 && (typeof clientSecret !== "string" || clientSecret.trim() === ""))
+    return null;
+  const client = { clientId: clientId.trim(), ...clientSecret === void 0 ? {} : { clientSecret: clientSecret.trim() } };
+  const requestedRedirectUri = Object.hasOwn(record2, "requestedRedirectUri") ? record2.requestedRedirectUri : void 0;
+  if (requestedRedirectUri !== void 0) {
+    try {
+      if (typeof requestedRedirectUri !== "string")
+        throw new Error("Invalid redirect identity");
+      loopbackTarget({ redirectUri: requestedRedirectUri });
+    } catch {
+      throw new Error("Invalid stored OAuth registration redirect identity");
     }
-    protectedPaths.push(currentPath);
+    client.requestedRedirectUri = requestedRedirectUri;
   }
-  return protectedPaths;
-}
-function isPathInsideOrEqual(childPath, parentPath) {
-  const relativePath = path2.relative(parentPath, childPath);
-  return relativePath === "" || !relativePath.startsWith("..") && !path2.isAbsolute(relativePath);
-}
-async function removeIfPresent(fileSystem, filePath) {
-  try {
-    await fileSystem.unlink(filePath);
-  } catch (error) {
-    if (!isNotFoundError(error)) {
-      throw error;
-    }
+  const method = normalizeOAuthTokenEndpointAuthMethod(Object.hasOwn(record2, "tokenEndpointAuthMethod") ? record2.tokenEndpointAuthMethod : void 0);
+  if (Object.hasOwn(record2, "registration") && record2.registration !== void 0) {
+    const registration = parseOAuthClientRegistration(record2.registration);
+    const registeredSecret = Object.hasOwn(registration, "client_secret") ? registration.client_secret?.trim() : void 0;
+    if (registration.client_id.trim() !== client.clientId || registeredSecret !== client.clientSecret)
+      throw new Error("OAuth client registration does not match the client identity");
+    client.registration = registration;
+    const registrationMethod = normalizeOAuthTokenEndpointAuthMethod(Object.hasOwn(registration, "token_endpoint_auth_method") ? registration.token_endpoint_auth_method : void 0);
+    if (method !== void 0 && registrationMethod !== void 0 && method !== registrationMethod)
+      throw new Error("OAuth token endpoint authentication conflicts with the client registration");
+    if (registrationMethod !== void 0)
+      client.tokenEndpointAuthMethod = registrationMethod;
   }
+  if (method !== void 0)
+    client.tokenEndpointAuthMethod = method;
+  return client;
 }
-function defaultMachineIdentity() {
-  return {
-    hostname: hostname(),
-    username: userInfo().username
-  };
-}
-async function deriveEncryptionKey(getMachineIdentity, salt) {
-  const machineIdentity = await getMachineIdentity();
-  const secret = `${machineIdentity.hostname}:${machineIdentity.username}`;
-  const cacheKey = JSON.stringify([machineIdentity.hostname, machineIdentity.username, salt]);
-  const cached = derivedKeyCache.get(cacheKey);
-  if (cached) {
-    return cached;
-  }
-  const keyPromise = new Promise((resolve, reject) => {
-    scrypt(secret, salt, ENCRYPTION_KEY_BYTES, (error, derivedKey) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      resolve(Buffer.from(derivedKey));
-    });
-  });
-  derivedKeyCache.set(cacheKey, keyPromise);
-  return keyPromise.catch((error) => {
-    if (derivedKeyCache.get(cacheKey) === keyPromise) {
-      derivedKeyCache.delete(cacheKey);
+function registrationMatchesRedirect(client, requestedUri, fresh = false) {
+  if (client.requestedRedirectUri !== void 0)
+    return client.requestedRedirectUri === requestedUri;
+  const redirects = client.registration?.redirect_uris;
+  if (redirects === void 0 || redirects === null || redirects.length === 0)
+    return true;
+  return redirects.some((returnedUri) => {
+    if (returnedUri === requestedUri)
+      return true;
+    if (!fresh)
+      return false;
+    let returned, requested;
+    try {
+      returned = new URL(returnedUri);
+      requested = new URL(requestedUri);
+    } catch {
+      return false;
     }
-    throw error;
+    if (requested.protocol !== "http:" || returned.protocol !== "http:" || !["127.0.0.1", "[::1]", "localhost"].includes(requested.hostname))
+      return false;
+    const sameHost = returned.hostname === requested.hostname;
+    const normalizedIpv4 = requested.hostname === "127.0.0.1" && returned.hostname === "localhost" && returned.port === "";
+    if (!sameHost && !normalizedIpv4)
+      return false;
+    returned.hostname = requested.hostname;
+    returned.port = requested.port;
+    return returned.href === requested.href;
   });
 }
-function parseEncryptedDocument(raw) {
-  try {
-    const parsed = JSON.parse(raw);
-    if (!isRecord2(parsed)) {
-      return null;
-    }
-    const version = getOwnEntry(parsed, "version");
-    const iv = getOwnEntry(parsed, "iv");
-    const authTag = getOwnEntry(parsed, "authTag");
-    const ciphertext = getOwnEntry(parsed, "ciphertext");
-    if (version !== ENCRYPTION_VERSION) {
-      return null;
-    }
-    if (typeof iv !== "string" || typeof authTag !== "string" || typeof ciphertext !== "string") {
-      return null;
-    }
-    return {
-      version,
-      iv,
-      authTag,
-      ciphertext
-    };
-  } catch {
-    return null;
-  }
-}
-function isRecord2(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-function getOwnEntry(record2, key2) {
-  return Object.prototype.hasOwnProperty.call(record2, key2) ? record2[key2] : void 0;
-}
-function isNotFoundError(error) {
-  return hasOwnErrorCode(error, "ENOENT");
-}
-function isAlreadyExistsError(error) {
-  return hasOwnErrorCode(error, "EEXIST");
+
+// ../mcp-oauth/dist/client/auth-store-session-store.js
+import crypto2 from "node:crypto";
+import path4 from "node:path";
+
+// ../auth-store/dist/encrypted-file-store.js
+import { createCipheriv, createDecipheriv, randomBytes, randomUUID as randomUUID2, scrypt } from "node:crypto";
+import { promises as fs } from "node:fs";
+import { homedir, hostname, userInfo } from "node:os";
+import path2 from "node:path";
+
+// ../auth-store/dist/error-codes.js
+function hasOwnErrorCode(error, code) {
+  return error instanceof Error && Object.prototype.hasOwnProperty.call(error, "code") && error.code === code;
 }
 
-// ../auth-store/dist/keychain-store.js
-import { spawn } from "node:child_process";
-import { createHash } from "node:crypto";
-import { promises as nodeFs } from "node:fs";
-import { homedir as homedir2 } from "node:os";
-import path3 from "node:path";
-var SECURITY_CLI = "security";
-var KEYCHAIN_ITEM_NOT_FOUND_EXIT_CODE = 44;
-var KeychainStore = class {
-  runCommand;
-  service;
-  account;
-  lockFs;
-  lockDirectory;
-  constructor(input) {
-    this.runCommand = input.runCommand ?? runSecurityCommand;
-    this.service = input.service.trim();
-    this.account = input.account.trim();
-    this.lockFs = input.lock?.fs ?? nodeFs;
-    this.lockDirectory = input.lock?.directory ?? path3.join(homedir2(), ".auth-store", "keychain-locks");
-    if (this.service.length === 0) {
-      throw new Error("Keychain service must not be empty");
-    }
-    if (this.account.length === 0) {
-      throw new Error("Keychain account must not be empty");
-    }
-  }
-  async get() {
-    const result = await this.executeSecurityCommand(["find-generic-password", "-s", this.service, "-a", this.account, "-w"], "read secret from macOS Keychain");
-    if (getCommandExitCode(result) === 0) {
-      return stripTrailingLineBreak(getCommandOutput(result, "stdout"));
-    }
-    if (isKeychainEntryNotFound(result)) {
-      return null;
-    }
-    throw createSecurityCliFailure("read secret from macOS Keychain", result);
-  }
-  async withLock(operation, options = {}) {
-    const identity = createHash("sha256").update(JSON.stringify([this.service, this.account])).digest("hex");
-    return withSecretStoreFileLock(this.lockFs, path3.join(this.lockDirectory, identity), operation, options);
-  }
-  async set(value) {
-    if (value.includes("\n") || value.includes("\r")) {
-      throw new Error("Keychain secrets cannot contain line breaks");
-    }
-    const result = await this.executeSecurityCommand([
-      "add-generic-password",
-      "-s",
-      this.service,
-      "-a",
-      this.account,
-      "-U",
-      "-w",
-      value
-    ], "store secret in macOS Keychain");
-    if (getCommandExitCode(result) !== 0) {
-      throw createSecurityCliFailure("store secret in macOS Keychain", result);
-    }
-  }
-  async delete() {
-    const result = await this.executeSecurityCommand(["delete-generic-password", "-s", this.service, "-a", this.account], "delete secret from macOS Keychain");
-    if (getCommandExitCode(result) === 0 || isKeychainEntryNotFound(result)) {
-      return;
+// ../auth-store/dist/transaction-lock.js
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+async function withSecretStoreFileLock(fs2, lockDirectory, operation, options = {}) {
+  const timeoutMs = options.timeoutMs ?? 3e4;
+  if (!Number.isFinite(timeoutMs) || timeoutMs < 0 || timeoutMs > 2147483647)
+    throw new Error("Invalid secret-store transaction lock timeout");
+  options.signal?.throwIfAborted();
+  const deadline = performance.now() + timeoutMs;
+  const directory = path.resolve(lockDirectory);
+  await assertLockDirectoryPath(fs2, directory);
+  await fs2.mkdir(directory, { recursive: true, mode: 448 });
+  await assertLockDirectoryPath(fs2, directory);
+  const name = `${process.pid}-${randomUUID()}.claim`;
+  const claimPath = path.join(directory, name);
+  const temporaryPath = `${claimPath}.tmp`;
+  let claimed = true;
+  let temporaryCreated = false;
+  let outcome;
+  try {
+    try {
+      await fs2.writeFile(claimPath, JSON.stringify({ ticket: null }), { encoding: "utf8", flag: "wx", mode: 384 });
+    } catch (error) {
+      if (hasOwnErrorCode(error, "EEXIST"))
+        claimed = false;
+      throw error;
     }
-    throw createSecurityCliFailure("delete secret from macOS Keychain", result);
-  }
-  async executeSecurityCommand(args, operation, options) {
+    const existing = await readClaims(fs2, directory, name);
+    const ticket = existing.reduce((max, claim) => Math.max(max, claim.ticket ?? 0), 0) + 1;
+    if (!Number.isSafeInteger(ticket))
+      throw new Error("Secret-store transaction lock ticket overflow");
+    temporaryCreated = true;
     try {
-      if (options === void 0) {
-        return await this.runCommand(SECURITY_CLI, args);
-      }
-      return await this.runCommand(SECURITY_CLI, args, options);
+      await fs2.writeFile(temporaryPath, JSON.stringify({ ticket }), { encoding: "utf8", flag: "wx", mode: 384 });
     } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to ${operation}: ${message}`);
+      if (hasOwnErrorCode(error, "EEXIST"))
+        temporaryCreated = false;
+      throw error;
     }
-  }
-};
-function runSecurityCommand(command, args, options) {
-  return new Promise((resolve) => {
-    const child = spawn(command, args, {
-      stdio: [options?.stdin === void 0 ? "ignore" : "pipe", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    let stdinErrorMessage;
-    const appendStderr = (message) => {
-      stderr = stderr.length === 0 ? message : `${stderr}${stderr.endsWith("\n") ? "" : "\n"}${message}`;
-    };
-    const appendStdinError = () => {
-      if (stdinErrorMessage === void 0) {
-        return;
-      }
-      appendStderr(stdinErrorMessage);
-      stdinErrorMessage = void 0;
-    };
-    child.stdout?.setEncoding("utf8");
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.stderr?.setEncoding("utf8");
-    child.stderr?.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    if (options?.stdin !== void 0) {
-      child.stdin?.once("error", (error) => {
-        stdinErrorMessage = error instanceof Error ? error.message : String(error);
+    await fs2.rename(temporaryPath, claimPath);
+    temporaryCreated = false;
+    for (; ; ) {
+      options.signal?.throwIfAborted();
+      const peers = await readClaims(fs2, directory, name);
+      if (!peers.some((peer) => peer.ticket === null || peer.ticket < ticket || peer.ticket === ticket && peer.name < name))
+        break;
+      const remaining = deadline - performance.now();
+      if (remaining <= 0)
+        throw new Error("Timed out waiting for secret-store transaction lock");
+      await new Promise((resolve, reject) => {
+        const abort = () => {
+          clearTimeout(timer);
+          options.signal?.removeEventListener("abort", abort);
+          reject(options.signal?.reason);
+        };
+        const timer = setTimeout(() => {
+          options.signal?.removeEventListener("abort", abort);
+          resolve();
+        }, Math.min(10, remaining));
+        options.signal?.addEventListener("abort", abort, { once: true });
+        if (options.signal?.aborted)
+          abort();
       });
-      child.stdin?.end(options.stdin);
     }
-    child.on("error", (error) => {
-      const message = error instanceof Error ? error.message : String(error ?? "Unknown error");
-      appendStdinError();
-      appendStderr(message);
-      resolve({
-        stdout,
-        stderr,
-        exitCode: 127
-      });
-    });
-    child.on("close", (code) => {
-      appendStdinError();
-      resolve({
-        stdout,
-        stderr,
-        exitCode: code ?? 1
-      });
-    });
-  });
-}
-function stripTrailingLineBreak(value) {
-  if (value.endsWith("\r\n")) {
-    return value.slice(0, -2);
+    options.signal?.throwIfAborted();
+    outcome = { result: await operation() };
+  } catch (error) {
+    outcome = { error };
   }
-  if (value.endsWith("\n") || value.endsWith("\r")) {
-    return value.slice(0, -1);
+  const cleanup = [];
+  for (const target of [...temporaryCreated ? [temporaryPath] : [], ...claimed ? [claimPath] : []]) {
+    try {
+      await fs2.unlink(target);
+    } catch (error) {
+      if (!hasOwnErrorCode(error, "ENOENT"))
+        cleanup.push(error);
+    }
   }
-  return value;
-}
-function isKeychainEntryNotFound(result) {
-  return getCommandExitCode(result) === KEYCHAIN_ITEM_NOT_FOUND_EXIT_CODE;
+  if (cleanup.length)
+    throw new AggregateError([..."error" in outcome ? [outcome.error] : [], ...cleanup], "Secret-store transaction lock cleanup failed");
+  if ("error" in outcome)
+    throw outcome.error;
+  return outcome.result;
 }
-function createSecurityCliFailure(operation, result) {
-  const exitCode = getCommandExitCode(result);
-  const details = getCommandOutput(result, "stderr").trim() || getCommandOutput(result, "stdout").trim();
-  if (details) {
-    return new Error(`Failed to ${operation}: security exited with code ${exitCode}: ${details}`);
+async function assertNoSymbolicLink(fs2, target) {
+  try {
+    if ((await fs2.lstat(target)).isSymbolicLink())
+      throw new Error("Refusing secret-store transaction lock through symbolic link");
+  } catch (error) {
+    if (!hasOwnErrorCode(error, "ENOENT"))
+      throw error;
   }
-  return new Error(`Failed to ${operation}: security exited with code ${exitCode}`);
-}
-function getCommandExitCode(result) {
-  const value = getOwnEntry2(result, "exitCode");
-  return typeof value === "number" && Number.isInteger(value) ? value : 1;
-}
-function getCommandOutput(result, key2) {
-  const value = getOwnEntry2(result, key2);
-  return typeof value === "string" ? value : "";
 }
-function getOwnEntry2(record2, key2) {
-  return Object.prototype.hasOwnProperty.call(record2, key2) ? record2[key2] : void 0;
+async function assertLockDirectoryPath(fs2, directory) {
+  const root = path.parse(directory).root;
+  const segments = directory.slice(root.length).split(path.sep).filter(Boolean);
+  let current = root;
+  for (const [index, segment] of segments.entries()) {
+    current = path.join(current, segment);
+    if (index > 0 || segments.length === 1)
+      await assertNoSymbolicLink(fs2, current);
+  }
 }
-
-// ../auth-store/dist/create-secret-store.js
-var DEFAULT_BACKEND_ENV_VAR = "AUTH_BACKEND";
-var MACOS_PLATFORM = "darwin";
-var storeFactories = {
-  file: (input) => {
-    if (!input.fileStore) {
-      throw new Error("fileStore configuration is required for file backend");
+async function readClaims(fs2, directory, ownName) {
+  const claims = [];
+  for (const name of await fs2.readdir(directory)) {
+    if (name === ownName || !name.endsWith(".claim"))
+      continue;
+    const pidText = name.slice(0, name.indexOf("-"));
+    const pid = Number(pidText);
+    if (!Number.isSafeInteger(pid) || pid < 1 || String(pid) !== pidText)
+      throw new Error("Malformed secret-store transaction lock owner");
+    const target = path.join(directory, name);
+    await assertNoSymbolicLink(fs2, target);
+    let alive = true;
+    try {
+      process.kill(pid, 0);
+    } catch (error) {
+      alive = !hasOwnErrorCode(error, "ESRCH");
     }
-    return new EncryptedFileStore(input.fileStore);
-  },
-  keychain: (input) => {
-    if (!input.keychainStore) {
-      throw new Error("keychainStore configuration is required for keychain backend");
+    if (!alive) {
+      try {
+        await fs2.unlink(target);
+      } catch (error) {
+        if (!hasOwnErrorCode(error, "ENOENT"))
+          throw error;
+      }
+      continue;
     }
-    return new KeychainStore(input.keychainStore);
-  }
-};
-function createSecretStore(input) {
-  const backend = resolveBackend(input);
-  const platform = input.platform ?? process.platform;
-  if (backend === "keychain" && platform !== MACOS_PLATFORM) {
-    throw new Error(`Keychain backend is only supported on macOS. Current platform: ${platform}`);
-  }
-  const store = storeFactories[backend](input);
-  return { backend, store };
-}
-function resolveBackend(input) {
-  const envVar = input.backendEnvVar ?? DEFAULT_BACKEND_ENV_VAR;
-  const configuredBackend = input.backend ?? getOwnEnvValue(input.env, envVar) ?? getOwnEnvValue(process.env, envVar);
-  const backend = configuredBackend?.trim();
-  if (backend === "keychain") {
-    return "keychain";
-  }
-  if (backend === void 0 || backend === "file") {
-    return "file";
+    let ticket = null;
+    let raw;
+    try {
+      raw = await fs2.readFile(target, "utf8");
+    } catch (error) {
+      if (hasOwnErrorCode(error, "ENOENT"))
+        continue;
+      throw error;
+    }
+    try {
+      const value = JSON.parse(raw);
+      if (value !== null && typeof value === "object" && "ticket" in value && typeof value.ticket === "number" && Number.isSafeInteger(value.ticket) && value.ticket > 0)
+        ticket = value.ticket;
+    } catch {
+    }
+    claims.push({ name, ticket });
   }
-  throw new Error(`Unsupported auth store backend: ${backend}`);
-}
-function getOwnEnvValue(env, key2) {
-  return env !== void 0 && Object.prototype.hasOwnProperty.call(env, key2) ? env[key2] : void 0;
+  return claims;
 }
 
-// ../mcp-oauth/dist/resource-indicator.js
-function canonicalizeResourceIndicator(value) {
-  let url;
-  try {
-    url = value instanceof URL ? new URL(value.toString()) : new URL(value);
-  } catch {
-    throw new Error("Resource indicator must be an absolute URL");
+// ../auth-store/dist/encrypted-file-store.js
+var derivedKeyCache = /* @__PURE__ */ new Map();
+var ENCRYPTION_ALGORITHM = "aes-256-gcm";
+var ENCRYPTION_VERSION = 1;
+var ENCRYPTION_KEY_BYTES = 32;
+var ENCRYPTION_IV_BYTES = 12;
+var ENCRYPTION_AUTH_TAG_BYTES = 16;
+var ENCRYPTION_FILE_MODE = 384;
+var EncryptedFileStore = class {
+  fs;
+  filePath;
+  symbolicLinkCheckStartPath;
+  salt;
+  getMachineIdentity;
+  getRandomBytes;
+  keyPromise = null;
+  throwOnInvalidDocument;
+  constructor(input) {
+    this.fs = input.fs ?? fs;
+    this.salt = input.salt;
+    if (input.filePath === void 0) {
+      const homeDirectory = (input.getHomeDirectory ?? homedir)();
+      const defaultDirectory = input.defaultDirectory ?? ".auth-store";
+      const defaultFileName = input.defaultFileName ?? "credentials.enc";
+      assertSafeDefaultDirectory(defaultDirectory);
+      assertSafeDefaultFileName(defaultFileName);
+      this.filePath = path2.join(homeDirectory, defaultDirectory, defaultFileName);
+      this.symbolicLinkCheckStartPath = resolveDefaultDirectoryCheckStart(homeDirectory, defaultDirectory);
+    } else {
+      this.filePath = input.filePath;
+      this.symbolicLinkCheckStartPath = null;
+    }
+    this.getMachineIdentity = input.getMachineIdentity ?? defaultMachineIdentity;
+    this.getRandomBytes = input.getRandomBytes ?? randomBytes;
+    this.throwOnInvalidDocument = input.throwOnInvalidDocument ?? false;
   }
-  url.hash = "";
-  return url.toString();
-}
-
-// ../mcp-oauth/dist/client/auth-store-session-store.js
-var DEFAULT_FILE_SALT = "poe-code:mcp-oauth:v1";
-var DEFAULT_FILE_DIRECTORY = ".poe-code/mcp-oauth";
-var DEFAULT_KEYCHAIN_SERVICE = "poe-code-mcp-oauth";
-var DEFAULT_CLIENT_FILE_SALT = "poe-code:mcp-oauth:clients:v1";
-var DEFAULT_CLIENT_FILE_DIRECTORY = ".poe-code/mcp-oauth/clients";
-var DEFAULT_CLIENT_KEYCHAIN_SERVICE = "poe-code-mcp-oauth-clients";
-var MAX_JS_DATE_MS = 864e13;
-function createAuthStoreSessionStore(options = {}, namespace) {
-  assertPersistenceNamespace(namespace);
-  return {
-    async withLock(resource, operation, lockOptions) {
-      const store = createResourceSecretStore(resource, options, namespace);
-      if (store.withLock === void 0)
-        throw new Error("OAuth secret-store backend does not support transaction locks");
-      return store.withLock(operation, lockOptions);
-    },
-    async load(resource) {
-      const store = createResourceSecretStore(resource, options, namespace);
-      const value = await store.get();
-      if (value === null) {
+  async get() {
+    await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
+    let rawDocument;
+    try {
+      rawDocument = await this.fs.readFile(this.filePath, "utf8");
+    } catch (error) {
+      if (isNotFoundError(error)) {
         return null;
       }
-      let parsed;
-      try {
-        parsed = JSON.parse(value);
-      } catch {
-        throw new Error("Stored OAuth session must be valid JSON; reset the store explicitly to recover");
+      throw error;
+    }
+    const document = parseEncryptedDocument(rawDocument);
+    if (!document) {
+      if (this.throwOnInvalidDocument)
+        throw new Error("Invalid encrypted credential document; reset the store explicitly to recover");
+      return null;
+    }
+    const key2 = await this.getEncryptionKey();
+    try {
+      const iv = Buffer.from(document.iv, "base64");
+      const authTag = Buffer.from(document.authTag, "base64");
+      const ciphertext = Buffer.from(document.ciphertext, "base64");
+      if (iv.byteLength !== ENCRYPTION_IV_BYTES || authTag.byteLength !== ENCRYPTION_AUTH_TAG_BYTES) {
+        if (this.throwOnInvalidDocument)
+          throw new Error("Invalid encrypted credential document; reset the store explicitly to recover");
+        return null;
       }
-      if (isStoredOAuthSession(parsed)) {
-        return parsed;
+      const decipher = createDecipheriv(ENCRYPTION_ALGORITHM, key2, iv);
+      decipher.setAuthTag(authTag);
+      const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+      return plaintext.toString("utf8");
+    } catch {
+      if (this.throwOnInvalidDocument)
+        throw new Error("Invalid encrypted credential document; reset the store explicitly to recover");
+      return null;
+    }
+  }
+  async withLock(operation, options = {}) {
+    await this.assertCredentialPathHasNoSymbolicLinks(`${this.filePath}.lock`);
+    if (this.fs.readdir === void 0)
+      throw new Error("Secret-store transaction locks require filesystem readdir support");
+    return withSecretStoreFileLock(this.fs, `${this.filePath}.lock`, operation, options);
+  }
+  async set(value) {
+    await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
+    const key2 = await this.getEncryptionKey();
+    const iv = this.getRandomBytes(ENCRYPTION_IV_BYTES);
+    const cipher = createCipheriv(ENCRYPTION_ALGORITHM, key2, iv);
+    const ciphertext = Buffer.concat([
+      cipher.update(value, "utf8"),
+      cipher.final()
+    ]);
+    const authTag = cipher.getAuthTag();
+    const document = {
+      version: ENCRYPTION_VERSION,
+      iv: iv.toString("base64"),
+      authTag: authTag.toString("base64"),
+      ciphertext: ciphertext.toString("base64")
+    };
+    await this.fs.mkdir(path2.dirname(this.filePath), { recursive: true });
+    await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
+    const temporaryPath = `${this.filePath}.${process.pid}.${randomUUID2()}.tmp`;
+    let temporaryCreated = false;
+    try {
+      await this.assertCredentialPathHasNoSymbolicLinks(temporaryPath);
+      await this.fs.writeFile(temporaryPath, JSON.stringify(document), {
+        encoding: "utf8",
+        flag: "wx",
+        mode: ENCRYPTION_FILE_MODE
+      });
+      temporaryCreated = true;
+      await this.fs.chmod(temporaryPath, ENCRYPTION_FILE_MODE);
+      await this.fs.rename(temporaryPath, this.filePath);
+    } catch (error) {
+      if (temporaryCreated || !isAlreadyExistsError(error)) {
+        await removeIfPresent(this.fs, temporaryPath).catch(() => void 0);
       }
-      throw new Error("Stored OAuth session must match the expected shape");
-    },
-    async save(resource, session) {
-      const store = createResourceSecretStore(resource, options, namespace);
-      await store.set(JSON.stringify(session));
-    },
-    async clear(resource) {
-      const store = createResourceSecretStore(resource, options, namespace);
-      await store.delete();
+      throw error;
     }
-  };
-}
-function createAuthStoreClientStore(options, namespace) {
-  assertPersistenceNamespace(namespace);
-  return {
-    async load(issuer) {
-      const store = createIssuerSecretStore(issuer, options, namespace);
-      const value = await store.get();
-      if (value === null) {
-        return null;
+  }
+  async delete() {
+    await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
+    try {
+      await this.fs.unlink(this.filePath);
+    } catch (error) {
+      if (!isNotFoundError(error)) {
+        throw error;
       }
-      let parsed;
+    }
+  }
+  async assertCredentialPathHasNoSymbolicLinks(targetPath) {
+    const resolvedPath = path2.resolve(targetPath);
+    const protectedPaths = getProtectedCredentialPaths(resolvedPath, this.symbolicLinkCheckStartPath);
+    for (const currentPath of protectedPaths) {
       try {
-        parsed = JSON.parse(value);
-      } catch {
-        throw new Error("Stored OAuth client must be valid JSON; reset the store explicitly to recover");
+        const stats = await this.fs.lstat(currentPath);
+        if (stats.isSymbolicLink()) {
+          throw new Error(`Refusing to use encrypted credential path through symbolic link: ${currentPath}`);
+        }
+      } catch (error) {
+        if (isNotFoundError(error)) {
+          return;
+        }
+        throw error;
       }
-      if (isObjectRecord(parsed) && typeof getOwnEntry3(parsed, "clientId") === "string")
-        return parsed;
-      throw new Error("Stored OAuth client must be a JSON object with clientId");
-    },
-    async save(issuer, client) {
-      const store = createIssuerSecretStore(issuer, options, namespace);
-      await store.set(JSON.stringify(client));
-    },
-    async clear(issuer) {
-      const store = createIssuerSecretStore(issuer, options, namespace);
-      await store.delete();
     }
-  };
-}
-function createNamedSecretStore(key2, options, defaults, namespace) {
-  const hash = crypto.createHash("sha256").update(namespace === void 0 ? key2 : JSON.stringify([namespace, key2])).digest("hex");
-  const configuredFilePath = options.fileStore?.filePath;
-  const parsedFilePath = configuredFilePath === void 0 ? null : path4.parse(configuredFilePath);
-  const fileStore = {
-    ...options.fileStore,
-    throwOnInvalidDocument: true,
-    filePath: parsedFilePath === null ? void 0 : path4.join(parsedFilePath.dir, `${parsedFilePath.name}-${hash}${parsedFilePath.ext || ".enc"}`),
-    salt: options.fileStore?.salt ?? defaults.salt,
-    defaultDirectory: options.fileStore?.defaultDirectory || defaults.directory,
-    defaultFileName: parsedFilePath === null ? `${hash}.enc` : `${parsedFilePath.name}-${hash}${parsedFilePath.ext || ".enc"}`
-  };
-  const keychainStore = {
-    ...options.keychainStore,
-    service: options.keychainStore?.service ?? defaults.service,
-    account: `${options.keychainStore?.account ?? defaults.accountPrefix}:${hash}`
-  };
-  return createSecretStore({ ...options, fileStore, keychainStore }).store;
-}
-function createResourceSecretStore(resource, options, namespace) {
-  return createNamedSecretStore(canonicalizeResourceIndicator(resource), options, {
-    salt: DEFAULT_FILE_SALT,
-    directory: DEFAULT_FILE_DIRECTORY,
-    service: DEFAULT_KEYCHAIN_SERVICE,
-    accountPrefix: "provider"
-  }, namespace);
-}
-function createIssuerSecretStore(issuer, options, namespace) {
-  return createNamedSecretStore(issuer, options, {
-    salt: DEFAULT_CLIENT_FILE_SALT,
-    directory: DEFAULT_CLIENT_FILE_DIRECTORY,
-    service: DEFAULT_CLIENT_KEYCHAIN_SERVICE,
-    accountPrefix: "issuer"
-  }, namespace);
-}
-function assertPersistenceNamespace(namespace) {
-  if (namespace !== void 0 && (typeof namespace !== "string" || namespace.trim() === "" || Buffer.byteLength(namespace, "utf8") > 1024))
-    throw new Error("OAuth persistence namespace must be a nonempty string within 1024 bytes");
-}
-function isObjectRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function getOwnEntry3(record2, key2) {
-  return Object.prototype.hasOwnProperty.call(record2, key2) ? record2[key2] : void 0;
-}
-function getOwnString(record2, key2) {
-  const value = getOwnEntry3(record2, key2);
-  return typeof value === "string" ? value : void 0;
-}
-function isStoredOAuthSession(value) {
-  if (!isObjectRecord(value)) {
-    return false;
   }
-  return isNonBlankOwnString(value, "resource") && isNonBlankOwnString(value, "authorizationServer") && normalizeStoredOAuthClient(getOwnEntry3(value, "client")) !== null && isStoredOAuthDiscovery(getOwnEntry3(value, "discovery")) && (getOwnEntry3(value, "requestedScope") === void 0 || isNonBlankOwnString(value, "requestedScope")) && (getOwnEntry3(value, "refreshState") === void 0 || getOwnEntry3(value, "refreshState") === "pending" && getOwnEntry3(value, "tokens") === void 0) && isStoredOAuthTokensOrMissing(getOwnEntry3(value, "tokens"));
+  getEncryptionKey() {
+    if (!this.keyPromise) {
+      const retryableKeyPromise = deriveEncryptionKey(this.getMachineIdentity, this.salt).catch((error) => {
+        if (this.keyPromise === retryableKeyPromise) {
+          this.keyPromise = null;
+        }
+        throw error;
+      });
+      this.keyPromise = retryableKeyPromise;
+    }
+    return this.keyPromise;
+  }
+};
+function resolveDefaultDirectoryCheckStart(homeDirectory, defaultDirectory) {
+  const [firstSegment] = defaultDirectory.split(/[\\/]+/).filter(Boolean);
+  return path2.resolve(homeDirectory, firstSegment ?? ".");
 }
-function isStoredOAuthDiscovery(value) {
-  if (!isObjectRecord(value)) {
-    return false;
+function getProtectedCredentialPaths(resolvedPath, symbolicLinkCheckStartPath) {
+  if (symbolicLinkCheckStartPath === null) {
+    return getExplicitProtectedCredentialPaths(resolvedPath);
+  }
+  const resolvedStartPath = path2.resolve(symbolicLinkCheckStartPath);
+  if (!isPathInsideOrEqual(resolvedPath, resolvedStartPath)) {
+    return [path2.dirname(resolvedPath), resolvedPath];
+  }
+  const protectedPaths = [resolvedStartPath];
+  let currentPath = resolvedStartPath;
+  for (const segment of path2.relative(resolvedStartPath, resolvedPath).split(path2.sep).filter(Boolean)) {
+    currentPath = path2.join(currentPath, segment);
+    protectedPaths.push(currentPath);
   }
-  return isNonBlankOwnString(value, "resourceMetadataUrl") && isObjectRecord(getOwnEntry3(value, "resourceMetadata")) && isObjectRecord(getOwnEntry3(value, "authorizationServerMetadata"));
+  return protectedPaths;
 }
-function isStoredOAuthTokensOrMissing(value) {
-  if (value === void 0) {
-    return true;
+function assertSafeDefaultDirectory(defaultDirectory) {
+  if (path2.isAbsolute(defaultDirectory) || path2.win32.isAbsolute(defaultDirectory)) {
+    throw new Error("defaultDirectory must be a relative path inside the home directory");
   }
-  if (!isObjectRecord(value)) {
-    return false;
+  for (const segment of splitPathSegments(defaultDirectory)) {
+    if (segment === "..") {
+      throw new Error("defaultDirectory must be a relative path inside the home directory");
+    }
   }
-  if (!isNonBlankOwnString(value, "accessToken") || getOwnString(value, "tokenType") !== "Bearer") {
-    return false;
+}
+function assertSafeDefaultFileName(defaultFileName) {
+  if (defaultFileName.trim().length === 0 || defaultFileName === "." || defaultFileName === ".." || splitPathSegments(defaultFileName).length !== 1) {
+    throw new Error("defaultFileName must be a file name without path separators");
   }
-  const expiresAt = getOwnEntry3(value, "expiresAt");
-  if (expiresAt !== null && (typeof expiresAt !== "number" || !Number.isSafeInteger(expiresAt) || expiresAt > MAX_JS_DATE_MS || !Number.isFinite(new Date(expiresAt).getTime()))) {
-    return false;
+}
+function splitPathSegments(value) {
+  return value.split("/").flatMap((segment) => segment.split("\\")).filter((segment) => segment.length > 0);
+}
+function getExplicitProtectedCredentialPaths(resolvedPath) {
+  const parsed = path2.parse(resolvedPath);
+  const segments = resolvedPath.slice(parsed.root.length).split(path2.sep).filter((segment) => segment.length > 0);
+  if (segments.length <= 1) {
+    return [resolvedPath];
   }
-  const refreshToken = getOwnEntry3(value, "refreshToken");
-  if (refreshToken !== void 0 && (typeof refreshToken !== "string" || refreshToken.trim().length === 0)) {
-    return false;
+  const protectedPaths = [];
+  let currentPath = parsed.root;
+  for (const [index, segment] of segments.entries()) {
+    currentPath = path2.join(currentPath, segment);
+    if (index === 0) {
+      continue;
+    }
+    protectedPaths.push(currentPath);
   }
-  const scope = getOwnEntry3(value, "scope");
-  return scope === void 0 || typeof scope === "string" && scope.trim().length > 0;
+  return protectedPaths;
 }
-function isNonBlankOwnString(record2, key2) {
-  const value = getOwnString(record2, key2);
-  return value !== void 0 && value.trim().length > 0;
+function isPathInsideOrEqual(childPath, parentPath) {
+  const relativePath = path2.relative(parentPath, childPath);
+  return relativePath === "" || !relativePath.startsWith("..") && !path2.isAbsolute(relativePath);
 }
-
-// ../mcp-oauth/dist/client/default-oauth-client-provider.js
-import { isIP } from "node:net";
-
-// ../mcp-oauth/dist/http-fetch.js
-async function fetchMcpResponse(fetchImplementation, input, init = {}) {
-  const response = await fetchImplementation(input, { ...init, redirect: "error" });
-  if (response.redirected || response.type === "opaqueredirect") {
-    void response.body?.cancel().catch(() => void 0);
-    throw new Error("MCP HTTP redirects are not allowed");
+async function removeIfPresent(fileSystem, filePath) {
+  try {
+    await fileSystem.unlink(filePath);
+  } catch (error) {
+    if (!isNotFoundError(error)) {
+      throw error;
+    }
   }
-  return response;
 }
-
-// ../mcp-oauth/dist/client/default-oauth-client-provider.js
-import { URL as URL2 } from "node:url";
-
-// ../mcp-oauth/dist/client/loopback-authorization.js
-import http from "node:http";
-
-// ../mcp-oauth/dist/client/authorization-state.js
-import crypto2 from "node:crypto";
-function createAuthorizationState(input) {
-  const payload = {
-    v: 1,
-    n: crypto2.randomBytes(16).toString("base64url"),
-    i: input.issuer,
-    r: input.requireIssuer
+function defaultMachineIdentity() {
+  return {
+    hostname: hostname(),
+    username: userInfo().username
   };
-  return Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
 }
-function parseAuthorizationState(value) {
-  if (value === null || value.length === 0) {
-    return null;
+async function deriveEncryptionKey(getMachineIdentity, salt) {
+  const machineIdentity = await getMachineIdentity();
+  const secret = `${machineIdentity.hostname}:${machineIdentity.username}`;
+  const cacheKey = JSON.stringify([machineIdentity.hostname, machineIdentity.username, salt]);
+  const cached = derivedKeyCache.get(cacheKey);
+  if (cached) {
+    return cached;
   }
+  const keyPromise = new Promise((resolve, reject) => {
+    scrypt(secret, salt, ENCRYPTION_KEY_BYTES, (error, derivedKey) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve(Buffer.from(derivedKey));
+    });
+  });
+  derivedKeyCache.set(cacheKey, keyPromise);
+  return keyPromise.catch((error) => {
+    if (derivedKeyCache.get(cacheKey) === keyPromise) {
+      derivedKeyCache.delete(cacheKey);
+    }
+    throw error;
+  });
+}
+function parseEncryptedDocument(raw) {
   try {
-    const decoded = Buffer.from(value, "base64url").toString("utf8");
-    const parsed = JSON.parse(decoded);
-    if (!isObjectRecord2(parsed)) {
+    const parsed = JSON.parse(raw);
+    if (!isRecord2(parsed)) {
       return null;
     }
-    const version = getOwnEntry4(parsed, "v");
-    const nonce = getOwnEntry4(parsed, "n");
-    const issuer = getOwnEntry4(parsed, "i");
-    const requireIssuer = getOwnEntry4(parsed, "r");
-    if (version !== 1 || typeof nonce !== "string" || nonce.length === 0 || typeof issuer !== "string" || issuer.length === 0 || typeof requireIssuer !== "boolean") {
+    const version = getOwnEntry2(parsed, "version");
+    const iv = getOwnEntry2(parsed, "iv");
+    const authTag = getOwnEntry2(parsed, "authTag");
+    const ciphertext = getOwnEntry2(parsed, "ciphertext");
+    if (version !== ENCRYPTION_VERSION) {
+      return null;
+    }
+    if (typeof iv !== "string" || typeof authTag !== "string" || typeof ciphertext !== "string") {
       return null;
     }
     return {
-      issuer,
-      requireIssuer
+      version,
+      iv,
+      authTag,
+      ciphertext
     };
   } catch {
     return null;
   }
 }
-function isObjectRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
-function getOwnEntry4(record2, key2) {
+function getOwnEntry2(record2, key2) {
   return Object.prototype.hasOwnProperty.call(record2, key2) ? record2[key2] : void 0;
 }
+function isNotFoundError(error) {
+  return hasOwnErrorCode(error, "ENOENT");
+}
+function isAlreadyExistsError(error) {
+  return hasOwnErrorCode(error, "EEXIST");
+}
 
-// ../mcp-oauth/dist/client/loopback-authorization.js
-async function createLoopbackAuthorizationSession(options = {}) {
-  options.signal?.throwIfAborted();
-  const timeoutMs = options.timeoutMs ?? 12e4;
-  if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2147483647)
-    throw new Error("OAuth authorization timeoutMs must be a positive supported timer interval");
-  const target = loopbackTarget(options);
-  const server = options.createServer ? options.createServer() : http.createServer();
-  const controller = new AbortController();
-  let closed = false;
-  let used = false;
-  const callerAbort = () => controller.abort(options.signal?.reason);
-  const teardown = () => {
-    if (closed)
-      return;
-    closed = true;
-    clearTimeout(timer);
-    options.signal?.removeEventListener("abort", callerAbort);
-    server.closeAllConnections?.();
-    server.close();
-  };
-  const timer = setTimeout(() => controller.abort(new Error("OAuth authorization timed out")), timeoutMs);
-  timer.unref?.();
-  controller.signal.addEventListener("abort", teardown, { once: true });
-  options.signal?.addEventListener("abort", callerAbort, { once: true });
-  if (options.signal?.aborted)
-    callerAbort();
-  let port;
-  try {
-    port = await startServer(server, target.port, target.host, controller.signal);
-  } catch (error) {
-    controller.abort(error);
-    throw error;
+// ../auth-store/dist/keychain-store.js
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { promises as nodeFs } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import path3 from "node:path";
+var SECURITY_CLI = "security";
+var KEYCHAIN_ITEM_NOT_FOUND_EXIT_CODE = 44;
+var KeychainStore = class {
+  runCommand;
+  service;
+  account;
+  lockFs;
+  lockDirectory;
+  constructor(input) {
+    this.runCommand = input.runCommand ?? runSecurityCommand;
+    this.service = input.service.trim();
+    this.account = input.account.trim();
+    this.lockFs = input.lock?.fs ?? nodeFs;
+    this.lockDirectory = input.lock?.directory ?? path3.join(homedir2(), ".auth-store", "keychain-locks");
+    if (this.service.length === 0) {
+      throw new Error("Keychain service must not be empty");
+    }
+    if (this.account.length === 0) {
+      throw new Error("Keychain account must not be empty");
+    }
   }
-  const redirectUri = options.redirectUri ?? `http://127.0.0.1:${port}${target.callbackPath}`;
-  return {
-    redirectUri,
-    async waitForCode(authorizationUrl) {
-      controller.signal.throwIfAborted();
-      if (used)
-        throw new Error("OAuth authorization session has already been used");
-      used = true;
-      try {
-        return await waitForAuthorizationCode(server, authorizationUrl, options, target.callbackPath, controller.signal);
-      } finally {
-        clearTimeout(timer);
-      }
-    },
-    close() {
-      controller.abort(new Error("OAuth authorization session closed"));
+  async get() {
+    const result = await this.executeSecurityCommand(["find-generic-password", "-s", this.service, "-a", this.account, "-w"], "read secret from macOS Keychain");
+    if (getCommandExitCode(result) === 0) {
+      return stripTrailingLineBreak(getCommandOutput(result, "stdout"));
+    }
+    if (isKeychainEntryNotFound(result)) {
+      return null;
+    }
+    throw createSecurityCliFailure("read secret from macOS Keychain", result);
+  }
+  async withLock(operation, options = {}) {
+    const identity = createHash("sha256").update(JSON.stringify([this.service, this.account])).digest("hex");
+    return withSecretStoreFileLock(this.lockFs, path3.join(this.lockDirectory, identity), operation, options);
+  }
+  async set(value) {
+    if (value.includes("\n") || value.includes("\r")) {
+      throw new Error("Keychain secrets cannot contain line breaks");
+    }
+    const result = await this.executeSecurityCommand([
+      "add-generic-password",
+      "-s",
+      this.service,
+      "-a",
+      this.account,
+      "-U",
+      "-w",
+      value
+    ], "store secret in macOS Keychain");
+    if (getCommandExitCode(result) !== 0) {
+      throw createSecurityCliFailure("store secret in macOS Keychain", result);
     }
-  };
-}
-function loopbackTarget(options) {
-  if (options.redirectUri !== void 0) {
-    let url;
-    try {
-      url = new URL(options.redirectUri);
-    } catch (cause) {
-      throw new Error("Invalid OAuth loopback redirect URI", { cause });
+  }
+  async delete() {
+    const result = await this.executeSecurityCommand(["delete-generic-password", "-s", this.service, "-a", this.account], "delete secret from macOS Keychain");
+    if (getCommandExitCode(result) === 0 || isKeychainEntryNotFound(result)) {
+      return;
     }
-    const forbiddenQuery = ["code", "state", "error", "error_description", "iss"];
-    if (url.protocol !== "http:" || !["localhost", "127.0.0.1", "[::1]"].includes(url.hostname) || url.username || url.password || url.hash || url.port === "0" || forbiddenQuery.some((name) => url.searchParams.has(name)) || [...options.redirectUri].some((char) => char.codePointAt(0) <= 32) || options.callbackPath !== void 0 && options.callbackPath !== url.pathname)
-      throw new Error("Invalid OAuth loopback redirect URI");
-    return { port: url.port ? Number(url.port) : 80, host: url.hostname === "[::1]" ? "::1" : url.hostname, callbackPath: url.pathname };
+    throw createSecurityCliFailure("delete secret from macOS Keychain", result);
   }
-  const callbackPath = options.callbackPath ?? "/callback";
-  const parsed = new URL(callbackPath, "http://127.0.0.1");
-  if (!callbackPath.startsWith("/") || parsed.origin !== "http://127.0.0.1" || parsed.pathname !== callbackPath || parsed.search || parsed.hash)
-    throw new Error("Invalid OAuth loopback callback path");
-  return { port: 0, host: "127.0.0.1", callbackPath };
-}
-async function startServer(server, port, host, signal) {
-  signal.throwIfAborted();
-  return new Promise((resolve, reject) => {
-    const cleanup = () => {
-      server.off("error", handleError);
-      signal.removeEventListener("abort", aborted);
-    };
-    const handleError = (error) => {
-      cleanup();
-      reject(error);
-    };
-    const aborted = () => {
-      cleanup();
-      reject(signal.reason);
-    };
-    server.once("error", handleError);
-    signal.addEventListener("abort", aborted, { once: true });
+  async executeSecurityCommand(args, operation, options) {
     try {
-      server.listen(port, host, () => {
-        cleanup();
-        if (signal.aborted) {
-          server.close();
-          reject(signal.reason);
-          return;
-        }
-        const address = server.address();
-        if (address === null || typeof address === "string") {
-          reject(new Error("OAuth listener has no TCP address"));
-          return;
-        }
-        resolve(address.port);
-      });
+      if (options === void 0) {
+        return await this.runCommand(SECURITY_CLI, args);
+      }
+      return await this.runCommand(SECURITY_CLI, args, options);
     } catch (error) {
-      cleanup();
-      reject(error);
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to ${operation}: ${message}`);
     }
-  });
-}
-function waitForAuthorizationCode(server, authorizationUrl, options, callbackPath, signal) {
-  signal.throwIfAborted();
-  const expectedAuthorization = readExpectedAuthorizationCallback(authorizationUrl);
-  return new Promise((resolve, reject) => {
-    let settled = false;
-    const settle = (fn) => {
-      if (settled)
-        return;
-      settled = true;
-      server.off("request", request);
-      signal.removeEventListener("abort", aborted);
-      fn();
+  }
+};
+function runSecurityCommand(command, args, options) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, {
+      stdio: [options?.stdin === void 0 ? "ignore" : "pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    let stdinErrorMessage;
+    const appendStderr = (message) => {
+      stderr = stderr.length === 0 ? message : `${stderr}${stderr.endsWith("\n") ? "" : "\n"}${message}`;
     };
-    const aborted = () => settle(() => reject(signal.reason));
-    const request = (req, res) => {
-      let url;
-      try {
-        url = new URL(req.url ?? "/", "http://127.0.0.1");
-      } catch {
-        res.writeHead(400);
-        res.end("Invalid callback URL");
-        return;
-      }
-      if (url.pathname !== callbackPath) {
-        res.writeHead(404);
-        res.end("Not found");
+    const appendStdinError = () => {
+      if (stdinErrorMessage === void 0) {
         return;
       }
-      const callbackParameters = {
-        code: url.searchParams.get("code"),
-        error: url.searchParams.get("error"),
-        errorDescription: url.searchParams.get("error_description"),
-        state: url.searchParams.get("state"),
-        iss: url.searchParams.get("iss")
-      };
-      try {
-        validateAuthorizationCallbackBinding(callbackParameters, expectedAuthorization);
-        if (callbackParameters.error !== null)
-          throw createAuthorizationError(callbackParameters.error, callbackParameters.errorDescription ?? callbackParameters.error);
-        const code = validateAuthorizationCallbackParameters(callbackParameters, expectedAuthorization);
-        res.writeHead(200, { "Content-Type": "text/html" });
-        res.end(buildSuccessPage(options.landingPage));
-        settle(() => resolve(code));
-      } catch (error) {
-        res.writeHead(400);
-        res.end(error instanceof Error ? error.message : "Invalid OAuth callback");
-        settle(() => reject(error));
-      }
+      appendStderr(stdinErrorMessage);
+      stdinErrorMessage = void 0;
     };
-    server.on("request", request);
-    signal.addEventListener("abort", aborted, { once: true });
-    if (options.readLine !== void 0) {
-      void Promise.resolve().then(() => settled ? void 0 : options.readLine()).then((input) => {
-        if (settled)
-          return;
-        const callbackParameters = extractCallbackParametersFromInput(input);
-        if (callbackParameters === null)
-          throw new Error("OAuth callback missing authorization code");
-        validateAuthorizationCallbackBinding(callbackParameters, expectedAuthorization);
-        if (callbackParameters.error !== null)
-          throw createAuthorizationError(callbackParameters.error, callbackParameters.errorDescription ?? callbackParameters.error);
-        const code = validateAuthorizationCallbackParameters(callbackParameters, expectedAuthorization);
-        settle(() => resolve(code));
-      }).catch((error) => settle(() => reject(error)));
-    }
-    if (options.openBrowser !== void 0) {
-      void Promise.resolve().then(() => settled ? void 0 : options.openBrowser(authorizationUrl)).catch((error) => settle(() => reject(error)));
+    child.stdout?.setEncoding("utf8");
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.setEncoding("utf8");
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    if (options?.stdin !== void 0) {
+      child.stdin?.once("error", (error) => {
+        stdinErrorMessage = error instanceof Error ? error.message : String(error);
+      });
+      child.stdin?.end(options.stdin);
     }
+    child.on("error", (error) => {
+      const message = error instanceof Error ? error.message : String(error ?? "Unknown error");
+      appendStdinError();
+      appendStderr(message);
+      resolve({
+        stdout,
+        stderr,
+        exitCode: 127
+      });
+    });
+    child.on("close", (code) => {
+      appendStdinError();
+      resolve({
+        stdout,
+        stderr,
+        exitCode: code ?? 1
+      });
+    });
   });
 }
-function extractCallbackParametersFromInput(input) {
-  const trimmed = input.replaceAll("\r", "").replaceAll("\n", "").trim();
-  if (trimmed.length === 0) {
-    return null;
+function stripTrailingLineBreak(value) {
+  if (value.endsWith("\r\n")) {
+    return value.slice(0, -2);
+  }
+  if (value.endsWith("\n") || value.endsWith("\r")) {
+    return value.slice(0, -1);
+  }
+  return value;
+}
+function isKeychainEntryNotFound(result) {
+  return getCommandExitCode(result) === KEYCHAIN_ITEM_NOT_FOUND_EXIT_CODE;
+}
+function createSecurityCliFailure(operation, result) {
+  const exitCode = getCommandExitCode(result);
+  const details = getCommandOutput(result, "stderr").trim() || getCommandOutput(result, "stdout").trim();
+  if (details) {
+    return new Error(`Failed to ${operation}: security exited with code ${exitCode}: ${details}`);
+  }
+  return new Error(`Failed to ${operation}: security exited with code ${exitCode}`);
+}
+function getCommandExitCode(result) {
+  const value = getOwnEntry3(result, "exitCode");
+  return typeof value === "number" && Number.isInteger(value) ? value : 1;
+}
+function getCommandOutput(result, key2) {
+  const value = getOwnEntry3(result, key2);
+  return typeof value === "string" ? value : "";
+}
+function getOwnEntry3(record2, key2) {
+  return Object.prototype.hasOwnProperty.call(record2, key2) ? record2[key2] : void 0;
+}
+
+// ../auth-store/dist/create-secret-store.js
+var DEFAULT_BACKEND_ENV_VAR = "AUTH_BACKEND";
+var MACOS_PLATFORM = "darwin";
+var storeFactories = {
+  file: (input) => {
+    if (!input.fileStore) {
+      throw new Error("fileStore configuration is required for file backend");
+    }
+    return new EncryptedFileStore(input.fileStore);
+  },
+  keychain: (input) => {
+    if (!input.keychainStore) {
+      throw new Error("keychainStore configuration is required for keychain backend");
+    }
+    return new KeychainStore(input.keychainStore);
+  }
+};
+function createSecretStore(input) {
+  const backend = resolveBackend(input);
+  const platform = input.platform ?? process.platform;
+  if (backend === "keychain" && platform !== MACOS_PLATFORM) {
+    throw new Error(`Keychain backend is only supported on macOS. Current platform: ${platform}`);
+  }
+  const store = storeFactories[backend](input);
+  return { backend, store };
+}
+function resolveBackend(input) {
+  const envVar = input.backendEnvVar ?? DEFAULT_BACKEND_ENV_VAR;
+  const configuredBackend = input.backend ?? getOwnEnvValue(input.env, envVar) ?? getOwnEnvValue(process.env, envVar);
+  const backend = configuredBackend?.trim();
+  if (backend === "keychain") {
+    return "keychain";
+  }
+  if (backend === void 0 || backend === "file") {
+    return "file";
   }
+  throw new Error(`Unsupported auth store backend: ${backend}`);
+}
+function getOwnEnvValue(env, key2) {
+  return env !== void 0 && Object.prototype.hasOwnProperty.call(env, key2) ? env[key2] : void 0;
+}
+
+// ../mcp-oauth/dist/resource-indicator.js
+function canonicalizeResourceIndicator(value) {
+  let url;
   try {
-    const url = new URL(trimmed);
-    return {
-      code: url.searchParams.get("code"),
-      error: url.searchParams.get("error"),
-      errorDescription: url.searchParams.get("error_description"),
-      state: url.searchParams.get("state"),
-      iss: url.searchParams.get("iss")
-    };
+    url = value instanceof URL ? new URL(value.toString()) : new URL(value);
   } catch {
-    return {
-      code: trimmed,
-      error: null,
-      errorDescription: null,
-      state: null,
-      iss: null
-    };
+    throw new Error("Resource indicator must be an absolute URL");
   }
+  url.hash = "";
+  return url.toString();
 }
-function readExpectedAuthorizationCallback(authorizationUrl) {
-  const url = new URL(authorizationUrl);
-  const state = url.searchParams.get("state");
-  const parsedState = parseAuthorizationState(state);
+
+// ../mcp-oauth/dist/client/auth-store-session-store.js
+var DEFAULT_FILE_SALT = "poe-code:mcp-oauth:v1";
+var DEFAULT_FILE_DIRECTORY = ".poe-code/mcp-oauth";
+var DEFAULT_KEYCHAIN_SERVICE = "poe-code-mcp-oauth";
+var DEFAULT_CLIENT_FILE_SALT = "poe-code:mcp-oauth:clients:v1";
+var DEFAULT_CLIENT_FILE_DIRECTORY = ".poe-code/mcp-oauth/clients";
+var DEFAULT_CLIENT_KEYCHAIN_SERVICE = "poe-code-mcp-oauth-clients";
+var MAX_JS_DATE_MS = 864e13;
+function createAuthStoreSessionStore(options = {}, namespace) {
+  assertPersistenceNamespace(namespace);
   return {
-    state,
-    issuer: parsedState?.issuer ?? null,
-    requireIssuer: parsedState?.requireIssuer ?? false
+    async withLock(resource, operation, lockOptions) {
+      const store = createResourceSecretStore(resource, options, namespace);
+      if (store.withLock === void 0)
+        throw new Error("OAuth secret-store backend does not support transaction locks");
+      return store.withLock(operation, lockOptions);
+    },
+    async load(resource) {
+      const store = createResourceSecretStore(resource, options, namespace);
+      const value = await store.get();
+      if (value === null) {
+        return null;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(value);
+      } catch {
+        throw new Error("Stored OAuth session must be valid JSON; reset the store explicitly to recover");
+      }
+      if (isStoredOAuthSession(parsed)) {
+        return parsed;
+      }
+      throw new Error("Stored OAuth session must match the expected shape");
+    },
+    async save(resource, session) {
+      const store = createResourceSecretStore(resource, options, namespace);
+      await store.set(JSON.stringify(session));
+    },
+    async clear(resource) {
+      const store = createResourceSecretStore(resource, options, namespace);
+      await store.delete();
+    }
   };
 }
-function validateAuthorizationCallbackParameters(callback, expected) {
-  validateAuthorizationCallbackBinding(callback, expected);
-  if (callback.code === null || callback.code.length === 0) {
-    throw new Error("OAuth callback missing authorization code");
+function createAuthStoreClientStore(options, namespace) {
+  assertPersistenceNamespace(namespace);
+  return {
+    async load(issuer) {
+      const store = createIssuerSecretStore(issuer, options, namespace);
+      const value = await store.get();
+      if (value === null) {
+        return null;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(value);
+      } catch {
+        throw new Error("Stored OAuth client must be valid JSON; reset the store explicitly to recover");
+      }
+      if (isObjectRecord2(parsed) && typeof getOwnEntry4(parsed, "clientId") === "string")
+        return parsed;
+      throw new Error("Stored OAuth client must be a JSON object with clientId");
+    },
+    async save(issuer, client) {
+      const store = createIssuerSecretStore(issuer, options, namespace);
+      await store.set(JSON.stringify(client));
+    },
+    async clear(issuer) {
+      const store = createIssuerSecretStore(issuer, options, namespace);
+      await store.delete();
+    }
+  };
+}
+function createNamedSecretStore(key2, options, defaults, namespace) {
+  const hash = crypto2.createHash("sha256").update(namespace === void 0 ? key2 : JSON.stringify([namespace, key2])).digest("hex");
+  const configuredFilePath = options.fileStore?.filePath;
+  const parsedFilePath = configuredFilePath === void 0 ? null : path4.parse(configuredFilePath);
+  const fileStore = {
+    ...options.fileStore,
+    throwOnInvalidDocument: true,
+    filePath: parsedFilePath === null ? void 0 : path4.join(parsedFilePath.dir, `${parsedFilePath.name}-${hash}${parsedFilePath.ext || ".enc"}`),
+    salt: options.fileStore?.salt ?? defaults.salt,
+    defaultDirectory: options.fileStore?.defaultDirectory || defaults.directory,
+    defaultFileName: parsedFilePath === null ? `${hash}.enc` : `${parsedFilePath.name}-${hash}${parsedFilePath.ext || ".enc"}`
+  };
+  const keychainStore = {
+    ...options.keychainStore,
+    service: options.keychainStore?.service ?? defaults.service,
+    account: `${options.keychainStore?.account ?? defaults.accountPrefix}:${hash}`
+  };
+  return createSecretStore({ ...options, fileStore, keychainStore }).store;
+}
+function createResourceSecretStore(resource, options, namespace) {
+  return createNamedSecretStore(canonicalizeResourceIndicator(resource), options, {
+    salt: DEFAULT_FILE_SALT,
+    directory: DEFAULT_FILE_DIRECTORY,
+    service: DEFAULT_KEYCHAIN_SERVICE,
+    accountPrefix: "provider"
+  }, namespace);
+}
+function createIssuerSecretStore(issuer, options, namespace) {
+  return createNamedSecretStore(issuer, options, {
+    salt: DEFAULT_CLIENT_FILE_SALT,
+    directory: DEFAULT_CLIENT_FILE_DIRECTORY,
+    service: DEFAULT_CLIENT_KEYCHAIN_SERVICE,
+    accountPrefix: "issuer"
+  }, namespace);
+}
+function assertPersistenceNamespace(namespace) {
+  if (namespace !== void 0 && (typeof namespace !== "string" || namespace.trim() === "" || Buffer.byteLength(namespace, "utf8") > 1024))
+    throw new Error("OAuth persistence namespace must be a nonempty string within 1024 bytes");
+}
+function isObjectRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getOwnEntry4(record2, key2) {
+  return Object.prototype.hasOwnProperty.call(record2, key2) ? record2[key2] : void 0;
+}
+function getOwnString(record2, key2) {
+  const value = getOwnEntry4(record2, key2);
+  return typeof value === "string" ? value : void 0;
+}
+function isStoredOAuthSession(value) {
+  if (!isObjectRecord2(value)) {
+    return false;
   }
-  return callback.code;
+  return isNonBlankOwnString(value, "resource") && isNonBlankOwnString(value, "authorizationServer") && normalizeStoredOAuthClient(getOwnEntry4(value, "client")) !== null && isStoredOAuthDiscovery(getOwnEntry4(value, "discovery")) && (getOwnEntry4(value, "requestedScope") === void 0 || isNonBlankOwnString(value, "requestedScope")) && (getOwnEntry4(value, "refreshState") === void 0 || getOwnEntry4(value, "refreshState") === "pending" && getOwnEntry4(value, "tokens") === void 0) && isStoredOAuthTokensOrMissing(getOwnEntry4(value, "tokens"));
 }
-function validateAuthorizationCallbackBinding(callback, expected) {
-  if (expected.state !== null) {
-    if (callback.state === null || callback.state.length === 0) {
-      throw new Error("OAuth callback missing state");
-    }
-    if (callback.state !== expected.state) {
-      throw new Error("OAuth callback state mismatch");
-    }
+function isStoredOAuthDiscovery(value) {
+  if (!isObjectRecord2(value)) {
+    return false;
   }
-  if (expected.requireIssuer) {
-    if (callback.iss === null || callback.iss.length === 0) {
-      throw new Error("OAuth callback missing issuer");
-    }
+  return isNonBlankOwnString(value, "resourceMetadataUrl") && isObjectRecord2(getOwnEntry4(value, "resourceMetadata")) && isObjectRecord2(getOwnEntry4(value, "authorizationServerMetadata"));
+}
+function isStoredOAuthTokensOrMissing(value) {
+  if (value === void 0) {
+    return true;
   }
-  if (callback.iss !== null && callback.iss.length > 0 && expected.issuer !== null && callback.iss !== expected.issuer) {
-    throw new Error("OAuth callback issuer mismatch");
+  if (!isObjectRecord2(value)) {
+    return false;
+  }
+  if (!isNonBlankOwnString(value, "accessToken") || getOwnString(value, "tokenType") !== "Bearer") {
+    return false;
+  }
+  const expiresAt = getOwnEntry4(value, "expiresAt");
+  if (expiresAt !== null && (typeof expiresAt !== "number" || !Number.isSafeInteger(expiresAt) || expiresAt > MAX_JS_DATE_MS || !Number.isFinite(new Date(expiresAt).getTime()))) {
+    return false;
   }
+  const refreshToken = getOwnEntry4(value, "refreshToken");
+  if (refreshToken !== void 0 && (typeof refreshToken !== "string" || refreshToken.trim().length === 0)) {
+    return false;
+  }
+  const scope = getOwnEntry4(value, "scope");
+  return scope === void 0 || typeof scope === "string" && scope.trim().length > 0;
 }
-function createAuthorizationError(error, description) {
-  return new Error(`OAuth authorization failed: ${error} \u2014 ${description}`);
+function isNonBlankOwnString(record2, key2) {
+  const value = getOwnString(record2, key2);
+  return value !== void 0 && value.trim().length > 0;
 }
-function escapeHtml(text) {
-  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+
+// ../mcp-oauth/dist/client/resource-bound-store.js
+function createResourceBoundOAuthStores(options, namespace, identity) {
+  assertPersistenceNamespace(identity);
+  const store = createNamedSecretStore(identity, options, {
+    salt: "poe-code:mcp-oauth:resources:v1",
+    directory: ".poe-code/mcp-oauth/resources",
+    service: "poe-code-mcp-oauth-resources",
+    accountPrefix: "resource"
+  }, namespace);
+  const result = { initialGrantAllowed: true, sessionStore: {}, clientStore: {} };
+  async function read() {
+    const raw = await store.get();
+    if (raw === null)
+      return null;
+    let value;
+    try {
+      value = JSON.parse(raw);
+    } catch {
+      throw new Error("Stored OAuth resource identity must be valid JSON; reset explicitly to recover");
+    }
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+      throw new Error("Invalid stored OAuth resource identity");
+    const record2 = value;
+    if (!["version", "resource", "generation", "session", "clients"].every((key2) => Object.hasOwn(record2, key2)) || record2.version !== 1 || typeof record2.resource !== "string" || record2.resource !== canonicalizeResourceIndicator(record2.resource) || !Number.isSafeInteger(record2.generation) || record2.generation < 0 || record2.session !== null && (!isStoredOAuthSession(record2.session) || record2.session.resource !== record2.resource) || typeof record2.clients !== "object" || record2.clients === null || Array.isArray(record2.clients))
+      throw new Error("Invalid stored OAuth resource identity; reset explicitly to recover");
+    let resourceUrl;
+    try {
+      resourceUrl = new URL(record2.resource);
+    } catch {
+      throw new Error("Invalid stored OAuth resource identity URL");
+    }
+    if (!["http:", "https:"].includes(resourceUrl.protocol) || resourceUrl.username || resourceUrl.password || resourceUrl.hash)
+      throw new Error("Invalid stored OAuth resource identity URL");
+    for (const [issuer, client] of Object.entries(record2.clients)) {
+      const normalized = normalizeStoredOAuthClient(client);
+      let url;
+      try {
+        url = new URL(issuer);
+      } catch {
+        throw new Error("Invalid stored OAuth resource client issuer");
+      }
+      if (normalized === null || !["http:", "https:"].includes(url.protocol) || url.username || url.password || url.hash)
+        throw new Error("Invalid stored OAuth resource client");
+      Object.defineProperty(record2.clients, issuer, { value: normalized, enumerable: true, configurable: true, writable: true });
+    }
+    return record2;
+  }
+  async function reconcile(resource) {
+    resource = canonicalizeResourceIndicator(resource);
+    const existing = await read();
+    if (existing?.resource === resource) {
+      result.initialGrantAllowed = existing.generation === 0;
+      return existing;
+    }
+    const record2 = { version: 1, resource, generation: existing === null ? 0 : existing.generation + 1, session: null, clients: {} };
+    if (!Number.isSafeInteger(record2.generation))
+      throw new Error("OAuth resource identity generation limit exceeded");
+    await store.set(JSON.stringify(record2));
+    result.initialGrantAllowed = record2.generation === 0;
+    return record2;
+  }
+  result.sessionStore = {
+    async withLock(_resource, operation, options2) {
+      if (store.withLock === void 0)
+        throw new Error("OAuth resource identity backend must support transaction locks");
+      return store.withLock(operation, options2);
+    },
+    async load(resource) {
+      return (await reconcile(resource)).session;
+    },
+    async save(resource, session) {
+      const record2 = await reconcile(resource);
+      if (canonicalizeResourceIndicator(session.resource) !== record2.resource)
+        throw new Error("OAuth session does not match its resource identity");
+      record2.session = session;
+      await store.set(JSON.stringify(record2));
+    },
+    async clear(resource) {
+      const record2 = await reconcile(resource);
+      record2.session = null;
+      record2.generation = Math.max(1, record2.generation);
+      result.initialGrantAllowed = false;
+      await store.set(JSON.stringify(record2));
+    }
+  };
+  result.clientStore = {
+    async load(issuer) {
+      const record2 = await read();
+      return record2 !== null && Object.hasOwn(record2.clients, issuer) ? record2.clients[issuer] : null;
+    },
+    async save(issuer, client) {
+      const record2 = await read();
+      if (record2 === null)
+        throw new Error("OAuth resource identity must be bound before registering a client");
+      Object.defineProperty(record2.clients, issuer, { value: client, enumerable: true, configurable: true, writable: true });
+      await store.set(JSON.stringify(record2));
+    },
+    async clear(issuer) {
+      const record2 = await read();
+      if (record2 === null || !Object.hasOwn(record2.clients, issuer))
+        return;
+      delete record2.clients[issuer];
+      await store.set(JSON.stringify(record2));
+    }
+  };
+  return result;
 }
-function buildSuccessPage(landingPage) {
-  const title = landingPage?.title ?? "Connected";
-  const body = landingPage?.body ?? "You can close this tab and return to your terminal.";
-  return [
-    "<!DOCTYPE html>",
-    `<html><head><meta charset=utf-8><title>${escapeHtml(title)}</title></head>`,
-    '<body style="font-family:system-ui,sans-serif;display:flex;align-items:center;justify-content:center;min-height:100vh;margin:0">',
-    '<div style="text-align:center">',
-    `<h1>${escapeHtml(title)}</h1>`,
-    `<p style="color:#666">${escapeHtml(body)}</p>`,
-    "</div></body></html>"
-  ].join("");
+
+// ../mcp-oauth/dist/client/default-oauth-client-provider.js
+import { isIP } from "node:net";
+
+// ../mcp-oauth/dist/http-fetch.js
+async function fetchMcpResponse(fetchImplementation, input, init = {}) {
+  const response = await fetchImplementation(input, { ...init, redirect: "error" });
+  if (response.redirected || response.type === "opaqueredirect") {
+    void response.body?.cancel().catch(() => void 0);
+    throw new Error("MCP HTTP redirects are not allowed");
+  }
+  return response;
 }
 
+// ../mcp-oauth/dist/client/default-oauth-client-provider.js
+import { URL as URL2 } from "node:url";
+
 // ../mcp-oauth/dist/client/pkce.js
 import crypto3 from "node:crypto";
 function generateCodeVerifier() {
@@ -4983,8 +5131,11 @@ function createDefaultOAuthClientProvider(options) {
   const configuredClient = normalizeConfiguredClient(options.client);
   const requestedTokenMethod = normalizeOAuthTokenEndpointAuthMethod(options.client.tokenEndpointAuthMethod);
   const configuredTokenMethod = requestedTokenMethod ?? configuredClient?.tokenEndpointAuthMethod;
-  const sessionStore = options.sessionStore ?? createAuthStoreSessionStore(options.authStore, options.persistenceNamespace);
-  const clientStore = options.authStore === void 0 ? null : createAuthStoreClientStore(options.authStore, options.persistenceNamespace);
+  if (options.resourceIdentity !== void 0 && options.sessionStore !== void 0)
+    throw new Error("OAuth resourceIdentity requires native-owned persistence; custom stores own their resource trust policy");
+  const resourceStores = options.resourceIdentity === void 0 ? void 0 : createResourceBoundOAuthStores(options.authStore ?? {}, options.persistenceNamespace, options.resourceIdentity);
+  const sessionStore = resourceStores?.sessionStore ?? options.sessionStore ?? createAuthStoreSessionStore(options.authStore, options.persistenceNamespace);
+  const clientStore = resourceStores?.clientStore ?? (options.authStore === void 0 ? null : createAuthStoreClientStore(options.authStore, options.persistenceNamespace));
   const now = options.now ?? Date.now;
   const registeredClients = /* @__PURE__ */ new Map();
   if (options.initialGrant !== void 0) {
@@ -4999,7 +5150,7 @@ function createDefaultOAuthClientProvider(options) {
   }
   const initialGrant = options.initialGrant === void 0 ? void 0 : {
     resource: canonicalizeResourceIndicator(options.initialGrant.resource),
-    tokens: normalizeStoredTokens(options.initialGrant.tokens),
+    tokens: normalizeImportedTokens(options.initialGrant.tokens, now),
     client: configuredClient
   };
   if (initialGrant !== void 0 && (initialGrant.tokens === void 0 || initialGrant.client === null))
@@ -5077,6 +5228,15 @@ function createDefaultOAuthClientProvider(options) {
     const canonicalResource = canonicalizeResourceIndicator(resource);
     return withOAuthSessionTransaction(sessionStore, canonicalResource, async () => {
       let session = await loadSession(canonicalResource);
+      if (resourceStores !== void 0) {
+        registeredClients.clear();
+        if (!resourceStores.initialGrantAllowed)
+          initialGrantConsumed = true;
+      }
+      if (session !== null)
+        assertRegistrationIssuer(session.client, session.authorizationServer);
+      if (configuredClient !== null && discovery !== void 0)
+        assertRegistrationIssuer(configuredClient, discovery.authorizationServer);
       if (session !== null && initialGrant?.resource === canonicalResource)
         initialGrantConsumed = true;
       signal?.throwIfAborted();
@@ -5122,6 +5282,11 @@ function createDefaultOAuthClientProvider(options) {
         return session;
       }
       if (session?.tokens?.refreshToken !== void 0 && sessionDiscovery !== void 0 && (forceRefresh || isExpired(session.tokens, now))) {
+        if (hasExpiredClientSecret(session.client, now)) {
+          if (!allowInteractive || options.allowInteractive === false || options.client.mode === "static" || configuredClient?.registration !== void 0)
+            throw new Error("OAuth client secret has expired; authorize again or update the imported registration");
+          return authorizeSession(canonicalResource, clearSessionTokens(session), sessionDiscovery, fetch2, signal);
+        }
         session = await refreshSession(canonicalResource, session, sessionDiscovery, fetch2, signal);
         if (session?.tokens !== void 0 && !isExpired(session.tokens, now)) {
           return session;
@@ -5289,6 +5454,9 @@ function createDefaultOAuthClientProvider(options) {
       if (configuredClient === null) {
         throw new Error("OAuth client_id must not be blank");
       }
+      assertRegistrationIssuer(configuredClient, discovery.authorizationServer);
+      if (hasExpiredClientSecret(configuredClient, now))
+        throw new Error("OAuth client secret has expired; update the imported registration");
       return {
         kind: "static",
         fromStoredRegistration: false,
@@ -5303,7 +5471,14 @@ function createDefaultOAuthClientProvider(options) {
         client: configuredClient
       };
     }
-    const storedClient = await loadRegisteredClient(discovery.authorizationServer);
+    let storedClient = await loadRegisteredClient(discovery.authorizationServer);
+    if (storedClient !== null) {
+      assertRegistrationIssuer(storedClient, discovery.authorizationServer);
+      if (hasExpiredClientSecret(storedClient, now) || !registrationMatchesRedirect(storedClient, redirectUri)) {
+        await clearRegisteredClient(discovery.authorizationServer);
+        storedClient = null;
+      }
+    }
     if (storedClient !== null) {
       return {
         kind: "dynamic",
@@ -5312,7 +5487,7 @@ function createDefaultOAuthClientProvider(options) {
       };
     }
     if (registrationEndpoint === void 0) {
-      if (existingSession !== null && existingSession.client.clientId.length > 0) {
+      if (existingSession !== null && existingSession.client.clientId.length > 0 && !hasExpiredClientSecret(existingSession.client, now) && registrationMatchesRedirect(existingSession.client, redirectUri)) {
         return {
           kind: "dynamic",
           fromStoredRegistration: true,
@@ -5321,7 +5496,7 @@ function createDefaultOAuthClientProvider(options) {
       }
       throw new Error("Authorization server metadata is missing registration_endpoint");
     }
-    if (existingSession !== null && existingSession.client.clientId.length > 0) {
+    if (existingSession !== null && existingSession.client.clientId.length > 0 && !hasExpiredClientSecret(existingSession.client, now) && registrationMatchesRedirect(existingSession.client, redirectUri)) {
       const isConfiguredStaticFallback = configuredClient !== null && existingSession.client.clientId === configuredClient.clientId && existingSession.client.clientSecret === configuredClient.clientSecret;
       if (!isConfiguredStaticFallback) {
         await saveRegisteredClient(discovery.authorizationServer, existingSession.client);
@@ -5357,11 +5532,17 @@ function createDefaultOAuthClientProvider(options) {
       ...responseMethod === void 0 ? {} : { tokenEndpointAuthMethod: responseMethod },
       registration
     };
-    await saveRegisteredClient(discovery.authorizationServer, registeredClient);
+    assertRegistrationIssuer(registeredClient, discovery.authorizationServer);
+    if (hasExpiredClientSecret(registeredClient, now))
+      throw new Error("OAuth client secret has expired in the registration response");
+    if (!registrationMatchesRedirect(registeredClient, redirectUri, true))
+      throw new Error("OAuth registration response does not match the requested redirect URI");
+    const clientWithRedirect = { ...registeredClient, requestedRedirectUri: redirectUri };
+    await saveRegisteredClient(discovery.authorizationServer, clientWithRedirect);
     return {
       kind: "dynamic",
       fromStoredRegistration: false,
-      client: registeredClient
+      client: clientWithRedirect
     };
   }
   async function loadSession(resource) {
@@ -5464,6 +5645,19 @@ function normalizeLoadedSession(session) {
     tokens: normalizeStoredTokens(getOwnEntry6(session, "tokens"))
   };
 }
+function normalizeImportedTokens(value, now) {
+  if (!isObjectRecord3(value))
+    return void 0;
+  const absolute = getOwnEntry6(value, "expiresAt");
+  const lifetime = getOwnEntry6(value, "expiresIn");
+  const issuedAt = getOwnEntry6(value, "issuedAt");
+  if (lifetime !== void 0 && (typeof lifetime !== "number" || !Number.isSafeInteger(lifetime) || lifetime < 0))
+    throw new Error("OAuth initial grant has invalid relative expiry");
+  if (issuedAt !== void 0 && (typeof issuedAt !== "number" || !Number.isSafeInteger(issuedAt) || Math.abs(issuedAt) > MAX_JS_DATE_MS3))
+    throw new Error("OAuth initial grant has invalid issuance time");
+  const expiresAt = absolute !== void 0 && absolute !== null ? absolute : lifetime === void 0 ? null : (issuedAt === void 0 ? now() : issuedAt) + lifetime * 1e3;
+  return normalizeStoredTokens({ ...value, expiresAt });
+}
 function normalizeStoredTokens(value) {
   if (value === void 0 || !isObjectRecord3(value)) {
     return void 0;
@@ -5604,6 +5798,17 @@ function assertRequestMatchesResource(requestUrl, resource) {
     throw new Error(`OAuth request URL ${requestUrl} does not match discovered resource ${resource}`);
   }
 }
+function assertRegistrationIssuer(client, issuer) {
+  const registrationIssuer = client.registration === void 0 ? void 0 : getOwnString2(client.registration, "issuer");
+  if (registrationIssuer !== void 0 && registrationIssuer !== issuer)
+    throw new Error("OAuth client registration issuer does not match the authorization server");
+}
+function hasExpiredClientSecret(client, now) {
+  if (client.clientSecret === void 0 || client.tokenEndpointAuthMethod === "none" || client.registration === void 0)
+    return false;
+  const expiry = getOwnEntry6(client.registration, "client_secret_expires_at");
+  return typeof expiry === "number" && expiry !== 0 && expiry <= now() / 1e3;
+}
 function getSupportedTokenAuthMethods(metadata) {
   const value = getOwnEntry6(metadata, "token_endpoint_auth_methods_supported");
   if (value === void 0)