@kevisual/cli 0.1.5 → 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.5")
-      version2 = "0.1.5";
+    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.44/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();
@@ -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,
@@ -25293,7 +25298,6 @@ class Query {
   }
   async post(body, options) {
     const url = options?.url || this.url;
-    console.log("query post", url, body, options);
     const { headers, adapter: adapter2, beforeRequest, afterResponse, timeout, ...rest } = options || {};
     const _headers = { ...this.headers, ...headers };
     const _adapter = adapter2 || this.adapter;
@@ -25307,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
           });
         }
@@ -25322,13 +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) {
@@ -25336,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 {
@@ -25353,10 +25373,10 @@ 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
         });
       }
@@ -25394,23 +25414,17 @@ class Query {
   }
 }
 
-// node_modules/.pnpm/@kevisual+query@0.0.44/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();
@@ -25469,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") {
@@ -25503,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;
@@ -25520,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"
     };
@@ -25533,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,
@@ -25555,7 +25586,6 @@ class Query2 {
   }
   async post(body, options) {
     const url = options?.url || this.url;
-    console.log("query post", url, body, options);
     const { headers, adapter: adapter22, beforeRequest, afterResponse, timeout, ...rest } = options || {};
     const _headers = { ...this.headers, ...headers };
     const _adapter = adapter22 || this.adapter;
@@ -25569,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
           });
         }
@@ -25584,13 +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) {
@@ -25598,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 {
@@ -25615,10 +25661,10 @@ class Query2 {
         }
         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
         });
       }
@@ -25681,13 +25727,8 @@ class BaseQuery {
   }
 }
 
-// node_modules/.pnpm/@kevisual+query-login@0.0.7_@kevisual+query@0.0.44/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;
@@ -25745,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() {
@@ -25782,1408 +25825,1479 @@ 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;
-          }
-        } else {
-          that.storage.removeItem("token");
-          await that.cacheStore.clearCurrentUser();
+      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;
         }
-        return res;
+        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;
     }
-    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;
-    }
-    return null;
-  }
-  async checkLocalToken() {
-    const token = this.storage.getItem("token");
-    return !!token;
-  }
-  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 });
+  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: {
-          accessToken: user.accessToken,
-          refreshToken: user.refreshToken
-        },
-        success: true,
-        message: "切换用户成功"
+        data: data.modules
       };
     }
-    const res = await this.postSwitchUser(username);
-    if (res.code === 200) {
-      const { accessToken, refreshToken } = res?.data || {};
-      this.storage.setItem("token", accessToken || "");
-      await this.beforeSetLoginUser({ accessToken, refreshToken });
+    if (data?.status === "loading") {
+      return await this.listenKey(key, { timeout: hasLoadOpts?.timeout ?? this.timeout });
     }
-    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 } });
+    if (data?.status === "error") {
+      return {
+        code: 500,
+        message: "load error"
+      };
+    }
+    if (data?.status === "cancel") {
+      return {
+        code: 499,
+        message: "operation cancelled"
+      };
+    }
+    return {
+      code: 404
+    };
   }
-  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;
+  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"
+          };
         }
-        return response;
+        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 checkLoginStatus(token) {
-    const res = await this.post({
-      path: "user",
-      key: "checkLoginStatus",
-      loginToken: token
-    });
-    if (res.code === 200) {
-      const accessToken = res.data?.accessToken;
-      this.storage.setItem("token", accessToken || "");
-      await this.beforeSetLoginUser({ accessToken, refreshToken: res.data?.refreshToken });
-      return res;
     }
-    return false;
   }
-  loginWithWeb(baseURL, { MD5, jsonwebtoken }) {
-    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
-    });
-    const url = `${baseURL}/api/router?path=user&key=webLogin&p&loginToken=${token}&sign=${sign}&randomId=${randomId}`;
-    return { url, token, tokenSecret };
+  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");
   }
