@pixerate/editor 0.139.1 → 0.140.1

package/dist/chunk-5RRYDFU2.js

@@ -1,466 +0,0 @@
-import {
-  validateJsonSchema
-} from "./chunk-V2ZCJRDM.js";
-
-// src/tools/registry.ts
-var ToolRegistryError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "ToolRegistryError";
-    this.code = code;
-  }
-};
-var TOOL_NAMESPACE_SEPARATOR = "__";
-var TOOL_NAME_REGEX = /^[A-Za-z0-9_.-]{1,128}$/;
-var sanitizeNamespace = (id) => id.replace(/[^A-Za-z0-9_-]/g, "_");
-function readTools(provider) {
-  return typeof provider.tools === "function" ? provider.tools() : provider.tools;
-}
-function toDefinition(name, tool) {
-  const { handler: _handler, name: _name, ...rest } = tool;
-  return { name, ...rest };
-}
-function errorResult(error) {
-  const details = error.details?.length ? "\n" + error.details.map((d) => `- ${d.path}: ${d.message}`).join("\n") : "";
-  return {
-    isError: true,
-    content: [{ type: "text", text: `${error.message}${details}` }],
-    structuredContent: { error }
-  };
-}
-function toToolResult(value) {
-  if (value && typeof value === "object" && Array.isArray(value.content)) {
-    return value;
-  }
-  if (value === void 0) return { content: [] };
-  if (typeof value === "string") return { content: [{ type: "text", text: value }] };
-  const text = JSON.stringify(value);
-  const isPlainObject = typeof value === "object" && value !== null && !Array.isArray(value);
-  return {
-    content: [{ type: "text", text: text ?? String(value) }],
-    ...isPlainObject ? { structuredContent: value } : {}
-  };
-}
-var ToolRegistry = class {
-  /** MCP server capabilities this registry supports. */
-  capabilities = { tools: { listChanged: true } };
-  entries = [];
-  listeners = /* @__PURE__ */ new Set();
-  options;
-  timer = null;
-  lastSignature;
-  constructor(options = {}) {
-    this.options = {
-      onCollision: options.onCollision ?? "namespace",
-      listChangedDelayMs: options.listChangedDelayMs ?? 0,
-      validateArguments: options.validateArguments ?? true
-    };
-    this.lastSignature = this.signature();
-  }
-  /**
-   * Registers a provider and returns a function that unregisters it.
-   * Throws a {@link ToolRegistryError} for a duplicate provider id, an invalid
-   * tool name, or (with `onCollision: 'error'`) a tool name collision.
-   */
-  register(provider) {
-    if (this.entries.some((e) => e.provider.id === provider.id)) {
-      throw new ToolRegistryError("duplicate_provider", `Tool provider "${provider.id}" is already registered.`);
-    }
-    for (const tool of readTools(provider)) {
-      if (!TOOL_NAME_REGEX.test(tool.name)) {
-        throw new ToolRegistryError("invalid_tool", `Invalid tool name "${tool.name}" from provider "${provider.id}".`);
-      }
-    }
-    const entry = { provider };
-    this.entries.push(entry);
-    try {
-      const names = this.resolve(this.options.onCollision === "error").map((t) => t.name);
-      const duplicate = names.find((name, i) => names.indexOf(name) !== i);
-      if (duplicate) {
-        throw new ToolRegistryError("name_collision", `Tool name "${duplicate}" is exposed more than once.`);
-      }
-    } catch (error) {
-      this.entries.pop();
-      throw error;
-    }
-    if (provider.subscribe) {
-      entry.unsubscribe = provider.subscribe(() => this.notifyListChanged());
-    }
-    this.notifyListChanged();
-    let registered = true;
-    return () => {
-      if (!registered) return;
-      registered = false;
-      this.unregister(provider);
-    };
-  }
-  /** Removes a provider by id or instance. Returns whether it was registered. */
-  unregister(providerOrId) {
-    const index = this.entries.findIndex(
-      (e) => typeof providerOrId === "string" ? e.provider.id === providerOrId : e.provider === providerOrId
-    );
-    if (index === -1) return false;
-    const [entry] = this.entries.splice(index, 1);
-    entry.unsubscribe?.();
-    this.notifyListChanged();
-    return true;
-  }
-  /** Registered provider ids in registration order. */
-  providerIds() {
-    return this.entries.map((e) => e.provider.id);
-  }
-  /**
-   * Resolves exposed names. Tools are ordered by provider registration, then
-   * by their order within the provider.
-   */
-  resolve(throwOnCollision = false) {
-    const all = [];
-    const counts = /* @__PURE__ */ new Map();
-    for (const { provider } of this.entries) {
-      for (const tool of readTools(provider)) {
-        all.push({ name: tool.name, tool, provider });
-        if (!provider.namespace) counts.set(tool.name, (counts.get(tool.name) ?? 0) + 1);
-      }
-    }
-    for (const item of all) {
-      const prefix = item.provider.namespace ?? ((counts.get(item.name) ?? 0) > 1 ? item.provider.id : void 0);
-      if (prefix !== void 0) {
-        if (throwOnCollision && !item.provider.namespace) {
-          throw new ToolRegistryError(
-            "name_collision",
-            `Tool "${item.name}" from provider "${item.provider.id}" collides with another provider's tool.`
-          );
-        }
-        item.name = `${sanitizeNamespace(prefix)}${TOOL_NAMESPACE_SEPARATOR}${item.name}`;
-      }
-    }
-    return all;
-  }
-  /** MCP `tools/list` result for the current providers. */
-  listTools() {
-    return { tools: this.resolve().map(({ name, tool }) => toDefinition(name, tool)) };
-  }
-  /** Whether a tool with this exposed name exists. */
-  hasTool(name) {
-    return this.resolve().some((t) => t.name === name);
-  }
-  /** Looks up a tool definition by exposed name. */
-  getTool(name) {
-    const found = this.resolve().find((t) => t.name === name);
-    return found ? toDefinition(found.name, found.tool) : void 0;
-  }
-  /**
-   * Calls a tool by exposed name and returns an MCP `tools/call` result.
-   * Never rejects: unknown tools, invalid arguments and handler errors come
-   * back as `isError: true` results with a {@link ToolCallError} in
-   * `structuredContent.error` (MCP transports may map `unknown_tool` to a
-   * JSON-RPC `-32602` error instead).
-   */
-  async callTool(name, args = {}, options = {}) {
-    const found = this.resolve().find((t) => t.name === name);
-    if (!found) {
-      return errorResult({ code: "unknown_tool", message: `Unknown tool "${name}".`, tool: name });
-    }
-    const input = args ?? {};
-    if (this.options.validateArguments) {
-      const details = validateJsonSchema(input, found.tool.inputSchema);
-      if (details.length > 0) {
-        return errorResult({
-          code: "invalid_arguments",
-          message: `Invalid arguments for tool "${name}".`,
-          tool: name,
-          details
-        });
-      }
-    }
-    try {
-      const value = await found.tool.handler(input, {
-        name,
-        providerId: found.provider.id,
-        signal: options.signal
-      });
-      return toToolResult(value);
-    } catch (error) {
-      return errorResult({
-        code: "tool_failed",
-        message: error instanceof Error ? error.message : String(error),
-        tool: name
-      });
-    }
-  }
-  /**
-   * Subscribes to tool-list changes. Notifications are coalesced: many
-   * registrations or provider signals within the delay window produce one
-   * call, and none if the exposed list ends up unchanged (e.g. a provider
-   * unmounted and remounted). Returns an unsubscribe function.
-   */
-  onListChanged(listener) {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  /** Schedules a coalesced `listChanged` check; providers may call it directly. */
-  notifyListChanged() {
-    if (this.timer !== null) return;
-    this.timer = setTimeout(() => this.flush(), this.options.listChangedDelayMs);
-  }
-  /** Runs a pending `listChanged` check immediately. */
-  flush() {
-    if (this.timer !== null) {
-      clearTimeout(this.timer);
-      this.timer = null;
-    }
-    const signature = this.signature();
-    if (signature === this.lastSignature) return;
-    this.lastSignature = signature;
-    const { tools } = this.listTools();
-    for (const listener of Array.from(this.listeners)) listener(tools);
-  }
-  signature() {
-    try {
-      return JSON.stringify(this.listTools().tools);
-    } catch {
-      return String(Math.random());
-    }
-  }
-  /** Unregisters every provider and listener and cancels pending notifications. */
-  dispose() {
-    if (this.timer !== null) clearTimeout(this.timer);
-    this.timer = null;
-    for (const entry of this.entries.splice(0)) entry.unsubscribe?.();
-    this.listeners.clear();
-  }
-};
-function createToolRegistry(options) {
-  return new ToolRegistry(options);
-}
-
-// src/tools/mcp-server.ts
-var MCP_PROTOCOL_VERSIONS = ["2025-06-18", "2025-03-26", "2024-11-05"];
-var JSON_RPC_ERRORS = {
-  parseError: -32700,
-  invalidRequest: -32600,
-  methodNotFound: -32601,
-  invalidParams: -32602,
-  internalError: -32603
-};
-var errorResponse = (id, code, message, data) => ({
-  jsonrpc: "2.0",
-  id,
-  error: { code, message, ...data !== void 0 ? { data } : {} }
-});
-function createMcpServer(registry, options) {
-  let initialized = false;
-  let unsubscribe = null;
-  const running = /* @__PURE__ */ new Map();
-  const startNotifications = () => {
-    if (unsubscribe || !options.send) return;
-    const send = options.send;
-    unsubscribe = registry.onListChanged(() => send({ jsonrpc: "2.0", method: "notifications/tools/list_changed" }));
-  };
-  async function dispatch(request) {
-    const id = request.id ?? null;
-    const isNotification = request.id === void 0 || request.id === null;
-    const params = request.params ?? {};
-    switch (request.method) {
-      case "initialize": {
-        const requested = String(params.protocolVersion ?? "");
-        const protocolVersion = MCP_PROTOCOL_VERSIONS.includes(requested) ? requested : MCP_PROTOCOL_VERSIONS[0];
-        return {
-          jsonrpc: "2.0",
-          id,
-          result: {
-            protocolVersion,
-            capabilities: registry.capabilities,
-            serverInfo: { name: options.name, version: options.version, ...options.title ? { title: options.title } : {} },
-            ...options.instructions ? { instructions: options.instructions } : {}
-          }
-        };
-      }
-      case "notifications/initialized":
-        initialized = true;
-        startNotifications();
-        return null;
-      case "notifications/cancelled": {
-        const requestId = params.requestId;
-        if (requestId !== void 0) running.get(requestId)?.abort(params.reason);
-        return null;
-      }
-      case "ping":
-        return { jsonrpc: "2.0", id, result: {} };
-      case "tools/list":
-        return { jsonrpc: "2.0", id, result: registry.listTools() };
-      case "tools/call": {
-        const name = params.name;
-        if (typeof name !== "string") {
-          return errorResponse(id, JSON_RPC_ERRORS.invalidParams, 'tools/call needs a string "name".');
-        }
-        if (!registry.hasTool(name)) {
-          return errorResponse(id, JSON_RPC_ERRORS.invalidParams, `Unknown tool: ${name}`);
-        }
-        const args = params.arguments;
-        if (args !== void 0 && (typeof args !== "object" || args === null || Array.isArray(args))) {
-          return errorResponse(id, JSON_RPC_ERRORS.invalidParams, '"arguments" must be an object.');
-        }
-        const controller = new AbortController();
-        if (!isNotification) running.set(id, controller);
-        try {
-          const result = await registry.callTool(name, args ?? {}, { signal: controller.signal });
-          if (controller.signal.aborted) return null;
-          return { jsonrpc: "2.0", id, result };
-        } finally {
-          if (!isNotification) running.delete(id);
-        }
-      }
-      default:
-        if (isNotification) return null;
-        return errorResponse(id, JSON_RPC_ERRORS.methodNotFound, `Method not found: ${request.method}`);
-    }
-  }
-  return {
-    get initialized() {
-      return initialized;
-    },
-    async handle(message) {
-      let request;
-      if (typeof message === "string") {
-        try {
-          request = JSON.parse(message);
-        } catch {
-          return errorResponse(null, JSON_RPC_ERRORS.parseError, "Parse error.");
-        }
-      } else {
-        request = message;
-      }
-      if (!request || typeof request !== "object" || Array.isArray(request) || request.jsonrpc !== "2.0" || typeof request.method !== "string") {
-        const id = request && typeof request === "object" && !Array.isArray(request) ? request.id ?? null : null;
-        return errorResponse(id, JSON_RPC_ERRORS.invalidRequest, "Invalid JSON-RPC 2.0 request.");
-      }
-      try {
-        return await dispatch(request);
-      } catch (error) {
-        if (request.id === void 0 || request.id === null) return null;
-        return errorResponse(
-          request.id,
-          JSON_RPC_ERRORS.internalError,
-          error instanceof Error ? error.message : String(error)
-        );
-      }
-    },
-    close() {
-      unsubscribe?.();
-      unsubscribe = null;
-      for (const controller of running.values()) controller.abort("Server closed.");
-      running.clear();
-    }
-  };
-}
-
-// src/tools/bridge-client.ts
-var TOOL_BRIDGE_PROTOCOL = 1;
-var TOOL_BRIDGE_DEFAULT_PORT = 4477;
-function connectToolBridge(registry, options) {
-  const Ctor = options.WebSocket ?? globalThis.WebSocket;
-  if (!Ctor) throw new Error("No WebSocket implementation: pass options.WebSocket.");
-  const base = options.url ?? `ws://127.0.0.1:${TOOL_BRIDGE_DEFAULT_PORT}`;
-  const url = options.token ? `${base}${base.includes("?") ? "&" : "?"}token=${encodeURIComponent(options.token)}` : base;
-  let status = "connecting";
-  let editorId = null;
-  let socket = null;
-  let closed = false;
-  let delay = 500;
-  let retry = null;
-  const running = /* @__PURE__ */ new Map();
-  const setStatus = (next, detail) => {
-    if (next === status && !detail) return;
-    status = next;
-    options.onStatus?.(next, detail);
-  };
-  const send = (message) => {
-    if (socket && socket.readyState === 1) socket.send(JSON.stringify(message));
-  };
-  const unsubscribe = registry.onListChanged((tools) => send({ t: "tools", tools }));
-  const open = () => {
-    if (closed) return;
-    setStatus("connecting");
-    const ws = new Ctor(url);
-    socket = ws;
-    ws.addEventListener("open", () => {
-      delay = 500;
-      send({ t: "hello", v: TOOL_BRIDGE_PROTOCOL, name: options.name, ...options.kind ? { kind: options.kind } : {}, tools: registry.listTools().tools });
-    });
-    ws.addEventListener("message", (event) => {
-      let message;
-      try {
-        message = JSON.parse(String(event.data));
-      } catch {
-        return;
-      }
-      if (message.t === "welcome") {
-        editorId = message.id;
-        setStatus("connected");
-      } else if (message.t === "call") {
-        const controller = new AbortController();
-        running.set(message.id, controller);
-        void registry.callTool(message.name, message.arguments ?? {}, { signal: controller.signal }).then((result) => {
-          running.delete(message.id);
-          if (!controller.signal.aborted) send({ t: "result", id: message.id, result });
-        });
-      } else if (message.t === "cancel") {
-        running.get(message.id)?.abort(message.reason ?? "Cancelled by the agent.");
-        running.delete(message.id);
-      }
-    });
-    ws.addEventListener("close", (event) => {
-      if (socket !== ws) return;
-      socket = null;
-      editorId = null;
-      for (const controller of running.values()) controller.abort("The bridge disconnected.");
-      running.clear();
-      if (closed) return setStatus("closed");
-      setStatus("disconnected", event.reason || void 0);
-      if (options.reconnect === false) return;
-      retry = setTimeout(open, delay);
-      delay = Math.min(1e4, delay * 2);
-    });
-    ws.addEventListener("error", () => {
-    });
-  };
-  open();
-  return {
-    get status() {
-      return status;
-    },
-    get editorId() {
-      return editorId;
-    },
-    close() {
-      if (closed) return;
-      closed = true;
-      if (retry) clearTimeout(retry);
-      unsubscribe();
-      for (const controller of running.values()) controller.abort("The editor disconnected.");
-      running.clear();
-      const ws = socket;
-      socket = null;
-      ws?.close(1e3, "Editor closed.");
-      setStatus("closed");
-    }
-  };
-}
-
-export {
-  ToolRegistryError,
-  TOOL_NAMESPACE_SEPARATOR,
-  toToolResult,
-  ToolRegistry,
-  createToolRegistry,
-  MCP_PROTOCOL_VERSIONS,
-  JSON_RPC_ERRORS,
-  createMcpServer,
-  TOOL_BRIDGE_PROTOCOL,
-  TOOL_BRIDGE_DEFAULT_PORT,
-  connectToolBridge
-};