fastmcp 4.9.0 → 4.9.2

package/dist/{chunk-IX3HKAX4.cjs → chunk-DZYT6QAH.cjs}

@@ -37,6 +37,237 @@ function requireScopes(...requiredScopes) {
 var _crypto = require('crypto');
 var _zod = require('zod');
 
+// src/auth/OAuthProxyStateStore.ts
+
+var STORAGE_KEY_PREFIX = {
+  client: "client:",
+  code: "code:",
+  transaction: "transaction:"
+};
+var storedDateSchema = _zod.z.union([_zod.z.date(), _zod.z.string()]).transform((value, context) => {
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) {
+    context.addIssue({
+      code: "custom",
+      message: "Invalid stored date"
+    });
+    return _zod.z.NEVER;
+  }
+  return date;
+});
+var dcrClientMetadataSchema = _zod.z.object({
+  client_name: _zod.z.string().optional(),
+  client_uri: _zod.z.string().optional(),
+  contacts: _zod.z.array(_zod.z.string()).optional(),
+  jwks: _zod.z.record(_zod.z.string(), _zod.z.unknown()).optional(),
+  jwks_uri: _zod.z.string().optional(),
+  logo_uri: _zod.z.string().optional(),
+  policy_uri: _zod.z.string().optional(),
+  scope: _zod.z.string().optional(),
+  software_id: _zod.z.string().optional(),
+  software_version: _zod.z.string().optional(),
+  tos_uri: _zod.z.string().optional()
+});
+var proxyDcrClientStorageSchema = _zod.z.object({
+  callbackUrl: _zod.z.string(),
+  clientId: _zod.z.string(),
+  clientSecret: _zod.z.string().optional(),
+  metadata: dcrClientMetadataSchema.optional(),
+  redirectUris: _zod.z.array(_zod.z.string()),
+  registeredAt: storedDateSchema
+});
+var upstreamTokenSetStorageSchema = _zod.z.object({
+  accessToken: _zod.z.string(),
+  expiresIn: _zod.z.number(),
+  idToken: _zod.z.string().optional(),
+  issuedAt: storedDateSchema,
+  refreshExpiresIn: _zod.z.number().optional(),
+  refreshToken: _zod.z.string().optional(),
+  scope: _zod.z.array(_zod.z.string()),
+  tokenType: _zod.z.string()
+});
+var clientCodeStorageSchema = _zod.z.object({
+  clientId: _zod.z.string(),
+  code: _zod.z.string(),
+  codeChallenge: _zod.z.string(),
+  codeChallengeMethod: _zod.z.string(),
+  createdAt: storedDateSchema,
+  expiresAt: storedDateSchema,
+  transactionId: _zod.z.string(),
+  upstreamTokens: upstreamTokenSetStorageSchema,
+  used: _zod.z.boolean().optional()
+});
+var spentClientCodeStorageSchema = _zod.z.object({
+  expiresAt: storedDateSchema,
+  used: _zod.z.literal(true)
+});
+var oauthTransactionStorageSchema = _zod.z.object({
+  clientCallbackUrl: _zod.z.string(),
+  clientCodeChallenge: _zod.z.string(),
+  clientCodeChallengeMethod: _zod.z.string(),
+  clientId: _zod.z.string(),
+  consentGiven: _zod.z.boolean().optional(),
+  createdAt: storedDateSchema,
+  expiresAt: storedDateSchema,
+  id: _zod.z.string(),
+  metadata: _zod.z.record(_zod.z.string(), _zod.z.unknown()).optional(),
+  proxyCodeChallenge: _zod.z.string(),
+  proxyCodeVerifier: _zod.z.string(),
+  scope: _zod.z.array(_zod.z.string()),
+  state: _zod.z.string()
+});
+var OAuthProxyStateStore = class {
+  
+  
+  constructor(config) {
+    this.registeredClientsByClientId = config.registeredClientsByClientId;
+    this.tokenStorage = config.tokenStorage;
+  }
+  cacheRegisteredClient(client) {
+    this.registeredClientsByClientId.set(client.clientId, client);
+  }
+  /**
+   * Atomically consume an authorization code. At most one caller — across all
+   * processes sharing the storage — can receive a given code, which is what
+   * makes single use enforceable (RFC 6749 §4.1.2).
+   *
+   * Spent codes are taken too, so the caller must write the tombstone back
+   * with `markClientCodeSpent` to keep reporting the precise error on the
+   * attempt after this one.
+   */
+  async consumeClientCode(code) {
+    const stored = await this.takeFromStorage(
+      `${STORAGE_KEY_PREFIX.code}${code}`
+    );
+    const spent = spentClientCodeStorageSchema.safeParse(stored);
+    if (spent.success) {
+      return this.isExpired(spent.data.expiresAt) ? null : { expiresAt: spent.data.expiresAt, status: "spent" };
+    }
+    const parsed = clientCodeStorageSchema.safeParse(stored);
+    if (!parsed.success || this.isExpired(parsed.data.expiresAt)) {
+      return null;
+    }
+    return {
+      clientCode: parsed.data,
+      expiresAt: parsed.data.expiresAt,
+      status: "active"
+    };
+  }
+  /**
+   * Atomically consume a transaction, so a callback can only be redeemed once
+   * no matter which instance it lands on.
+   */
+  async consumeTransaction(transactionId) {
+    const stored = await this.takeFromStorage(
+      `${STORAGE_KEY_PREFIX.transaction}${transactionId}`
+    );
+    const parsed = oauthTransactionStorageSchema.safeParse(stored);
+    if (!parsed.success || this.isExpired(parsed.data.expiresAt)) {
+      return null;
+    }
+    return parsed.data;
+  }
+  async deleteTransaction(transactionId) {
+    await this.tokenStorage.delete(
+      `${STORAGE_KEY_PREFIX.transaction}${transactionId}`
+    );
+  }
+  async getRegisteredClientByClientId(clientId) {
+    const cached = this.registeredClientsByClientId.get(clientId);
+    if (cached) {
+      return cached;
+    }
+    const stored = await this.tokenStorage.get(
+      `${STORAGE_KEY_PREFIX.client}${clientId}`
+    );
+    const parsed = proxyDcrClientStorageSchema.safeParse(stored);
+    if (!parsed.success) {
+      return null;
+    }
+    this.cacheRegisteredClient(parsed.data);
+    return parsed.data;
+  }
+  /**
+   * Read a transaction without consuming it. Used by the consent screen, which
+   * has to hand the same transaction back to the upstream redirect.
+   */
+  async getTransaction(transactionId) {
+    const stored = await this.tokenStorage.get(
+      `${STORAGE_KEY_PREFIX.transaction}${transactionId}`
+    );
+    const parsed = oauthTransactionStorageSchema.safeParse(stored);
+    if (!parsed.success) {
+      return null;
+    }
+    if (this.isExpired(parsed.data.expiresAt)) {
+      await this.deleteTransaction(transactionId);
+      return null;
+    }
+    return parsed.data;
+  }
+  async isTransactionCallbackRegistered(transaction) {
+    const registeredClient = await this.getRegisteredClientByClientId(
+      transaction.clientId
+    );
+    return _nullishCoalesce(_optionalChain([registeredClient, 'optionalAccess', _ => _.redirectUris, 'access', _2 => _2.includes, 'call', _3 => _3(transaction.clientCallbackUrl)]), () => ( false));
+  }
+  /**
+   * Record that an authorization code has been redeemed, so a later attempt
+   * gets "already used" rather than looking like an unknown code. Keyed and
+   * expiring exactly like the code it replaces, so it cannot outlive it.
+   */
+  async markClientCodeSpent(code, expiresAt) {
+    await this.tokenStorage.save(
+      `${STORAGE_KEY_PREFIX.code}${code}`,
+      { expiresAt, used: true },
+      this.getTtlSeconds(expiresAt)
+    );
+  }
+  async saveClientCode(clientCode) {
+    await this.tokenStorage.save(
+      `${STORAGE_KEY_PREFIX.code}${clientCode.code}`,
+      clientCode,
+      this.getTtlSeconds(clientCode.expiresAt)
+    );
+  }
+  async saveRegisteredClient(client) {
+    await this.tokenStorage.save(
+      `${STORAGE_KEY_PREFIX.client}${client.clientId}`,
+      client
+    );
+  }
+  async saveTransaction(transaction) {
+    await this.tokenStorage.save(
+      `${STORAGE_KEY_PREFIX.transaction}${transaction.id}`,
+      transaction,
+      this.getTtlSeconds(transaction.expiresAt)
+    );
+  }
+  getTtlSeconds(expiresAt) {
+    const millisecondsUntilExpiry = expiresAt.getTime() - Date.now();
+    return Math.max(Math.ceil(millisecondsUntilExpiry / 1e3), 1);
+  }
+  isExpired(expiresAt) {
+    return expiresAt.getTime() < Date.now();
+  }
+  /**
+   * Prefer the storage's atomic take. Falling back to get + delete leaves a
+   * window in which two processes can both observe the same value, so
+   * multi-process deployments should implement `TokenStorage.take`.
+   */
+  async takeFromStorage(key) {
+    if (this.tokenStorage.take) {
+      return this.tokenStorage.take(key);
+    }
+    const stored = await this.tokenStorage.get(key);
+    if (stored === null) {
+      return null;
+    }
+    await this.tokenStorage.delete(key);
+    return stored;
+  }
+};
+
 // src/auth/types.ts
 var DEFAULT_ACCESS_TOKEN_TTL = 3600;
 var DEFAULT_ACCESS_TOKEN_TTL_NO_REFRESH = 31536e3;
