@lantos1618/better-ui 0.4.1 → 0.6.0

package/dist/auth/index.mjs

@@ -1,4 +1,4 @@
-import "../chunk-Y6FXYEAI.mjs";
+import "../chunk-CIESM3BP.mjs";
 
 // src/auth/jwt.ts
 function jwtAuth(options) {

package/dist/chunk-CIESM3BP.mjs

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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);
+
+export {
+  __require,
+  __esm,
+  __export,
+  __toCommonJS
+};

package/dist/chunk-XDWHMRBN.mjs

@@ -0,0 +1,159 @@
+import {
+  __esm,
+  __export
+} from "./chunk-CIESM3BP.mjs";
+
+// src/mcp/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  zodToJsonSchema: () => zodToJsonSchema
+});
+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;
+}
+var init_schema = __esm({
+  "src/mcp/schema.ts"() {
+    "use strict";
+  }
+});
+
+export {
+  zodToJsonSchema,
+  schema_exports,
+  init_schema
+};

package/dist/components/index.mjs

@@ -1,5 +1,5 @@
 "use client";
-import "../chunk-Y6FXYEAI.mjs";
+import "../chunk-CIESM3BP.mjs";
 
 // src/components/ChatProvider.tsx
 import { createContext, useContext, useCallback as useCallback2, useRef, useState, useEffect } from "react";

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import {
   __require
-} from "./chunk-Y6FXYEAI.mjs";
+} from "./chunk-CIESM3BP.mjs";
 
 // src/tool.tsx
 import { memo } from "react";

package/dist/mcp/index.d.mts

@@ -0,0 +1,157 @@
+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 a Streamable HTTP handler (MCP spec 2025-03-26).
+     * Supports both single JSON-RPC requests and SSE streaming for long-running operations.
+     * Compatible with Next.js route handlers, Deno, Bun, Cloudflare Workers.
+     *
+     * @example
+     * ```typescript
+     * // Next.js route: app/api/mcp/route.ts
+     * import { server } from '@/lib/mcp';
+     * export const POST = server.streamableHttpHandler();
+     * ```
+     */
+    streamableHttpHandler(): (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,157 @@
+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 a Streamable HTTP handler (MCP spec 2025-03-26).
+     * Supports both single JSON-RPC requests and SSE streaming for long-running operations.
+     * Compatible with Next.js route handlers, Deno, Bun, Cloudflare Workers.
+     *
+     * @example
+     * ```typescript
+     * // Next.js route: app/api/mcp/route.ts
+     * import { server } from '@/lib/mcp';
+     * export const POST = server.streamableHttpHandler();
+     * ```
+     */
+    streamableHttpHandler(): (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 };