toolcraft 0.0.232 → 0.0.233

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

@@ -3,6 +3,9 @@ export declare class StdioInput extends Transform {
     private readonly maxLineBytes;
     private lineBytes;
     private trailingHighSurrogate;
+    private readonly decoder;
     constructor(maxLineBytes: number);
     _transform(chunk: Buffer | string, _encoding: BufferEncoding, callback: TransformCallback): void;
+    _flush(callback: TransformCallback): void;
+    private pushSegment;
 }

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

@@ -3,43 +3,65 @@ export class StdioInput extends Transform {
     maxLineBytes;
     lineBytes = 0;
     trailingHighSurrogate = false;
+    decoder = new TextDecoder("utf-8", { fatal: true });
     constructor(maxLineBytes) {
         super({ decodeStrings: false, readableObjectMode: true });
         this.maxLineBytes = maxLineBytes;
     }
     _transform(chunk, _encoding, callback) {
-        const text = typeof chunk === "string";
-        if (!text)
-            this.trailingHighSurrogate = false;
-        let start = 0;
-        for (let index = 0; index < chunk.length; index++) {
-            const unit = text ? chunk.charCodeAt(index) : chunk[index];
-            if (unit === 10 || unit === 13) {
-                this.lineBytes = 0;
+        try {
+            const text = typeof chunk === "string";
+            if (!text)
                 this.trailingHighSurrogate = false;
-                this.push(text ? chunk.slice(start, index + 1) : chunk.subarray(start, index + 1));
-                start = index + 1;
-                if (this.destroyed) {
-                    callback();
+            let start = 0;
+            for (let index = 0; index < chunk.length; index++) {
+                const unit = text ? chunk.charCodeAt(index) : chunk[index];
+                if (unit === 10 || unit === 13) {
+                    this.lineBytes = 0;
+                    this.trailingHighSurrogate = false;
+                    this.pushSegment(text ? chunk.slice(start, index + 1) : chunk.subarray(start, index + 1));
+                    start = index + 1;
+                    if (this.destroyed) {
+                        callback();
+                        return;
+                    }
+                    continue;
+                }
+                if (text) {
+                    const lowSurrogate = unit >= 0xdc00 && unit <= 0xdfff;
+                    this.lineBytes += this.trailingHighSurrogate && lowSurrogate ? 1 : unit <= 0x7f ? 1 : unit <= 0x7ff ? 2 : 3;
+                    this.trailingHighSurrogate = unit >= 0xd800 && unit <= 0xdbff;
+                }
+                else {
+                    this.lineBytes++;
+                }
+                if (this.lineBytes > this.maxLineBytes) {
+                    callback(new Error("Stdio input line byte limit exceeded"));
                     return;
                 }
-                continue;
-            }
-            if (text) {
-                const lowSurrogate = unit >= 0xdc00 && unit <= 0xdfff;
-                this.lineBytes += this.trailingHighSurrogate && lowSurrogate ? 1 : unit <= 0x7f ? 1 : unit <= 0x7ff ? 2 : 3;
-                this.trailingHighSurrogate = unit >= 0xd800 && unit <= 0xdbff;
-            }
-            else {
-                this.lineBytes++;
-            }
-            if (this.lineBytes > this.maxLineBytes) {
-                callback(new Error("Stdio input line byte limit exceeded"));
-                return;
             }
+            if (start < chunk.length)
+                this.pushSegment(text ? chunk.slice(start) : chunk.subarray(start));
+            callback();
         }
-        if (start < chunk.length)
-            this.push(text ? chunk.slice(start) : chunk.subarray(start));
-        callback();
+        catch (error) {
+            callback(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    _flush(callback) {
+        try {
+            this.decoder.decode();
+            callback();
+        }
+        catch (error) {
+            callback(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    pushSegment(segment) {
+        if (typeof segment === "string")
+            this.decoder.decode();
+        else
+            this.decoder.decode(segment, { stream: true });
+        this.push(segment);
     }
 }

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

@@ -0,0 +1,11 @@
+import { type HandleResult, type JSONRPCNotification } from "./types.js";
+export declare class SubscriptionRegistry {
+    private readonly listener;
+    private readonly supportNotifications;
+    private readonly supportResourceSubscriptions;
+    private readonly subscriptions;
+    constructor(listener: (notification: JSONRPCNotification) => void | Promise<void>, supportNotifications: boolean, supportResourceSubscriptions: boolean);
+    get size(): number;
+    listen(id: string | number | undefined, value: unknown, signal: AbortSignal): Promise<HandleResult>;
+    emit(method: string, params?: Record<string, unknown>): Promise<void>;
+}

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

@@ -0,0 +1,128 @@
+import { isValidUri } from "./uri.js";
+import { JSON_RPC_ERROR_CODES } from "./types.js";
+const listNotifications = {
+    "notifications/tools/list_changed": "toolsListChanged",
+    "notifications/prompts/list_changed": "promptsListChanged",
+    "notifications/resources/list_changed": "resourcesListChanged"
+};
+export class SubscriptionRegistry {
+    listener;
+    supportNotifications;
+    supportResourceSubscriptions;
+    subscriptions = new Map();
+    constructor(listener, supportNotifications, supportResourceSubscriptions) {
+        this.listener = listener;
+        this.supportNotifications = supportNotifications;
+        this.supportResourceSubscriptions = supportResourceSubscriptions;
+    }
+    get size() {
+        return this.subscriptions.size;
+    }
+    async listen(id, value, signal) {
+        if (id === undefined || (typeof id === "number" && !Number.isSafeInteger(id))) {
+            return {
+                error: {
+                    code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+                    message: "subscriptions/listen requires a request ID"
+                }
+            };
+        }
+        if (typeof value !== "object" || value === null || Array.isArray(value)) {
+            return {
+                error: {
+                    code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+                    message: "Subscription notifications must be an object"
+                }
+            };
+        }
+        const requested = value;
+        const filter = {};
+        for (const field of Object.values(listNotifications)) {
+            if (requested[field] !== undefined && typeof requested[field] !== "boolean") {
+                return {
+                    error: {
+                        code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+                        message: `${field} must be a boolean`
+                    }
+                };
+            }
+            if (this.supportNotifications && requested[field] === true)
+                filter[field] = true;
+        }
+        const uris = requested.resourceSubscriptions;
+        if (uris !== undefined) {
+            if (!Array.isArray(uris) || uris.length > 1024 || !uris.every((uri) => {
+                if (typeof uri !== "string" || uri.length > 8192)
+                    return false;
+                return isValidUri(uri);
+            })) {
+                return {
+                    error: {
+                        code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+                        message: "resourceSubscriptions must contain at most 1024 absolute URIs of at most 8192 characters"
+                    }
+                };
+            }
+            if (this.supportResourceSubscriptions)
+                filter.resourceSubscriptions = [...new Set(uris)];
+        }
+        if (signal.aborted)
+            return { result: undefined };
+        let resolve;
+        const completed = new Promise((complete) => {
+            resolve = complete;
+        });
+        const entry = {
+            filter,
+            resourceUris: new Set(Array.isArray(filter.resourceSubscriptions) ? filter.resourceSubscriptions : []),
+            ready: false,
+            finish: () => {
+                signal.removeEventListener("abort", entry.finish);
+                if (this.subscriptions.get(id) === entry)
+                    this.subscriptions.delete(id);
+                resolve({ result: undefined });
+            }
+        };
+        this.subscriptions.set(id, entry);
+        signal.addEventListener("abort", entry.finish, { once: true });
+        try {
+            await this.listener({
+                jsonrpc: "2.0",
+                method: "notifications/subscriptions/acknowledged",
+                params: {
+                    _meta: { "io.modelcontextprotocol/subscriptionId": id },
+                    notifications: structuredClone(filter)
+                }
+            });
+            if (!signal.aborted)
+                entry.ready = true;
+            return await completed;
+        }
+        catch (error) {
+            entry.finish();
+            throw error;
+        }
+    }
+    async emit(method, params) {
+        await Promise.all([...this.subscriptions].map(async ([id, entry]) => {
+            if (!entry.ready)
+                return;
+            const field = listNotifications[method];
+            const selected = field !== undefined
+                ? entry.filter[field] === true
+                : method === "notifications/resources/updated" &&
+                    typeof params?.uri === "string" &&
+                    entry.resourceUris.has(params.uri);
+            if (!selected)
+                return;
+            await this.listener({
+                jsonrpc: "2.0",
+                method,
+                params: {
+                    ...params,
+                    _meta: { "io.modelcontextprotocol/subscriptionId": id }
+                }
+            });
+        }));
+    }
+}

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

@@ -22,6 +22,7 @@ export declare const JSON_RPC_ERROR_CODES: Readonly<{
     readonly INVALID_PARAMS: -32602;
     readonly INTERNAL_ERROR: -32603;
     readonly RESOURCE_NOT_FOUND: -32002;
+    readonly UNSUPPORTED_PROTOCOL_VERSION: -32022;
 }>;
 export declare class ToolError extends Error {
     readonly code: number;
@@ -38,24 +39,40 @@ export interface ResourcesCapability {
     subscribe?: boolean;
     listChanged?: boolean;
 }
+export interface Implementation {
+    name: string;
+    title?: string;
+    version: string;
+    description?: string;
+    websiteUrl?: string;
+    icons?: Icon[];
+}
 export interface InitializeResult {
     protocolVersion: string;
     capabilities: {
+        extensions?: Record<string, Record<string, unknown>>;
         tools?: ToolsCapability;
         prompts?: PromptsCapability;
         resources?: ResourcesCapability;
     };
-    serverInfo: {
-        name: string;
-        version: string;
+    serverInfo: Implementation;
+}
+export interface DiscoverResult {
+    resultType: "complete";
+    supportedVersions: string[];
+    capabilities: InitializeResult["capabilities"];
+    _meta: {
+        "io.modelcontextprotocol/serverInfo": InitializeResult["serverInfo"];
     };
+    ttlMs: number;
+    cacheScope: "public" | "private";
 }
 export interface Tool {
     name: string;
     title?: string;
     description?: string;
     inputSchema: JSONSchema;
-    outputSchema?: JSONSchema;
+    outputSchema?: OutputSchema;
     annotations?: ToolAnnotations;
     execution?: ToolExecution;
     icons?: Icon[];
@@ -63,7 +80,7 @@ export interface Tool {
 }
 export interface CallToolResult {
     content: ContentItem[];
-    structuredContent?: Record<string, unknown>;
+    structuredContent?: unknown;
     isError?: boolean;
 }
 export interface ToolAnnotations {
@@ -87,18 +104,12 @@ export interface ContentAnnotations {
     priority?: number;
     lastModified?: string;
 }
-export interface ResourceLink {
+export interface ResourceLink extends Resource {
     type: "resource_link";
-    uri: string;
-    name: string;
-    title?: string;
-    description?: string;
-    mimeType?: string;
-    size?: number;
-    annotations?: ContentAnnotations;
 }
 export interface PromptArgument {
     name: string;
+    title?: string;
     description?: string;
     required?: boolean;
 }
@@ -112,13 +123,13 @@ export interface Prompt {
 }
 export interface PromptMessage {
     role: "user" | "assistant";
-    content: PromptContentItem;
+    content: ContentItem;
 }
 export interface GetPromptResult {
     description?: string;
     messages: PromptMessage[];
 }
-export type PromptHandler = (args: Record<string, string>) => Promise<GetPromptResult> | GetPromptResult;
+export type PromptHandler = (args: Record<string, string>, context: HandlerRequestContext) => Promise<GetPromptResult | InputRequiredResult> | GetPromptResult | InputRequiredResult;
 export interface PromptDefinition extends Prompt {
     handler: PromptHandler;
 }
@@ -147,15 +158,17 @@ export type ResourceContents = {
     uri: string;
     mimeType?: string;
     text: string;
+    _meta?: Record<string, unknown>;
 } | {
     uri: string;
     mimeType?: string;
     blob: string;
+    _meta?: Record<string, unknown>;
 };
 export interface ReadResourceResult {
     contents: ResourceContents[];
 }
-export type ResourceHandler = (uri: string) => Promise<ReadResourceResult> | ReadResourceResult;
+export type ResourceHandler = (uri: string, context: HandlerRequestContext) => Promise<ReadResourceResult | InputRequiredResult> | ReadResourceResult | InputRequiredResult;
 export interface ResourceDefinition extends Resource {
     handler: ResourceHandler;
 }
@@ -170,27 +183,33 @@ export type PromptContentItem = {
     type: "text";
     text: string;
     annotations?: ContentAnnotations;
+    _meta?: Record<string, unknown>;
 } | {
     type: "image";
     data: string;
     mimeType: string;
     annotations?: ContentAnnotations;
+    _meta?: Record<string, unknown>;
 } | {
     type: "audio";
     data: string;
     mimeType: string;
     annotations?: ContentAnnotations;
+    _meta?: Record<string, unknown>;
 } | {
     type: "resource";
     annotations?: ContentAnnotations;
+    _meta?: Record<string, unknown>;
     resource: {
         uri: string;
         mimeType?: string;
         text: string;
+        _meta?: Record<string, unknown>;
     } | {
         uri: string;
         mimeType?: string;
         blob: string;
+        _meta?: Record<string, unknown>;
     };
 };
 export type ContentItem = PromptContentItem | ResourceLink;
@@ -200,6 +219,10 @@ export interface JSONSchema {
     required?: string[];
     [keyword: string]: unknown;
 }
+export interface OutputSchema {
+    $schema?: string;
+    [keyword: string]: unknown;
+}
 export interface JSONSchemaProperty extends Record<string, unknown> {
     type?: string | string[];
     description?: string;
@@ -217,19 +240,36 @@ export interface ServerOptions {
     maxStdioOutputBytes?: number;
     /** Per-stdio-connection messages awaiting handler/output settlement; defaults to 128. */
     maxPendingStdioMessages?: number;
+    /** Shared in-flight requests retained until their work settles; defaults to 128. */
+    maxActiveRequests?: number;
     maxStdioLineBytes?: number;
     validateToolArguments?: boolean;
     supportNotifications?: boolean;
     supportResourceSubscriptions?: boolean;
 }
 import type { ToolReturn } from "./content/index.js";
-export type ToolHandler<T = Record<string, unknown>, TOut = ToolReturn> = (args: T) => Promise<TOut | CallToolResult> | TOut | CallToolResult;
+export interface InputRequiredResult {
+    resultType: "input_required";
+    inputRequests?: Record<string, {
+        method: "elicitation/create" | "sampling/createMessage" | "roots/list";
+        params?: Record<string, unknown>;
+    }>;
+    requestState?: string;
+    _meta?: Record<string, unknown>;
+}
+export interface HandlerRequestContext {
+    readonly signal: AbortSignal;
+    readonly requestState?: string;
+    readonly inputResponses?: Record<string, unknown>;
+    readonly clientCapabilities: Record<string, unknown>;
+}
+export type ToolHandler<T = Record<string, unknown>, TOut = ToolReturn> = (args: T, context: HandlerRequestContext) => Promise<TOut | CallToolResult | InputRequiredResult> | TOut | CallToolResult | InputRequiredResult;
 export interface ToolDefinition<T = Record<string, unknown>, TOut = ToolReturn> {
     name: string;
     title?: string;
     description?: string;
     inputSchema: JSONSchema;
-    outputSchema?: JSONSchema;
+    outputSchema?: OutputSchema;
     annotations?: ToolAnnotations;
     execution?: ToolExecution;
     icons?: Icon[];

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

@@ -5,7 +5,8 @@ export const JSON_RPC_ERROR_CODES = Object.freeze({
     METHOD_NOT_FOUND: -32601,
     INVALID_PARAMS: -32602,
     INTERNAL_ERROR: -32603,
-    RESOURCE_NOT_FOUND: -32002
+    RESOURCE_NOT_FOUND: -32002,
+    UNSUPPORTED_PROTOCOL_VERSION: -32022
 });
 export class ToolError extends Error {
     code;

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

@@ -0,0 +1 @@
+export declare function isValidUri(uri: string): boolean;

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

@@ -0,0 +1,41 @@
+const invalidUriCharacters = new Set(["\"", "<", ">", "\\", "^", "`", "{", "|", "}"]);
+export function isValidUri(uri) {
+    for (let index = 0; index < uri.length; index++) {
+        const code = uri.charCodeAt(index);
+        if (code <= 0x20 || code >= 0x7f || invalidUriCharacters.has(uri[index]))
+            return false;
+        if (uri[index] === "%") {
+            if (index + 2 >= uri.length)
+                return false;
+            for (let offset = 1; offset <= 2; offset++) {
+                const digit = uri.charCodeAt(index + offset);
+                if (!((digit >= 0x30 && digit <= 0x39) || (digit >= 0x41 && digit <= 0x46) || (digit >= 0x61 && digit <= 0x66)))
+                    return false;
+            }
+            index += 2;
+        }
+    }
+    try {
+        const parsed = new URL(uri);
+        const openingBracket = uri.indexOf("[");
+        const closingBracket = uri.indexOf("]");
+        if (openingBracket !== -1 || closingBracket !== -1) {
+            const schemeEnd = uri.indexOf(":");
+            if (!uri.startsWith("//", schemeEnd + 1) || !parsed.hostname.startsWith("["))
+                return false;
+            const authorityStart = schemeEnd + 3;
+            let authorityEnd = authorityStart;
+            while (authorityEnd < uri.length && !"/?#".includes(uri[authorityEnd]))
+                authorityEnd++;
+            const authority = uri.slice(authorityStart, authorityEnd);
+            if (openingBracket !== authorityStart + authority.lastIndexOf("@") + 1 ||
+                closingBracket >= authorityEnd || uri.indexOf("[", openingBracket + 1) !== -1 ||
+                uri.indexOf("]", closingBracket + 1) !== -1)
+                return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -20,6 +20,14 @@
     "./testing": {
       "types": "./dist/testing.d.ts",
       "import": "./dist/testing.js"
+    },
+    "./headers": {
+      "types": "./dist/headers.d.ts",
+      "import": "./dist/headers.js"
+    },
+    "./protocol": {
+      "types": "./dist/protocol.d.ts",
+      "import": "./dist/protocol.js"
     }
   },
   "scripts": {

package/node_modules/toolcraft-design/dist/command-registry.d.ts

@@ -0,0 +1,11 @@
+export interface DesignCommand {
+    id: string;
+    label: string;
+    keys: readonly string[];
+    enabled?: () => boolean;
+    run: () => void;
+}
+export declare function createCommandRegistry(commands: readonly DesignCommand[]): {
+    dispatch(key: string): boolean;
+    list(): DesignCommand[];
+};

package/node_modules/toolcraft-design/dist/command-registry.js

@@ -0,0 +1,24 @@
+export function createCommandRegistry(commands) {
+    const bindings = new Map();
+    const ids = new Set();
+    for (const command of commands) {
+        if (ids.has(command.id))
+            throw new Error(`Duplicate command: ${command.id}`);
+        ids.add(command.id);
+        for (const key of command.keys) {
+            if (bindings.has(key))
+                throw new Error(`Duplicate binding: ${key}`);
+            bindings.set(key, command);
+        }
+    }
+    return {
+        dispatch(key) {
+            const command = bindings.get(key);
+            if (!command || command.enabled?.() === false)
+                return false;
+            command.run();
+            return true;
+        },
+        list() { return commands.filter(command => command.enabled?.() !== false); }
+    };
+}

package/node_modules/toolcraft-design/dist/dashboard/ansi.d.ts

@@ -6,6 +6,8 @@ export interface StyledSegment {
 export interface StyledLine {
     segments: StyledSegment[];
 }
+/** Visible text for a plain screen row; styles are supplied by the caller. */
+export declare function plainTerminalText(text: string): string;
 export declare function hasAnsi(text: string): boolean;
 /**
  * Parse a block of text that may contain ANSI SGR escape codes into a sequence of