onin-sdk 1.3.0

package/dist/index.js

@@ -0,0 +1,1538 @@
+var fe = Object.defineProperty;
+var ge = (e, t, r) => t in e ? fe(e, t, { enumerable: !0, configurable: !0, writable: !0, value: r }) : e[t] = r;
+var u = (e, t, r) => ge(e, typeof t != "symbol" ? t + "" : t, r);
+var _ = /* @__PURE__ */ ((e) => (e.Headless = "headless", e.Webview = "webview", e.Iframe = "iframe", e.Unknown = "unknown", e))(_ || {});
+function R() {
+  return typeof window < "u" && window.__TAURI_INTERNALS__ ? "webview" : typeof window < "u" && window.self !== window.top ? "iframe" : typeof Deno < "u" && Deno.core ? "headless" : "unknown";
+}
+let A = null, me = 0;
+const D = /* @__PURE__ */ new Map();
+let X = !1;
+function pe() {
+  X || (X = !0, window.addEventListener("message", (e) => {
+    const t = e.data;
+    if (!t || typeof t != "object" || !t.messageId || !D.has(t.messageId)) return;
+    const r = D.get(t.messageId);
+    D.delete(t.messageId), t.error ? r.reject(new Error(t.error)) : r.resolve(t.result);
+  }));
+}
+async function he() {
+  if (A)
+    return A;
+  const e = R();
+  if (e === _.Webview) {
+    const { invoke: t } = await import("@tauri-apps/api/core");
+    A = t;
+  } else if (e === _.Iframe)
+    pe(), A = async (t, r) => new Promise((n, s) => {
+      const i = `invoke_${++me}_${Date.now()}`;
+      D.set(i, { resolve: n, reject: s }), window.parent.postMessage({
+        type: "plugin-tauri-call",
+        messageId: i,
+        command: "invoke",
+        args: [t, r]
+      }, "*"), setTimeout(() => {
+        D.has(i) && (D.delete(i), s(new Error(`Invoke timeout for method: ${t}`)));
+      }, 3e4);
+    });
+  else if (e === _.Headless)
+    A = async (t, r) => {
+      const n = await Deno.core.ops.op_invoke(t, r);
+      if (n && typeof n == "object") {
+        if (n.type === "error")
+          throw new Error(n.error);
+        if (n.type === "ok")
+          return n.value;
+      }
+      if (n && typeof n == "object" && "error" in n)
+        throw new Error(n.error);
+      return n;
+    };
+  else
+    throw new Error("Unsupported runtime environment for invoke");
+  return A;
+}
+async function l(e, t) {
+  const r = await he();
+  if (!r)
+    throw new Error("Invoke function not loaded");
+  return r(e, t);
+}
+let k = null;
+async function _e() {
+  if (k)
+    return k;
+  const e = R();
+  if (e === _.Webview) {
+    const { listen: t } = await import("./event-DiwgtsjL.js");
+    k = t;
+  } else if (e === _.Iframe) {
+    const t = /* @__PURE__ */ new Map();
+    window.addEventListener("message", (r) => {
+      const n = r.data;
+      if (!(!n || typeof n != "object") && n.type === "plugin-event" && n.eventName) {
+        const s = t.get(n.eventName);
+        s && s.forEach((i) => {
+          i({ payload: n.payload });
+        });
+      }
+    }), k = (r, n) => {
+      const s = r.toString();
+      return t.has(s) || t.set(s, /* @__PURE__ */ new Set()), t.get(s).add(n), Promise.resolve(() => {
+        const i = t.get(s);
+        i && i.delete(n);
+      });
+    };
+  } else if (e === _.Headless)
+    k = (t, r) => t === "plugin_command_execute" ? (globalThis.__ONIN_COMMAND_HANDLER__ = r, Promise.resolve(() => {
+    })) : (console.warn(
+      `Event listening for '${t.toString()}' is not supported in headless mode.`
+    ), Promise.resolve(() => {
+    }));
+  else
+    throw new Error("Unsupported runtime environment for listen");
+  return k;
+}
+async function S(e, t) {
+  const r = await _e();
+  if (!r)
+    throw new Error("Listen function not loaded");
+  return r(e, t);
+}
+const o = {
+  /** Common errors */
+  common: {
+    UNKNOWN: "COMMON_UNKNOWN",
+    PERMISSION_DENIED: "COMMON_PERMISSION_DENIED",
+    INVALID_ARGUMENT: "COMMON_INVALID_ARGUMENT"
+  },
+  /** HTTP related errors */
+  http: {
+    NETWORK_ERROR: "HTTP_NETWORK_ERROR",
+    TIMEOUT: "HTTP_TIMEOUT",
+    HTTP_ERROR: "HTTP_HTTP_ERROR"
+    // Generic HTTP error with status code information
+  },
+  /** File system errors */
+  fs: {
+    FILE_NOT_FOUND: "FS_FILE_NOT_FOUND",
+    FILE_ACCESS_DENIED: "FS_FILE_ACCESS_DENIED",
+    DIRECTORY_NOT_FOUND: "FS_DIRECTORY_NOT_FOUND",
+    DISK_FULL: "FS_DISK_FULL",
+    FILE_ALREADY_EXISTS: "FS_FILE_ALREADY_EXISTS",
+    INVALID_PATH: "FS_INVALID_PATH",
+    READ_ONLY_FILESYSTEM: "FS_READ_ONLY_FILESYSTEM"
+  },
+  /** Clipboard errors */
+  clipboard: {
+    UNAVAILABLE: "CLIPBOARD_UNAVAILABLE",
+    FORMAT_UNSUPPORTED: "CLIPBOARD_FORMAT_UNSUPPORTED",
+    EMPTY: "CLIPBOARD_EMPTY",
+    ACCESS_DENIED: "CLIPBOARD_ACCESS_DENIED"
+  },
+  /** Dialog errors */
+  dialog: {
+    CANCELLED: "DIALOG_CANCELLED",
+    UNAVAILABLE: "DIALOG_UNAVAILABLE",
+    INVALID_OPTIONS: "DIALOG_INVALID_OPTIONS"
+  },
+  /** Storage errors */
+  storage: {
+    QUOTA_EXCEEDED: "STORAGE_QUOTA_EXCEEDED",
+    UNAVAILABLE: "STORAGE_UNAVAILABLE"
+  }
+};
+function c(e, t, r) {
+  const n = new Error(t);
+  return Object.defineProperty(n, "name", { value: "PluginError", writable: !1 }), n.code = e, n.context = r, n;
+}
+const a = {
+  /** Common error factories */
+  common: {
+    unknown: (e, t) => c(o.common.UNKNOWN, e, t),
+    permissionDenied: (e, t) => c(
+      o.common.PERMISSION_DENIED,
+      `Permission denied for ${e}`,
+      t
+    ),
+    invalidArgument: (e, t) => c(
+      o.common.INVALID_ARGUMENT,
+      `Invalid argument: ${e}`,
+      t
+    )
+  },
+  /** HTTP error factories */
+  http: {
+    networkError: (e, t) => c(o.http.NETWORK_ERROR, e, t),
+    timeout: (e, t, r) => c(
+      o.http.TIMEOUT,
+      `Request to ${e} timed out after ${t}ms`,
+      { url: e, timeout: t, ...r }
+    ),
+    httpError: (e, t, r) => c(
+      o.http.HTTP_ERROR,
+      `HTTP ${e}: ${t}`,
+      { status: e, statusText: t, ...r }
+    )
+  },
+  /** File system error factories */
+  fs: {
+    fileNotFound: (e, t) => c(
+      o.fs.FILE_NOT_FOUND,
+      `File not found: ${e}`,
+      { path: e, ...t }
+    ),
+    fileAccessDenied: (e, t) => c(
+      o.fs.FILE_ACCESS_DENIED,
+      `Access denied: ${e}`,
+      { path: e, ...t }
+    ),
+    diskFull: (e, t) => c(
+      o.fs.DISK_FULL,
+      `Disk full while accessing: ${e}`,
+      { path: e, ...t }
+    ),
+    fileAlreadyExists: (e, t) => c(
+      o.fs.FILE_ALREADY_EXISTS,
+      `File already exists: ${e}`,
+      { path: e, ...t }
+    ),
+    invalidPath: (e, t) => c(
+      o.fs.INVALID_PATH,
+      `Invalid path: ${e}`,
+      { path: e, ...t }
+    )
+  },
+  /** Clipboard error factories */
+  clipboard: {
+    unavailable: (e) => c(
+      o.clipboard.UNAVAILABLE,
+      "Clipboard is not available",
+      e
+    ),
+    formatUnsupported: (e, t) => c(
+      o.clipboard.FORMAT_UNSUPPORTED,
+      `Clipboard format not supported${e ? `: ${e}` : ""}`,
+      { format: e, ...t }
+    ),
+    empty: (e) => c(
+      o.clipboard.EMPTY,
+      "Clipboard is empty",
+      e
+    ),
+    accessDenied: (e) => c(
+      o.clipboard.ACCESS_DENIED,
+      "Clipboard access denied",
+      e
+    )
+  },
+  /** Dialog error factories */
+  dialog: {
+    cancelled: (e) => c(
+      o.dialog.CANCELLED,
+      "Dialog was cancelled by user",
+      e
+    ),
+    unavailable: (e) => c(
+      o.dialog.UNAVAILABLE,
+      "Dialog is not available",
+      e
+    ),
+    invalidOptions: (e, t) => c(
+      o.dialog.INVALID_OPTIONS,
+      `Invalid dialog options${e ? `: ${e}` : ""}`,
+      { reason: e, ...t }
+    )
+  },
+  /** Storage error factories */
+  storage: {
+    quotaExceeded: (e) => c(
+      o.storage.QUOTA_EXCEEDED,
+      "Storage quota exceeded",
+      e
+    ),
+    unavailable: (e) => c(
+      o.storage.UNAVAILABLE,
+      "Storage is not available",
+      e
+    )
+  }
+}, m = {
+  /**
+   * Checks if an error is a plugin error
+   * @param error - The error to check
+   * @returns True if the error is a PluginError
+   */
+  isPluginError: (e) => e && e.name === "PluginError" && typeof e.code == "string",
+  /**
+   * Checks if an error is of a specific type
+   * @param error - The error to check
+   * @param code - The error code to match
+   * @returns True if the error matches the specified code
+   */
+  isErrorCode: (e, t) => m.isPluginError(e) && e.code === t,
+  /**
+   * Checks if an error is one of the specified types
+   * @param error - The error to check
+   * @param codes - Array of error codes to match against
+   * @returns True if the error matches any of the specified codes
+   */
+  isOneOfErrorCodes: (e, t) => m.isPluginError(e) && t.includes(e.code),
+  /**
+   * Gets detailed information about an error
+   * @param error - The error to analyze
+   * @returns Error information object or null if not a plugin error
+   */
+  getErrorInfo: (e) => m.isPluginError(e) ? {
+    name: e.name,
+    code: e.code,
+    message: e.message,
+    context: e.context
+  } : null
+}, qt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  createError: a,
+  errorCode: o,
+  errorUtils: m
+}, Symbol.toStringTag, { value: "Module" })), Ee = [
+  // Specific network errors (high priority)
+  {
+    patterns: ["timed out", "timeout", "TIMEOUT"],
+    createError: (e, t) => a.http.timeout(
+      (t == null ? void 0 : t.url) || "unknown",
+      (t == null ? void 0 : t.timeout) || 3e4,
+      { originalError: e, ...t }
+    )
+  },
+  {
+    patterns: ["Network error", "network error", "NETWORK_ERROR", "connection refused", "connection failed"],
+    createError: (e, t) => a.http.networkError(e, { originalError: e, ...t })
+  },
+  // Generic permission errors (low priority, placed last)
+  {
+    patterns: ["Permission denied", "permission denied", "PERMISSION_DENIED"],
+    createError: (e, t) => a.common.permissionDenied(
+      `URL: ${(t == null ? void 0 : t.url) || "unknown"}`,
+      { originalError: e, ...t }
+    )
+  }
+], we = [
+  // Specific file system errors (high priority)
+  {
+    patterns: ["not found", "No such file", "FILE_NOT_FOUND", "does not exist"],
+    createError: (e, t) => a.fs.fileNotFound(
+      (t == null ? void 0 : t.path) || "unknown",
+      { originalError: e, ...t }
+    )
+  },
+  {
+    patterns: ["Access denied", "access denied", "FILE_ACCESS_DENIED"],
+    createError: (e, t) => a.fs.fileAccessDenied(
+      (t == null ? void 0 : t.path) || "unknown",
+      { originalError: e, ...t }
+    )
+  },
+  {
+    patterns: ["No space left", "disk full", "DISK_FULL", "insufficient space"],
+    createError: (e, t) => a.fs.diskFull(
+      (t == null ? void 0 : t.path) || "unknown",
+      { originalError: e, ...t }
+    )
+  },
+  {
+    patterns: ["already exists", "file exists", "FILE_ALREADY_EXISTS"],
+    createError: (e, t) => a.fs.fileAlreadyExists(
+      (t == null ? void 0 : t.path) || "unknown",
+      { originalError: e, ...t }
+    )
+  },
+  {
+    patterns: ["invalid path", "INVALID_PATH", "malformed path"],
+    createError: (e, t) => a.fs.invalidPath(
+      (t == null ? void 0 : t.path) || "unknown",
+      { originalError: e, ...t }
+    )
+  },
+  // Generic permission errors (low priority, placed last)
+  {
+    patterns: ["Permission denied", "PERMISSION_DENIED"],
+    createError: (e, t) => a.common.permissionDenied(
+      `file system operation on ${(t == null ? void 0 : t.path) || "unknown"}`,
+      { originalError: e, ...t }
+    )
+  }
+], ye = [
+  // Specific clipboard errors (high priority)
+  {
+    patterns: ["format not supported", "unsupported format", "FORMAT_UNSUPPORTED"],
+    createError: (e, t) => a.clipboard.formatUnsupported(
+      t == null ? void 0 : t.format,
+      { originalError: e, ...t }
+    )
+  },
+  {
+    patterns: ["empty", "no content", "CLIPBOARD_EMPTY"],
+    createError: (e, t) => a.clipboard.empty({ originalError: e, ...t })
+  },
+  {
+    patterns: ["clipboard access denied", "clipboard ACCESS_DENIED"],
+    createError: (e, t) => a.clipboard.accessDenied({ originalError: e, ...t })
+  },
+  {
+    patterns: ["unavailable", "not available", "CLIPBOARD_UNAVAILABLE", "clipboard not accessible"],
+    createError: (e, t) => a.clipboard.unavailable({ originalError: e, ...t })
+  },
+  // Generic permission errors (low priority, placed last)
+  {
+    patterns: ["Permission denied", "permission denied", "PERMISSION_DENIED"],
+    createError: (e, t) => a.common.permissionDenied(
+      "clipboard access",
+      { originalError: e, ...t }
+    )
+  }
+], be = [
+  {
+    patterns: ["cancelled", "canceled", "DIALOG_CANCELLED", "user cancelled"],
+    createError: (e, t) => a.dialog.cancelled({ originalError: e, ...t })
+  },
+  {
+    patterns: ["unavailable", "not available", "DIALOG_UNAVAILABLE", "dialog not supported"],
+    createError: (e, t) => a.dialog.unavailable({ originalError: e, ...t })
+  },
+  {
+    patterns: ["invalid options", "INVALID_OPTIONS", "malformed options"],
+    createError: (e, t) => a.dialog.invalidOptions(
+      t == null ? void 0 : t.reason,
+      { originalError: e, ...t }
+    )
+  },
+  {
+    patterns: ["Permission denied", "permission denied", "PERMISSION_DENIED"],
+    createError: (e, t) => a.common.permissionDenied(
+      "dialog access",
+      { originalError: e, ...t }
+    )
+  }
+];
+function Ie(e) {
+  if (typeof e == "string")
+    return e;
+  if (e && typeof e == "object") {
+    const t = e;
+    if (typeof t.message == "string")
+      return t.message;
+    if (typeof t.error == "string")
+      return t.error;
+  }
+  return "Unknown error";
+}
+function Ae(e, t) {
+  const r = e.toLowerCase();
+  for (const n of t)
+    for (const s of n.patterns)
+      if (r.includes(s.toLowerCase()))
+        return {
+          matched: !0,
+          pattern: n
+        };
+  return { matched: !1 };
+}
+function O(e, t, r) {
+  const n = Ie(e), s = Ae(n, t);
+  if (s.matched && s.pattern)
+    try {
+      return s.pattern.createError(n, r);
+    } catch (i) {
+      console.warn("Failed to create specific error, falling back to generic error:", i);
+    }
+  return a.common.unknown(n, {
+    originalError: n,
+    parseContext: "No pattern matched",
+    ...r
+  });
+}
+function ke(e, t) {
+  return O(e, Ee, {
+    ...t,
+    errorType: "http"
+  });
+}
+function De(e, t) {
+  return O(e, we, {
+    ...t,
+    errorType: "filesystem"
+  });
+}
+function Z(e, t) {
+  return O(e, ye, {
+    ...t,
+    errorType: "clipboard"
+  });
+}
+function ee(e, t) {
+  return O(e, be, {
+    ...t,
+    errorType: "dialog"
+  });
+}
+async function N(e) {
+  try {
+    const t = await l("plugin_request", e);
+    if (e.responseType === "arraybuffer" && typeof t.body == "string") {
+      const r = atob(t.body), n = new Uint8Array(r.length);
+      for (let s = 0; s < r.length; s++)
+        n[s] = r.charCodeAt(s);
+      t.body = n.buffer;
+    }
+    if (t.status >= 200 && t.status < 300)
+      return t;
+    throw a.http.httpError(t.status, t.statusText, {
+      url: e.url,
+      method: e.method || "GET",
+      response: t
+    });
+  } catch (t) {
+    throw m.isPluginError(t) ? t : ke(t, {
+      url: e.url,
+      method: e.method || "GET",
+      options: e
+    });
+  }
+}
+async function Se(e, t) {
+  return N({ ...t, url: e, method: "GET" });
+}
+async function Le(e, t, r) {
+  return N({ ...r, url: e, method: "POST", body: t });
+}
+async function Ne(e, t, r) {
+  return N({ ...r, url: e, method: "PUT", body: t });
+}
+async function Te(e, t, r) {
+  return N({ ...r, url: e, method: "PATCH", body: t });
+}
+async function Ce(e, t) {
+  return N({ ...t, url: e, method: "DELETE" });
+}
+const Kt = {
+  request: N,
+  get: Se,
+  post: Le,
+  put: Ne,
+  patch: Te,
+  delete: Ce
+  // delete is a keyword, use del
+};
+function T(e) {
+  const t = R();
+  if (t === _.Webview)
+    return e.webview();
+  if (t === _.Headless)
+    return e.headless();
+  throw new Error(`Unsupported environment: ${t}`);
+}
+function E(e, t) {
+  return T({
+    webview: () => l(e, t),
+    headless: () => l(e, t)
+  });
+}
+function Pe(e, t) {
+  return E("plugin_storage_set", { key: e, value: t });
+}
+function ve(e) {
+  return E("plugin_storage_get", { key: e });
+}
+function Re(e) {
+  return E("plugin_storage_remove", { key: e });
+}
+function Oe() {
+  return E("plugin_storage_clear");
+}
+function Fe() {
+  return E("plugin_storage_keys");
+}
+function Me(e) {
+  return E("plugin_storage_set_items", { items: e });
+}
+function Ue(e) {
+  return E("plugin_storage_get_items", {
+    keys: e
+  });
+}
+function $e() {
+  return E("plugin_storage_get_all");
+}
+function He(e) {
+  return E("plugin_storage_set_all", { data: e });
+}
+const xt = {
+  setItem: Pe,
+  getItem: ve,
+  removeItem: Re,
+  clear: Oe,
+  keys: Fe,
+  setItems: Me,
+  getItems: Ue,
+  getAll: $e,
+  setAll: He
+};
+function Be(e) {
+  return T({
+    // Webview environment: Tauri expects parameter structure { options: { ... } }
+    webview: () => l("show_notification", { options: e }),
+    // Headless environment: pass options directly
+    headless: () => l("show_notification", e)
+  });
+}
+const Xt = {
+  show: Be
+};
+let Q = !1;
+async function Ve(e) {
+  if (Q) {
+    console.warn(
+      "CommandHandler has already been registered. Ignoring subsequent calls."
+    );
+    return;
+  }
+  await T({
+    webview: () => S("plugin_command_execute", async (r) => {
+      const { command: n, args: s, requestId: i } = r.payload;
+      try {
+        const d = await e(n, s);
+        try {
+          await l("plugin_command_result", {
+            requestId: i,
+            success: !0,
+            result: d
+          });
+        } catch (w) {
+          console.error("Failed to send command result:", w);
+        }
+      } catch (d) {
+        try {
+          await l("plugin_command_result", {
+            requestId: i,
+            success: !1,
+            error: d instanceof Error ? d.message : String(d)
+          });
+        } catch (w) {
+          console.error("Failed to send command error:", w);
+        }
+      }
+    }),
+    headless: () => S("plugin_command_execute", e)
+  }), Q = !0;
+}
+async function We(e) {
+  if (!e.code)
+    throw new Error("Command code is required");
+  if (!e.name)
+    throw new Error("Command name is required");
+  await l("register_dynamic_command", {
+    command: e
+  });
+}
+async function ze(e) {
+  if (!e)
+    throw new Error("Command code is required");
+  await l("remove_dynamic_command", {
+    commandCode: e
+  });
+}
+const Qt = {
+  register: We,
+  handle: Ve,
+  remove: ze
+};
+async function h(e, t) {
+  try {
+    return await T({
+      webview: () => l(e, t),
+      headless: () => l(e, t)
+    });
+  } catch (r) {
+    throw m.isPluginError(r) ? r : De(r, {
+      path: (t == null ? void 0 : t.path) || (t == null ? void 0 : t.sourcePath),
+      method: e,
+      args: t
+    });
+  }
+}
+function Ge(e) {
+  return h("plugin_fs_read_file", { path: e });
+}
+function je(e, t) {
+  return h("plugin_fs_write_file", { path: e, content: t });
+}
+function Ye(e) {
+  return h("plugin_fs_exists", { path: e });
+}
+function qe(e, t = !0) {
+  return h("plugin_fs_create_dir", { path: e, recursive: t });
+}
+function Ke(e) {
+  return h("plugin_fs_list_dir", { path: e });
+}
+function xe(e) {
+  return h("plugin_fs_delete_file", { path: e });
+}
+function Xe(e, t = !1) {
+  return h("plugin_fs_delete_dir", { path: e, recursive: t });
+}
+function Qe(e) {
+  return h("plugin_fs_get_file_info", { path: e });
+}
+function Je(e, t) {
+  return h("plugin_fs_copy_file", { sourcePath: e, destPath: t });
+}
+function Ze(e, t) {
+  return h("plugin_fs_move_file", { sourcePath: e, destPath: t });
+}
+const Jt = {
+  readFile: Ge,
+  writeFile: je,
+  exists: Ye,
+  createDir: qe,
+  listDir: Ke,
+  deleteFile: xe,
+  deleteDir: Xe,
+  getFileInfo: Qe,
+  copyFile: Je,
+  moveFile: Ze
+};
+async function F(e, t) {
+  try {
+    return await T({
+      webview: () => l(e, t),
+      headless: () => l(e, t)
+    });
+  } catch (r) {
+    throw m.isPluginError(r) ? r : ee(r, {
+      method: e,
+      args: t
+    });
+  }
+}
+function M(e) {
+  return F("plugin_dialog_message", e);
+}
+function te(e) {
+  return F("plugin_dialog_confirm", e);
+}
+async function U(e) {
+  const t = await F("plugin_dialog_open", e || {});
+  return t == null ? null : Array.isArray(t) || typeof t == "string" ? t : null;
+}
+function re(e) {
+  return F("plugin_dialog_save", e || {});
+}
+function et(e, t) {
+  return M({
+    message: e,
+    title: t,
+    kind: "info"
+  });
+}
+function tt(e, t) {
+  return M({
+    message: e,
+    title: t,
+    kind: "warning"
+  });
+}
+function rt(e, t) {
+  return M({
+    message: e,
+    title: t,
+    kind: "error"
+  });
+}
+function nt(e, t) {
+  return te({
+    message: e,
+    title: t
+  });
+}
+function st(e, t) {
+  return U({
+    filters: e,
+    defaultPath: t,
+    multiple: !1,
+    directory: !1
+  });
+}
+function it(e, t) {
+  return U({
+    filters: e,
+    defaultPath: t,
+    multiple: !0,
+    directory: !1
+  });
+}
+function ot(e) {
+  return U({
+    defaultPath: e,
+    multiple: !1,
+    directory: !0
+  });
+}
+function at(e, t) {
+  return re({
+    defaultPath: e,
+    filters: t
+  });
+}
+const Zt = {
+  /** Core methods */
+  showMessage: M,
+  showConfirm: te,
+  showOpen: U,
+  showSave: re,
+  /** Convenience methods */
+  info: et,
+  warning: tt,
+  error: rt,
+  confirm: nt,
+  selectFile: st,
+  selectFiles: it,
+  selectFolder: ot,
+  saveFile: at,
+  /** Error handling tools */
+  parseDialogError: ee
+};
+async function C(e, t) {
+  try {
+    return await T({
+      webview: () => l(e, t),
+      headless: () => l(e, t)
+    });
+  } catch (r) {
+    throw m.isPluginError(r) ? r : Z(r, {
+      method: e,
+      args: t
+    });
+  }
+}
+function W() {
+  return C("plugin_clipboard_read_text");
+}
+function ne(e) {
+  return C("plugin_clipboard_write_text", { text: e });
+}
+function se() {
+  return C("plugin_clipboard_read_image");
+}
+function lt(e) {
+  const t = typeof e == "string" ? e : Array.from(e);
+  return C("plugin_clipboard_write_image", { imageData: t });
+}
+function ct() {
+  return C("plugin_clipboard_clear");
+}
+async function ut() {
+  const e = await W();
+  return e !== null && e.length > 0;
+}
+async function dt() {
+  return await se() !== null;
+}
+function ft(e) {
+  return ne(e);
+}
+function gt() {
+  return W();
+}
+function mt() {
+  return C("plugin_clipboard_get_metadata");
+}
+const er = {
+  /** Core methods */
+  readText: W,
+  writeText: ne,
+  readImage: se,
+  writeImage: lt,
+  clear: ct,
+  /** Check methods */
+  hasText: ut,
+  hasImage: dt,
+  /** Metadata methods */
+  getMetadata: mt,
+  /** Convenience methods */
+  copy: ft,
+  paste: gt,
+  /** Error handling tools */
+  parseClipboardError: Z
+};
+let z = [];
+async function pt(e) {
+  z = e;
+  try {
+    const t = globalThis.__PLUGIN_ID__;
+    if (!t)
+      throw a.common.unknown("Plugin ID not found in global context");
+    await l("register_plugin_settings_schema", {
+      pluginId: t,
+      schema: ht(e)
+    });
+  } catch (t) {
+    if (t && typeof t == "object" && t !== null && "name" in t && t.name === "PluginError")
+      throw t;
+    const r = t instanceof Error ? t.message : String(t);
+    throw a.common.unknown(
+      `Failed to register settings schema: ${r}`
+    );
+  }
+}
+function ht(e) {
+  return {
+    fields: e
+  };
+}
+async function ie() {
+  try {
+    const e = globalThis.__PLUGIN_ID__;
+    if (!e)
+      throw a.common.unknown("Plugin ID not found in global context");
+    const r = { ...await l("get_plugin_settings", {
+      pluginId: e
+    }) };
+    for (const n of z)
+      r[n.key] === void 0 && "defaultValue" in n && n.defaultValue !== void 0 && (r[n.key] = n.defaultValue);
+    return r;
+  } catch (e) {
+    throw e && typeof e == "object" && e !== null && "name" in e && e.name === "PluginError" ? e : a.common.unknown(`Failed to get plugin settings: ${e}`);
+  }
+}
+async function _t(e, t) {
+  try {
+    const n = (await ie())[e];
+    return n !== void 0 ? n : t;
+  } catch (r) {
+    if (t !== void 0)
+      return t;
+    throw r;
+  }
+}
+function Et() {
+  return z;
+}
+const tr = {
+  useSettingsSchema: pt,
+  getAll: ie,
+  get: _t,
+  getSchema: Et
+};
+let G = [], j = [], B = !1;
+function wt(e) {
+  G.push(e), B || (B = !0, queueMicrotask(() => {
+    bt().catch((t) => {
+      console.error("[Lifecycle] Failed to execute onLoad callbacks:", t);
+    });
+  }));
+}
+function yt(e) {
+  j.push(e);
+}
+async function bt() {
+  for (const e of G)
+    try {
+      await e();
+    } catch (t) {
+      const r = t instanceof Error ? t.message : String(t);
+      throw console.error("[Lifecycle] Error in onLoad callback:", r), a.common.unknown(
+        `onLoad callback failed: ${r}`
+      );
+    }
+}
+async function It() {
+  for (const e of j)
+    try {
+      await e();
+    } catch (t) {
+      console.error("[Lifecycle] Error in onUnload callback:", t);
+    }
+}
+function At() {
+  G = [], j = [], B = !1;
+}
+const rr = {
+  onLoad: wt,
+  onUnload: yt,
+  // Internal functions exposed for plugin system
+  _executeUnloadCallbacks: It,
+  _resetCallbacks: At
+}, v = /* @__PURE__ */ new Map();
+let J = !1;
+function kt() {
+  J || (J = !0, S("scheduler:execute-task", (e) => {
+    const { taskId: t } = e.payload, r = v.get(t);
+    r ? Promise.resolve(r()).catch((n) => {
+      console.error(`[Scheduler] Task ${t} execution failed:`, n);
+    }) : console.warn(`[Scheduler] No callback found for task: ${t}`);
+  }));
+}
+kt();
+function oe(e) {
+  if (!/^([0-1]?[0-9]|2[0-3]):([0-5][0-9])$/.test(e))
+    throw new Error(`Invalid time format: ${e}. Expected format: HH:MM (e.g., 08:30)`);
+}
+function Dt(e) {
+  if (e.split(/\s+/).length !== 5)
+    throw new Error(
+      `Invalid cron format: ${e}. Expected format: 'minute hour day month weekday'`
+    );
+}
+async function $(e, t, r) {
+  Dt(t), v.set(e, r);
+  try {
+    await l("schedule_task", {
+      options: { id: e, cron: t }
+    });
+  } catch (n) {
+    throw v.delete(e), n;
+  }
+}
+async function St(e, t, r) {
+  oe(t);
+  const [n, s] = t.split(":"), i = `${s} ${n} * * *`;
+  return $(e, i, r);
+}
+async function Lt(e, t, r) {
+  const n = `${t} * * * *`;
+  return $(e, n, r);
+}
+async function Nt(e, t, r, n) {
+  if (t < 0 || t > 6)
+    throw new Error(`Invalid weekday: ${t}. Expected 0-6 (0=Sunday, 6=Saturday)`);
+  oe(r);
+  const [s, i] = r.split(":"), d = `${i} ${s} * * ${t}`;
+  return $(e, d, n);
+}
+async function Tt(e) {
+  await l("cancel_task", { taskId: e }), v.delete(e);
+}
+async function Ct() {
+  return l("list_tasks", {});
+}
+const nr = {
+  schedule: $,
+  daily: St,
+  hourly: Lt,
+  weekly: Nt,
+  cancel: Tt,
+  list: Ct
+};
+function Pt() {
+  const e = /* @__PURE__ */ new Date(), t = e.getHours().toString().padStart(2, "0"), r = e.getMinutes().toString().padStart(2, "0"), n = e.getSeconds().toString().padStart(2, "0"), s = e.getMilliseconds().toString().padStart(3, "0");
+  return `${t}:${r}:${n}.${s}`;
+}
+const I = class I {
+  constructor() {
+    u(this, "showCallbacks", []);
+    u(this, "hideCallbacks", []);
+    u(this, "focusCallbacks", []);
+    u(this, "blurCallbacks", []);
+    u(this, "initialized", !1);
+    // 状态跟踪：防止连续触发相同类型的事件
+    u(this, "isVisible", !0);
+    // 假设初始状态为可见
+    u(this, "isFocused", !0);
+    u(this, "lastShowTime", 0);
+    u(this, "lastHideTime", 0);
+    u(this, "lastFocusTime", 0);
+    u(this, "lastBlurTime", 0);
+  }
+  /**
+   * 获取带时间戳的日志前缀
+   */
+  log(t) {
+    console.log(`[${Pt()}] [Adapter] ${t}`);
+  }
+  onShow(t) {
+    this.showCallbacks.includes(t) || this.showCallbacks.push(t), this.ensureInitialized();
+  }
+  onHide(t) {
+    this.hideCallbacks.includes(t) || this.hideCallbacks.push(t), this.ensureInitialized();
+  }
+  onFocus(t) {
+    this.focusCallbacks.includes(t) || this.focusCallbacks.push(t), this.ensureInitialized();
+  }
+  onBlur(t) {
+    this.blurCallbacks.includes(t) || this.blurCallbacks.push(t), this.ensureInitialized();
+  }
+  ensureInitialized() {
+    this.initialized || (this.initialize(), this.initialized = !0);
+  }
+  destroy() {
+    this.showCallbacks = [], this.hideCallbacks = [], this.focusCallbacks = [], this.blurCallbacks = [], this.initialized = !1, this.isVisible = !0, this.isFocused = !0;
+  }
+  /**
+   * 执行显示回调（带防抖和状态检查）
+   */
+  async executeShowCallbacks() {
+    if (this.isVisible)
+      return;
+    const t = Date.now();
+    if (!(t - this.lastShowTime < I.DEBOUNCE_MS)) {
+      this.lastShowTime = t, this.isVisible = !0;
+      for (const r of this.showCallbacks)
+        try {
+          await r();
+        } catch (n) {
+          console.error("[WindowAdapter] Error in onShow callback:", n);
+        }
+    }
+  }
+  /**
+   * 执行隐藏回调（带防抖和状态检查）
+   */
+  async executeHideCallbacks() {
+    if (!this.isVisible)
+      return;
+    const t = Date.now();
+    if (!(t - this.lastHideTime < I.DEBOUNCE_MS)) {
+      this.lastHideTime = t, this.isVisible = !1;
+      for (const r of this.hideCallbacks)
+        try {
+          await r();
+        } catch (n) {
+          console.error("[WindowAdapter] Error in onHide callback:", n);
+        }
+    }
+  }
+  async executeFocusCallbacks() {
+    if (this.log(`executeFocusCallbacks - isFocused: ${this.isFocused}`), this.isFocused) {
+      this.log("Skipping focus - already focused");
+      return;
+    }
+    const t = Date.now();
+    if (!(t - this.lastFocusTime < I.DEBOUNCE_MS)) {
+      this.lastFocusTime = t, this.isFocused = !0;
+      for (const r of this.focusCallbacks)
+        try {
+          await r();
+        } catch (n) {
+          console.error("[WindowAdapter] Error in onFocus callback:", n);
+        }
+    }
+  }
+  async executeBlurCallbacks() {
+    if (this.log(`executeBlurCallbacks - isFocused: ${this.isFocused}`), !this.isFocused) {
+      this.log("Skipping blur - already blurred");
+      return;
+    }
+    const t = Date.now();
+    if (!(t - this.lastBlurTime < I.DEBOUNCE_MS)) {
+      this.lastBlurTime = t, this.isFocused = !1;
+      for (const r of this.blurCallbacks)
+        try {
+          await r();
+        } catch (n) {
+          console.error("[WindowAdapter] Error in onBlur callback:", n);
+        }
+    }
+  }
+};
+// 假设初始状态为聚焦
+// 防抖时间（毫秒）
+u(I, "DEBOUNCE_MS", 100);
+let V = I;
+class vt extends V {
+  constructor() {
+    super();
+    u(this, "messageHandler", null);
+    u(this, "runtimeResolve", null);
+    u(this, "runtimePromise");
+    u(this, "_runtime", null);
+    this.runtimePromise = new Promise((r) => {
+      this.runtimeResolve = r;
+    }), this.initializeNow();
+  }
+  /**
+   * 立即初始化
+   */
+  initializeNow() {
+    console.log("[PostMessageAdapter] Initializing..."), console.log("[PostMessageAdapter] In iframe:", window.self !== window.top), this.trySetRuntimeFromUrl(), this.messageHandler = (r) => {
+      r.data && typeof r.data == "object" && r.data.type && console.log(
+        "[PostMessageAdapter] Received message:",
+        r.data.type,
+        r.data
+      );
+      const n = r.data;
+      !n || typeof n != "object" || (n.type === "plugin-runtime-init" ? this.handleRuntimeInit(n.runtime) : n.type === "plugin-lifecycle-event" && this.handleLifecycleEvent(n.event));
+    }, window.addEventListener("message", this.messageHandler), this.initialized = !0, console.log("[PostMessageAdapter] Initialized, listening for postMessage");
+  }
+  /**
+   * 尝试从 URL 参数设置运行时信息（作为 fallback）
+   */
+  trySetRuntimeFromUrl() {
+    try {
+      const r = new URLSearchParams(window.location.search), n = r.get("mode"), s = r.get("plugin_id") || "unknown";
+      (n === "window" || n === "inline") && (console.log("[PostMessageAdapter] Setting runtime from URL params:", {
+        mode: n,
+        pluginId: s
+      }), this._runtime = {
+        mode: n,
+        pluginId: s,
+        version: "0.1.0",
+        mainWindowLabel: "main"
+      }, this.runtimeResolve && (this.runtimeResolve(this._runtime), this.runtimeResolve = null));
+    } catch (r) {
+      console.warn("[PostMessageAdapter] Failed to read URL params:", r);
+    }
+  }
+  /**
+   * 获取运行时信息（异步）
+   */
+  async getRuntime() {
+    return this._runtime ? this._runtime : this.runtimePromise;
+  }
+  /**
+   * 获取运行时信息（同步，可能返回 null）
+   */
+  getRuntimeSync() {
+    return this._runtime;
+  }
+  initialize() {
+  }
+  /**
+   * 处理运行时初始化
+   */
+  handleRuntimeInit(r) {
+    console.log("[PostMessageAdapter] Runtime init received:", r), this._runtime = r, this._stateUnknown = !0, this.runtimeResolve && (this.runtimeResolve(r), this.runtimeResolve = null);
+  }
+  /**
+   * 处理生命周期事件
+   */
+  handleLifecycleEvent(r) {
+    switch (console.log("[PostMessageAdapter] Lifecycle event:", r), this._stateUnknown && (this._stateUnknown = !1, r === "show" ? this.isVisible = !1 : r === "hide" ? this.isVisible = !0 : r === "focus" ? this.isFocused = !1 : r === "blur" && (this.isFocused = !0)), r) {
+      case "show":
+        this.executeShowCallbacks();
+        break;
+      case "hide":
+        this.executeHideCallbacks();
+        break;
+      case "focus":
+        this.executeFocusCallbacks();
+        break;
+      case "blur":
+        this.executeBlurCallbacks();
+        break;
+    }
+  }
+  destroy() {
+    this.messageHandler && (window.removeEventListener("message", this.messageHandler), this.messageHandler = null), this.initialized = !1, this.showCallbacks = [], this.hideCallbacks = [], this.focusCallbacks = [], this.blurCallbacks = [], console.log("[PostMessageAdapter] Destroyed");
+  }
+}
+let L = null;
+function y() {
+  return L || (console.log("[pluginWindow] Creating PostMessageAdapter"), L = new vt()), L;
+}
+function Rt(e) {
+  y().onShow(e);
+}
+function Ot(e) {
+  y().onHide(e);
+}
+function Ft(e) {
+  y().onFocus(e);
+}
+function Mt(e) {
+  y().onBlur(e);
+}
+function Ut() {
+  const e = y().getRuntimeSync();
+  return (e == null ? void 0 : e.mode) ?? "unknown";
+}
+async function $t() {
+  return (await y().getRuntime()).mode;
+}
+function Ht() {
+  const e = y().getRuntimeSync();
+  return (e == null ? void 0 : e.pluginId) ?? "unknown";
+}
+const sr = {
+  onShow: Rt,
+  onHide: Ot,
+  onFocus: Ft,
+  onBlur: Mt,
+  getMode: Ut,
+  getModeAsync: $t,
+  getPluginId: Ht,
+  // 内部函数，用于测试和高级用例
+  _getAdapter: y,
+  _resetAdapter: () => {
+    L && (L.destroy(), L = null);
+  }
+};
+function b(e, t) {
+  return {
+    role: e,
+    content: [{ type: "text", text: t }]
+  };
+}
+async function ae(e, t = {}) {
+  let r;
+  typeof e == "string" ? r = [b("user", e)] : r = e;
+  const n = {
+    messages: r,
+    ...t
+  };
+  return l("plugin_ai_ask", { request: n });
+}
+async function le(e, t, r = {}) {
+  let n;
+  typeof e == "string" ? n = [b("user", e)] : n = e;
+  const s = {
+    messages: n,
+    ...r
+  }, i = `ai_stream_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  return new Promise(async (d, w) => {
+    const H = await S(i, (p) => {
+      t(p.payload);
+    }), P = await S(
+      `${i}_error`,
+      (p) => {
+        f(), w(new Error(p.payload));
+      }
+    ), g = await S(`${i}_done`, () => {
+      f(), d();
+    }), f = () => {
+      H(), P(), g();
+    };
+    try {
+      await l("plugin_ai_stream", { request: s, eventId: i });
+    } catch (p) {
+      f(), w(p);
+    }
+  });
+}
+async function Bt() {
+  try {
+    return await ce() !== null;
+  } catch {
+    return !1;
+  }
+}
+async function ce() {
+  return l("get_ai_capabilities", {});
+}
+async function Vt() {
+  return l("list_ai_models", {});
+}
+async function Wt(e, t) {
+  return l("validate_ai_provider", {
+    base_url: e,
+    api_key: t ?? null
+  });
+}
+function zt(e) {
+  return new Gt(e);
+}
+class Gt {
+  constructor(t) {
+    u(this, "messages", []);
+    t && this.messages.push(b("system", t));
+  }
+  addMessage(t) {
+    this.messages.push(t);
+  }
+  async ask(t, r) {
+    const n = typeof t == "string" ? b("user", t) : t;
+    this.messages.push(n);
+    try {
+      const s = await ae(this.messages, r || {});
+      return this.messages.push(b("assistant", s)), s;
+    } catch (s) {
+      throw this.messages.pop(), s;
+    }
+  }
+  async stream(t, r, n) {
+    const s = typeof t == "string" ? b("user", t) : t;
+    this.messages.push(s);
+    let i = "";
+    try {
+      await le(
+        this.messages,
+        (d) => {
+          i += d, r(d);
+        },
+        n || {}
+      ), this.messages.push(b("assistant", i));
+    } catch (d) {
+      throw this.messages.pop(), d;
+    }
+  }
+  getHistory() {
+    return [...this.messages];
+  }
+  clear() {
+    const t = this.messages.find((r) => r.role === "system");
+    this.messages = t ? [t] : [];
+  }
+  getLastResponse() {
+    for (let t = this.messages.length - 1; t >= 0; t--)
+      if (this.messages[t].role === "assistant") {
+        const n = this.messages[t].content.find((s) => s.type === "text");
+        if (n && n.type === "text") return n.text;
+      }
+    return null;
+  }
+}
+const ir = {
+  ask: ae,
+  stream: le,
+  isAvailable: Bt,
+  getCapabilities: ce,
+  listModels: Vt,
+  validateProvider: Wt,
+  createConversation: zt
+}, or = {
+  version: "0.0.1",
+  getEnvironment: R,
+  getRuntimeInfo: () => ({
+    timestamp: Date.now(),
+    userAgent: typeof navigator < "u" ? navigator.userAgent : "Deno Runtime",
+    platform: typeof navigator < "u" ? navigator.platform : "Unknown"
+  }),
+  async testConnection() {
+    try {
+      return { success: !0, result: await l("plugin_test_connection", {}) };
+    } catch (e) {
+      return { success: !1, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+};
+function Y(e) {
+  var t;
+  if (m.isPluginError(e))
+    switch (e.code) {
+      case o.http.NETWORK_ERROR:
+      case o.http.TIMEOUT:
+        return !0;
+      case o.http.HTTP_ERROR:
+        const r = (t = e.context) == null ? void 0 : t.status;
+        return r === 429 || // Too Many Requests
+        r === 500 || // Internal Server Error
+        r === 502 || // Bad Gateway
+        r === 503 || // Service Unavailable
+        r === 504;
+      case o.clipboard.UNAVAILABLE:
+        return !0;
+      default:
+        return !1;
+    }
+  return !1;
+}
+function q(e, t = 1) {
+  var r, n;
+  if (m.isPluginError(e))
+    switch (e.code) {
+      case o.http.HTTP_ERROR:
+        switch ((r = e.context) == null ? void 0 : r.status) {
+          case 429:
+            return (((n = e.context) == null ? void 0 : n.retryAfter) || 60) * 1e3;
+          case 500:
+            return Math.min(1e4 * t, 6e4);
+          case 502:
+          case 503:
+          case 504:
+            return Math.min(5e3 * t, 3e4);
+          default:
+            return Math.min(3e3 * t, 15e3);
+        }
+      case o.http.TIMEOUT:
+        return Math.min(5e3 * t, 3e4);
+      default:
+        return Math.min(3e3 * t, 15e3);
+    }
+  return 3e3 * t;
+}
+function K(e, t, r = 3e4) {
+  const n = e * Math.pow(2, t - 1);
+  return Math.min(n, r);
+}
+async function x(e, t = {}) {
+  const {
+    maxRetries: r = 3,
+    baseDelay: n = 1e3,
+    exponentialBackoff: s = !1,
+    maxDelay: i = 3e4,
+    shouldRetry: d = Y,
+    getDelay: w = (g, f) => s ? K(n, f, i) : q(g, f),
+    onRetry: H = (g, f, p) => {
+      console.log(
+        `Operation failed, retrying in ${p}ms (${f}/${r})`
+      ), m.isPluginError(g) && console.log(`Error type: ${g.code}, message: ${g.message}`);
+    }
+  } = t;
+  let P;
+  for (let g = 1; g <= r; g++)
+    try {
+      return await e();
+    } catch (f) {
+      if (P = f, g === r || !d(f))
+        throw f;
+      const p = w(f, g);
+      H(f, g, p), await new Promise((de) => setTimeout(de, p));
+    }
+  throw P;
+}
+function ue(e, t = {}) {
+  return (...r) => x(() => e(...r), t);
+}
+const jt = {
+  withRetry: x,
+  createRetryWrapper: ue,
+  isRetryableError: Y,
+  getRetryDelay: q,
+  calculateExponentialBackoff: K
+}, ar = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  calculateExponentialBackoff: K,
+  createRetryWrapper: ue,
+  getRetryDelay: q,
+  isRetryableError: Y,
+  retry: jt,
+  withRetry: x
+}, Symbol.toStringTag, { value: "Module" }));
+if (typeof window < "u") {
+  const t = new URLSearchParams(window.location.search).get("plugin_id");
+  t && (window.__PLUGIN_ID__ = t, globalThis.__PLUGIN_ID__ = t), window.addEventListener("message", (r) => {
+    var n;
+    if (((n = r.data) == null ? void 0 : n.type) === "set-plugin-id") {
+      const s = r.data.pluginId;
+      window.__PLUGIN_ID__ = s, globalThis.__PLUGIN_ID__ = s;
+    }
+  });
+}
+const lr = {
+  Permissions: {},
+  Errors: {},
+  Retry: {},
+  Fs: {},
+  Dialog: {},
+  Settings: {}
+};
+export {
+  ir as ai,
+  er as clipboard,
+  Qt as command,
+  or as debug,
+  Zt as dialog,
+  qt as error,
+  Jt as fs,
+  Kt as http,
+  l as invoke,
+  rr as lifecycle,
+  S as listen,
+  Xt as notification,
+  sr as pluginWindow,
+  ar as retry,
+  nr as scheduler,
+  tr as settings,
+  xt as storage,
+  lr as types
+};