toolcraft 0.0.314 → 0.0.316

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

@@ -3395,1184 +3395,1336 @@ var SubscriptionManager = class {
   }
 };
 
-// ../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";
+// ../mcp-oauth/dist/client/loopback-authorization.js
+import http from "node:http";
 
-// ../auth-store/dist/error-codes.js
-function hasOwnErrorCode(error, code) {
-  return error instanceof Error && Object.prototype.hasOwnProperty.call(error, "code") && error.code === code;
+// ../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");
 }
-
-// ../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;
+function parseAuthorizationState(value) {
+  if (value === null || value.length === 0) {
+    return null;
+  }
   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;
-    }
-    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 {
-      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();
-      });
+    const decoded = Buffer.from(value, "base64url").toString("utf8");
+    const parsed = JSON.parse(decoded);
+    if (!isObjectRecord(parsed)) {
+      return null;
     }
-    options.signal?.throwIfAborted();
-    outcome = { result: await operation() };
-  } catch (error) {
-    outcome = { error };
-  }
-  const cleanup = [];
-  for (const target of [...temporaryCreated ? [temporaryPath] : [], ...claimed ? [claimPath] : []]) {
-    try {
-      await fs2.unlink(target);
-    } catch (error) {
-      if (!hasOwnErrorCode(error, "ENOENT"))
-        cleanup.push(error);
+    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 {
+    return null;
   }
-  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 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;
+}
+
+// ../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 {
-    if ((await fs2.lstat(target)).isSymbolicLink())
-      throw new Error("Refusing secret-store transaction lock through symbolic link");
+    port = await startServer(server, target.port, target.host, controller.signal);
   } catch (error) {
-    if (!hasOwnErrorCode(error, "ENOENT"))
-      throw error;
-  }
-}
-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);
+    controller.abort(error);
+    throw error;
   }
-}
-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) {
+  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 {
-        await fs2.unlink(target);
-      } catch (error) {
-        if (!hasOwnErrorCode(error, "ENOENT"))
-          throw error;
+        return await waitForAuthorizationCode(server, authorizationUrl, options, target.callbackPath, controller.signal);
+      } finally {
+        clearTimeout(timer);
       }
-      continue;
-    }
-    let ticket = null;
-    let raw;
-    try {
-      raw = await fs2.readFile(target, "utf8");
-    } catch (error) {
-      if (hasOwnErrorCode(error, "ENOENT"))
-        continue;
-      throw error;
+    },
+    close() {
+      controller.abort(new Error("OAuth authorization session closed"));
     }
+  };
+}
+function loopbackTarget(options) {
+  if (options.redirectUri !== void 0) {
+    let url;
     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 {
+      url = new URL(options.redirectUri);
+    } catch (cause) {
+      throw new Error("Invalid OAuth loopback redirect URI", { cause });
     }
-    claims.push({ name, ticket });
+    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 };
   }
-  return claims;
+  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 };
 }
-
-// ../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")
+async function startServer(server, port, host, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      server.off("error", handleError);
+      signal.removeEventListener("abort", aborted);
     };
-    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;
+    const handleError = (error) => {
+      cleanup();
+      reject(error);
+    };
+    const aborted = () => {
+      cleanup();
+      reject(signal.reason);
+    };
+    server.once("error", handleError);
+    signal.addEventListener("abort", aborted, { once: true });
     try {
-      await this.assertCredentialPathHasNoSymbolicLinks(temporaryPath);
-      await this.fs.writeFile(temporaryPath, JSON.stringify(document), {
-        encoding: "utf8",
-        flag: "wx",
-        mode: ENCRYPTION_FILE_MODE
+      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);
       });
-      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;
+      cleanup();
+      reject(error);
     }
-  }
-  async delete() {
-    await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
-    try {
-      await this.fs.unlink(this.filePath);
-    } catch (error) {
-      if (!isNotFoundError(error)) {
-        throw error;
+  });
+}
+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;
       }
-    }
-  }
-  async assertCredentialPathHasNoSymbolicLinks(targetPath) {
-    const resolvedPath = path2.resolve(targetPath);
-    const protectedPaths = getProtectedCredentialPaths(resolvedPath, this.symbolicLinkCheckStartPath);
-    for (const currentPath of protectedPaths) {
+      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 {
-        const stats = await this.fs.lstat(currentPath);
-        if (stats.isSymbolicLink()) {
-          throw new Error(`Refusing to use encrypted credential path through symbolic link: ${currentPath}`);
-        }
+        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) {
-        if (isNotFoundError(error)) {
-          return;
-        }
-        throw 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)));
     }
