@sybil-studio-devs/sdk 0.1.0 → 0.1.1

package/dist/chunk-IN53AFMQ.mjs

@@ -0,0 +1,348 @@
+// 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();
+    }
+  };
+}
+
+export {
+  SybilSDK,
+  SybilError,
+  embedPage
+};