toolcraft 0.0.749 → 0.0.750

package/node_modules/auth-store/README.md

@@ -48,6 +48,41 @@ to `~/.auth-store/keychain-locks`; `keychainStore.lock` can select another
 directory or filesystem adapter. Injected encrypted-file adapters need
 `readdir` support when using transactions.
 
+## Workers and portable hosts
+
+The `workerd`, `worker`, `browser`, and fallback exports contain no Node built-ins.
+Node retains the desktop API above. Use `auth-store/portable` to select the portable
+API explicitly on any host. It exports `SafeFsSecretStore`, `MigratingSecretStore`,
+`key`, and the portable `SecretStore` contract.
+
+```ts
+import { SafeFsSecretStore } from "auth-store/portable";
+
+const store = new SafeFsSecretStore({
+  fs, // Host-owned @poe-code/safe-fs FileSystem
+  filePath: "/credentials/service.enc",
+  key: encryptionKey, // Host-managed AES-256-GCM CryptoKey; encrypt + decrypt usages
+});
+await store.set("secret-value");
+const value = await store.get();
+await store.delete();
+```
+
+Keep the key in host-managed secret storage; use the same key to read persisted
+credentials across requests. No machine identity, home directory, process, or
+Keychain access is inferred. Web Crypto encrypts UTF-8 bytes with a fresh nonce
+for every write. The AES-GCM document format matches the desktop store when the
+host imports the same derived key. Missing files return `null`; malformed or
+unauthenticated documents throw and remain untouched.
+
+The filesystem must support exclusive creation and atomic rename, and its
+namespace must be controlled by the trusted host. Writes stage a private `0600`
+file and publish it by rename; path checks reject existing symbolic links.
+These checks do not protect against an untrusted actor concurrently changing
+filesystem ancestry. The portable store does not advertise `withLock`: hosts
+must provide transaction coordination across requests or Workers when needed.
+Desktop PID locks and automatic dead-process recovery are not portable.
+
 ## Backends
 
 | `backendEnvVar` value | Platform | Backend        |

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

@@ -0,0 +1,4 @@
+export { SafeFsSecretStore } from "./safe-fs-secret-store.js";
+export type { SafeFsSecretStoreInput } from "./safe-fs-secret-store.js";
+export { key, MigratingSecretStore } from "./provider-store.js";
+export type { SecretStore, SecretStoreLockOptions } from "./secret-store.js";

package/node_modules/auth-store/dist/index.browser.js

@@ -0,0 +1,2 @@
+export { SafeFsSecretStore } from "./safe-fs-secret-store.js";
+export { key, MigratingSecretStore } from "./provider-store.js";

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

