tiny-http-mcp-server 0.1.26 → 0.1.27

package/dist/composition.json

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

package/node_modules/auth-store/README.md

@@ -25,6 +25,22 @@ const value = await store.get(); // "secret-value"
 await store.delete();
 ```
 
+Both built-in backends expose `store.withLock(operation, { signal, timeoutMs })`
+for transactions spanning a read, external operation and write. Independent
+instances and processes serialize the same encrypted file or Keychain
+service/account; unrelated identities proceed independently. The default
+acquisition timeout is 30 seconds. Cancellation during acquisition does not
+release the active owner's lock. Individual `get`, `set` and `delete` calls do
+not implicitly acquire it.
+
+Locks use private filesystem claim directories, containing PID/random names
+and numeric tickets without credentials. Dead-owner claims are recovered;
+live claims are never stolen because of age. Empty directories remain so an
+arriving contender cannot race directory removal. Keychain lock storage defaults
+to `~/.auth-store/keychain-locks`; `keychainStore.lock` can select another
+directory or filesystem adapter. Injected encrypted-file adapters need
+`readdir` support when using transactions.
+
 ## Backends
 
 | `backendEnvVar` value | Platform | Backend        |

package/node_modules/auth-store/dist/encrypted-file-store.d.ts

@@ -1,9 +1,11 @@
 import type { SecretStore } from "./types.js";
+import { type SecretStoreLockOptions } from "./transaction-lock.js";
 export interface MachineIdentity {
     hostname: string;
     username: string;
 }
 export interface EncryptedFileStoreFileSystem {
+    readdir?(path: string): Promise<string[]>;
     readFile(path: string, encoding: BufferEncoding): Promise<string>;
     writeFile(path: string, data: string | NodeJS.ArrayBufferView, options?: {
         encoding?: BufferEncoding;
@@ -40,6 +42,7 @@ export declare class EncryptedFileStore implements SecretStore {
     private keyPromise;
     constructor(input: EncryptedFileStoreInput);
     get(): Promise<string | null>;
+    withLock<T>(operation: () => Promise<T>, options?: SecretStoreLockOptions): Promise<T>;
     set(value: string): Promise<void>;
     delete(): Promise<void>;
     private assertCredentialPathHasNoSymbolicLinks;

package/node_modules/auth-store/dist/encrypted-file-store.js

@@ -3,6 +3,7 @@ import { promises as fs } from "node:fs";
 import { homedir, hostname, userInfo } from "node:os";
 import path from "node:path";
 import { hasOwnErrorCode } from "./error-codes.js";
+import { withSecretStoreFileLock } from "./transaction-lock.js";
 const derivedKeyCache = new Map();
 const ENCRYPTION_ALGORITHM = "aes-256-gcm";
 const ENCRYPTION_VERSION = 1;
@@ -71,6 +72,12 @@ export class EncryptedFileStore {
             return null;
         }
     }
+    async withLock(operation, options = {}) {
+        await this.assertCredentialPathHasNoSymbolicLinks(`${this.filePath}.lock`);
+        if (this.fs.readdir === undefined)
+            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 key = await this.getEncryptionKey();

package/node_modules/auth-store/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { createSecretStore } from "./create-secret-store.js";
 export { EncryptedFileStore } from "./encrypted-file-store.js";
 export { KeychainStore } from "./keychain-store.js";
+export type { SecretStoreLockOptions, SecretStoreLockFileSystem } from "./transaction-lock.js";
 export { key, MigratingSecretStore } from "./provider-store.js";
 export type { SecretStore, StoreBackend, CreateSecretStoreInput, CreateSecretStoreResult } from "./types.js";
 export type { MachineIdentity, EncryptedFileStoreInput, EncryptedFileStoreFileSystem } from "./encrypted-file-store.js";

package/node_modules/auth-store/dist/keychain-store.d.ts

@@ -1,4 +1,5 @@
 import type { SecretStore } from "./types.js";
+import { type SecretStoreLockFileSystem, type SecretStoreLockOptions } from "./transaction-lock.js";
 export interface KeychainCommandResult {
     stdout: string;
     stderr: string;
@@ -12,13 +13,20 @@ export interface KeychainStoreInput {
     runCommand?: KeychainCommandRunner;
     service: string;
     account: string;
+    lock?: {
+        fs?: SecretStoreLockFileSystem;
+        directory?: string;
+    };
 }
 export declare class KeychainStore implements SecretStore {
     private readonly runCommand;
     private readonly service;
     private readonly account;
+    private readonly lockFs;
+    private readonly lockDirectory;
     constructor(input: KeychainStoreInput);
     get(): Promise<string | null>;
+    withLock<T>(operation: () => Promise<T>, options?: SecretStoreLockOptions): Promise<T>;
     set(value: string): Promise<void>;
     delete(): Promise<void>;
     private executeSecurityCommand;

package/node_modules/auth-store/dist/keychain-store.js

@@ -1,14 +1,23 @@
 import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { promises as nodeFs } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+import { withSecretStoreFileLock } from "./transaction-lock.js";
 const SECURITY_CLI = "security";
 const KEYCHAIN_ITEM_NOT_FOUND_EXIT_CODE = 44;
 export class KeychainStore {
     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 ?? path.join(homedir(), ".auth-store", "keychain-locks");
         if (this.service.length === 0) {
             throw new Error("Keychain service must not be empty");
         }
@@ -26,6 +35,10 @@ export class KeychainStore {
         }
         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, path.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");

package/node_modules/auth-store/dist/transaction-lock.d.ts

@@ -0,0 +1,24 @@
+export interface SecretStoreLockOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+export interface SecretStoreLockFileSystem {
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+        mode?: number;
+    }): Promise<unknown>;
+    readdir(path: string): Promise<string[]>;
+    readFile(path: string, encoding: BufferEncoding): Promise<string>;
+    writeFile(path: string, value: string, options: {
+        encoding: BufferEncoding;
+        flag: string;
+        mode: number;
+    }): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    unlink(path: string): Promise<void>;
+    lstat(path: string): Promise<{
+        isSymbolicLink(): boolean;
+    }>;
+}
+/** Filesystem bakery lock: unique claims allow dead-owner cleanup without deleting a replacement owner's lock. */
+export declare function withSecretStoreFileLock<T>(fs: SecretStoreLockFileSystem, lockDirectory: string, operation: () => Promise<T>, options?: SecretStoreLockOptions): Promise<T>;

package/node_modules/auth-store/dist/transaction-lock.js

@@ -0,0 +1,152 @@
+import { randomUUID } from "node:crypto";
+import path from "node:path";
+import { hasOwnErrorCode } from "./error-codes.js";
+/** Filesystem bakery lock: unique claims allow dead-owner cleanup without deleting a replacement owner's lock. */
+export async function withSecretStoreFileLock(fs, lockDirectory, operation, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 30_000;
+    if (!Number.isFinite(timeoutMs) || timeoutMs < 0 || timeoutMs > 2_147_483_647)
+        throw new Error("Invalid secret-store transaction lock timeout");
+    options.signal?.throwIfAborted();
+    const deadline = performance.now() + timeoutMs;
+    const directory = path.resolve(lockDirectory);
+    await assertLockDirectoryPath(fs, directory);
+    await fs.mkdir(directory, { recursive: true, mode: 0o700 });
+    await assertLockDirectoryPath(fs, 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 fs.writeFile(claimPath, JSON.stringify({ ticket: null }), { encoding: "utf8", flag: "wx", mode: 0o600 });
+        }
+        catch (error) {
+            if (hasOwnErrorCode(error, "EEXIST"))
+                claimed = false;
+            throw error;
+        }
+        const existing = await readClaims(fs, 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 fs.writeFile(temporaryPath, JSON.stringify({ ticket }), { encoding: "utf8", flag: "wx", mode: 0o600 });
+        }
+        catch (error) {
+            if (hasOwnErrorCode(error, "EEXIST"))
+                temporaryCreated = false;
+            throw error;
+        }
+        await fs.rename(temporaryPath, claimPath);
+        temporaryCreated = false;
+        for (;;) {
+            options.signal?.throwIfAborted();
+            const peers = await readClaims(fs, 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 };
+    }
+    const cleanup = [];
+    for (const target of [...(temporaryCreated ? [temporaryPath] : []), ...(claimed ? [claimPath] : [])]) {
+        try {
+            await fs.unlink(target);
+        }
+        catch (error) {
+            if (!hasOwnErrorCode(error, "ENOENT"))
+                cleanup.push(error);
+        }
+    }
+    if (cleanup.length)
+        throw new AggregateError([...("error" in outcome ? [outcome.error] : []), ...cleanup], "Secret-store transaction lock cleanup failed");
+    if ("error" in outcome)
+        throw outcome.error;
+    return outcome.result;
+}
+async function assertNoSymbolicLink(fs, target) {
+    try {
+        if ((await fs.lstat(target)).isSymbolicLink())
+            throw new Error("Refusing secret-store transaction lock through symbolic link");
+    }
+    catch (error) {
+        if (!hasOwnErrorCode(error, "ENOENT"))
+            throw error;
+    }
+}
+async function assertLockDirectoryPath(fs, 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);
+        // Match encrypted credential paths: allow OS root aliases such as macOS /var.
+        if (index > 0 || segments.length === 1)
+            await assertNoSymbolicLink(fs, current);
+    }
+}
+async function readClaims(fs, directory, ownName) {
+    const claims = [];
+    for (const name of await fs.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(fs, target);
+        let alive = true;
+        try {
+            process.kill(pid, 0);
+        }
+        catch (error) {
+            alive = !hasOwnErrorCode(error, "ESRCH");
+        }
+        if (!alive) {
+            try {
+                await fs.unlink(target);
+            }
+            catch (error) {
+                if (!hasOwnErrorCode(error, "ENOENT"))
+                    throw error;
+            }
+            continue;
+        }
+        let ticket = null;
+        let raw;
+        try {
+            raw = await fs.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 { /* Incomplete live claims remain in the choosing phase; never steal them by age. */ }
+        claims.push({ name, ticket });
+    }
+    return claims;
+}

package/node_modules/auth-store/dist/types.d.ts

@@ -1,11 +1,13 @@
 import type { EncryptedFileStoreInput } from "./encrypted-file-store.js";
 import type { KeychainStoreInput } from "./keychain-store.js";
+import type { SecretStoreLockOptions } from "./transaction-lock.js";
 export interface SecretStore {
     get(options?: {
         readOnly?: boolean;
     }): Promise<string | null>;
     set(value: string): Promise<void>;
     delete(): Promise<void>;
+    withLock?<T>(operation: () => Promise<T>, options?: SecretStoreLockOptions): Promise<T>;
 }
 export type StoreBackend = "file" | "keychain";
 export interface CreateSecretStoreInput {

package/node_modules/mcp-oauth/README.md

@@ -115,7 +115,12 @@ active owner's lock. Custom stores may implement
 transaction across store instances or processes. The hook must honor acquisition
 cancellation and keep the lock until the operation settles. The timeout bounds
 acquisition, while token and browser operations retain their own deadlines.
-Cross-process locking for the native secret-store backend is under development.
+The native `auth-store` session adapter implements this hook for both encrypted
+files and Keychain identities, including across independent processes. Locks
+cover the complete read, refresh/authorization and persisted winner. Dead-owner
+claims are recovered without stealing a live transaction. A process crash or
+cancellation after refresh redemption but before persistence is still an
+uncertain token outcome; recovery for that case is under development.
 
 ## Environment Variables
 

package/node_modules/mcp-oauth/dist/client/auth-store-session-store.js

@@ -11,6 +11,12 @@ const DEFAULT_CLIENT_KEYCHAIN_SERVICE = "poe-code-mcp-oauth-clients";
 const MAX_JS_DATE_MS = 8_640_000_000_000_000;
 export function createAuthStoreSessionStore(options = {}) {
     return {
+        async withLock(resource, operation, lockOptions) {
+            const store = createResourceSecretStore(resource, options);
+            if (store.withLock === undefined)
+                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);
             const value = await store.get();

package/node_modules/tiny-mcp-client/dist/index.d.ts

@@ -20,11 +20,31 @@ interface McpSubscription {
     cancel(): void;
 }
 
+interface SecretStoreLockFileSystem {
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+        mode?: number;
+    }): Promise<unknown>;
+    readdir(path: string): Promise<string[]>;
+    readFile(path: string, encoding: BufferEncoding): Promise<string>;
+    writeFile(path: string, value: string, options: {
+        encoding: BufferEncoding;
+        flag: string;
+        mode: number;
+    }): Promise<void>;
+    rename(from: string, to: string): Promise<void>;
+    unlink(path: string): Promise<void>;
+    lstat(path: string): Promise<{
+        isSymbolicLink(): boolean;
+    }>;
+}
+
 interface MachineIdentity {
     hostname: string;
     username: string;
 }
 interface EncryptedFileStoreFileSystem {
+    readdir?(path: string): Promise<string[]>;
     readFile(path: string, encoding: BufferEncoding): Promise<string>;
     writeFile(path: string, data: string | NodeJS.ArrayBufferView, options?: {
         encoding?: BufferEncoding;
@@ -65,6 +85,10 @@ interface KeychainStoreInput {
     runCommand?: KeychainCommandRunner;
     service: string;
     account: string;
+    lock?: {
+        fs?: SecretStoreLockFileSystem;
+        directory?: string;
+    };
 }
 
 type StoreBackend = "file" | "keychain";

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

@@ -279,8 +279,8 @@ function receivedType(value) {
   }
   return typeof value;
 }
-function issue(path3, expected, value, message, keyword = keywordFor(expected)) {
-  return { path: path3, expected, received: receivedType(value), message, keyword };
+function issue(path5, expected, value, message, keyword = keywordFor(expected)) {
+  return { path: path5, expected, received: receivedType(value), message, keyword };
 }
 function keywordFor(expected) {
   if (["null", "boolean", "object", "array", "number", "integer", "string"].includes(expected)) {
@@ -997,113 +997,113 @@ function evaluateArrayApplicators(graph, node, schema, value, context) {
   }
   return results;
 }
-function evaluateValidationKeywords(node, schema, value, path3) {
+function evaluateValidationKeywords(node, schema, value, path5) {
   const results = [];
   const types = typeof schema.type === "string" ? [schema.type] : Array.isArray(schema.type) ? schema.type : [];
   if (types.length > 0 && !types.some((type) => typeof type === "string" && typeMatches(type, value))) {
-    results.push(invalidResult(issue(path3, types.join(","), value, `must be ${types.join(",")}`)));
+    results.push(invalidResult(issue(path5, types.join(","), value, `must be ${types.join(",")}`)));
     return results;
   }
   if (schema.const !== void 0 && !deepEqual(schema.const, value)) {
-    results.push(invalidResult(issue(path3, "const", value, "must be equal to constant")));
+    results.push(invalidResult(issue(path5, "const", value, "must be equal to constant")));
   }
   if (Array.isArray(schema.enum) && !schema.enum.some((entry) => deepEqual(entry, value))) {
-    results.push(invalidResult(issue(path3, "enum", value, "must be equal to one of the allowed values")));
+    results.push(invalidResult(issue(path5, "enum", value, "must be equal to one of the allowed values")));
   }
   if (typeof value === "number" && Number.isFinite(value)) {
-    evaluateNumberKeywords(schema, value, path3, results);
+    evaluateNumberKeywords(schema, value, path5, results);
   }
   if (typeof value === "string") {
-    evaluateStringKeywords(schema, value, path3, results);
+    evaluateStringKeywords(schema, value, path5, results);
   }
   if (Array.isArray(value)) {
-    evaluateArrayKeywords(schema, value, path3, results);
+    evaluateArrayKeywords(schema, value, path5, results);
   }
   if (isObject(value)) {
-    evaluateObjectKeywords(node, schema, value, path3, results);
+    evaluateObjectKeywords(node, schema, value, path5, results);
   }
   return results;
 }
-function evaluateNumberKeywords(schema, value, path3, results) {
+function evaluateNumberKeywords(schema, value, path5, results) {
   if (typeof schema.multipleOf === "number" && !isMultipleOf(value, schema.multipleOf)) {
-    results.push(invalidResult(issue(path3, `multiple of ${schema.multipleOf}`, value, `must be multiple of ${schema.multipleOf}`)));
+    results.push(invalidResult(issue(path5, `multiple of ${schema.multipleOf}`, value, `must be multiple of ${schema.multipleOf}`)));
   }
   if (typeof schema.maximum === "number" && value > schema.maximum) {
-    results.push(invalidResult(issue(path3, `<= ${schema.maximum}`, value, `must be <= ${schema.maximum}`)));
+    results.push(invalidResult(issue(path5, `<= ${schema.maximum}`, value, `must be <= ${schema.maximum}`)));
   }
   if (typeof schema.minimum === "number" && value < schema.minimum) {
-    results.push(invalidResult(issue(path3, `>= ${schema.minimum}`, value, `must be >= ${schema.minimum}`)));
+    results.push(invalidResult(issue(path5, `>= ${schema.minimum}`, value, `must be >= ${schema.minimum}`)));
   }
   if (typeof schema.exclusiveMaximum === "number" && value >= schema.exclusiveMaximum) {
-    results.push(invalidResult(issue(path3, `< ${schema.exclusiveMaximum}`, value, `must be < ${schema.exclusiveMaximum}`)));
+    results.push(invalidResult(issue(path5, `< ${schema.exclusiveMaximum}`, value, `must be < ${schema.exclusiveMaximum}`)));
   }
   if (typeof schema.exclusiveMinimum === "number" && value <= schema.exclusiveMinimum) {
-    results.push(invalidResult(issue(path3, `> ${schema.exclusiveMinimum}`, value, `must be > ${schema.exclusiveMinimum}`)));
+    results.push(invalidResult(issue(path5, `> ${schema.exclusiveMinimum}`, value, `must be > ${schema.exclusiveMinimum}`)));
   }
 }
-function evaluateStringKeywords(schema, value, path3, results) {
+function evaluateStringKeywords(schema, value, path5, results) {
   const length = unicodeLength(value);
   if (typeof schema.maxLength === "number" && length > schema.maxLength) {
-    results.push(invalidResult(issue(path3, `length <= ${schema.maxLength}`, value, `must NOT have more than ${schema.maxLength} characters`)));
+    results.push(invalidResult(issue(path5, `length <= ${schema.maxLength}`, value, `must NOT have more than ${schema.maxLength} characters`)));
   }
   if (typeof schema.minLength === "number" && length < schema.minLength) {
-    results.push(invalidResult(issue(path3, `length >= ${schema.minLength}`, value, `must NOT have fewer than ${schema.minLength} characters`)));
+    results.push(invalidResult(issue(path5, `length >= ${schema.minLength}`, value, `must NOT have fewer than ${schema.minLength} characters`)));
   }
   if (typeof schema.pattern === "string" && !new RegExp(schema.pattern, "u").test(value)) {
-    results.push(invalidResult(issue(path3, `pattern ${schema.pattern}`, value, `must match pattern ${schema.pattern}`)));
+    results.push(invalidResult(issue(path5, `pattern ${schema.pattern}`, value, `must match pattern ${schema.pattern}`)));
   }
 }
-function evaluateArrayKeywords(schema, value, path3, results) {
+function evaluateArrayKeywords(schema, value, path5, results) {
   if (typeof schema.maxItems === "number" && value.length > schema.maxItems) {
-    results.push(invalidResult(issue(path3, `items <= ${schema.maxItems}`, value, `must NOT have more than ${schema.maxItems} items`)));
+    results.push(invalidResult(issue(path5, `items <= ${schema.maxItems}`, value, `must NOT have more than ${schema.maxItems} items`)));
   }
   if (typeof schema.minItems === "number" && value.length < schema.minItems) {
-    results.push(invalidResult(issue(path3, `items >= ${schema.minItems}`, value, `must NOT have fewer than ${schema.minItems} items`)));
+    results.push(invalidResult(issue(path5, `items >= ${schema.minItems}`, value, `must NOT have fewer than ${schema.minItems} items`)));
   }
   if (schema.uniqueItems === true) {
     for (let left = 0; left < value.length; left += 1) {
       for (let right = left + 1; right < value.length; right += 1) {
         if (deepEqual(value[left], value[right])) {
-          results.push(invalidResult(issue(path3, "unique items", value, "must NOT have duplicate items")));
+          results.push(invalidResult(issue(path5, "unique items", value, "must NOT have duplicate items")));
           return;
         }
       }
     }
   }
 }
-function evaluateObjectKeywords(node, schema, value, path3, results) {
+function evaluateObjectKeywords(node, schema, value, path5, results) {
   const keys = Object.keys(value);
   if (typeof schema.maxProperties === "number" && keys.length > schema.maxProperties) {
-    results.push(invalidResult(issue(path3, `properties <= ${schema.maxProperties}`, value, `must NOT have more than ${schema.maxProperties} properties`)));
+    results.push(invalidResult(issue(path5, `properties <= ${schema.maxProperties}`, value, `must NOT have more than ${schema.maxProperties} properties`)));
   }
   if (typeof schema.minProperties === "number" && keys.length < schema.minProperties) {
-    results.push(invalidResult(issue(path3, `properties >= ${schema.minProperties}`, value, `must NOT have fewer than ${schema.minProperties} properties`)));
+    results.push(invalidResult(issue(path5, `properties >= ${schema.minProperties}`, value, `must NOT have fewer than ${schema.minProperties} properties`)));
   }
   if (Array.isArray(schema.required)) {
     for (const key2 of schema.required) {
       if (typeof key2 === "string" && !Object.prototype.hasOwnProperty.call(value, key2)) {
-        results.push(invalidResult(issue([...path3, key2], "required", void 0, `must have required property '${key2}'`)));
+        results.push(invalidResult(issue([...path5, key2], "required", void 0, `must have required property '${key2}'`)));
       }
     }
   }
   const dependentRequired = isObject(schema.dependentRequired) ? schema.dependentRequired : {};
   for (const [key2, dependencies] of Object.entries(dependentRequired)) {
     if (Object.prototype.hasOwnProperty.call(value, key2) && Array.isArray(dependencies)) {
-      addMissingDependencies(value, dependencies, path3, results);
+      addMissingDependencies(value, dependencies, path5, results);
     }
   }
   if (node.dialect === "draft7" && isObject(schema.dependencies)) {
     for (const [key2, dependencies] of Object.entries(schema.dependencies)) {
       if (Object.prototype.hasOwnProperty.call(value, key2) && Array.isArray(dependencies)) {
-        addMissingDependencies(value, dependencies, path3, results);
+        addMissingDependencies(value, dependencies, path5, results);
       }
     }
   }
 }
-function addMissingDependencies(value, dependencies, path3, results) {
+function addMissingDependencies(value, dependencies, path5, results) {
   for (const dependency of dependencies) {
     if (typeof dependency === "string" && !Object.prototype.hasOwnProperty.call(value, dependency)) {
-      results.push(invalidResult(issue([...path3, dependency], "dependency", void 0, `must have property '${dependency}'`)));
+      results.push(invalidResult(issue([...path5, dependency], "dependency", void 0, `must have property '${dependency}'`)));
     }
   }
 }
@@ -3397,19 +3397,168 @@ var SubscriptionManager = class {
 
 // ../mcp-oauth/dist/client/auth-store-session-store.js
 import crypto from "node:crypto";
-import path2 from "node:path";
+import path4 from "node:path";
 
 // ../auth-store/dist/encrypted-file-store.js
-import { createCipheriv, createDecipheriv, randomBytes, randomUUID, scrypt } from "node:crypto";
+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 path from "node:path";
+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/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;
+    }
+    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();
+      });
+    }
+    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);
+    }
+  }
+  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) {
+  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;
+  }
+}
+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);
+  }
+}
+async function readClaims(fs2, directory, ownName) {
+  const claims = [];
+  for (const name of await fs2.readdir(directory)) {
+    if (name === ownName || !name.endsWith(".claim"))
+      continue;
+    const pidText = name.slice(0, name.indexOf("-"));
+    const pid = Number(pidText);
+    if (!Number.isSafeInteger(pid) || pid < 1 || String(pid) !== pidText)
+      throw new Error("Malformed secret-store transaction lock owner");
+    const target = path.join(directory, name);
+    await assertNoSymbolicLink(fs2, target);
+    let alive = true;
+    try {
+      process.kill(pid, 0);
+    } catch (error) {
+      alive = !hasOwnErrorCode(error, "ESRCH");
+    }
+    if (!alive) {
+      try {
+        await fs2.unlink(target);
+      } catch (error) {
+        if (!hasOwnErrorCode(error, "ENOENT"))
+          throw error;
+      }
+      continue;
+    }
+    let ticket = null;
+    let raw;
+    try {
+      raw = await fs2.readFile(target, "utf8");
+    } catch (error) {
+      if (hasOwnErrorCode(error, "ENOENT"))
+        continue;
+      throw error;
+    }
+    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;
+}
+
 // ../auth-store/dist/encrypted-file-store.js
 var derivedKeyCache = /* @__PURE__ */ new Map();
 var ENCRYPTION_ALGORITHM = "aes-256-gcm";
@@ -3435,7 +3584,7 @@ var EncryptedFileStore = class {
       const defaultFileName = input.defaultFileName ?? "credentials.enc";
       assertSafeDefaultDirectory(defaultDirectory);
       assertSafeDefaultFileName(defaultFileName);
-      this.filePath = path.join(homeDirectory, defaultDirectory, defaultFileName);
+      this.filePath = path2.join(homeDirectory, defaultDirectory, defaultFileName);
       this.symbolicLinkCheckStartPath = resolveDefaultDirectoryCheckStart(homeDirectory, defaultDirectory);
     } else {
       this.filePath = input.filePath;
@@ -3475,6 +3624,12 @@ var EncryptedFileStore = class {
       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();
@@ -3491,9 +3646,9 @@ var EncryptedFileStore = class {
       authTag: authTag.toString("base64"),
       ciphertext: ciphertext.toString("base64")
     };
-    await this.fs.mkdir(path.dirname(this.filePath), { recursive: true });
+    await this.fs.mkdir(path2.dirname(this.filePath), { recursive: true });
     await this.assertCredentialPathHasNoSymbolicLinks(this.filePath);
-    const temporaryPath = `${this.filePath}.${process.pid}.${randomUUID()}.tmp`;
+    const temporaryPath = `${this.filePath}.${process.pid}.${randomUUID2()}.tmp`;
     let temporaryCreated = false;
     try {
       await this.assertCredentialPathHasNoSymbolicLinks(temporaryPath);
@@ -3523,7 +3678,7 @@ var EncryptedFileStore = class {
     }
   }
   async assertCredentialPathHasNoSymbolicLinks(targetPath) {
-    const resolvedPath = path.resolve(targetPath);
+    const resolvedPath = path2.resolve(targetPath);
     const protectedPaths = getProtectedCredentialPaths(resolvedPath, this.symbolicLinkCheckStartPath);
     for (const currentPath of protectedPaths) {
       try {
@@ -3554,26 +3709,26 @@ var EncryptedFileStore = class {
 };
 function resolveDefaultDirectoryCheckStart(homeDirectory, defaultDirectory) {
   const [firstSegment] = defaultDirectory.split(/[\\/]+/).filter(Boolean);
-  return path.resolve(homeDirectory, firstSegment ?? ".");
+  return path2.resolve(homeDirectory, firstSegment ?? ".");
 }
 function getProtectedCredentialPaths(resolvedPath, symbolicLinkCheckStartPath) {
   if (symbolicLinkCheckStartPath === null) {
     return getExplicitProtectedCredentialPaths(resolvedPath);
   }
-  const resolvedStartPath = path.resolve(symbolicLinkCheckStartPath);
+  const resolvedStartPath = path2.resolve(symbolicLinkCheckStartPath);
   if (!isPathInsideOrEqual(resolvedPath, resolvedStartPath)) {
-    return [path.dirname(resolvedPath), resolvedPath];
+    return [path2.dirname(resolvedPath), resolvedPath];
   }
   const protectedPaths = [resolvedStartPath];
   let currentPath = resolvedStartPath;
-  for (const segment of path.relative(resolvedStartPath, resolvedPath).split(path.sep).filter(Boolean)) {
-    currentPath = path.join(currentPath, segment);
+  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 (path.isAbsolute(defaultDirectory) || path.win32.isAbsolute(defaultDirectory)) {
+  if (path2.isAbsolute(defaultDirectory) || path2.win32.isAbsolute(defaultDirectory)) {
     throw new Error("defaultDirectory must be a relative path inside the home directory");
   }
   for (const segment of splitPathSegments(defaultDirectory)) {
@@ -3591,15 +3746,15 @@ function splitPathSegments(value) {
   return value.split("/").flatMap((segment) => segment.split("\\")).filter((segment) => segment.length > 0);
 }
 function getExplicitProtectedCredentialPaths(resolvedPath) {
-  const parsed = path.parse(resolvedPath);
-  const segments = resolvedPath.slice(parsed.root.length).split(path.sep).filter((segment) => segment.length > 0);
+  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 = path.join(currentPath, segment);
+    currentPath = path2.join(currentPath, segment);
     if (index === 0) {
       continue;
     }
@@ -3608,8 +3763,8 @@ function getExplicitProtectedCredentialPaths(resolvedPath) {
   return protectedPaths;
 }
 function isPathInsideOrEqual(childPath, parentPath) {
-  const relativePath = path.relative(parentPath, childPath);
-  return relativePath === "" || !relativePath.startsWith("..") && !path.isAbsolute(relativePath);
+  const relativePath = path2.relative(parentPath, childPath);
+  return relativePath === "" || !relativePath.startsWith("..") && !path2.isAbsolute(relativePath);
 }
 async function removeIfPresent(fileSystem, filePath) {
   try {
@@ -3692,16 +3847,24 @@ function isAlreadyExistsError(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");
     }
@@ -3719,6 +3882,10 @@ var KeychainStore = class {
     }
     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");
@@ -3904,6 +4071,12 @@ var DEFAULT_CLIENT_KEYCHAIN_SERVICE = "poe-code-mcp-oauth-clients";
 var MAX_JS_DATE_MS = 864e13;
 function createAuthStoreSessionStore(options = {}) {
   return {
+    async withLock(resource, operation, lockOptions) {
+      const store = createResourceSecretStore(resource, options);
+      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);
       const value = await store.get();
@@ -3958,10 +4131,10 @@ function createAuthStoreClientStore(options) {
 function createNamedSecretStore(key2, options, defaults) {
   const hash = crypto.createHash("sha256").update(key2).digest("hex");
   const configuredFilePath = options.fileStore?.filePath;
-  const parsedFilePath = configuredFilePath === void 0 ? null : path2.parse(configuredFilePath);
+  const parsedFilePath = configuredFilePath === void 0 ? null : path4.parse(configuredFilePath);
   const fileStore = {
     ...options.fileStore,
-    filePath: parsedFilePath === null ? void 0 : path2.join(parsedFilePath.dir, `${parsedFilePath.name}-${hash}${parsedFilePath.ext || ".enc"}`),
+    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"}`
@@ -5347,7 +5520,7 @@ function getParameterHeaders(schema) {
   const names = /* @__PURE__ */ new Set();
   const ancestors = /* @__PURE__ */ new Set();
   let nodes = 0;
-  const visit = (value, path3, reachable, depth) => {
+  const visit = (value, path5, reachable, depth) => {
     if (++nodes > 1e4 || depth > 64)
       throw new Error("MCP header schema traversal limit exceeded");
     if (typeof value === "boolean")
@@ -5358,7 +5531,7 @@ function getParameterHeaders(schema) {
     try {
       if (Object.prototype.hasOwnProperty.call(value, "x-mcp-header")) {
         const name = value["x-mcp-header"];
-        if (!reachable || path3.length === 0 || typeof name !== "string" || name.length === 0 || [...name].some((character) => {
+        if (!reachable || path5.length === 0 || typeof name !== "string" || name.length === 0 || [...name].some((character) => {
           const code = character.charCodeAt(0);
           return !tokenPunctuation.has(character) && !(code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122);
         }))
@@ -5369,25 +5542,25 @@ function getParameterHeaders(schema) {
         if (names.has(key2))
           throw new Error("Duplicate x-mcp-header name");
         names.add(key2);
-        headers.push({ name: `Mcp-Param-${name}`, path: [...path3], type: value.type });
+        headers.push({ name: `Mcp-Param-${name}`, path: [...path5], type: value.type });
       }
       for (const [keyword, child] of Object.entries(value)) {
         if (schemaMaps.has(keyword)) {
           if (!isRecord3(child))
             throw new Error("Invalid schema map");
           for (const [key2, nested] of Object.entries(child))
-            visit(nested, keyword === "properties" ? [...path3, key2] : path3, reachable && keyword === "properties", depth + 1);
+            visit(nested, keyword === "properties" ? [...path5, key2] : path5, reachable && keyword === "properties", depth + 1);
         } else if (schemaArrays.has(keyword)) {
           if (!Array.isArray(child))
             throw new Error("Invalid schema array");
           for (const nested of child)
-            visit(nested, path3, false, depth + 1);
+            visit(nested, path5, false, depth + 1);
         } else if (schemaChildren.has(keyword)) {
           if (Array.isArray(child))
             for (const nested of child)
-              visit(nested, path3, false, depth + 1);
+              visit(nested, path5, false, depth + 1);
           else
-            visit(child, path3, false, depth + 1);
+            visit(child, path5, false, depth + 1);
         }
       }
     } finally {
@@ -5585,8 +5758,8 @@ function authorizationServerMetadataLocations(issuer) {
   ];
   const issuerUrl = new URL(issuer);
   if (issuerUrl.pathname !== "/") {
-    const path3 = issuerUrl.pathname.endsWith("/") ? issuerUrl.pathname.slice(0, -1) : issuerUrl.pathname;
-    issuerUrl.pathname = `${path3}/.well-known/openid-configuration`;
+    const path5 = issuerUrl.pathname.endsWith("/") ? issuerUrl.pathname.slice(0, -1) : issuerUrl.pathname;
+    issuerUrl.pathname = `${path5}/.well-known/openid-configuration`;
     locations.push(issuerUrl.toString());
   }
   return locations;

package/package.json

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