-};
-var fileExists = async (filePath, { createIfNotExists = true, isFile = true, isDir = false } = {}) => {
-  try {
-    accessSync(filePath, fs4.constants.F_OK);
-    return true;
-  } catch (error) {
-    if (createIfNotExists && isDir) {
-      await mkdir(filePath, { recursive: true });
-      return true;
-    } else if (createIfNotExists && isFile) {
-      await mkdir(dirname(filePath), { recursive: true });
-      return false;
+  remove(key) {
+    const has = this.modules.has(key);
+    if (has) {
+      this.checkRemoveController(key);
+      this.modules.delete(key);
     }
-    return false;
   }
-};
-var readConfigFile = (filePath) => {
-  try {
-    const data = readFileSync(filePath, "utf-8");
-    const jsonData = JSON.parse(data);
-    return jsonData;
-  } catch (error) {
-    return {};
+  emitLoaded(key) {
+    this.checkRemoveController(key);
+    this.event.emit(key);
   }
-};
-var writeConfigFile = (filePath, data) => {
-  writeFileSync(filePath, JSON.stringify(data, null, 2));
-};
-var getHostName = () => {
-  const configDir = join(homedir(), ".config", "envision");
-  const configFile = join(configDir, "config.json");
-  const config = readConfigFile(configFile);
-  const baseURL = config.baseURL || "https://kevisual.cn";
-  const hostname = new URL(baseURL).hostname;
-  return hostname;
-};
-var StorageNode = class {
-  cacheData;
-  filePath;
-  constructor() {
-    this.cacheData = {};
-    const configDir = join(homedir(), ".config", "envision");
-    const hostname = getHostName();
-    this.filePath = join(configDir, "config", `${hostname}-storage.json`);
-    fileExists(this.filePath, { isFile: true });
+  setModule(key, data, loadData) {
+    const newModule = {
+      key,
+      status: "loaded",
+      loading: false,
+      modules: data || {},
+      ...loadData
+    };
+    this.modules.set(key, newModule);
+    this.emitLoaded(key);
+    return newModule;
   }
-  async loadCache() {
-    const filePath = this.filePath;
-    try {
-      const data = await readConfigFile(filePath);
-      this.cacheData = data;
-    } catch (error) {
-      this.cacheData = {};
-      await writeFile(filePath, JSON.stringify(this.cacheData, null, 2));
-    }
+  cancel(key) {
+    this.checkRemoveController(key);
   }
-  get length() {
-    return Object.keys(this.cacheData).length;
-  }
-  getItem(key) {
-    return this.cacheData[key];
-  }
-  setItem(key, value) {
-    this.cacheData[key] = value;
-    writeFile(this.filePath, JSON.stringify(this.cacheData, null, 2));
-  }
-  removeItem(key) {
-    delete this.cacheData[key];
-    writeFile(this.filePath, JSON.stringify(this.cacheData, null, 2));
+  checkRemoveController(key) {
+    const data = this.modules.get(key);
+    if (data?.controller) {
+      data.controller?.abort?.();
+      delete data.controller;
+      this.modules.set(key, data);
+    }
   }
-  clear() {
-    this.cacheData = {};
-    writeFile(this.filePath, JSON.stringify(this.cacheData, null, 2));
+}
+
+// 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;
   }
-  key(index) {
-    return Object.keys(this.cacheData)[index];
+  setQuery(query) {
+    this.query = query;
   }
-};
-var LoginNodeCache = class {
-  filepath;
-  constructor(filepath) {
-    this.filepath = filepath || join(homedir(), ".config", "envision", "config", `${getHostName()}-login.json`);
-    fileExists(this.filepath, { isFile: true });
+  async init() {
+    await this.cacheStore.init();
+    this.load = true;
+    this.onLoad?.();
   }
-  async get(_key) {
+  async post(data, opts) {
     try {
-      const filePath = this.filepath;
-      const data = readConfigFile(filePath);
-      return data;
+      return this.query.post({ path: "user", ...data }, opts);
     } catch (error) {
-      console.log("get error", error);
-      return {};
+      console.log("error", error);
+      return {
+        code: 400
+      };
     }
   }
-  async set(_key, value) {
-    try {
-      const data = readConfigFile(this.filepath);
-      const newData = { ...data, ...value };
-      writeConfigFile(this.filepath, newData);
-    } catch (error) {
-      console.log("set error", error);
+  async login(data) {
+    const res = await this.post({ 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 del() {
-    await unlink(this.filepath);
+  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 loadCache(filePath) {
-    try {
-      const data = await readFile(filePath, "utf-8");
-      const jsonData = JSON.parse(data);
-      return jsonData;
-    } catch (error) {
-      console.log("create new cache file:", filePath);
-      const defaultData = { loginUsers: [] };
-      writeConfigFile(filePath, defaultData);
-      return defaultData;
+  async setLoginToken(token) {
+    const { accessToken, refreshToken, accessTokenExpiresIn } = token;
+    this.storage.setItem("token", accessToken || "");
+    await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
+  }
+  async loginByWechat(data) {
+    const res = await this.post({ path: "wx", key: "open-login", code: data.code });
+    if (res.code === 200) {
+      const { accessToken, refreshToken, accessTokenExpiresIn } = res?.data || {};
+      this.storage.setItem("token", accessToken || "");
+      await this.beforeSetLoginUser({ accessToken, refreshToken, accessTokenExpiresIn });
     }
+    return res;
   }
-  async init() {
-    return await this.loadCache(this.filepath);
+  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);
+      }
+    }
   }
-};
-var storage = new StorageNode;
-await storage.loadCache();
-var QueryLoginNode = class extends QueryLogin {
-  constructor(opts) {
-    super({
-      ...opts,
-      storage,
-      cache: new LoginNodeCache
-    });
+  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("登录失败");
+        }
+      }
+    }
   }
-};
-
-// src/module/query.ts
-var config = getConfig2();
-var baseURL = config?.baseURL || "https://kevisual.cn";
-var getBaseURL = () => {
-  return baseURL;
-};
-var query = new Query({
-  url: `${getBaseURL()}/api/router`
-});
-var getHeader = async () => {
-  const headers = {
-    "Content-Type": "application/json"
-  };
-  let token = getEnvToken();
-  if (!token) {
-    token = await storage.getItem("token");
+  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;
+      }
+    });
   }
-  if (token) {
-    headers["Authorization"] = "Bearer " + token;
+  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;
   }
-  return headers;
-};
-query.beforeRequest = async (config2) => {
-  if (config2.headers) {
-    let token = getEnvToken();
-    if (!token) {
-      token = await storage.getItem("token");
+  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;
     }
-    if (token) {
-      config2.headers["Authorization"] = "Bearer " + token;
+  }
+  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;
   }
-  return config2;
-};
-query.afterResponse = async (response, ctx) => {
-  return await queryLogin.run401Action(response, ctx);
-};
-var queryLogin = new QueryLoginNode({
-  query,
-  onLoad: async () => {}
-});
-var getUrl = (url) => {
-  return new URL("/api/router", url).href;
-};
-
-// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
-var ANSI_BACKGROUND_OFFSET = 10;
-var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
-var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
-var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
-var styles = {
-  modifier: {
-    reset: [0, 0],
-    bold: [1, 22],
-    dim: [2, 22],
-    italic: [3, 23],
-    underline: [4, 24],
-    overline: [53, 55],
-    inverse: [7, 27],
-    hidden: [8, 28],
-    strikethrough: [9, 29]
-  },
-  color: {
-    black: [30, 39],
-    red: [31, 39],
-    green: [32, 39],
-    yellow: [33, 39],
-    blue: [34, 39],
-    magenta: [35, 39],
-    cyan: [36, 39],
-    white: [37, 39],
-    blackBright: [90, 39],
-    gray: [90, 39],
-    grey: [90, 39],
-    redBright: [91, 39],
-    greenBright: [92, 39],
-    yellowBright: [93, 39],
-    blueBright: [94, 39],
-    magentaBright: [95, 39],
-    cyanBright: [96, 39],
-    whiteBright: [97, 39]
-  },
-  bgColor: {
-    bgBlack: [40, 49],
-    bgRed: [41, 49],
-    bgGreen: [42, 49],
-    bgYellow: [43, 49],
-    bgBlue: [44, 49],
-    bgMagenta: [45, 49],
-    bgCyan: [46, 49],
-    bgWhite: [47, 49],
-    bgBlackBright: [100, 49],
-    bgGray: [100, 49],
-    bgGrey: [100, 49],
-    bgRedBright: [101, 49],
-    bgGreenBright: [102, 49],
-    bgYellowBright: [103, 49],
-    bgBlueBright: [104, 49],
-    bgMagentaBright: [105, 49],
-    bgCyanBright: [106, 49],
-    bgWhiteBright: [107, 49]
+  async checkLocalToken() {
+    const token = this.storage.getItem("token");
+    return !!token;
   }
-};
-var modifierNames = Object.keys(styles.modifier);
-var foregroundColorNames = Object.keys(styles.color);
-var backgroundColorNames = Object.keys(styles.bgColor);
-var colorNames = [...foregroundColorNames, ...backgroundColorNames];
-function assembleStyles() {
-  const codes = new Map;
-  for (const [groupName, group] of Object.entries(styles)) {
-    for (const [styleName, style] of Object.entries(group)) {
-      styles[styleName] = {
-        open: `\x1B[${style[0]}m`,
-        close: `\x1B[${style[1]}m`
-      };
-      group[styleName] = styles[styleName];
-      codes.set(style[0], style[1]);
-    }
-    Object.defineProperty(styles, groupName, {
-      value: group,
-      enumerable: false
-    });
+  async getToken() {
+    const token = this.storage.getItem("token");
+    return token || "";
   }
-  Object.defineProperty(styles, "codes", {
-    value: codes,
-    enumerable: false
-  });
-  styles.color.close = "\x1B[39m";
-  styles.bgColor.close = "\x1B[49m";
-  styles.color.ansi = wrapAnsi16();
-  styles.color.ansi256 = wrapAnsi256();
-  styles.color.ansi16m = wrapAnsi16m();
-  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
-  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
-  Object.defineProperties(styles, {
-    rgbToAnsi256: {
-      value(red, green, blue) {
-        if (red === green && green === blue) {
-          if (red < 8) {
-            return 16;
-          }
-          if (red > 248) {
-            return 231;
-          }
-          return Math.round((red - 8) / 247 * 24) + 232;
-        }
-        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
-      },
-      enumerable: false
-    },
-    hexToRgb: {
-      value(hex) {
-        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
-        if (!matches) {
-          return [0, 0, 0];
-        }
-        let [colorString] = matches;
-        if (colorString.length === 3) {
-          colorString = [...colorString].map((character) => character + character).join("");
-        }
-        const integer = Number.parseInt(colorString, 16);
-        return [
-          integer >> 16 & 255,
-          integer >> 8 & 255,
-          integer & 255
-        ];
-      },
-      enumerable: false
-    },
-    hexToAnsi256: {
-      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
-      enumerable: false
-    },
-    ansi256ToAnsi: {
-      value(code) {
-        if (code < 8) {
-          return 30 + code;
-        }
-        if (code < 16) {
-          return 90 + (code - 8);
-        }
-        let red;
-        let green;
-        let blue;
-        if (code >= 232) {
-          red = ((code - 232) * 10 + 8) / 255;
-          green = red;
-          blue = red;
-        } else {
-          code -= 16;
-          const remainder = code % 36;
-          red = Math.floor(code / 36) / 5;
-          green = Math.floor(remainder / 6) / 5;
-          blue = remainder % 6 / 5;
-        }
-        const value = Math.max(red, green, blue) * 2;
-        if (value === 0) {
-          return 30;
-        }
-        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
-        if (value === 2) {
-          result += 60;
-        }
-        return result;
-      },
-      enumerable: false
-    },
-    rgbToAnsi: {
-      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
-      enumerable: false
-    },
-    hexToAnsi: {
-      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
-      enumerable: false
+  async beforeRequest(opts = {}) {
+    const token = this.storage.getItem("token");
+    if (token) {
+      opts.headers = { ...opts.headers, Authorization: `Bearer ${token}` };
     }
-  });
-  return styles;
-}
-var ansiStyles = assembleStyles();
-var ansi_styles_default = ansiStyles;
-
-// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
-import process4 from "node:process";
-import os2 from "node:os";
-import tty from "node:tty";
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process4.argv) {
-  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
-  const position = argv.indexOf(prefix + flag);
-  const terminatorPosition = argv.indexOf("--");
-  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
-}
-var { env } = process4;
-var flagForceColor;
-if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
-  flagForceColor = 0;
-} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
-  flagForceColor = 1;
-}
-function envForceColor() {
-  if ("FORCE_COLOR" in env) {
-    if (env.FORCE_COLOR === "true") {
-      return 1;
+    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: "切换用户成功"
+      };
     }
-    if (env.FORCE_COLOR === "false") {
-      return 0;
+    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 env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
+    return res;
   }
-}
-function translateLevel(level) {
-  if (level === 0) {
-    return false;
+  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 } });
   }
-  return {
-    level,
-    hasBasic: true,
-    has256: level >= 2,
-    has16m: level >= 3
-  };
-}
-function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
-  const noFlagForceColor = envForceColor();
-  if (noFlagForceColor !== undefined) {
-    flagForceColor = noFlagForceColor;
+  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;
+      }
+    });
   }
-  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
-  if (forceColor === 0) {
-    return 0;
+  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;
   }
-  if (sniffFlags) {
-    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
-      return 3;
+  loginWithWeb(baseURL, { MD5, jsonwebtoken }) {
+    const randomId = Math.random().toString(36).substring(2, 15);
+    const timestamp = Date.now();
+    const tokenSecret = "xiao" + randomId;
+    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;
     }
-    if (hasFlag("color=256")) {
-      return 2;
+    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;
   }
-  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
-    return 1;
+}
+
+// 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);
+    return true;
+  } catch (error) {
+    if (createIfNotExists && isDir) {
+      await mkdir(filePath, { recursive: true });
+      return true;
+    } else if (createIfNotExists && isFile) {
+      await mkdir(dirname(filePath), { recursive: true });
+      return false;
+    }
+    return false;
   }
-  if (haveStream && !streamIsTTY && forceColor === undefined) {
-    return 0;
+};
+var readConfigFile = (filePath) => {
+  try {
+    const data = readFileSync(filePath, "utf-8");
+    const jsonData = JSON.parse(data);
+    return jsonData;
+  } catch (error) {
+    return {};
   }
-  const min = forceColor || 0;
-  if (env.TERM === "dumb") {
-    return min;
+};
+var writeConfigFile = (filePath, data) => {
+  writeFileSync(filePath, JSON.stringify(data, null, 2));
+};
+var getHostName = () => {
+  const configDir = join(homedir(), ".config", "envision");
+  const configFile = join(configDir, "config.json");
+  const config = readConfigFile(configFile);
+  const baseURL = config.baseURL || "https://kevisual.cn";
+  const hostname = new URL(baseURL).hostname;
+  return hostname;
+};
+
+class StorageNode {
+  cacheData;
+  filePath;
+  constructor() {
+    this.cacheData = {};
+    const configDir = join(homedir(), ".config", "envision");
+    const hostname = getHostName();
+    this.filePath = join(configDir, "config", `${hostname}-storage.json`);
+    fileExists(this.filePath, { isFile: true });
   }
-  if (process4.platform === "win32") {
-    const osRelease = os2.release().split(".");
-    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
-      return Number(osRelease[2]) >= 14931 ? 3 : 2;
+  async loadCache() {
+    const filePath = this.filePath;
+    try {
+      const data = await readConfigFile(filePath);
+      this.cacheData = data;
+    } catch (error) {
+      this.cacheData = {};
+      await writeFile(filePath, JSON.stringify(this.cacheData, null, 2));
     }
-    return 1;
   }
-  if ("CI" in env) {
-    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env))) {
-      return 3;
-    }
-    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
-      return 1;
-    }
-    return min;
+  get length() {
+    return Object.keys(this.cacheData).length;
   }
-  if ("TEAMCITY_VERSION" in env) {
-    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  getItem(key) {
+    return this.cacheData[key];
   }
-  if (env.COLORTERM === "truecolor") {
-    return 3;
+  setItem(key, value) {
+    this.cacheData[key] = value;
+    writeFile(this.filePath, JSON.stringify(this.cacheData, null, 2));
   }
-  if (env.TERM === "xterm-kitty") {
-    return 3;
+  removeItem(key) {
+    delete this.cacheData[key];
+    writeFile(this.filePath, JSON.stringify(this.cacheData, null, 2));
   }
-  if (env.TERM === "xterm-ghostty") {
-    return 3;
+  clear() {
+    this.cacheData = {};
+    writeFile(this.filePath, JSON.stringify(this.cacheData, null, 2));
   }
-  if (env.TERM === "wezterm") {
-    return 3;
+  key(index) {
+    return Object.keys(this.cacheData)[index];
   }
-  if ("TERM_PROGRAM" in env) {
-    const version2 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
-    switch (env.TERM_PROGRAM) {
-      case "iTerm.app": {
-        return version2 >= 3 ? 3 : 2;
-      }
-      case "Apple_Terminal": {
-        return 2;
-      }
+}
+
+class LoginNodeCache {
+  filepath;
+  constructor(filepath) {
+    this.filepath = filepath || join(homedir(), ".config", "envision", "config", `${getHostName()}-login.json`);
+    fileExists(this.filepath, { isFile: true });
+  }
+  async get(_key) {
+    try {
+      const filePath = this.filepath;
+      const data = readConfigFile(filePath);
+      return data;
+    } catch (error) {
+      console.log("get error", error);
+      return {};
     }
   }
-  if (/-256(color)?$/i.test(env.TERM)) {
-    return 2;
+  async set(_key, value) {
+    try {
+      const data = readConfigFile(this.filepath);
+      const newData = { ...data, ...value };
+      writeConfigFile(this.filepath, newData);
+    } catch (error) {
+      console.log("set error", error);
+    }
   }
-  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
-    return 1;
+  async del() {
+    await unlink(this.filepath);
   }
-  if ("COLORTERM" in env) {
-    return 1;
+  async loadCache(filePath) {
+    try {
+      const data = await readFile(filePath, "utf-8");
+      const jsonData = JSON.parse(data);
+      return jsonData;
+    } catch (error) {
+      console.log("create new cache file:", filePath);
+      const defaultData = { loginUsers: [] };
+      writeConfigFile(filePath, defaultData);
+      return defaultData;
+    }
+  }
+  async init() {
+    return await this.loadCache(this.filepath);
   }
-  return min;
-}
-function createSupportsColor(stream, options = {}) {
-  const level = _supportsColor(stream, {
-    streamIsTTY: stream && stream.isTTY,
-    ...options
-  });
-  return translateLevel(level);
 }
-var supportsColor = {
-  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
-  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
-};
-var supports_color_default = supportsColor;
 
-// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js
-function stringReplaceAll(string, substring, replacer) {
-  let index = string.indexOf(substring);
-  if (index === -1) {
-    return string;
+// 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();
+
+class QueryLoginNode extends QueryLogin {
+  constructor(opts) {
+    super({
+      ...opts,
+      storage,
+      cache: new LoginNodeCache
+    });
   }
-  const substringLength = substring.length;
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    returnValue += string.slice(endIndex, index) + substring + replacer;
-    endIndex = index + substringLength;
-    index = string.indexOf(substring, endIndex);
-  } while (index !== -1);
-  returnValue += string.slice(endIndex);
-  return returnValue;
 }
-function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
-  let endIndex = 0;
-  let returnValue = "";
-  do {
-    const gotCR = string[index - 1] === "\r";
-    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? `\r
-` : `
-`) + postfix;
-    endIndex = index + 1;
-    index = string.indexOf(`
-`, endIndex);
-  } while (index !== -1);
-  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;
+// src/module/query.ts
+var config = getConfig2();
+var baseURL = config?.baseURL || "https://kevisual.cn";
+var getBaseURL = () => {
+  return baseURL;
 };
-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;
-    }
+var query = new Query({
+  url: `${getBaseURL()}/api/router`
+});
+var getHeader = async () => {
+  const headers = {
+    "Content-Type": "application/json"
   };
-}
-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_));
+  let token = getEnvToken();
+  if (!token) {
+    token = await storage.getItem("token");
   }
-  if (model === "hex") {
-    return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_));
+  if (token) {
+    headers["Authorization"] = "Bearer " + token;
   }
-  return ansi_styles_default[type][model](...arguments_);
+  return headers;
 };
-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]);
-      };
+query.beforeRequest = async (config2) => {
+  if (config2.headers) {
+    let token = getEnvToken();
+    if (!token) {
+      token = await storage.getItem("token");
     }
-  };
-}
-var proto = Object.defineProperties(() => {}, {
-  ...styles2,
-  level: {
-    enumerable: true,
-    get() {
-      return this[GENERATOR].level;
-    },
-    set(level) {
-      this[GENERATOR].level = level;
+    if (token) {
+      config2.headers["Authorization"] = "Bearer " + token;
     }
   }
-});
-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
-  };
+  return config2;
 };
