toolcraft 0.0.739 → 0.0.741

package/composition.json

@@ -98,7 +98,7 @@
     },
     {
       "name": "tiny-http-mcp-server",
-      "version": "0.1.111",
+      "version": "0.1.113",
       "license": "MIT"
     },
     {
@@ -113,7 +113,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.739",
+      "version": "0.0.741",
       "license": "MIT"
     },
     {
@@ -123,7 +123,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.739",
+      "version": "0.0.741",
       "license": "MIT"
     },
     {

package/dist/composition.json

@@ -98,7 +98,7 @@
     },
     {
       "name": "tiny-http-mcp-server",
-      "version": "0.1.111",
+      "version": "0.1.113",
       "license": "MIT"
     },
     {
@@ -113,7 +113,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.739",
+      "version": "0.0.741",
       "license": "MIT"
     },
     {
@@ -123,7 +123,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.739",
+      "version": "0.0.741",
       "license": "MIT"
     },
     {

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

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

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

@@ -41,6 +41,15 @@ alone do not establish either native error type.
 - `createJwksTokenVerifier(options)`: JWKS-backed access-token verifier for MCP servers.
 - `OAuthError`: OAuth HTTP error type with status, retryability and known-outcome fields.
 
+## Resumable server authorization
+
+`beginRemoteMcpAuthorization` and `completeRemoteMcpAuthorization` are available
+in both Node and Worker exports, and through `@poe-platform/safe-bash/mcp`.
+They use Web Crypto and host storage, with no filesystem, listener, browser opener
+or pending callback promise. Supply a statically registered client and trusted
+discovery. See [the public MCP example](../safe-bash-mcp/README.md#resumable-https-oauth)
+for callback routing and the required atomic storage contract.
+
 ## Configuration
 
 `createDefaultOAuthClientProvider(options)` accepts:

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

@@ -0,0 +1,52 @@
+import type { OAuthDiscoveryResult, OAuthMetadataFetch, StoredOAuthClient, StoredOAuthSession } from "./types.js";
+/** Sensitive, JSON-serializable record. Store only in private, authenticated host storage. */
+export interface RemoteMcpAuthorizationTransaction {
+    readonly state: string;
+    readonly expiresAt: number;
+    readonly redirectUri: string;
+    readonly codeVerifier: string;
+    readonly requireIssuer: boolean;
+    readonly session: StoredOAuthSession;
+}
+/** Bind each store instance to the authenticated user and logical server. */
+export interface RemoteMcpAuthorizationStore {
+    /** Atomically insert a unique state and capture the current credential generation. Never overwrite a state. */
+    create(transaction: RemoteMcpAuthorizationTransaction): Promise<void>;
+    /** Atomically remove/mark consumed, returning at most once across all workers. Preserve the commit fence. */
+    consume(state: string): Promise<RemoteMcpAuthorizationTransaction | null>;
+    /** Atomically persist only if the consumed transaction's generation is still current.
+     * Reset, deletion, reconfiguration and a superseding grant must invalidate the fence.
+     * Return false if stale. Never implement as an unconditional credential save.
+     */
+    commit(transaction: RemoteMcpAuthorizationTransaction, session: StoredOAuthSession): Promise<boolean>;
+}
+export interface BeginRemoteMcpAuthorizationOptions {
+    readonly resource: string;
+    readonly redirectUri: string;
+    readonly client: StoredOAuthClient;
+    readonly scope?: string;
+    readonly store: RemoteMcpAuthorizationStore;
+    /** Host-validated discovery, including issuer trust and network policy. No implicit network access. */
+    readonly discover: (resource: string, signal?: AbortSignal) => Promise<OAuthDiscoveryResult>;
+    readonly signal?: AbortSignal;
+    readonly now?: () => number;
+    /** Transaction lifetime, at most ten minutes. */
+    readonly ttlMs?: number;
+}
+export interface CompleteRemoteMcpAuthorizationOptions {
+    readonly callbackUrl: string;
+    readonly store: RemoteMcpAuthorizationStore;
+    /** Required host network policy. Redirects are rejected, including at the token endpoint. */
+    readonly fetch: OAuthMetadataFetch;
+    readonly signal?: AbortSignal;
+    readonly now?: () => number;
+}
+/** 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;
+    expiresAt: number;
+}>;
+/** Redeem once after any process restart, then conditionally persist. Returns no tokens or callback secrets. */
+export declare function completeRemoteMcpAuthorization(options: CompleteRemoteMcpAuthorizationOptions): Promise<{
+    resource: string;
+}>;

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

@@ -0,0 +1,133 @@
+import { exchangeAuthorizationCode } from "./token-endpoint.js";
+import { normalizeOAuthTokenEndpointAuthMethod } from "./token-auth-method.js";
+import { normalizeOAuthScope } from "./scope.js";
+const responseParameters = ["code", "state", "iss", "error", "error_description", "error_uri"];
+function httpsUrl(value) {
+    const url = new URL(value);
+    if (url.protocol !== "https:" || url.username || url.password || url.href.includes("#"))
+        throw new Error();
+    return url;
+}
+function base64url(bytes) {
+    return btoa(String.fromCharCode(...bytes)).split("+").join("-").split("/").join("_").split("=").join("");
+}
+function timestamp(now) {
+    const value = now();
+    if (!Number.isSafeInteger(value) || value < 0 || value > 8_640_000_000_000_000 - 600_000)
+        throw new Error();
+    return value;
+}
+/** Start consent without a listener or a pending callback promise. Only the URL leaves private storage. */
+export async function beginRemoteMcpAuthorization(options) {
+    try {
+        const { store, signal, discover } = options;
+        const now = options.now?.bind(options) ?? Date.now;
+        const resource = httpsUrl(options.resource).href;
+        const redirect = httpsUrl(options.redirectUri);
+        if (responseParameters.some(key => redirect.searchParams.has(key)))
+            throw new Error();
+        const client = structuredClone(options.client);
+        if (typeof client.clientId !== "string" || !client.clientId.trim())
+            throw new Error();
+        const method = normalizeOAuthTokenEndpointAuthMethod(client.tokenEndpointAuthMethod) ?? (client.clientSecret === undefined ? "none" : "client_secret_post");
+        if (client.clientSecret !== undefined && (typeof client.clientSecret !== "string" || !client.clientSecret.trim()))
+            throw new Error();
+        if (method !== "none" && client.clientSecret === undefined)
+            throw new Error();
+        if (client.registration !== undefined && (client.registration.client_id !== client.clientId ||
+            (client.registration.client_secret != null && client.registration.client_secret !== client.clientSecret) ||
+            (client.registration.token_endpoint_auth_method != null && client.registration.token_endpoint_auth_method !== method)))
+            throw new Error();
+        client.tokenEndpointAuthMethod = method;
+        if (client.requestedRedirectUri !== undefined && client.requestedRedirectUri !== redirect.href)
+            throw new Error();
+        if (client.registration?.redirect_uris != null && !client.registration.redirect_uris.includes(redirect.href))
+            throw new Error();
+        const scope = normalizeOAuthScope(options.scope);
+        const ttl = options.ttlMs ?? 600_000;
+        if (!Number.isSafeInteger(ttl) || ttl < 1 || ttl > 600_000)
+            throw new Error();
+        signal?.throwIfAborted();
+        const metadata = structuredClone(await discover(resource, signal));
+        signal?.throwIfAborted();
+        const server = metadata.authorizationServerMetadata;
+        if (httpsUrl(metadata.resource).href !== resource || httpsUrl(metadata.resourceMetadata.resource).href !== resource ||
+            server.issuer !== metadata.authorizationServer || !metadata.resourceMetadata.authorization_servers.includes(server.issuer) ||
+            !server.response_types_supported.includes("code") || !server.code_challenge_methods_supported.includes("S256"))
+            throw new Error();
+        httpsUrl(server.issuer);
+        httpsUrl(server.token_endpoint);
+        const authorization = httpsUrl(server.authorization_endpoint);
+        const state = base64url(crypto.getRandomValues(new Uint8Array(32)));
+        const codeVerifier = base64url(crypto.getRandomValues(new Uint8Array(32)));
+        const challenge = base64url(new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(codeVerifier))));
+        const expiresAt = timestamp(now) + ttl;
+        const session = { resource, authorizationServer: server.issuer,
+            client: { ...client, registrationOwnership: "caller", requestedRedirectUri: redirect.href },
+            ...(scope === undefined ? {} : { requestedScope: scope }),
+            discovery: { resourceMetadataUrl: metadata.resourceMetadataUrl, resourceMetadata: metadata.resourceMetadata, authorizationServerMetadata: server } };
+        for (const [key, value] of Object.entries({ response_type: "code", client_id: client.clientId, redirect_uri: redirect.href,
+            resource, state, code_challenge: challenge, code_challenge_method: "S256" }))
+            authorization.searchParams.set(key, value);
+        authorization.searchParams.delete("scope");
+        if (scope !== undefined)
+            authorization.searchParams.set("scope", scope);
+        signal?.throwIfAborted();
+        await store.create({ state, expiresAt, redirectUri: redirect.href, codeVerifier,
+            requireIssuer: server.authorization_response_iss_parameter_supported === true, session });
+        signal?.throwIfAborted();
+        return { authorizationUrl: authorization.href, expiresAt };
+    }
+    catch {
+        throw new Error("Unable to begin MCP authorization");
+    }
+}
+/** Redeem once after any process restart, then conditionally persist. Returns no tokens or callback secrets. */
+export async function completeRemoteMcpAuthorization(options) {
+    try {
+        const { store, fetch, signal } = options;
+        const now = options.now?.bind(options) ?? Date.now;
+        const callback = httpsUrl(options.callbackUrl);
+        for (const key of responseParameters)
+            if (callback.searchParams.getAll(key).length > 1)
+                throw new Error();
+        const state = callback.searchParams.get("state");
+        if (!state || state.length > 256)
+            throw new Error();
+        signal?.throwIfAborted();
+        const stored = await store.consume(state);
+        if (stored === null)
+            throw new Error();
+        const transaction = structuredClone(stored);
+        if (transaction.state !== state || !Number.isSafeInteger(transaction.expiresAt) || transaction.expiresAt <= timestamp(now))
+            throw new Error();
+        const expected = httpsUrl(transaction.redirectUri);
+        const issuer = callback.searchParams.get("iss");
+        if ((transaction.requireIssuer && issuer === null) || (issuer !== null && issuer !== transaction.session.authorizationServer))
+            throw new Error();
+        const code = callback.searchParams.get("code");
+        if (!code || callback.searchParams.has("error"))
+            throw new Error();
+        for (const key of responseParameters)
+            callback.searchParams.delete(key);
+        // Compare query pairs without changing their encoding/order requirements on the registered redirect.
+        const actualPairs = [...callback.searchParams].sort(), expectedPairs = [...expected.searchParams].sort();
+        if (callback.origin !== expected.origin || callback.pathname !== expected.pathname || JSON.stringify(actualPairs) !== JSON.stringify(expectedPairs))
+            throw new Error();
+        const session = structuredClone(transaction.session);
+        const tokenEndpoint = httpsUrl(String(session.discovery.authorizationServerMetadata.token_endpoint)).href;
+        signal?.throwIfAborted();
+        session.tokens = await exchangeAuthorizationCode({ tokenEndpoint, clientId: session.client.clientId,
+            clientSecret: session.client.clientSecret, tokenEndpointAuthMethod: session.client.tokenEndpointAuthMethod,
+            code, codeVerifier: transaction.codeVerifier, redirectUri: transaction.redirectUri, resource: session.resource, fetch, signal, now });
+        if (session.tokens.scope === undefined && session.requestedScope !== undefined)
+            session.tokens.scope = session.requestedScope;
+        signal?.throwIfAborted();
+        if (transaction.expiresAt <= timestamp(now) || !await store.commit(transaction, session))
+            throw new Error();
+        return { resource: session.resource };
+    }
+    catch {
+        throw new Error("Unable to complete MCP authorization");
+    }
+}

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

