toolcraft 0.0.103 → 0.0.105

package/node_modules/tiny-stdio-mcp-server/dist/content/file.js

@@ -0,0 +1,110 @@
+import { assertBase64, fileTypeFromBuffer, parseContentType, safeRemoteLabel } from "./mime.js";
+import { readRemoteBytes } from "./remote.js";
+function isTextMimeType(mimeType) {
+    const normalizedMimeType = mimeType.toLowerCase();
+    return (normalizedMimeType.startsWith("text/") ||
+        normalizedMimeType === "application/json" ||
+        normalizedMimeType.endsWith("+json") ||
+        normalizedMimeType === "application/xml" ||
+        normalizedMimeType.endsWith("+xml") ||
+        normalizedMimeType === "application/javascript" ||
+        normalizedMimeType === "application/typescript");
+}
+export class File {
+    data;
+    mimeType;
+    isText;
+    name;
+    charset;
+    constructor(data, mimeType, isText, name, charset = "utf-8") {
+        this.data = data;
+        this.mimeType = mimeType;
+        this.isText = isText;
+        this.name = name;
+        this.charset = charset;
+    }
+    static async fromUrl(url, options) {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch file from ${safeRemoteLabel(url)}: ${response.status} ${response.statusText}`);
+        }
+        const data = await readRemoteBytes(response, "file", url, options);
+        const detected = fileTypeFromBuffer(data);
+        let mimeType;
+        if (detected) {
+            mimeType = detected.mime;
+        }
+        else {
+            const contentType = parseContentType(response.headers.get("content-type"));
+            if (contentType.mimeType) {
+                mimeType = contentType.mimeType;
+            }
+            else {
+                throw new Error(`Unable to detect MIME type from ${safeRemoteLabel(url)}`);
+            }
+        }
+        const contentType = parseContentType(response.headers.get("content-type"));
+        const charset = contentType.charset ?? "utf-8";
+        let isText = isTextMimeType(mimeType);
+        if (isText) {
+            try {
+                new TextDecoder(charset);
+            }
+            catch {
+                isText = false;
+            }
+        }
+        const name = new URL(url).pathname.split("/").pop() || "file";
+        return new File(data, mimeType, isText, name, charset);
+    }
+    static fromBytes(data, mimeType) {
+        const isText = isTextMimeType(mimeType);
+        return new File(data, mimeType, isText);
+    }
+    static fromText(text, mimeType = "text/plain") {
+        return new File(text, mimeType, isTextMimeType(mimeType));
+    }
+    static fromBase64(base64, mimeType) {
+        assertBase64(base64);
+        const data = Buffer.from(base64, "base64");
+        const isText = isTextMimeType(mimeType);
+        return new File(new Uint8Array(data), mimeType, isText);
+    }
+    toContentBlock() {
+        const uri = this.name ? `file:///${this.name}` : "file:///data";
+        if (this.isText) {
+            let text;
+            if (typeof this.data === "string") {
+                text = this.data;
+            }
+            else {
+                text = new TextDecoder(this.charset).decode(this.data);
+            }
+            return {
+                type: "resource",
+                resource: {
+                    uri,
+                    mimeType: this.mimeType,
+                    text,
+                },
+            };
+        }
+        else {
+            let blob;
+            if (typeof this.data === "string") {
+                blob = Buffer.from(this.data).toString("base64");
+            }
+            else {
+                blob = Buffer.from(this.data).toString("base64");
+            }
+            return {
+                type: "resource",
+                resource: {
+                    uri,
+                    mimeType: this.mimeType,
+                    blob,
+                },
+            };
+        }
+    }
+}

package/node_modules/tiny-stdio-mcp-server/dist/content/image.d.ts

@@ -0,0 +1,15 @@
+import { type FromUrlOptions } from "./remote.js";
+export interface ImageContent {
+    type: "image";
+    data: string;
+    mimeType: string;
+}
+export declare class Image {
+    private readonly base64Data;
+    private readonly mimeType;
+    private constructor();
+    static fromUrl(url: string, options?: FromUrlOptions): Promise<Image>;
+    static fromBytes(data: Uint8Array, format?: string): Image;
+    static fromBase64(base64: string, mimeType: string): Image;
+    toContentBlock(): ImageContent;
+}

package/node_modules/tiny-stdio-mcp-server/dist/content/image.js