-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;
+query.afterResponse = async (response, ctx) => {
+  return await queryLogin.run401Action(response, ctx);
 };
-var applyStyle = (self2, string) => {
-  if (self2.level <= 0 || !string) {
-    return self2[IS_EMPTY] ? "" : string;
-  }
-  let styler = self2[STYLER];
-  if (styler === undefined) {
-    return string;
+var queryLogin = new QueryLoginNode({
+  query,
+  onLoad: async () => {}
+});
+var getUrl = (url) => {
+  return new URL("/api/router", url).href;
+};
+
+// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/ansi-styles/index.js
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
+var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
+var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    blackBright: [90, 39],
+    gray: [90, 39],
+    grey: [90, 39],
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    bgGrey: [100, 49],
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
   }
-  const { openAll, closeAll } = styler;
-  if (string.includes("\x1B")) {
-    while (styler !== undefined) {
-      string = stringReplaceAll(string, styler.close, styler.open);
-      styler = styler.parent;
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = new Map;
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
     }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
   }
-  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;
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
         }
-        for (i = 1, args = new Array(len - 1);i < len; i++) {
-          args[i - 1] = arguments[i];
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
         }
-        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);
-          }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
         }
-      }
-      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);
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
         }
-      } 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 (code < 16) {
+          return 90 + (code - 8);
         }
