toolcraft 0.0.119 → 0.0.121

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

@@ -0,0 +1,13 @@
+export { createServer, defineSchema, Image, Audio, File, toContentBlocks, fileTypeFromBuffer, JSON_RPC_ERROR_CODES, ToolError } from "tiny-stdio-mcp-server";
+export type { Server, TypedSchema, ImageContent, AudioContent, EmbeddedResource, TextResourceContents, BlobResourceContents, ContentBlock, TextContent, FileTypeResult, ToolReturn, ServerOptions, ToolHandler, ToolDefinition, Tool, ToolAnnotations, ToolExecution, Icon, ContentAnnotations, ResourceLink, CallToolResult, PromptContentItem, PromptArgument, Prompt, PromptMessage, GetPromptResult, PromptHandler, PromptDefinition, Resource, ResourceTemplate, ResourceContents, ReadResourceResult, ResourceHandler, ResourceDefinition, ResourceTemplateDefinition, HandleResult, ContentItem, JSONSchema, JSONSchemaProperty, Transport, SDKTransport, JSONRPCRequest, JSONRPCResponse, JSONRPCError, JSONRPCMessage, JSONRPCNotification, InitializeResult } from "tiny-stdio-mcp-server";
+export { createExpressMiddleware, createExpressOAuthHandlers, createProtectedResourceMetadataRouter } from "./express-middleware.js";
+export type { CreateExpressOAuthHandlersOptions } from "./express-middleware.js";
+export { createHttpServer, createProtectedResourceMetadataDocument } from "./http-server.js";
+export type { HttpToolContext, HttpToolHandler, HttpListenOptions, HttpServer, HttpServerHandle, HttpTransportOptions, ProtectedResourceMetadataOptions, TinyHttpMcpServerOAuthOptions } from "./http-server.js";
+export { TokenVerificationError } from "./auth.js";
+export type { RequestAuthInfo, TokenVerifier, VerifiedAccessToken } from "./auth.js";
+export { StreamableHttpTransport } from "./http-transport.js";
+export type { HttpObservabilityEvent, HttpObservabilityOptions, StreamableHttpTransportOptions } from "./http-transport.js";
+export type { Session, SessionStore } from "./session.js";
+export { createJwksTokenVerifier } from "mcp-oauth";
+export type { JwksTokenVerifier, JwksTokenVerifierOptions, JwksVerifiedAccessToken } from "mcp-oauth";

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

@@ -0,0 +1,6 @@
+export { createServer, defineSchema, Image, Audio, File, toContentBlocks, fileTypeFromBuffer, JSON_RPC_ERROR_CODES, ToolError } from "tiny-stdio-mcp-server";
+export { createExpressMiddleware, createExpressOAuthHandlers, createProtectedResourceMetadataRouter } from "./express-middleware.js";
+export { createHttpServer, createProtectedResourceMetadataDocument } from "./http-server.js";
+export { TokenVerificationError } from "./auth.js";
+export { StreamableHttpTransport } from "./http-transport.js";
+export { createJwksTokenVerifier } from "mcp-oauth";

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

@@ -0,0 +1,6 @@
+import type { TokenVerifier } from "./auth.js";
+export declare function loadOAuthVerifier(input: {
+    modulePath: string;
+    exportName?: string;
+    cwd?: string;
+}): Promise<TokenVerifier>;

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

@@ -0,0 +1,43 @@
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+function isWindowsAbsolutePath(value) {
+    if (value.length < 3) {
+        return false;
+    }
+    const drive = value.charCodeAt(0);
+    const separator = value[2];
+    const isLetter = (drive >= 65 && drive <= 90) || (drive >= 97 && drive <= 122);
+    return isLetter && value[1] === ":" && (separator === "\\" || separator === "/");
+}
+function resolveModuleSpecifier(modulePath, cwd) {
+    if (modulePath.startsWith("file:")) {
+        return modulePath;
+    }
+    if (modulePath.startsWith(".")
+        || modulePath.startsWith("/")
+        || isWindowsAbsolutePath(modulePath)) {
+        const resolvedPath = path.isAbsolute(modulePath)
+            ? modulePath
+            : path.resolve(cwd, modulePath);
+        return pathToFileURL(resolvedPath).href;
+    }
+    return modulePath;
+}
+function isTokenVerifier(value) {
+    if (typeof value !== "object"
+        || value === null
+        || !Object.prototype.hasOwnProperty.call(value, "verify")) {
+        return false;
+    }
+    return typeof value.verify === "function";
+}
+export async function loadOAuthVerifier(input) {
+    const exportName = input.exportName ?? "default";
+    const moduleSpecifier = resolveModuleSpecifier(input.modulePath, input.cwd ?? process.cwd());
+    const loadedModule = (await import(moduleSpecifier));
+    const verifier = loadedModule[exportName];
+    if (!isTokenVerifier(verifier)) {
+        throw new Error(`OAuth verifier export "${exportName}" from "${input.modulePath}" must be an object with a verify() method.`);
+    }
+    return verifier;
+}

