@lantos1618/better-ui 0.4.0 → 0.5.0

package/dist/mcp/index.d.mts

@@ -0,0 +1,144 @@
+import { T as Tool, c as ToolContext } from '../tool-Ca2x-VNK.mjs';
+import { z } from 'zod';
+import 'react';
+
+/**
+ * MCP (Model Context Protocol) Server for Better UI
+ *
+ * Exposes registered Better UI tools as MCP tools, allowing any MCP-compatible
+ * client (Claude Desktop, Cursor, VS Code, etc.) to discover and call them.
+ *
+ * Protocol: JSON-RPC 2.0 over stdio (newline-delimited JSON)
+ *
+ * @example
+ * ```typescript
+ * import { createMCPServer } from '@lantos1618/better-ui/mcp';
+ * import { weatherTool, searchTool } from './tools';
+ *
+ * const server = createMCPServer({
+ *   name: 'my-tools',
+ *   version: '1.0.0',
+ *   tools: { weather: weatherTool, search: searchTool },
+ * });
+ *
+ * server.start(); // Listens on stdin/stdout
+ * ```
+ */
+
+interface MCPServerConfig {
+    /** Server name exposed to MCP clients */
+    name: string;
+    /** Server version */
+    version: string;
+    /** Tool registry — keys are tool names */
+    tools: Record<string, Tool>;
+    /** Optional context passed to every tool execution */
+    context?: Partial<ToolContext>;
+    /** Called when the server starts */
+    onStart?: () => void;
+    /** Called on errors */
+    onError?: (error: Error) => void;
+}
+interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id?: string | number | null;
+    method: string;
+    params?: Record<string, unknown>;
+}
+interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: string | number | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+interface MCPToolSchema {
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+}
+declare class MCPServer {
+    private config;
+    private initialized;
+    private running;
+    constructor(config: MCPServerConfig);
+    /** Start listening on stdin for JSON-RPC messages */
+    start(): void;
+    /** Stop the server */
+    stop(): void;
+    /** Handle a single JSON-RPC message. Returns a response or null for notifications. */
+    handleMessage(message: JsonRpcRequest): Promise<JsonRpcResponse | null>;
+    /** Get all tools as MCP tool schemas */
+    listTools(): MCPToolSchema[];
+    /** Execute a tool by name */
+    callTool(name: string, args: unknown): Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+    private handleLine;
+    private handleInitialize;
+    private handleToolsList;
+    private handleToolsCall;
+    /**
+     * Create a Web Request handler for HTTP-based MCP transport.
+     * Compatible with Next.js route handlers, Deno, Bun, Cloudflare Workers, etc.
+     *
+     * @example
+     * ```typescript
+     * // Next.js route: app/api/mcp/route.ts
+     * import { server } from '@/lib/mcp';
+     * export const POST = server.httpHandler();
+     * ```
+     */
+    httpHandler(): (req: Request) => Promise<Response>;
+}
+/**
+ * Create an MCP server from a Better UI tool registry.
+ *
+ * @example
+ * ```typescript
+ * const server = createMCPServer({
+ *   name: 'my-app',
+ *   version: '1.0.0',
+ *   tools: { weather: weatherTool, search: searchTool },
+ * });
+ *
+ * // For stdio transport (Claude Desktop, etc.)
+ * server.start();
+ * ```
+ */
+declare function createMCPServer(config: MCPServerConfig): MCPServer;
+
+/**
+ * Lightweight Zod-to-JSON-Schema converter.
+ * Handles common Zod types without requiring zod-to-json-schema dependency.
+ */
+
+interface JsonSchema {
+    type?: string;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    items?: JsonSchema;
+    enum?: unknown[];
+    description?: string;
+    default?: unknown;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+    anyOf?: JsonSchema[];
+    oneOf?: JsonSchema[];
+    nullable?: boolean;
+    additionalProperties?: boolean | JsonSchema;
+    [key: string]: unknown;
+}
+declare function zodToJsonSchema(schema: z.ZodType): JsonSchema;
+
+export { MCPServer, type MCPServerConfig, createMCPServer, zodToJsonSchema };