-  }
-  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;
+    if (options.openBrowser !== void 0) {
+      void Promise.resolve().then(() => settled ? void 0 : options.openBrowser(authorizationUrl)).catch((error) => settle(() => reject(error)));
     }
-    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];
-  }
-  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 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");
+function extractCallbackParametersFromInput(input) {
+  const trimmed = input.replaceAll("\r", "").replaceAll("\n", "").trim();
+  if (trimmed.length === 0) {
+    return null;
   }
-  for (const segment of splitPathSegments(defaultDirectory)) {
-    if (segment === "..") {
-      throw new Error("defaultDirectory must be a relative path inside the home directory");
-    }
-  }
-}
-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");
-  }
-}
-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;
-    }
-    protectedPaths.push(currentPath);
-  }
-  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 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
+    };
   }
 }
-function defaultMachineIdentity() {
+function readExpectedAuthorizationCallback(authorizationUrl) {
+  const url = new URL(authorizationUrl);
+  const state = url.searchParams.get("state");
+  const parsedState = parseAuthorizationState(state);
   return {
-    hostname: hostname(),
-    username: userInfo().username
+    state,
+    issuer: parsedState?.issuer ?? null,
+    requireIssuer: parsedState?.requireIssuer ?? false
   };
 }
-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;
+function validateAuthorizationCallbackParameters(callback, expected) {
+  validateAuthorizationCallbackBinding(callback, expected);
+  if (callback.code === null || callback.code.length === 0) {
+    throw new Error("OAuth callback missing authorization code");
   }
-  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;
-  });
+  return callback.code;
 }
-function parseEncryptedDocument(raw) {
-  try {
-    const parsed = JSON.parse(raw);
-    if (!isRecord2(parsed)) {
-      return null;
+function validateAuthorizationCallbackBinding(callback, expected) {
+  if (expected.state !== null) {
+    if (callback.state === null || callback.state.length === 0) {
+      throw new Error("OAuth callback missing state");
     }
-    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 (callback.state !== expected.state) {
+      throw new Error("OAuth callback state mismatch");
     }
-    if (typeof iv !== "string" || typeof authTag !== "string" || typeof ciphertext !== "string") {
-      return null;
+  }
+  if (expected.requireIssuer) {
+    if (callback.iss === null || callback.iss.length === 0) {
+      throw new Error("OAuth callback missing issuer");
     }
-    return {
-      version,
-      iv,
-      authTag,
-      ciphertext
-    };
-  } catch {
-    return null;
+  }
+  if (callback.iss !== null && callback.iss.length > 0 && expected.issuer !== null && callback.iss !== expected.issuer) {
+    throw new Error("OAuth callback issuer mismatch");
   }
 }
-function isRecord2(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+function createAuthorizationError(error, description) {
+  return new Error(`OAuth authorization failed: ${error} \u2014 ${description}`);
 }
-function getOwnEntry(record2, key2) {
-  return Object.prototype.hasOwnProperty.call(record2, key2) ? record2[key2] : void 0;
+function escapeHtml(text) {
+  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
 }
-function isNotFoundError(error) {
-  return hasOwnErrorCode(error, "ENOENT");
+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("");
 }
-function isAlreadyExistsError(error) {
-  return hasOwnErrorCode(error, "EEXIST");
+
+// ../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;
 }
 
-// ../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);
+// ../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)];
+    }));
+  }
+  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();
   }
-  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);
+  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();
   }
-  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);
-    }
+  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();
   }
-  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;
-    }
-    throw createSecurityCliFailure("delete secret from macOS Keychain", result);
+  try {
+    normalizeOAuthScope(Object.hasOwn(record2, "scope") && record2.scope !== null ? record2.scope : void 0);
+  } catch {
+    throw invalid();
   }
