tiny-http-mcp-server 0.1.42 → 0.1.43

package/dist/composition.json

@@ -18,7 +18,7 @@
     },
     {
       "name": "tiny-http-mcp-server",
-      "version": "0.1.42",
+      "version": "0.1.43",
       "license": "MIT"
     },
     {

package/node_modules/mcp-oauth/README.md

@@ -142,6 +142,23 @@ Discovery binds an expired or explicitly rejected grant before silent refresh,
 using the original configured client. Persisted sessions take precedence,
 including sessions whose tokens have been cleared; an import cannot revive them.
 Input tokens are copied and invalid expiry values fail before authorization.
+For a raw OAuth response, `parseOAuthTokenGrant(response, { issuedAt, expiresAt })`
+returns normalized `StoredOAuthTokens`. It accepts `access_token`, `refresh_token`,
+`token_type`, `scope`, `expires_in` (seconds), `expires_at` (epoch seconds), and
+`expiresAt` (epoch milliseconds). Numeric absolute expiry wins over relative
+lifetime; the options timestamp wins over response timestamps. The optional
+`now` clock anchors a new import. JSON is bounded to 64 KiB/64 levels; malformed
+credentials, scope, timing, accessors and non-JSON metadata are rejected without
+quoting the input. The parser makes no network or storage requests.
+For named native persistence, `createResourceBoundOAuthStores(authStore,
+namespace, identity).importSession(session, { signal, timeoutMs })` explicitly
+replaces the bound grant and original client in one locked document. It takes
+an owned, bounded session snapshot before waiting; validates resource/issuer
+binding; marks full registrations as caller-owned; and retires previous clients.
+Its durable marker suppresses stale automatic environment imports after tokens
+are cleared. Like reset, explicit import can recover a corrupt old document
+without decrypting it. The default lock wait is 30 seconds. A session must
+contain a complete usable grant and matching validated discovery metadata.
 Pass a complete DCR response as `client.registration` (or validate untrusted JSON
 with `parseOAuthClientRegistration`). Dynamic clients infer their original ID
 and secret from that response and reuse it without registering another app.

package/node_modules/mcp-oauth/dist/client/bounded-json.d.ts

@@ -0,0 +1,2 @@
+/** Copy credential JSON without invoking accessors or custom serialization. */
+export declare function copyBoundedOAuthJson(value: unknown, message: string): unknown;

package/node_modules/mcp-oauth/dist/client/bounded-json.js

@@ -0,0 +1,46 @@
+/** Copy credential JSON without invoking accessors or custom serialization. */
+export function copyBoundedOAuthJson(value, message) {
+    const invalid = () => new Error(message);
+    let nodes = 0;
+    function copy(input, depth) {
+        if (++nodes > 20_000 || 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 > 20_000)
+                throw invalid();
+            const result = [];
+            for (let index = 0; index < length; index++) {
+                const descriptor = descriptors[String(index)];
+                if (descriptor === undefined || !Object.hasOwn(descriptor, "value"))
+                    throw invalid();
+                result.push(copy(descriptor.value, depth + 1));
+            }
+            return result;
+        }
+        if (Object.getPrototypeOf(input) !== Object.prototype && Object.getPrototypeOf(input) !== null)
+            throw invalid();
+        return Object.fromEntries(Object.entries(descriptors).filter(([, descriptor]) => descriptor.enumerable).map(([key, descriptor]) => {
+            if (!Object.hasOwn(descriptor, "value"))
+                throw invalid();
+            return [key, copy(descriptor.value, depth + 1)];
+        }));
+    }
+    let result;
+    try {
+        result = copy(value, 0);
+    }
+    catch {
+        throw invalid();
+    }
+    if (Buffer.byteLength(JSON.stringify(result), "utf8") > 64 * 1024)
+        throw invalid();
+    return result;
+}

package/node_modules/mcp-oauth/dist/client/client-registration.js

