@kevisual/cli 0.1.4 → 0.1.6

package/dist/envision.js

@@ -21754,7 +21754,8 @@ var {
 // src/program.ts
 import fs from "fs";
 
-// node_modules/.pnpm/@kevisual+context@0.0.6/node_modules/@kevisual/context/dist/app.js
+// node_modules/.pnpm/@kevisual+context@0.0.8/node_modules/@kevisual/context/dist/app.js
+var isBrowser2 = typeof window !== "undefined" && typeof window.document !== "undefined";
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
@@ -22218,7 +22219,7 @@ var useEnv = (initEnv, initKey = "config", isOverwrite) => {
   }
   return gt[initKey];
 };
-var useEnvKey = (key, init, initKey = "config") => {
+var useEnvKey = (key, init, initKey = "config", opts = {}) => {
   const _env = useEnv({}, initKey);
   if (key && typeof _env[key] !== "undefined") {
     return _env[key];
@@ -22244,12 +22245,13 @@ var useEnvKey = (key, init, initKey = "config") => {
     const voidFn = async () => {
       return _env[key];
     };
+    const timeout = opts.timeout || 5 * 60 * 1000;
     const checkFn = async () => {
       const loadRes = await baseLoad.load(voidFn, {
         key,
         isReRun: true,
         checkSuccess: () => _env[key],
-        timeout: 5 * 60 * 1000,
+        timeout,
         interval: 1000
       });
       if (loadRes.code !== 200) {
@@ -22265,27 +22267,28 @@ var useEnvKey = (key, init, initKey = "config") => {
 };
 var useEnvKeyNew = (key, initKey = "config", opts) => {
   const _env = useEnv({}, initKey);
+  const timeout = opts?.timeout;
   if (key) {
     delete _env[key];
   }
   if (opts?.getNew && opts.init) {
-    return useEnvKey(key, opts.init, initKey);
+    return useEnvKey(key, opts.init, initKey, { timeout });
   } else if (opts?.getNew) {
-    return useEnvKey(key, null, initKey);
+    return useEnvKey(key, null, initKey, { timeout });
   }
 };
-var useContextKey = (key, init, isNew) => {
-  if (isNew) {
-    return useEnvKeyNew(key, "context", { getNew: true, init });
+var useContextKey = (key, init, opts) => {
+  if (opts?.isNew) {
+    return useEnvKeyNew(key, "context", { getNew: true, init, ...opts });
   }
-  return useEnvKey(key, init, "context");
+  return useEnvKey(key, init, "context", opts);
 };
 var use = useContextKey;
-var useConfigKey = (key, init, isNew) => {
-  if (isNew) {
-    return useEnvKeyNew(key, "config", { getNew: true, init });
+var useConfigKey = (key, init, opts) => {
+  if (opts?.isNew) {
+    return useEnvKeyNew(key, "config", { getNew: true, init, ...opts });
   }
-  return useEnvKey(key, init, "config");
+  return useEnvKey(key, init, "config", opts);
 };
 
 class InitEnv {
@@ -22309,8 +22312,8 @@ InitEnv.init();
 var version = useContextKey("version", () => {
   let version2 = "0.0.64";
   try {
-    if ("0.1.4")
-      version2 = "0.1.4";
+    if ("0.1.6")
+      version2 = "0.1.6";
   } catch (e) {}
   return version2;
 });
@@ -25123,23 +25126,17 @@ var dist_default6 = createPrompt((config, done) => {
 var import_md5 = __toESM(require_md5(), 1);
 var import_jsonwebtoken = __toESM(require_jsonwebtoken(), 1);
 
-// node_modules/.pnpm/@kevisual+query@0.0.40/node_modules/@kevisual/query/dist/query.js
+// node_modules/.pnpm/@kevisual+query@0.0.49/node_modules/@kevisual/query/dist/query.js
 var isTextForContentType = (contentType) => {
   if (!contentType)
     return false;
-  const textTypes = ["text/", "xml", "html", "javascript", "css", "csv", "plain", "x-www-form-urlencoded", "md"];
+  const textTypes = ["text/", "xml", "html", "javascript", "css", "csv", "plain", "x-www-form-urlencoded", "md", "json"];
   return textTypes.some((type) => contentType.includes(type));
 };
 var adapter = async (opts = {}, overloadOpts) => {
   const controller = new AbortController;
   const signal = controller.signal;
   const isPostFile = opts.isPostFile || false;
-  let responseType = opts.responseType || "json";
-  if (opts.isBlob) {
-    responseType = "blob";
-  } else if (opts.isText) {
-    responseType = "text";
-  }
   const timeout = opts.timeout || 60000 * 3;
   const timer = setTimeout(() => {
     controller.abort();
@@ -25151,7 +25148,7 @@ var adapter = async (opts = {}, overloadOpts) => {
   if (opts?.url?.startsWith("http")) {
     url = new URL(opts.url);
   } else {
-    origin = window?.location?.origin || "http://localhost:51515";
+    origin = globalThis?.location?.origin || "http://localhost:51515";
     url = new URL(opts?.url || "", origin);
   }
   const isGet = method === "GET";
@@ -25198,21 +25195,31 @@ var adapter = async (opts = {}, overloadOpts) => {
     headers
   }).then(async (response) => {
     const contentType = response.headers.get("Content-Type");
-    if (responseType === "blob") {
-      return await response.blob();
-    }
-    const isText = responseType === "text";
     const isJson = contentType && contentType.includes("application/json");
-    if (isJson && !isText) {
-      return await response.json();
+    const isSuccess = response.ok;
+    if (isJson) {
+      const json = await response.json();
+      if (json?.code) {
+        return json;
+      }
+      return {
+        code: isSuccess ? 200 : response.status,
+        status: response.status,
+        data: json
+      };
     } else if (isTextForContentType(contentType)) {
       return {
-        code: response.status,
+        code: isSuccess ? 200 : response.status,
         status: response.status,
         data: await response.text()
       };
     } else {
-      return response;
+      return {
+        code: isSuccess ? 200 : response.status,
+        status: response.status,
+        data: "非文本非JSON响应, 请手动处理response。",
+        response
+      };
     }
   }).catch((err) => {
     if (err.name === "AbortError") {
@@ -25229,28 +25236,17 @@ var adapter = async (opts = {}, overloadOpts) => {
     clearTimeout(timer);
   });
 };
-var setBaseResponse = (res) => {
-  res.success = res.code === 200;
-  res.showError = (fn) => {
-    if (!res.success && !res.noMsg) {
-      fn?.();
-    }
-  };
-  return res;
-};
 var wrapperError = ({ code, message }) => {
   const result = {
     code: code || 500,
-    success: false,
-    message: message || "api request error",
-    showError: (fn) => {},
-    noMsg: true
+    message: message || "请求错误"
   };
   return result;
 };
 
 class Query {
   adapter;
+  baseURL;
   url;
   beforeRequest;
   afterResponse;
@@ -25258,11 +25254,20 @@ class Query {
   timeout;
   stop;
   qws;
-  isClient = false;
+  tokenName;
+  storage;
+  token;
   constructor(opts) {
     this.adapter = opts?.adapter || adapter;
+    this.tokenName = opts?.tokenName || "token";
+    this.storage = opts?.storage || globalThis?.localStorage;
     const defaultURL = opts?.isClient ? "/client/router" : "/api/router";
     this.url = opts?.url || defaultURL;
+    if (this.url.startsWith("http")) {
+      const urlObj = new URL(this.url);
+      this.baseURL = urlObj.origin;
+    }
+    this.baseURL = opts?.baseURL || this.baseURL;
     this.headers = opts?.headers || {
       "Content-Type": "application/json"
     };
@@ -25271,7 +25276,7 @@ class Query {
       this.beforeRequest = opts.beforeRequest;
     } else {
       this.beforeRequest = async (opts2) => {
-        const token = globalThis?.localStorage?.getItem("token");
+        const token = this.token || this.storage?.getItem?.(this.tokenName);
         if (token) {
           opts2.headers = {
             ...opts2.headers,
@@ -25306,13 +25311,20 @@ class Query {
       timeout: _timeout,
       ...rest
     };
+    const isStartsWithHttp = req.url.startsWith("http");
+    if (!isStartsWithHttp) {
+      if (this.baseURL) {
+        const baseURL = new URL(this.baseURL || globalThis?.location?.origin).origin;
+        req.url = baseURL + req.url;
+      }
+    }
     try {
       if (_beforeRequest) {
         const res = await _beforeRequest(req);
         if (res === false) {
           return wrapperError({
             code: 500,
-            message: "request is cancel",
+            message: "请求取消",
             req
           });
         }
@@ -25321,12 +25333,13 @@ class Query {
       console.error("request beforeFn error", e, req);
       return wrapperError({
         code: 500,
-        message: "api request beforeFn error"
+        message: "请求在请求前处理时发生错误",
+        req
       });
     }
     if (this.stop && !options?.noStop) {
       const that = this;
-      await new Promise((resolve) => {
+      const res = await new Promise((resolve) => {
         let timer = 0;
         const detect = setInterval(() => {
           if (!that.stop) {
@@ -25334,11 +25347,20 @@ class Query {
             resolve(true);
           }
           timer++;
-          if (timer > 30) {
-            console.error("request stop: timeout", req.url, timer);
+          if (timer > 5) {
+            console.error("等待请求失败：", req.url, timer);
+            clearInterval(detect);
+            resolve(false);
           }
         }, 1000);
       });
+      if (!res) {
+        return wrapperError({
+          code: 500,
+          message: "请求取消，可能是因为用户未登录或者token过期",
+          req
+        });
+      }
     }
     return _adapter(req).then(async (res) => {
       try {
@@ -25351,10 +25373,11 @@ class Query {
         }
         return res;
       } catch (e) {
-        console.error("request afterFn error", e, req);
+        console.error("请求在响应后处理时发生错误", e, req);
         return wrapperError({
           code: 500,
-          message: "api request afterFn error"
+          message: "请求在响应后处理时发生错误",
+          req
         });
       }
     });
@@ -25391,23 +25414,17 @@ class Query {
   }
 }
 
-// node_modules/.pnpm/@kevisual+query@0.0.40/node_modules/@kevisual/query/dist/query-browser.js
+// node_modules/.pnpm/@kevisual+query@0.0.49/node_modules/@kevisual/query/dist/query-browser.js
 var isTextForContentType2 = (contentType) => {
   if (!contentType)
     return false;
-  const textTypes = ["text/", "xml", "html", "javascript", "css", "csv", "plain", "x-www-form-urlencoded", "md"];
+  const textTypes = ["text/", "xml", "html", "javascript", "css", "csv", "plain", "x-www-form-urlencoded", "md", "json"];
   return textTypes.some((type) => contentType.includes(type));
 };
 var adapter2 = async (opts = {}, overloadOpts) => {
   const controller = new AbortController;
   const signal = controller.signal;
   const isPostFile = opts.isPostFile || false;
-  let responseType = opts.responseType || "json";
-  if (opts.isBlob) {
-    responseType = "blob";
-  } else if (opts.isText) {
-    responseType = "text";
-  }
   const timeout = opts.timeout || 60000 * 3;
   const timer = setTimeout(() => {
     controller.abort();
@@ -25419,7 +25436,7 @@ var adapter2 = async (opts = {}, overloadOpts) => {
   if (opts?.url?.startsWith("http")) {
     url = new URL(opts.url);
   } else {
-    origin = window?.location?.origin || "http://localhost:51515";
+    origin = globalThis?.location?.origin || "http://localhost:51515";
     url = new URL(opts?.url || "", origin);
   }
   const isGet = method === "GET";
@@ -25466,21 +25483,31 @@ var adapter2 = async (opts = {}, overloadOpts) => {
     headers
   }).then(async (response) => {
     const contentType = response.headers.get("Content-Type");
-    if (responseType === "blob") {
-      return await response.blob();
-    }
-    const isText = responseType === "text";
     const isJson = contentType && contentType.includes("application/json");
-    if (isJson && !isText) {
-      return await response.json();
+    const isSuccess = response.ok;
+    if (isJson) {
+      const json = await response.json();
+      if (json?.code) {
+        return json;
+      }
+      return {
+        code: isSuccess ? 200 : response.status,
+        status: response.status,
+        data: json
+      };
     } else if (isTextForContentType2(contentType)) {
       return {
-        code: response.status,
+        code: isSuccess ? 200 : response.status,
         status: response.status,
         data: await response.text()
       };
     } else {
-      return response;
+      return {
+        code: isSuccess ? 200 : response.status,
+        status: response.status,
+        data: "非文本非JSON响应, 请手动处理response。",
+        response
+      };
     }
   }).catch((err) => {
     if (err.name === "AbortError") {
@@ -25500,16 +25527,14 @@ var adapter2 = async (opts = {}, overloadOpts) => {
 var wrapperError2 = ({ code, message }) => {
   const result = {
     code: code || 500,
-    success: false,
-    message: message || "api request error",
-    showError: (fn) => {},
-    noMsg: true
+    message: message || "请求错误"
   };
   return result;
 };
 
 class Query2 {
   adapter;
+  baseURL;
   url;
   beforeRequest;
   afterResponse;
@@ -25517,11 +25542,20 @@ class Query2 {
   timeout;
   stop;
   qws;
-  isClient = false;
+  tokenName;
+  storage;
+  token;
   constructor(opts) {
     this.adapter = opts?.adapter || adapter2;
+    this.tokenName = opts?.tokenName || "token";
+    this.storage = opts?.storage || globalThis?.localStorage;
     const defaultURL = opts?.isClient ? "/client/router" : "/api/router";
     this.url = opts?.url || defaultURL;
+    if (this.url.startsWith("http")) {
+      const urlObj = new URL(this.url);
+      this.baseURL = urlObj.origin;
+    }
+    this.baseURL = opts?.baseURL || this.baseURL;
     this.headers = opts?.headers || {
       "Content-Type": "application/json"
     };
@@ -25530,7 +25564,7 @@ class Query2 {
       this.beforeRequest = opts.beforeRequest;
     } else {
       this.beforeRequest = async (opts2) => {
-        const token = globalThis?.localStorage?.getItem("token");
+        const token = this.token || this.storage?.getItem?.(this.tokenName);
         if (token) {
           opts2.headers = {
             ...opts2.headers,
@@ -25552,9 +25586,9 @@ class Query2 {
   }
   async post(body, options) {
     const url = options?.url || this.url;
-    const { headers, adapter: adapter3, beforeRequest, afterResponse, timeout, ...rest } = options || {};
+    const { headers, adapter: adapter22, beforeRequest, afterResponse, timeout, ...rest } = options || {};
     const _headers = { ...this.headers, ...headers };
-    const _adapter = adapter3 || this.adapter;
+    const _adapter = adapter22 || this.adapter;
     const _beforeRequest = beforeRequest || this.beforeRequest;
     const _afterResponse = afterResponse || this.afterResponse;
     const _timeout = timeout || this.timeout;
@@ -25565,13 +25599,20 @@ class Query2 {
       timeout: _timeout,
       ...rest
     };
+    const isStartsWithHttp = req.url.startsWith("http");
+    if (!isStartsWithHttp) {
+      if (this.baseURL) {
+        const baseURL = new URL(this.baseURL || globalThis?.location?.origin).origin;
+        req.url = baseURL + req.url;
+      }
+    }
     try {
       if (_beforeRequest) {
         const res = await _beforeRequest(req);
         if (res === false) {
           return wrapperError2({
             code: 500,
-            message: "request is cancel",
+            message: "请求取消",
             req
           });
         }
@@ -25580,12 +25621,13 @@ class Query2 {
       console.error("request beforeFn error", e, req);
       return wrapperError2({
         code: 500,
-        message: "api request beforeFn error"
+        message: "请求在请求前处理时发生错误",
+        req
       });
     }
     if (this.stop && !options?.noStop) {
       const that = this;
-      await new Promise((resolve) => {
+      const res = await new Promise((resolve) => {
         let timer = 0;
         const detect = setInterval(() => {
           if (!that.stop) {
@@ -25593,11 +25635,20 @@ class Query2 {
             resolve(true);
           }
           timer++;
-          if (timer > 30) {
-            console.error("request stop: timeout", req.url, timer);
+          if (timer > 5) {
+            console.error("等待请求失败：", req.url, timer);
+            clearInterval(detect);
+            resolve(false);
           }
         }, 1000);
       });
+      if (!res) {
+        return wrapperError2({
+          code: 500,
+          message: "请求取消，可能是因为用户未登录或者token过期",
+          req
+        });
+      }
     }
     return _adapter(req).then(async (res) => {
       try {
@@ -25605,15 +25656,16 @@ class Query2 {
           return await _afterResponse(res, {
             req,
             res,
-            fetch: adapter3
+            fetch: adapter22
           });
         }
         return res;
       } catch (e) {
-        console.error("request afterFn error", e, req);
+        console.error("请求在响应后处理时发生错误", e, req);
         return wrapperError2({
           code: 500,
-          message: "api request afterFn error"
+          message: "请求在响应后处理时发生错误",
+          req
         });
       }
     });
@@ -25675,13 +25727,8 @@ class BaseQuery {
   }
 }
 
-// node_modules/.pnpm/@kevisual+query-login@0.0.7_@kevisual+query@0.0.40/node_modules/@kevisual/query-login/dist/query-login-node.js
-import { homedir } from "os";
-import { join, dirname } from "path";
-import fs4 from "fs";
-import { readFileSync, writeFileSync, accessSync } from "fs";
-import { readFile, writeFile, unlink, mkdir } from "fs/promises";
-var LoginCacheStore = class {
+// node_modules/.pnpm/@kevisual+api@0.0.52_@types+react@19.2.10_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@kevisual/api/query/query-login/login-cache.ts
+class LoginCacheStore {
   cache;
   name;
   cacheData;
@@ -25739,6 +25786,8 @@ var LoginCacheStore = class {
     this.cacheData.id = user.id;
     this.cacheData.accessToken = user.accessToken;
     this.cacheData.refreshToken = user.refreshToken;
+    this.cacheData.accessTokenExpiresIn = user.accessTokenExpiresIn;
+    this.cacheData.createdAt = user.createdAt;
     await this.setValue(this.cacheData);
   }
   getCurrentUser() {
@@ -25776,268 +25825,738 @@ var LoginCacheStore = class {
     this.cacheData.refreshToken = undefined;
     await this.setValue(this.cacheData);
   }
-};
-var QueryLogin = class extends BaseQuery {
-  cacheStore;
-  isBrowser;
-  load;
-  storage;
-  onLoad;
-  constructor(opts) {
-    super({
-      query: opts?.query || new Query2
-    });
-    this.cacheStore = new LoginCacheStore({ name: "login", cache: opts.cache });
-    this.isBrowser = opts?.isBrowser ?? true;
-    this.init();
-    this.onLoad = opts?.onLoad;
-    this.storage = opts?.storage || localStorage;
-  }
-  setQuery(query) {
-    this.query = query;
-  }
-  async init() {
-    await this.cacheStore.init();
-    this.load = true;
-    this.onLoad?.();
-  }
-  async post(data, opts) {
-    try {
-      return this.query.post({ path: "user", ...data }, opts);
-    } catch (error) {
-      console.log("error", error);
-      return {
-        code: 400
-      };
-    }
-  }
-  async login(data) {
-    const res = await this.post({ key: "login", ...data });
-    if (res.code === 200) {
-      const { accessToken, refreshToken } = res?.data || {};
-      this.storage.setItem("token", accessToken || "");
-      await this.beforeSetLoginUser({ accessToken, refreshToken });
-    }
-    return res;
-  }
-  async loginByCode(data) {
-    const res = await this.post({ path: "sms", key: "login", data });
-    if (res.code === 200) {
-      const { accessToken, refreshToken } = res?.data || {};
-      this.storage.setItem("token", accessToken || "");
-      await this.beforeSetLoginUser({ accessToken, refreshToken });
+}
+
+// node_modules/.pnpm/@kevisual+load@0.0.6/node_modules/@kevisual/load/dist/load.js
+function getDefaultExportFromCjs3(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+var eventemitter33 = { exports: {} };
+var hasRequiredEventemitter33;
+function requireEventemitter33() {
+  if (hasRequiredEventemitter33)
+    return eventemitter33.exports;
+  hasRequiredEventemitter33 = 1;
+  (function(module) {
+    var has = Object.prototype.hasOwnProperty, prefix = "~";
+    function Events() {}
+    if (Object.create) {
+      Events.prototype = Object.create(null);
+      if (!new Events().__proto__)
+        prefix = false;
     }
-    return res;
-  }
-  async setLoginToken(token) {
-    const { accessToken, refreshToken } = token;
-    this.storage.setItem("token", accessToken || "");
-    await this.beforeSetLoginUser({ accessToken, refreshToken });
-  }
-  async loginByWechat(data) {
-    const res = await this.post({ path: "wx", key: "open-login", code: data.code });
-    if (res.code === 200) {
-      const { accessToken, refreshToken } = res?.data || {};
-      this.storage.setItem("token", accessToken || "");
-      await this.beforeSetLoginUser({ accessToken, refreshToken });
+    function EE(fn, context, once) {
+      this.fn = fn;
+      this.context = context;
+      this.once = once || false;
     }
-    return res;
-  }
-  async checkWechat({ onSuccess, onError }) {
-    const url = new URL(window.location.href);
-    const code = url.searchParams.get("code");
-    const state = url.searchParams.get("state");
-    if (code && state) {
-      const res = await this.loginByWechat({ code });
-      if (res.code === 200) {
-        onSuccess?.(res.data);
-      } else {
-        onError?.(res);
+    function addListener(emitter, event, fn, context, once) {
+      if (typeof fn !== "function") {
+        throw new TypeError("The listener must be a function");
       }
+      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+      if (!emitter._events[evt])
+        emitter._events[evt] = listener, emitter._eventsCount++;
+      else if (!emitter._events[evt].fn)
+        emitter._events[evt].push(listener);
+      else
+        emitter._events[evt] = [emitter._events[evt], listener];
+      return emitter;
     }
-  }
-  async beforeSetLoginUser({ accessToken, refreshToken, check401 }) {
-    if (accessToken && refreshToken) {
-      const resUser = await this.getMe(accessToken, check401);
-      if (resUser.code === 200) {
-        const user = resUser.data;
-        if (user) {
-          this.cacheStore.setLoginUser({
-            user,
-            id: user.id,
-            accessToken,
-            refreshToken
-          });
-        } else {
-          console.error("登录失败");
-        }
-      }
+    function clearEvent(emitter, evt) {
+      if (--emitter._eventsCount === 0)
+        emitter._events = new Events;
+      else
+        delete emitter._events[evt];
     }
-  }
-  async queryRefreshToken(refreshToken) {
-    const _refreshToken = refreshToken || this.cacheStore.getRefreshToken();
-    let data = { refreshToken: _refreshToken };
-    if (!_refreshToken) {
-      await this.cacheStore.clearCurrentUser();
-      return {
-        code: 401,
-        message: "请先登录",
-        data: {}
-      };
+    function EventEmitter3() {
+      this._events = new Events;
+      this._eventsCount = 0;
     }
-    return this.post({ key: "refreshToken", data }, {
-      afterResponse: async (response, ctx) => {
-        setBaseResponse(response);
-        return response;
+    EventEmitter3.prototype.eventNames = function eventNames() {
+      var names = [], events, name;
+      if (this._eventsCount === 0)
+        return names;
+      for (name in events = this._events) {
+        if (has.call(events, name))
+          names.push(prefix ? name.slice(1) : name);
       }
-    });
-  }
-  async afterCheck401ToRefreshToken(response, ctx, refetch) {
-    const that = this;
-    if (response?.code === 401) {
-      const hasRefreshToken = await that.cacheStore.getRefreshToken();
-      if (hasRefreshToken) {
-        const res = await that.queryRefreshToken(hasRefreshToken);
-        if (res.code === 200) {
-          const { accessToken, refreshToken } = res?.data || {};
-          that.storage.setItem("token", accessToken || "");
-          await that.beforeSetLoginUser({ accessToken, refreshToken, check401: false });
-          if (refetch && ctx && ctx.req && ctx.req.url && ctx.fetch) {
-            await new Promise((resolve) => setTimeout(resolve, 1500));
-            const url = ctx.req?.url;
-            const body = ctx.req?.body;
-            const headers = ctx.req?.headers;
-            const res2 = await ctx.fetch(url, {
-              method: "POST",
-              body,
-              headers: { ...headers, Authorization: `Bearer ${accessToken}` }
-            });
-            setBaseResponse(res2);
-            return res2;
+      if (Object.getOwnPropertySymbols) {
+        return names.concat(Object.getOwnPropertySymbols(events));
+      }
+      return names;
+    };
+    EventEmitter3.prototype.listeners = function listeners(event) {
+      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+      if (!handlers)
+        return [];
+      if (handlers.fn)
+        return [handlers.fn];
+      for (var i = 0, l = handlers.length, ee = new Array(l);i < l; i++) {
+        ee[i] = handlers[i].fn;
+      }
+      return ee;
+    };
+    EventEmitter3.prototype.listenerCount = function listenerCount(event) {
+      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+      if (!listeners)
+        return 0;
+      if (listeners.fn)
+        return 1;
+      return listeners.length;
+    };
+    EventEmitter3.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt])
+        return false;
+      var listeners = this._events[evt], len = arguments.length, args, i;
+      if (listeners.fn) {
+        if (listeners.once)
+          this.removeListener(event, listeners.fn, undefined, true);
+        switch (len) {
+          case 1:
+            return listeners.fn.call(listeners.context), true;
+          case 2:
+            return listeners.fn.call(listeners.context, a1), true;
+          case 3:
+            return listeners.fn.call(listeners.context, a1, a2), true;
+          case 4:
+            return listeners.fn.call(listeners.context, a1, a2, a3), true;
+          case 5:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+          case 6:
+            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+        }
+        for (i = 1, args = new Array(len - 1);i < len; i++) {
+          args[i - 1] = arguments[i];
+        }
+        listeners.fn.apply(listeners.context, args);
+      } else {
+        var length = listeners.length, j;
+        for (i = 0;i < length; i++) {
+          if (listeners[i].once)
+            this.removeListener(event, listeners[i].fn, undefined, true);
+          switch (len) {
+            case 1:
+              listeners[i].fn.call(listeners[i].context);
+              break;
+            case 2:
+              listeners[i].fn.call(listeners[i].context, a1);
+              break;
+            case 3:
+              listeners[i].fn.call(listeners[i].context, a1, a2);
+              break;
+            case 4:
+              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+              break;
+            default:
+              if (!args)
+                for (j = 1, args = new Array(len - 1);j < len; j++) {
+                  args[j - 1] = arguments[j];
+                }
+              listeners[i].fn.apply(listeners[i].context, args);
           }
-        } else {
-          that.storage.removeItem("token");
-          await that.cacheStore.clearCurrentUser();
         }
-        return res;
       }
+      return true;
+    };
+    EventEmitter3.prototype.on = function on(event, fn, context) {
+      return addListener(this, event, fn, context, false);
+    };
+    EventEmitter3.prototype.once = function once(event, fn, context) {
+      return addListener(this, event, fn, context, true);
+    };
+    EventEmitter3.prototype.removeListener = function removeListener(event, fn, context, once) {
+      var evt = prefix ? prefix + event : event;
+      if (!this._events[evt])
+        return this;
+      if (!fn) {
+        clearEvent(this, evt);
+        return this;
+      }
+      var listeners = this._events[evt];
+      if (listeners.fn) {
+        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+          clearEvent(this, evt);
+        }
+      } else {
+        for (var i = 0, events = [], length = listeners.length;i < length; i++) {
+          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+            events.push(listeners[i]);
+          }
+        }
+        if (events.length)
+          this._events[evt] = events.length === 1 ? events[0] : events;
+        else
+          clearEvent(this, evt);
+      }
+      return this;
+    };
+    EventEmitter3.prototype.removeAllListeners = function removeAllListeners(event) {
+      var evt;
+      if (event) {
+        evt = prefix ? prefix + event : event;
+        if (this._events[evt])
+          clearEvent(this, evt);
+      } else {
+        this._events = new Events;
+        this._eventsCount = 0;
+      }
+      return this;
+    };
+    EventEmitter3.prototype.off = EventEmitter3.prototype.removeListener;
+    EventEmitter3.prototype.addListener = EventEmitter3.prototype.on;
+    EventEmitter3.prefixed = prefix;
+    EventEmitter3.EventEmitter = EventEmitter3;
+    {
+      module.exports = EventEmitter3;
     }
-    return response;
-  }
-  async run401Action(response, ctx, opts) {
-    const that = this;
-    const refetch = opts?.refetch ?? false;
-    if (response?.code === 401) {
-      if (that.query.stop === true) {
-        return { code: 500, success: false, message: "refresh token loading..." };
+  })(eventemitter33);
+  return eventemitter33.exports;
+}
+var eventemitter3Exports3 = requireEventemitter33();
+var EventEmitter3 = /* @__PURE__ */ getDefaultExportFromCjs3(eventemitter3Exports3);
+var reRunFn3 = (promiseOpts) => {
+  const timeout = promiseOpts.timeout || 5 * 60 * 1000;
+  const interval = promiseOpts.interval || 1000;
+  const checkSuccess = promiseOpts?.checkSuccess || (() => true);
+  const signal = promiseOpts.signal;
+  return new Promise(async (resolve, reject) => {
+    let intervalId;
+    let timeoutId = setTimeout(() => {
+      clearTimeout(intervalId);
+      resolve({
+        code: 500,
+        message: "timeout"
+      });
+    }, timeout);
+    const fn = promiseOpts.fn || (() => true);
+    const runFn = async () => {
+      if (signal?.aborted) {
+        clearInterval(intervalId);
+        clearTimeout(timeoutId);
+        return resolve({
+          code: 499,
+          message: "operation cancelled"
+        });
       }
-      that.query.stop = true;
-      const res = await that.afterCheck401ToRefreshToken(response, ctx, refetch);
-      that.query.stop = false;
-      opts?.afterCheck?.(res);
-      if (res.code === 401) {
-        opts?.afterAlso401?.(res);
+      const res = await fn();
+      if (!!checkSuccess(res)) {
+        clearInterval(intervalId);
+        clearTimeout(timeoutId);
+        resolve({
+          code: 200,
+          data: res
+        });
+      } else {
+        setTimeout(() => {
+          runFn();
+        }, interval);
       }
-      return res;
-    } else {
-      return response;
+    };
+    if (signal) {
+      signal.addEventListener("abort", () => {
+        clearInterval(intervalId);
+        clearTimeout(timeoutId);
+        resolve({
+          code: 499,
+          message: "operation cancelled"
+        });
+      });
     }
+    runFn();
+  });
+};
+
+class BaseLoad3 {
+  modules = new Map;
+  event;
+  loading;
+  static reRunFn = reRunFn3;
+  timeout = 5 * 60 * 1000;
+  constructor() {
+    this.event = new EventEmitter3;
+    this.loading = false;
   }
-  async getMe(token, check401 = true) {
-    const _token = token || this.storage.getItem("token");
-    const that = this;
-    return that.post({ key: "me" }, {
-      beforeRequest: async (config) => {
-        if (config.headers) {
-          config.headers["Authorization"] = `Bearer ${_token}`;
+  listenKey(key, listenOpts) {
+    const timeout = listenOpts?.timeout ?? this.timeout;
+    return new Promise((resolve) => {
+      const timeoutId = setTimeout(() => {
+        this.event.removeListener(key, onEvent);
+        resolve({
+          code: 500,
+          message: "timeout"
+        });
+      }, timeout);
+      const onEvent = (error) => {
+        clearTimeout(timeoutId);
+        if (error) {
+          return resolve({
+            code: 500,
+            message: error
+          });
         }
-        if (!_token) {}
-        return config;
-      },
-      afterResponse: async (response, ctx) => {
-        if (response?.code === 401 && check401 && !token) {
-          return await that.afterCheck401ToRefreshToken(response, ctx);
+        const data = this.modules.get(key);
+        if (data?.loadSuccessClear) {
+          this.remove(key);
         }
-        return response;
-      }
+        resolve({
+          code: 200,
+          data: data?.modules
+        });
+      };
+      this.event.once(key, onEvent);
     });
   }
-  async checkLocalUser() {
-    const user = await this.cacheStore.getCurrentUser();
-    if (user) {
-      return user;
+  async hasLoaded(key, hasLoadOpts) {
+    if (!key) {
+      return {
+        code: 404,
+        message: "key is required"
+      };
     }
-    return null;
+    const has = this.modules.has(key);
+    if (!has) {
+      const isExist = hasLoadOpts?.isExist ?? true;
+      const timeout = hasLoadOpts?.timeout ?? this.timeout;
+      if (isExist) {
+        return await this.listenKey(key, { timeout });
+      }
+      return {
+        code: 404
+      };
+    }
+    const data = this.modules.get(key);
+    if (data?.status === "loaded") {
+      return {
+        code: 200,
+        data: data.modules
+      };
+    }
+    if (data?.status === "loading") {
+      return await this.listenKey(key, { timeout: hasLoadOpts?.timeout ?? this.timeout });
+    }
+    if (data?.status === "error") {
+      return {
+        code: 500,
+        message: "load error"
+      };
+    }
+    if (data?.status === "cancel") {
+      return {
+        code: 499,
+        message: "operation cancelled"
+      };
+    }
+    return {
+      code: 404
+    };
   }
-  async checkLocalToken() {
-    const token = this.storage.getItem("token");
-    return !!token;
+  async loadFn(loadContent, opts) {
+    const key = opts.key;
+    if (!key) {
+      return {
+        code: 404,
+        message: "key is required"
+      };
+    }
+    const newModule = {
+      key: opts.key,
+      status: "loading",
+      loading: true,
+      loadSuccessClear: opts.loadSuccessClear ?? true
+    };
+    let errorMessage = "";
+    try {
+      const isReRun = opts.isReRun ?? false;
+      let res;
+      if (!isReRun) {
+        this.modules.set(key, newModule);
+        res = await loadContent();
+      } else {
+        newModule.controller = new AbortController;
+        const signal = newModule.controller.signal;
+        this.modules.set(key, newModule);
+        const data = await reRunFn3({
+          timeout: opts.timeout,
+          interval: opts.interval,
+          checkSuccess: opts.checkSuccess,
+          fn: loadContent,
+          signal
+        });
+        newModule.controller = null;
+        if (data.code === 499) {
+          newModule.status = "cancel";
+          return {
+            code: 499,
+            message: "operation cancelled"
+          };
+        }
+        if (data.code !== 200) {
+          throw new Error(data.message);
+        }
+        res = data.data;
+      }
+      newModule.modules = res;
+      newModule.status = "loaded";
+      return {
+        code: 200,
+        data: res
+      };
+    } catch (error) {
+      errorMessage = error.message;
+      newModule.status = "error";
+      return {
+        code: 500,
+        message: error
+      };
+    } finally {
+      newModule.loading = false;
+      this.modules.set(opts.key, newModule);
+      if (!errorMessage) {
+        this.event.emit(opts.key);
+      } else {
+        this.event.emit(opts.key, errorMessage);
+      }
+    }
   }
-  async postSwitchUser(username) {
-    return this.post({ key: "switchCheck", data: { username } });
+  async load(loadContent, opts) {
+    this.loading = true;
+    const key = opts.key;
+    if (!key) {
+      return {
+        code: 404,
+        message: "key is required"
+      };
+    }
+    if (opts?.force) {
+      this.remove(key);
+    }
+    const has = this.modules.has(key);
+    if (has) {
+      return await this.hasLoaded(key);
+    }
+    if (typeof loadContent === "function") {
+      return this.loadFn(loadContent, opts);
+    }
+    console.error("loadContent is not a function and not has loaded");
   }
-  async switchUser(username) {
-    const localUserList = await this.cacheStore.getCurrentUserList();
-    const user = localUserList.find((userItem) => userItem.user.username === username);
-    if (user) {
-      this.storage.setItem("token", user.accessToken || "");
-      await this.beforeSetLoginUser({ accessToken: user.accessToken, refreshToken: user.refreshToken });
+  remove(key) {
+    const has = this.modules.has(key);
+    if (has) {
+      this.checkRemoveController(key);
+      this.modules.delete(key);
+    }
+  }
+  emitLoaded(key) {
+    this.checkRemoveController(key);
+    this.event.emit(key);
+  }
+  setModule(key, data, loadData) {
+    const newModule = {
+      key,
+      status: "loaded",
+      loading: false,
+      modules: data || {},
+      ...loadData
+    };
+    this.modules.set(key, newModule);
+    this.emitLoaded(key);
+    return newModule;
+  }
+  cancel(key) {
+    this.checkRemoveController(key);
+  }
+  checkRemoveController(key) {
+    const data = this.modules.get(key);
+    if (data?.controller) {
+      data.controller?.abort?.();
+      delete data.controller;
+      this.modules.set(key, data);
+    }
+  }
+}
+
+// node_modules/.pnpm/@kevisual+api@0.0.52_@types+react@19.2.10_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@kevisual/api/query/query-login/query-login.ts
+class QueryLogin extends BaseQuery {
+  cacheStore;
+  isBrowser;
+  load;
+  storage;
+  onLoad;
+  constructor(opts) {
+    super({
+      query: opts?.query || new Query2
+    });
+    this.cacheStore = new LoginCacheStore({ name: "login", cache: opts?.cache });
+    this.isBrowser = opts?.isBrowser ?? true;
+    this.init();
+    this.onLoad = opts?.onLoad;
+    this.storage = opts?.storage || globalThis?.localStorage;
+  }
+  setQuery(query) {
+    this.query = query;
+  }
+  async init() {
+    await this.cacheStore.init();
+    this.load = true;
+    this.onLoad?.();
+  }
+  async post(data, opts) {
+    try {
+      return this.query.post({ path: "user", ...data }, opts);
+    } catch (error) {
+      console.log("error", error);
       return {
-        code: 200,
-        data: {
-          accessToken: user.accessToken,
-          refreshToken: user.refreshToken
-        },
-        success: true,
-        message: "切换用户成功"
+        code: 400
       };
     }
-    const res = await this.postSwitchUser(username);
+  }
+  async login(data) {
+    const res = await this.post({ key: "login", ...data });
     if (res.code === 200) {
-      const { accessToken, refreshToken } = res?.data || {};
+      const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
       this.storage.setItem("token", accessToken || "");
-      await this.beforeSetLoginUser({ accessToken, refreshToken });
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
     }
     return res;
   }
-  async logout() {
-    this.storage.removeItem("token");
-    const users = await this.cacheStore.getCurrentUserList();
-    const tokens = users.map((user) => {
-      return user?.accessToken;
-    }).filter(Boolean);
-    this.cacheStore.delValue();
-    return this.post({ key: "logout", data: { tokens } });
+  async loginByCode(data) {
+    const res = await this.post({ path: "sms", key: "login", data });
+    if (res.code === 200) {
+      const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
+      this.storage.setItem("token", accessToken || "");
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
+    }
+    return res;
   }
-  async hasUser(username) {
-    const that = this;
-    return this.post({
-      path: "org",
-      key: "hasUser",
-      data: {
-        username
-      }
-    }, {
-      afterResponse: async (response, ctx) => {
-        if (response?.code === 401) {
-          const res = await that.afterCheck401ToRefreshToken(response, ctx, true);
-          return res;
-        }
-        return response;
-      }
-    });
+  async setLoginToken(token) {
+    const { accessToken, refreshToken, accessTokenExpiresIn } = token;
+    this.storage.setItem("token", accessToken || "");
+    await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
   }
-  async checkLoginStatus(token) {
-    const res = await this.post({
-      path: "user",
-      key: "checkLoginStatus",
-      loginToken: token
-    });
+  async loginByWechat(data) {
+    const res = await this.post({ path: "wx", key: "open-login", code: data.code });
     if (res.code === 200) {
-      const accessToken = res.data?.accessToken;
+      const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
       this.storage.setItem("token", accessToken || "");
-      await this.beforeSetLoginUser({ accessToken, refreshToken: res.data?.refreshToken });
-      return res;
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
+    }
+    return res;
+  }
+  async checkWechat({ onSuccess, onError }) {
+    const url = new URL(window.location.href);
+    const code = url.searchParams.get("code");
+    const state = url.searchParams.get("state");
+    if (code && state) {
+      const res = await this.loginByWechat({ code });
+      if (res.code === 200) {
+        onSuccess?.(res.data);
+      } else {
+        onError?.(res);
+      }
+    }
+  }
+  async beforeSetLoginUser({ accessToken, refreshToken, check401, accessTokenExpiresIn }) {
+    if (accessToken && refreshToken) {
+      const resUser = await this.getMe(accessToken, check401);
+      if (resUser.code === 200) {
+        const user = resUser.data;
+        if (user) {
+          this.cacheStore.setLoginUser({
+            user,
+            id: user.id,
+            accessToken,
+            refreshToken,
+            accessTokenExpiresIn,
+            createdAt: Date.now()
+          });
+        } else {
+          console.error("登录失败");
+        }
+      }
+    }
+  }
+  async queryRefreshToken(refreshToken) {
+    const _refreshToken = refreshToken || this.cacheStore.getRefreshToken();
+    let data = { refreshToken: _refreshToken };
+    if (!_refreshToken) {
+      await this.cacheStore.clearCurrentUser();
+      return {
+        code: 401,
+        message: "请先登录",
+        data: {}
+      };
+    }
+    return this.post({ key: "refreshToken", data }, {
+      afterResponse: async (response, ctx) => {
+        return response;
+      }
+    });
+  }
+  async afterCheck401ToRefreshToken(response, ctx, refetch) {
+    const that = this;
+    if (response?.code === 401) {
+      const hasRefreshToken = await that.cacheStore.getRefreshToken();
+      if (hasRefreshToken) {
+        const res = await that.queryRefreshToken(hasRefreshToken);
+        if (res.code === 200) {
+          const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
+          that.storage.setItem("token", accessToken || "");
+          await that.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn, check401: false });
+          if (refetch && ctx && ctx.req && ctx.req.url && ctx.fetch) {
+            await new Promise((resolve) => setTimeout(resolve, 1500));
+            const url = ctx.req?.url;
+            const body = ctx.req?.body;
+            const headers = ctx.req?.headers;
+            const res2 = await ctx.fetch(url, {
+              method: "POST",
+              body,
+              headers: { ...headers, Authorization: `Bearer ${accessToken}` }
+            });
+            return res2;
+          }
+        } else {
+          that.storage.removeItem("token");
+          await that.cacheStore.clearCurrentUser();
+        }
+        return res;
+      }
+    }
+    return response;
+  }
+  async run401Action(response, ctx, opts) {
+    const that = this;
+    const refetch = opts?.refetch ?? false;
+    if (response?.code === 401) {
+      if (that.query.stop === true) {
+        return { code: 500, success: false, message: "refresh token loading..." };
+      }
+      that.query.stop = true;
+      const res = await that.afterCheck401ToRefreshToken(response, ctx, refetch);
+      that.query.stop = false;
+      opts?.afterCheck?.(res);
+      if (res.code === 401) {
+        opts?.afterAlso401?.(res);
+      }
+      return res;
+    } else {
+      return response;
+    }
+  }
+  async getMe(token, check401 = true) {
+    const _token = token || this.storage.getItem("token");
+    const that = this;
+    return that.post({ key: "me" }, {
+      beforeRequest: async (config) => {
+        if (config.headers) {
+          config.headers["Authorization"] = `Bearer ${_token}`;
+        }
+        if (!_token) {
+          return false;
+        }
+        return config;
+      },
+      afterResponse: async (response, ctx) => {
+        if (response?.code === 401 && check401 && !token) {
+          return await that.afterCheck401ToRefreshToken(response, ctx);
+        }
+        return response;
+      }
+    });
+  }
+  async checkLocalUser() {
+    const user = await this.cacheStore.getCurrentUser();
+    if (user) {
+      return user;
+    }
+    return null;
+  }
+  async checkLocalToken() {
+    const token = this.storage.getItem("token");
+    return !!token;
+  }
+  async getToken() {
+    const token = this.storage.getItem("token");
+    return token || "";
+  }
+  async beforeRequest(opts = {}) {
+    const token = this.storage.getItem("token");
+    if (token) {
+      opts.headers = { ...opts.headers, Authorization: `Bearer ${token}` };
+    }
+    return opts;
+  }
+  async postSwitchUser(username) {
+    return this.post({ key: "switchCheck", data: { username } });
+  }
+  async switchUser(username) {
+    const localUserList = await this.cacheStore.getCurrentUserList();
+    const user = localUserList.find((userItem) => userItem.user.username === username);
+    if (user) {
+      this.storage.setItem("token", user.accessToken || "");
+      await this.beforeSetLoginUser({
+        accessToken: user.accessToken,
+        refreshToken: user.refreshToken,
+        accessTokenExpiresIn: user.accessTokenExpiresIn
+      });
+      return {
+        code: 200,
+        data: {
+          accessToken: user.accessToken,
+          refreshToken: user.refreshToken,
+          accessTokenExpiresIn: user.accessTokenExpiresIn
+        },
+        success: true,
+        message: "切换用户成功"
+      };
+    }
+    const res = await this.postSwitchUser(username);
+    if (res.code === 200) {
+      const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
+      this.storage.setItem("token", accessToken || "");
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
+    }
+    return res;
+  }
+  async logout() {
+    this.storage.removeItem("token");
+    const users = await this.cacheStore.getCurrentUserList();
+    const tokens = users.map((user) => {
+      return user?.accessToken;
+    }).filter(Boolean);
+    this.cacheStore.delValue();
+    return this.post({ key: "logout", data: { tokens } });
+  }
+  async hasUser(username) {
+    const that = this;
+    return this.post({
+      path: "org",
+      key: "hasUser",
+      data: {
+        username
+      }
+    }, {
+      afterResponse: async (response, ctx) => {
+        if (response?.code === 401) {
+          const res = await that.afterCheck401ToRefreshToken(response, ctx, true);
+          return res;
+        }
+        return response;
+      }
+    });
+  }
+  async checkLoginStatus(token) {
+    const res = await this.post({
+      path: "user",
+      key: "checkLoginStatus",
+      loginToken: token
+    });
+    if (res.code === 200) {
+      const { accessTokenExpiresIn, accessToken, refreshToken } = res.data;
+      this.storage.setItem("token", accessToken || "");
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
+      return res;
     }
     return false;
   }
@@ -26045,14 +26564,60 @@ var QueryLogin = class extends BaseQuery {
     const randomId = Math.random().toString(36).substring(2, 15);
     const timestamp = Date.now();
     const tokenSecret = "xiao" + randomId;
-    const sign = MD5(`${tokenSecret}${timestamp}`).toString();
-    const token = jsonwebtoken.sign({ randomId, timestamp, sign }, tokenSecret, {
-      expiresIn: 60 * 10
-    });
+    let sign = "";
+    if (MD5) {
+      sign = MD5(`${tokenSecret}${timestamp}`).toString();
+    }
+    let token = "";
+    if (jsonwebtoken) {
+      token = jsonwebtoken.sign({ randomId, timestamp, sign }, tokenSecret, {
+        expiresIn: 60 * 10
+      });
+    } else {
+      token = tokenSecret;
+    }
     const url = `${baseURL}/api/router?path=user&key=webLogin&p&loginToken=${token}&sign=${sign}&randomId=${randomId}`;
     return { url, token, tokenSecret };
   }
-};
+  async pollLoginStatus(data) {
+    const token = data.token;
+    const load2 = new BaseLoad3;
+    load2.load(async () => {
+      const res2 = await this.checkLoginStatus(token);
+      if (res2.code === 500) {
+        load2.cancel("check-login-status");
+      }
+      return res2;
+    }, {
+      key: "check-login-status",
+      isReRun: true,
+      checkSuccess: (data2) => {
+        return data2?.code === 200;
+      }
+    });
+    const res = await load2.hasLoaded("check-login-status", {
+      timeout: 60 * 3 * 1000
+    });
+    if (res.code === 200 && res.data?.code === 200) {
+      try {
+        console.log("网页登录成功");
+        return true;
+      } catch (error) {
+        console.log("登录失败", error);
+        return false;
+      }
+    }
+    console.log("登录失败", res);
+    return false;
+  }
+}
+
+// node_modules/.pnpm/@kevisual+api@0.0.52_@types+react@19.2.10_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@kevisual/api/query/query-login/login-node-cache.ts
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import fs4 from "node:fs";
+import { readFileSync, writeFileSync, accessSync } from "node:fs";
+import { readFile, writeFile, unlink, mkdir } from "node:fs/promises";
 var fileExists = async (filePath, { createIfNotExists = true, isFile = true, isDir = false } = {}) => {
   try {
     accessSync(filePath, fs4.constants.F_OK);
@@ -26088,7 +26653,8 @@ var getHostName = () => {
   const hostname = new URL(baseURL).hostname;
   return hostname;
 };
-var StorageNode = class {
+
+class StorageNode {
   cacheData;
   filePath;
   constructor() {
@@ -26129,8 +26695,9 @@ var StorageNode = class {
   key(index) {
     return Object.keys(this.cacheData)[index];
   }
-};
-var LoginNodeCache = class {
+}
+
+class LoginNodeCache {
   filepath;
   constructor(filepath) {
     this.filepath = filepath || join(homedir(), ".config", "envision", "config", `${getHostName()}-login.json`);
@@ -26173,10 +26740,13 @@ var LoginNodeCache = class {
   async init() {
     return await this.loadCache(this.filepath);
   }
-};
+}
+
+// node_modules/.pnpm/@kevisual+api@0.0.52_@types+react@19.2.10_react-dom@19.2.4_react@19.2.4__react@19.2.4/node_modules/@kevisual/api/query/query-login/query-login-node.ts
 var storage = new StorageNode;
 await storage.loadCache();
-var QueryLoginNode = class extends QueryLogin {
+
+class QueryLoginNode extends QueryLogin {
   constructor(opts) {
     super({
       ...opts,
@@ -26184,7 +26754,7 @@ var QueryLoginNode = class extends QueryLogin {
       cache: new LoginNodeCache
     });
   }
-};
+}
 
 // src/module/query.ts
 var config = getConfig2();
@@ -26572,612 +27142,162 @@ function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
   returnValue += string.slice(endIndex);
   return returnValue;
 }
-
-// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
-var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
-var GENERATOR = Symbol("GENERATOR");
-var STYLER = Symbol("STYLER");
-var IS_EMPTY = Symbol("IS_EMPTY");
-var levelMapping = [
-  "ansi",
-  "ansi",
-  "ansi256",
-  "ansi16m"
-];
-var styles2 = Object.create(null);
-var applyOptions = (object, options = {}) => {
-  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
-    throw new Error("The `level` option should be an integer from 0 to 3");
-  }
-  const colorLevel = stdoutColor ? stdoutColor.level : 0;
-  object.level = options.level === undefined ? colorLevel : options.level;
-};
-
-class Chalk {
-  constructor(options) {
-    return chalkFactory(options);
-  }
-}
-var chalkFactory = (options) => {
-  const chalk = (...strings) => strings.join(" ");
-  applyOptions(chalk, options);
-  Object.setPrototypeOf(chalk, createChalk.prototype);
-  return chalk;
-};
-function createChalk(options) {
-  return chalkFactory(options);
-}
-Object.setPrototypeOf(createChalk.prototype, Function.prototype);
-for (const [styleName, style] of Object.entries(ansi_styles_default)) {
-  styles2[styleName] = {
-    get() {
-      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
-      Object.defineProperty(this, styleName, { value: builder });
-      return builder;
-    }
-  };
-}
-styles2.visible = {
-  get() {
-    const builder = createBuilder(this, this[STYLER], true);
-    Object.defineProperty(this, "visible", { value: builder });
-    return builder;
-  }
-};
-var getModelAnsi = (model, level, type, ...arguments_) => {
-  if (model === "rgb") {
-    if (level === "ansi16m") {
-      return ansi_styles_default[type].ansi16m(...arguments_);
-    }
-    if (level === "ansi256") {
-      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
-    }
-    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
-  }
-  if (model === "hex") {
-    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
-  }
-  return ansi_styles_default[type][model](...arguments_);
-};
-var usedModels = ["rgb", "hex", "ansi256"];
-for (const model of usedModels) {
-  styles2[model] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
-  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
-  styles2[bgModel] = {
-    get() {
-      const { level } = this;
-      return function(...arguments_) {
-        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
-        return createBuilder(this, styler, this[IS_EMPTY]);
-      };
-    }
-  };
-}
-var proto = Object.defineProperties(() => {}, {
-  ...styles2,
-  level: {
-    enumerable: true,
-    get() {
-      return this[GENERATOR].level;
-    },
-    set(level) {
-      this[GENERATOR].level = level;
-    }
-  }
-});
-var createStyler = (open, close, parent) => {
-  let openAll;
-  let closeAll;
-  if (parent === undefined) {
-    openAll = open;
-    closeAll = close;
-  } else {
-    openAll = parent.openAll + open;
-    closeAll = close + parent.closeAll;
-  }
-  return {
-    open,
-    close,
-    openAll,
-    closeAll,
-    parent
-  };
-};
-var createBuilder = (self2, _styler, _isEmpty) => {
-  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
-  Object.setPrototypeOf(builder, proto);
-  builder[GENERATOR] = self2;
-  builder[STYLER] = _styler;
-  builder[IS_EMPTY] = _isEmpty;
-  return builder;
-};
-var applyStyle = (self2, string) => {
-  if (self2.level <= 0 || !string) {
-    return self2[IS_EMPTY] ? "" : string;
-  }
-  let styler = self2[STYLER];
-  if (styler === undefined) {
-    return string;
-  }
-  const { openAll, closeAll } = styler;
-  if (string.includes("\x1B")) {
-    while (styler !== undefined) {
-      string = stringReplaceAll(string, styler.close, styler.open);
-      styler = styler.parent;
-    }
-  }
-  const lfIndex = string.indexOf(`
-`);
-  if (lfIndex !== -1) {
-    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
-  }
-  return openAll + string + closeAll;
-};
-Object.defineProperties(createChalk.prototype, styles2);
-var chalk = createChalk();
-var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
-var source_default = chalk;
-
-// src/module/chalk.ts
-var chalk2 = new Chalk({ level: 3 });
-
-// node_modules/.pnpm/@kevisual+load@0.0.6/node_modules/@kevisual/load/dist/load.js
-function getDefaultExportFromCjs3(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
-}
-var eventemitter33 = { exports: {} };
-var hasRequiredEventemitter33;
-function requireEventemitter33() {
-  if (hasRequiredEventemitter33)
-    return eventemitter33.exports;
-  hasRequiredEventemitter33 = 1;
-  (function(module) {
-    var has = Object.prototype.hasOwnProperty, prefix = "~";
-    function Events() {}
-    if (Object.create) {
-      Events.prototype = Object.create(null);
-      if (!new Events().__proto__)
-        prefix = false;
-    }
-    function EE(fn, context, once) {
-      this.fn = fn;
-      this.context = context;
-      this.once = once || false;
-    }
-    function addListener(emitter, event, fn, context, once) {
-      if (typeof fn !== "function") {
-        throw new TypeError("The listener must be a function");
-      }
-      var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
-      if (!emitter._events[evt])
-        emitter._events[evt] = listener, emitter._eventsCount++;
-      else if (!emitter._events[evt].fn)
-        emitter._events[evt].push(listener);
-      else
-        emitter._events[evt] = [emitter._events[evt], listener];
-      return emitter;
-    }
-    function clearEvent(emitter, evt) {
-      if (--emitter._eventsCount === 0)
-        emitter._events = new Events;
-      else
-        delete emitter._events[evt];
-    }
-    function EventEmitter3() {
-      this._events = new Events;
-      this._eventsCount = 0;
-    }
-    EventEmitter3.prototype.eventNames = function eventNames() {
-      var names = [], events, name;
-      if (this._eventsCount === 0)
-        return names;
-      for (name in events = this._events) {
-        if (has.call(events, name))
-          names.push(prefix ? name.slice(1) : name);
-      }
-      if (Object.getOwnPropertySymbols) {
-        return names.concat(Object.getOwnPropertySymbols(events));
-      }
-      return names;
-    };
-    EventEmitter3.prototype.listeners = function listeners(event) {
-      var evt = prefix ? prefix + event : event, handlers = this._events[evt];
-      if (!handlers)
-        return [];
-      if (handlers.fn)
-        return [handlers.fn];
-      for (var i = 0, l = handlers.length, ee = new Array(l);i < l; i++) {
-        ee[i] = handlers[i].fn;
-      }
-      return ee;
-    };
-    EventEmitter3.prototype.listenerCount = function listenerCount(event) {
-      var evt = prefix ? prefix + event : event, listeners = this._events[evt];
-      if (!listeners)
-        return 0;
-      if (listeners.fn)
-        return 1;
-      return listeners.length;
-    };
-    EventEmitter3.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
-      var evt = prefix ? prefix + event : event;
-      if (!this._events[evt])
-        return false;
-      var listeners = this._events[evt], len = arguments.length, args, i;
-      if (listeners.fn) {
-        if (listeners.once)
-          this.removeListener(event, listeners.fn, undefined, true);
-        switch (len) {
-          case 1:
-            return listeners.fn.call(listeners.context), true;
-          case 2:
-            return listeners.fn.call(listeners.context, a1), true;
-          case 3:
-            return listeners.fn.call(listeners.context, a1, a2), true;
-          case 4:
-            return listeners.fn.call(listeners.context, a1, a2, a3), true;
-          case 5:
-            return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
-          case 6:
-            return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
-        }
-        for (i = 1, args = new Array(len - 1);i < len; i++) {
-          args[i - 1] = arguments[i];
-        }
-        listeners.fn.apply(listeners.context, args);
-      } else {
-        var length = listeners.length, j;
-        for (i = 0;i < length; i++) {
-          if (listeners[i].once)
-            this.removeListener(event, listeners[i].fn, undefined, true);
-          switch (len) {
-            case 1:
-              listeners[i].fn.call(listeners[i].context);
-              break;
-            case 2:
-              listeners[i].fn.call(listeners[i].context, a1);
-              break;
-            case 3:
-              listeners[i].fn.call(listeners[i].context, a1, a2);
-              break;
-            case 4:
-              listeners[i].fn.call(listeners[i].context, a1, a2, a3);
-              break;
-            default:
-              if (!args)
-                for (j = 1, args = new Array(len - 1);j < len; j++) {
-                  args[j - 1] = arguments[j];
-                }
-              listeners[i].fn.apply(listeners[i].context, args);
-          }
-        }
-      }
-      return true;
-    };
-    EventEmitter3.prototype.on = function on(event, fn, context) {
-      return addListener(this, event, fn, context, false);
-    };
-    EventEmitter3.prototype.once = function once(event, fn, context) {
-      return addListener(this, event, fn, context, true);
-    };
-    EventEmitter3.prototype.removeListener = function removeListener(event, fn, context, once) {
-      var evt = prefix ? prefix + event : event;
-      if (!this._events[evt])
-        return this;
-      if (!fn) {
-        clearEvent(this, evt);
-        return this;
-      }
-      var listeners = this._events[evt];
-      if (listeners.fn) {
-        if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
-          clearEvent(this, evt);
-        }
-      } else {
-        for (var i = 0, events = [], length = listeners.length;i < length; i++) {
-          if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
-            events.push(listeners[i]);
-          }
-        }
-        if (events.length)
-          this._events[evt] = events.length === 1 ? events[0] : events;
-        else
-          clearEvent(this, evt);
-      }
-      return this;
-    };
-    EventEmitter3.prototype.removeAllListeners = function removeAllListeners(event) {
-      var evt;
-      if (event) {
-        evt = prefix ? prefix + event : event;
-        if (this._events[evt])
-          clearEvent(this, evt);
-      } else {
-        this._events = new Events;
-        this._eventsCount = 0;
-      }
-      return this;
-    };
-    EventEmitter3.prototype.off = EventEmitter3.prototype.removeListener;
-    EventEmitter3.prototype.addListener = EventEmitter3.prototype.on;
-    EventEmitter3.prefixed = prefix;
-    EventEmitter3.EventEmitter = EventEmitter3;
-    {
-      module.exports = EventEmitter3;
-    }
-  })(eventemitter33);
-  return eventemitter33.exports;
-}
-var eventemitter3Exports3 = requireEventemitter33();
-var EventEmitter3 = /* @__PURE__ */ getDefaultExportFromCjs3(eventemitter3Exports3);
-var reRunFn3 = (promiseOpts) => {
-  const timeout = promiseOpts.timeout || 5 * 60 * 1000;
-  const interval = promiseOpts.interval || 1000;
-  const checkSuccess = promiseOpts?.checkSuccess || (() => true);
-  const signal = promiseOpts.signal;
-  return new Promise(async (resolve, reject) => {
-    let intervalId;
-    let timeoutId = setTimeout(() => {
-      clearTimeout(intervalId);
-      resolve({
-        code: 500,
-        message: "timeout"
-      });
-    }, timeout);
-    const fn = promiseOpts.fn || (() => true);
-    const runFn = async () => {
-      if (signal?.aborted) {
-        clearInterval(intervalId);
-        clearTimeout(timeoutId);
-        return resolve({
-          code: 499,
-          message: "operation cancelled"
-        });
-      }
-      const res = await fn();
-      if (!!checkSuccess(res)) {
-        clearInterval(intervalId);
-        clearTimeout(timeoutId);
-        resolve({
-          code: 200,
-          data: res
-        });
-      } else {
-        setTimeout(() => {
-          runFn();
-        }, interval);
-      }
-    };
-    if (signal) {
-      signal.addEventListener("abort", () => {
-        clearInterval(intervalId);
-        clearTimeout(timeoutId);
-        resolve({
-          code: 499,
-          message: "operation cancelled"
-        });
-      });
-    }
-    runFn();
-  });
-};
-
-class BaseLoad3 {
-  modules = new Map;
-  event;
-  loading;
-  static reRunFn = reRunFn3;
-  timeout = 5 * 60 * 1000;
-  constructor() {
-    this.event = new EventEmitter3;
-    this.loading = false;
-  }
-  listenKey(key, listenOpts) {
-    const timeout = listenOpts?.timeout ?? this.timeout;
-    return new Promise((resolve) => {
-      const timeoutId = setTimeout(() => {
-        this.event.removeListener(key, onEvent);
-        resolve({
-          code: 500,
-          message: "timeout"
-        });
-      }, timeout);
-      const onEvent = (error) => {
-        clearTimeout(timeoutId);
-        if (error) {
-          return resolve({
-            code: 500,
-            message: error
-          });
-        }
-        const data = this.modules.get(key);
-        if (data?.loadSuccessClear) {
-          this.remove(key);
-        }
-        resolve({
-          code: 200,
-          data: data?.modules
-        });
-      };
-      this.event.once(key, onEvent);
-    });
-  }
-  async hasLoaded(key, hasLoadOpts) {
-    if (!key) {
-      return {
-        code: 404,
-        message: "key is required"
-      };
-    }
-    const has = this.modules.has(key);
-    if (!has) {
-      const isExist = hasLoadOpts?.isExist ?? true;
-      const timeout = hasLoadOpts?.timeout ?? this.timeout;
-      if (isExist) {
-        return await this.listenKey(key, { timeout });
-      }
-      return {
-        code: 404
-      };
-    }
-    const data = this.modules.get(key);
-    if (data?.status === "loaded") {
-      return {
-        code: 200,
-        data: data.modules
-      };
-    }
-    if (data?.status === "loading") {
-      return await this.listenKey(key, { timeout: hasLoadOpts?.timeout ?? this.timeout });
-    }
-    if (data?.status === "error") {
-      return {
-        code: 500,
-        message: "load error"
-      };
-    }
-    if (data?.status === "cancel") {
-      return {
-        code: 499,
-        message: "operation cancelled"
-      };
+
+// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/index.js
+var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
+var GENERATOR = Symbol("GENERATOR");
+var STYLER = Symbol("STYLER");
+var IS_EMPTY = Symbol("IS_EMPTY");
+var levelMapping = [
+  "ansi",
+  "ansi",
+  "ansi256",
+  "ansi16m"
+];
+var styles2 = Object.create(null);
+var applyOptions = (object, options = {}) => {
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error("The `level` option should be an integer from 0 to 3");
+  }
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === undefined ? colorLevel : options.level;
+};
+
+class Chalk {
+  constructor(options) {
+    return chalkFactory(options);
+  }
+}
+var chalkFactory = (options) => {
+  const chalk = (...strings) => strings.join(" ");
+  applyOptions(chalk, options);
+  Object.setPrototypeOf(chalk, createChalk.prototype);
+  return chalk;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(ansi_styles_default)) {
+  styles2[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, { value: builder });
+      return builder;
     }
-    return {
-      code: 404
-    };
+  };
+}
+styles2.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, "visible", { value: builder });
+    return builder;
   }
-  async loadFn(loadContent, opts) {
-    const key = opts.key;
-    if (!key) {
-      return {
-        code: 404,
-        message: "key is required"
-      };
+};
+var getModelAnsi = (model, level, type, ...arguments_) => {
+  if (model === "rgb") {
+    if (level === "ansi16m") {
+      return ansi_styles_default[type].ansi16m(...arguments_);
     }
-    const newModule = {
-      key: opts.key,
-      status: "loading",
-      loading: true,
-      loadSuccessClear: opts.loadSuccessClear ?? true
-    };
-    let errorMessage = "";
-    try {
-      const isReRun = opts.isReRun ?? false;
-      let res;
-      if (!isReRun) {
-        this.modules.set(key, newModule);
-        res = await loadContent();
-      } else {
-        newModule.controller = new AbortController;
-        const signal = newModule.controller.signal;
-        this.modules.set(key, newModule);
-        const data = await reRunFn3({
-          timeout: opts.timeout,
-          interval: opts.interval,
-          checkSuccess: opts.checkSuccess,
-          fn: loadContent,
-          signal
-        });
-        newModule.controller = null;
-        if (data.code === 499) {
-          newModule.status = "cancel";
-          return {
-            code: 499,
-            message: "operation cancelled"
-          };
-        }
-        if (data.code !== 200) {
-          throw new Error(data.message);
-        }
-        res = data.data;
-      }
-      newModule.modules = res;
-      newModule.status = "loaded";
-      return {
-        code: 200,
-        data: res
-      };
-    } catch (error) {
-      errorMessage = error.message;
-      newModule.status = "error";
-      return {
-        code: 500,
-        message: error
-      };
-    } finally {
-      newModule.loading = false;
-      this.modules.set(opts.key, newModule);
-      if (!errorMessage) {
-        this.event.emit(opts.key);
-      } else {
-        this.event.emit(opts.key, errorMessage);
-      }
+    if (level === "ansi256") {
+      return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_));
     }
+    return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_));
   }
-  async load(loadContent, opts) {
-    this.loading = true;
-    const key = opts.key;
-    if (!key) {
-      return {
-        code: 404,
-        message: "key is required"
+  if (model === "hex") {
+    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  }
+  return ansi_styles_default[type][model](...arguments_);
+};
+var usedModels = ["rgb", "hex", "ansi256"];
+for (const model of usedModels) {
+  styles2[model] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_), ansi_styles_default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
       };
     }
-    if (opts?.force) {
-      this.remove(key);
-    }
-    const has = this.modules.has(key);
-    if (has) {
-      return await this.hasLoaded(key);
-    }
-    if (typeof loadContent === "function") {
-      return this.loadFn(loadContent, opts);
+  };
+  const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
+  styles2[bgModel] = {
+    get() {
+      const { level } = this;
+      return function(...arguments_) {
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_), ansi_styles_default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
     }
-    console.error("loadContent is not a function and not has loaded");
-  }
-  remove(key) {
-    const has = this.modules.has(key);
-    if (has) {
-      this.checkRemoveController(key);
-      this.modules.delete(key);
+  };
+}
+var proto = Object.defineProperties(() => {}, {
+  ...styles2,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
     }
   }
-  emitLoaded(key) {
-    this.checkRemoveController(key);
-    this.event.emit(key);
+});
+var createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === undefined) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
   }
-  setModule(key, data, loadData) {
-    const newModule = {
-      key,
-      status: "loaded",
-      loading: false,
-      modules: data || {},
-      ...loadData
-    };
-    this.modules.set(key, newModule);
-    this.emitLoaded(key);
-    return newModule;
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+var createBuilder = (self2, _styler, _isEmpty) => {
+  const builder = (...arguments_) => applyStyle(builder, arguments_.length === 1 ? "" + arguments_[0] : arguments_.join(" "));
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self2;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+var applyStyle = (self2, string) => {
+  if (self2.level <= 0 || !string) {
+    return self2[IS_EMPTY] ? "" : string;
   }
-  cancel(key) {
-    this.checkRemoveController(key);
+  let styler = self2[STYLER];
+  if (styler === undefined) {
+    return string;
   }
-  checkRemoveController(key) {
-    const data = this.modules.get(key);
-    if (data?.controller) {
-      data.controller?.abort?.();
-      delete data.controller;
-      this.modules.set(key, data);
+  const { openAll, closeAll } = styler;
+  if (string.includes("\x1B")) {
+    while (styler !== undefined) {
+      string = stringReplaceAll(string, styler.close, styler.open);
+      styler = styler.parent;
     }
   }
-}
+  const lfIndex = string.indexOf(`
+`);
+  if (lfIndex !== -1) {
+    string = stringEncaseCRLFWithFirstIndex(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles2);
+var chalk = createChalk();
+var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
+var source_default = chalk;
+
+// src/module/chalk.ts
+var chalk2 = new Chalk({ level: 3 });
 
 // src/module/login/login-by-web.ts
 var pollLoginStatus = async (token, opts) => {
@@ -31179,7 +31299,7 @@ class QueryRouterServer extends QueryRouter {
 }
 
 // node_modules/.pnpm/@kevisual+context@0.0.4/node_modules/@kevisual/context/dist/app.js
-var isBrowser2 = typeof window !== "undefined" && typeof window.document !== "undefined";
+var isBrowser3 = typeof window !== "undefined" && typeof window.document !== "undefined";
 function getDefaultExportFromCjs4(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
@@ -33595,7 +33715,7 @@ function mitt_default(n) {
 }
 
 // node_modules/.pnpm/@kevisual+app@0.0.2_dotenv@17.3.1/node_modules/@kevisual/app/src/app.ts
-var isBrowser3 = typeof window !== "undefined";
+var isBrowser5 = typeof window !== "undefined";
 
 class App {
   #router;
@@ -33614,7 +33734,7 @@ class App {
     if (opts?.storage) {
       this.storage = opts.storage;
     } else {
-      if (isBrowser3) {
+      if (isBrowser5) {
         this.storage = sessionStorage;
       } else {
         console.warn("没有提供 storage，某些功能可能无法使用");
@@ -33658,7 +33778,7 @@ class App {
     return this.ai;
   }
   get token() {
-    if (isBrowser3 && !this.#token) {
+    if (isBrowser5 && !this.#token) {
       this.#token = localStorage?.getItem("token") || "";
       return this.#token;
     }
@@ -33689,7 +33809,7 @@ class App {
     }
     const data = res.data || {};
     const config2 = data.data || {};
-    if (isBrowser3) {
+    if (isBrowser5) {
       this.storage?.setItem?.(`config_${key}`, JSON.stringify(config2));
     }
     return config2;