@@ -0,0 +1,72 @@
+import { assertBase64, fileTypeFromBuffer, parseContentType, safeRemoteLabel } from "./mime.js";
+import { readRemoteBytes } from "./remote.js";
+const SUPPORTED_IMAGE_MIMES = new Set([
+    "image/png",
+    "image/jpeg",
+    "image/gif",
+    "image/webp",
+]);
+export class Image {
+    base64Data;
+    mimeType;
+    constructor(base64Data, mimeType) {
+        this.base64Data = base64Data;
+        this.mimeType = mimeType;
+    }
+    static async fromUrl(url, options) {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch image from ${safeRemoteLabel(url)}: ${response.status} ${response.statusText}`);
+        }
+        const data = await readRemoteBytes(response, "image", url, options);
+        const detected = fileTypeFromBuffer(data);
+        let mimeType;
+        if (detected && SUPPORTED_IMAGE_MIMES.has(detected.mime)) {
+            mimeType = detected.mime;
+        }
+        else {
+            const contentType = parseContentType(response.headers.get("content-type")).mimeType;
+            if (contentType && SUPPORTED_IMAGE_MIMES.has(contentType)) {
+                mimeType = contentType;
+            }
+            else {
+                throw new Error(`Unable to detect image MIME type from ${safeRemoteLabel(url)}`);
+            }
+        }
+        const base64 = Buffer.from(data).toString("base64");
+        return new Image(base64, mimeType);
+    }
+    static fromBytes(data, format) {
+        let mimeType;
+        if (format) {
+            mimeType = (format.includes("/") ? format : `image/${format}`).toLowerCase();
+            if (!SUPPORTED_IMAGE_MIMES.has(mimeType)) {
+                throw new Error(`Unsupported image MIME type: ${mimeType}`);
+            }
+        }
+        else {
+            const detected = fileTypeFromBuffer(data);
+            if (!detected || !SUPPORTED_IMAGE_MIMES.has(detected.mime)) {
+                throw new Error("Unable to detect image MIME type from bytes");
+            }
+            mimeType = detected.mime;
+        }
+        const base64 = Buffer.from(data).toString("base64");
+        return new Image(base64, mimeType);
+    }
+    static fromBase64(base64, mimeType) {
+        assertBase64(base64);
+        const normalizedMimeType = mimeType.toLowerCase();
+        if (!SUPPORTED_IMAGE_MIMES.has(normalizedMimeType)) {
+            throw new Error(`Unsupported image MIME type: ${normalizedMimeType}`);
+        }
+        return new Image(base64, normalizedMimeType);
+    }
+    toContentBlock() {
+        return {
+            type: "image",
+            data: this.base64Data,
+            mimeType: this.mimeType,
+        };
+    }
+}

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

@@ -0,0 +1,7 @@
+export { fileTypeFromBuffer, type FileTypeResult } from "./mime.js";
+export { DEFAULT_FROM_URL_MAX_BYTES } from "./remote.js";
+export type { FromUrlOptions } from "./remote.js";
+export { Image, type ImageContent } from "./image.js";
+export { Audio, type AudioContent } from "./audio.js";
+export { File, type EmbeddedResource, type TextResourceContents, type BlobResourceContents, } from "./file.js";
+export { toContentBlocks, type ContentBlock, type TextContent, type ToolReturn, } from "./convert.js";

package/node_modules/tiny-stdio-mcp-server/dist/content/index.js

@@ -0,0 +1,9 @@
+// MIME detection
+export { fileTypeFromBuffer } from "./mime.js";
+export { DEFAULT_FROM_URL_MAX_BYTES } from "./remote.js";
+// Content helpers
+export { Image } from "./image.js";
+export { Audio } from "./audio.js";
+export { File, } from "./file.js";
+// Conversion utility
+export { toContentBlocks, } from "./convert.js";

package/node_modules/tiny-stdio-mcp-server/dist/content/mime.d.ts

@@ -0,0 +1,7 @@
+export { fileTypeFromBuffer, type FileTypeResult } from "./file-type.js";
+export declare function parseContentType(value: string | null): {
+    mimeType?: string;
+    charset?: string;
+};
+export declare function assertBase64(value: string): void;
+export declare function safeRemoteLabel(url: string): string;

package/node_modules/tiny-stdio-mcp-server/dist/content/mime.js

@@ -0,0 +1,52 @@
+export { fileTypeFromBuffer } from "./file-type.js";
+export function parseContentType(value) {
+    if (!value) {
+        return {};
+    }
+    const [rawMimeType, ...parameters] = value.split(";");
+    const mimeType = rawMimeType?.trim().toLowerCase();
+    const charsetParameter = parameters.find((parameter) => parameter.trim().toLowerCase().startsWith("charset="));
+    const rawCharset = charsetParameter?.split("=", 2)[1]?.trim();
+    const charset = rawCharset?.startsWith('"') && rawCharset.endsWith('"')
+        ? rawCharset.slice(1, -1)
+        : rawCharset;
+    return {
+        ...(mimeType ? { mimeType } : {}),
+        ...(charset ? { charset } : {})
+    };
+}
+export function assertBase64(value) {
+    if (value.length % 4 !== 0) {
+        throw new Error("Invalid base64 content");
+    }
+    let paddingStarted = false;
+    let paddingCount = 0;
+    for (const character of value) {
+        if (character === "=") {
+            paddingStarted = true;
+            paddingCount += 1;
+            continue;
+        }
+        const code = character.charCodeAt(0);
+        const isValid = (code >= 65 && code <= 90) ||
+            (code >= 97 && code <= 122) ||
+            (code >= 48 && code <= 57) ||
+            character === "+" ||
+            character === "/";
+        if (!isValid || paddingStarted) {
+            throw new Error("Invalid base64 content");
+        }
+    }
+    if (paddingCount > 2) {
+        throw new Error("Invalid base64 content");
+    }
+}
+export function safeRemoteLabel(url) {
+    try {
+        const parsed = new URL(url);
+        return `${parsed.origin}${parsed.pathname}`;
+    }
+    catch {
+        return "remote resource";
+    }
+}

package/node_modules/tiny-stdio-mcp-server/dist/content/remote.d.ts

@@ -0,0 +1,5 @@
+export declare const DEFAULT_FROM_URL_MAX_BYTES: number;
+export interface FromUrlOptions {
+    maxBytes?: number;
+}
+export declare function readRemoteBytes(response: Response, kind: string, url: string, options?: FromUrlOptions): Promise<Uint8Array>;

package/node_modules/tiny-stdio-mcp-server/dist/content/remote.js

@@ -0,0 +1,69 @@
+import { safeRemoteLabel } from "./mime.js";
+export const DEFAULT_FROM_URL_MAX_BYTES = 5 * 1024 * 1024;
+function resolveMaxBytes(options) {
+    const maxBytes = options?.maxBytes ?? DEFAULT_FROM_URL_MAX_BYTES;
+    if (!Number.isSafeInteger(maxBytes) || maxBytes <= 0) {
+        throw new Error("maxBytes must be a positive integer");
+    }
+    return maxBytes;
+}
+function createSizeError(kind, url, maxBytes) {
+    return new Error(`Remote ${kind} from ${safeRemoteLabel(url)} exceeds maximum size of ${maxBytes} bytes`);
+}
+function readContentLength(response) {
+    const rawContentLength = response.headers.get("content-length");
+    if (typeof rawContentLength !== "string") {
+        return undefined;
+    }
+    const contentLength = Number(rawContentLength.trim());
+    if (!Number.isSafeInteger(contentLength) || contentLength < 0) {
+        return undefined;
+    }
+    return contentLength;
+}
+function combineChunks(chunks, totalBytes) {
+    const combined = new Uint8Array(totalBytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+        combined.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return combined;
+}
+async function readStreamBytes(body, kind, url, maxBytes) {
+    const reader = body.getReader();
+    const chunks = [];
+    let totalBytes = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done) {
+                return combineChunks(chunks, totalBytes);
+            }
+            totalBytes += value.byteLength;
+            if (totalBytes > maxBytes) {
+                await reader.cancel().catch(() => undefined);
+                throw createSizeError(kind, url, maxBytes);
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
+export async function readRemoteBytes(response, kind, url, options) {
+    const maxBytes = resolveMaxBytes(options);
+    const contentLength = readContentLength(response);
+    if (contentLength !== undefined && contentLength > maxBytes) {
+        throw createSizeError(kind, url, maxBytes);
+    }
+    if (response.body) {
+        return readStreamBytes(response.body, kind, url, maxBytes);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    if (arrayBuffer.byteLength > maxBytes) {
+        throw createSizeError(kind, url, maxBytes);
+    }
+    return new Uint8Array(arrayBuffer);
+}

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

@@ -0,0 +1,9 @@
+export { createServer } from "./server.js";
+export type { CustomMethodHandler, MessageHandler, MessageSession, MessageSessionContext, Server } from "./server.js";
+export { defineSchema } from "./schema.js";
+export type { TypedSchema } from "./schema.js";
+export { Image, Audio, File, toContentBlocks, fileTypeFromBuffer, DEFAULT_FROM_URL_MAX_BYTES, } from "./content/index.js";
+export type { ImageContent, AudioContent, EmbeddedResource, TextResourceContents, BlobResourceContents, ContentBlock, TextContent, FileTypeResult, FromUrlOptions, } from "./content/index.js";
+export type { ToolReturn } from "./content/index.js";
+export type { 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 "./types.js";
+export { JSON_RPC_ERROR_CODES, ToolError } from "./types.js";

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

@@ -0,0 +1,7 @@
+// Server
+export { createServer } from "./server.js";
+// Schema
+export { defineSchema } from "./schema.js";
+// Content helpers
+export { Image, Audio, File, toContentBlocks, fileTypeFromBuffer, DEFAULT_FROM_URL_MAX_BYTES, } from "./content/index.js";
+export { JSON_RPC_ERROR_CODES, ToolError } from "./types.js";

package/node_modules/tiny-stdio-mcp-server/dist/jsonrpc.d.ts

@@ -0,0 +1,14 @@
+import type { JSONRPCRequest, JSONRPCError, JSONRPCNotification } from "./types.js";
+export interface ParseResult {
+    success: true;
+    request: JSONRPCRequest | JSONRPCNotification;
+    isNotification: boolean;
+}
+export interface ParseError {
+    success: false;
+    error: JSONRPCError;
+    id: string | number | null;
+}
+export declare function parseMessage(line: string): ParseResult | ParseError;
+export declare function formatSuccessResponse(id: string | number | null, result: unknown): string;
+export declare function formatErrorResponse(id: string | number | null, error: JSONRPCError): string;

package/node_modules/tiny-stdio-mcp-server/dist/jsonrpc.js

@@ -0,0 +1,118 @@
+import { JSON_RPC_ERROR_CODES } from "./types.js";
+export function parseMessage(line) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return {
+            success: false,
+            error: {
+                code: JSON_RPC_ERROR_CODES.PARSE_ERROR,
+                message: "Parse error",
+            },
+            id: null,
+        };
+    }
+    if (typeof parsed !== "object" ||
+        parsed === null ||
+        Array.isArray(parsed)) {
+        return {
+            success: false,
+            error: {
+                code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+                message: "Invalid Request",
+            },
+            id: null,
+        };
+    }
+    const obj = parsed;
+    const hasId = "id" in obj;
+    const id = typeof obj.id === "string"
+        ? obj.id
+        : typeof obj.id === "number" && Number.isFinite(obj.id)
+            ? obj.id
+            : obj.id === null
+                ? null
+                : null;
+    if ("params" in obj
+        && (typeof obj.params !== "object"
+            || obj.params === null
+            || Array.isArray(obj.params))) {
+        return {
+            success: false,
+            error: {
+                code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+                message: "Invalid Request",
+            },
+            id,
+        };
+    }
+    if (obj.jsonrpc !== "2.0") {
+        return {
+            success: false,
+            error: {
+                code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+                message: "Invalid Request",
+            },
+            id,
+        };
+    }
+    if (typeof obj.method !== "string") {
+        return {
+            success: false,
+            error: {
+                code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+                message: "Invalid Request",
+            },
+            id,
+        };
+    }
+    if (!hasId) {
+        return {
+            success: true,
+            isNotification: true,
+            request: {
+                jsonrpc: "2.0",
+                method: obj.method,
+                params: obj.params,
+            },
+        };
+    }
+    if (obj.id !== null && id === null) {
+        return {
+            success: false,
+            error: {
+                code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+                message: "Invalid Request",
+            },
+            id: null,
+        };
+    }
+    return {
+        success: true,
+        isNotification: false,
+        request: {
+            jsonrpc: "2.0",
+            id,
+            method: obj.method,
+            params: obj.params,
+        },
+    };
+}
+export function formatSuccessResponse(id, result) {
+    const response = {
+        jsonrpc: "2.0",
+        id,
+        result,
+    };
+    return JSON.stringify(response);
+}
+export function formatErrorResponse(id, error) {
+    const response = {
+        jsonrpc: "2.0",
+        id,
+        error,
+    };
+    return JSON.stringify(response);
+}

package/node_modules/tiny-stdio-mcp-server/dist/schema.d.ts

@@ -0,0 +1,20 @@
+import type { JSONSchema } from "./types.js";
+type SchemaPropertyType = "string" | "number" | "integer" | "boolean" | "object" | "array";
+interface SchemaPropertyDef {
+    type: SchemaPropertyType;
+    description?: string;
+    optional?: boolean;
+    [keyword: string]: unknown;
+}
+type SchemaDefinition = Record<string, SchemaPropertyDef>;
+type InferType<T extends SchemaPropertyType> = T extends "string" ? string : T extends "number" | "integer" ? number : T extends "boolean" ? boolean : T extends "object" ? Record<string, unknown> : T extends "array" ? unknown[] : never;
+type InferSchema<T extends SchemaDefinition> = {
+    [K in keyof T as T[K]["optional"] extends true ? never : K]: InferType<T[K]["type"]>;
+} & {
+    [K in keyof T as T[K]["optional"] extends true ? K : never]?: InferType<T[K]["type"]>;
+};
+export interface TypedSchema<T> extends JSONSchema {
+    __type?: T;
+}
+export declare function defineSchema<T extends SchemaDefinition>(definition: T): TypedSchema<InferSchema<T>>;
+export {};

package/node_modules/tiny-stdio-mcp-server/dist/schema.js

@@ -0,0 +1,26 @@
+export function defineSchema(definition) {
+    const properties = {};
+    const required = [];
+    for (const [key, prop] of Object.entries(definition)) {
+        const jsonSchemaProperty = {};
+        for (const [propertyKey, propertyValue] of Object.entries(prop)) {
+            if (propertyKey !== "optional") {
+                jsonSchemaProperty[propertyKey] = propertyValue;
+            }
+        }
+        Object.defineProperty(properties, key, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: jsonSchemaProperty,
+        });
+        if (!prop.optional) {
+            required.push(key);
+        }
+    }
+    return {
+        type: "object",
+        properties,
+        required,
+    };
+}

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

@@ -0,0 +1,35 @@
+import type { ServerOptions, ToolDefinition, ToolHandler, HandleResult, Prompt, PromptHandler, Resource, ResourceHandler, ResourceTemplate, Transport, SDKTransport, JSONRPCNotification } from "./types.js";
+import type { TypedSchema } from "./schema.js";
+export interface Server {
+    tool<TIn, TOut = never>(name: string, description: string, inputSchema: TypedSchema<TIn>, handler: ToolHandler<TIn, TOut>, outputSchema?: TypedSchema<TOut>): Server;
+    registerTool<TIn, TOut = never>(definition: Omit<ToolDefinition<TIn, TOut>, "handler">, handler: ToolHandler<TIn, TOut>): Server;
+    prompt(definition: Prompt, handler: PromptHandler): Server;
+    resource(definition: Resource, handler: ResourceHandler): Server;
+    resourceTemplate(definition: ResourceTemplate, handler: ResourceHandler): Server;
+    method(name: string, handler: CustomMethodHandler): Server;
+    onNotification(listener: (notification: JSONRPCNotification) => void): () => void;
+    removeTool(name: string): boolean;
+    removePrompt(name: string): boolean;
+    removeResource(uri: string): boolean;
+    removeResourceTemplate(uriTemplate: string): boolean;
+    notifyToolsChanged(): Promise<void>;
+    notifyPromptsChanged(): Promise<void>;
+    notifyResourcesChanged(): Promise<void>;
+    notifyResourceUpdated(uri: string): Promise<void>;
+    createMessageSession(listener?: (notification: JSONRPCNotification) => void | Promise<void>): MessageSession;
+    handleMessage(method: string, params?: Record<string, unknown>): Promise<HandleResult>;
+    listen(): Promise<void>;
+    connect(transport: Transport): Promise<void>;
+    connectSDK(transport: SDKTransport): Promise<void>;
+}
+export interface MessageSessionContext {
+    readonly signal: AbortSignal;
+    notify(method: string, params?: Record<string, unknown>): Promise<void>;
+}
+export type CustomMethodHandler = (params: Record<string, unknown> | undefined, session: MessageSessionContext) => unknown | Promise<unknown>;
+export type MessageHandler = (method: string, params?: Record<string, unknown>) => Promise<HandleResult>;
+export interface MessageSession {
+    handleMessage: MessageHandler;
+    close(): void;
+}
+export declare function createServer(options: ServerOptions): Server;