@lantos1618/better-ui 0.4.1 → 0.5.0

package/dist/mcp/index.mjs

@@ -0,0 +1,386 @@
+import "../chunk-Y6FXYEAI.mjs";
+
+// 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);
+}
+export {
+  MCPServer,
+  createMCPServer,
+  zodToJsonSchema
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lantos1618/better-ui",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "A minimal, type-safe AI-first UI framework for building tools",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -31,6 +31,11 @@
       "import": "./dist/persistence/index.mjs",
       "require": "./dist/persistence/index.js"
     },
+    "./mcp": {
+      "types": "./dist/mcp/index.d.ts",
+      "import": "./dist/mcp/index.mjs",
+      "require": "./dist/mcp/index.js"
+    },
     "./theme.css": "./src/theme.css"
   },
   "files": [
@@ -55,7 +60,7 @@
   },
   "scripts": {
     "build": "npm run build:lib",
-    "build:lib": "tsup src/index.ts src/react/index.ts src/components/index.ts src/auth/index.ts src/persistence/index.ts --format cjs,esm --dts --clean --tsconfig tsconfig.lib.json",
+    "build:lib": "tsup src/index.ts src/react/index.ts src/components/index.ts src/auth/index.ts src/persistence/index.ts src/mcp/index.ts --format cjs,esm --dts --clean --tsconfig tsconfig.lib.json",
     "test": "jest",
     "type-check": "tsc --noEmit",
     "prepublishOnly": "npm run build:lib"