@@ -1,48 +1,11 @@
+import { copyBoundedOAuthJson } from "./bounded-json.js";
 import { loopbackTarget } from "./loopback-authorization.js";
 import { normalizeOAuthScope } from "./scope.js";
 import { normalizeOAuthTokenEndpointAuthMethod } from "./token-auth-method.js";
 /** Validate and copy a bounded JSON DCR response without quoting credential input. */
 export function parseOAuthClientRegistration(value) {
     const invalid = () => new Error("Invalid OAuth client registration metadata");
-    let nodes = 0;
-    function copy(input, depth) {
-        if (++nodes > 20_000 || 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 > 20_000)
-                throw invalid();
-            const result = [];
-            for (let index = 0; index < length; index++) {
-                const descriptor = descriptors[String(index)];
-                if (descriptor === undefined || !Object.hasOwn(descriptor, "value"))
-                    throw invalid();
-                result.push(copy(descriptor.value, depth + 1));
-            }
-            return result;
-        }
-        if (Object.getPrototypeOf(input) !== Object.prototype && Object.getPrototypeOf(input) !== null)
-            throw invalid();
-        return Object.fromEntries(Object.entries(descriptors).filter(([, descriptor]) => descriptor.enumerable).map(([key, descriptor]) => {
-            if (!Object.hasOwn(descriptor, "value"))
-                throw invalid();
-            return [key, copy(descriptor.value, depth + 1)];
-        }));
-    }
-    let result;
-    try {
-        result = copy(value, 0);
-    }
-    catch {
-        throw invalid();
-    }
+    const result = copyBoundedOAuthJson(value, "Invalid OAuth client registration metadata");
     if (typeof result !== "object" || result === null || Array.isArray(result))
         throw invalid();
     const record = result;