package/dist/mcp/index.d.ts

@@ -0,0 +1,144 @@
+import { T as Tool, c as ToolContext } from '../tool-Ca2x-VNK.js';
+import { z } from 'zod';
+import 'react';
+
+/**
+ * MCP (Model Context Protocol) Server for Better UI
+ *
+ * Exposes registered Better UI tools as MCP tools, allowing any MCP-compatible
+ * client (Claude Desktop, Cursor, VS Code, etc.) to discover and call them.
+ *
+ * Protocol: JSON-RPC 2.0 over stdio (newline-delimited JSON)
+ *
+ * @example
+ * ```typescript
+ * import { createMCPServer } from '@lantos1618/better-ui/mcp';
+ * import { weatherTool, searchTool } from './tools';
+ *
+ * const server = createMCPServer({
+ *   name: 'my-tools',
+ *   version: '1.0.0',
+ *   tools: { weather: weatherTool, search: searchTool },
+ * });
+ *
+ * server.start(); // Listens on stdin/stdout
+ * ```
+ */
+
+interface MCPServerConfig {
+    /** Server name exposed to MCP clients */
+    name: string;
+    /** Server version */
+    version: string;
+    /** Tool registry — keys are tool names */
+    tools: Record<string, Tool>;
+    /** Optional context passed to every tool execution */
+    context?: Partial<ToolContext>;
+    /** Called when the server starts */
+    onStart?: () => void;
+    /** Called on errors */
+    onError?: (error: Error) => void;
+}
+interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id?: string | number | null;
+    method: string;
+    params?: Record<string, unknown>;
+}
+interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: string | number | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+interface MCPToolSchema {
+    name: string;
+    description?: string;
+    inputSchema: Record<string, unknown>;
+}
+declare class MCPServer {
+    private config;
+    private initialized;
+    private running;
+    constructor(config: MCPServerConfig);
+    /** Start listening on stdin for JSON-RPC messages */
+    start(): void;
+    /** Stop the server */
+    stop(): void;
+    /** Handle a single JSON-RPC message. Returns a response or null for notifications. */
+    handleMessage(message: JsonRpcRequest): Promise<JsonRpcResponse | null>;
+    /** Get all tools as MCP tool schemas */
+    listTools(): MCPToolSchema[];
+    /** Execute a tool by name */
+    callTool(name: string, args: unknown): Promise<{
+        content: Array<{
+            type: string;
+            text: string;
+        }>;
+    }>;
+    private handleLine;
+    private handleInitialize;
+    private handleToolsList;
+    private handleToolsCall;
+    /**
+     * Create a Web Request handler for HTTP-based MCP transport.
+     * Compatible with Next.js route handlers, Deno, Bun, Cloudflare Workers, etc.
+     *
+     * @example
+     * ```typescript
+     * // Next.js route: app/api/mcp/route.ts
+     * import { server } from '@/lib/mcp';
+     * export const POST = server.httpHandler();
+     * ```
+     */
+    httpHandler(): (req: Request) => Promise<Response>;
+}
+/**
+ * Create an MCP server from a Better UI tool registry.
+ *
+ * @example
+ * ```typescript
+ * const server = createMCPServer({
+ *   name: 'my-app',
+ *   version: '1.0.0',
+ *   tools: { weather: weatherTool, search: searchTool },
+ * });
+ *
+ * // For stdio transport (Claude Desktop, etc.)
+ * server.start();
+ * ```
+ */
+declare function createMCPServer(config: MCPServerConfig): MCPServer;
+
+/**
+ * Lightweight Zod-to-JSON-Schema converter.
+ * Handles common Zod types without requiring zod-to-json-schema dependency.
+ */
+
+interface JsonSchema {
+    type?: string;
+    properties?: Record<string, JsonSchema>;
+    required?: string[];
+    items?: JsonSchema;
+    enum?: unknown[];
+    description?: string;
+    default?: unknown;
+    minimum?: number;
+    maximum?: number;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    format?: string;
+    anyOf?: JsonSchema[];
+    oneOf?: JsonSchema[];
+    nullable?: boolean;
+    additionalProperties?: boolean | JsonSchema;
+    [key: string]: unknown;
+}
+declare function zodToJsonSchema(schema: z.ZodType): JsonSchema;
+
+export { MCPServer, type MCPServerConfig, createMCPServer, zodToJsonSchema };

