poe-code 3.0.178 → 3.0.179

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

@@ -0,0 +1,99 @@
+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" || typeof obj.id === "number" ? obj.id : null;
+    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 (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/packages/tiny-stdio-mcp-server/dist/schema.d.ts

@@ -0,0 +1,19 @@
+import type { JSONSchema } from "./types.js";
+type SchemaPropertyType = "string" | "number" | "boolean" | "object" | "array";
+interface SchemaPropertyDef {
+    type: SchemaPropertyType;
+    description?: string;
+    optional?: boolean;
+}
+type SchemaDefinition = Record<string, SchemaPropertyDef>;
+type InferType<T extends SchemaPropertyType> = T extends "string" ? string : T extends "number" ? 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/packages/tiny-stdio-mcp-server/dist/schema.js

@@ -0,0 +1,18 @@
+export function defineSchema(definition) {
+    const properties = {};
+    const required = [];
+    for (const [key, prop] of Object.entries(definition)) {
+        properties[key] = {
+            type: prop.type,
+            ...(prop.description !== undefined && { description: prop.description }),
+        };
+        if (!prop.optional) {
+            required.push(key);
+        }
+    }
+    return {
+        type: "object",
+        properties,
+        required,
+    };
+}

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

@@ -0,0 +1,13 @@
+import type { ServerOptions, ToolHandler, HandleResult, Transport, SDKTransport, JSONRPCNotification } from "./types.js";
+import type { TypedSchema } from "./schema.js";
+export interface Server {
+    tool<T>(name: string, description: string, inputSchema: TypedSchema<T>, handler: ToolHandler<T>): Server;
+    onNotification(listener: (notification: JSONRPCNotification) => void): () => void;
+    removeTool(name: string): boolean;
+    notifyToolsChanged(): Promise<void>;
+    handleMessage(method: string, params?: Record<string, unknown>): Promise<HandleResult>;
+    listen(): Promise<void>;
+    connect(transport: Transport): Promise<void>;
+    connectSDK(transport: SDKTransport): Promise<void>;
+}
+export declare function createServer(options: ServerOptions): Server;

package/packages/tiny-stdio-mcp-server/dist/server.js

@@ -0,0 +1,226 @@
+import * as readline from "readline";
+import { JSON_RPC_ERROR_CODES, ToolError } from "./types.js";
+import { parseMessage, formatSuccessResponse, formatErrorResponse, } from "./jsonrpc.js";
+import { toContentBlocks } from "./content/convert.js";
+const PROTOCOL_VERSION = "2025-11-25";
+export function createServer(options) {
+    const tools = new Map();
+    const notificationListeners = new Set();
+    let initialized = false;
+    const handleMessage = async (method, params) => {
+        // Allow ping and initialize before initialization
+        if (method === "ping") {
+            return { result: {} };
+        }
+        if (method === "initialize") {
+            initialized = true;
+            const requestedProtocol = typeof params?.protocolVersion === "string"
+                ? params.protocolVersion
+                : null;
+            const result = {
+                protocolVersion: requestedProtocol ?? PROTOCOL_VERSION,
+                capabilities: {
+                    tools: {
+                        listChanged: true,
+                    },
+                },
+                serverInfo: {
+                    name: options.name,
+                    version: options.version,
+                },
+            };
+            return { result };
+        }
+        if (method === "notifications/initialized") {
+            return { result: undefined };
+        }
+        // All other methods require initialization
+        if (!initialized) {
+            return {
+                error: {
+                    code: JSON_RPC_ERROR_CODES.INVALID_REQUEST,
+                    message: "Server not initialized",
+                },
+            };
+        }
+        if (method === "tools/list") {
+            const toolList = [];
+            for (const tool of tools.values()) {
+                toolList.push({
+                    name: tool.name,
+                    description: tool.description,
+                    inputSchema: tool.inputSchema,
+                });
+            }
+            return { result: { tools: toolList } };
+        }
+        if (method === "tools/call") {
+            const toolName = params?.name;
+            const toolArgs = params?.arguments || {};
+            if (!toolName) {
+                return {
+                    error: {
+                        code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+                        message: "Tool name required",
+                    },
+                };
+            }
+            const tool = tools.get(toolName);
+            if (!tool) {
+                return {
+                    error: {
+                        code: JSON_RPC_ERROR_CODES.INVALID_PARAMS,
+                        message: `Tool not found: ${toolName}`,
+                    },
+                };
+            }
+            try {
+                const handlerResult = await tool.handler(toolArgs);
+                const result = { content: toContentBlocks(handlerResult) };
+                return { result };
+            }
+            catch (err) {
+                if (err instanceof ToolError) {
+                    return {
+                        error: {
+                            code: err.code,
+                            message: err.message,
+                        },
+                    };
+                }
+                const errorMessage = err instanceof Error ? err.message : String(err);
+                const result = {
+                    content: [{ type: "text", text: `Error: ${errorMessage}` }],
+                    isError: true,
+                };
+                return { result };
+            }
+        }
+        return {
+            error: {
+                code: JSON_RPC_ERROR_CODES.METHOD_NOT_FOUND,
+                message: "Method not found",
+            },
+        };
+    };
+    const processLine = async (line, write) => {
+        const parsed = parseMessage(line);
+        if (!parsed.success) {
+            write(formatErrorResponse(parsed.id, parsed.error) + "\n");
+            return;
+        }
+        const { request, isNotification } = parsed;
+        const { result, error } = await server.handleMessage(request.method, request.params);
+        if (isNotification) {
+            return;
+        }
+        const requestWithId = request;
+        if (error) {
+            write(formatErrorResponse(requestWithId.id, error) + "\n");
+        }
+        else if (result !== undefined) {
+            write(formatSuccessResponse(requestWithId.id, result) + "\n");
+        }
+    };
+    const broadcastNotification = (method) => {
+        const notification = {
+            jsonrpc: "2.0",
+            method,
+        };
+        for (const listener of notificationListeners) {
+            listener(notification);
+        }
+    };
+    const server = {
+        tool(name, description, inputSchema, handler) {
+            tools.set(name, {
+                name,
+                description,
+                inputSchema: inputSchema,
+                handler: handler,
+            });
+            return server;
+        },
+        onNotification(listener) {
+            notificationListeners.add(listener);
+            return () => {
+                notificationListeners.delete(listener);
+            };
+        },
+        removeTool(name) {
+            return tools.delete(name);
+        },
+        async notifyToolsChanged() {
+            if (initialized) {
+                broadcastNotification("notifications/tools/list_changed");
+            }
+        },
+        handleMessage,
+        async listen() {
+            return server.connect({
+                readable: process.stdin,
+                writable: process.stdout,
+            });
+        },
+        async connect(transport) {
+            return new Promise((resolve) => {
+                const unsubscribe = server.onNotification((notification) => {
+                    transport.writable.write(`${JSON.stringify(notification)}\n`);
+                });
+                const rl = readline.createInterface({
+                    input: transport.readable,
+                    crlfDelay: Infinity,
+                });
+                rl.on("line", (line) => {
+                    processLine(line, (data) => transport.writable.write(data));
+                });
+                rl.on("close", () => {
+                    unsubscribe();
+                    resolve();
+                });
+            });
+        },
+        async connectSDK(transport) {
+            return new Promise((resolve) => {
+                const unsubscribe = server.onNotification((notification) => {
+                    void transport.send(notification);
+                });
+                transport.onmessage = async (message) => {
+                    // Ignore responses (we only handle requests/notifications)
+                    if (!("method" in message)) {
+                        return;
+                    }
+                    // Handle notifications (no id) - don't respond
+                    if (!("id" in message) || message.id === undefined) {
+                        await server.handleMessage(message.method, message.params);
+                        return;
+                    }
+                    const request = message;
+                    const { result, error } = await server.handleMessage(request.method, request.params);
+                    if (error) {
+                        const response = {
+                            jsonrpc: "2.0",
+                            id: request.id,
+                            error,
+                        };
+                        await transport.send(response);
+                    }
+                    else if (result !== undefined) {
+                        const response = {
+                            jsonrpc: "2.0",
+                            id: request.id,
+                            result,
+                        };
+                        await transport.send(response);
+                    }
+                };
+                transport.onclose = () => {
+                    unsubscribe();
+                    resolve();
+                };
+                transport.start();
+            });
+        },
+    };
+    return server;
+}

package/packages/tiny-stdio-mcp-server/dist/testing.d.ts

@@ -0,0 +1,7 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { Server } from "./server.js";
+export interface TestPair {
+    client: Client;
+    cleanup: () => Promise<void>;
+}
+export declare function createTestPair(server: Server): Promise<TestPair>;

package/packages/tiny-stdio-mcp-server/dist/testing.js

@@ -0,0 +1,20 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+export async function createTestPair(server) {
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    const client = new Client({
+        name: "test-client",
+        version: "1.0.0",
+    });
+    // Start server connection (runs in background)
+    const serverPromise = server.connectSDK(serverTransport);
+    // Connect client
+    await client.connect(clientTransport);
+    const cleanup = async () => {
+        await client.close();
+        await clientTransport.close();
+        await serverTransport.close();
+        await serverPromise;
+    };
+    return { client, cleanup };
+}

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

@@ -0,0 +1,119 @@
+export interface JSONRPCRequest {
+    jsonrpc: "2.0";
+    id: string | number;
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface JSONRPCResponse {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    result?: unknown;
+    error?: JSONRPCError;
+}
+export interface JSONRPCError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export declare const JSON_RPC_ERROR_CODES: {
+    readonly PARSE_ERROR: -32700;
+    readonly INVALID_REQUEST: -32600;
+    readonly METHOD_NOT_FOUND: -32601;
+    readonly INVALID_PARAMS: -32602;
+    readonly INTERNAL_ERROR: -32603;
+};
+export declare class ToolError extends Error {
+    readonly code: number;
+    constructor(code: number, message: string);
+}
+export interface ToolsCapability {
+    listChanged?: boolean;
+}
+export interface InitializeResult {
+    protocolVersion: string;
+    capabilities: {
+        tools?: ToolsCapability;
+    };
+    serverInfo: {
+        name: string;
+        version: string;
+    };
+}
+export interface Tool {
+    name: string;
+    description: string;
+    inputSchema: JSONSchema;
+}
+export interface CallToolResult {
+    content: ContentItem[];
+    isError?: boolean;
+}
+export interface HandleResult {
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+    };
+}
+export type ContentItem = {
+    type: "text";
+    text: string;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+} | {
+    type: "audio";
+    data: string;
+    mimeType: string;
+} | {
+    type: "resource";
+    resource: {
+        uri: string;
+        mimeType: string;
+        text: string;
+    } | {
+        uri: string;
+        mimeType: string;
+        blob: string;
+    };
+};
+export interface JSONSchema {
+    type: "object";
+    properties: Record<string, JSONSchemaProperty>;
+    required?: string[];
+}
+export interface JSONSchemaProperty {
+    type: "string" | "number" | "boolean" | "object" | "array";
+    description?: string;
+}
+export interface ServerOptions {
+    name: string;
+    version: string;
+}
+import type { ToolReturn } from "./content/index.js";
+export type ToolHandler<T = Record<string, unknown>> = (args: T) => Promise<ToolReturn> | ToolReturn;
+export interface ToolDefinition<T = Record<string, unknown>> {
+    name: string;
+    description: string;
+    inputSchema: JSONSchema;
+    handler: ToolHandler<T>;
+}
+export interface Transport {
+    readable: NodeJS.ReadableStream;
+    writable: NodeJS.WritableStream;
+}
+export interface SDKTransport {
+    onmessage?: (message: JSONRPCMessage) => void;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    start: () => Promise<void>;
+    close: () => Promise<void>;
+    send: (message: JSONRPCMessage) => Promise<void>;
+}
+export type JSONRPCMessage = JSONRPCRequest | JSONRPCResponse | JSONRPCNotification;
+export interface JSONRPCNotification {
+    jsonrpc: "2.0";
+    method: string;
+    params?: Record<string, unknown>;
+}

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

@@ -0,0 +1,16 @@
+// JSON-RPC error codes
+export const JSON_RPC_ERROR_CODES = {
+    PARSE_ERROR: -32700,
+    INVALID_REQUEST: -32600,
+    METHOD_NOT_FOUND: -32601,
+    INVALID_PARAMS: -32602,
+    INTERNAL_ERROR: -32603
+};
+export class ToolError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "ToolError";
+    }
+}