@@ -71,8 +34,6 @@ export function parseOAuthClientRegistration(value) {
     catch {
         throw invalid();
     }
-    if (Buffer.byteLength(JSON.stringify(record), "utf8") > 64 * 1024)
-        throw invalid();
     return record;
 }
 export function normalizeStoredOAuthClient(value) {

package/node_modules/mcp-oauth/dist/client/resource-bound-store.d.ts

@@ -1,11 +1,16 @@
 import type { CreateSecretStoreInput } from "auth-store";
 import { type OAuthClientStore } from "./auth-store-session-store.js";
-import type { OAuthSessionStore } from "./types.js";
+import type { OAuthSessionStore, StoredOAuthSession } from "./types.js";
 export interface ResourceBoundOAuthStores {
     readonly sessionStore: OAuthSessionStore;
     readonly clientStore: OAuthClientStore;
     readonly initialGrantAllowed: boolean;
     /** Retire grants/clients even when their document cannot be decrypted or parsed. */
+    /** Explicitly replace the bound grant and original client in one transaction. */
+    importSession(session: StoredOAuthSession, options?: {
+        signal?: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<void>;
     reset(resource: string, options?: {
         signal?: AbortSignal;
         timeoutMs?: number;

package/node_modules/mcp-oauth/dist/client/resource-bound-store.js

@@ -1,3 +1,4 @@
+import { copyBoundedOAuthJson } from "./bounded-json.js";
 import { canonicalizeResourceIndicator } from "../resource-indicator.js";
 import { assertPersistenceNamespace, createNamedSecretStore, isStoredOAuthSession } from "./auth-store-session-store.js";
 import { normalizeStoredOAuthClient } from "./client-registration.js";
@@ -19,21 +20,51 @@ export function createResourceBoundOAuthStores(options, namespace, identity) {
             }
             if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.hash)
                 throw new Error("OAuth reset resource must be an HTTP URL without credentials or fragment");
-            const timeoutMs = options.timeoutMs ?? 30_000;
-            if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2_147_483_647)
-                throw new Error("OAuth reset timeoutMs must be a positive supported timer interval");
-            if (store.withLock === undefined)
-                throw new Error("OAuth resource identity backend must support transaction locks");
-            // Acquire the raw backend lock: the session lock reconciles by strictly
-            // reading the document, which must be bypassed for explicit corruption recovery.
-            await store.withLock(async () => {
-                options.signal?.throwIfAborted();
-                const record = { version: 1, resource: canonicalizeResourceIndicator(url), generation: 1, session: null, clients: {} };
-                await store.set(JSON.stringify(record));
-                result.initialGrantAllowed = false;
-            }, { signal: options.signal, timeoutMs });
+            await replace({ version: 1, resource: canonicalizeResourceIndicator(url), generation: 1, session: null, clients: {} }, options);
+        },
+        async importSession(value, options = {}) {
+            options.signal?.throwIfAborted();
+            const session = copyBoundedOAuthJson(value, "Invalid OAuth import session");
+            try {
+                if (!isStoredOAuthSession(session) || session.tokens === undefined || session.refreshState !== undefined)
+                    throw new Error("Invalid session");
+                const resource = new URL(session.resource), issuer = new URL(session.authorizationServer);
+                if ([resource, issuer].some(url => !["http:", "https:"].includes(url.protocol) || url.username || url.password || url.hash) ||
+                    session.discovery.authorizationServerMetadata.issuer !== session.authorizationServer ||
+                    typeof session.discovery.resourceMetadata.resource !== "string" ||
+                    canonicalizeResourceIndicator(session.discovery.resourceMetadata.resource) !== canonicalizeResourceIndicator(resource))
+                    throw new Error("Invalid binding");
+                session.client = normalizeStoredOAuthClient(session.client);
+                if (session.client.registration !== undefined)
+                    session.client.registrationOwnership = "caller";
+                if (session.client.registration?.issuer !== undefined && session.client.registration.issuer !== null &&
+                    session.client.registration.issuer !== session.authorizationServer)
+                    throw new Error("Invalid registration issuer");
+                new Headers({ Authorization: `Bearer ${session.tokens.accessToken}` });
+                session.resource = canonicalizeResourceIndicator(resource);
+            }
+            catch {
+                throw new Error("Invalid OAuth import session or resource binding");
+            }
+            await replace({ version: 1, resource: session.resource, generation: 1, session,
+                clients: { [session.authorizationServer]: session.client } }, options);
         }
     };
+    async function replace(record, options) {
+        options.signal?.throwIfAborted();
+        const timeoutMs = options.timeoutMs ?? 30_000;
+        if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2_147_483_647)
+            throw new Error("OAuth replacement timeoutMs must be a positive supported timer interval");
+        if (store.withLock === undefined)
+            throw new Error("OAuth resource identity backend must support transaction locks");
+        // Strict reconciliation reads are bypassed only for explicit replacement,
+        // while the raw stable backend lock still serializes every identity writer.
+        await store.withLock(async () => {
+            options.signal?.throwIfAborted();
+            await store.set(JSON.stringify(record));
+            result.initialGrantAllowed = false;
+        }, { signal: options.signal, timeoutMs });
+    }
     async function read() {
         const raw = await store.get();
         if (raw === null)

package/node_modules/mcp-oauth/dist/client/token-grant.d.ts

@@ -0,0 +1,10 @@
+import type { StoredOAuthTokens } from "./types.js";
+export interface OAuthTokenGrantImportOptions {
+    /** Absolute Unix epoch milliseconds; a numeric value takes precedence. */
+    readonly expiresAt?: number | null;
+    /** Original Unix epoch milliseconds for a delayed relative-lifetime import. */
+    readonly issuedAt?: number;
+    readonly now?: () => number;
+}
+/** Validate a raw RFC token response and anchor its lifetime once for persistence. */
+export declare function parseOAuthTokenGrant(value: unknown, options?: OAuthTokenGrantImportOptions): StoredOAuthTokens;

package/node_modules/mcp-oauth/dist/client/token-grant.js

@@ -0,0 +1,52 @@
+import { copyBoundedOAuthJson } from "./bounded-json.js";
+import { normalizeOAuthScope } from "./scope.js";
+/** Validate a raw RFC token response and anchor its lifetime once for persistence. */
+export function parseOAuthTokenGrant(value, options = {}) {
+    const invalid = () => new Error("Invalid OAuth token grant");
+    const result = copyBoundedOAuthJson(value, "Invalid OAuth token grant");
+    if (typeof result !== "object" || result === null || Array.isArray(result))
+        throw invalid();
+    const record = result;
+    const own = (key) => Object.hasOwn(record, key) ? record[key] : undefined;
+    const access = own("access_token"), refresh = own("refresh_token"), type = own("token_type");
+    if (typeof access !== "string" || access.trim() === "" || typeof type !== "string" || type.toLowerCase() !== "bearer" ||
+        (refresh !== undefined && (typeof refresh !== "string" || refresh.trim() === "")))
+        throw invalid();
+    const accessToken = access.trim();
+    try {
+        new Headers({ Authorization: `Bearer ${accessToken}` });
+    }
+    catch {
+        throw invalid();
+    }
+    const lifetime = own("expires_in"), seconds = own("expires_at"), milliseconds = own("expiresAt");
+    if ((lifetime !== undefined && (typeof lifetime !== "number" || !Number.isSafeInteger(lifetime) || lifetime < 0)) ||
+        (seconds !== undefined && seconds !== null && (typeof seconds !== "number" || !Number.isSafeInteger(seconds))))
+        throw invalid();
+    const validTimestamp = (input) => typeof input === "number" && Number.isSafeInteger(input) && Math.abs(input) <= 8_640_000_000_000_000;
+    if ((milliseconds !== undefined && milliseconds !== null && !validTimestamp(milliseconds)) ||
+        (options.expiresAt !== undefined && options.expiresAt !== null && !validTimestamp(options.expiresAt)) ||
+        (options.issuedAt !== undefined && !validTimestamp(options.issuedAt)))
+        throw invalid();
+    // Validate every supplied timing field, even if a higher-precedence absolute
+    // value is selected. Reload uses only the resulting normalized timestamp.
+    const absoluteSeconds = typeof seconds === "number" ? seconds * 1000 : undefined;
+    if (absoluteSeconds !== undefined && !validTimestamp(absoluteSeconds))
+        throw invalid();
+    const relative = typeof lifetime === "number" ? (options.issuedAt ?? (options.now ?? Date.now)()) + lifetime * 1000 : undefined;
+    if (relative !== undefined && !validTimestamp(relative))
+        throw invalid();
+    const expiresAt = options.expiresAt ?? (typeof milliseconds === "number" ? milliseconds : undefined) ?? absoluteSeconds ?? relative ?? null;
+    let scope;
+    try {
+        scope = normalizeOAuthScope(own("scope"));
+    }
+    catch {
+        throw invalid();
+    }
+    if (own("scope") !== undefined && scope === undefined)
+        throw invalid();
+    return { accessToken, tokenType: "Bearer", expiresAt,
+        ...(refresh === undefined ? {} : { refreshToken: refresh.trim() }),
+        ...(scope === undefined ? {} : { scope }) };
+}

package/node_modules/mcp-oauth/dist/index.d.ts

@@ -1,3 +1,5 @@
+export { parseOAuthTokenGrant } from "./client/token-grant.js";
+export type { OAuthTokenGrantImportOptions } from "./client/token-grant.js";
 export { createAuthStoreSessionStore, } from "./client/auth-store-session-store.js";
 export { createResourceBoundOAuthStores } from "./client/resource-bound-store.js";
 export type { ResourceBoundOAuthStores } from "./client/resource-bound-store.js";

package/node_modules/mcp-oauth/dist/index.js

@@ -1,3 +1,4 @@
+export { parseOAuthTokenGrant } from "./client/token-grant.js";
 export { createAuthStoreSessionStore, } from "./client/auth-store-session-store.js";
 export { createResourceBoundOAuthStores } from "./client/resource-bound-store.js";
 export { parseOAuthClientRegistration } from "./client/client-registration.js";

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

@@ -3395,6 +3395,62 @@ var SubscriptionManager = class {
   }
 };
 
+// ../mcp-oauth/dist/client/bounded-json.js
+function copyBoundedOAuthJson(value, message) {
+  const invalid = () => new Error(message);
+  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 (Buffer.byteLength(JSON.stringify(result), "utf8") > 64 * 1024)
+    throw invalid();
+  return result;
+}
+
+// ../mcp-oauth/dist/client/scope.js
+function normalizeOAuthScope(scope) {
+  if (scope === void 0)
+    return void 0;
+  if (typeof scope !== "string" || [...scope].some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) > 126 || char === '"' || char === "\\"))
+    throw new Error("Invalid OAuth scope syntax");
+  const normalized = [...new Set(scope.split(" ").filter(Boolean))].sort().join(" ");
+  return normalized || void 0;
+}
+
 // ../mcp-oauth/dist/client/loopback-authorization.js
 import http from "node:http";
 
