chatablex-web-sdk 1.0.31 → 1.0.34

package/dist/index.js

@@ -22,6 +22,10 @@ var index_exports = {};
 __export(index_exports, {
   Bridge: () => Bridge,
   ChatableX: () => ChatableX,
+  CloudAuthRequiredError: () => CloudAuthRequiredError,
+  CloudError: () => CloudError,
+  CloudQuotaExceededError: () => CloudQuotaExceededError,
+  CloudSubscriptionRequiredError: () => CloudSubscriptionRequiredError,
   SDK_VERSION: () => SDK_VERSION
 });
 module.exports = __toCommonJS(index_exports);
@@ -160,7 +164,7 @@ var Bridge = class {
 };
 
 // src/modules/tool.ts
-function createToolModule(bridge, appId) {
+function createToolModule(bridge, appId, agentLock) {
   let _info = { id: appId, name: appId, version: "1.0.0", description: "" };
   let _handler = null;
   const dispatch = async (params) => {
@@ -178,6 +182,7 @@ function createToolModule(bridge, appId) {
   bridge.addEventListener("toolExecution", async (data) => {
     const params = data;
     const requestId = params._requestId;
+    if (requestId && agentLock) agentLock._autoLock(requestId);
     const result = await dispatch(params);
     if (requestId && window.ChatableXBridge) {
       window.ChatableXBridge.postMessage(JSON.stringify({
@@ -185,6 +190,7 @@ function createToolModule(bridge, appId) {
         params: { _requestId: requestId, ...result }
       }));
     }
+    if (requestId && agentLock) agentLock._autoUnlock(requestId);
   });
   return {
     getInfo() {
@@ -357,10 +363,403 @@ function createAuthModule(bridge) {
   return new HostAuthProvider(bridge);
 }
 
+// src/modules/cloud.ts
+var CloudError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.name = "CloudError";
+    this.code = code;
+  }
+};
+var CloudAuthRequiredError = class extends CloudError {
+  constructor(message = "cloud storage requires an authenticated session") {
+    super(message, 401);
+    this.name = "CloudAuthRequiredError";
+  }
+};
+var CloudSubscriptionRequiredError = class extends CloudError {
+  constructor(message = "cloud storage requires an active subscription") {
+    super(message, 40302);
+    this.name = "CloudSubscriptionRequiredError";
+  }
+};
+var CloudQuotaExceededError = class extends CloudError {
+  constructor(usedBytes, quotaBytes, message = "storage quota exceeded") {
+    super(message, 40301);
+    this.name = "CloudQuotaExceededError";
+    this.usedBytes = usedBytes;
+    this.quotaBytes = quotaBytes;
+  }
+};
+var DEFAULT_CONTENT_TYPE = "application/octet-stream";
+function normalizeData(data) {
+  if (typeof Blob !== "undefined" && data instanceof Blob) {
+    return { body: data, size: data.size, type: data.type || "" };
+  }
+  if (typeof data === "string") {
+    const blob = new Blob([data]);
+    return { body: blob, size: blob.size, type: "" };
+  }
+  if (data instanceof ArrayBuffer) {
+    return { body: data, size: data.byteLength, type: "" };
+  }
+  if (ArrayBuffer.isView(data)) {
+    return { body: data, size: data.byteLength, type: "" };
+  }
+  throw new CloudError("unsupported upload data type", 400);
+}
+function createCloudModule(bridge, deps) {
+  const { appId, auth } = deps;
+  let resolvedBase = deps.apiBaseUrl ? stripTrailingSlash(deps.apiBaseUrl) : null;
+  function stripTrailingSlash(url) {
+    return url.replace(/\/+$/, "");
+  }
+  async function baseUrl() {
+    if (resolvedBase) return resolvedBase;
+    try {
+      const r = await bridge.sendMessage("host.getApiBaseUrl", {}, 5e3);
+      const url = typeof r === "string" ? r : r && typeof r === "object" && typeof r.base_url === "string" ? r.base_url : "";
+      if (url) {
+        resolvedBase = stripTrailingSlash(url);
+        return resolvedBase;
+      }
+    } catch {
+    }
+    throw new CloudError(
+      "cloud API base URL is not configured; pass apiBaseUrl to ChatableX.init()",
+      0
+    );
+  }
+  async function authedFetch(path, init) {
+    const token = await auth.getToken();
+    if (!token) throw new CloudAuthRequiredError();
+    const base = await baseUrl();
+    const url = `${base}${path}`;
+    const build = async () => ({
+      ...init,
+      headers: { ...init.headers ?? {}, ...await auth.getAuthHeaders() }
+    });
+    let res = await fetch(url, await build());
+    if (res.status === 401 && await auth.refresh()) {
+      res = await fetch(url, await build());
+    }
+    return res;
+  }
+  async function callApi(path, init) {
+    const res = await authedFetch(path, init);
+    let body = null;
+    try {
+      body = await res.json();
+    } catch {
+    }
+    const code = body?.code;
+    const message = body?.message || `HTTP ${res.status}`;
+    if (!res.ok || body?.success === false) {
+      if (code === 40301) {
+        const q = body?.data ?? {};
+        throw new CloudQuotaExceededError(q.used_bytes ?? 0, q.quota_bytes ?? 0, message);
+      }
+      if (code === 40302) throw new CloudSubscriptionRequiredError(message);
+      if (res.status === 401) throw new CloudAuthRequiredError(message);
+      throw new CloudError(message, code ?? res.status);
+    }
+    return body?.data ?? null;
+  }
+  function validateFileKey(fileKey) {
+    if (!fileKey || typeof fileKey !== "string") {
+      throw new CloudError("fileKey is required", 400);
+    }
+  }
+  return {
+    async upload(fileKey, data, options = {}) {
+      validateFileKey(fileKey);
+      const { body, size, type } = normalizeData(data);
+      const contentType = options.contentType || type || DEFAULT_CONTENT_TYPE;
+      const signed = await callApi("/api/storage/upload-url", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          app_id: appId,
+          file_key: fileKey,
+          content_type: contentType,
+          size_bytes: size
+        })
+      });
+      const put = await fetch(signed.upload_url, {
+        method: "PUT",
+        headers: { "Content-Type": contentType },
+        body
+      });
+      if (!put.ok) {
+        throw new CloudError(`OSS upload failed: HTTP ${put.status}`, put.status);
+      }
+      return { fileKey, objectKey: signed.object_key, size, contentType };
+    },
+    async getDownloadUrl(fileKey) {
+      validateFileKey(fileKey);
+      const signed = await callApi("/api/storage/download-url", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ app_id: appId, file_key: fileKey })
+      });
+      return signed.download_url;
+    },
+    async download(fileKey) {
+      const url = await this.getDownloadUrl(fileKey);
+      const res = await fetch(url, { method: "GET" });
+      if (!res.ok) {
+        throw new CloudError(`OSS download failed: HTTP ${res.status}`, res.status);
+      }
+      return res.blob();
+    },
+    async list(options = {}) {
+      const qs = new URLSearchParams({ app_id: appId });
+      if (options.prefix) qs.set("prefix", options.prefix);
+      const data = await callApi(`/api/storage/files?${qs.toString()}`, {
+        method: "GET"
+      });
+      return (data?.files ?? []).map((f) => ({
+        fileKey: f.file_key,
+        size: f.size,
+        lastModified: f.last_modified
+      }));
+    },
+    async delete(fileKey) {
+      validateFileKey(fileKey);
+      const qs = new URLSearchParams({ app_id: appId, file_key: fileKey });
+      await callApi(`/api/storage/files?${qs.toString()}`, { method: "DELETE" });
+    },
+    async usage() {
+      const data = await callApi("/api/storage/usage", { method: "GET" });
+      return {
+        usedBytes: data.used_bytes,
+        quotaBytes: data.quota_bytes,
+        fileCount: data.file_count,
+        reconciledAt: data.reconciled_at
+      };
+    }
+  };
+}
+
+// src/assets/bee.png
+var bee_default = "data:image/png;base64,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";
+
+// src/modules/agentLock.ts
+var DEFAULT_CONFIG = {
+  enabled: true,
+  mode: "overlay",
+  logoUrl: "",
+  message: "Agent \u6B63\u5728\u64CD\u4F5C\uFF0C\u8BF7\u7A0D\u5019\u2026",
+  allowCancel: true,
+  opacity: 0.3,
+  timeout: 3e4,
+  debounceUnlock: 200
+};
+var OVERLAY_ID = "__chatablex_agent_lock_overlay__";
+var BLOCKED_EVENTS = [
+  "mousedown",
+  "mouseup",
+  "click",
+  "dblclick",
+  "contextmenu",
+  "keydown",
+  "keyup",
+  "keypress",
+  "touchstart",
+  "touchmove",
+  "touchend",
+  "wheel",
+  "scroll",
+  "pointerdown",
+  "pointerup"
+];
+var CANCEL_BTN_ID = "__ctx_agent_lock_cancel__";
+function blockEvent(e) {
+  const target = e.target;
+  if (target?.id === CANCEL_BTN_ID) return;
+  e.stopPropagation();
+  e.preventDefault();
+}
+function createAgentLockModule(_bridge, userConfig = {}) {
+  const cfg = { ...DEFAULT_CONFIG, ...userConfig };
+  const logoSrc = cfg.logoUrl || bee_default;
+  const listeners = /* @__PURE__ */ new Map();
+  let overlayEl = null;
+  let locked = false;
+  let lockCount = 0;
+  let timeoutTimer = null;
+  let debounceTimer = null;
+  let currentMessage = cfg.message;
+  function emit(event, data = {}) {
+    const payload = { timestamp: Date.now(), ...data };
+    const handlers = listeners.get(event);
+    if (handlers) {
+      for (const fn of handlers) {
+        try {
+          fn(payload);
+        } catch (e) {
+          console.error("[ChatableX AgentLock] event handler error:", e);
+        }
+      }
+    }
+  }
+  function injectOverlay(message) {
+    if (typeof document === "undefined") return;
+    if (document.getElementById(OVERLAY_ID)) return;
+    const el = document.createElement("div");
+    el.id = OVERLAY_ID;
+    el.setAttribute("aria-hidden", "true");
+    el.style.cssText = [
+      "position:fixed",
+      "inset:0",
+      `z-index:2147483646`,
+      `background:rgba(255,255,255,${cfg.opacity})`,
+      "display:flex",
+      "flex-direction:column",
+      "align-items:center",
+      "justify-content:center",
+      "pointer-events:all",
+      "user-select:none",
+      "backdrop-filter:blur(1px)",
+      "-webkit-backdrop-filter:blur(1px)"
+    ].join(";");
+    el.innerHTML = `
+      <img src="${logoSrc}" alt="" style="width:48px;height:48px;animation:__ctx_spin 1.5s linear infinite;" />
+      <p style="margin:12px 0 0;font:14px/1.4 -apple-system,BlinkMacSystemFont,sans-serif;color:#666;">${message}</p>
+      ${cfg.allowCancel ? '<button id="__ctx_agent_lock_cancel__" style="margin-top:16px;background:none;border:none;color:#6366f1;font:13px -apple-system,BlinkMacSystemFont,sans-serif;cursor:pointer;text-decoration:underline;padding:4px 8px;">\u53D6\u6D88</button>' : ""}
+    `;
+    if (!document.getElementById("__ctx_agent_lock_style__")) {
+      const style = document.createElement("style");
+      style.id = "__ctx_agent_lock_style__";
+      style.textContent = "@keyframes __ctx_spin{from{transform:rotate(0deg)}to{transform:rotate(360deg)}}";
+      document.head.appendChild(style);
+    }
+    for (const evt of BLOCKED_EVENTS) {
+      el.addEventListener(evt, blockEvent, { capture: true, passive: false });
+    }
+    if (cfg.allowCancel) {
+      queueMicrotask(() => {
+        const btn = el.querySelector("#__ctx_agent_lock_cancel__");
+        if (btn) {
+          btn.addEventListener("click", (e) => {
+            e.stopPropagation();
+            handleCancel();
+          });
+        }
+      });
+    }
+    document.body.appendChild(el);
+    overlayEl = el;
+  }
+  function removeOverlay() {
+    if (overlayEl) {
+      for (const evt of BLOCKED_EVENTS) {
+        overlayEl.removeEventListener(evt, blockEvent, { capture: true });
+      }
+      overlayEl.remove();
+      overlayEl = null;
+    }
+    const style = typeof document !== "undefined" ? document.getElementById("__ctx_agent_lock_style__") : null;
+    if (style) style.remove();
+  }
+  function startTimeout(ms, requestId) {
+    clearTimeoutTimer();
+    if (ms <= 0) return;
+    timeoutTimer = setTimeout(() => {
+      console.warn("[ChatableX] Agent lock timeout \u2014 auto-unlocking");
+      forceUnlock();
+      emit("timeout", { requestId });
+    }, ms);
+  }
+  function clearTimeoutTimer() {
+    if (timeoutTimer !== null) {
+      clearTimeout(timeoutTimer);
+      timeoutTimer = null;
+    }
+  }
+  function clearDebounceTimer() {
+    if (debounceTimer !== null) {
+      clearTimeout(debounceTimer);
+      debounceTimer = null;
+    }
+  }
+  function doLock(message, timeout, requestId) {
+    if (locked) return;
+    locked = true;
+    currentMessage = message;
+    if (cfg.mode === "overlay") {
+      injectOverlay(currentMessage);
+    }
+    startTimeout(timeout, requestId);
+    emit("lock", { requestId });
+  }
+  function forceUnlock(requestId) {
+    if (!locked) return;
+    locked = false;
+    lockCount = 0;
+    clearTimeoutTimer();
+    clearDebounceTimer();
+    if (cfg.mode === "overlay") {
+      removeOverlay();
+    }
+    emit("unlock", { requestId });
+  }
+  function handleCancel() {
+    const rid = void 0;
+    forceUnlock(rid);
+    emit("cancel", { requestId: rid });
+  }
+  function lock(opts) {
+    if (!cfg.enabled) return;
+    const msg = opts?.message ?? cfg.message;
+    const timeout = opts?.timeout ?? cfg.timeout;
+    doLock(msg, timeout);
+  }
+  function unlock() {
+    forceUnlock();
+  }
+  function isLocked() {
+    return locked;
+  }
+  function on(event, handler) {
+    if (!listeners.has(event)) listeners.set(event, /* @__PURE__ */ new Set());
+    listeners.get(event).add(handler);
+    return () => off(event, handler);
+  }
+  function off(event, handler) {
+    listeners.get(event)?.delete(handler);
+  }
+  function _autoLock(requestId) {
+    if (!cfg.enabled) return;
+    clearDebounceTimer();
+    lockCount++;
+    if (!locked) {
+      doLock(cfg.message, cfg.timeout, requestId);
+    }
+  }
+  function _autoUnlock(requestId) {
+    if (!cfg.enabled) return;
+    lockCount = Math.max(0, lockCount - 1);
+    if (lockCount === 0) {
+      clearDebounceTimer();
+      debounceTimer = setTimeout(() => {
+        if (lockCount === 0) {
+          forceUnlock(requestId);
+        }
+      }, cfg.debounceUnlock);
+    }
+  }
+  function _destroy() {
+    forceUnlock();
+    listeners.clear();
+  }
+  return { lock, unlock, isLocked, on, off, _autoLock, _autoUnlock, _destroy };
+}
+
 // package.json
 var package_default = {
   name: "chatablex-web-sdk",
-  version: "1.0.31",
+  version: "1.0.34",
   description: "ChatableX Web SDK for AI App WebUI development. Provides bridge communication with the ChatableX Flutter client.",
   main: "dist/index.js",
   module: "dist/index.mjs",
@@ -379,8 +778,8 @@ var package_default = {
     "README.zh-CN.md"
   ],
   scripts: {
-    build: "tsup src/index.ts --format cjs,esm --dts --clean",
-    dev: "tsup src/index.ts --format cjs,esm --dts --watch",
+    build: "tsup",
+    dev: "tsup --watch",
     typecheck: "tsc --noEmit",
     test: "vitest run",
     "test:watch": "vitest",
@@ -450,8 +849,10 @@ var ChatableX = {
     } catch {
       if (debug) console.warn("[ChatableX] sdk_init handshake failed, continuing with defaults");
     }
-    const toolModule = createToolModule(bridge, config.appId);
+    const agentLockModule = createAgentLockModule(bridge, config.agentLock);
+    const toolModule = createToolModule(bridge, config.appId, agentLockModule);
     if (toolConfig) toolModule._setInfo(toolConfig);
+    const authModule = createAuthModule(bridge);
     const sdk = {
       ai: createAIModule(bridge),
       tools: createToolsModule(bridge),
@@ -460,7 +861,13 @@ var ChatableX = {
       storage: createStorageModule(bridge),
       tool: toolModule,
       platform: createPlatformModule(bridge),
-      auth: createAuthModule(bridge)
+      auth: authModule,
+      cloud: createCloudModule(bridge, {
+        appId: config.appId,
+        auth: authModule,
+        apiBaseUrl: config.apiBaseUrl
+      }),
+      agentLock: agentLockModule
     };
     window.ChatableX = sdk;
     _instance = sdk;
@@ -483,5 +890,9 @@ var ChatableX = {
 0 && (module.exports = {
   Bridge,
   ChatableX,
+  CloudAuthRequiredError,
+  CloudError,
+  CloudQuotaExceededError,
+  CloudSubscriptionRequiredError,
   SDK_VERSION
 });