@@ -1,4 +1,4 @@
-import type { SecretStore } from "./types.js";
+import type { SecretStore } from "./secret-store.js";
 export declare function key(providerId: string): string;
 export declare class MigratingSecretStore implements SecretStore {
     private readonly store;

package/node_modules/auth-store/dist/safe-fs-secret-store.d.ts

@@ -0,0 +1,21 @@
+import { type FileSystem } from "@poe-code/safe-fs/core";
+import type { SecretStore } from "./secret-store.js";
+export interface SafeFsSecretStoreInput {
+    /** Host-owned filesystem with exclusive creation and atomic rename support. */
+    fs: FileSystem;
+    /** Absolute path inside a trusted, host-controlled filesystem namespace. */
+    filePath: string;
+    /** Host-managed AES-256-GCM key, with encrypt and decrypt usages. */
+    key: CryptoKey;
+}
+/** Portable encrypted storage. Hosts own key management and transaction coordination. */
+export declare class SafeFsSecretStore implements SecretStore {
+    private readonly fs;
+    private readonly filePath;
+    private readonly key;
+    constructor(input: SafeFsSecretStoreInput);
+    get(): Promise<string | null>;
+    set(value: string): Promise<void>;
+    delete(): Promise<void>;
+    private assertSafePath;
+}

package/node_modules/auth-store/dist/safe-fs-secret-store.js

@@ -0,0 +1,119 @@
+import { dirname, normalizePath } from "@poe-code/safe-fs/core";
+import { hasOwnErrorCode } from "./error-codes.js";
+/** Portable encrypted storage. Hosts own key management and transaction coordination. */
+export class SafeFsSecretStore {
+    fs;
+    filePath;
+    key;
+    constructor(input) {
+        this.fs = input.fs;
+        if (!input.filePath.startsWith("/"))
+            throw new Error("Credential filePath must be absolute");
+        this.filePath = normalizePath(input.filePath);
+        if (this.filePath === "/")
+            throw new Error("Credential filePath must name a file");
+        this.key = input.key;
+        if (this.key.type !== "secret" || this.key.algorithm.name !== "AES-GCM" ||
+            this.key.algorithm.length !== 256 ||
+            !this.key.usages.includes("encrypt") || !this.key.usages.includes("decrypt")) {
+            throw new Error("Credential key must be an AES-256-GCM key with encrypt and decrypt usages");
+        }
+    }
+    async get() {
+        await this.assertSafePath();
+        let bytes;
+        try {
+            bytes = await this.fs.readFile(this.filePath);
+        }
+        catch (error) {
+            if (hasOwnErrorCode(error, "ENOENT"))
+                return null;
+            throw error;
+        }
+        try {
+            const document = JSON.parse(new TextDecoder().decode(bytes));
+            if (!document || typeof document !== "object" || Array.isArray(document))
+                throw new Error();
+            const record = document;
+            if (!["version", "iv", "authTag", "ciphertext"].every(key => Object.hasOwn(record, key)) ||
+                record.version !== 1 || typeof record.iv !== "string" ||
+                typeof record.authTag !== "string" || typeof record.ciphertext !== "string")
+                throw new Error();
+            const iv = decodeBase64(record.iv);
+            const tag = decodeBase64(record.authTag);
+            const ciphertext = decodeBase64(record.ciphertext);
+            if (iv.length !== 12 || tag.length !== 16)
+                throw new Error();
+            const sealed = new Uint8Array(ciphertext.length + tag.length);
+            sealed.set(ciphertext);
+            sealed.set(tag, ciphertext.length);
+            const plaintext = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, this.key, sealed);
+            return new TextDecoder("utf-8", { fatal: true }).decode(plaintext);
+        }
+        catch {
+            throw new Error("Invalid encrypted credential document; reset the store explicitly to recover");
+        }
+    }
+    async set(value) {
+        await this.assertSafePath();
+        const iv = crypto.getRandomValues(new Uint8Array(12));
+        const sealed = new Uint8Array(await crypto.subtle.encrypt({ name: "AES-GCM", iv }, this.key, new TextEncoder().encode(value)));
+        const document = JSON.stringify({
+            version: 1, iv: encodeBase64(iv),
+            authTag: encodeBase64(sealed.subarray(sealed.length - 16)),
+            ciphertext: encodeBase64(sealed.subarray(0, sealed.length - 16)),
+        });
+        await this.fs.mkdir(dirname(this.filePath), { recursive: true, mode: 0o700 });
+        await this.assertSafePath();
+        const staging = `${this.filePath}.${crypto.randomUUID()}.tmp`;
+        // Exclusive creation must succeed before this operation owns staging cleanup.
+        await this.fs.writeFile(staging, new TextEncoder().encode(document), { flag: "wx", mode: 0o600 });
+        try {
+            await this.fs.rename(staging, this.filePath);
+        }
+        catch (error) {
+            try {
+                await this.fs.rm(staging);
+            }
+            catch (cleanup) {
+                throw new AggregateError([error, cleanup], "Credential publication and cleanup failed");
+            }
+            throw error;
+        }
+    }
+    async delete() {
+        await this.assertSafePath();
+        try {
+            await this.fs.rm(this.filePath);
+        }
+        catch (error) {
+            if (!hasOwnErrorCode(error, "ENOENT"))
+                throw error;
+        }
+    }
+    async assertSafePath() {
+        let current = "";
+        for (const segment of this.filePath.slice(1).split("/")) {
+            current += `/${segment}`;
+            try {
+                if ((await this.fs.lstat(current)).type === "symlink") {
+                    throw new Error("Refusing encrypted credential path through symbolic link");
+                }
+            }
+            catch (error) {
+                if (hasOwnErrorCode(error, "ENOENT"))
+                    return;
+                throw error;
+            }
+        }
+    }
+}
+function encodeBase64(bytes) {
+    let binary = "";
+    for (const byte of bytes)
+        binary += String.fromCharCode(byte);
+    return btoa(binary);
+}
+function decodeBase64(value) {
+    return Uint8Array.from(atob(value), character => character.charCodeAt(0));
+}

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