-  async executeSecurityCommand(args, operation, options) {
+  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 requestedRedirectUri = Object.hasOwn(record2, "requestedRedirectUri") ? record2.requestedRedirectUri : void 0;
+  if (requestedRedirectUri !== void 0) {
     try {
-      if (options === void 0) {
-        return await this.runCommand(SECURITY_CLI, args);
-      }
-      return await this.runCommand(SECURITY_CLI, args, options);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      throw new Error(`Failed to ${operation}: ${message}`);
+      if (typeof requestedRedirectUri !== "string")
+        throw new Error("Invalid redirect identity");
+      loopbackTarget({ redirectUri: requestedRedirectUri });
+    } catch {
+      throw new Error("Invalid stored OAuth registration redirect identity");
+    }
+    client.requestedRedirectUri = requestedRedirectUri;
+  }
+  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 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;
     }
-  }
-};
-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);
-      });
-      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
-      });
-    });
+    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 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 = 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;
+
+// ../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/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");
+// ../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;
     }
-    return new EncryptedFileStore(input.fileStore);
-  },
-  keychain: (input) => {
-    if (!input.keychainStore) {
-      throw new Error("keychainStore configuration is required for keychain backend");
+    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 {
+      await fs2.writeFile(temporaryPath, JSON.stringify({ ticket }), { encoding: "utf8", flag: "wx", mode: 384 });
+    } catch (error) {
+      if (hasOwnErrorCode(error, "EEXIST"))
+        temporaryCreated = false;
+      throw error;
     }
-    return new KeychainStore(input.keychainStore);
+    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();
+      });
+    }
+    options.signal?.throwIfAborted();
+    outcome = { result: await operation() };
+  } catch (error) {
+    outcome = { error };
   }
-};
-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 cleanup = [];
+  for (const target of [...temporaryCreated ? [temporaryPath] : [], ...claimed ? [claimPath] : []]) {
+    try {
+      await fs2.unlink(target);
+    } catch (error) {
+      if (!hasOwnErrorCode(error, "ENOENT"))
+        cleanup.push(error);
+    }
   }
-  const store = storeFactories[backend](input);
-  return { backend, store };
+  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 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";
+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;
   }
-  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 {
-    url = value instanceof URL ? new URL(value.toString()) : new URL(value);
-  } catch {
-    throw new Error("Resource indicator must be an absolute URL");
+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);
   }
-  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) {
-        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;
+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;
       }
-      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();
+      continue;
     }
-  };
+    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 });
+  }
+  return claims;
 }
-function createAuthStoreClientStore(options, namespace) {
-  assertPersistenceNamespace(namespace);
-  return {
-    async load(issuer) {
-      const store = createIssuerSecretStore(issuer, options, namespace);
-      const value = await store.get();
-      if (value === null) {
+
+// ../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;
       }
-      let parsed;
-      try {
-        parsed = JSON.parse(value);
-      } catch {
-        throw new Error("Stored OAuth client 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;
       }
-      const clientId = isObjectRecord(parsed) ? getOwnString(parsed, "clientId") : void 0;
-      if (clientId !== void 0) {
-        const client = { clientId };
-        if (isObjectRecord(parsed) && Object.prototype.hasOwnProperty.call(parsed, "clientSecret")) {
-          client.clientSecret = getOwnEntry3(parsed, "clientSecret");
+      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;
+    }
+  }
+  async delete() {
+    await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
+    try {
+      await this.fs.unlink(this.filePath);
+    } catch (error) {
+      if (!isNotFoundError(error)) {
+        throw error;
+      }
+    }
+  }
+  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}`);
         }
-        return client;
+      } catch (error) {
+        if (isNotFoundError(error)) {
+          return;
+        }
+        throw error;
       }
-      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") && isStoredOAuthClient(getOwnEntry3(value, "client")) && 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 isStoredOAuthClient(value) {
-  if (!isObjectRecord(value) || !isNonBlankOwnString(value, "clientId")) {
-    return false;
+function getProtectedCredentialPaths(resolvedPath, symbolicLinkCheckStartPath) {
+  if (symbolicLinkCheckStartPath === null) {
+    return getExplicitProtectedCredentialPaths(resolvedPath);
   }
-  const clientSecret = getOwnEntry3(value, "clientSecret");
-  return clientSecret === void 0 || typeof clientSecret === "string" && clientSecret.trim().length > 0;
-}
-function isStoredOAuthDiscovery(value) {
-  if (!isObjectRecord(value)) {
-    return false;
+  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;
-}
-function isNonBlankOwnString(record2, key2) {
-  const value = getOwnString(record2, key2);
-  return value !== void 0 && value.trim().length > 0;
+  return protectedPaths;
 }
-
-// ../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;
+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");
+    }
+  }
+  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);
+    }
   }
-  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 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;
     }
-  };
-}
-function loopbackTarget(options) {
-  if (options.redirectUri !== void 0) {
-    let url;
+    throw createSecurityCliFailure("delete secret from macOS Keychain", result);
+  }
+  async executeSecurityCommand(args, operation, options) {
     try {
-      url = new URL(options.redirectUri);
-    } catch (cause) {
-      throw new Error("Invalid OAuth loopback redirect URI", { cause });
+      if (options === void 0) {
+        return await this.runCommand(SECURITY_CLI, args);
+      }
+      return await this.runCommand(SECURITY_CLI, args, options);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to ${operation}: ${message}`);
     }
-    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 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);
+};
+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 = () => {
-      cleanup();
-      reject(signal.reason);
+    const appendStdinError = () => {
+      if (stdinErrorMessage === void 0) {
+        return;
+      }
+      appendStderr(stdinErrorMessage);
+      stdinErrorMessage = void 0;
     };
-    server.once("error", handleError);
-    signal.addEventListener("abort", aborted, { once: true });
-    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);
+    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);
       });