@@ -3700,16 +3756,6 @@ function buildSuccessPage(landingPage) {
   ].join("");
 }
 
-// ../mcp-oauth/dist/client/scope.js
-function normalizeOAuthScope(scope) {
-  if (scope === void 0)
-    return void 0;
-  if (typeof scope !== "string" || [...scope].some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) > 126 || char === '"' || char === "\\"))
-    throw new Error("Invalid OAuth scope syntax");
-  const normalized = [...new Set(scope.split(" ").filter(Boolean))].sort().join(" ");
-  return normalized || void 0;
-}
-
 // ../mcp-oauth/dist/client/token-auth-method.js
 function normalizeOAuthTokenEndpointAuthMethod(value) {
   if (value === void 0 || value === null)
@@ -3722,44 +3768,7 @@ function normalizeOAuthTokenEndpointAuthMethod(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();
-  }
+  const result = copyBoundedOAuthJson(value, "Invalid OAuth client registration metadata");
   if (typeof result !== "object" || result === null || Array.isArray(result))
     throw invalid();
   const record2 = result;
@@ -3804,8 +3813,6 @@ function parseOAuthClientRegistration(value) {
   } catch {
     throw invalid();
   }
-  if (Buffer.byteLength(JSON.stringify(record2), "utf8") > 64 * 1024)
-    throw invalid();
   return record2;
 }
 function normalizeStoredOAuthClient(value) {
@@ -4739,19 +4746,49 @@ function createResourceBoundOAuthStores(options, namespace, identity) {
       }
       if (!["http:", "https:"].includes(url.protocol) || url.username || url.password || url.hash)
         throw new Error("OAuth reset resource must be an HTTP URL without credentials or fragment");
-      const timeoutMs = options2.timeoutMs ?? 3e4;
-      if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2147483647)
-        throw new Error("OAuth reset timeoutMs must be a positive supported timer interval");
-      if (store.withLock === void 0)
-        throw new Error("OAuth resource identity backend must support transaction locks");
-      await store.withLock(async () => {
-        options2.signal?.throwIfAborted();
-        const record2 = { version: 1, resource: canonicalizeResourceIndicator(url), generation: 1, session: null, clients: {} };
-        await store.set(JSON.stringify(record2));
-        result.initialGrantAllowed = false;
-      }, { signal: options2.signal, timeoutMs });
+      await replace({ version: 1, resource: canonicalizeResourceIndicator(url), generation: 1, session: null, clients: {} }, options2);
+    },
+    async importSession(value, options2 = {}) {
+      options2.signal?.throwIfAborted();
+      const session = copyBoundedOAuthJson(value, "Invalid OAuth import session");
+      try {
+        if (!isStoredOAuthSession(session) || session.tokens === void 0 || session.refreshState !== void 0)
+          throw new Error("Invalid session");
+        const resource = new URL(session.resource), issuer = new URL(session.authorizationServer);
+        if ([resource, issuer].some((url) => !["http:", "https:"].includes(url.protocol) || url.username || url.password || url.hash) || session.discovery.authorizationServerMetadata.issuer !== session.authorizationServer || typeof session.discovery.resourceMetadata.resource !== "string" || canonicalizeResourceIndicator(session.discovery.resourceMetadata.resource) !== canonicalizeResourceIndicator(resource))
+          throw new Error("Invalid binding");
+        session.client = normalizeStoredOAuthClient(session.client);
+        if (session.client.registration !== void 0)
+          session.client.registrationOwnership = "caller";
+        if (session.client.registration?.issuer !== void 0 && session.client.registration.issuer !== null && session.client.registration.issuer !== session.authorizationServer)
+          throw new Error("Invalid registration issuer");
+        new Headers({ Authorization: `Bearer ${session.tokens.accessToken}` });
+        session.resource = canonicalizeResourceIndicator(resource);
+      } catch {
+        throw new Error("Invalid OAuth import session or resource binding");
+      }
+      await replace({
+        version: 1,
+        resource: session.resource,
+        generation: 1,
+        session,
+        clients: { [session.authorizationServer]: session.client }
+      }, options2);
     }
   };
+  async function replace(record2, options2) {
+    options2.signal?.throwIfAborted();
+    const timeoutMs = options2.timeoutMs ?? 3e4;
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 2147483647)
+      throw new Error("OAuth replacement timeoutMs must be a positive supported timer interval");
+    if (store.withLock === void 0)
+      throw new Error("OAuth resource identity backend must support transaction locks");
+    await store.withLock(async () => {
+      options2.signal?.throwIfAborted();
+      await store.set(JSON.stringify(record2));
+      result.initialGrantAllowed = false;
+    }, { signal: options2.signal, timeoutMs });
+  }
   async function read() {
     const raw = await store.get();
     if (raw === null)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tiny-http-mcp-server",
-  "version": "0.1.42",
+  "version": "0.1.43",
   "description": "Minimal MCP server over HTTP built on tiny-stdio-mcp-server",
   "type": "module",
   "main": "dist/index.js",