@pixerate/editor 0.53.0 → 0.55.0

package/dist/bridge/index.d.cts

@@ -0,0 +1,65 @@
+import { M as McpServer } from '../bridge-client-C5OziCRK.cjs';
+export { T as TOOL_BRIDGE_DEFAULT_PORT, a as TOOL_BRIDGE_PROTOCOL } from '../bridge-client-C5OziCRK.cjs';
+import { T as ToolRegistry } from '../registry-DIpIaCkH.cjs';
+import '../schema-Di0CS6Pe.cjs';
+
+interface ToolBridgeOptions {
+    /** The MCP server's name. */
+    name: string;
+    version?: string;
+    /** Said to the model in the MCP `initialize` result, before the bridge's own usage notes. */
+    instructions?: string;
+    /** WebSocket port editors connect to (default 4477; 0 picks a free one). */
+    port?: number;
+    /** Shared secret pages must send as `?token=`. Recommended: any local page can otherwise connect. */
+    token?: string;
+    /** Browser origins allowed besides localhost ones (e.g. "https://app.example.com"). */
+    origins?: readonly string[];
+    /** How long a page has to answer a call (ms, default 60 000). */
+    timeoutMs?: number;
+    /**
+     * While another process holds the port, how often to try again (ms, default 2000; 0 never).
+     * Until it gets the port, tools say why.
+     */
+    retryMs?: number;
+    /**
+     * Where MCP messages come from and go to. Default: stdio (one JSON message per line on
+     * stdin / stdout). `false` serves no transport; call `bridge.mcp.handle` yourself.
+     */
+    stdio?: {
+        input: NodeJS.ReadableStream;
+        output: NodeJS.WritableStream;
+    } | false;
+    /** Diagnostics (default: stderr, since stdout carries MCP). */
+    log?: (message: string) => void;
+}
+/** An editor as `list_editors` reports it. */
+interface ToolBridgeEditorInfo {
+    id: string;
+    name: string;
+    kind?: string;
+    tools: number;
+    /** Seconds since the editor last connected or answered a call. */
+    idleSeconds: number;
+}
+interface ToolBridge {
+    /** The WebSocket port editors connect to. */
+    readonly port: number;
+    /** The MCP server (handle messages yourself when `stdio` is false). */
+    readonly mcp: McpServer;
+    /** The registry the MCP server serves: `list_editors` plus every tool the pages expose. */
+    readonly registry: ToolRegistry;
+    /** The connected editors. */
+    editors(): ToolBridgeEditorInfo[];
+    /** Stops listening, disconnects editors, fails pending calls and closes MCP. */
+    close(): Promise<void>;
+}
+/** Whether a browser origin is this machine (localhost, 127.0.0.1, [::1], *.localhost). */
+declare function isLocalOrigin(origin: string): boolean;
+/**
+ * Starts a bridge: listens for editors on 127.0.0.1 and serves their tools, plus
+ * `list_editors`, over MCP. Resolves once the port is bound (or known to be taken).
+ */
+declare function createToolBridge(options: ToolBridgeOptions): Promise<ToolBridge>;
+
+export { type ToolBridge, type ToolBridgeEditorInfo, type ToolBridgeOptions, createToolBridge, isLocalOrigin };

package/dist/bridge/index.d.ts