@@ -89,7 +89,7 @@ async function requestTokens(input) {
     if (method === "client_secret_basic") {
         const encoded = new URLSearchParams({ credential: input.clientId }).toString().slice("credential=".length);
         const encodedSecret = new URLSearchParams({ credential: input.clientSecret }).toString().slice("credential=".length);
-        headers.set("Authorization", `Basic ${Buffer.from(`${encoded}:${encodedSecret}`).toString("base64")}`);
+        headers.set("Authorization", `Basic ${btoa(`${encoded}:${encodedSecret}`)}`);
     }
     else {
         body.set("client_id", input.clientId);

package/node_modules/tiny-http-mcp-server/node_modules/mcp-oauth/dist/index.browser.d.ts

@@ -10,3 +10,5 @@ import type { OAuthClientProvider, OAuthClientProviderOptions } from "./client/t
 export declare function createOAuthClientProvider(options: OAuthClientProviderOptions): OAuthClientProvider;
 export declare function createDefaultOAuthClientProvider(): never;
 export declare function createAuthStoreSessionStore(): never;
+export { beginRemoteMcpAuthorization, completeRemoteMcpAuthorization } from "./client/resumable.js";
+export type { RemoteMcpAuthorizationTransaction, RemoteMcpAuthorizationStore, BeginRemoteMcpAuthorizationOptions, CompleteRemoteMcpAuthorizationOptions } from "./client/resumable.js";

package/node_modules/tiny-http-mcp-server/node_modules/mcp-oauth/dist/index.browser.js

@@ -16,3 +16,4 @@ export function createDefaultOAuthClientProvider() {
 export function createAuthStoreSessionStore() {
     throw new Error("Desktop OAuth persistence is unavailable in Worker MCP");
 }
+export { beginRemoteMcpAuthorization, completeRemoteMcpAuthorization } from "./client/resumable.js";

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

@@ -18,3 +18,5 @@ export type { JwksTokenVerifier, JwksTokenVerifierOptions, JwksVerifiedAccessTok
 export type { LoopbackAuthorizationOptions, LoopbackAuthorizationSession, OAuthLandingPage, } from "./client/loopback-authorization.js";
 export { readBoundedResponseText } from "./http-response.js";
 export { fetchMcpResponse } from "./http-fetch.js";
+export { beginRemoteMcpAuthorization, completeRemoteMcpAuthorization } from "./client/resumable.js";
+export type { RemoteMcpAuthorizationTransaction, RemoteMcpAuthorizationStore, BeginRemoteMcpAuthorizationOptions, CompleteRemoteMcpAuthorizationOptions } from "./client/resumable.js";

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

@@ -13,3 +13,4 @@ export { canonicalizeResourceIndicator, } from "./resource-indicator.js";
 export { createJwksTokenVerifier, } from "./server/jwks-token-verifier.js";
 export { readBoundedResponseText } from "./http-response.js";
 export { fetchMcpResponse } from "./http-fetch.js";
+export { beginRemoteMcpAuthorization, completeRemoteMcpAuthorization } from "./client/resumable.js";

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

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

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

@@ -3570,11 +3570,11 @@ function copyBoundedOAuthJson(value, message) {
 import http from "node:http";
 
 // ../mcp-oauth/dist/client/authorization-state.js
-import crypto from "node:crypto";
+import crypto2 from "node:crypto";
 function createAuthorizationState(input) {
   const payload = {
     v: 1,
-    n: crypto.randomBytes(16).toString("base64url"),
+    n: crypto2.randomBytes(16).toString("base64url"),
     i: input.issuer,
     r: input.requireIssuer
   };
@@ -4114,7 +4114,7 @@ function registrationMatchesRedirect(client, requestedUri, fresh = false) {
 }
 
 // ../mcp-oauth/dist/client/auth-store-session-store.js
-import crypto2 from "node:crypto";
+import crypto3 from "node:crypto";
 import path4 from "node:path";
 
 // ../auth-store/dist/encrypted-file-store.js
@@ -4871,7 +4871,7 @@ function snapshotPersistenceOptions(options) {
 }
 function createNamedSecretStore(key2, options, defaults, namespace) {
   options = snapshotOAuthPersistenceOptions(options);
-  const hash = crypto2.createHash("sha256").update(namespace === void 0 ? key2 : JSON.stringify([namespace, key2])).digest("hex");
+  const hash = crypto3.createHash("sha256").update(namespace === void 0 ? key2 : JSON.stringify([namespace, key2])).digest("hex");
   const configuredFilePath = options.fileStore?.filePath;
   const parsedFilePath = configuredFilePath === void 0 ? null : path4.parse(configuredFilePath);
   const fileStore = {
@@ -5184,12 +5184,12 @@ async function fetchMcpResponse(fetchImplementation, input, init = {}) {
 import { URL as URL2 } from "node:url";
 
 // ../mcp-oauth/dist/client/pkce.js
-import crypto3 from "node:crypto";
+import crypto4 from "node:crypto";
 function generateCodeVerifier() {
-  return crypto3.randomBytes(32).toString("base64url");
+  return crypto4.randomBytes(32).toString("base64url");
 }
 function generateCodeChallenge(verifier) {
-  return crypto3.createHash("sha256").update(verifier).digest("base64url");
+  return crypto4.createHash("sha256").update(verifier).digest("base64url");
 }
 
 // ../mcp-oauth/dist/http-response.js
@@ -5322,7 +5322,7 @@ async function requestTokens(input) {
   if (method === "client_secret_basic") {
     const encoded = new URLSearchParams({ credential: input.clientId }).toString().slice("credential=".length);
     const encodedSecret = new URLSearchParams({ credential: input.clientSecret }).toString().slice("credential=".length);
-    headers.set("Authorization", `Basic ${Buffer.from(`${encoded}:${encodedSecret}`).toString("base64")}`);
+    headers.set("Authorization", `Basic ${btoa(`${encoded}:${encodedSecret}`)}`);
   } else {
     body.set("client_id", input.clientId);
     if (method === "client_secret_post")

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

@@ -8,7 +8,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.739",
+      "version": "0.0.741",
       "license": "MIT"
     }
   ]

package/node_modules/toolcraft-schema/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-schema",
-  "version": "0.0.739",
+  "version": "0.0.741",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft",
-  "version": "0.0.739",
+  "version": "0.0.741",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -162,7 +162,7 @@
     "yaml"
   ],
   "optionalDependencies": {
-    "toolcraft-schema": "0.0.739",
+    "toolcraft-schema": "0.0.741",
     "toolcraft-design": "*",
     "@poe-code/frontmatter": "*",
     "@poe-code/agent-mcp-config": "*",