toolcraft 0.0.124 → 0.0.126

package/composition.json

@@ -76,6 +76,11 @@
       "version": "0.0.1",
       "license": "MIT"
     },
+    {
+      "name": "mcp-oauth-server",
+      "version": "0.1.0",
+      "license": "MIT"
+    },
     {
       "name": "sisteransi",
       "version": "1.0.5",
@@ -88,7 +93,7 @@
     },
     {
       "name": "tiny-http-mcp-server",
-      "version": "0.1.0",
+      "version": "0.1.4",
       "license": "MIT"
     },
     {
@@ -103,7 +108,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.124",
+      "version": "0.0.126",
       "license": "MIT"
     },
     {
@@ -113,7 +118,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.124",
+      "version": "0.0.126",
       "license": "MIT"
     },
     {

package/dist/composition.json

@@ -76,6 +76,11 @@
       "version": "0.0.1",
       "license": "MIT"
     },
+    {
+      "name": "mcp-oauth-server",
+      "version": "0.1.0",
+      "license": "MIT"
+    },
     {
       "name": "sisteransi",
       "version": "1.0.5",
@@ -88,7 +93,7 @@
     },
     {
       "name": "tiny-http-mcp-server",
-      "version": "0.1.0",
+      "version": "0.1.4",
       "license": "MIT"
     },
     {
@@ -103,7 +108,7 @@
     },
     {
       "name": "toolcraft",
-      "version": "0.0.124",
+      "version": "0.0.126",
       "license": "MIT"
     },
     {
@@ -113,7 +118,7 @@
     },
     {
       "name": "toolcraft-schema",
-      "version": "0.0.124",
+      "version": "0.0.126",
       "license": "MIT"
     },
     {

package/dist/http.d.ts

@@ -1,6 +1,7 @@
 import "./node-require-shim.js";
 import { type HttpListenOptions, type HttpServer, type HttpServerHandle, type HttpToolContext, type HttpTransportOptions } from "tiny-http-mcp-server/server";
 import type { Group } from "./index.js";
+import type { OAuthAuthorizationServer } from "mcp-oauth-server";
 import { type RunMCPOptions } from "./mcp.js";
 export type ToolcraftHTTPContext = HttpToolContext;
 export type ToolcraftHTTPServer = HttpServer;
@@ -13,7 +14,16 @@ export interface RunHTTPMCPOptions<TServices extends object = Record<string, unk
     path?: string;
     requestServices?(context: ToolcraftHTTPContext): Partial<TServices> | Promise<Partial<TServices>>;
 }
+export interface HTTPMCPAuthorizationOptions {
+    authorizationServer: Pick<OAuthAuthorizationServer, "issuer" | "verifyAccessToken">;
+    resource: string;
+    requiredScopes?: readonly string[];
+    scopesSupported?: readonly string[];
+}
+export declare function createHTTPMCPAuthorization(options: HTTPMCPAuthorizationOptions): import("tiny-http-mcp-server/server").TinyHttpMcpServerOAuthOptions;
 export declare function createHTTPMCPServer<TServices extends object = Record<string, unknown>>(roots: Group<TServices> | Group<TServices>[], options: RunHTTPMCPOptions<TServices>): Promise<ToolcraftHTTPServer>;
 export declare function runHTTPMCP<TServices extends object = Record<string, unknown>>(roots: Group<TServices> | Group<TServices>[], options: RunHTTPMCPOptions<TServices>): Promise<ToolcraftHTTPServerHandle>;
 export type { HttpListenOptions, HttpObservabilityEvent, HttpObservabilityOptions, RequestAuthInfo, Session, SessionStore, StreamableHttpTransportOptions, TinyHttpMcpServerOAuthOptions, TokenVerifier, VerifiedAccessToken } from "tiny-http-mcp-server/server";
 export { createJwksTokenVerifier, TokenVerificationError } from "tiny-http-mcp-server/server";
+export { createAuthorizationInteractionSecurity, createInMemoryAuthorizationServerStore, createOAuthAuthorizationServer, verifyAuthorizationInteractionCsrf } from "mcp-oauth-server";
+export type { AuthorizationInteraction, AuthorizationInteractionSecurity, AuthorizationServerStore, OAuthAuthorizationServer, OAuthAuthorizationServerOptions, VerifiedAuthorizationServerToken } from "mcp-oauth-server";

package/dist/http.js

@@ -2,6 +2,45 @@ import "./node-require-shim.js";
 import { createHttpServer } from "tiny-http-mcp-server/server";
 import { createMCPServerForTransport } from "./mcp.js";
 import { enableSourceMaps } from "./stack-trim.js";
