@sybil-studio-devs/sdk 0.1.0 → 0.1.1

package/dist/react/index.js

@@ -0,0 +1,542 @@
+"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/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  SybilPages: () => SybilPages,
+  useSybilPages: () => useSybilPages
+});
+module.exports = __toCommonJS(react_exports);
+
+// src/react/SybilPages.tsx
+var import_react = require("react");
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://app.sybil.studio/api/sdk/v1";
+var DEFAULT_TIMEOUT = 3e4;
+var SybilSDK = class {
+  constructor(config) {
+    if (typeof config === "string") {
+      this.apiKey = config;
+      this.baseUrl = DEFAULT_BASE_URL;
+      this.timeout = DEFAULT_TIMEOUT;
+    } else {
+      this.apiKey = config.apiKey;
+      this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
+      this.timeout = config.timeout || DEFAULT_TIMEOUT;
+    }
+    if (!this.apiKey) {
+      throw new Error("API key is required");
+    }
+    if (!this.apiKey.startsWith("sk_live_") && !this.apiKey.startsWith("sk_test_")) {
+      throw new Error("Invalid API key format. Must start with sk_live_ or sk_test_");
+    }
+    this.pages = new PagesAPI(this);
+    this.documents = new DocumentsAPI(this);
+    this.youtube = new YouTubeAPI(this);
+    this.chat = new ChatAPI(this);
+    this.analyze = new AnalyzeAPI(this);
+  }
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers = {
+      "x-api-key": this.apiKey,
+      ...options.headers
+    };
+    if (options.body && typeof options.body === "string") {
+      headers["Content-Type"] = "application/json";
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        const message = errorData.error?.message || `Request failed with status ${response.status}`;
+        throw new SybilError(message, response.status, errorData.error?.code);
+      }
+      return response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof SybilError) {
+        throw error;
+      }
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new SybilError("Request timeout", 408, "TIMEOUT");
+      }
+      throw new SybilError(
+        error instanceof Error ? error.message : "Unknown error",
+        500,
+        "UNKNOWN"
+      );
+    }
+  }
+};
+var SybilError = class extends Error {
+  constructor(message, status, code) {
+    super(message);
+    this.name = "SybilError";
+    this.status = status;
+    this.code = code;
+  }
+};
+var PagesAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.limit) searchParams.set("limit", params.limit.toString());
+    if (params.offset) searchParams.set("offset", params.offset.toString());
+    if (params.parent_id) searchParams.set("parent_id", params.parent_id);
+    if (params.is_published !== void 0) searchParams.set("is_published", params.is_published.toString());
+    const query = searchParams.toString();
+    return this.client.request(`/pages${query ? `?${query}` : ""}`);
+  }
+  async get(pageId) {
+    return this.client.request(`/pages/${pageId}`);
+  }
+  async create(params = {}) {
+    return this.client.request("/pages", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  async update(pageId, params) {
+    return this.client.request(`/pages/${pageId}`, {
+      method: "PUT",
+      body: JSON.stringify(params)
+    });
+  }
+  async delete(pageId) {
+    return this.client.request(`/pages/${pageId}`, {
+      method: "DELETE"
+    });
+  }
+  async upload(file, fileName) {
+    const formData = new FormData();
+    formData.append("file", file, fileName);
+    return this.client.request("/pages/upload", {
+      method: "POST",
+      body: formData
+    });
+  }
+  async deleteFile(filePath) {
+    return this.client.request("/pages/upload", {
+      method: "DELETE",
+      body: JSON.stringify({ filePath })
+    });
+  }
+};
+var DocumentsAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.limit) searchParams.set("limit", params.limit.toString());
+    if (params.offset) searchParams.set("offset", params.offset.toString());
+    if (params.status) searchParams.set("status", params.status);
+    if (params.fileType) searchParams.set("fileType", params.fileType);
+    if (params.search) searchParams.set("search", params.search);
+    const query = searchParams.toString();
+    return this.client.request(`/documents${query ? `?${query}` : ""}`);
+  }
+  async get(documentId, params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.includeContent) searchParams.set("includeContent", "true");
+    if (params.includeInsights === false) searchParams.set("includeInsights", "false");
+    if (params.includeMetadata === false) searchParams.set("includeMetadata", "false");
+    const query = searchParams.toString();
+    return this.client.request(`/documents/${documentId}${query ? `?${query}` : ""}`);
+  }
+  async process(file, options = {}) {
+    const formData = new FormData();
+    formData.append("file", file, options.fileName);
+    if (options.metadata) {
+      formData.append("metadata", JSON.stringify(options.metadata));
+    }
+    if (options.collectionId) {
+      formData.append("collectionId", options.collectionId);
+    }
+    return this.client.request("/documents", {
+      method: "POST",
+      body: formData
+    });
+  }
+  async status(documentId) {
+    return this.client.request(`/documents/${documentId}/status`);
+  }
+  async insights(documentId, type) {
+    const query = type ? `?type=${type}` : "";
+    return this.client.request(`/documents/${documentId}/insights${query}`);
+  }
+  async delete(documentId) {
+    return this.client.request(`/documents/${documentId}`, {
+      method: "DELETE"
+    });
+  }
+  async waitForProcessing(documentId, options = {}) {
+    const maxAttempts = options.maxAttempts || 60;
+    const interval = options.interval || 3e3;
+    for (let i = 0; i < maxAttempts; i++) {
+      const status = await this.status(documentId);
+      if (status.status === "processed" || status.status === "completed") {
+        const { document: document2 } = await this.get(documentId);
+        return document2;
+      }
+      if (status.status === "failed") {
+        throw new SybilError(status.error?.message || "Processing failed", 500, "PROCESSING_FAILED");
+      }
+      await new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    throw new SybilError("Processing timeout", 408, "TIMEOUT");
+  }
+};
+var YouTubeAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.limit) searchParams.set("limit", params.limit.toString());
+    if (params.offset) searchParams.set("offset", params.offset.toString());
+    const query = searchParams.toString();
+    return this.client.request(`/youtube${query ? `?${query}` : ""}`);
+  }
+  async process(url, options) {
+    return this.client.request("/youtube", {
+      method: "POST",
+      body: JSON.stringify({
+        url,
+        collectionId: options?.collectionId,
+        force: options?.force
+      })
+    });
+  }
+  async get(videoId, params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.includeTranscript) searchParams.set("includeTranscript", "true");
+    if (params.includeChunks) searchParams.set("includeChunks", "true");
+    if (params.includeInsights === false) searchParams.set("includeInsights", "false");
+    const query = searchParams.toString();
+    return this.client.request(`/youtube/${videoId}${query ? `?${query}` : ""}`);
+  }
+  async delete(videoId) {
+    return this.client.request(`/youtube/${videoId}`, {
+      method: "DELETE"
+    });
+  }
+};
+var ChatAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async send(paramsOrDocId, query) {
+    const params = typeof paramsOrDocId === "string" ? { documentId: paramsOrDocId, query } : paramsOrDocId;
+    return this.client.request("/chat", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  async history(documentId, limit) {
+    const searchParams = new URLSearchParams();
+    searchParams.set("documentId", documentId);
+    if (limit) searchParams.set("limit", limit.toString());
+    return this.client.request(`/chat?${searchParams.toString()}`);
+  }
+};
+var AnalyzeAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async run(paramsOrDocId, forceRefresh) {
+    const params = typeof paramsOrDocId === "string" ? { documentId: paramsOrDocId, forceRefresh } : paramsOrDocId;
+    return this.client.request("/analyze", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  async get(documentId) {
+    return this.client.request(`/analyze?documentId=${documentId}`);
+  }
+};
+function embedPage(options) {
+  const {
+    pageId,
+    apiKey,
+    container,
+    baseUrl = "https://app.sybil.studio",
+    theme = "dark",
+    readOnly = false,
+    toolbar = true,
+    minHeight = "400px",
+    maxHeight,
+    onReady,
+    onChange,
+    onSave,
+    onError
+  } = options;
+  const containerEl = typeof container === "string" ? document.querySelector(container) : container;
+  if (!containerEl) {
+    throw new Error("Container element not found");
+  }
+  const params = new URLSearchParams({
+    apiKey,
+    readOnly: readOnly.toString(),
+    toolbar: toolbar.toString(),
+    minHeight
+  });
+  if (typeof theme === "string") {
+    params.set("theme", theme);
+  } else {
+    if (theme.background) params.set("bg", theme.background);
+    if (theme.backgroundSecondary) params.set("bgSecondary", theme.backgroundSecondary);
+    if (theme.text) params.set("textColor", theme.text);
+    if (theme.textSecondary) params.set("textSecondary", theme.textSecondary);
+    if (theme.border) params.set("borderColor", theme.border);
+    if (theme.accent) params.set("accent", theme.accent);
+  }
+  const iframe = document.createElement("iframe");
+  iframe.src = `${baseUrl}/embed/pages/${pageId}?${params.toString()}`;
+  iframe.style.width = "100%";
+  iframe.style.minHeight = minHeight;
+  if (maxHeight) iframe.style.maxHeight = maxHeight;
+  iframe.style.border = "none";
+  iframe.style.borderRadius = "8px";
+  iframe.allow = "clipboard-write";
+  const handleMessage = (event) => {
+    if (event.origin !== new URL(baseUrl).origin) return;
+    switch (event.data?.type) {
+      case "sybil:page:ready":
+        onReady?.();
+        break;
+      case "sybil:page:changed":
+        onChange?.(event.data.blocks);
+        break;
+      case "sybil:page:saved":
+        onSave?.();
+        break;
+      case "sybil:page:error":
+        onError?.(new Error(event.data.error));
+        break;
+      case "sybil:content":
+        break;
+    }
+  };
+  window.addEventListener("message", handleMessage);
+  containerEl.appendChild(iframe);
+  return {
+    getContent: () => {
+      return new Promise((resolve) => {
+        const handler = (event) => {
+          if (event.data?.type === "sybil:content") {
+            window.removeEventListener("message", handler);
+            resolve(event.data.blocks);
+          }
+        };
+        window.addEventListener("message", handler);
+        iframe.contentWindow?.postMessage({ type: "sybil:getContent" }, baseUrl);
+      });
+    },
+    setContent: (blocks) => {
+      iframe.contentWindow?.postMessage({ type: "sybil:setContent", blocks }, baseUrl);
+    },
+    destroy: () => {
+      window.removeEventListener("message", handleMessage);
+      iframe.remove();
+    }
+  };
+}
+
+// src/react/SybilPages.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var SybilPages = (0, import_react.forwardRef)(function SybilPages2({
+  apiKey,
+  pageId,
+  baseUrl,
+  theme = "dark",
+  readOnly = false,
+  toolbar = true,
+  minHeight = "400px",
+  maxHeight,
+  className,
+  style,
+  onReady,
+  onChange,
+  onSave,
+  onError
+}, ref) {
+  const containerRef = (0, import_react.useRef)(null);
+  const instanceRef = (0, import_react.useRef)(null);
+  (0, import_react.useImperativeHandle)(ref, () => ({
+    getContent: async () => {
+      if (!instanceRef.current) return [];
+      return instanceRef.current.getContent();
+    },
+    setContent: (blocks) => {
+      instanceRef.current?.setContent(blocks);
+    }
+  }));
+  (0, import_react.useEffect)(() => {
+    if (!containerRef.current || !pageId || !apiKey) return;
+    instanceRef.current?.destroy();
+    instanceRef.current = embedPage({
+      pageId,
+      apiKey,
+      container: containerRef.current,
+      baseUrl,
+      theme,
+      readOnly,
+      toolbar,
+      minHeight,
+      maxHeight,
+      onReady,
+      onChange,
+      onSave,
+      onError
+    });
+    return () => {
+      instanceRef.current?.destroy();
+      instanceRef.current = null;
+    };
+  }, [pageId, apiKey, baseUrl, theme, readOnly, toolbar, minHeight, maxHeight]);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "div",
+    {
+      ref: containerRef,
+      className,
+      style: {
+        minHeight,
+        maxHeight,
+        ...style
+      }
+    }
+  );
+});
+
+// src/react/hooks.ts
+var import_react2 = require("react");
+function useSybilPages(options) {
+  const { apiKey, baseUrl } = options;
+  const [page, setPage] = (0, import_react2.useState)(null);
+  const [loading, setLoading] = (0, import_react2.useState)(false);
+  const [saving, setSaving] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const sdkRef = (0, import_react2.useRef)(null);
+  const pendingBlocksRef = (0, import_react2.useRef)(null);
+  (0, import_react2.useEffect)(() => {
+    sdkRef.current = new SybilSDK({
+      apiKey,
+      baseUrl: baseUrl ? `${baseUrl}/api/sdk/v1` : void 0
+    });
+  }, [apiKey, baseUrl]);
+  const fetchPage = (0, import_react2.useCallback)(async (pageId) => {
+    if (!sdkRef.current) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const { page: fetchedPage } = await sdkRef.current.pages.get(pageId);
+      setPage(fetchedPage);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch page"));
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const createPage = (0, import_react2.useCallback)(async (params = {}) => {
+    if (!sdkRef.current) throw new Error("SDK not initialized");
+    setLoading(true);
+    setError(null);
+    try {
+      const { page: newPage } = await sdkRef.current.pages.create(params);
+      setPage(newPage);
+      return newPage;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create page");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const updatePage = (0, import_react2.useCallback)(async (pageId, params) => {
+    if (!sdkRef.current) throw new Error("SDK not initialized");
+    setSaving(true);
+    setError(null);
+    try {
+      const { page: updatedPage } = await sdkRef.current.pages.update(pageId, params);
+      setPage(updatedPage);
+      return updatedPage;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to update page");
+      setError(error2);
+      throw error2;
+    } finally {
+      setSaving(false);
+    }
+  }, []);
+  const deletePage = (0, import_react2.useCallback)(async (pageId) => {
+    if (!sdkRef.current) throw new Error("SDK not initialized");
+    setLoading(true);
+    setError(null);
+    try {
+      await sdkRef.current.pages.delete(pageId);
+      setPage(null);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to delete page");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const setBlocks = (0, import_react2.useCallback)((blocks) => {
+    pendingBlocksRef.current = blocks;
+    setPage((prev) => prev ? { ...prev, blocks } : null);
+  }, []);
+  const save = (0, import_react2.useCallback)(async () => {
+    if (!page || !sdkRef.current || !pendingBlocksRef.current) return;
+    await updatePage(page.id, { blocks: pendingBlocksRef.current });
+    pendingBlocksRef.current = null;
+  }, [page, updatePage]);
+  return {
+    page,
+    loading,
+    saving,
+    error,
+    fetchPage,
+    createPage,
+    updatePage,
+    deletePage,
+    setBlocks,
+    save
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SybilPages,
+  useSybilPages
+});

package/dist/react/index.mjs

@@ -0,0 +1,174 @@
+import {
+  SybilSDK,
+  embedPage
+} from "../chunk-IN53AFMQ.mjs";
+
+// src/react/SybilPages.tsx
+import { useEffect, useRef, forwardRef, useImperativeHandle } from "react";
+import { jsx } from "react/jsx-runtime";
+var SybilPages = forwardRef(function SybilPages2({
+  apiKey,
+  pageId,
+  baseUrl,
+  theme = "dark",
+  readOnly = false,
+  toolbar = true,
+  minHeight = "400px",
+  maxHeight,
+  className,
+  style,
+  onReady,
+  onChange,
+  onSave,
+  onError
+}, ref) {
+  const containerRef = useRef(null);
+  const instanceRef = useRef(null);
+  useImperativeHandle(ref, () => ({
+    getContent: async () => {
+      if (!instanceRef.current) return [];
+      return instanceRef.current.getContent();
+    },
+    setContent: (blocks) => {
+      instanceRef.current?.setContent(blocks);
+    }
+  }));
+  useEffect(() => {
+    if (!containerRef.current || !pageId || !apiKey) return;
+    instanceRef.current?.destroy();
+    instanceRef.current = embedPage({
+      pageId,
+      apiKey,
+      container: containerRef.current,
+      baseUrl,
+      theme,
+      readOnly,
+      toolbar,
+      minHeight,
+      maxHeight,
+      onReady,
+      onChange,
+      onSave,
+      onError
+    });
+    return () => {
+      instanceRef.current?.destroy();
+      instanceRef.current = null;
+    };
+  }, [pageId, apiKey, baseUrl, theme, readOnly, toolbar, minHeight, maxHeight]);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ref: containerRef,
+      className,
+      style: {
+        minHeight,
+        maxHeight,
+        ...style
+      }
+    }
+  );
+});
+
+// src/react/hooks.ts
+import { useState, useCallback as useCallback2, useRef as useRef2, useEffect as useEffect2 } from "react";
+function useSybilPages(options) {
+  const { apiKey, baseUrl } = options;
+  const [page, setPage] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [saving, setSaving] = useState(false);
+  const [error, setError] = useState(null);
+  const sdkRef = useRef2(null);
+  const pendingBlocksRef = useRef2(null);
+  useEffect2(() => {
+    sdkRef.current = new SybilSDK({
+      apiKey,
+      baseUrl: baseUrl ? `${baseUrl}/api/sdk/v1` : void 0
+    });
+  }, [apiKey, baseUrl]);
+  const fetchPage = useCallback2(async (pageId) => {
+    if (!sdkRef.current) return;
+    setLoading(true);
+    setError(null);
+    try {
+      const { page: fetchedPage } = await sdkRef.current.pages.get(pageId);
+      setPage(fetchedPage);
+    } catch (err) {
+      setError(err instanceof Error ? err : new Error("Failed to fetch page"));
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const createPage = useCallback2(async (params = {}) => {
+    if (!sdkRef.current) throw new Error("SDK not initialized");
+    setLoading(true);
+    setError(null);
+    try {
+      const { page: newPage } = await sdkRef.current.pages.create(params);
+      setPage(newPage);
+      return newPage;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to create page");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const updatePage = useCallback2(async (pageId, params) => {
+    if (!sdkRef.current) throw new Error("SDK not initialized");
+    setSaving(true);
+    setError(null);
+    try {
+      const { page: updatedPage } = await sdkRef.current.pages.update(pageId, params);
+      setPage(updatedPage);
+      return updatedPage;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to update page");
+      setError(error2);
+      throw error2;
+    } finally {
+      setSaving(false);
+    }
+  }, []);
+  const deletePage = useCallback2(async (pageId) => {
+    if (!sdkRef.current) throw new Error("SDK not initialized");
+    setLoading(true);
+    setError(null);
+    try {
+      await sdkRef.current.pages.delete(pageId);
+      setPage(null);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to delete page");
+      setError(error2);
+      throw error2;
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+  const setBlocks = useCallback2((blocks) => {
+    pendingBlocksRef.current = blocks;
+    setPage((prev) => prev ? { ...prev, blocks } : null);
+  }, []);
+  const save = useCallback2(async () => {
+    if (!page || !sdkRef.current || !pendingBlocksRef.current) return;
+    await updatePage(page.id, { blocks: pendingBlocksRef.current });
+    pendingBlocksRef.current = null;
+  }, [page, updatePage]);
+  return {
+    page,
+    loading,
+    saving,
+    error,
+    fetchPage,
+    createPage,
+    updatePage,
+    deletePage,
+    setBlocks,
+    save
+  };
+}
+export {
+  SybilPages,
+  useSybilPages
+};