-    } catch (error) {
-      cleanup();
-      reject(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 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)));
+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");
     }
-    if (options.openBrowser !== void 0) {
-      void Promise.resolve().then(() => settled ? void 0 : options.openBrowser(authorizationUrl)).catch((error) => settle(() => reject(error)));
+    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 extractCallbackParametersFromInput(input) {
-  const trimmed = input.replaceAll("\r", "").replaceAll("\n", "").trim();
-  if (trimmed.length === 0) {
-    return null;
+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 escapeHtml(text) {
-  return text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;");
+function isNonBlankOwnString(record2, key2) {
+  const value = getOwnString(record2, key2);
+  return value !== void 0 && value.trim().length > 0;
 }
-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() {
@@ -4665,6 +4817,7 @@ async function exchangeAuthorizationCode(input) {
     tokenEndpoint: input.tokenEndpoint,
     clientId: input.clientId,
     clientSecret: input.clientSecret,
+    tokenEndpointAuthMethod: input.tokenEndpointAuthMethod,
     params: {
       grant_type: "authorization_code",
       code: input.code,
@@ -4683,6 +4836,7 @@ async function refreshAccessToken(input) {
     tokenEndpoint: input.tokenEndpoint,
     clientId: input.clientId,
     clientSecret: input.clientSecret,
+    tokenEndpointAuthMethod: input.tokenEndpointAuthMethod,
     params: {
       grant_type: "refresh_token",
       refresh_token: input.refreshToken,
@@ -4694,21 +4848,26 @@ async function refreshAccessToken(input) {
   });
 }
 async function requestTokens(input) {
-  const body = new URLSearchParams({
-    client_id: input.clientId,
-    ...input.params
-  });
-  if (input.clientSecret !== void 0) {
-    body.set("client_secret", input.clientSecret);
+  const method = normalizeOAuthTokenEndpointAuthMethod(input.tokenEndpointAuthMethod) ?? (input.clientSecret === void 0 ? "none" : "client_secret_post");
+  if (method !== "none" && (input.clientSecret === void 0 || input.clientSecret.trim() === ""))
+    throw new Error("OAuth token endpoint authentication requires a client secret");
+  const body = new URLSearchParams(input.params);
+  const headers = new Headers({ "Content-Type": "application/x-www-form-urlencoded" });
+  if (method === "client_secret_basic") {
+    const encoded = new URLSearchParams({ credential: input.clientId }).toString().slice("credential=".length);
+    const encodedSecret = new URLSearchParams({ credential: input.clientSecret }).toString().slice("credential=".length);
+    headers.set("Authorization", `Basic ${Buffer.from(`${encoded}:${encodedSecret}`).toString("base64")}`);
+  } else {
+    body.set("client_id", input.clientId);
+    if (method === "client_secret_post")
+      body.set("client_secret", input.clientSecret);
   }
   input.signal?.throwIfAborted();
   const deadline = AbortSignal.timeout(3e4);
   const signal = input.signal === void 0 ? deadline : AbortSignal.any([input.signal, deadline]);
   const response = await fetchMcpResponse(input.fetch, input.tokenEndpoint, {
     method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded"
-    },
+    headers,
     body: body.toString(),
     signal
   });
@@ -4861,6 +5020,9 @@ function createDefaultOAuthClientProvider(options) {
   assertPersistenceNamespace(options.persistenceNamespace);
   const clientMetadata = getClientMetadata(options.client);
   const requestedScope = clientMetadata?.scope;
+  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);
   const now = options.now ?? Date.now;
@@ -4877,8 +5039,8 @@ function createDefaultOAuthClientProvider(options) {
   }
   const initialGrant = options.initialGrant === void 0 ? void 0 : {
     resource: canonicalizeResourceIndicator(options.initialGrant.resource),
-    tokens: normalizeStoredTokens(options.initialGrant.tokens),
-    client: normalizeConfiguredClient(options.client)
+    tokens: normalizeImportedTokens(options.initialGrant.tokens, now),
+    client: configuredClient
   };
   if (initialGrant !== void 0 && (initialGrant.tokens === void 0 || initialGrant.client === null))
     throw new Error("OAuth initial grant requires valid tokens and the original client ID");
@@ -4955,6 +5117,10 @@ function createDefaultOAuthClientProvider(options) {
     const canonicalResource = canonicalizeResourceIndicator(resource);
     return withOAuthSessionTransaction(sessionStore, canonicalResource, async () => {
       let session = await loadSession(canonicalResource);
+      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();
@@ -4982,13 +5148,15 @@ function createDefaultOAuthClientProvider(options) {
       if (forceRefresh && rejectedTokens !== void 0 && (rejectedTokens === null || session?.tokens === void 0 || !sameTokenGrant(session.tokens, rejectedTokens)))
         forceRefresh = false;
       const sessionDiscovery = resolveDiscovery(discovery, session);
-      if ((options.client.mode === "static" || initialGrant !== void 0) && session !== null && (session.tokens !== void 0 || session.refreshState === "pending")) {
-        const configured = normalizeConfiguredClient(options.client);
+      if ((options.client.mode === "static" || configuredClient?.registration !== void 0 || initialGrant !== void 0) && session !== null && (session.tokens !== void 0 || session.refreshState === "pending")) {
+        const configured = configuredClient;
         if (configured === null || configured.clientId !== session.client.clientId || configured.clientSecret !== session.client.clientSecret)
           throw new Error("Stored session belongs to a different OAuth client; use separate persistence or explicitly reset it");
       }
       if (requestedScope !== void 0 && session?.tokens !== void 0 && normalizeOAuthScope(session.tokens.scope ?? session.requestedScope) !== requestedScope)
         throw new Error("Stored session does not match the requested OAuth scope; authorize again or select separate persistence");
+      if (configuredTokenMethod !== void 0 && session !== null && (session.tokens !== void 0 || session.refreshState === "pending") && (session.client.tokenEndpointAuthMethod ?? (session.client.clientSecret === void 0 ? "none" : "client_secret_post")) !== configuredTokenMethod)
+        throw new Error("Stored session does not match the requested OAuth token endpoint authentication; select separate persistence or reset it");
       if (session?.refreshState === "pending") {
         if (!allowInteractive || options.allowInteractive === false || sessionDiscovery === void 0)
           throw new Error("OAuth refresh outcome is unknown; authorize again before using this resource");
@@ -4998,6 +5166,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;
@@ -5021,6 +5194,7 @@ function createDefaultOAuthClientProvider(options) {
     if (session.tokens?.refreshToken === void 0) {
       return session;
     }
+    assertTokenEndpointAuthentication(session.client, discovery.authorizationServerMetadata);
     const pendingSession = { ...clearSessionTokens(session), refreshState: "pending" };
     await saveSession(resource, pendingSession);
     signal?.throwIfAborted();
@@ -5032,6 +5206,7 @@ function createDefaultOAuthClientProvider(options) {
           tokenEndpoint: requireOwnString(discovery.authorizationServerMetadata, "token_endpoint", "Authorization server metadata"),
           clientId: session.client.clientId,
           clientSecret: session.client.clientSecret,
+          tokenEndpointAuthMethod: session.client.tokenEndpointAuthMethod,
           refreshToken: session.tokens.refreshToken,
           resource,
           fetch: fetch2,
@@ -5095,6 +5270,7 @@ function createDefaultOAuthClientProvider(options) {
       let resolvedClient = null;
       try {
         resolvedClient = await resolveClient(currentSession, discovery, loopback.redirectUri, fetch2, signal);
+        assertTokenEndpointAuthentication(resolvedClient.client, discovery.authorizationServerMetadata);
         const sessionWithoutTokens = {
           resource,
           authorizationServer: discovery.authorizationServer,
@@ -5118,6 +5294,7 @@ function createDefaultOAuthClientProvider(options) {
           tokenEndpoint: requireOwnString(discovery.authorizationServerMetadata, "token_endpoint", "Authorization server metadata"),
           clientId: resolvedClient.client.clientId,
           clientSecret: resolvedClient.client.clientSecret,
+          tokenEndpointAuthMethod: resolvedClient.client.tokenEndpointAuthMethod,
           code,
           codeVerifier: verifier,
           redirectUri: loopback.redirectUri,
@@ -5157,11 +5334,13 @@ function createDefaultOAuthClientProvider(options) {
   }
   async function resolveClient(existingSession, discovery, redirectUri, fetch2, parentSignal) {
     parentSignal?.throwIfAborted();
-    const configuredClient = normalizeConfiguredClient(options.client);
-    if (options.client.mode === "static") {
+    if (options.client.mode === "static" || configuredClient?.registration !== void 0) {
       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,
@@ -5176,7 +5355,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",
@@ -5185,7 +5371,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,
@@ -5194,7 +5380,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);
@@ -5205,7 +5391,11 @@ function createDefaultOAuthClientProvider(options) {
         };
       }
     }
-    const registrationBody = buildClientRegistrationBody(clientMetadata, redirectUri);
+    const supported = getSupportedTokenAuthMethods(discovery.authorizationServerMetadata);
+    const registrationMethod = requestedTokenMethod ?? (supported === void 0 ? "none" : ["none", "client_secret_basic", "client_secret_post"].find((method) => supported.includes(method)));
+    if (registrationMethod === void 0 || supported !== void 0 && !supported.includes(registrationMethod))
+      throw new Error("Authorization server does not support the requested OAuth token endpoint authentication");
+    const registrationBody = buildClientRegistrationBody(clientMetadata, redirectUri, registrationMethod);
     const deadline = AbortSignal.timeout(3e4);
     const signal = parentSignal === void 0 ? deadline : AbortSignal.any([parentSignal, deadline]);
     const response = await fetchMcpResponse(fetch2, registrationEndpoint, {
@@ -5217,27 +5407,33 @@ function createDefaultOAuthClientProvider(options) {
       signal
     });
     const payload = await readOAuthJsonObjectResponse(response, signal);
-    const clientId = getOwnString2(payload, "client_id");
-    if (clientId === void 0 || clientId.trim().length === 0) {
-      throw new Error("OAuth client registration response missing client_id");
-    }
-    const clientSecret = getOwnString2(payload, "client_secret");
+    const registration = parseOAuthClientRegistration(payload);
+    const registeredSecret = getOwnString2(registration, "client_secret");
+    const responseMethod = normalizeOAuthTokenEndpointAuthMethod(getOwnEntry6(registration, "token_endpoint_auth_method")) ?? requestedTokenMethod ?? (supported === void 0 ? void 0 : normalizeOAuthTokenEndpointAuthMethod(registrationMethod));
     const registeredClient = {
-      clientId: clientId.trim(),
-      clientSecret: clientSecret !== void 0 && clientSecret.trim().length > 0 ? clientSecret.trim() : void 0
+      clientId: registration.client_id.trim(),
+      ...registeredSecret === void 0 ? {} : { clientSecret: registeredSecret.trim() },
+      ...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) {
     return normalizeLoadedSession(await sessionStore.load(resource));
   }
   async function saveSession(resource, session) {
-    await sessionStore.save(resource, session);
+    await sessionStore.save(resource, structuredClone(session));
   }
   async function clearSession(resource) {
     await sessionStore.clear(resource);
@@ -5250,7 +5446,7 @@ function createDefaultOAuthClientProvider(options) {
       return null;
     }
     const client = await clientStore.load(issuer);
-    const normalizedClient = client === null ? null : normalizeStoredClient(client);
+    const normalizedClient = client === null ? null : normalizeStoredOAuthClient(client);
     if (client !== null && normalizedClient === null) {
       await clientStore.clear(issuer);
       return null;
@@ -5323,7 +5519,7 @@ function normalizeLoadedSession(session) {
   const refreshState = getOwnEntry6(session, "refreshState");
   if (refreshState !== void 0 && (refreshState !== "pending" || getOwnEntry6(session, "tokens") !== void 0))
     throw new Error("Stored OAuth refresh state is invalid");
-  const client = normalizeStoredClient(getOwnEntry6(session, "client"));
+  const client = normalizeStoredOAuthClient(getOwnEntry6(session, "client"));
   if (client === null) {
     return { ...session, client: { clientId: "" }, tokens: void 0 };
   }
@@ -5333,24 +5529,18 @@ function normalizeLoadedSession(session) {
     tokens: normalizeStoredTokens(getOwnEntry6(session, "tokens"))
   };
 }
-function normalizeStoredClient(value) {
-  if (!isObjectRecord3(value)) {
-    return null;
-  }
-  const clientId = getOwnString2(value, "clientId");
-  if (clientId === void 0 || clientId.trim().length === 0) {
-    return null;
-  }
-  const normalizedClientId = clientId.trim();
-  const clientSecret = getOwnEntry6(value, "clientSecret");
-  if (clientSecret === void 0) {
-    return { clientId: normalizedClientId };
-  }
-  if (typeof clientSecret !== "string" || clientSecret.trim().length === 0) {
-    return null;
-  }
-  const normalizedClientSecret = clientSecret.trim();
-  return { clientId: normalizedClientId, clientSecret: normalizedClientSecret };
+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)) {
@@ -5387,12 +5577,12 @@ function getClientMetadata(client) {
   };
 }
 function normalizeConfiguredClient(client) {
-  const clientId = normalizeOptionalOAuthString(client.clientId);
-  if (clientId === void 0) {
+  const registration = client.registration === void 0 ? void 0 : parseOAuthClientRegistration(client.registration);
+  const clientId = normalizeOptionalOAuthString(client.clientId) ?? registration?.client_id.trim();
+  if (clientId === void 0)
     return null;
-  }
-  const clientSecret = normalizeOptionalOAuthString(client.clientSecret);
-  return clientSecret === void 0 ? { clientId } : { clientId, clientSecret };
+  const clientSecret = normalizeOptionalOAuthString(client.clientSecret) ?? (registration === void 0 ? void 0 : getOwnString2(registration, "client_secret")?.trim());
+  return normalizeStoredOAuthClient({ clientId, clientSecret, registration, tokenEndpointAuthMethod: client.tokenEndpointAuthMethod });
 }
 function normalizeOptionalOAuthString(value) {
   if (value === void 0) {
@@ -5492,12 +5682,39 @@ function assertRequestMatchesResource(requestUrl, resource) {
     throw new Error(`OAuth request URL ${requestUrl} does not match discovered resource ${resource}`);
   }
 }
-function buildClientRegistrationBody(metadata, redirectUri) {
+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)
+    return void 0;
+  if (!Array.isArray(value) || value.length > 128 || value.some((method) => typeof method !== "string"))
+    throw new Error("Invalid OAuth token endpoint authentication metadata");
+  return value;
+}
+function assertTokenEndpointAuthentication(client, metadata) {
+  const method = client.tokenEndpointAuthMethod ?? (client.clientSecret === void 0 ? "none" : "client_secret_post");
+  if (method !== "none" && client.clientSecret === void 0)
+    throw new Error("OAuth token endpoint authentication requires a client secret");
+  const supported = getSupportedTokenAuthMethods(metadata);
+  if (supported !== void 0 && !supported.includes(method))
+    throw new Error("Authorization server does not support the requested OAuth token endpoint authentication");
+}
+function buildClientRegistrationBody(metadata, redirectUri, tokenEndpointAuthMethod) {
   const body = {
     redirect_uris: [redirectUri],
     grant_types: ["authorization_code", "refresh_token"],
     response_types: ["code"],
-    token_endpoint_auth_method: "none"
+    token_endpoint_auth_method: tokenEndpointAuthMethod
   };
   const clientName = metadata === void 0 ? void 0 : getOwnString2(metadata, "clientName");
   const scope = metadata === void 0 ? void 0 : getOwnString2(metadata, "scope");