@@ -134,7 +365,7 @@ var ClaimsExtractor = (_class = class {
       if (this.PROTECTED_CLAIMS.has(key)) {
         continue;
       }
-      if (_optionalChain([this, 'access', _ => _.config, 'access', _2 => _2.blockedClaims, 'optionalAccess', _3 => _3.includes, 'call', _4 => _4(key)])) {
+      if (_optionalChain([this, 'access', _4 => _4.config, 'access', _5 => _5.blockedClaims, 'optionalAccess', _6 => _6.includes, 'call', _7 => _7(key)])) {
         continue;
       }
       if (this.config.allowedClaims && !this.config.allowedClaims.includes(key)) {
@@ -743,20 +974,7 @@ var EncryptedTokenStorage = (_class2 = class {
     await this.backend.delete(key);
   }
   async get(key) {
-    const encrypted = await this.backend.get(key);
-    if (!encrypted) {
-      return null;
-    }
-    try {
-      const decrypted = await this.decrypt(
-        encrypted,
-        this.encryptionKey
-      );
-      return JSON.parse(decrypted);
-    } catch (error) {
-      console.error("Failed to decrypt value:", error);
-      return null;
-    }
+    return this.decryptStored(await this.backend.get(key));
   }
   async save(key, value, ttl) {
     const encrypted = await this.encrypt(
@@ -765,6 +983,21 @@ var EncryptedTokenStorage = (_class2 = class {
     );
     await this.backend.save(key, encrypted, ttl);
   }
+  /**
+   * Delegates to the backend so that the atomicity of the underlying store is
+   * preserved; falls back to get + delete when the backend cannot do better.
+   */
+  async take(key) {
+    if (this.backend.take) {
+      return this.decryptStored(await this.backend.take(key));
+    }
+    const value = await this.get(key);
+    if (value === null) {
+      return null;
+    }
+    await this.backend.delete(key);
+    return value;
+  }
   async decrypt(ciphertext, key) {
     const parts = ciphertext.split(":");
     if (parts.length !== 3) {
@@ -783,6 +1016,21 @@ var EncryptedTokenStorage = (_class2 = class {
     decrypted += decipher.final("utf8");
     return decrypted;
   }
+  async decryptStored(encrypted) {
+    if (!encrypted) {
+      return null;
+    }
+    try {
+      const decrypted = await this.decrypt(
+        encrypted,
+        this.encryptionKey
+      );
+      return JSON.parse(decrypted);
+    } catch (error) {
+      console.error("Failed to decrypt value:", error);
+      return null;
+    }
+  }
   async encrypt(plaintext, key) {
     const iv = _crypto.randomBytes.call(void 0, 16);
     const cipher = _crypto.createCipheriv.call(void 0, this.algorithm, key, iv, {
@@ -852,6 +1100,18 @@ var MemoryTokenStorage = (_class3 = class {
   size() {
     return this.store.size;
   }
+  /**
+   * Atomic by construction: the read and the delete happen in a single
+   * synchronous block, so no other task can observe the value in between.
+   */
+  async take(key) {
+    const entry = this.store.get(key);
+    this.store.delete(key);
+    if (!entry || entry.expiresAt < Date.now()) {
+      return null;
+    }
+    return entry.value;
+  }
 }, _class3);
 
 // src/auth/OAuthProxy.ts
@@ -867,17 +1127,19 @@ var RESERVED_AUTHORIZATION_PARAMS = /* @__PURE__ */ new Set([
 var OAuthProxy = (_class4 = class {
   __init5() {this.claimsExtractor = null}
   __init6() {this.cleanupInterval = null}
-  __init7() {this.clientCodes = /* @__PURE__ */ new Map()}
   
   
   
-  /** Keyed by redirect_uri for defence-in-depth checks in handleCallback/handleConsent */
-  __init8() {this.registeredClients = /* @__PURE__ */ new Map()}
-  /** Keyed by proxy-issued client_id for authorize/token-exchange lookups */
-  __init9() {this.registeredClientsByClientId = /* @__PURE__ */ new Map()}
+  /**
+   * Keyed by proxy-issued client_id for authorize/token-exchange lookups and
+   * for the defence-in-depth callback checks. A registration never changes
+   * after it is written, so caching it locally cannot go stale; it is also
+   * persisted, so another instance can hydrate it.
+   */
+  __init7() {this.registeredClientsByClientId = /* @__PURE__ */ new Map()}
+  
   
-  __init10() {this.transactions = /* @__PURE__ */ new Map()}
-  constructor(config) {;_class4.prototype.__init5.call(this);_class4.prototype.__init6.call(this);_class4.prototype.__init7.call(this);_class4.prototype.__init8.call(this);_class4.prototype.__init9.call(this);_class4.prototype.__init10.call(this);
+  constructor(config) {;_class4.prototype.__init5.call(this);_class4.prototype.__init6.call(this);_class4.prototype.__init7.call(this);
     this.config = {
       authorizationCodeTtl: DEFAULT_AUTHORIZATION_CODE_TTL,
       consentRequired: true,
@@ -895,6 +1157,10 @@ var OAuthProxy = (_class4 = class {
       storage = new EncryptedTokenStorage(storage, encryptionKey);
     }
     this.tokenStorage = storage;
+    this.stateStore = new OAuthProxyStateStore({
+      registeredClientsByClientId: this.registeredClientsByClientId,
+      tokenStorage: this.tokenStorage
+    });
     this.consentManager = new ConsentManager(
       config.consentSigningKey || this.generateSigningKey()
     );
@@ -928,9 +1194,7 @@ var OAuthProxy = (_class4 = class {
         "Only 'code' response type is supported"
       );
     }
-    const registeredClient = this.registeredClientsByClientId.get(
-      params.client_id
-    );
+    const registeredClient = await this.stateStore.getRegisteredClientByClientId(params.client_id);
     if (!registeredClient) {
       throw new OAuthProxyError("invalid_client", "Unknown client_id");
     }
@@ -963,9 +1227,6 @@ var OAuthProxy = (_class4 = class {
       clearInterval(this.cleanupInterval);
       this.cleanupInterval = null;
     }
-    this.transactions.clear();
-    this.clientCodes.clear();
-    this.registeredClients.clear();
     this.registeredClientsByClientId.clear();
   }
   /**
@@ -978,16 +1239,25 @@ var OAuthProxy = (_class4 = class {
         "Only authorization_code grant type is supported"
       );
     }
-    if (!this.registeredClientsByClientId.has(request.client_id)) {
+    const registeredClient = await this.stateStore.getRegisteredClientByClientId(request.client_id);
+    if (!registeredClient) {
       throw new OAuthProxyError("invalid_client", "Unknown client_id");
     }
-    const clientCode = this.clientCodes.get(request.code);
-    if (!clientCode) {
+    const consumed = await this.stateStore.consumeClientCode(request.code);
+    if (!consumed) {
       throw new OAuthProxyError(
         "invalid_grant",
         "Invalid or expired authorization code"
       );
     }
+    await this.stateStore.markClientCodeSpent(request.code, consumed.expiresAt);
+    if (consumed.status === "spent") {
+      throw new OAuthProxyError(
+        "invalid_grant",
+        "Authorization code already used"
+      );
+    }
+    const clientCode = consumed.clientCode;
     if (clientCode.clientId !== request.client_id) {
       throw new OAuthProxyError("invalid_client", "Client ID mismatch");
     }
@@ -1007,14 +1277,6 @@ var OAuthProxy = (_class4 = class {
         throw new OAuthProxyError("invalid_grant", "Invalid PKCE verifier");
       }
     }
-    if (clientCode.used) {
-      throw new OAuthProxyError(
-        "invalid_grant",
-        "Authorization code already used"
-      );
-    }
-    clientCode.used = true;
-    this.clientCodes.set(request.code, clientCode);
     if (this.config.enableTokenSwap && this.jwtIssuer) {
       return await this.issueSwappedTokens(
         clientCode.clientId,
@@ -1090,23 +1352,21 @@ var OAuthProxy = (_class4 = class {
         "Missing code or state parameter"
       );
     }
-    const transaction = this.transactions.get(state);
+    const transaction = await this.stateStore.consumeTransaction(state);
     if (!transaction) {
       throw new OAuthProxyError("invalid_request", "Invalid or expired state");
     }
-    if (!this.registeredClients.has(transaction.clientCallbackUrl)) {
-      this.transactions.delete(state);
+    if (!await this.stateStore.isTransactionCallbackRegistered(transaction)) {
       throw new OAuthProxyError(
         "invalid_request",
         "Transaction callback URL is not registered"
       );
     }
     const upstreamTokens = await this.exchangeUpstreamCode(code, transaction);
-    const clientCode = this.generateAuthorizationCode(
+    const clientCode = await this.generateAuthorizationCode(
       transaction,
       upstreamTokens
     );
-    this.transactions.delete(state);
     const redirectUrl = new URL(transaction.clientCallbackUrl);
     redirectUrl.searchParams.set("code", clientCode);
     redirectUrl.searchParams.set("state", transaction.state);
@@ -1124,10 +1384,16 @@ var OAuthProxy = (_class4 = class {
     const formData = await request.formData();
     const transactionId = formData.get("transaction_id");
     const action = formData.get("action");
-    if (!transactionId) {
+    if (typeof transactionId !== "string" || !transactionId) {
       throw new OAuthProxyError("invalid_request", "Missing transaction_id");
     }
-    const transaction = this.transactions.get(transactionId);
+    if (action !== "approve" && action !== "deny") {
+      throw new OAuthProxyError(
+        "invalid_request",
+        "action must be 'approve' or 'deny'"
+      );
+    }
+    const transaction = await this.stateStore.getTransaction(transactionId);
     if (!transaction) {
       throw new OAuthProxyError(
         "invalid_request",
@@ -1135,8 +1401,8 @@ var OAuthProxy = (_class4 = class {
       );
     }
     if (action === "deny") {
-      this.transactions.delete(transactionId);
-      if (!this.registeredClients.has(transaction.clientCallbackUrl)) {
+      await this.stateStore.deleteTransaction(transactionId);
+      if (!await this.stateStore.isTransactionCallbackRegistered(transaction)) {
         throw new OAuthProxyError(
           "invalid_request",
           "Transaction callback URL is not registered"
@@ -1156,9 +1422,12 @@ var OAuthProxy = (_class4 = class {
         status: 302
       });
     }
-    transaction.consentGiven = true;
-    this.transactions.set(transactionId, transaction);
-    return this.redirectToUpstream(transaction);
+    const approvedTransaction = {
+      ...transaction,
+      consentGiven: true
+    };
+    await this.stateStore.saveTransaction(approvedTransaction);
+    return this.redirectToUpstream(approvedTransaction);
   }
   /**
    * Load upstream tokens from a FastMCP JWT
@@ -1168,7 +1437,7 @@ var OAuthProxy = (_class4 = class {
       return null;
     }
     const result = await this.jwtIssuer.verify(fastmcpToken);
-    if (!result.valid || !_optionalChain([result, 'access', _5 => _5.claims, 'optionalAccess', _6 => _6.jti])) {
+    if (!result.valid || !_optionalChain([result, 'access', _8 => _8.claims, 'optionalAccess', _9 => _9.jti])) {
       return null;
     }
     const mapping = await this.tokenStorage.get(
@@ -1222,10 +1491,8 @@ var OAuthProxy = (_class4 = class {
       redirectUris: request.redirect_uris,
       registeredAt: /* @__PURE__ */ new Date()
     };
-    this.registeredClientsByClientId.set(proxyClientId, client);
-    for (const uri of request.redirect_uris) {
-      this.registeredClients.set(uri, client);
-    }
+    this.stateStore.cacheRegisteredClient(client);
+    await this.stateStore.saveRegisteredClient(client);
     const response = {
       client_id: proxyClientId,
       client_id_issued_at: Math.floor(Date.now() / 1e3),
@@ -1269,21 +1536,15 @@ var OAuthProxy = (_class4 = class {
     }
   }
   /**
-   * Clean up expired transactions and codes
+   * Periodic maintenance hook. Expiry is enforced by the token storage.
    */
   cleanup() {
-    const now = Date.now();
-    for (const [id, transaction] of this.transactions.entries()) {
-      if (transaction.expiresAt.getTime() < now) {
-        this.transactions.delete(id);
-      }
-    }
-    for (const [code, clientCode] of this.clientCodes.entries()) {
-      if (clientCode.expiresAt.getTime() < now) {
-        this.clientCodes.delete(code);
-      }
-    }
-    void this.tokenStorage.cleanup();
+    void this.tokenStorage.cleanup().catch((error) => {
+      console.error(
+        "[FastMCP] OAuth proxy token storage cleanup failed:",
+        error instanceof Error ? error.message : String(error)
+      );
+    });
   }
   /**
    * Create a new OAuth transaction
@@ -1306,7 +1567,7 @@ var OAuthProxy = (_class4 = class {
       scope: params.scope ? params.scope.split(" ") : this.config.scopes || [],
       state: params.state || this.generateId()
     };
-    this.transactions.set(transactionId, transaction);
+    await this.stateStore.saveTransaction(transaction);
     return transaction;
   }
   /**
@@ -1367,7 +1628,7 @@ var OAuthProxy = (_class4 = class {
       throw new Error("JWT issuer not initialized");
     }
     const result = await this.jwtIssuer.verify(token);
-    if (!result.valid || !_optionalChain([result, 'access', _7 => _7.claims, 'optionalAccess', _8 => _8.jti])) {
+    if (!result.valid || !_optionalChain([result, 'access', _10 => _10.claims, 'optionalAccess', _11 => _11.jti])) {
       throw new Error("Failed to extract JTI from token");
     }
     return result.claims.jti;
@@ -1406,7 +1667,7 @@ var OAuthProxy = (_class4 = class {
   /**
    * Generate authorization code for client
    */
-  generateAuthorizationCode(transaction, upstreamTokens) {
+  async generateAuthorizationCode(transaction, upstreamTokens) {
     const code = this.generateId();
     const clientCode = {
       clientId: transaction.clientId,
@@ -1420,7 +1681,7 @@ var OAuthProxy = (_class4 = class {
       transactionId: transaction.id,
       upstreamTokens
     };
-    this.clientCodes.set(code, clientCode);
+    await this.stateStore.saveClientCode(clientCode);
     return code;
   }
   /**
@@ -1514,7 +1775,7 @@ var OAuthProxy = (_class4 = class {
         "Invalid or expired refresh token"
       );
     }
-    const jti = _optionalChain([verifyResult, 'access', _9 => _9.claims, 'optionalAccess', _10 => _10.jti]);
+    const jti = _optionalChain([verifyResult, 'access', _12 => _12.claims, 'optionalAccess', _13 => _13.jti]);
     if (!jti) {
       throw new OAuthProxyError("invalid_grant", "Refresh token missing JTI");
     }
@@ -1916,7 +2177,7 @@ var AuthProvider = class {
     if (!request) {
       return void 0;
     }
-    const authHeader = _optionalChain([request, 'access', _11 => _11.headers, 'optionalAccess', _12 => _12.authorization]);
+    const authHeader = _optionalChain([request, 'access', _14 => _14.headers, 'optionalAccess', _15 => _15.authorization]);
     if (!authHeader || !authHeader.startsWith("Bearer ")) {
       return void 0;
     }
@@ -2105,13 +2366,22 @@ var OAuthProvider = class extends AuthProvider {
 };
 
 // src/auth/utils/diskStore.ts
+
+
+
+
+
+
+
+
+
 var _promises = require('fs/promises');
 var _path = require('path');
 var DiskStore = (_class5 = class {
-  __init11() {this.cleanupInterval = null}
+  __init8() {this.cleanupInterval = null}
   
   
-  constructor(options) {;_class5.prototype.__init11.call(this);
+  constructor(options) {;_class5.prototype.__init8.call(this);
     this.directory = options.directory;
     this.fileExtension = options.fileExtension || ".json";
     void this.ensureDirectory();
@@ -2224,6 +2494,36 @@ var DiskStore = (_class5 = class {
       return 0;
     }
   }
+  /**
+   * Atomically retrieve a value and delete it.
+   *
+   * rename() is atomic on POSIX filesystems, so when several processes race
+   * for the same key exactly one rename succeeds and the losers see ENOENT.
+   * That is what makes single-use authorization codes safe when more than one
+   * process shares the directory.
+   */
+  async take(key) {
+    const filePath = this.getFilePath(key);
+    const claimPath = `${filePath}.${_crypto.randomUUID.call(void 0, )}.claim${this.fileExtension}`;
+    try {
+      await _promises.rename.call(void 0, filePath, claimPath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        console.error(`Failed to take key ${key}:`, error);
+      }
+      return null;
+    }
+    try {
+      const content = await _promises.readFile.call(void 0, claimPath, "utf-8");
+      const entry = JSON.parse(content);
+      return entry.expiresAt < Date.now() ? null : entry.value;
+    } catch (error) {
+      console.error(`Failed to read key ${key}:`, error);
+      return null;
+    } finally {
+      await _promises.rm.call(void 0, claimPath, { force: true });
+    }
+  }
   /**
    * Ensure storage directory exists
    */
@@ -2254,9 +2554,9 @@ var DiskStore = (_class5 = class {
 var JWKSVerifier = (_class6 = class {
   
   
-  __init12() {this.joseLoaded = false}
+  __init9() {this.joseLoaded = false}
   
-  constructor(config) {;_class6.prototype.__init12.call(this);
+  constructor(config) {;_class6.prototype.__init9.call(this);
     this.config = {
       cacheDuration: 36e5,
       // 1 hour
@@ -2414,4 +2714,4 @@ Original error: ${error.message}`
 
 
 exports.getAuthSession = getAuthSession; exports.requireAll = requireAll; exports.requireAny = requireAny; exports.requireAuth = requireAuth; exports.requireRole = requireRole; exports.requireScopes = requireScopes; exports.DEFAULT_ACCESS_TOKEN_TTL = DEFAULT_ACCESS_TOKEN_TTL; exports.DEFAULT_ACCESS_TOKEN_TTL_NO_REFRESH = DEFAULT_ACCESS_TOKEN_TTL_NO_REFRESH; exports.DEFAULT_REFRESH_TOKEN_TTL = DEFAULT_REFRESH_TOKEN_TTL; exports.DEFAULT_AUTHORIZATION_CODE_TTL = DEFAULT_AUTHORIZATION_CODE_TTL; exports.DEFAULT_TRANSACTION_TTL = DEFAULT_TRANSACTION_TTL; exports.ConsentManager = ConsentManager; exports.JWTIssuer = JWTIssuer; exports.PKCEUtils = PKCEUtils; exports.EncryptedTokenStorage = EncryptedTokenStorage; exports.MemoryTokenStorage = MemoryTokenStorage; exports.OAuthProxy = OAuthProxy; exports.OAuthProxyError = OAuthProxyError; exports.AuthProvider = AuthProvider; exports.AzureProvider = AzureProvider; exports.GitHubProvider = GitHubProvider; exports.GoogleProvider = GoogleProvider; exports.OAuthProvider = OAuthProvider; exports.DiskStore = DiskStore; exports.JWKSVerifier = JWKSVerifier;
-//# sourceMappingURL=chunk-IX3HKAX4.cjs.map
+//# sourceMappingURL=chunk-DZYT6QAH.cjs.map