-        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"
-        });
-      });
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
     }
-    runFn();
   });
-};
+  return styles;
+}
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
 
-class BaseLoad3 {
-  modules = new Map;
-  event;
-  loading;
-  static reRunFn = reRunFn3;
-  timeout = 5 * 60 * 1000;
-  constructor() {
-    this.event = new EventEmitter3;
-    this.loading = false;
+// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/vendor/supports-color/index.js
+import process4 from "node:process";
+import os2 from "node:os";
+import tty from "node:tty";
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process4.argv) {
+  const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
+  const position = argv.indexOf(prefix + flag);
+  const terminatorPosition = argv.indexOf("--");
+  return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+}
+var { env } = process4;
+var flagForceColor;
+if (hasFlag("no-color") || hasFlag("no-colors") || hasFlag("color=false") || hasFlag("color=never")) {
+  flagForceColor = 0;
+} else if (hasFlag("color") || hasFlag("colors") || hasFlag("color=true") || hasFlag("color=always")) {
+  flagForceColor = 1;
+}
+function envForceColor() {
+  if ("FORCE_COLOR" in env) {
+    if (env.FORCE_COLOR === "true") {
+      return 1;
+    }
+    if (env.FORCE_COLOR === "false") {
+      return 0;
+    }
+    return env.FORCE_COLOR.length === 0 ? 1 : Math.min(Number.parseInt(env.FORCE_COLOR, 10), 3);
   }
-  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);
-    });
+}
+function translateLevel(level) {
+  if (level === 0) {
+    return false;
   }
-  async hasLoaded(key, hasLoadOpts) {
-    if (!key) {
-      return {
-        code: 404,
-        message: "key is required"
-      };
+  return {
+    level,
+    hasBasic: true,
+    has256: level >= 2,
+    has16m: level >= 3
+  };
+}
+function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
+  const noFlagForceColor = envForceColor();
+  if (noFlagForceColor !== undefined) {
+    flagForceColor = noFlagForceColor;
+  }
+  const forceColor = sniffFlags ? flagForceColor : noFlagForceColor;
+  if (forceColor === 0) {
+    return 0;
+  }
+  if (sniffFlags) {
+    if (hasFlag("color=16m") || hasFlag("color=full") || hasFlag("color=truecolor")) {
+      return 3;
     }
-    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
-      };
+    if (hasFlag("color=256")) {
+      return 2;
     }
-    const data = this.modules.get(key);
-    if (data?.status === "loaded") {
-      return {
-        code: 200,
-        data: data.modules
-      };
+  }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
+  if (haveStream && !streamIsTTY && forceColor === undefined) {
+    return 0;
+  }
+  const min = forceColor || 0;
+  if (env.TERM === "dumb") {
+    return min;
+  }
+  if (process4.platform === "win32") {
+    const osRelease = os2.release().split(".");
+    if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
+      return Number(osRelease[2]) >= 14931 ? 3 : 2;
     }
-    if (data?.status === "loading") {
-      return await this.listenKey(key, { timeout: hasLoadOpts?.timeout ?? this.timeout });
+    return 1;
+  }
+  if ("CI" in env) {
+    if (["GITHUB_ACTIONS", "GITEA_ACTIONS", "CIRCLECI"].some((key) => (key in env))) {
+      return 3;
     }
-    if (data?.status === "error") {
-      return {
-        code: 500,
-        message: "load error"
-      };
+    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => (sign in env)) || env.CI_NAME === "codeship") {
+      return 1;
     }
-    if (data?.status === "cancel") {
-      return {
-        code: 499,
-        message: "operation cancelled"
-      };
+    return min;
+  }
+  if ("TEAMCITY_VERSION" in env) {
+    return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
+  }
+  if (env.COLORTERM === "truecolor") {
+    return 3;
+  }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
+  if (env.TERM === "xterm-ghostty") {
+    return 3;
+  }
+  if (env.TERM === "wezterm") {
+    return 3;
+  }
+  if ("TERM_PROGRAM" in env) {
+    const version2 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    switch (env.TERM_PROGRAM) {
+      case "iTerm.app": {
+        return version2 >= 3 ? 3 : 2;
+      }
+      case "Apple_Terminal": {
+        return 2;
+      }
+    }
+  }
+  if (/-256(color)?$/i.test(env.TERM)) {
+    return 2;
+  }
+  if (/^screen|^xterm|^vt100|^vt220|^rxvt|color|ansi|cygwin|linux/i.test(env.TERM)) {
+    return 1;
+  }
+  if ("COLORTERM" in env) {
+    return 1;
+  }
+  return min;
+}
+function createSupportsColor(stream, options = {}) {
+  const level = _supportsColor(stream, {
+    streamIsTTY: stream && stream.isTTY,
+    ...options
+  });
+  return translateLevel(level);
+}
+var supportsColor = {
+  stdout: createSupportsColor({ isTTY: tty.isatty(1) }),
+  stderr: createSupportsColor({ isTTY: tty.isatty(2) })
+};
+var supports_color_default = supportsColor;
+
+// node_modules/.pnpm/chalk@5.6.2/node_modules/chalk/source/utilities.js
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = "";
+  do {
+    const gotCR = string[index - 1] === "\r";
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? `\r
+` : `
+`) + postfix;
+    endIndex = index + 1;
+    index = string.indexOf(`
+`, endIndex);
+  } while (index !== -1);
+  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;
     }
-    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) => {
@@ -31185,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;
 }
@@ -33601,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;
@@ -33620,7 +33734,7 @@ class App {
     if (opts?.storage) {
       this.storage = opts.storage;
     } else {
-      if (isBrowser3) {
+      if (isBrowser5) {
         this.storage = sessionStorage;
       } else {
         console.warn("没有提供 storage，某些功能可能无法使用");
@@ -33664,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;
     }
@@ -33695,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;