+function toVerifiedAccessToken(token, issuer, verified) {
+    return {
+        token,
+        issuer,
+        audience: [verified.resource],
+        scopes: [...verified.scopes],
+        expiresAt: verified.expiresAt,
+        claims: {
+            sub: verified.subject,
+            client_id: verified.clientId,
+            aud: verified.resource,
+            jti: verified.tokenId
+        },
+        subject: verified.subject,
+        clientId: verified.clientId
+    };
+}
+export function createHTTPMCPAuthorization(options) {
+    const issuer = options.authorizationServer.issuer;
+    const resource = new URL(options.resource).href;
+    return {
+        resource,
+        authorizationServers: [issuer],
+        requiredScopes: options.requiredScopes,
+        scopesSupported: options.scopesSupported ?? options.requiredScopes,
+        verifier: {
+            async verify(input) {
+                if (input.authorizationServers.length !== 1 || input.authorizationServers[0] !== issuer) {
+                    throw new Error("authorization server issuer does not match");
+                }
+                if (new URL(input.resource).href !== resource) {
+                    throw new Error("protected resource does not match");
+                }
+                const verified = await options.authorizationServer.verifyAccessToken(input.token, resource);
+                return toVerifiedAccessToken(input.token, issuer, verified);
+            }
+        }
+    };
+}
 function createTransportOptions(options, serverOptions) {
     return {
         ...serverOptions,
@@ -60,3 +99,4 @@ export async function runHTTPMCP(roots, options) {
     return server.listenHttp(createListenOptions(options));
 }
 export { createJwksTokenVerifier, TokenVerificationError } from "tiny-http-mcp-server/server";
+export { createAuthorizationInteractionSecurity, createInMemoryAuthorizationServerStore, createOAuthAuthorizationServer, verifyAuthorizationInteractionCsrf } from "mcp-oauth-server";

package/node_modules/mcp-oauth-server/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Poe Platform
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,192 @@
+# mcp-oauth-server
+
+Production OAuth 2.1 authorization-server primitives for MCP applications.
+
+The package provides:
+
+- authorization code with mandatory PKCE `S256`
+- RFC 8414 authorization-server metadata
+- RFC 7591 dynamic registration for public MCP clients
+- exact registered redirect URI validation
+- RFC 8707 resource indicators and audience-bound JWT access tokens
+- JWKS publication and short-lived `at+jwt` access tokens
+- rotating refresh tokens with replay-triggered family revocation
+- token and grant revocation
+- asynchronous durable storage interfaces
+- an application-owned browser authorization interaction
+- CSRF, state, nonce, and secure cookie helpers
+- a Toolcraft adapter through `createHTTPMCPAuthorization()` from `toolcraft/http`
+
+## Availability
+
+This package is bundled privately inside the published `toolcraft` package and
+is supported through the `toolcraft/http` exports. It is not published as a
+standalone npm package because that npm package name is owned outside this
+repository.
+
+## Quick Start
+
+```ts
+import { generateKeyPairSync } from "node:crypto";
+import { exportJWK } from "jose";
+import {
+  createHTTPMCPAuthorization,
+  createOAuthAuthorizationServer,
+  runHTTPMCP,
+  type AuthorizationInteraction,
+  type AuthorizationServerStore
+} from "toolcraft/http";
+
+const { privateKey, publicKey } = generateKeyPairSync("ec", {
+  namedCurve: "P-256"
+});
+
+const store: AuthorizationServerStore = createDurableStore();
+const interaction: AuthorizationInteraction = {
+  async start({ transaction }) {
+    return renderApplicationAuthorizationPage(transaction);
+  }
+};
+
+const authorizationServer = createOAuthAuthorizationServer({
+  issuer: "https://auth.example.com",
+  resources: ["https://mcp.example.com/mcp"],
+  signingKey: {
+    algorithm: "ES256",
+    keyId: "2026-07",
+    privateKey,
+    publicJwk: await exportJWK(publicKey)
+  },
+  store,
+  interaction
+});
+
+await runHTTPMCP(groups, {
+  oauth: createHTTPMCPAuthorization({
+    authorizationServer,
+    resource: "https://mcp.example.com/mcp",
+    requiredScopes: ["mcp.read"]
+  }),
+  requestServices(context) {
+    if (context.auth === undefined) throw new Error("OAuth subject required");
+    return {
+      babyDaybook: loadBabyDaybookSession(context.auth.subject)
+    };
+  }
+});
+```
+
+Route requests for `/.well-known/oauth-authorization-server`,
+`/.well-known/jwks.json`, `/register`, `/authorize`, `/token`, and `/revoke`
+to `authorizationServer.handle(request)` in the application HTTP framework.
+
+## Application Authorization Interaction
+
+`interaction.start({ request, transaction })` owns the browser experience. It
+may render a login page, redirect to an upstream identity provider, or render a
+one-time credential completion form. The application finishes the OAuth flow
+only after authenticating its user:
+
+```ts
+const completion = await authorizationServer.completeAuthorization({
+  transactionId,
+  subject: applicationUserId,
+  scopes: approvedScopes
+});
+
+return Response.redirect(completion.redirectUrl);
+```
+
+For an Apple `intent://callback?...` completion flow:
+
+1. Generate the application CSRF token, upstream state, and nonce with
+   `createAuthorizationInteractionSecurity()`.
+2. Bind the upstream state to the pending authorization transaction in the
+   application's durable store.
+3. Render the callback paste form with the hidden CSRF token and returned
+   `Set-Cookie` value.
+4. On submission, bound the request body, verify CSRF with
+   `verifyAuthorizationInteractionCsrf()`, validate the exact intent callback
+   shape and state, and consume the application transaction once.
+5. Exchange the one-time callback immediately. Never log or persist the
+   callback, password, authorization code, access token, or refresh token in
+   plaintext.
+6. Persist only the encrypted upstream refresh session under the approved OAuth
+   subject, then call `completeAuthorization()`.
+
+The application credential is deliberately absent from all package APIs so it
+cannot accidentally enter OAuth transaction or token storage.
+
+## Durable Storage
+
+Production deployments must implement `AuthorizationServerStore`. The
+interface covers:
+
+- dynamic clients
+- browser authorization transactions
+- authorization grants
+- one-time authorization codes
+- access-token revocation records
+- refresh-token families
+
+`takeAuthorizationTransaction()`, `takeAuthorizationCode()`, and
+`rotateRefreshToken()` must be atomic. Refresh replay detection depends on the
+store retaining rotated token-family relationships and revoking the family
+when an old token is presented again.
+
+`createInMemoryAuthorizationServerStore()` is intended for tests and local
+development only. It is not durable and must not be used in production.
+
+## Subject Isolation
+
+The access token `sub` claim is the only identity passed to Toolcraft as
+`context.auth.subject`. Application service lookup must require that subject
+and load only credentials stored under the same subject. Do not fall back to a
+shared environment credential when a subject session is missing.
+
+Grant and token revocation use opaque identifiers and token hashes. Raw
+authorization codes, access tokens, and refresh tokens are never stored by the
+provided store contract.
+
+## Security Requirements
+
+- Terminate TLS before exposing any endpoint publicly.
+- Keep signing private keys outside source control and rotate keys with an
+  overlap period long enough for issued access tokens to expire.
+- Use a durable store implementation with transactional or compare-and-swap
+  semantics for one-time consumption and refresh rotation.
+- Keep access-token lifetimes short. The default is five minutes.
+- Set restrictive CSP, `Referrer-Policy: no-referrer`, and `Cache-Control:
+  no-store` on application authorization pages.
+- Require exact redirect URI matches. Do not add wildcard or prefix matching.
+- Treat every OAuth subject as a separate security boundary.
+- Encrypt application-owned upstream refresh tokens at rest with a
+  production key-management service.
+- Redact authorization headers, cookies, codes, callbacks, and tokens from
+  logs and traces.
+
+## Configuration
+
+`createOAuthAuthorizationServer(options)` accepts:
+
+| Option | Required | Default | Description |
+| --- | --- | --- | --- |
+| `issuer` | yes | none | HTTPS authorization-server issuer. Loopback HTTP is allowed for local development. |
+| `resources` | yes | none | Exact protected resource identifiers accepted through the OAuth `resource` parameter. |
+| `signingKey` | yes | none | Current `ES256` or `RS256` private key, public JWK, and key id. |
+| `additionalPublicJwks` | no | `[]` | Previous public signing keys retained in JWKS during a key-rotation overlap. |
+| `store` | yes | none | Durable `AuthorizationServerStore` implementation. |
+| `interaction` | yes | none | Application-owned browser authorization hook. |
+| `accessTokenTtlSeconds` | no | `300` | Signed access-token lifetime. |
+| `authorizationCodeTtlSeconds` | no | `60` | One-time authorization-code lifetime. |
+| `authorizationTransactionTtlSeconds` | no | `600` | Pending browser interaction lifetime. |
+| `refreshTokenTtlSeconds` | no | `2592000` | Rotating refresh-token lifetime. |
+| `maxRequestBodyBytes` | no | `65536` | Maximum DCR, token, and revocation request body size. |
+| `now` | no | `Date.now` | Clock override for tests. |
+| `randomToken` | no | cryptographic random | Opaque identifier generator override for tests. |
+
+## Environment Variables
+
+This package reads no environment variables. Signing keys, durable database
+connections, encryption keys, issuer URLs, and protected resource identifiers
+must be passed explicitly by the application.

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

@@ -0,0 +1,157 @@
+import { type KeyObject } from "node:crypto";
+import { type JWK } from "jose";
+export interface OAuthClientRecord {
+    id: string;
+    redirectUris: readonly string[];
+    createdAt: number;
+}
+export interface AuthorizationTransactionRecord {
+    id: string;
+    clientId: string;
+    redirectUri: string;
+    codeChallenge: string;
+    resource: string;
+    scopes: readonly string[];
+    state?: string;
+    createdAt: number;
+    expiresAt: number;
+}
+export interface AuthorizationCodeRecord {
+    tokenHash: string;
+    grantId: string;
+    clientId: string;
+    subject: string;
+    redirectUri: string;
+    codeChallenge: string;
+    resource: string;
+    scopes: readonly string[];
+    expiresAt: number;
+}
+export interface AuthorizationGrantRecord {
+    id: string;
+    clientId: string;
+    subject: string;
+    resource: string;
+    scopes: readonly string[];
+    createdAt: number;
+    revokedAt?: number;
+}
+export interface RefreshTokenRecord {
+    tokenHash: string;
+    familyId: string;
+    grantId: string;
+    clientId: string;
+    subject: string;
+    resource: string;
+    scopes: readonly string[];
+    createdAt: number;
+    expiresAt: number;
+    status: "active" | "rotated" | "revoked";
+}
+export interface AccessTokenRecord {
+    tokenHash: string;
+    tokenId: string;
+    grantId: string;
+    subject: string;
+    clientId: string;
+    resource: string;
+    expiresAt: number;
+    revokedAt?: number;
+}
+export type RefreshTokenRotationResult = {
+    status: "rotated";
+    previous: RefreshTokenRecord;
+} | {
+    status: "replay";
+} | {
+    status: "invalid";
+};
+export interface AuthorizationServerStore {
+    putClient(client: OAuthClientRecord): Promise<void>;
+    getClient(clientId: string): Promise<OAuthClientRecord | undefined>;
+    putAuthorizationTransaction(transaction: AuthorizationTransactionRecord): Promise<void>;
+    takeAuthorizationTransaction(transactionId: string): Promise<AuthorizationTransactionRecord | undefined>;
+    putAuthorizationCode(code: AuthorizationCodeRecord): Promise<void>;
+    takeAuthorizationCode(tokenHash: string): Promise<AuthorizationCodeRecord | undefined>;
+    putGrant(grant: AuthorizationGrantRecord): Promise<void>;
+    getGrant(grantId: string): Promise<AuthorizationGrantRecord | undefined>;
+    putAccessToken(token: AccessTokenRecord): Promise<void>;
+    getAccessToken(tokenHash: string): Promise<AccessTokenRecord | undefined>;
+    putRefreshToken(token: RefreshTokenRecord): Promise<void>;
+    rotateRefreshToken(tokenHash: string, replacementTokenHash: string, now: number, expiresAt: number): Promise<RefreshTokenRotationResult>;
+    revokeToken(tokenHash: string, now: number): Promise<void>;
+    revokeGrant(grantId: string, now: number): Promise<void>;
+}
+export interface AuthorizationInteractionStartContext {
+    request: Request;
+    transaction: AuthorizationTransactionRecord;
+}
+export interface AuthorizationInteraction {
+    start(context: AuthorizationInteractionStartContext): Promise<Response> | Response;
+}
+export interface OAuthAuthorizationServerSigningKey {
+    algorithm: "ES256" | "RS256";
+    keyId: string;
+    privateKey: KeyObject;
+    publicJwk: JWK;
+}
+export interface OAuthAuthorizationServerOptions {
+    issuer: string;
+    resources: readonly string[];
+    signingKey: OAuthAuthorizationServerSigningKey;
+    additionalPublicJwks?: readonly JWK[];
+    store: AuthorizationServerStore;
+    interaction: AuthorizationInteraction;
+    accessTokenTtlSeconds?: number;
+    authorizationCodeTtlSeconds?: number;
+    authorizationTransactionTtlSeconds?: number;
+    refreshTokenTtlSeconds?: number;
+    maxRequestBodyBytes?: number;
+    now?: () => number;
+    randomToken?: () => string;
+}
+export interface CompleteAuthorizationInput {
+    transactionId: string;
+    subject: string;
+    scopes?: readonly string[];
+}
+export interface CompleteAuthorizationResult {
+    redirectUrl: URL;
+    grantId: string;
+}
+export interface AuthorizationInteractionSecurity {
+    csrfToken: string;
+    state: string;
+    nonce: string;
+    setCookie: string;
+}
+export interface AuthorizationInteractionSecurityOptions {
+    cookieName?: string;
+    maxAgeSeconds?: number;
+    randomToken?: () => string;
+}
+export interface VerifyAuthorizationInteractionCsrfInput {
+    cookieHeader: string | null;
+    submittedToken: string;
+    cookieName?: string;
+}
+export interface OAuthAuthorizationServer {
+    issuer: string;
+    handle(request: Request): Promise<Response>;
+    completeAuthorization(input: CompleteAuthorizationInput): Promise<CompleteAuthorizationResult>;
+    denyAuthorization(transactionId: string, error?: string): Promise<URL>;
+    revokeGrant(grantId: string): Promise<void>;
+    verifyAccessToken(token: string, resource: string): Promise<VerifiedAuthorizationServerToken>;
+}
+export interface VerifiedAuthorizationServerToken {
+    subject: string;
+    clientId: string;
+    resource: string;
+    scopes: readonly string[];
+    tokenId: string;
+    expiresAt: number;
+}
+export declare function createAuthorizationInteractionSecurity(options?: AuthorizationInteractionSecurityOptions): AuthorizationInteractionSecurity;
+export declare function verifyAuthorizationInteractionCsrf(input: VerifyAuthorizationInteractionCsrfInput): boolean;
+export declare function createInMemoryAuthorizationServerStore(): AuthorizationServerStore;
+export declare function createOAuthAuthorizationServer(options: OAuthAuthorizationServerOptions): OAuthAuthorizationServer;

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

@@ -0,0 +1,641 @@
+import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import { importJWK, jwtVerify, SignJWT } from "jose";
+class OAuthProtocolError extends Error {
+    error;
+    status;
+    constructor(error, message, status = 400) {
+        super(message);
+        this.error = error;
+        this.status = status;
+    }
+}
+function opaqueToken() {
+    return randomBytes(32).toString("base64url");
+}
+function hashToken(token) {
+    return createHash("sha256").update(token).digest("base64url");
+}
+export function createAuthorizationInteractionSecurity(options = {}) {
+    const randomToken = options.randomToken ?? opaqueToken;
+    const cookieName = options.cookieName ?? "__Host-mcp_oauth_csrf";
+    const maxAgeSeconds = options.maxAgeSeconds ?? 600;
+    if (!cookieName.startsWith("__Host-") || cookieName.includes(";") || cookieName.includes("=")) {
+        throw new Error("CSRF cookie name must use the __Host- prefix.");
+    }
+    if (!Number.isInteger(maxAgeSeconds) || maxAgeSeconds <= 0) {
+        throw new Error("CSRF cookie max age must be a positive integer.");
+    }
+    const csrfToken = randomToken();
+    return {
+        csrfToken,
+        state: randomToken(),
+        nonce: randomToken(),
+        setCookie: `${cookieName}=${csrfToken}; Path=/; Max-Age=${maxAgeSeconds}; HttpOnly; Secure; SameSite=Lax`
+    };
+}
+export function verifyAuthorizationInteractionCsrf(input) {
+    const cookieName = input.cookieName ?? "__Host-mcp_oauth_csrf";
+    const cookieValue = input.cookieHeader
+        ?.split(";")
+        .map((entry) => entry.trim())
+        .find((entry) => entry.startsWith(`${cookieName}=`))
+        ?.slice(cookieName.length + 1);
+    if (cookieValue === undefined)
+        return false;
+    const cookieBuffer = Buffer.from(cookieValue);
+    const submittedBuffer = Buffer.from(input.submittedToken);
+    return (cookieBuffer.length === submittedBuffer.length &&
+        timingSafeEqual(cookieBuffer, submittedBuffer));
+}
+function isObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function exactStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string")
+        ? value
+        : undefined;
+}
+function parseAbsoluteUrl(value, label) {
+    let url;
+    try {
+        url = new URL(value);
+    }
+    catch {
+        throw new OAuthProtocolError("invalid_request", `${label} must be an absolute URL.`);
+    }
+    if (url.hash.length > 0) {
+        throw new OAuthProtocolError("invalid_request", `${label} must not contain a fragment.`);
+    }
+    return url.href;
+}
+function validateIssuer(value) {
+    const issuer = new URL(parseAbsoluteUrl(value, "issuer"));
+    if (issuer.protocol !== "https:" && issuer.hostname !== "localhost" && issuer.hostname !== "127.0.0.1") {
+        throw new Error("issuer must use HTTPS unless it is loopback.");
+    }
+    if (issuer.pathname !== "/" || issuer.search.length > 0) {
+        throw new Error("issuer must be an origin URL without a path or query.");
+    }
+    return issuer.href.replace(/\/$/, "");
+}
+function validateResources(values) {
+    if (values.length === 0) {
+        throw new Error("At least one protected resource is required.");
+    }
+    return new Set(values.map((value) => parseAbsoluteUrl(value, "resource")));
+}
+function parseScopes(value) {
+    if (value === null || value.length === 0)
+        return [];
+    const scopes = value.split(" ");
+    if (scopes.some((scope) => scope.length === 0 || /[\u0000-\u0020\u007f]/u.test(scope))) {
+        throw new OAuthProtocolError("invalid_scope", "scope contains an invalid value.");
+    }
+    return [...new Set(scopes)];
+}
+function formResponse(payload, status = 200) {
+    return Response.json(payload, {
+        status,
+        headers: {
+            "cache-control": "no-store",
+            pragma: "no-cache"
+        }
+    });
+}
+function protocolErrorResponse(error) {
+    if (error instanceof OAuthProtocolError) {
+        return formResponse({ error: error.error, error_description: error.message }, error.status);
+    }
+    throw error;
+}
+function requireFormContentType(request) {
+    const contentType = request.headers.get("content-type")?.split(";", 1)[0]?.trim();
+    if (contentType !== "application/x-www-form-urlencoded") {
+        throw new OAuthProtocolError("invalid_request", "Expected form-encoded request body.");
+    }
+}
+function requireJsonContentType(request) {
+    const contentType = request.headers.get("content-type")?.split(";", 1)[0]?.trim();
+    if (contentType !== "application/json") {
+        throw new OAuthProtocolError("invalid_request", "Expected JSON request body.");
+    }
+}
+function pkceMatches(verifier, challenge) {
+    if (verifier.length < 43 || verifier.length > 128 || !/^[A-Za-z0-9._~-]+$/u.test(verifier)) {
+        return false;
+    }
+    const actual = createHash("sha256").update(verifier).digest();
+    const expected = Buffer.from(challenge, "base64url");
+    return actual.length === expected.length && timingSafeEqual(actual, expected);
+}
+function narrowedScopes(requested, approved) {
+    if (approved === undefined)
+        return [...requested];
+    const requestedSet = new Set(requested);
+    if (approved.some((scope) => !requestedSet.has(scope))) {
+        throw new Error("Approved scopes must be a subset of requested scopes.");
+    }
+    return [...new Set(approved)];
+}
+export function createInMemoryAuthorizationServerStore() {
+    const clients = new Map();
+    const transactions = new Map();
+    const codes = new Map();
+    const grants = new Map();
+    const accessTokens = new Map();
+    const refreshTokens = new Map();
+    function revokeFamily(familyId, now) {
+        for (const [tokenHash, token] of refreshTokens) {
+            if (token.familyId === familyId) {
+                refreshTokens.set(tokenHash, { ...token, status: "revoked" });
+            }
+        }
+        for (const [grantId, grant] of grants) {
+            if (grant.revokedAt === undefined &&
+                [...refreshTokens.values()].some((token) => token.familyId === familyId && token.grantId === grantId)) {
+                grants.set(grantId, { ...grant, revokedAt: now });
+            }
+        }
+    }
+    return {
+        async putClient(client) {
+            clients.set(client.id, structuredClone(client));
+        },
+        async getClient(clientId) {
+            const client = clients.get(clientId);
+            return client === undefined ? undefined : structuredClone(client);
+        },
+        async putAuthorizationTransaction(transaction) {
+            transactions.set(transaction.id, structuredClone(transaction));
+        },
+        async takeAuthorizationTransaction(transactionId) {
+            const transaction = transactions.get(transactionId);
+            transactions.delete(transactionId);
+            return transaction === undefined ? undefined : structuredClone(transaction);
+        },
+        async putAuthorizationCode(code) {
+            codes.set(code.tokenHash, structuredClone(code));
+        },
+        async takeAuthorizationCode(tokenHash) {
+            const code = codes.get(tokenHash);
+            codes.delete(tokenHash);
+            return code === undefined ? undefined : structuredClone(code);
+        },
+        async putGrant(grant) {
+            grants.set(grant.id, structuredClone(grant));
+        },
+        async getGrant(grantId) {
+            const grant = grants.get(grantId);
+            return grant === undefined ? undefined : structuredClone(grant);
+        },
+        async putAccessToken(token) {
+            accessTokens.set(token.tokenHash, structuredClone(token));
+        },
+        async getAccessToken(tokenHash) {
+            const token = accessTokens.get(tokenHash);
+            return token === undefined ? undefined : structuredClone(token);
+        },
+        async putRefreshToken(token) {
+            refreshTokens.set(token.tokenHash, structuredClone(token));
+        },
+        async rotateRefreshToken(tokenHash, replacementTokenHash, now, expiresAt) {
+            const token = refreshTokens.get(tokenHash);
+            if (token === undefined || token.expiresAt <= now || token.status === "revoked") {
+                return { status: "invalid" };
+            }
+            if (token.status === "rotated") {
+                revokeFamily(token.familyId, now);
+                return { status: "replay" };
+            }
+            refreshTokens.set(tokenHash, { ...token, status: "rotated" });
+            refreshTokens.set(replacementTokenHash, {
+                ...token,
+                tokenHash: replacementTokenHash,
+                createdAt: now,
+                expiresAt,
+                status: "active"
+            });
+            return { status: "rotated", previous: structuredClone(token) };
+        },
+        async revokeToken(tokenHash, now) {
+            const refreshToken = refreshTokens.get(tokenHash);
+            if (refreshToken !== undefined) {
+                revokeFamily(refreshToken.familyId, now);
+            }
+            const accessToken = accessTokens.get(tokenHash);
+            if (accessToken !== undefined) {
+                accessTokens.set(tokenHash, { ...accessToken, revokedAt: now });
+            }
+        },
+        async revokeGrant(grantId, now) {
+            const grant = grants.get(grantId);
+            if (grant !== undefined)
+                grants.set(grantId, { ...grant, revokedAt: now });
+            for (const [tokenHash, token] of refreshTokens) {
+                if (token.grantId === grantId) {
+                    refreshTokens.set(tokenHash, { ...token, status: "revoked" });
+                }
+            }
+            for (const [tokenHash, token] of accessTokens) {
+                if (token.grantId === grantId) {
+                    accessTokens.set(tokenHash, { ...token, revokedAt: now });
+                }
+            }
+        }
+    };
+}
+export function createOAuthAuthorizationServer(options) {
+    const issuer = validateIssuer(options.issuer);
+    const resources = validateResources(options.resources);
+    const now = options.now ?? Date.now;
+    const randomToken = options.randomToken ?? opaqueToken;
+    const accessTokenTtlMs = (options.accessTokenTtlSeconds ?? 300) * 1000;
+    const authorizationCodeTtlMs = (options.authorizationCodeTtlSeconds ?? 60) * 1000;
+    const authorizationTransactionTtlMs = (options.authorizationTransactionTtlSeconds ?? 600) * 1000;
+    const refreshTokenTtlMs = (options.refreshTokenTtlSeconds ?? 2_592_000) * 1000;
+    const maxRequestBodyBytes = options.maxRequestBodyBytes ?? 65_536;
+    if (!Number.isInteger(maxRequestBodyBytes) || maxRequestBodyBytes <= 0) {
+        throw new Error("maxRequestBodyBytes must be a positive integer.");
+    }
+    const publicJwk = {
+        ...options.signingKey.publicJwk,
+        kid: options.signingKey.keyId,
+        alg: options.signingKey.algorithm,
+        use: "sig"
+    };
+    const publishedJwks = [publicJwk, ...(options.additionalPublicJwks ?? [])];
+    const verificationKey = importJWK(publicJwk, options.signingKey.algorithm);
+    function endpoint(path) {
+        return `${issuer}${path}`;
+    }
+    function requireResource(value) {
+        if (value === null) {
+            throw new OAuthProtocolError("invalid_target", "resource is required.");
+        }
+        const normalized = parseAbsoluteUrl(value, "resource");
+        if (!resources.has(normalized)) {
+            throw new OAuthProtocolError("invalid_target", "resource is not supported.");
+        }
+        return normalized;
+    }
+    async function readRequestBody(request) {
+        const declaredLength = request.headers.get("content-length");
+        if (declaredLength !== null) {
+            const parsedLength = Number(declaredLength);
+            if (Number.isFinite(parsedLength) && parsedLength > maxRequestBodyBytes) {
+                throw new OAuthProtocolError("invalid_request", "Request body is too large.", 413);
+            }
+        }
+        const body = new Uint8Array(await request.arrayBuffer());
+        if (body.byteLength > maxRequestBodyBytes) {
+            throw new OAuthProtocolError("invalid_request", "Request body is too large.", 413);
+        }
+        return new TextDecoder().decode(body);
+    }
+    async function handleRegister(request) {
+        requireJsonContentType(request);
+        const body = await readRequestBody(request);
+        let payload;
+        try {
+            payload = JSON.parse(body);
+        }
+        catch {
+            throw new OAuthProtocolError("invalid_client_metadata", "Registration body must be JSON.");
+        }
+        if (!isObject(payload)) {
+            throw new OAuthProtocolError("invalid_client_metadata", "Registration body must be an object.");
+        }
+        const redirectUris = exactStringArray(payload.redirect_uris);
+        if (redirectUris === undefined || redirectUris.length === 0) {
+            throw new OAuthProtocolError("invalid_redirect_uri", "redirect_uris is required.");
+        }
+        const normalizedRedirectUris = redirectUris.map((value) => parseAbsoluteUrl(value, "redirect_uri"));
+        if (payload.token_endpoint_auth_method !== undefined &&
+            payload.token_endpoint_auth_method !== "none") {
+            throw new OAuthProtocolError("invalid_client_metadata", "Only public clients using token_endpoint_auth_method none are supported.");
+        }
+        const grantTypes = exactStringArray(payload.grant_types) ?? ["authorization_code"];
+        if (grantTypes.some((value) => value !== "authorization_code" && value !== "refresh_token")) {
+            throw new OAuthProtocolError("invalid_client_metadata", "Unsupported grant type.");
+        }
+        const responseTypes = exactStringArray(payload.response_types) ?? ["code"];
+        if (responseTypes.length !== 1 || responseTypes[0] !== "code") {
+            throw new OAuthProtocolError("invalid_client_metadata", "Only response_type code is supported.");
+        }
+        const client = {
+            id: randomToken(),
+            redirectUris: [...new Set(normalizedRedirectUris)],
+            createdAt: now()
+        };
+        await options.store.putClient(client);
+        return formResponse({
+            client_id: client.id,
+            client_id_issued_at: Math.floor(client.createdAt / 1000),
+            redirect_uris: client.redirectUris,
+            token_endpoint_auth_method: "none",
+            grant_types: grantTypes,
+            response_types: ["code"]
+        }, 201);
+    }
+    async function handleAuthorize(request) {
+        const url = new URL(request.url);
+        if (url.searchParams.get("response_type") !== "code") {
+            throw new OAuthProtocolError("unsupported_response_type", "response_type must be code.");
+        }
+        const clientId = url.searchParams.get("client_id");
+        if (clientId === null)
+            throw new OAuthProtocolError("invalid_request", "client_id is required.");
+        const client = await options.store.getClient(clientId);
+        if (client === undefined)
+            throw new OAuthProtocolError("unauthorized_client", "Unknown client.");
+        const redirectUriValue = url.searchParams.get("redirect_uri");
+        if (redirectUriValue === null) {
+            throw new OAuthProtocolError("invalid_request", "redirect_uri is required.");
+        }
+        const redirectUri = parseAbsoluteUrl(redirectUriValue, "redirect_uri");
+        if (!client.redirectUris.includes(redirectUri)) {
+            throw new OAuthProtocolError("invalid_request", "redirect_uri is not registered.");
+        }
+        const codeChallenge = url.searchParams.get("code_challenge");
+        if (codeChallenge === null || !/^[A-Za-z0-9_-]{43}$/u.test(codeChallenge)) {
+            throw new OAuthProtocolError("invalid_request", "A valid code_challenge is required.");
+        }
+        if (url.searchParams.get("code_challenge_method") !== "S256") {
+            throw new OAuthProtocolError("invalid_request", "code_challenge_method must be S256.");
+        }
+        const transaction = {
+            id: randomToken(),
+            clientId,
+            redirectUri,
+            codeChallenge,
+            resource: requireResource(url.searchParams.get("resource")),
+            scopes: parseScopes(url.searchParams.get("scope")),
+            ...(url.searchParams.has("state") && { state: url.searchParams.get("state") ?? undefined }),
+            createdAt: now(),
+            expiresAt: now() + authorizationTransactionTtlMs
+        };
+        await options.store.putAuthorizationTransaction(transaction);
+        return options.interaction.start({ request, transaction });
+    }
+    async function completeAuthorization(input) {
+        if (input.subject.length === 0)
+            throw new Error("subject is required.");
+        const transaction = await options.store.takeAuthorizationTransaction(input.transactionId);
+        const currentTime = now();
+        if (transaction === undefined || transaction.expiresAt <= currentTime) {
+            throw new Error("Authorization transaction is missing, expired, or already completed.");
+        }
+        const scopes = narrowedScopes(transaction.scopes, input.scopes);
+        const grantId = randomToken();
+        await options.store.putGrant({
+            id: grantId,
+            clientId: transaction.clientId,
+            subject: input.subject,
+            resource: transaction.resource,
+            scopes,
+            createdAt: currentTime
+        });
+        const code = randomToken();
+        await options.store.putAuthorizationCode({
+            tokenHash: hashToken(code),
+            grantId,
+            clientId: transaction.clientId,
+            subject: input.subject,
+            redirectUri: transaction.redirectUri,
+            codeChallenge: transaction.codeChallenge,
+            resource: transaction.resource,
+            scopes,
+            expiresAt: currentTime + authorizationCodeTtlMs
+        });
+        const redirectUrl = new URL(transaction.redirectUri);
+        redirectUrl.searchParams.set("code", code);
+        if (transaction.state !== undefined)
+            redirectUrl.searchParams.set("state", transaction.state);
+        redirectUrl.searchParams.set("iss", issuer);
+        return { redirectUrl, grantId };
+    }
+    async function denyAuthorization(transactionId, error = "access_denied") {
+        const transaction = await options.store.takeAuthorizationTransaction(transactionId);
+        if (transaction === undefined) {
+            throw new Error("Authorization transaction is missing or already completed.");
+        }
+        const redirectUrl = new URL(transaction.redirectUri);
+        redirectUrl.searchParams.set("error", error);
+        if (transaction.state !== undefined)
+            redirectUrl.searchParams.set("state", transaction.state);
+        redirectUrl.searchParams.set("iss", issuer);
+        return redirectUrl;
+    }
+    async function issueToken(input) {
+        const currentTime = now();
+        const expiresAt = currentTime + accessTokenTtlMs;
+        const tokenId = randomToken();
+        const accessToken = await new SignJWT({
+            scope: input.grant.scopes.join(" "),
+            client_id: input.grant.clientId
+        })
+            .setProtectedHeader({
+            alg: options.signingKey.algorithm,
+            kid: options.signingKey.keyId,
+            typ: "at+jwt"
+        })
+            .setIssuer(issuer)
+            .setSubject(input.grant.subject)
+            .setAudience(input.grant.resource)
+            .setJti(tokenId)
+            .setIssuedAt(Math.floor(currentTime / 1000))
+            .setExpirationTime(Math.floor(expiresAt / 1000))
+            .sign(options.signingKey.privateKey);
+        await options.store.putAccessToken({
+            tokenHash: hashToken(accessToken),
+            tokenId,
+            grantId: input.grant.id,
+            subject: input.grant.subject,
+            clientId: input.grant.clientId,
+            resource: input.grant.resource,
+            expiresAt
+        });
+        const response = {
+            access_token: accessToken,
+            token_type: "Bearer",
+            expires_in: Math.floor(accessTokenTtlMs / 1000),
+            scope: input.grant.scopes.join(" ")
+        };
+        if (input.includeRefreshToken) {
+            const refreshToken = randomToken();
+            await options.store.putRefreshToken({
+                tokenHash: hashToken(refreshToken),
+                familyId: input.familyId ?? randomToken(),
+                grantId: input.grant.id,
+                clientId: input.grant.clientId,
+                subject: input.grant.subject,
+                resource: input.grant.resource,
+                scopes: input.grant.scopes,
+                createdAt: currentTime,
+                expiresAt: currentTime + refreshTokenTtlMs,
+                status: "active"
+            });
+            response.refresh_token = refreshToken;
+        }
+        return response;
+    }
+    async function exchangeAuthorizationCode(body) {
+        const codeValue = body.get("code");
+        if (codeValue === null)
+            throw new OAuthProtocolError("invalid_request", "code is required.");
+        const code = await options.store.takeAuthorizationCode(hashToken(codeValue));
+        const currentTime = now();
+        if (code === undefined || code.expiresAt <= currentTime) {
+            throw new OAuthProtocolError("invalid_grant", "Authorization code is invalid.");
+        }
+        if (body.get("client_id") !== code.clientId ||
+            body.get("redirect_uri") !== code.redirectUri ||
+            requireResource(body.get("resource")) !== code.resource ||
+            !pkceMatches(body.get("code_verifier") ?? "", code.codeChallenge)) {
+            throw new OAuthProtocolError("invalid_grant", "Authorization code binding is invalid.");
+        }
+        const grant = await options.store.getGrant(code.grantId);
+        if (grant === undefined || grant.revokedAt !== undefined) {
+            throw new OAuthProtocolError("invalid_grant", "Authorization grant is invalid.");
+        }
+        return formResponse(await issueToken({
+            grant,
+            includeRefreshToken: grant.scopes.includes("offline_access")
+        }));
+    }
+    async function rotateRefreshToken(body) {
+        const refreshToken = body.get("refresh_token");
+        if (refreshToken === null) {
+            throw new OAuthProtocolError("invalid_request", "refresh_token is required.");
+        }
+        const replacementValue = randomToken();
+        const currentTime = now();
+        const replacementTokenHash = hashToken(replacementValue);
+        const requestedResource = requireResource(body.get("resource"));
+        const tokenHash = hashToken(refreshToken);
+        const existing = await options.store.rotateRefreshToken(tokenHash, replacementTokenHash, currentTime, currentTime + refreshTokenTtlMs);
+        if (existing.status !== "rotated") {
+            throw new OAuthProtocolError("invalid_grant", "Refresh token is invalid or replayed.");
+        }
+        if (existing.previous.clientId !== body.get("client_id") ||
+            existing.previous.resource !== requestedResource) {
+            await options.store.revokeGrant(existing.previous.grantId, currentTime);
+            throw new OAuthProtocolError("invalid_grant", "Refresh token binding is invalid.");
+        }
+        const grant = await options.store.getGrant(existing.previous.grantId);
+        if (grant === undefined || grant.revokedAt !== undefined) {
+            throw new OAuthProtocolError("invalid_grant", "Authorization grant is invalid.");
+        }
+        const response = await issueToken({ grant, includeRefreshToken: false });
+        response.refresh_token = replacementValue;
+        return formResponse(response);
+    }
+    async function handleToken(request) {
+        requireFormContentType(request);
+        const body = new URLSearchParams(await readRequestBody(request));
+        const grantType = body.get("grant_type");
+        if (grantType === "authorization_code")
+            return exchangeAuthorizationCode(body);
+        if (grantType === "refresh_token")
+            return rotateRefreshToken(body);
+        throw new OAuthProtocolError("unsupported_grant_type", "Unsupported grant_type.");
+    }
+    async function handleRevoke(request) {
+        requireFormContentType(request);
+        const body = new URLSearchParams(await readRequestBody(request));
+        const token = body.get("token");
+        if (token !== null)
+            await options.store.revokeToken(hashToken(token), now());
+        return new Response(null, { status: 200, headers: { "cache-control": "no-store" } });
+    }
+    async function handle(request) {
+        try {
+            const url = new URL(request.url);
+            if (request.method === "GET" && url.pathname === "/.well-known/oauth-authorization-server") {
+                return formResponse({
+                    issuer,
+                    authorization_endpoint: endpoint("/authorize"),
+                    token_endpoint: endpoint("/token"),
+                    registration_endpoint: endpoint("/register"),
+                    revocation_endpoint: endpoint("/revoke"),
+                    jwks_uri: endpoint("/.well-known/jwks.json"),
+                    response_types_supported: ["code"],
+                    grant_types_supported: ["authorization_code", "refresh_token"],
+                    token_endpoint_auth_methods_supported: ["none"],
+                    code_challenge_methods_supported: ["S256"],
+                    protected_resources: [...resources]
+                });
+            }
+            if (request.method === "GET" && url.pathname === "/.well-known/jwks.json") {
+                return formResponse({ keys: publishedJwks });
+            }
+            if (request.method === "POST" && url.pathname === "/register") {
+                return await handleRegister(request);
+            }
+            if (request.method === "GET" && url.pathname === "/authorize") {
+                return await handleAuthorize(request);
+            }
+            if (request.method === "POST" && url.pathname === "/token") {
+                return await handleToken(request);
+            }
+            if (request.method === "POST" && url.pathname === "/revoke") {
+                return await handleRevoke(request);
+            }
+            return formResponse({ error: "not_found" }, 404);
+        }
+        catch (error) {
+            return protocolErrorResponse(error);
+        }
+    }
+    async function verifyAccessToken(token, resource) {
+        const normalizedResource = parseAbsoluteUrl(resource, "resource");
+        if (!resources.has(normalizedResource)) {
+            throw new Error("Access token resource is not supported.");
+        }
+        const storedToken = await options.store.getAccessToken(hashToken(token));
+        const currentTime = now();
+        if (storedToken === undefined ||
+            storedToken.revokedAt !== undefined ||
+            storedToken.expiresAt <= currentTime) {
+            throw new Error("Access token is revoked, expired, or unknown.");
+        }
+        const verified = await jwtVerify(token, await verificationKey, {
+            issuer,
+            audience: normalizedResource,
+            algorithms: [options.signingKey.algorithm],
+            typ: "at+jwt"
+        });
+        const subject = verified.payload.sub;
+        const clientId = verified.payload.client_id;
+        const tokenId = verified.payload.jti;
+        const scope = verified.payload.scope;
+        if (typeof subject !== "string" ||
+            typeof clientId !== "string" ||
+            typeof tokenId !== "string" ||
+            typeof scope !== "string" ||
+            subject !== storedToken.subject ||
+            clientId !== storedToken.clientId ||
+            tokenId !== storedToken.tokenId ||
+            normalizedResource !== storedToken.resource) {
+            throw new Error("Access token claims do not match the authorization record.");
+        }
+        return {
+            subject,
+            clientId,
+            resource: normalizedResource,
+            scopes: parseScopes(scope),
+            tokenId,
+            expiresAt: Math.floor(storedToken.expiresAt / 1000)
+        };
+    }
+    return {
+        issuer,
+        handle,
+        completeAuthorization,
+        denyAuthorization,
+        verifyAccessToken,
+        async revokeGrant(grantId) {
+            await options.store.revokeGrant(grantId, now());
+        }
+    };
+}

package/node_modules/mcp-oauth-server/package.json

@@ -0,0 +1,34 @@
+{
+  "private": true,
+  "description": "Production OAuth authorization server primitives for MCP applications",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "node ../../scripts/guard-package-dist.mjs && tsc",
+    "test": "cd ../.. && vitest run packages/mcp-oauth-server/src",
+    "test:unit": "cd ../.. && vitest run packages/mcp-oauth-server/src"
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/poe-platform/poe-code.git",
+    "directory": "packages/mcp-oauth-server"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "mcp-oauth": "*"
+  }
+}

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

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

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

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

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

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