@@ -0,0 +1,12 @@
+export interface SecretStoreLockOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+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>;
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -1,7 +1,5 @@
-export interface SecretStoreLockOptions {
-    signal?: AbortSignal;
-    timeoutMs?: number;
-}
+import type { SecretStoreLockOptions } from "./secret-store.js";
+export type { SecretStoreLockOptions } from "./secret-store.js";
 export interface SecretStoreLockFileSystem {
     mkdir(path: string, options?: {
         recursive?: boolean;

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

@@ -1,14 +1,7 @@
 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>;
-}
+import type { SecretStore } from "./secret-store.js";
+export type { SecretStore } from "./secret-store.js";
 export type StoreBackend = "file" | "keychain";
 export interface CreateSecretStoreInput {
     backend?: StoreBackend;

package/node_modules/auth-store/package.json

@@ -6,8 +6,22 @@
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "types": {
+        "workerd": "./dist/index.browser.d.ts",
+        "browser": "./dist/index.browser.d.ts",
+        "worker": "./dist/index.browser.d.ts",
+        "node": "./dist/index.d.ts",
+        "default": "./dist/index.browser.d.ts"
+      },
+      "workerd": "./dist/index.browser.js",
+      "browser": "./dist/index.browser.js",
+      "worker": "./dist/index.browser.js",
+      "node": "./dist/index.js",
+      "default": "./dist/index.browser.js"
+    },
+    "./portable": {
+      "types": "./dist/index.browser.d.ts",
+      "default": "./dist/index.browser.js"
     }
   },
   "scripts": {

package/node_modules/tiny-http-mcp-server/dist/composition.json

@@ -1,6 +1,21 @@
 {
   "schemaVersion": 1,
   "packages": [
+    {
+      "name": "@noble/hashes",
+      "version": "2.4.0",
+      "license": "MIT"
+    },
+    {
+      "name": "@poe-code/safe-fs",
+      "version": "0.0.0-dev",
+      "license": "MIT"
+    },
+    {
+      "name": "@poe-code/xml-ast",
+      "version": "0.0.1",
+      "license": "MIT"
+    },
     {
       "name": "auth-store",
       "version": "0.0.1",
@@ -18,7 +33,7 @@
     },
     {
       "name": "tiny-http-mcp-server",
-      "version": "0.1.115",
+      "version": "0.1.124",
       "license": "MIT"
     },
     {

package/node_modules/tiny-http-mcp-server/node_modules/mcp-oauth/README.md

@@ -50,6 +50,31 @@ or pending callback promise. Supply a statically registered client and trusted
 discovery. See [the public MCP example](../safe-bash-command-mcp/README.md#resumable-https-oauth)
 for callback routing and the required atomic storage contract.
 
+Hosts with an existing durable issuance journal can use
+`prepareRemoteMcpAuthorization` to obtain `{ authorizationUrl, transaction }`
+without persisting or exchanging. Store the sensitive transaction before
+exposing the URL. Optional `statePrefix` (at most 32 ASCII letters, digits,
+underscores or hyphens) adds a routing hint to a fresh 256-bit nonce; it never
+identifies or authorizes the caller. `beginRemoteMcpAuthorization` uses the same
+preparation before calling `store.create`.
+
+`registerOAuthClient`, `exchangeAuthorizationCode`, `refreshAccessToken`,
+`revokeOAuthToken`, and `discoverOAuthMetadata`
+are also available through the bundled MCP API. They use the existing protocol
+implementation; token operations return normalized `StoredOAuthTokens` and never
+persist or retry the exchange. Supply a policy-checked fetch and signal. A host
+using these operations owns one-use callback validation, issuer/redirect/expiry
+checks, durable dispatch/settlement, and credential generation fences. Returned
+tokens and `OAuthError` diagnostics are private; redact them at user boundaries.
+Revocation uses RFC 7009 form authentication, accepts empty success bodies, and
+never clears host credentials or retries a request. It shares token-operation
+authentication and has a 30-second deadline and a 1 MiB response limit.
+Registration accepts a host-approved `registrationEndpoint`, `redirectUri`, optional
+`metadata` and `tokenEndpointAuthMethod`, plus the policy-checked fetch. It reuses
+the native client registration path without consent or persistence; it bounds the
+request to 64 KiB and response to 1 MiB with a 30-second deadline, and never
+retries. Bind and store the returned registration privately before starting consent.
+
 ## Configuration
 
 `createDefaultOAuthClientProvider(options)` accepts:

package/node_modules/tiny-http-mcp-server/node_modules/mcp-oauth/dist/client/authorization-state.js

@@ -1,19 +1,19 @@
-import crypto from "node:crypto";
+import { base64url } from "jose";
 export function createAuthorizationState(input) {
     const payload = {
         v: 1,
-        n: crypto.randomBytes(16).toString("base64url"),
+        n: base64url.encode(crypto.getRandomValues(new Uint8Array(16))),
         i: input.issuer,
         r: input.requireIssuer,
     };
-    return Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+    return base64url.encode(JSON.stringify(payload));
 }
 export function parseAuthorizationState(value) {
     if (value === null || value.length === 0) {
         return null;
     }
     try {
-        const decoded = Buffer.from(value, "base64url").toString("utf8");
+        const decoded = new TextDecoder().decode(base64url.decode(value));
         const parsed = JSON.parse(decoded);
         if (!isObjectRecord(parsed)) {
             return null;

package/node_modules/tiny-http-mcp-server/node_modules/mcp-oauth/dist/client/default-oauth-client-provider.js

@@ -4,13 +4,13 @@ import { normalizeStoredOAuthClient, parseOAuthClientRegistration, registrationM
 import { normalizeOAuthScope } from "./scope.js";
 import { normalizeOAuthTokenEndpointAuthMethod } from "./token-auth-method.js";
 import { isIP } from "node:net";
-import { fetchMcpResponse } from "../http-fetch.js";
+import { registerOAuthClient } from "./register-client.js";
 import { URL } from "node:url";
 import { createAuthStoreClientStore, createAuthStoreSessionStore, assertPersistenceNamespace } from "./auth-store-session-store.js";
 import { createLoopbackAuthorizationSession, validateAuthorizationRedirect, snapshotLoopbackAuthorizationOptions } from "./loopback-authorization.js";
 import { createAuthorizationState } from "./authorization-state.js";
 import { generateCodeChallenge, generateCodeVerifier } from "./pkce.js";
-import { exchangeAuthorizationCode, OAuthError, refreshAccessToken, isRetryableOAuthError, readOAuthJsonObjectResponse } from "./token-endpoint.js";
+import { exchangeAuthorizationCode, OAuthError, refreshAccessToken, isRetryableOAuthError } from "./token-endpoint.js";
 import { canonicalizeResourceIndicator } from "../resource-indicator.js";
 import { withOAuthSessionTransaction } from "./session-transaction.js";
 import { waitForOAuthOperation } from "./cancellable-operation.js";
@@ -466,20 +466,11 @@ export function createDefaultOAuthClientProvider(options) {
             ["none", "client_secret_basic", "client_secret_post"].find(method => supported.includes(method)));
         if (registrationMethod === undefined || (supported !== undefined && !supported.includes(registrationMethod)))
             throw new Error("Authorization server does not support the requested OAuth token endpoint authentication");
-        const registrationBody = buildClientRegistrationBody(clientMetadata, redirectUri, registrationMethod);
-        const deadline = AbortSignal.timeout(30_000);
-        const signal = parentSignal === undefined ? deadline : AbortSignal.any([parentSignal, deadline]);
-        const response = await fetchMcpResponse(fetch, registrationEndpoint, {
-            method: "POST",
-            headers: {
-                Accept: "application/json",
-                "Content-Type": "application/json"
-            },
-            body: JSON.stringify(registrationBody),
-            signal
+        const registration = await registerOAuthClient({
+            registrationEndpoint, redirectUri, metadata: clientMetadata,
+            tokenEndpointAuthMethod: normalizeOAuthTokenEndpointAuthMethod(registrationMethod),
+            fetch, signal: parentSignal
         });
-        const payload = await readOAuthJsonObjectResponse(response, signal);
-        const registration = parseOAuthClientRegistration(payload);
         const registeredSecret = getOwnString(registration, "client_secret");
         const responseMethod = normalizeOAuthTokenEndpointAuthMethod(getOwnEntry(registration, "token_endpoint_auth_method")) ??
             requestedTokenMethod ?? (supported === undefined ? undefined : normalizeOAuthTokenEndpointAuthMethod(registrationMethod));
@@ -829,31 +820,6 @@ function assertTokenEndpointAuthentication(client, metadata) {
     if (supported !== undefined && !supported.includes(method))
         throw new Error("Authorization server does not support the requested OAuth token endpoint authentication");
 }
-function buildClientRegistrationBody(metadata, redirectUri, tokenEndpointAuthMethod) {
-    const body = {
-        redirect_uris: [redirectUri],
-        grant_types: ["authorization_code", "refresh_token"],
-        response_types: ["code"],
-        token_endpoint_auth_method: tokenEndpointAuthMethod
-    };
-    const clientName = metadata === undefined ? undefined : getOwnString(metadata, "clientName");
-    const scope = metadata === undefined ? undefined : getOwnString(metadata, "scope");
-    const softwareId = metadata === undefined ? undefined : getOwnString(metadata, "softwareId");
-    const softwareVersion = metadata === undefined ? undefined : getOwnString(metadata, "softwareVersion");
-    if (clientName !== undefined && clientName.length > 0) {
-        body.client_name = clientName;
-    }
-    if (scope !== undefined && scope.length > 0) {
-        body.scope = scope;
-    }
-    if (softwareId !== undefined && softwareId.length > 0) {
-        body.software_id = softwareId;
-    }
-    if (softwareVersion !== undefined && softwareVersion.length > 0) {
-        body.software_version = softwareVersion;
-    }
-    return body;
-}
 function toStoredDiscovery(discovery) {
     return {
         resourceMetadataUrl: discovery.resourceMetadataUrl,

package/node_modules/tiny-http-mcp-server/node_modules/mcp-oauth/dist/client/oauth-form.d.ts

@@ -0,0 +1,10 @@
+import type { OAuthTokenEndpointAuthMethod } from "./types.js";
+export declare function createOAuthFormRequest(input: {
+    clientId: string;
+    clientSecret?: string;
+    tokenEndpointAuthMethod?: OAuthTokenEndpointAuthMethod;
+    params: Record<string, string>;
+}): {
+    body: URLSearchParams;
+    headers: Headers;
+};

package/node_modules/tiny-http-mcp-server/node_modules/mcp-oauth/dist/client/oauth-form.js

@@ -0,0 +1,20 @@
+import { normalizeOAuthTokenEndpointAuthMethod } from "./token-auth-method.js";
+export function createOAuthFormRequest(input) {
+    const method = normalizeOAuthTokenEndpointAuthMethod(input.tokenEndpointAuthMethod) ??
+        (input.clientSecret === undefined ? "none" : "client_secret_post");
+    if (method !== "none" && (input.clientSecret === undefined || input.clientSecret.trim() === ""))
+        throw new Error("OAuth token endpoint authentication requires a client secret");
+    const body = new URLSearchParams(input.params);
+    const headers = new Headers({ Accept: "application/json", "Content-Type": "application/x-www-form-urlencoded" });
+    if (method === "client_secret_basic") {
+        const encoded = new URLSearchParams({ credential: input.clientId }).toString().slice("credential=".length);
+        const encodedSecret = new URLSearchParams({ credential: input.clientSecret }).toString().slice("credential=".length);
+        headers.set("Authorization", `Basic ${btoa(`${encoded}:${encodedSecret}`)}`);
+    }
+    else {
+        body.set("client_id", input.clientId);
+        if (method === "client_secret_post")
+            body.set("client_secret", input.clientSecret);
+    }
+    return { body, headers };
+}

package/node_modules/tiny-http-mcp-server/node_modules/mcp-oauth/dist/client/pkce.js

@@ -1,7 +1,8 @@
-import crypto from "node:crypto";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { base64url } from "jose";
 export function generateCodeVerifier() {
-    return crypto.randomBytes(32).toString("base64url");
+    return base64url.encode(crypto.getRandomValues(new Uint8Array(32)));
 }
 export function generateCodeChallenge(verifier) {
-    return crypto.createHash("sha256").update(verifier).digest("base64url");
+    return base64url.encode(sha256(new TextEncoder().encode(verifier)));
 }

package/node_modules/tiny-http-mcp-server/node_modules/mcp-oauth/dist/client/register-client.d.ts

@@ -0,0 +1,14 @@
+import type { OAuthClientMetadata, OAuthClientRegistration, OAuthMetadataFetch, OAuthTokenEndpointAuthMethod } from "./types.js";
+export interface RegisterOAuthClientOptions {
+    /** Discovered endpoint approved by the host's network and issuer policy. */
+    registrationEndpoint: string;
+    redirectUri: string;
+    metadata?: OAuthClientMetadata;
+    tokenEndpointAuthMethod?: OAuthTokenEndpointAuthMethod;
+    fetch: OAuthMetadataFetch;
+    signal?: AbortSignal;
+}
+/** RFC 7591 registration only: no consent, persistence, or automatic retries.
+ * The host owns issuer/redirect binding and private persistence of the returned registration.
+ */
+export declare function registerOAuthClient(input: RegisterOAuthClientOptions): Promise<OAuthClientRegistration>;

package/node_modules/tiny-http-mcp-server/node_modules/mcp-oauth/dist/client/register-client.js

@@ -0,0 +1,53 @@
+import { fetchMcpResponse } from "../http-fetch.js";
+import { parseOAuthClientRegistration } from "./client-registration.js";
+import { loopbackTarget, validateHostedOAuthRedirect } from "./redirect-target.js";
+import { readOAuthJsonObjectResponse } from "./token-endpoint.js";
+import { normalizeOAuthTokenEndpointAuthMethod } from "./token-auth-method.js";
+/** RFC 7591 registration only: no consent, persistence, or automatic retries.
+ * The host owns issuer/redirect binding and private persistence of the returned registration.
+ */
+export async function registerOAuthClient(input) {
+    if (new URL(input.redirectUri).protocol === "https:")
+        validateHostedOAuthRedirect(input.redirectUri);
+    else
+        loopbackTarget({ redirectUri: input.redirectUri });
+    const body = JSON.stringify(buildClientRegistrationBody(input.metadata, input.redirectUri, normalizeOAuthTokenEndpointAuthMethod(input.tokenEndpointAuthMethod) ?? "none"));
+    if (new TextEncoder().encode(body).byteLength > 65_536)
+        throw new Error("OAuth registration request is too large");
+    input.signal?.throwIfAborted();
+    const deadline = AbortSignal.timeout(30_000);
+    const signal = input.signal === undefined ? deadline : AbortSignal.any([input.signal, deadline]);
+    const response = await fetchMcpResponse(input.fetch, input.registrationEndpoint, {
+        method: "POST", headers: { Accept: "application/json", "Content-Type": "application/json" }, body, signal
+    });
+    return parseOAuthClientRegistration(await readOAuthJsonObjectResponse(response, signal));
+}
+function getOwnString(input, key) {
+    const descriptor = Object.getOwnPropertyDescriptor(input, key);
+    return descriptor !== undefined && "value" in descriptor && typeof descriptor.value === "string" ? descriptor.value : undefined;
+}
+function buildClientRegistrationBody(metadata, redirectUri, tokenEndpointAuthMethod) {
+    const body = {
+        redirect_uris: [redirectUri],
+        grant_types: ["authorization_code", "refresh_token"],
+        response_types: ["code"],
+        token_endpoint_auth_method: tokenEndpointAuthMethod
+    };
+    const clientName = metadata === undefined ? undefined : getOwnString(metadata, "clientName");
+    const scope = metadata === undefined ? undefined : getOwnString(metadata, "scope");
+    const softwareId = metadata === undefined ? undefined : getOwnString(metadata, "softwareId");
+    const softwareVersion = metadata === undefined ? undefined : getOwnString(metadata, "softwareVersion");
+    if (clientName !== undefined && clientName.length > 0) {
+        body.client_name = clientName;
+    }
+    if (scope !== undefined && scope.length > 0) {
+        body.scope = scope;
+    }
+    if (softwareId !== undefined && softwareId.length > 0) {
+        body.software_id = softwareId;
+    }
+    if (softwareVersion !== undefined && softwareVersion.length > 0) {
+        body.software_version = softwareVersion;
+    }
+    return body;
+}

package/node_modules/tiny-http-mcp-server/node_modules/mcp-oauth/dist/client/resumable.d.ts

@@ -20,12 +20,14 @@ export interface RemoteMcpAuthorizationStore {
      */
     commit(transaction: RemoteMcpAuthorizationTransaction, session: StoredOAuthSession): Promise<boolean>;
 }
-export interface BeginRemoteMcpAuthorizationOptions {
+export interface PrepareRemoteMcpAuthorizationOptions {
     readonly resource: string;
     readonly redirectUri: string;
+    /** Consent preparation needs only public client identity; a durable host may load the secret at exchange. */
     readonly client: StoredOAuthClient;
     readonly scope?: string;
-    readonly store: RemoteMcpAuthorizationStore;
+    /** Optional routing hint; entropy always comes from a fresh 256-bit nonce. */
+    readonly statePrefix?: string;
     /** Host-validated discovery, including issuer trust and network policy. No implicit network access. */
     readonly discover: (resource: string, signal?: AbortSignal) => Promise<OAuthDiscoveryResult>;
     readonly signal?: AbortSignal;
@@ -33,6 +35,9 @@ export interface BeginRemoteMcpAuthorizationOptions {
     /** Transaction lifetime, at most ten minutes. */
     readonly ttlMs?: number;
 }
+export interface BeginRemoteMcpAuthorizationOptions extends PrepareRemoteMcpAuthorizationOptions {
+    readonly store: RemoteMcpAuthorizationStore;
+}
 export interface CompleteRemoteMcpAuthorizationOptions {
     readonly callbackUrl: string;
     readonly store: RemoteMcpAuthorizationStore;
@@ -41,6 +46,15 @@ export interface CompleteRemoteMcpAuthorizationOptions {
     readonly signal?: AbortSignal;
     readonly now?: () => number;
 }
+/** Prepare consent for a host that owns a durable issuance journal.
+ * The transaction contains secrets: persist privately before exposing the URL.
+ * The host must consume state once, validate callback issuer/redirect/expiry,
+ * and fence token persistence against reset or superseding grants.
+ */
+export declare function prepareRemoteMcpAuthorization(options: PrepareRemoteMcpAuthorizationOptions): Promise<{
+    authorizationUrl: string;
+    transaction: RemoteMcpAuthorizationTransaction;
+}>;
 /** Start consent without a listener or a pending callback promise. Only the URL leaves private storage. */
 export declare function beginRemoteMcpAuthorization(options: BeginRemoteMcpAuthorizationOptions): Promise<{
     authorizationUrl: string;