package/node_modules/tiny-http-mcp-server/dist/parse-body.d.ts

@@ -0,0 +1,22 @@
+import type { IncomingMessage } from "node:http";
+import type { JSONRPCMessage, JSONRPCNotification, JSONRPCRequest, JSONRPCResponse } from "tiny-stdio-mcp-server";
+export interface ClassifiedBody {
+    entries: Array<JSONRPCMessage | null>;
+    messages: JSONRPCMessage[];
+    hasRequests: boolean;
+    hasNotifications: boolean;
+    hasResponses: boolean;
+    requests: JSONRPCRequest[];
+    notifications: JSONRPCNotification[];
+    responses: JSONRPCResponse[];
+}
+export interface BodyReadOptions {
+    maxBytes?: number;
+    maxBatchSize?: number;
+}
+export declare class JsonRpcMessageError extends Error {
+    readonly id: string | number | null;
+    readonly code: number;
+    constructor(id: string | number | null, code: number, message: string);
+}
+export declare function readAndClassifyBody(req: IncomingMessage, preParsed?: unknown, options?: BodyReadOptions): Promise<ClassifiedBody>;

package/node_modules/tiny-http-mcp-server/dist/parse-body.js

@@ -0,0 +1,150 @@
+import { parseMessage } from "tiny-stdio-mcp-server/jsonrpc";
+export class JsonRpcMessageError extends Error {
+    id;
+    code;
+    constructor(id, code, message) {
+        super(message);
+        this.id = id;
+        this.code = code;
+    }
+}
+function isObjectRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn(value, property) {
+    return Object.prototype.hasOwnProperty.call(value, property);
+}
+function isValidResponse(value) {
+    if (!isObjectRecord(value) || value.jsonrpc !== "2.0" || hasOwn(value, "method")) {
+        return false;
+    }
+    if (!hasOwn(value, "id")) {
+        return false;
+    }
+    if (value.id !== null &&
+        typeof value.id !== "string" &&
+        typeof value.id !== "number") {
+        return false;
+    }
+    const hasResult = hasOwn(value, "result");
+    const hasError = hasOwn(value, "error");
+    if (hasResult === hasError) {
+        return false;
+    }
+    if (!hasError) {
+        return true;
+    }
+    return (isObjectRecord(value.error) &&
+        typeof value.error.code === "number" &&
+        typeof value.error.message === "string");
+}
+function hasResponseFields(value) {
+    return isObjectRecord(value) && (hasOwn(value, "result") || hasOwn(value, "error"));
+}
+async function readStreamBody(req, maxBytes) {
+    const chunks = [];
+    let totalBytes = 0;
+    for await (const chunk of req) {
+        let bytes;
+        if (typeof chunk === "string") {
+            bytes = Buffer.from(chunk);
+        }
+        else if (chunk instanceof Uint8Array) {
+            bytes = chunk;
+        }
+        else {
+            bytes = Buffer.from(String(chunk));
+        }
+        totalBytes += bytes.byteLength;
+        if (maxBytes !== undefined && totalBytes > maxBytes) {
+            throw new Error("Payload too large");
+        }
+        chunks.push(bytes);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+async function readRawBody(req, preParsed, options) {
+    if (preParsed !== undefined) {
+        return preParsed;
+    }
+    const reqWithBody = req;
+    if (reqWithBody.body !== undefined) {
+        return reqWithBody.body;
+    }
+    const raw = await readStreamBody(req, options.maxBytes);
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error("Parse error");
+    }
+}
+function toMessageList(body, maxBatchSize) {
+    if (Array.isArray(body)) {
+        if (body.length === 0) {
+            throw new Error("Invalid Request");
+        }
+        if (maxBatchSize !== undefined && body.length > maxBatchSize) {
+            throw new Error("Batch size exceeds configured limit");
+        }
+        return body;
+    }
+    if (isObjectRecord(body)) {
+        return [body];
+    }
+    throw new Error("Invalid Request");
+}
+export async function readAndClassifyBody(req, preParsed, options = {}) {
+    const body = await readRawBody(req, preParsed, options);
+    const inputMessages = toMessageList(body, options.maxBatchSize);
+    const isBatch = Array.isArray(body);
+    const entries = [];
+    const requests = [];
+    const notifications = [];
+    const responses = [];
+    const messages = [];
+    for (const message of inputMessages) {
+        if (isValidResponse(message)) {
+            responses.push(message);
+            messages.push(message);
+            entries.push(message);
+            continue;
+        }
+        if (hasResponseFields(message)) {
+            if (!isBatch) {
+                throw new Error("Invalid Request");
+            }
+            entries.push(null);
+            continue;
+        }
+        const parsed = parseMessage(JSON.stringify(message));
+        if (!parsed.success) {
+            if (!isBatch) {
+                throw new JsonRpcMessageError(parsed.id, parsed.error.code, parsed.error.message);
+            }
+            entries.push(null);
+            continue;
+        }
+        if (parsed.isNotification) {
+            const notification = parsed.request;
+            notifications.push(notification);
+            messages.push(notification);
+            entries.push(notification);
+            continue;
+        }
+        const request = parsed.request;
+        requests.push(request);
+        messages.push(request);
+        entries.push(request);
+    }
+    return {
+        entries,
+        messages,
+        hasRequests: requests.length > 0,
+        hasNotifications: notifications.length > 0,
+        hasResponses: responses.length > 0,
+        requests,
+        notifications,
+        responses,
+    };
+}

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

@@ -0,0 +1,9 @@
+export { createHttpServer, createProtectedResourceMetadataDocument } from "./http-server.js";
+export type { HttpToolContext, HttpToolHandler, HttpListenOptions, HttpServer, HttpServerHandle, HttpTransportOptions, ProtectedResourceMetadataOptions, TinyHttpMcpServerOAuthOptions } from "./http-server.js";
+export { TokenVerificationError } from "./auth.js";
+export type { RequestAuthInfo, TokenVerifier, VerifiedAccessToken } from "./auth.js";
+export { StreamableHttpTransport } from "./http-transport.js";
+export type { HttpObservabilityEvent, HttpObservabilityOptions, StreamableHttpTransportOptions } from "./http-transport.js";
+export type { Session, SessionStore } from "./session.js";
+export { createJwksTokenVerifier } from "mcp-oauth";
+export type { JwksTokenVerifier, JwksTokenVerifierOptions, JwksVerifiedAccessToken } from "mcp-oauth";

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

@@ -0,0 +1,4 @@
+export { createHttpServer, createProtectedResourceMetadataDocument } from "./http-server.js";
+export { TokenVerificationError } from "./auth.js";
+export { StreamableHttpTransport } from "./http-transport.js";
+export { createJwksTokenVerifier } from "mcp-oauth";

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

@@ -0,0 +1,18 @@
+export interface Session {
+    id: string;
+    initialized: boolean;
+    authSubject?: string;
+    protocolVersion?: string;
+    createdAt: Date;
+    lastSeenAt: Date;
+}
+export interface SessionStore {
+    create(id: string): Session;
+    get(id: string): Session | undefined;
+    delete(id: string): boolean;
+    has(id: string): boolean;
+    touch?(id: string): void;
+    entries?(): Iterable<Session>;
+}
+export declare function defaultSessionIdGenerator(): string;
+export declare function createSessionStore(): SessionStore;

package/node_modules/tiny-http-mcp-server/dist/session.js

@@ -0,0 +1,37 @@
+import { randomUUID } from "node:crypto";
+export function defaultSessionIdGenerator() {
+    return randomUUID();
+}
+export function createSessionStore() {
+    const sessions = new Map();
+    return {
+        create(id) {
+            const session = {
+                id,
+                initialized: false,
+                createdAt: new Date(),
+                lastSeenAt: new Date(),
+            };
+            sessions.set(id, session);
+            return session;
+        },
+        get(id) {
+            return sessions.get(id);
+        },
+        delete(id) {
+            return sessions.delete(id);
+        },
+        has(id) {
+            return sessions.has(id);
+        },
+        touch(id) {
+            const session = sessions.get(id);
+            if (session !== undefined) {
+                session.lastSeenAt = new Date();
+            }
+        },
+        entries() {
+            return sessions.values();
+        },
+    };
+}

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

@@ -0,0 +1,11 @@
+export interface SseEvent {
+    data: string;
+    id?: string;
+    event?: string;
+}
+export declare const SSE_HEADERS: {
+    readonly "Content-Type": "text/event-stream";
+    readonly "Cache-Control": "no-cache";
+    readonly Connection: "keep-alive";
+};
+export declare function formatSseEvent(event: SseEvent): string;

package/node_modules/tiny-http-mcp-server/dist/sse.js

@@ -0,0 +1,22 @@
+export const SSE_HEADERS = {
+    "Content-Type": "text/event-stream",
+    "Cache-Control": "no-cache",
+    Connection: "keep-alive",
+};
+export function formatSseEvent(event) {
+    const lines = [];
+    if (event.id !== undefined) {
+        lines.push(`id: ${event.id}`);
+    }
+    if (event.event !== undefined) {
+        lines.push(`event: ${event.event}`);
+    }
+    const dataLines = event.data
+        .replaceAll("\r\n", "\n")
+        .replaceAll("\r", "\n")
+        .split("\n");
+    for (const dataLine of dataLines) {
+        lines.push(`data: ${dataLine}`);
+    }
+    return `${lines.join("\n")}\n\n`;
+}

package/node_modules/tiny-http-mcp-server/dist/test-support.d.ts

@@ -0,0 +1,10 @@
+import { type HttpServer } from "./http-server.js";
+export declare function installInMemoryHttp(): void;
+export declare function nodeFetch(input: string | URL, init?: RequestInit): Promise<Response>;
+export declare function createTestMcpServer(options?: Partial<{
+    name: string;
+    version: string;
+    enableJsonResponse: boolean;
+    sessionIdGenerator: (() => string) | undefined;
+    oauth: import("./http-server.js").TinyHttpMcpServerOAuthOptions;
+}>): HttpServer;