package/node_modules/toolcraft-schema/package.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft",
-  "version": "0.0.124",
+  "version": "0.0.126",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -100,8 +100,8 @@
     "test": "cd ../.. && vitest run packages/toolcraft/src",
     "test:unit": "cd ../.. && vitest run packages/toolcraft/src",
     "lint": "cd ../.. && eslint packages/toolcraft/src --ext ts && tsc -p packages/toolcraft/tsconfig.json --noEmit",
-    "prepack": "node ../../scripts/manage-bundled-workspace-deps.mjs prepare . toolcraft-schema toolcraft-design @poe-code/frontmatter @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner tiny-http-mcp-server tiny-mcp-client tiny-stdio-mcp-server auth-store jose fast-string-width fast-wrap-ansi ignore jsonc-parser sisteransi smol-toml yaml",
-    "postpack": "node ../../scripts/manage-bundled-workspace-deps.mjs cleanup . toolcraft-schema toolcraft-design @poe-code/frontmatter @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner tiny-http-mcp-server tiny-mcp-client tiny-stdio-mcp-server auth-store jose fast-string-width fast-wrap-ansi ignore jsonc-parser sisteransi smol-toml yaml"
+    "prepack": "node ../../scripts/manage-bundled-workspace-deps.mjs prepare . toolcraft-schema toolcraft-design @poe-code/frontmatter @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner mcp-oauth-server tiny-http-mcp-server tiny-mcp-client tiny-stdio-mcp-server auth-store jose fast-string-width fast-wrap-ansi ignore jsonc-parser sisteransi smol-toml yaml",
+    "postpack": "node ../../scripts/manage-bundled-workspace-deps.mjs cleanup . toolcraft-schema toolcraft-design @poe-code/frontmatter @poe-code/agent-mcp-config @poe-code/agent-human-in-loop @poe-code/task-list @poe-code/agent-defs @poe-code/config-mutations @poe-code/process-runner mcp-oauth-server tiny-http-mcp-server tiny-mcp-client tiny-stdio-mcp-server auth-store jose fast-string-width fast-wrap-ansi ignore jsonc-parser sisteransi smol-toml yaml"
   },
   "dependencies": {
     "commander": "^13.1.0",
@@ -138,6 +138,7 @@
     "@poe-code/agent-defs",
     "@poe-code/config-mutations",
     "@poe-code/process-runner",
+    "mcp-oauth-server",
     "tiny-http-mcp-server",
     "tiny-mcp-client",
     "tiny-stdio-mcp-server",
@@ -152,7 +153,7 @@
     "yaml"
   ],
   "optionalDependencies": {
-    "toolcraft-schema": "0.0.124",
+    "toolcraft-schema": "0.0.126",
     "toolcraft-design": "*",
     "@poe-code/frontmatter": "*",
     "@poe-code/agent-mcp-config": "*",
@@ -161,6 +162,7 @@
     "@poe-code/agent-defs": "*",
     "@poe-code/config-mutations": "*",
     "@poe-code/process-runner": "*",
+    "mcp-oauth-server": "*",
     "tiny-http-mcp-server": "*",
     "tiny-mcp-client": "*",
     "tiny-stdio-mcp-server": "*",