@@ -0,0 +1,65 @@
+import { M as McpServer } from '../bridge-client-C5dRjrz5.js';
+export { T as TOOL_BRIDGE_DEFAULT_PORT, a as TOOL_BRIDGE_PROTOCOL } from '../bridge-client-C5dRjrz5.js';
+import { T as ToolRegistry } from '../registry-7AZFuand.js';
+import '../schema-Di0CS6Pe.js';
+
+interface ToolBridgeOptions {
+    /** The MCP server's name. */
+    name: string;
+    version?: string;
+    /** Said to the model in the MCP `initialize` result, before the bridge's own usage notes. */
+    instructions?: string;
+    /** WebSocket port editors connect to (default 4477; 0 picks a free one). */
+    port?: number;
+    /** Shared secret pages must send as `?token=`. Recommended: any local page can otherwise connect. */
+    token?: string;
+    /** Browser origins allowed besides localhost ones (e.g. "https://app.example.com"). */
+    origins?: readonly string[];
+    /** How long a page has to answer a call (ms, default 60 000). */
+    timeoutMs?: number;
+    /**
+     * While another process holds the port, how often to try again (ms, default 2000; 0 never).
+     * Until it gets the port, tools say why.
+     */
+    retryMs?: number;
+    /**
+     * Where MCP messages come from and go to. Default: stdio (one JSON message per line on
+     * stdin / stdout). `false` serves no transport; call `bridge.mcp.handle` yourself.
+     */
+    stdio?: {
+        input: NodeJS.ReadableStream;
+        output: NodeJS.WritableStream;
+    } | false;
+    /** Diagnostics (default: stderr, since stdout carries MCP). */
+    log?: (message: string) => void;
+}
+/** An editor as `list_editors` reports it. */
+interface ToolBridgeEditorInfo {
+    id: string;
+    name: string;
+    kind?: string;
+    tools: number;
+    /** Seconds since the editor last connected or answered a call. */
+    idleSeconds: number;
+}
+interface ToolBridge {
+    /** The WebSocket port editors connect to. */
+    readonly port: number;
+    /** The MCP server (handle messages yourself when `stdio` is false). */
+    readonly mcp: McpServer;
+    /** The registry the MCP server serves: `list_editors` plus every tool the pages expose. */
+    readonly registry: ToolRegistry;
+    /** The connected editors. */
+    editors(): ToolBridgeEditorInfo[];
+    /** Stops listening, disconnects editors, fails pending calls and closes MCP. */
+    close(): Promise<void>;
+}
+/** Whether a browser origin is this machine (localhost, 127.0.0.1, [::1], *.localhost). */
+declare function isLocalOrigin(origin: string): boolean;
+/**
+ * Starts a bridge: listens for editors on 127.0.0.1 and serves their tools, plus
+ * `list_editors`, over MCP. Resolves once the port is bound (or known to be taken).
+ */
+declare function createToolBridge(options: ToolBridgeOptions): Promise<ToolBridge>;
+
+export { type ToolBridge, type ToolBridgeEditorInfo, type ToolBridgeOptions, createToolBridge, isLocalOrigin };

package/dist/bridge/index.js

@@ -0,0 +1,16 @@
+import {
+  createToolBridge,
+  isLocalOrigin
+} from "../chunk-AWKPSOSX.js";
+import {
+  TOOL_BRIDGE_DEFAULT_PORT,
+  TOOL_BRIDGE_PROTOCOL
+} from "../chunk-PTMIGXZ2.js";
+import "../chunk-4FX5ACVG.js";
+export {
+  TOOL_BRIDGE_DEFAULT_PORT,
+  TOOL_BRIDGE_PROTOCOL,
+  createToolBridge,
+  isLocalOrigin
+};
+//# sourceMappingURL=index.js.map

package/dist/bridge/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/bridge-client-C5OziCRK.d.cts

