@nimblebrain/synapse 0.2.2 → 0.4.0

package/dist/chunk-54YIV4ZL.cjs

@@ -0,0 +1,656 @@
+'use strict';
+
+var extApps = require('@modelcontextprotocol/ext-apps');
+
+// src/connect.ts
+
+// src/content-parser.ts
+function parseToolResultParams(params) {
+  const raw = params ?? {};
+  const structuredContent = raw.structuredContent ?? null;
+  if (structuredContent != null) {
+    return { content: structuredContent, structuredContent, raw };
+  }
+  const rawContent = raw.content;
+  if (Array.isArray(rawContent)) {
+    const texts = rawContent.filter(
+      (block) => block != null && typeof block === "object" && block.type === "text" && typeof block.text === "string"
+    ).map((block) => block.text);
+    if (texts.length > 0) {
+      const joined = texts.join("");
+      try {
+        return { content: JSON.parse(joined), structuredContent: null, raw };
+      } catch {
+        return { content: joined, structuredContent: null, raw };
+      }
+    }
+    return { content: rawContent, structuredContent: null, raw };
+  }
+  if (typeof rawContent === "string") {
+    try {
+      return { content: JSON.parse(rawContent), structuredContent: null, raw };
+    } catch {
+      return { content: rawContent, structuredContent: null, raw };
+    }
+  }
+  return { content: rawContent ?? null, structuredContent: null, raw };
+}
+var EVENT_MAP = {
+  "tool-result": extApps.TOOL_RESULT_METHOD,
+  "tool-input": extApps.TOOL_INPUT_METHOD,
+  "tool-input-partial": extApps.TOOL_INPUT_PARTIAL_METHOD,
+  "tool-cancelled": extApps.TOOL_CANCELLED_METHOD,
+  "theme-changed": extApps.HOST_CONTEXT_CHANGED_METHOD,
+  teardown: extApps.RESOURCE_TEARDOWN_METHOD
+};
+function resolveEventMethod(name) {
+  return EVENT_MAP[name] ?? name;
+}
+
+// src/resize.ts
+function createResizer(send, autoResize) {
+  let destroyed = false;
+  let observer = null;
+  let rafId = null;
+  function measureAndSend() {
+    if (destroyed) return;
+    const width = document.body.scrollWidth;
+    const height = document.body.scrollHeight;
+    send("ui/notifications/size-changed", { width, height });
+  }
+  function resize(width, height) {
+    if (destroyed) return;
+    if (width !== void 0 && height !== void 0) {
+      send("ui/notifications/size-changed", { width, height });
+    } else {
+      measureAndSend();
+    }
+  }
+  if (autoResize && typeof ResizeObserver !== "undefined") {
+    observer = new ResizeObserver(() => {
+      if (destroyed) return;
+      if (rafId !== null) cancelAnimationFrame(rafId);
+      rafId = requestAnimationFrame(() => {
+        rafId = null;
+        measureAndSend();
+      });
+    });
+    observer.observe(document.body);
+  }
+  function destroy() {
+    if (destroyed) return;
+    destroyed = true;
+    if (rafId !== null) cancelAnimationFrame(rafId);
+    observer?.disconnect();
+    observer = null;
+  }
+  return { resize, measureAndSend, destroy };
+}
+
+// src/result-parser.ts
+function parseToolResult(raw) {
+  if (raw == null) {
+    return { data: null, isError: false };
+  }
+  if (isCallToolResult(raw)) {
+    return parseCallToolResult(raw);
+  }
+  return { data: raw, isError: false };
+}
+function isCallToolResult(value) {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    return false;
+  }
+  return Array.isArray(value.content);
+}
+function isTextBlock(block) {
+  if (block === null || typeof block !== "object" || Array.isArray(block)) {
+    return false;
+  }
+  const obj = block;
+  return obj.type === "text" && typeof obj.text === "string";
+}
+function parseCallToolResult(result) {
+  const isError = result.isError === true;
+  const content = result.content;
+  if (content.length === 0) {
+    return { data: null, isError };
+  }
+  const firstText = content.find(isTextBlock);
+  if (!firstText) {
+    return { data: content, isError };
+  }
+  try {
+    return { data: JSON.parse(firstText.text), isError };
+  } catch {
+    return { data: firstText.text, isError };
+  }
+}
+
+// src/transport.ts
+var SynapseTransport = class {
+  counter = 0;
+  destroyed = false;
+  pending = /* @__PURE__ */ new Map();
+  handlers = /* @__PURE__ */ new Map();
+  listener;
+  constructor() {
+    this.listener = (event) => this.handleMessage(event);
+    window.addEventListener("message", this.listener);
+  }
+  send(method, params) {
+    if (this.destroyed) return;
+    const msg = {
+      jsonrpc: "2.0",
+      method,
+      ...params !== void 0 && { params }
+    };
+    window.parent.postMessage(msg, "*");
+  }
+  request(method, params) {
+    if (this.destroyed) {
+      return Promise.reject(new Error("Transport destroyed"));
+    }
+    const id = `syn-${++this.counter}`;
+    const msg = {
+      jsonrpc: "2.0",
+      method,
+      id,
+      ...params !== void 0 && { params }
+    };
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, { resolve, reject });
+      window.parent.postMessage(msg, "*");
+    });
+  }
+  onMessage(method, callback) {
+    if (!this.handlers.has(method)) {
+      this.handlers.set(method, /* @__PURE__ */ new Set());
+    }
+    this.handlers.get(method)?.add(callback);
+    return () => {
+      const set = this.handlers.get(method);
+      if (set) {
+        set.delete(callback);
+        if (set.size === 0) {
+          this.handlers.delete(method);
+        }
+      }
+    };
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    window.removeEventListener("message", this.listener);
+    const error = new Error("Transport destroyed");
+    for (const entry of this.pending.values()) {
+      entry.reject(error);
+    }
+    this.pending.clear();
+    this.handlers.clear();
+  }
+  handleMessage(event) {
+    if (this.destroyed) return;
+    const data = event.data;
+    if (!data || data.jsonrpc !== "2.0") return;
+    if ("id" in data && data.id && !("method" in data)) {
+      const response = data;
+      const entry = this.pending.get(response.id);
+      if (!entry) return;
+      this.pending.delete(response.id);
+      if (response.error) {
+        const err = new Error(response.error.message);
+        err.code = response.error.code;
+        err.data = response.error.data;
+        entry.reject(err);
+      } else {
+        entry.resolve(response.result);
+      }
+      return;
+    }
+    if ("method" in data && !("id" in data && data.id)) {
+      const notification = data;
+      const set = this.handlers.get(notification.method);
+      if (set) {
+        for (const handler of set) {
+          handler(notification.params);
+        }
+      }
+    }
+  }
+};
+
+// src/connect.ts
+async function connect(options) {
+  const { name, version, autoResize = false } = options;
+  const transport = new SynapseTransport();
+  let destroyed = false;
+  let currentTheme = { mode: "light", tokens: {} };
+  let hostInfo = { name: "unknown", version: "unknown" };
+  let toolInfo = null;
+  let containerDimensions = null;
+  const handlers = /* @__PURE__ */ new Map();
+  const resizer = createResizer((method, params) => transport.send(method, params), autoResize);
+  resizer.measureAndSend();
+  const initParams = {
+    protocolVersion: extApps.LATEST_PROTOCOL_VERSION,
+    appInfo: { name, version },
+    appCapabilities: {}
+  };
+  const result = await transport.request(
+    extApps.INITIALIZE_METHOD,
+    initParams
+  );
+  if (result) {
+    hostInfo = {
+      name: result.hostInfo?.name ?? "unknown",
+      version: result.hostInfo?.version ?? "unknown"
+    };
+    const ctx = result.hostContext;
+    if (ctx) {
+      currentTheme = {
+        mode: ctx.theme === "dark" ? "dark" : "light",
+        tokens: ctx.styles?.variables && typeof ctx.styles.variables === "object" ? ctx.styles.variables : {}
+      };
+      if (ctx.toolInfo && typeof ctx.toolInfo === "object") {
+        toolInfo = { tool: ctx.toolInfo.tool ?? {} };
+      }
+      if (ctx.containerDimensions && typeof ctx.containerDimensions === "object") {
+        containerDimensions = ctx.containerDimensions;
+      }
+      injectCssVariables(ctx.styles?.variables);
+    }
+  }
+  transport.onMessage(extApps.HOST_CONTEXT_CHANGED_METHOD, (params) => {
+    if (destroyed || !params) return;
+    const ctx = params;
+    const mode = ctx.theme === "dark" ? "dark" : "light";
+    const variables = ctx.styles?.variables;
+    const tokens = variables && typeof variables === "object" ? variables : currentTheme.tokens;
+    currentTheme = { mode, tokens };
+    injectCssVariables(tokens);
+    const set = handlers.get(extApps.HOST_CONTEXT_CHANGED_METHOD);
+    if (set) {
+      for (const handler of set) handler(currentTheme);
+    }
+  });
+  const subscribedMethods = /* @__PURE__ */ new Set([extApps.HOST_CONTEXT_CHANGED_METHOD]);
+  function ensureTransportSub(method) {
+    if (subscribedMethods.has(method)) return;
+    subscribedMethods.add(method);
+    const isToolResult = method === extApps.TOOL_RESULT_METHOD;
+    transport.onMessage(method, (params) => {
+      if (destroyed) return;
+      const set = handlers.get(method);
+      if (!set) return;
+      for (const handler of set) {
+        if (isToolResult) {
+          handler(parseToolResultParams(params));
+        } else {
+          handler(params);
+        }
+      }
+    });
+  }
+  if (options.on) {
+    for (const [event, handler] of Object.entries(options.on)) {
+      if (typeof handler === "function") {
+        const method = resolveEventMethod(event);
+        if (!handlers.has(method)) handlers.set(method, /* @__PURE__ */ new Set());
+        handlers.get(method)?.add(handler);
+        ensureTransportSub(method);
+      }
+    }
+  }
+  transport.send(extApps.INITIALIZED_METHOD, {});
+  const app = {
+    get theme() {
+      return { ...currentTheme };
+    },
+    get hostInfo() {
+      return { ...hostInfo };
+    },
+    get toolInfo() {
+      return toolInfo;
+    },
+    get containerDimensions() {
+      return containerDimensions;
+    },
+    on(event, handler) {
+      const method = resolveEventMethod(event);
+      if (!handlers.has(method)) {
+        handlers.set(method, /* @__PURE__ */ new Set());
+      }
+      handlers.get(method)?.add(handler);
+      ensureTransportSub(method);
+      return () => {
+        const set = handlers.get(method);
+        if (set) {
+          set.delete(handler);
+          if (set.size === 0) handlers.delete(method);
+        }
+      };
+    },
+    resize(width, height) {
+      resizer.resize(width, height);
+    },
+    openLink(url) {
+      if (destroyed) return;
+      const params = { url };
+      transport.request(extApps.OPEN_LINK_METHOD, params).catch(() => {
+      });
+    },
+    updateModelContext(state, summary) {
+      if (destroyed) return;
+      const params = {
+        structuredContent: state,
+        ...summary !== void 0 && {
+          content: [{ type: "text", text: summary }]
+        }
+      };
+      transport.send("ui/update-model-context", params);
+    },
+    async callTool(toolName, args) {
+      const params = {
+        name: toolName,
+        arguments: args ?? {}
+      };
+      const raw = await transport.request(
+        "tools/call",
+        params
+      );
+      return parseToolResult(raw);
+    },
+    sendMessage(text, context) {
+      if (destroyed) return;
+      const textBlock = {
+        type: "text",
+        text,
+        ...context && { _meta: { context } }
+      };
+      const params = {
+        role: "user",
+        content: [textBlock]
+      };
+      transport.send(extApps.MESSAGE_METHOD, params);
+    },
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      resizer.destroy();
+      handlers.clear();
+      transport.destroy();
+    }
+  };
+  return app;
+}
+function injectCssVariables(vars) {
+  if (!vars || typeof vars !== "object") return;
+  for (const [k, v] of Object.entries(vars)) {
+    if (typeof k === "string" && typeof v === "string") {
+      document.documentElement.style.setProperty(k, v);
+    }
+  }
+}
+
+// src/detection.ts
+var DEFAULT_THEME = {
+  mode: "light",
+  primaryColor: "#6366f1",
+  tokens: {}
+};
+function detectHost(initResponse) {
+  const resp = initResponse;
+  const hostName = resp?.hostInfo?.name ?? "unknown";
+  const protocolVersion = resp?.protocolVersion ?? "unknown";
+  const ctx = resp?.hostContext;
+  const theme = extractTheme(ctx);
+  return {
+    isNimbleBrain: hostName === "nimblebrain",
+    serverName: hostName,
+    protocolVersion,
+    theme
+  };
+}
+function extractTheme(ctx) {
+  if (!ctx) return { ...DEFAULT_THEME };
+  const mode = ctx.theme === "light" || ctx.theme === "dark" ? ctx.theme : DEFAULT_THEME.mode;
+  const variables = ctx.styles?.variables;
+  const tokens = variables && typeof variables === "object" && !Array.isArray(variables) ? variables : {};
+  return { mode, primaryColor: DEFAULT_THEME.primaryColor, tokens };
+}
+
+// src/keyboard.ts
+var KeyboardForwarder = class {
+  listener;
+  destroyed = false;
+  constructor(transport, customKeys) {
+    const config = customKeys ?? null;
+    this.listener = (event) => {
+      if (this.destroyed) return;
+      if (this.shouldForward(event, config)) {
+        event.preventDefault();
+        transport.send("synapse/keydown", {
+          key: event.key,
+          ctrlKey: event.ctrlKey,
+          metaKey: event.metaKey,
+          shiftKey: event.shiftKey,
+          altKey: event.altKey
+        });
+      }
+    };
+    document.addEventListener("keydown", this.listener);
+  }
+  destroy() {
+    if (this.destroyed) return;
+    this.destroyed = true;
+    document.removeEventListener("keydown", this.listener);
+  }
+  shouldForward(event, config) {
+    if (config && config.length === 0) return false;
+    if (config) {
+      return config.some(
+        (k) => event.key.toLowerCase() === k.key.toLowerCase() && (k.ctrl === void 0 || event.ctrlKey === k.ctrl) && (k.meta === void 0 || event.metaKey === k.meta) && (k.shift === void 0 || event.shiftKey === k.shift) && (k.alt === void 0 || event.altKey === k.alt)
+      );
+    }
+    if (event.key === "Escape") return true;
+    if (event.ctrlKey || event.metaKey) {
+      const key = event.key.toLowerCase();
+      if (key === "c" || key === "v" || key === "x" || key === "a") return false;
+      return true;
+    }
+    return false;
+  }
+};
+
+// src/core.ts
+function createSynapse(options) {
+  const { name, version, internal = false, forwardKeys } = options;
+  const transport = new SynapseTransport();
+  let hostInfo = null;
+  let currentTheme = {
+    mode: "light",
+    primaryColor: "#6366f1",
+    tokens: {}
+  };
+  let destroyed = false;
+  let stateTimer = null;
+  let keyboard = null;
+  const initParams = {
+    protocolVersion: extApps.LATEST_PROTOCOL_VERSION,
+    appInfo: { name, version },
+    appCapabilities: {}
+  };
+  const ready = transport.request(extApps.INITIALIZE_METHOD, initParams).then((result) => {
+    hostInfo = detectHost(result);
+    currentTheme = hostInfo.theme;
+    transport.send(extApps.INITIALIZED_METHOD, {});
+    keyboard = new KeyboardForwarder(transport, forwardKeys);
+  });
+  const unsubTheme = transport.onMessage(extApps.HOST_CONTEXT_CHANGED_METHOD, (params) => {
+    if (!params) return;
+    const mode = params.theme === "dark" ? "dark" : "light";
+    const styles = params.styles;
+    const variables = styles?.variables;
+    const tokens = variables && typeof variables === "object" ? variables : currentTheme.tokens;
+    currentTheme = { mode, primaryColor: currentTheme.primaryColor, tokens };
+    for (const cb of themeCallbacks) cb(currentTheme);
+  });
+  const themeCallbacks = /* @__PURE__ */ new Set();
+  const dataCallbacks = /* @__PURE__ */ new Set();
+  const actionCallbacks = /* @__PURE__ */ new Set();
+  const unsubData = transport.onMessage("synapse/data-changed", (params) => {
+    if (!params) return;
+    const event = {
+      source: "agent",
+      server: params.server ?? "",
+      tool: params.tool ?? ""
+    };
+    for (const cb of dataCallbacks) cb(event);
+  });
+  const unsubAction = transport.onMessage("synapse/action", (params) => {
+    if (!params || typeof params.type !== "string") return;
+    const action = {
+      type: params.type,
+      payload: params.payload ?? {},
+      requiresConfirmation: params.requiresConfirmation === true,
+      label: typeof params.label === "string" ? params.label : void 0
+    };
+    for (const cb of actionCallbacks) cb(action);
+  });
+  const isNB = () => hostInfo?.isNimbleBrain === true;
+  const synapse = {
+    get ready() {
+      return ready;
+    },
+    get isNimbleBrainHost() {
+      return isNB();
+    },
+    get destroyed() {
+      return destroyed;
+    },
+    async callTool(toolName, args) {
+      const params = {
+        name: toolName,
+        arguments: args ?? {}
+      };
+      if (internal) {
+        params.server = name;
+      }
+      const raw = await transport.request("tools/call", params);
+      return parseToolResult(raw);
+    },
+    onDataChanged(callback) {
+      dataCallbacks.add(callback);
+      return () => {
+        dataCallbacks.delete(callback);
+      };
+    },
+    onAction(callback) {
+      actionCallbacks.add(callback);
+      return () => {
+        actionCallbacks.delete(callback);
+      };
+    },
+    getTheme() {
+      return { ...currentTheme };
+    },
+    onThemeChanged(callback) {
+      themeCallbacks.add(callback);
+      return () => {
+        themeCallbacks.delete(callback);
+      };
+    },
+    action(action, params) {
+      if (!isNB()) return;
+      transport.send("synapse/action", { action, ...params });
+    },
+    chat(message, context) {
+      const textBlock = {
+        type: "text",
+        text: message,
+        ...isNB() && context && { _meta: { context } }
+      };
+      const params = {
+        role: "user",
+        content: [textBlock]
+      };
+      transport.send(extApps.MESSAGE_METHOD, params);
+    },
+    setVisibleState(state, summary) {
+      if (stateTimer) clearTimeout(stateTimer);
+      stateTimer = setTimeout(() => {
+        const params = {
+          structuredContent: state,
+          ...summary !== void 0 && {
+            content: [{ type: "text", text: summary }]
+          }
+        };
+        transport.send("ui/update-model-context", params);
+        stateTimer = null;
+      }, 250);
+    },
+    saveFile(filename, content, mimeType) {
+      const data = typeof content === "string" ? content : "[Blob content not serializable]";
+      transport.send("synapse/save-file", {
+        data,
+        filename,
+        mimeType: mimeType ?? "application/octet-stream"
+      });
+    },
+    openLink(url) {
+      const params = { url };
+      transport.request(extApps.OPEN_LINK_METHOD, params).catch(() => {
+        window.open(url, "_blank", "noopener");
+      });
+    },
+    async pickFile(options2) {
+      if (!isNB()) {
+        throw new Error("pickFile is not supported in this host");
+      }
+      const result = await transport.request("synapse/pick-file", {
+        accept: options2?.accept,
+        maxSize: options2?.maxSize ?? 26214400,
+        multiple: false
+      });
+      return result ?? null;
+    },
+    async pickFiles(options2) {
+      if (!isNB()) {
+        throw new Error("pickFiles is not supported in this host");
+      }
+      const result = await transport.request("synapse/pick-file", {
+        accept: options2?.accept,
+        maxSize: options2?.maxSize ?? 26214400,
+        multiple: true
+      });
+      if (!result) return [];
+      return Array.isArray(result) ? result : [result];
+    },
+    _onMessage(method, callback) {
+      return transport.onMessage(method, callback);
+    },
+    _request(method, params) {
+      return transport.request(method, params);
+    },
+    destroy() {
+      if (destroyed) return;
+      destroyed = true;
+      if (stateTimer) clearTimeout(stateTimer);
+      keyboard?.destroy();
+      unsubTheme();
+      unsubData();
+      unsubAction();
+      themeCallbacks.clear();
+      dataCallbacks.clear();
+      actionCallbacks.clear();
+      transport.destroy();
+    }
+  };
+  return synapse;
+}
+
+exports.connect = connect;
+exports.createSynapse = createSynapse;
+//# sourceMappingURL=chunk-54YIV4ZL.cjs.map
+//# sourceMappingURL=chunk-54YIV4ZL.cjs.map