@brixel_ai/artifact-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,461 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createExecuteTask: () => createExecuteTask,
+  createMockBrixelHost: () => createMockBrixelHost,
+  executeTask: () => executeTask,
+  listenToUITaskMessages: () => listenToUITaskMessages,
+  mockContext: () => mockContext,
+  simulateBrixelInit: () => simulateBrixelInit,
+  useBrixelArtifact: () => useBrixelArtifact
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/useBrixelArtifact.ts
+var import_react = require("react");
+
+// src/executeTask.ts
+function getApiBaseUrl() {
+  if (typeof window !== "undefined") {
+    const hostname = window.location.hostname;
+    if (hostname === "localhost" || hostname === "127.0.0.1") {
+      return "http://localhost:8000/backoffice/ui-components";
+    }
+  }
+  return "https://api.brixel.ai/backoffice/ui-components";
+}
+async function executeTask(params) {
+  const { taskUuid, inputs, conversationId, apiToken, apiBaseUrl } = params;
+  const baseUrl = apiBaseUrl || getApiBaseUrl();
+  if (typeof window !== "undefined" && (window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1")) {
+    console.debug("[Brixel SDK] Using API URL:", baseUrl);
+  }
+  try {
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (apiToken) {
+      headers["Authorization"] = `Bearer ${apiToken}`;
+    }
+    if (conversationId) {
+      headers["x-conversation-id"] = conversationId;
+    }
+    const response = await fetch(`${baseUrl}/execute_task`, {
+      method: "POST",
+      headers,
+      // Include cookies as fallback if no explicit token provided
+      credentials: apiToken ? "same-origin" : "include",
+      body: JSON.stringify({
+        task_uuid: taskUuid,
+        inputs
+      })
+    });
+    const responseText = await response.text();
+    let data = null;
+    if (responseText) {
+      try {
+        data = JSON.parse(responseText);
+      } catch {
+        data = { raw: responseText };
+      }
+    }
+    if (!response.ok) {
+      return {
+        success: false,
+        error: {
+          code: data?.code || `HTTP_${response.status}`,
+          message: data?.message || `Request failed with status ${response.status}`,
+          details: data?.details || data
+        }
+      };
+    }
+    return {
+      success: true,
+      data: data ?? void 0
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: {
+        code: "NETWORK_ERROR",
+        message: error instanceof Error ? error.message : "Unknown error occurred",
+        details: error
+      }
+    };
+  }
+}
+function createExecuteTask(contextAuth) {
+  return (params) => {
+    return executeTask({
+      ...params,
+      apiToken: contextAuth?.apiToken,
+      conversationId: contextAuth?.conversationId,
+      apiBaseUrl: contextAuth?.apiBaseUrl
+    });
+  };
+}
+
+// src/useBrixelArtifact.ts
+var SDK_VERSION = "1.0.0";
+function isInIframe() {
+  try {
+    return window.self !== window.top;
+  } catch {
+    return true;
+  }
+}
+function useBrixelArtifact(options = {}) {
+  const { targetOrigin = "*", onInputsUpdate, onDestroy, debug = false } = options;
+  const [inputs, setInputs] = (0, import_react.useState)(null);
+  const [context, setContext] = (0, import_react.useState)(null);
+  const [status, setStatus] = (0, import_react.useState)("initializing");
+  const [renderMode, setRenderMode] = (0, import_react.useState)(null);
+  const [runId, setRunId] = (0, import_react.useState)(null);
+  const isEmbedded = (0, import_react.useRef)(isInIframe());
+  const parentWindow = (0, import_react.useRef)(null);
+  const hasCompleted = (0, import_react.useRef)(false);
+  const debugLog = (0, import_react.useCallback)(
+    (message, data) => {
+      if (debug) {
+        console.debug(`[BrixelSDK] ${message}`, data ?? "");
+      }
+    },
+    [debug]
+  );
+  const postToParent = (0, import_react.useCallback)(
+    (message) => {
+      if (parentWindow.current) {
+        debugLog("Sending message to parent:", message);
+        parentWindow.current.postMessage(message, targetOrigin);
+      } else {
+        debugLog("Cannot send message - no parent window");
+      }
+    },
+    [targetOrigin, debugLog]
+  );
+  const complete = (0, import_react.useCallback)(
+    (output) => {
+      if (hasCompleted.current) {
+        debugLog("Already completed, ignoring duplicate complete call");
+        return;
+      }
+      if (!runId) {
+        console.error("[BrixelSDK] Cannot complete - no runId");
+        return;
+      }
+      hasCompleted.current = true;
+      setStatus("completed");
+      postToParent({
+        type: "BRIXEL_COMPLETE",
+        payload: { runId, output }
+      });
+      debugLog("Task completed with output:", output);
+    },
+    [runId, postToParent, debugLog]
+  );
+  const cancel = (0, import_react.useCallback)(
+    (reason) => {
+      if (hasCompleted.current) {
+        debugLog("Already completed, ignoring cancel call");
+        return;
+      }
+      if (!runId) {
+        console.error("[BrixelSDK] Cannot cancel - no runId");
+        return;
+      }
+      hasCompleted.current = true;
+      setStatus("cancelled");
+      postToParent({
+        type: "BRIXEL_CANCEL",
+        payload: { runId, reason }
+      });
+      debugLog("Task cancelled:", reason);
+    },
+    [runId, postToParent, debugLog]
+  );
+  const setHeight = (0, import_react.useCallback)(
+    (height) => {
+      if (!runId) return;
+      postToParent({
+        type: "BRIXEL_RESIZE",
+        payload: { runId, height }
+      });
+      debugLog("Resize requested:", height);
+    },
+    [runId, postToParent, debugLog]
+  );
+  const log = (0, import_react.useCallback)(
+    (level, message, data) => {
+      if (!runId) return;
+      postToParent({
+        type: "BRIXEL_LOG",
+        payload: { runId, level, message, data }
+      });
+    },
+    [runId, postToParent]
+  );
+  (0, import_react.useEffect)(() => {
+    parentWindow.current = isEmbedded.current ? window.parent : window;
+    if (!isEmbedded.current) {
+      debugLog("Not in iframe, SDK will work in standalone mode (dev tools compatible)");
+    }
+    const handleMessage = (event) => {
+      const message = event.data;
+      if (!message || typeof message !== "object" || !message.type) {
+        return;
+      }
+      if (!message.type.startsWith("BRIXEL_")) {
+        return;
+      }
+      debugLog("Received message:", message);
+      switch (message.type) {
+        case "BRIXEL_INIT": {
+          const { runId: newRunId, inputs: newInputs, context: newContext, renderMode: mode } = message.payload;
+          setRunId(newRunId);
+          setInputs(newInputs);
+          setContext(newContext);
+          setRenderMode(mode);
+          setStatus("ready");
+          hasCompleted.current = false;
+          debugLog("Initialized with:", { runId: newRunId, inputs: newInputs, context: newContext });
+          break;
+        }
+        case "BRIXEL_UPDATE_INPUTS": {
+          const { inputs: updatedInputs } = message.payload;
+          setInputs((prev) => prev ? { ...prev, ...updatedInputs } : updatedInputs);
+          onInputsUpdate?.(updatedInputs);
+          debugLog("Inputs updated:", updatedInputs);
+          break;
+        }
+        case "BRIXEL_DESTROY": {
+          onDestroy?.();
+          debugLog("Destroy received");
+          break;
+        }
+        case "BRIXEL_UPDATE_THEME": {
+          const { theme } = message.payload;
+          setContext((prev) => prev ? { ...prev, theme } : prev);
+          debugLog("Theme updated:", theme);
+          break;
+        }
+        case "BRIXEL_UPDATE_LOCALE": {
+          const { locale } = message.payload;
+          setContext((prev) => prev ? { ...prev, locale } : prev);
+          debugLog("Locale updated:", locale);
+          break;
+        }
+      }
+    };
+    window.addEventListener("message", handleMessage);
+    postToParent({
+      type: "BRIXEL_READY",
+      payload: { version: SDK_VERSION }
+    });
+    debugLog("SDK initialized, READY sent");
+    return () => {
+      window.removeEventListener("message", handleMessage);
+    };
+  }, [debugLog, postToParent, onInputsUpdate, onDestroy]);
+  (0, import_react.useEffect)(() => {
+    if (!runId || !isEmbedded.current) return;
+    const resizeObserver = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        const height = entry.contentRect.height;
+        setHeight(height);
+      }
+    });
+    resizeObserver.observe(document.body);
+    return () => {
+      resizeObserver.disconnect();
+    };
+  }, [runId, setHeight]);
+  const executeTask2 = (0, import_react.useCallback)(
+    createExecuteTask({
+      apiToken: context?.apiToken,
+      conversationId: context?.conversationId,
+      apiBaseUrl: context?.apiBaseUrl
+    }),
+    [context?.apiToken, context?.conversationId, context?.apiBaseUrl]
+  );
+  return {
+    inputs,
+    context,
+    status,
+    renderMode,
+    runId,
+    complete,
+    cancel,
+    setHeight,
+    log,
+    isEmbedded: isEmbedded.current,
+    executeTask: executeTask2
+  };
+}
+
+// src/devTools.ts
+var mockContext = {
+  runId: "dev-run-001",
+  stepId: "dev-step-001",
+  userId: "dev-user-001",
+  organizationId: "dev-org-001",
+  theme: "light",
+  locale: "en-US",
+  conversationId: "dev-conversation-001"
+};
+function simulateBrixelInit(inputs, options = {}) {
+  const { runId = "dev-run-001", renderMode = "interaction", context = {}, delay = 100 } = options;
+  const message = {
+    type: "BRIXEL_INIT",
+    payload: {
+      runId,
+      inputs,
+      context: { ...mockContext, ...context, runId },
+      renderMode
+    }
+  };
+  setTimeout(() => {
+    window.postMessage(message, "*");
+    console.debug("[BrixelDevTools] Simulated INIT message sent:", message);
+  }, delay);
+}
+function listenToUITaskMessages(callback) {
+  const handleMessage = (event) => {
+    const message = event.data;
+    if (message && typeof message === "object" && message.type?.startsWith("BRIXEL_")) {
+      callback(message);
+    }
+  };
+  window.addEventListener("message", handleMessage);
+  return () => {
+    window.removeEventListener("message", handleMessage);
+  };
+}
+function createMockBrixelHost(options) {
+  const { onReady, onComplete, onCancel, onResize, onLog, onError } = options;
+  let currentRunId = null;
+  const handleMessage = (event) => {
+    const message = event.data;
+    if (!message || typeof message !== "object" || !message.type?.startsWith("BRIXEL_")) {
+      return;
+    }
+    switch (message.type) {
+      case "BRIXEL_READY":
+        onReady?.(message.payload?.version);
+        break;
+      case "BRIXEL_COMPLETE":
+        onComplete?.(message.payload?.output);
+        break;
+      case "BRIXEL_CANCEL":
+        onCancel?.(message.payload?.reason);
+        break;
+      case "BRIXEL_RESIZE":
+        onResize?.(message.payload?.height);
+        break;
+      case "BRIXEL_LOG":
+        onLog?.(message.payload?.level, message.payload?.message, message.payload?.data);
+        break;
+      case "BRIXEL_ERROR":
+        onError?.(message.payload?.error);
+        break;
+    }
+  };
+  window.addEventListener("message", handleMessage);
+  return {
+    init(inputs, runId = "mock-run-001", renderMode = "interaction") {
+      currentRunId = runId;
+      window.postMessage(
+        {
+          type: "BRIXEL_INIT",
+          payload: {
+            runId,
+            inputs,
+            context: { ...mockContext, runId },
+            renderMode
+          }
+        },
+        "*"
+      );
+    },
+    updateInputs(inputs) {
+      if (!currentRunId) {
+        console.warn("[MockHost] Cannot update inputs - no active run");
+        return;
+      }
+      window.postMessage(
+        {
+          type: "BRIXEL_UPDATE_INPUTS",
+          payload: { runId: currentRunId, inputs }
+        },
+        "*"
+      );
+    },
+    destroy() {
+      if (currentRunId) {
+        window.postMessage(
+          {
+            type: "BRIXEL_DESTROY",
+            payload: { runId: currentRunId }
+          },
+          "*"
+        );
+      }
+      window.removeEventListener("message", handleMessage);
+      currentRunId = null;
+    },
+    updateTheme(theme) {
+      if (!currentRunId) {
+        console.warn("[MockHost] Cannot update theme - no active run");
+        return;
+      }
+      window.postMessage(
+        {
+          type: "BRIXEL_UPDATE_THEME",
+          payload: { runId: currentRunId, theme }
+        },
+        "*"
+      );
+    },
+    updateLocale(locale) {
+      if (!currentRunId) {
+        console.warn("[MockHost] Cannot update locale - no active run");
+        return;
+      }
+      window.postMessage(
+        {
+          type: "BRIXEL_UPDATE_LOCALE",
+          payload: { runId: currentRunId, locale }
+        },
+        "*"
+      );
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createExecuteTask,
+  createMockBrixelHost,
+  executeTask,
+  listenToUITaskMessages,
+  mockContext,
+  simulateBrixelInit,
+  useBrixelArtifact
+});