package/dist/mcp/index.js

@@ -0,0 +1,413 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/mcp/index.ts
+var mcp_exports = {};
+__export(mcp_exports, {
+  MCPServer: () => MCPServer,
+  createMCPServer: () => createMCPServer,
+  zodToJsonSchema: () => zodToJsonSchema
+});
+module.exports = __toCommonJS(mcp_exports);
+
+// src/mcp/schema.ts
+function zodToJsonSchema(schema) {
+  return convert(schema);
+}
+function convert(schema) {
+  const def = schema._def;
+  const typeName = def?.typeName;
+  switch (typeName) {
+    case "ZodString":
+      return convertString(def);
+    case "ZodNumber":
+      return convertNumber(def);
+    case "ZodBoolean":
+      return { type: "boolean" };
+    case "ZodNull":
+      return { type: "null" };
+    case "ZodLiteral":
+      return { enum: [def.value] };
+    case "ZodEnum":
+      return { type: "string", enum: def.values };
+    case "ZodNativeEnum":
+      return { enum: Object.values(def.values) };
+    case "ZodObject":
+      return convertObject(def);
+    case "ZodArray":
+      return convertArray(def);
+    case "ZodOptional":
+      return convert(def.innerType);
+    case "ZodNullable": {
+      const inner = convert(def.innerType);
+      return { anyOf: [inner, { type: "null" }] };
+    }
+    case "ZodDefault":
+      return { ...convert(def.innerType), default: def.defaultValue() };
+    case "ZodUnion":
+      return { anyOf: def.options.map((o) => convert(o)) };
+    case "ZodDiscriminatedUnion":
+      return { oneOf: [...def.options.values()].map((o) => convert(o)) };
+    case "ZodRecord":
+      return {
+        type: "object",
+        additionalProperties: convert(def.valueType)
+      };
+    case "ZodTuple": {
+      const items = def.items.map((item) => convert(item));
+      return { type: "array", items: items.length === 1 ? items[0] : void 0, prefixItems: items };
+    }
+    case "ZodEffects":
+      return convert(def.schema);
+    case "ZodPipeline":
+      return convert(def.in);
+    case "ZodLazy":
+      return convert(def.getter());
+    case "ZodAny":
+      return {};
+    case "ZodUnknown":
+      return {};
+    default:
+      return {};
+  }
+}
+function convertString(def) {
+  const schema = { type: "string" };
+  if (def.checks) {
+    for (const check of def.checks) {
+      switch (check.kind) {
+        case "min":
+          schema.minLength = check.value;
+          break;
+        case "max":
+          schema.maxLength = check.value;
+          break;
+        case "email":
+          schema.format = "email";
+          break;
+        case "url":
+          schema.format = "uri";
+          break;
+        case "uuid":
+          schema.format = "uuid";
+          break;
+        case "regex":
+          schema.pattern = check.regex.source;
+          break;
+      }
+    }
+  }
+  if (def.description) schema.description = def.description;
+  return schema;
+}
+function convertNumber(def) {
+  const schema = { type: "number" };
+  if (def.checks) {
+    for (const check of def.checks) {
+      switch (check.kind) {
+        case "min":
+          schema.minimum = check.value;
+          if (check.inclusive === false) schema.exclusiveMinimum = check.value;
+          break;
+        case "max":
+          schema.maximum = check.value;
+          if (check.inclusive === false) schema.exclusiveMaximum = check.value;
+          break;
+        case "int":
+          schema.type = "integer";
+          break;
+      }
+    }
+  }
+  if (def.description) schema.description = def.description;
+  return schema;
+}
+function convertObject(def) {
+  const shape = def.shape();
+  const properties = {};
+  const required = [];
+  for (const [key, value] of Object.entries(shape)) {
+    properties[key] = convert(value);
+    const fieldDef = value._def;
+    const isOptional = fieldDef?.typeName === "ZodOptional" || fieldDef?.typeName === "ZodDefault";
+    if (!isOptional) {
+      required.push(key);
+    }
+  }
+  const schema = { type: "object", properties };
+  if (required.length > 0) schema.required = required;
+  if (def.description) schema.description = def.description;
+  return schema;
+}
+function convertArray(def) {
+  const schema = {
+    type: "array",
+    items: convert(def.type)
+  };
+  if (def.minLength) schema.minItems = def.minLength.value;
+  if (def.maxLength) schema.maxItems = def.maxLength.value;
+  if (def.description) schema.description = def.description;
+  return schema;
+}
+
+// src/mcp/server.ts
+var PARSE_ERROR = -32700;
+var INVALID_REQUEST = -32600;
+var METHOD_NOT_FOUND = -32601;
+var INVALID_PARAMS = -32602;
+var INTERNAL_ERROR = -32603;
+var MCPServer = class {
+  constructor(config) {
+    this.initialized = false;
+    this.running = false;
+    this.config = config;
+  }
+  /** Start listening on stdin for JSON-RPC messages */
+  start() {
+    if (this.running) return;
+    this.running = true;
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+    stdin.setEncoding("utf-8");
+    let buffer = "";
+    stdin.on("data", (chunk) => {
+      buffer += chunk;
+      let newlineIdx;
+      while ((newlineIdx = buffer.indexOf("\n")) !== -1) {
+        const line = buffer.slice(0, newlineIdx).trim();
+        buffer = buffer.slice(newlineIdx + 1);
+        if (!line) continue;
+        this.handleLine(line).then((response) => {
+          if (response) {
+            stdout.write(JSON.stringify(response) + "\n");
+          }
+        }).catch((err) => {
+          const errorResponse = {
+            jsonrpc: "2.0",
+            id: null,
+            error: { code: INTERNAL_ERROR, message: err.message }
+          };
+          stdout.write(JSON.stringify(errorResponse) + "\n");
+          this.config.onError?.(err instanceof Error ? err : new Error(String(err)));
+        });
+      }
+    });
+    stdin.on("end", () => {
+      this.running = false;
+    });
+    this.config.onStart?.();
+  }
+  /** Stop the server */
+  stop() {
+    this.running = false;
+  }
+  /** Handle a single JSON-RPC message. Returns a response or null for notifications. */
+  async handleMessage(message) {
+    if (message.id === void 0 || message.id === null) {
+      if (message.method === "notifications/initialized") {
+      }
+      return null;
+    }
+    switch (message.method) {
+      case "initialize":
+        return this.handleInitialize(message);
+      case "tools/list":
+        return this.handleToolsList(message);
+      case "tools/call":
+        return this.handleToolsCall(message);
+      case "ping":
+        return { jsonrpc: "2.0", id: message.id, result: {} };
+      default:
+        return {
+          jsonrpc: "2.0",
+          id: message.id,
+          error: { code: METHOD_NOT_FOUND, message: `Method not found: ${message.method}` }
+        };
+    }
+  }
+  /** Get all tools as MCP tool schemas */
+  listTools() {
+    return Object.values(this.config.tools).map((tool) => ({
+      name: tool.name,
+      description: tool.description || tool.name,
+      inputSchema: zodToJsonSchema(tool.inputSchema)
+    }));
+  }
+  /** Execute a tool by name */
+  async callTool(name, args) {
+    if (!Object.prototype.hasOwnProperty.call(this.config.tools, name)) {
+      throw new McpError(INVALID_PARAMS, `Unknown tool: ${name}`);
+    }
+    const tool = this.config.tools[name];
+    try {
+      const result = await tool.run(args, {
+        isServer: true,
+        ...this.config.context
+      });
+      const text = typeof result === "string" ? result : JSON.stringify(result, null, 2);
+      return { content: [{ type: "text", text }] };
+    } catch (error) {
+      if (error instanceof Error && error.name === "ZodError") {
+        throw new McpError(INVALID_PARAMS, `Invalid input: ${error.message}`);
+      }
+      throw error;
+    }
+  }
+  // ─── Private ─────────────────────────────────────────────────────────────
+  async handleLine(line) {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return {
+        jsonrpc: "2.0",
+        id: null,
+        error: { code: PARSE_ERROR, message: "Parse error" }
+      };
+    }
+    if (!message.jsonrpc || message.jsonrpc !== "2.0") {
+      return {
+        jsonrpc: "2.0",
+        id: message.id ?? null,
+        error: { code: INVALID_REQUEST, message: "Invalid JSON-RPC version" }
+      };
+    }
+    return this.handleMessage(message);
+  }
+  handleInitialize(message) {
+    this.initialized = true;
+    return {
+      jsonrpc: "2.0",
+      id: message.id,
+      result: {
+        protocolVersion: "2024-11-05",
+        capabilities: {
+          tools: {}
+        },
+        serverInfo: {
+          name: this.config.name,
+          version: this.config.version
+        }
+      }
+    };
+  }
+  handleToolsList(message) {
+    return {
+      jsonrpc: "2.0",
+      id: message.id,
+      result: {
+        tools: this.listTools()
+      }
+    };
+  }
+  async handleToolsCall(message) {
+    const params = message.params;
+    const toolName = params?.name;
+    const args = params?.arguments ?? {};
+    if (!toolName) {
+      return {
+        jsonrpc: "2.0",
+        id: message.id,
+        error: { code: INVALID_PARAMS, message: "Missing tool name" }
+      };
+    }
+    try {
+      const result = await this.callTool(toolName, args);
+      return {
+        jsonrpc: "2.0",
+        id: message.id,
+        result
+      };
+    } catch (error) {
+      if (error instanceof McpError) {
+        return {
+          jsonrpc: "2.0",
+          id: message.id,
+          error: { code: error.code, message: error.message }
+        };
+      }
+      return {
+        jsonrpc: "2.0",
+        id: message.id,
+        result: {
+          content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : "Unknown error"}` }],
+          isError: true
+        }
+      };
+    }
+  }
+  /**
+   * Create a Web Request handler for HTTP-based MCP transport.
+   * Compatible with Next.js route handlers, Deno, Bun, Cloudflare Workers, etc.
+   *
+   * @example
+   * ```typescript
+   * // Next.js route: app/api/mcp/route.ts
+   * import { server } from '@/lib/mcp';
+   * export const POST = server.httpHandler();
+   * ```
+   */
+  httpHandler() {
+    return async (req) => {
+      const contentType = req.headers.get("content-type") || "";
+      if (!contentType.includes("application/json")) {
+        return Response.json(
+          { jsonrpc: "2.0", id: null, error: { code: PARSE_ERROR, message: "Content-Type must be application/json" } },
+          { status: 400 }
+        );
+      }
+      let message;
+      try {
+        message = await req.json();
+      } catch {
+        return Response.json(
+          { jsonrpc: "2.0", id: null, error: { code: PARSE_ERROR, message: "Parse error" } },
+          { status: 400 }
+        );
+      }
+      if (!message.jsonrpc || message.jsonrpc !== "2.0") {
+        return Response.json(
+          { jsonrpc: "2.0", id: message.id ?? null, error: { code: INVALID_REQUEST, message: "Invalid JSON-RPC version" } },
+          { status: 400 }
+        );
+      }
+      const response = await this.handleMessage(message);
+      if (!response) {
+        return new Response(null, { status: 204 });
+      }
+      return Response.json(response);
+    };
+  }
+};
+var McpError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "McpError";
+  }
+};
+function createMCPServer(config) {
+  return new MCPServer(config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MCPServer,
+  createMCPServer,
+  zodToJsonSchema
+});