@@ -0,0 +1,148 @@
+import { T as ToolRegistry, M as McpToolDefinition, a as McpToolResult } from './registry-DIpIaCkH.cjs';
+
+/** MCP protocol revisions this server speaks, newest first. */
+declare const MCP_PROTOCOL_VERSIONS: readonly ["2025-06-18", "2025-03-26", "2024-11-05"];
+type JsonRpcId = string | number;
+interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id?: JsonRpcId | null;
+    method: string;
+    params?: Record<string, any>;
+}
+interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: JsonRpcId | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+interface JsonRpcNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params?: Record<string, unknown>;
+}
+/** Standard JSON-RPC error codes used by the server. */
+declare const JSON_RPC_ERRORS: {
+    readonly parseError: -32700;
+    readonly invalidRequest: -32600;
+    readonly methodNotFound: -32601;
+    readonly invalidParams: -32602;
+    readonly internalError: -32603;
+};
+interface McpServerOptions {
+    /** `serverInfo` sent in the `initialize` result. */
+    name: string;
+    version: string;
+    title?: string;
+    /** Usage hints for the client's model, sent in the `initialize` result. */
+    instructions?: string;
+    /**
+     * Sends server → client messages (`notifications/tools/list_changed`).
+     * Without it the server still answers requests but announces nothing.
+     */
+    send?: (message: JsonRpcNotification) => void;
+}
+interface McpServer {
+    /**
+     * Handles one client message (a JSON string or a parsed object) and
+     * resolves to the response to send back, or `null` for notifications.
+     * Never rejects.
+     */
+    handle(message: string | JsonRpcRequest): Promise<JsonRpcResponse | null>;
+    /** Whether the client has completed the `initialize` handshake. */
+    readonly initialized: boolean;
+    /** Stops list-changed notifications and aborts running tool calls. */
+    close(): void;
+}
+/**
+ * A transport-agnostic MCP server for a {@link ToolRegistry}: wire `handle`
+ * to any transport (stdio lines, a WebSocket, `postMessage`, an HTTP POST
+ * handler) and pass `send` for server → client notifications.
+ *
+ * Supports `initialize` (with protocol version negotiation), `ping`,
+ * `tools/list`, `tools/call` and `notifications/cancelled` (aborts the
+ * call's `signal`), and announces `notifications/tools/list_changed` after
+ * the client sends `notifications/initialized`. An unknown tool is a
+ * JSON-RPC `-32602` error, as the MCP spec asks; invalid arguments and
+ * handler failures are `isError` tool results the model can read and fix.
+ */
+declare function createMcpServer(registry: ToolRegistry, options: McpServerOptions): McpServer;
+
+/** Protocol version spoken between `connectToolBridge` and `createToolBridge`. */
+declare const TOOL_BRIDGE_PROTOCOL = 1;
+/** Default port the bridge listens on (127.0.0.1 only). */
+declare const TOOL_BRIDGE_DEFAULT_PORT = 4477;
+/** Editor → bridge messages. */
+type ToolBridgeEditorMessage = {
+    t: 'hello';
+    v: number;
+    name: string;
+    kind?: string;
+    tools: McpToolDefinition[];
+} | {
+    t: 'tools';
+    tools: McpToolDefinition[];
+} | {
+    t: 'result';
+    id: string;
+    result: McpToolResult;
+};
+/** Bridge → editor messages. */
+type ToolBridgeServerMessage = {
+    t: 'welcome';
+    v: number;
+    id: string;
+} | {
+    t: 'call';
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+} | {
+    t: 'cancel';
+    id: string;
+    reason?: string;
+};
+type ToolBridgeStatus = 'connecting' | 'connected' | 'disconnected' | 'closed';
+/** The parts of a WebSocket the client uses (the browser's, Node's global one, or `ws`). */
+interface ToolBridgeSocket {
+    readonly readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: 'open' | 'close' | 'error' | 'message', listener: (event: any) => void): void;
+}
+interface ConnectToolBridgeOptions {
+    /** Bridge URL (default `ws://127.0.0.1:4477`). */
+    url?: string;
+    /** The bridge's token, if it was started with one (sent as `?token=`). */
+    token?: string;
+    /** How this editor is listed to the agent (`list_editors`), e.g. "Diagram — Order flow". */
+    name: string;
+    /** What kind of editor this is ("diagram", "chart", "document"…), shown in `list_editors`. */
+    kind?: string;
+    /** Reconnect after the bridge goes away (default true), backing off up to 10 s. */
+    reconnect?: boolean;
+    /** WebSocket constructor (default: the global one). */
+    WebSocket?: new (url: string) => ToolBridgeSocket;
+    /** Called when the connection state changes. */
+    onStatus?: (status: ToolBridgeStatus, detail?: string) => void;
+}
+interface ToolBridgeConnection {
+    readonly status: ToolBridgeStatus;
+    /** The id the bridge gave this editor (`list_editors`), once connected. */
+    readonly editorId: string | null;
+    /** Disconnects and stops reconnecting; running calls are aborted. */
+    close(): void;
+}
+/**
+ * Connects a `ToolRegistry` to a local MCP bridge (`createToolBridge` /
+ * `pixerate-mcp-bridge`), so an MCP client (Claude Desktop, Claude Code, an IDE) can call
+ * the page's tools: the registry's tool list is sent on connect and whenever it changes,
+ * calls run through `registry.callTool` with an `AbortSignal` the bridge cancels, and the
+ * connection comes back after the bridge restarts.
+ */
+declare function connectToolBridge(registry: ToolRegistry, options: ConnectToolBridgeOptions): ToolBridgeConnection;
+
+export { type ConnectToolBridgeOptions as C, JSON_RPC_ERRORS as J, type McpServer as M, TOOL_BRIDGE_DEFAULT_PORT as T, TOOL_BRIDGE_PROTOCOL as a, type JsonRpcId as b, type JsonRpcNotification as c, type JsonRpcRequest as d, type JsonRpcResponse as e, MCP_PROTOCOL_VERSIONS as f, type McpServerOptions as g, type ToolBridgeConnection as h, type ToolBridgeEditorMessage as i, type ToolBridgeServerMessage as j, type ToolBridgeSocket as k, type ToolBridgeStatus as l, connectToolBridge as m, createMcpServer as n };

