@howone/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,1438 @@
+// src/components/FloatingButton.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var FloatingButton = ({
+  text = "Made in Howone",
+  onClick,
+  className = ""
+}) => {
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      onClick,
+      className: `fixed flex bg-white gap-2 items-center right-4 z-50 text-black px-3 py-2 rounded-lg shadow-lg transition-colors duration-200 ${className}`,
+      style: {
+        fontSize: "14px",
+        fontWeight: "bold",
+        bottom: "28px"
+      },
+      children: [
+        /* @__PURE__ */ jsx("img", { width: 20, src: "https://sxwxqoixnnklnpeutjrj.supabase.co/storage/v1/object/public/create-x/logo/logo-sm.svg", alt: "" }),
+        text
+      ]
+    }
+  );
+};
+
+// src/services/unified-oauth.ts
+var UnifiedAuthService = class {
+  constructor() {
+    this.API_BASE_URL = "https://create-x-backend.fly.dev";
+  }
+  /**
+   * 初始化 Google 登录流程
+   * @returns 包含 token 和用户信息的 Promise
+   */
+  async initiateGoogleLogin() {
+    const currentUrl = window.location.href;
+    const state = {
+      from_url: currentUrl,
+      app_id: this.generateAppId(),
+      timestamp: Date.now()
+    };
+    const stateString = encodeURIComponent(JSON.stringify(state));
+    try {
+      const response = await fetch(`${this.API_BASE_URL}/api/auth/google?state=${stateString}`);
+      const data = await response.json();
+      if (!data.data.success || !data.data.authUrl) {
+        throw new Error("Failed to get OAuth URL");
+      }
+      return this.openOAuthPopup(data.data.authUrl);
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * 打开 OAuth 认证弹窗
+   * @param authUrl 认证 URL
+   * @returns 包含 token 和用户信息的 Promise
+   */
+  openOAuthPopup(authUrl) {
+    return new Promise((resolve, reject) => {
+      const width = 500;
+      const height = 600;
+      const left = window.screen.width / 2 - width / 2;
+      const top = window.screen.height / 2 - height / 2;
+      const popup = window.open(
+        authUrl,
+        "oauth-popup",
+        `width=${width},height=${height},left=${left},top=${top},scrollbars=yes,resizable=yes`
+      );
+      if (!popup) {
+        reject(new Error("Unable to open popup, please check browser popup settings"));
+        return;
+      }
+      let popupClosed = false;
+      let popupCheckInterval = null;
+      const checkPopupStatus = () => {
+        try {
+          if (!popup || popup.closed) {
+            if (!popupClosed) {
+              popupClosed = true;
+              if (popupCheckInterval) {
+                clearInterval(popupCheckInterval);
+                popupCheckInterval = null;
+              }
+              window.removeEventListener("message", messageHandler);
+              reject(new Error("User cancelled login"));
+            }
+          }
+        } catch (e) {
+          if (!popupClosed) {
+            popupClosed = true;
+            if (popupCheckInterval) {
+              clearInterval(popupCheckInterval);
+              popupCheckInterval = null;
+            }
+            window.removeEventListener("message", messageHandler);
+            reject(new Error("User cancelled login"));
+          }
+        }
+      };
+      popupCheckInterval = window.setInterval(checkPopupStatus, 1e3);
+      const messageHandler = (event) => {
+        const validOrigins = [
+          window.location.origin,
+          "https://create-x-backend.fly.dev"
+        ];
+        const isValidOrigin = validOrigins.some(
+          (origin) => event.origin === origin || event.origin.includes("localhost") || event.origin.includes("127.0.0.1") || event.origin.includes("fly.dev")
+        );
+        if (!isValidOrigin) {
+          return;
+        }
+        if (event.data && event.data.type === "OAUTH_SUCCESS") {
+          popupClosed = true;
+          if (popupCheckInterval) {
+            clearInterval(popupCheckInterval);
+            popupCheckInterval = null;
+          }
+          window.removeEventListener("message", messageHandler);
+          try {
+            if (popup) popup.close();
+          } catch (e) {
+          }
+          resolve(event.data.payload);
+        } else if (event.data && event.data.type === "OAUTH_ERROR") {
+          popupClosed = true;
+          if (popupCheckInterval) {
+            clearInterval(popupCheckInterval);
+            popupCheckInterval = null;
+          }
+          window.removeEventListener("message", messageHandler);
+          try {
+            if (popup) popup.close();
+          } catch (e) {
+          }
+          reject(new Error(event.data.error || "login failed"));
+        }
+      };
+      window.addEventListener("message", messageHandler);
+      setTimeout(() => {
+        if (!popupClosed) {
+          popupClosed = true;
+          if (popupCheckInterval) {
+            clearInterval(popupCheckInterval);
+            popupCheckInterval = null;
+          }
+          window.removeEventListener("message", messageHandler);
+          try {
+            if (popup) popup.close();
+          } catch (e) {
+          }
+          reject(new Error("login timeout"));
+        }
+      }, 5 * 60 * 1e3);
+    });
+  }
+  /**
+   * 初始化 GitHub 登录流程
+   * @returns 包含 token 和用户信息的 Promise
+   */
+  async initiateGitHubLogin() {
+    const currentUrl = window.location.href;
+    const state = {
+      from_url: currentUrl,
+      app_id: this.generateAppId(),
+      timestamp: Date.now()
+    };
+    const stateString = encodeURIComponent(JSON.stringify(state));
+    try {
+      const response = await fetch(`${this.API_BASE_URL}/api/auth/github?state=${stateString}`);
+      const data = await response.json();
+      if (!data.data.success || !data.data.authUrl) {
+        throw new Error("Failed to get GitHub OAuth URL");
+      }
+      return this.openOAuthPopup(data.data.authUrl);
+    } catch (error) {
+      throw error;
+    }
+  }
+  /**
+   * 发送邮箱验证码
+   * @param email 邮箱地址
+   * @param appName 应用名称（可选）
+   * @returns 发送结果 Promise
+   */
+  async sendEmailVerificationCode(email, appName) {
+    try {
+      const currentUrl = window.location.origin;
+      const appId = this.generateAppId();
+      const response = await fetch(`${this.API_BASE_URL}/api/auth/email/send-code`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          email,
+          from_url: currentUrl,
+          app_id: appId,
+          app_name: appName
+        })
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        throw new Error(JSON.stringify(data));
+      }
+      if (data.code === 0 && data.data && data.data.success === false) {
+        throw new Error(JSON.stringify(data));
+      }
+      if (data.code === 429) {
+        throw new Error(JSON.stringify(data));
+      }
+      return data;
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith("{")) {
+        throw error;
+      }
+      throw new Error(error instanceof Error ? error.message : "\u7F51\u7EDC\u9519\u8BEF\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5");
+    }
+  }
+  /**
+   * 邮箱验证码登录
+   * @param email 邮箱地址
+   * @param code 验证码
+   * @returns 登录结果 Promise
+   */
+  async loginWithEmailCode(email, code) {
+    try {
+      const currentUrl = window.location.origin;
+      const appId = this.generateAppId();
+      const response = await fetch(`${this.API_BASE_URL}/api/auth/email/login`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          email,
+          code,
+          from_url: currentUrl,
+          app_id: appId
+        })
+      });
+      const data = await response.json();
+      if (!response.ok) {
+        throw new Error(JSON.stringify(data));
+      }
+      if (data.code === 0 && data.data && data.data.success === false) {
+        throw new Error(JSON.stringify(data));
+      }
+      return data;
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith("{")) {
+        throw error;
+      }
+      throw new Error(error instanceof Error ? error.message : "\u7F51\u7EDC\u9519\u8BEF\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5");
+    }
+  }
+  /**
+   * 获取验证码状态（调试用）
+   * @param email 邮箱地址
+   * @returns 验证码状态 Promise
+   */
+  async getCodeStatus(email) {
+    try {
+      const response = await fetch(
+        `${this.API_BASE_URL}/api/auth/email/code-status?email=${encodeURIComponent(email)}`
+      );
+      return await response.json();
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : "\u7F51\u7EDC\u9519\u8BEF" };
+    }
+  }
+  generateAppId() {
+    const urlParams = new URLSearchParams(window.location.search);
+    let appId = urlParams.get("appId");
+    return appId || "app";
+  }
+  /**
+   * 检查 OAuth 回调
+   * 从 URL 参数中获取 token 和错误信息
+   * @returns 包含 token、用户信息和错误的对象
+   */
+  checkOAuthCallback() {
+    const urlParams = new URLSearchParams(window.location.search);
+    const token = urlParams.get("token");
+    const error = urlParams.get("error");
+    const userParam = urlParams.get("user");
+    if (token) {
+      let user = null;
+      if (userParam) {
+        try {
+          user = JSON.parse(decodeURIComponent(userParam));
+        } catch (e) {
+        }
+      }
+      this.saveAuthData(token, user);
+      window.history.replaceState({}, document.title, window.location.pathname);
+      return { success: true, token, user };
+    }
+    if (error) {
+      window.history.replaceState({}, document.title, window.location.pathname);
+      return { success: false, error: decodeURIComponent(error) };
+    }
+    const savedAuth = this.getSavedAuthData();
+    if (savedAuth && savedAuth.token) {
+      return { success: true, ...savedAuth };
+    }
+    return { success: false };
+  }
+  /**
+   * 验证 token 是否有效
+   * @param token JWT token
+   * @returns 包含有效状态和用户信息的 Promise
+   */
+  async verifyToken(token) {
+    try {
+      const response = await fetch(`${this.API_BASE_URL}/api/auth/verify`, {
+        method: "GET",
+        headers: {
+          "Authorization": `Bearer ${token}`
+        }
+      });
+      if (response.ok) {
+        const data = await response.json();
+        if (data.success) {
+          return { valid: true, user: data.user };
+        }
+      }
+      return { valid: false };
+    } catch (error) {
+      return { valid: false };
+    }
+  }
+  /**
+  * 从本地存储获取认证数据
+  */
+  getSavedAuthData() {
+    try {
+      const token = localStorage.getItem("auth_token");
+      if (!token) return null;
+      let user = null;
+      const userJson = localStorage.getItem("auth_user");
+      if (userJson) {
+        try {
+          user = JSON.parse(userJson);
+        } catch (e) {
+          console.error("Failed to parse saved user data:", e);
+        }
+      }
+      return { token, user };
+    } catch (e) {
+      console.error("Failed to get auth data from localStorage:", e);
+      return null;
+    }
+  }
+  /**
+  * 保存认证数据到本地存储
+  */
+  saveAuthData(token, user) {
+    try {
+      localStorage.setItem("auth_token", token);
+      localStorage.setItem("auth_user", JSON.stringify(user || {}));
+    } catch (e) {
+      console.error("Failed to save auth data to localStorage:", e);
+    }
+  }
+  /**
+   * 退出登录
+   * @param token JWT token
+   */
+  async logout(token) {
+    try {
+      await fetch(`${this.API_BASE_URL}/api/auth/logout`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${token}`
+        }
+      });
+    } catch (error) {
+    }
+  }
+};
+var unifiedAuth = new UnifiedAuthService();
+var unifiedOAuth = unifiedAuth;
+function sendEmailVerificationCode(email, appName) {
+  return unifiedAuth.sendEmailVerificationCode(email, appName);
+}
+function loginWithEmailCode(email, code) {
+  return unifiedAuth.loginWithEmailCode(email, code);
+}
+function getCodeStatus(email) {
+  return unifiedAuth.getCodeStatus(email);
+}
+
+// src/services/ai-workflow.ts
+var AIWorkflowClient = class {
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl?.replace(/\/+$/, "") || "";
+    this.apiKey = options.apiKey;
+    this.headers = { "Content-Type": "application/json", ...options.headers || {} };
+    this.fetchImpl = options.fetchImpl || fetch.bind(globalThis);
+  }
+  buildHeaders(extra) {
+    const h = { ...this.headers, ...extra || {} };
+    if (this.apiKey && !h["Authorization"]) {
+      h["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    return h;
+  }
+  async safeJson(resp) {
+    try {
+      return await resp.json();
+    } catch (_e) {
+      return null;
+    }
+  }
+  /**
+   * 按 ID 执行工作流：POST {baseUrl}/workflow/{workflowId}/execute
+   * body: { input, options }
+   */
+  async executeWorkflow(workflowId, input, options) {
+    if (!this.baseUrl) {
+      throw new Error("AI workflow client requires a baseUrl (e.g. https://evoagentx-server.fly.dev)");
+    }
+    const url = `${this.baseUrl}/workflow/${encodeURIComponent(workflowId)}/execute`;
+    try {
+      const res = await this.fetchImpl(url, {
+        method: "POST",
+        headers: this.buildHeaders(),
+        body: JSON.stringify({ input, options })
+      });
+      const data = await this.safeJson(res);
+      if (!res.ok) {
+        return { success: false, error: data?.error || `HTTP ${res.status}` };
+      }
+      return data || { success: true };
+    } catch (error) {
+      return { success: false, error: error instanceof Error ? error.message : "Network error" };
+    }
+  }
+};
+function createAIWorkflowClient(options = {}) {
+  return new AIWorkflowClient(options);
+}
+var aiWorkflow = createAIWorkflowClient({ baseUrl: "https://evoagentx-server" });
+
+// src/services/request/index.ts
+import axios from "axios";
+var Request = class {
+  constructor(config) {
+    this.abortControllers = /* @__PURE__ */ new Map();
+    this.instance = axios.create({
+      ...config,
+      validateStatus: (status) => {
+        return status >= 200 && status < 300;
+      }
+    });
+    this.interceptors = config.interceptors;
+    this.instance.interceptors.request.use(
+      this.interceptors?.requestInterceptor,
+      this.interceptors?.requestInterceptorCatch
+    );
+    this.instance.interceptors.response.use(
+      this.interceptors?.responseInterceptor,
+      this.interceptors?.responseInterceptorCatch
+    );
+    this.instance.interceptors.request.use(
+      (config2) => {
+        return config2;
+      },
+      (err) => {
+        return Promise.reject(err);
+      }
+    );
+    this.instance.interceptors.response.use(
+      (res) => {
+        return res.data;
+      },
+      (err) => {
+        if (axios.isCancel(err)) {
+          return Promise.reject({
+            isCanceled: true,
+            message: "request canceled",
+            originalError: err
+          });
+        }
+        if (err.response?.data?.error) {
+          return Promise.reject(err.response.data.error);
+        }
+        return Promise.reject(err);
+      }
+    );
+  }
+  cancelRequest(url) {
+    this.abortControllers.forEach((controller, key) => {
+      if (key.includes(url)) {
+        controller.abort();
+        this.abortControllers.delete(key);
+      }
+    });
+  }
+  cancelAllRequests() {
+    this.abortControllers.forEach((controller) => {
+      controller.abort();
+    });
+    this.abortControllers.clear();
+  }
+  request(config) {
+    const controller = new AbortController();
+    const url = config.url || "";
+    const method = config.method || "GET";
+    const key = `${method}:${url}`;
+    this.abortControllers.set(key, controller);
+    config.signal = controller.signal;
+    return new Promise((resolve, reject) => {
+      if (config.interceptors?.requestInterceptor) {
+        config = config.interceptors.requestInterceptor(config);
+      }
+      this.instance.request(config).then((res) => {
+        this.abortControllers.delete(key);
+        if (config.interceptors?.responseInterceptor) {
+          res = config.interceptors.responseInterceptor(res);
+        }
+        resolve(res);
+      }).catch((err) => {
+        this.abortControllers.delete(key);
+        reject(err);
+      });
+    });
+  }
+  get(config) {
+    return this.request({ ...config, method: "GET" });
+  }
+  post(config) {
+    return this.request({ ...config, method: "POST" });
+  }
+  delete(config) {
+    return this.request({ ...config, method: "DELETE" });
+  }
+  put(config) {
+    return this.request({ ...config, method: "PUT" });
+  }
+  patch(config) {
+    return this.request({ ...config, method: "PATCH" });
+  }
+};
+var request_default = Request;
+
+// src/services/ai-workflow-axios.ts
+function createAIWorkflowClientAxios(options = {}) {
+  const basePath = options.basePath ?? "/api";
+  const baseUrl = (options.baseUrl || "https://evoagentx-server.fly.dev").replace(/\/+$/, "");
+  const baseAPI = `${baseUrl}${basePath.startsWith("/") ? "" : "/"}${basePath}`.replace(/\/+$/, "");
+  const client = options.requestInstance || new request_default({
+    baseURL: baseAPI,
+    timeout: options.timeout ?? 6e4,
+    interceptors: {
+      requestInterceptor: (config) => {
+        config.headers = config.headers || {};
+        if (options.apiKey && !config.headers["Authorization"]) {
+          config.headers["Authorization"] = `Bearer ${options.apiKey}`;
+        }
+        if (options.headers) {
+          config.headers = { ...config.headers || {}, ...options.headers };
+        }
+        return config;
+      },
+      requestInterceptorCatch: (err) => Promise.reject(err),
+      responseInterceptor: (res) => res,
+      responseInterceptorCatch: (err) => Promise.reject(err)
+    }
+  });
+  return {
+    async executeWorkflow(workflowId, input, opts) {
+      const url = `${baseUrl}/workflow/${encodeURIComponent(workflowId)}/execute`;
+      const data = await client.post({ url, data: { input, options: opts } });
+      return data;
+    }
+  };
+}
+
+// src/services/artifact-types.ts
+function canAccessArtifact(a, ctx = {}) {
+  if (!a) return false;
+  if (a.visibility === "public") return true;
+  if (a.visibility === "project") {
+    if (ctx.projectId && a.projectId && ctx.projectId === a.projectId) return true;
+    if (ctx.tokenScopes && ctx.tokenScopes.includes("project:read")) return true;
+    return false;
+  }
+  if (a.visibility === "private") {
+    if (ctx.userId && a.ownerId && ctx.userId === a.ownerId) return true;
+    if (ctx.tokenScopes && (ctx.tokenScopes.includes("artifact:read:all") || ctx.tokenScopes.includes("admin"))) return true;
+    return false;
+  }
+  if (a.visibility === "shared") {
+    if (ctx.userId && a.sharedWith && a.sharedWith.includes(ctx.userId)) return true;
+    if (ctx.tokenScopes && (ctx.tokenScopes.includes("artifact:read:all") || ctx.tokenScopes.includes("admin"))) return true;
+    return false;
+  }
+  return false;
+}
+
+// src/services/artifacts-client.ts
+function createArtifactsClient(req) {
+  return {
+    async create(input) {
+      return await req.post({ url: "/artifacts", data: input });
+    },
+    async list(query) {
+      return await req.get({ url: "/artifacts", params: query });
+    },
+    async get(id) {
+      return await req.get({ url: `/artifacts/${encodeURIComponent(id)}` });
+    },
+    async setVisibility(id, visibility) {
+      await req.patch({ url: `/artifacts/${encodeURIComponent(id)}/visibility`, data: { visibility } });
+    },
+    async delete(id) {
+      await req.delete({ url: `/artifacts/${encodeURIComponent(id)}` });
+    },
+    // convenience local check (server is authoritative)
+    canAccessLocal(a, ctx) {
+      if (!a) return false;
+      if (a.visibility === "public") return true;
+      if (a.visibility === "project") return Boolean(ctx.projectId && a.projectId && ctx.projectId === a.projectId);
+      if (a.visibility === "private") return Boolean(ctx.userId && a.ownerId && ctx.userId === a.ownerId);
+      if (a.visibility === "shared") return Boolean(ctx.userId && a.sharedWith && a.sharedWith.includes(ctx.userId));
+      return false;
+    }
+  };
+}
+
+// src/services/index.ts
+var request = new request_default({
+  baseURL: "https://create-x-backend.fly.dev/api",
+  timeout: 6e4,
+  interceptors: {
+    requestInterceptor: (config) => {
+      config.headers = config.headers || {};
+      return config;
+    },
+    requestInterceptorCatch: (err) => {
+      return Promise.reject(err);
+    },
+    responseInterceptor: (res) => {
+      return res;
+    },
+    responseInterceptorCatch: (err) => {
+      return Promise.reject(err);
+    }
+  }
+});
+var aiRequest = new request_default({
+  baseURL: "https://evoagentx-server.fly.dev",
+  timeout: 6e5,
+  interceptors: {
+    requestInterceptor: (config) => {
+      config.headers = config.headers || {};
+      return config;
+    },
+    requestInterceptorCatch: (err) => {
+      return Promise.reject(err);
+    },
+    responseInterceptor: (res) => {
+      return res;
+    },
+    responseInterceptorCatch: (err) => {
+      return Promise.reject(err);
+    }
+  }
+});
+var workflowRequest = aiRequest;
+function createClient(opts) {
+  const biz = opts?.requestInstance || request;
+  const ai = opts?.aiRequestInstance || aiRequest;
+  let token = null;
+  function applyToken(t) {
+    try {
+      try {
+        if (biz && biz.instance) {
+          if (t) biz.instance.defaults.headers.common["Authorization"] = `Bearer ${t}`;
+          else delete biz.instance.defaults.headers.common["Authorization"];
+        }
+        if (ai && ai.instance) {
+          if (t) ai.instance.defaults.headers.common["Authorization"] = `Bearer ${t}`;
+          else delete ai.instance.defaults.headers.common["Authorization"];
+        }
+      } catch (_e) {
+      }
+    } catch (_e) {
+    }
+  }
+  const runtimeMode = (() => {
+    if (opts?.mode) return opts.mode;
+    try {
+      if (typeof window !== "undefined") return window.self !== window.top ? "embedded" : "standalone";
+    } catch (_e) {
+      return "standalone";
+    }
+    return "standalone";
+  })();
+  async function initToken() {
+    if (opts?.auth?.getToken) {
+      try {
+        const t = await opts.auth.getToken();
+        if (t) {
+          token = t;
+          applyToken(token);
+          return;
+        }
+      } catch (_e) {
+      }
+    }
+    if (runtimeMode === "embedded" && opts?.auth?.tokenInjection) {
+      const allowed = opts.auth.tokenInjection.allowedOrigins || [];
+      const waitMs = opts.auth.tokenInjection.waitMs ?? 3e3;
+      const tokenFromPostMessage = await new Promise((resolve) => {
+        let resolved = false;
+        function handler(ev) {
+          try {
+            if (!ev.data || typeof ev.data !== "object") return;
+            if (ev.data.type !== "howone:token") return;
+            if (allowed.length > 0 && !allowed.includes(ev.origin)) return;
+            const t = ev.data.token;
+            if (t && !resolved) {
+              resolved = true;
+              window.removeEventListener("message", handler);
+              resolve(String(t));
+            }
+          } catch (_e) {
+          }
+        }
+        window.addEventListener("message", handler);
+        setTimeout(() => {
+          if (!resolved) {
+            resolved = true;
+            window.removeEventListener("message", handler);
+            resolve(null);
+          }
+        }, waitMs);
+      });
+      if (tokenFromPostMessage) {
+        token = tokenFromPostMessage;
+        applyToken(token);
+        return;
+      }
+    }
+  }
+  try {
+    if (typeof window !== "undefined") {
+      void initToken();
+    }
+  } catch (_e) {
+  }
+  return {
+    request: biz,
+    aiRequest: ai,
+    workflowRequest: ai,
+    // artifact helpers using artifacts-client
+    artifacts: createArtifactsClient(biz),
+    // auth helpers
+    auth: {
+      setToken: (t) => {
+        token = t;
+        applyToken(t);
+      },
+      getToken: () => token,
+      isAuthenticated: () => Boolean(token),
+      // minimal login/logout stubs - consumers can override behavior
+      login: (redirect) => {
+        if (opts?.authRequired) {
+          if (typeof window !== "undefined") {
+            const loc = redirect || window.location.href;
+            window.location.href = `/login?redirect=${encodeURIComponent(loc)}`;
+          }
+        }
+      },
+      logout: () => {
+        token = null;
+        applyToken(null);
+      }
+    }
+  };
+}
+
+// src/components/auth/LoginForm.tsx
+import { useState, useEffect } from "react";
+import { Icon } from "@iconify/react";
+import { Loader2 } from "lucide-react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var LoginForm = ({
+  onLoginSuccess,
+  appName = "AI Application Platform",
+  className = ""
+}) => {
+  const [email, setEmail] = useState("");
+  const [code, setCode] = useState("");
+  const [validationErrors, setValidationErrors] = useState({});
+  const [isAnyLoading, setIsAnyLoading] = useState(false);
+  const [codeSent, setCodeSent] = useState(false);
+  const [loginError, setLoginError] = useState(null);
+  const googleLogin = async () => {
+    console.log("Google login clicked");
+  };
+  const githubLogin = async () => {
+    console.log("GitHub login clicked");
+  };
+  const sendEmailCode = async (email2) => {
+    console.log("Send code to:", email2, "for app:", appName);
+    setCodeSent(true);
+  };
+  const loginWithEmail = async (email2, code2) => {
+    console.log("Login with email:", email2, "code:", code2);
+    if (onLoginSuccess) onLoginSuccess();
+  };
+  const clearError = () => {
+    setLoginError(null);
+    setValidationErrors({});
+  };
+  useEffect(() => {
+    if (loginError) {
+      try {
+        const errorObj = JSON.parse(loginError);
+        const newErrors = {};
+        if (errorObj.code === 429) {
+          newErrors.form = errorObj.msg || "\u8BF7\u6C42\u8FC7\u4E8E\u9891\u7E41\uFF0C\u8BF7\u7A0D\u540E\u518D\u8BD5";
+        } else if (errorObj.data?.code === 401 && errorObj.data?.message) {
+          if (codeSent) {
+            newErrors.code = errorObj.data.message;
+          } else {
+            newErrors.form = errorObj.data.message;
+          }
+        } else if (errorObj.msg) {
+          newErrors.form = errorObj.msg;
+        } else if (errorObj.data?.message) {
+          newErrors.form = errorObj.data.message;
+        } else {
+          newErrors.form = "\u53D1\u751F\u672A\u77E5\u9519\u8BEF\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+        }
+        setValidationErrors(newErrors);
+      } catch (e) {
+        setValidationErrors({ form: loginError });
+      }
+      const timer = setTimeout(() => {
+        clearError();
+      }, 8e3);
+      return () => clearTimeout(timer);
+    }
+  }, [loginError, codeSent]);
+  const handleSubmit = async (e) => {
+    e.preventDefault();
+    const formData = new FormData(e.currentTarget);
+    setValidationErrors({});
+    if (!codeSent) {
+      const emailValue = formData.get("email");
+      if (!emailValue) {
+        setValidationErrors({ email: "Please enter your email address" });
+        return;
+      }
+      setIsAnyLoading(true);
+      try {
+        await sendEmailCode(emailValue);
+        setEmail(emailValue);
+      } catch (error) {
+        setLoginError(error instanceof Error ? error.message : "Failed to send code");
+      } finally {
+        setIsAnyLoading(false);
+      }
+    } else {
+      const codeValue = code;
+      if (!codeValue || codeValue.length !== 6) {
+        setValidationErrors({ code: "Please enter the 6-digit verification code" });
+        return;
+      }
+      setIsAnyLoading(true);
+      try {
+        await loginWithEmail(email, codeValue);
+      } catch (error) {
+        setLoginError(error instanceof Error ? error.message : "Login failed");
+      } finally {
+        setIsAnyLoading(false);
+      }
+    }
+  };
+  return /* @__PURE__ */ jsxs2("div", { className: `w-full space-y-6 ${className}`, children: [
+    /* @__PURE__ */ jsxs2("div", { className: "space-y-1", children: [
+      /* @__PURE__ */ jsx2("h1", { className: "text-3xl font-bold text-gray-900", children: "Welcome Back!" }),
+      /* @__PURE__ */ jsx2("p", { className: "text-sm text-gray-600", children: "Please enter log in details below" })
+    ] }),
+    /* @__PURE__ */ jsxs2("form", { className: "space-y-5", onSubmit: handleSubmit, children: [
+      /* @__PURE__ */ jsxs2("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsx2("label", { htmlFor: "email", className: "text-gray-700 font-medium text-sm block", children: "Email" }),
+        /* @__PURE__ */ jsx2(
+          "input",
+          {
+            id: "email",
+            type: "email",
+            name: "email",
+            value: email,
+            onChange: (e) => {
+              const value = e.target.value;
+              setEmail(value);
+              if (validationErrors.email) {
+                const newErrors = { ...validationErrors };
+                delete newErrors.email;
+                setValidationErrors(newErrors);
+              }
+            },
+            required: true,
+            "aria-invalid": !!validationErrors.email,
+            className: "w-full text-sm bg-gray-50 rounded-md h-11 px-3 hover:bg-gray-100 focus:bg-white border border-gray-200 focus:border-gray-400 focus:outline-none",
+            placeholder: ""
+          }
+        ),
+        validationErrors.email && /* @__PURE__ */ jsx2("p", { className: "text-red-600 text-sm", children: validationErrors.email })
+      ] }),
+      codeSent && /* @__PURE__ */ jsxs2("div", { className: "space-y-2", children: [
+        /* @__PURE__ */ jsx2("label", { className: "text-gray-700 font-medium text-sm block", children: "Verification Code" }),
+        /* @__PURE__ */ jsx2(
+          "input",
+          {
+            type: "text",
+            maxLength: 6,
+            value: code,
+            onChange: (e) => {
+              const value = e.target.value.replace(/\D/g, "");
+              setCode(value);
+              if (validationErrors.code) {
+                const newErrors = { ...validationErrors };
+                delete newErrors.code;
+                setValidationErrors(newErrors);
+              }
+            },
+            "aria-invalid": !!validationErrors.code,
+            className: "w-full text-center text-sm bg-gray-50 rounded-md h-11 px-3 hover:bg-gray-100 focus:bg-white border border-gray-200 focus:border-gray-400 focus:outline-none tracking-widest",
+            placeholder: "000000"
+          }
+        ),
+        validationErrors.code && /* @__PURE__ */ jsx2("p", { className: "text-red-600 text-sm", children: validationErrors.code })
+      ] }),
+      validationErrors.form && /* @__PURE__ */ jsx2("div", { className: "text-red-600 text-sm p-3 bg-red-50 rounded-md border border-red-200", children: /* @__PURE__ */ jsxs2("div", { className: "flex items-center", children: [
+        /* @__PURE__ */ jsx2(Icon, { icon: "material-symbols:error", className: "text-red-600 mr-2" }),
+        /* @__PURE__ */ jsx2("span", { children: validationErrors.form })
+      ] }) }),
+      /* @__PURE__ */ jsxs2(
+        "button",
+        {
+          type: "submit",
+          className: "w-full h-11 bg-black hover:bg-gray-800 text-white font-medium rounded-md text-sm disabled:opacity-70 flex items-center justify-center",
+          disabled: isAnyLoading || !email || codeSent && code.length !== 6,
+          "aria-busy": isAnyLoading,
+          children: [
+            isAnyLoading && /* @__PURE__ */ jsx2(Loader2, { className: "mr-2 h-4 w-4 animate-spin" }),
+            codeSent ? isAnyLoading ? "Signing in..." : "Sign in" : isAnyLoading ? "Sending..." : "Send Code"
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs2("div", { className: "space-y-3", children: [
+      /* @__PURE__ */ jsxs2("div", { className: "relative", children: [
+        /* @__PURE__ */ jsx2("div", { className: "absolute inset-0 flex items-center", children: /* @__PURE__ */ jsx2("div", { className: "w-full border-t border-gray-200" }) }),
+        /* @__PURE__ */ jsx2("div", { className: "relative flex justify-center text-xs", children: /* @__PURE__ */ jsx2("span", { className: "px-4 text-gray-500", children: "or continue" }) })
+      ] }),
+      /* @__PURE__ */ jsxs2(
+        "button",
+        {
+          className: "w-full h-11 bg-white hover:bg-gray-50 text-gray-900 hover:text-gray-900 border border-gray-200 hover:border-gray-300 font-medium rounded-md text-sm disabled:opacity-70 flex items-center justify-center",
+          onClick: () => {
+            if (!isAnyLoading) {
+              clearError();
+              googleLogin();
+            }
+          },
+          disabled: isAnyLoading,
+          children: [
+            isAnyLoading ? /* @__PURE__ */ jsx2(Loader2, { className: "mr-2 h-4 w-4 animate-spin" }) : /* @__PURE__ */ jsx2(Icon, { icon: "flat-color-icons:google", className: "w-6 h-6 mr-2" }),
+            isAnyLoading ? "Connecting..." : "Log in with Google"
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs2(
+        "button",
+        {
+          className: "w-full h-11 bg-black hover:bg-gray-800 text-white font-medium rounded-md text-sm disabled:opacity-70 flex items-center justify-center",
+          onClick: () => {
+            if (!isAnyLoading) {
+              clearError();
+              githubLogin();
+            }
+          },
+          disabled: isAnyLoading,
+          children: [
+            isAnyLoading ? /* @__PURE__ */ jsx2(Loader2, { className: "mr-2 h-4 w-4 animate-spin" }) : /* @__PURE__ */ jsx2(Icon, { icon: "mdi:github", className: "w-6 h-6 mr-2" }),
+            isAnyLoading ? "Connecting..." : "Log in with GitHub"
+          ]
+        }
+      )
+    ] })
+  ] });
+};
+
+// src/components/auth/AuthGuard.tsx
+import { Navigate, useLocation } from "react-router-dom";
+import { Fragment, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var AuthGuard = ({
+  children,
+  fallback,
+  redirectTo = "/login",
+  requireAuth = true,
+  roles = [],
+  permissions = []
+}) => {
+  const isAuthenticated = false;
+  const user = null;
+  const isLoading = false;
+  const location = useLocation();
+  if (isLoading) {
+    if (fallback) {
+      return /* @__PURE__ */ jsx3(Fragment, { children: fallback });
+    }
+    return /* @__PURE__ */ jsx3("div", { className: "min-h-screen flex items-center justify-center", children: /* @__PURE__ */ jsx3("div", { className: "animate-spin rounded-full h-12 w-12 border-b-2 border-blue-600" }) });
+  }
+  if (requireAuth && !isAuthenticated) {
+    return /* @__PURE__ */ jsx3(Navigate, { to: redirectTo, state: { from: location }, replace: true });
+  }
+  if (roles.length > 0 && user !== null) {
+    const currentUser = user;
+    if (currentUser.roles) {
+      const hasRole = roles.some((role) => currentUser.roles.includes(role));
+      if (!hasRole) {
+        if (fallback) {
+          return /* @__PURE__ */ jsx3(Fragment, { children: fallback });
+        }
+        return /* @__PURE__ */ jsx3("div", { className: "min-h-screen flex items-center justify-center", children: /* @__PURE__ */ jsxs3("div", { className: "text-center", children: [
+          /* @__PURE__ */ jsx3("h1", { className: "text-2xl font-bold text-gray-900 mb-2", children: "Access Denied" }),
+          /* @__PURE__ */ jsx3("p", { className: "text-gray-600", children: "You don't have the required role to access this page." })
+        ] }) });
+      }
+    }
+  }
+  if (permissions.length > 0 && user !== null) {
+    const currentUser = user;
+    if (currentUser.permissions) {
+      const hasPermission = permissions.some((permission) => currentUser.permissions.includes(permission));
+      if (!hasPermission) {
+        if (fallback) {
+          return /* @__PURE__ */ jsx3(Fragment, { children: fallback });
+        }
+        return /* @__PURE__ */ jsx3("div", { className: "min-h-screen flex items-center justify-center", children: /* @__PURE__ */ jsxs3("div", { className: "text-center", children: [
+          /* @__PURE__ */ jsx3("h1", { className: "text-2xl font-bold text-gray-900 mb-2", children: "Access Denied" }),
+          /* @__PURE__ */ jsx3("p", { className: "text-gray-600", children: "You don't have the required permission to access this page." })
+        ] }) });
+      }
+    }
+  }
+  return /* @__PURE__ */ jsx3(Fragment, { children });
+};
+
+// src/components/ui/Loading.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var Loading = ({
+  size = "md",
+  text = "Loading...",
+  className = "",
+  fullScreen = false
+}) => {
+  const sizeClasses = {
+    sm: "h-4 w-4",
+    md: "h-8 w-8",
+    lg: "h-12 w-12"
+  };
+  const containerClasses = fullScreen ? "fixed inset-0 flex items-center justify-center bg-white/80 backdrop-blur-sm z-50" : "flex items-center justify-center p-4";
+  return /* @__PURE__ */ jsx4("div", { className: `${containerClasses} ${className}`, children: /* @__PURE__ */ jsxs4("div", { className: "text-center", children: [
+    /* @__PURE__ */ jsx4(
+      "div",
+      {
+        className: `animate-spin rounded-full border-2 border-gray-300 border-t-blue-600 mx-auto ${sizeClasses[size]}`
+      }
+    ),
+    text && /* @__PURE__ */ jsx4("p", { className: "mt-2 text-sm text-gray-600", children: text })
+  ] }) });
+};
+var LoadingSpinner = ({
+  size = "md",
+  className = ""
+}) => {
+  const sizeClasses = {
+    sm: "h-4 w-4",
+    md: "h-8 w-8",
+    lg: "h-12 w-12"
+  };
+  return /* @__PURE__ */ jsx4(
+    "div",
+    {
+      className: `animate-spin rounded-full border-2 border-gray-300 border-t-blue-600 ${sizeClasses[size]} ${className}`
+    }
+  );
+};
+
+// src/components/ui/ErrorBoundary.tsx
+import { Component } from "react";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var ErrorBoundary = class extends Component {
+  constructor(props) {
+    super(props);
+    this.handleRetry = () => {
+      this.setState({ hasError: false, error: void 0, errorInfo: void 0 });
+    };
+    this.state = { hasError: false };
+  }
+  static getDerivedStateFromError(error) {
+    return { hasError: true, error };
+  }
+  componentDidCatch(error, errorInfo) {
+    this.setState({
+      error,
+      errorInfo
+    });
+    this.props.onError?.(error, errorInfo);
+  }
+  render() {
+    if (this.state.hasError) {
+      if (this.props.fallback) {
+        const FallbackComponent = this.props.fallback;
+        return /* @__PURE__ */ jsx5(FallbackComponent, { error: this.state.error, retry: this.handleRetry });
+      }
+      return /* @__PURE__ */ jsx5("div", { className: "min-h-[400px] flex items-center justify-center p-4", children: /* @__PURE__ */ jsxs5("div", { className: "text-center max-w-md", children: [
+        /* @__PURE__ */ jsx5("div", { className: "text-red-500 text-6xl mb-4", children: "\u26A0\uFE0F" }),
+        /* @__PURE__ */ jsx5("h2", { className: "text-xl font-semibold text-gray-900 mb-2", children: "Something went wrong" }),
+        /* @__PURE__ */ jsx5("p", { className: "text-gray-600 mb-4", children: "An unexpected error occurred. Please try refreshing the page." }),
+        /* @__PURE__ */ jsx5(
+          "button",
+          {
+            onClick: this.handleRetry,
+            className: "px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700 transition-colors",
+            children: "Try Again"
+          }
+        ),
+        false
+      ] }) });
+    }
+    return this.props.children;
+  }
+};
+var DefaultErrorFallback = ({ retry }) => /* @__PURE__ */ jsx5("div", { className: "min-h-[200px] flex items-center justify-center p-4", children: /* @__PURE__ */ jsxs5("div", { className: "text-center", children: [
+  /* @__PURE__ */ jsx5("div", { className: "text-red-500 text-4xl mb-2", children: "\u26A0\uFE0F" }),
+  /* @__PURE__ */ jsx5("p", { className: "text-gray-600 mb-2", children: "Something went wrong" }),
+  retry && /* @__PURE__ */ jsx5(
+    "button",
+    {
+      onClick: retry,
+      className: "px-3 py-1 bg-blue-600 text-white text-sm rounded hover:bg-blue-700 transition-colors",
+      children: "Retry"
+    }
+  )
+] }) });
+
+// src/hooks/use-mobile.ts
+import * as React3 from "react";
+var MOBILE_BREAKPOINT = 768;
+function useIsMobile() {
+  const [isMobile, setIsMobile] = React3.useState(void 0);
+  React3.useEffect(() => {
+    const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`);
+    const onChange = () => {
+      setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+    };
+    mql.addEventListener("change", onChange);
+    setIsMobile(window.innerWidth < MOBILE_BREAKPOINT);
+    return () => mql.removeEventListener("change", onChange);
+  }, []);
+  return !!isMobile;
+}
+
+// src/hooks/use-local-storage.ts
+import { useState as useState3 } from "react";
+function useLocalStorage(key, initialValue) {
+  const [storedValue, setStoredValue] = useState3(() => {
+    try {
+      const item = window.localStorage.getItem(key);
+      return item ? JSON.parse(item) : initialValue;
+    } catch (error) {
+      console.error(`Error reading localStorage key "${key}":`, error);
+      return initialValue;
+    }
+  });
+  const setValue = (value) => {
+    try {
+      const valueToStore = value instanceof Function ? value(storedValue) : value;
+      setStoredValue(valueToStore);
+      window.localStorage.setItem(key, JSON.stringify(valueToStore));
+    } catch (error) {
+      console.error(`Error setting localStorage key "${key}":`, error);
+    }
+  };
+  const removeValue = () => {
+    try {
+      window.localStorage.removeItem(key);
+      setStoredValue(initialValue);
+    } catch (error) {
+      console.error(`Error removing localStorage key "${key}":`, error);
+    }
+  };
+  return [storedValue, setValue, removeValue];
+}
+
+// src/hooks/use-debounce.ts
+import { useState as useState4, useEffect as useEffect3 } from "react";
+function useDebounce(value, delay) {
+  const [debouncedValue, setDebouncedValue] = useState4(value);
+  useEffect3(() => {
+    const handler = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(handler);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+}
+
+// src/utils/earlyErrorHandler.ts
+function injectEarlyErrorHandler() {
+  if (typeof window === "undefined" || typeof document === "undefined") return;
+  const code = `
+  (function () {
+    const isIframe = window.self !== window.top;
+    console.log("isIframe", isIframe);
+
+    console.log("[\u65E9\u671F\u9519\u8BEF\u5904\u7406] \u521D\u59CB\u5316");
+
+    window.__SEND_ERROR_TO_PARENT__ = function (error, details) {
+      try {
+        const errorPayload = {
+          message: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : undefined,
+          filename: details?.file || details?.filename,
+          lineno: details?.line,
+          colno: details?.column,
+          timestamp: Date.now(),
+          type: details?.type || "compile-error",
+          details: details,
+        };
+
+        window.parent.postMessage({ type: "ERROR_EVENT", payload: errorPayload }, "*");
+        console.log("[\u65E9\u671F\u9519\u8BEF\u5904\u7406] \u9519\u8BEF\u5DF2\u53D1\u9001\u5230\u7236\u7A97\u53E3:", errorPayload);
+      } catch (e) {
+        console.error("[\u65E9\u671F\u9519\u8BEF\u5904\u7406] \u53D1\u9001\u9519\u8BEF\u5230\u7236\u7A97\u53E3\u5931\u8D25:", e);
+      }
+    };
+
+    function setupViteOverlayObserver() {
+      if (!window.MutationObserver) return;
+
+      console.log("[\u65E9\u671F\u9519\u8BEF\u5904\u7406] \u8BBE\u7F6E Vite \u9519\u8BEF overlay \u76D1\u542C\u5668");
+
+      function processViteErrorOverlay(overlay) {
+        try {
+          if (overlay.hasAttribute("data-error-sent")) return;
+          const shadowRoot = overlay.shadowRoot;
+          if (!shadowRoot) return;
+
+          const messageElement = shadowRoot.querySelector("pre.message");
+          const fileElement = shadowRoot.querySelector("pre.file");
+          const frameElements = shadowRoot.querySelectorAll("pre.frame");
+          const stackElement = shadowRoot.querySelector("pre.stack");
+
+          const message = messageElement ? messageElement.textContent : "";
+          const file = fileElement ? fileElement.textContent : "";
+          const frames = Array.from(frameElements).map((el) => el.textContent).join("
+");
+          const stack = stackElement ? stackElement.textContent : "";
+
+          let line, column;
+          const fileStr = file || "";
+          const lineColMatch = fileStr.match(/(?:line|at|:)(?:.*?)(?::| )(d+)(?::| )(d+)/i);
+          if (lineColMatch) {
+            line = parseInt(lineColMatch[1], 10);
+            column = parseInt(lineColMatch[2], 10);
+          }
+
+          const messageStr = message || "";
+          const isReactError =
+            messageStr.includes("React") ||
+            messageStr.includes("JSX") ||
+            messageStr.includes("Unexpected token") ||
+            messageStr.includes("vite:react-babel");
+
+          const viteError = new Error(messageStr);
+
+          window.__SEND_ERROR_TO_PARENT__(viteError, {
+            file,
+            line,
+            column,
+            frames,
+            stack,
+            isReactError,
+            type: isReactError ? "react-syntax" : "vite-error-overlay",
+          });
+
+          overlay.setAttribute("data-error-sent", "true");
+        } catch (e) {
+          console.error("[\u65E9\u671F\u9519\u8BEF\u5904\u7406] \u5904\u7406 vite-error-overlay \u5931\u8D25:", e);
+        }
+      }
+
+      function checkExistingOverlays() {
+        const viteErrorOverlays = document.querySelectorAll("vite-error-overlay");
+        if (viteErrorOverlays.length > 0) {
+          viteErrorOverlays.forEach((overlay) => {
+            if (!overlay.hasAttribute("data-error-sent")) {
+              processViteErrorOverlay(overlay);
+            }
+          });
+        }
+      }
+
+      const observer = new MutationObserver((mutations) => {
+        for (const mutation of mutations) {
+          if (mutation.addedNodes.length > 0) {
+            for (const node of Array.from(mutation.addedNodes)) {
+              if (node.nodeType === Node.ELEMENT_NODE) {
+                const element = node;
+                if (element.tagName === "VITE-ERROR-OVERLAY" && !element.hasAttribute("data-error-sent")) {
+                  setTimeout(() => processViteErrorOverlay(element), 100);
+                }
+                const viteErrorOverlays = element.querySelectorAll("vite-error-overlay");
+                for (const viteErrorOverlay of Array.from(viteErrorOverlays)) {
+                  if (!viteErrorOverlay.hasAttribute("data-error-sent")) {
+                    setTimeout(() => processViteErrorOverlay(viteErrorOverlay), 100);
+                  }
+                }
+              }
+            }
+          }
+        }
+      });
+
+      observer.observe(document.documentElement, { childList: true, subtree: true, attributes: true, characterData: true });
+      setTimeout(checkExistingOverlays, 500);
+      setInterval(checkExistingOverlays, 2000);
+    }
+
+    window.addEventListener(
+      "error",
+      function (event) {
+        const target = event && (event.target || event.srcElement);
+        const tagName = target && target.tagName;
+        if (tagName) {
+          const url = (target && (target.src || target.href || target.currentSrc)) || (target && target.getAttribute && (target.getAttribute('src') || target.getAttribute('href')));
+          const preview = target && target.outerHTML ? String(target.outerHTML).slice(0, 300) : undefined;
+          const resourceError = new Error('Resource load error: ' + tagName + ' ' + (url || 'unknown'));
+          window.__SEND_ERROR_TO_PARENT__(resourceError, { filename: url, tagName: tagName, element: preview, type: "resource" });
+          return;
+        }
+
+        var stack = (event && event.error && event.error.stack) || "";
+        var message = typeof event.message === "string" ? event.message : "";
+        if ((stack && stack.indexOf('error-handler') !== -1) || !message) return;
+
+        window.__SEND_ERROR_TO_PARENT__(event.error || new Error(event.message), { filename: event.filename, line: event.lineno, column: event.colno, type: "runtime" });
+      },
+      true
+    );
+
+    window.addEventListener("unhandledrejection", function (event) {
+      const reason = event.reason;
+      window.__SEND_ERROR_TO_PARENT__(reason instanceof Error ? reason : new Error(String(reason)), { type: "promise" });
+    });
+
+    setupViteOverlayObserver();
+
+    if (!window.__CONSOLE_ERROR_INTERCEPTED__) {
+      window.__CONSOLE_ERROR_INTERCEPTED__ = true;
+      const originalConsoleError = console.error;
+      console.error = function () {
+        try {
+          var args = Array.prototype.slice.call(arguments);
+          var first = args[0];
+          var firstStr = typeof first === "string" ? first : "";
+          var isReact = firstStr.indexOf("React") !== -1;
+          var isVite = firstStr.indexOf("[vite]") !== -1 || firstStr.indexOf("Failed to reload") !== -1;
+          if (isReact || isVite) {
+            var joined = args.map(function (a) {
+              if (a instanceof Error) return a.message;
+              if (typeof a === "string") return a;
+              if (a && typeof a.message === "string") return a.message;
+              try { return JSON.stringify(a); } catch (e) { return String(a); }
+            }).join(" ");
+            var errorForReport = new Error(joined);
+            window.__SEND_ERROR_TO_PARENT__(errorForReport, { type: "runtime", viteErrorType: "console" });
+          }
+        } catch (e) { void e }
+        return originalConsoleError.apply(console, arguments);
+      };
+    }
+
+    console.log("[\u65E9\u671F\u9519\u8BEF\u5904\u7406] \u521D\u59CB\u5316\u5B8C\u6210");
+  })();
+  `;
+  try {
+    const script = document.createElement("script");
+    script.type = "text/javascript";
+    script.text = code;
+    const parent = document.head || document.documentElement;
+    parent.prepend(script);
+  } catch (e) {
+    void e;
+  }
+}
+export {
+  AuthGuard,
+  DefaultErrorFallback,
+  ErrorBoundary,
+  FloatingButton,
+  Loading,
+  LoadingSpinner,
+  LoginForm,
+  aiRequest,
+  aiWorkflow,
+  canAccessArtifact,
+  createAIWorkflowClient,
+  createAIWorkflowClientAxios,
+  createArtifactsClient,
+  createClient,
+  getCodeStatus,
+  injectEarlyErrorHandler,
+  loginWithEmailCode,
+  request,
+  sendEmailVerificationCode,
+  unifiedAuth,
+  unifiedOAuth,
+  useDebounce,
+  useIsMobile,
+  useLocalStorage,
+  workflowRequest
+};
+//# sourceMappingURL=index.mjs.map