package/dist/bridge-client-C5dRjrz5.d.ts

@@ -0,0 +1,148 @@
+import { T as ToolRegistry, M as McpToolDefinition, a as McpToolResult } from './registry-7AZFuand.js';
+
+/** MCP protocol revisions this server speaks, newest first. */
+declare const MCP_PROTOCOL_VERSIONS: readonly ["2025-06-18", "2025-03-26", "2024-11-05"];
+type JsonRpcId = string | number;
+interface JsonRpcRequest {
+    jsonrpc: '2.0';
+    id?: JsonRpcId | null;
+    method: string;
+    params?: Record<string, any>;
+}
+interface JsonRpcResponse {
+    jsonrpc: '2.0';
+    id: JsonRpcId | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+interface JsonRpcNotification {
+    jsonrpc: '2.0';
+    method: string;
+    params?: Record<string, unknown>;
+}
+/** Standard JSON-RPC error codes used by the server. */
+declare const JSON_RPC_ERRORS: {
+    readonly parseError: -32700;
+    readonly invalidRequest: -32600;
+    readonly methodNotFound: -32601;
+    readonly invalidParams: -32602;
+    readonly internalError: -32603;
+};
+interface McpServerOptions {
+    /** `serverInfo` sent in the `initialize` result. */
+    name: string;
+    version: string;
+    title?: string;
+    /** Usage hints for the client's model, sent in the `initialize` result. */
+    instructions?: string;
+    /**
+     * Sends server → client messages (`notifications/tools/list_changed`).
+     * Without it the server still answers requests but announces nothing.
+     */
+    send?: (message: JsonRpcNotification) => void;
+}
+interface McpServer {
+    /**
+     * Handles one client message (a JSON string or a parsed object) and
+     * resolves to the response to send back, or `null` for notifications.
+     * Never rejects.
+     */
+    handle(message: string | JsonRpcRequest): Promise<JsonRpcResponse | null>;
+    /** Whether the client has completed the `initialize` handshake. */
+    readonly initialized: boolean;
+    /** Stops list-changed notifications and aborts running tool calls. */
+    close(): void;
+}
+/**
+ * A transport-agnostic MCP server for a {@link ToolRegistry}: wire `handle`
+ * to any transport (stdio lines, a WebSocket, `postMessage`, an HTTP POST
+ * handler) and pass `send` for server → client notifications.
+ *
+ * Supports `initialize` (with protocol version negotiation), `ping`,
+ * `tools/list`, `tools/call` and `notifications/cancelled` (aborts the
+ * call's `signal`), and announces `notifications/tools/list_changed` after
+ * the client sends `notifications/initialized`. An unknown tool is a
+ * JSON-RPC `-32602` error, as the MCP spec asks; invalid arguments and
+ * handler failures are `isError` tool results the model can read and fix.
+ */
+declare function createMcpServer(registry: ToolRegistry, options: McpServerOptions): McpServer;
+
+/** Protocol version spoken between `connectToolBridge` and `createToolBridge`. */
+declare const TOOL_BRIDGE_PROTOCOL = 1;
+/** Default port the bridge listens on (127.0.0.1 only). */
+declare const TOOL_BRIDGE_DEFAULT_PORT = 4477;
+/** Editor → bridge messages. */
+type ToolBridgeEditorMessage = {
+    t: 'hello';
+    v: number;
+    name: string;
+    kind?: string;
+    tools: McpToolDefinition[];
+} | {
+    t: 'tools';
+    tools: McpToolDefinition[];
+} | {
+    t: 'result';
+    id: string;
+    result: McpToolResult;
+};
+/** Bridge → editor messages. */
+type ToolBridgeServerMessage = {
+    t: 'welcome';
+    v: number;
+    id: string;
+} | {
+    t: 'call';
+    id: string;
+    name: string;
+    arguments: Record<string, unknown>;
+} | {
+    t: 'cancel';
+    id: string;
+    reason?: string;
+};
+type ToolBridgeStatus = 'connecting' | 'connected' | 'disconnected' | 'closed';
+/** The parts of a WebSocket the client uses (the browser's, Node's global one, or `ws`). */
+interface ToolBridgeSocket {
+    readonly readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    addEventListener(type: 'open' | 'close' | 'error' | 'message', listener: (event: any) => void): void;
+}
+interface ConnectToolBridgeOptions {
+    /** Bridge URL (default `ws://127.0.0.1:4477`). */
+    url?: string;
+    /** The bridge's token, if it was started with one (sent as `?token=`). */
+    token?: string;
+    /** How this editor is listed to the agent (`list_editors`), e.g. "Diagram — Order flow". */
+    name: string;
+    /** What kind of editor this is ("diagram", "chart", "document"…), shown in `list_editors`. */
+    kind?: string;
+    /** Reconnect after the bridge goes away (default true), backing off up to 10 s. */
+    reconnect?: boolean;
+    /** WebSocket constructor (default: the global one). */
+    WebSocket?: new (url: string) => ToolBridgeSocket;
+    /** Called when the connection state changes. */
+    onStatus?: (status: ToolBridgeStatus, detail?: string) => void;
+}
+interface ToolBridgeConnection {
+    readonly status: ToolBridgeStatus;
+    /** The id the bridge gave this editor (`list_editors`), once connected. */
+    readonly editorId: string | null;
+    /** Disconnects and stops reconnecting; running calls are aborted. */
+    close(): void;
+}
+/**
+ * Connects a `ToolRegistry` to a local MCP bridge (`createToolBridge` /
+ * `pixerate-mcp-bridge`), so an MCP client (Claude Desktop, Claude Code, an IDE) can call
+ * the page's tools: the registry's tool list is sent on connect and whenever it changes,
+ * calls run through `registry.callTool` with an `AbortSignal` the bridge cancels, and the
+ * connection comes back after the bridge restarts.
+ */
+declare function connectToolBridge(registry: ToolRegistry, options: ConnectToolBridgeOptions): ToolBridgeConnection;
+
+export { type ConnectToolBridgeOptions as C, JSON_RPC_ERRORS as J, type McpServer as M, TOOL_BRIDGE_DEFAULT_PORT as T, TOOL_BRIDGE_PROTOCOL as a, type JsonRpcId as b, type JsonRpcNotification as c, type JsonRpcRequest as d, type JsonRpcResponse as e, MCP_PROTOCOL_VERSIONS as f, type McpServerOptions as g, type ToolBridgeConnection as h, type ToolBridgeEditorMessage as i, type ToolBridgeServerMessage as j, type ToolBridgeSocket as k, type ToolBridgeStatus as l, connectToolBridge as m, createMcpServer as n };