@zhin.js/console 1.0.50 → 1.0.52

package/lib/index.js

@@ -1,15 +1,461 @@
-import { usePlugin } from '@zhin.js/core';
+import { usePlugin, Adapter } from '@zhin.js/core';
 import mime from 'mime';
-import * as fs from 'fs';
-import fs__default from 'fs';
-import * as path from 'path';
-import path__default from 'path';
+import * as fs2 from 'fs';
+import fs2__default from 'fs';
+import * as path2 from 'path';
+import path2__default from 'path';
 import * as crypto from 'crypto';
 import WebSocket from 'ws';
 import { transform } from 'esbuild';
 
 // src/index.ts
+
+// src/bot-db-models.ts
+var ConsoleBotRequestDefinition = {
+  id: { type: "integer", primary: true, autoIncrement: true },
+  adapter: { type: "text", nullable: false },
+  bot_id: { type: "text", nullable: false },
+  platform_request_id: { type: "text", nullable: false },
+  type: { type: "text", nullable: false },
+  sender_id: { type: "text", nullable: false },
+  sender_name: { type: "text", nullable: false },
+  comment: { type: "text", nullable: false },
+  channel_id: { type: "text", nullable: false },
+  channel_type: { type: "text", nullable: false },
+  created_at: { type: "integer", nullable: false },
+  consumed: { type: "integer", nullable: false, default: 0 },
+  consumed_at: { type: "integer", nullable: true }
+};
+var ConsoleBotNoticeDefinition = {
+  id: { type: "integer", primary: true, autoIncrement: true },
+  adapter: { type: "text", nullable: false },
+  bot_id: { type: "text", nullable: false },
+  notice_type: { type: "text", nullable: false },
+  channel_type: { type: "text", nullable: false },
+  channel_id: { type: "text", nullable: false },
+  payload: { type: "text", nullable: false },
+  created_at: { type: "integer", nullable: false },
+  consumed: { type: "integer", nullable: false, default: 0 },
+  consumed_at: { type: "integer", nullable: true }
+};
+var TABLE_REQUESTS = "console_bot_requests";
+var TABLE_NOTICES = "console_bot_notices";
+function registerBotModels(root3) {
+  const defineModel = root3.defineModel;
+  if (typeof defineModel !== "function") return;
+  defineModel(TABLE_REQUESTS, ConsoleBotRequestDefinition);
+  defineModel(TABLE_NOTICES, ConsoleBotNoticeDefinition);
+}
+
+// src/bot-persistence.ts
+var DATA_DIR = path2__default.join(process.cwd(), "data");
+var REQ_FILE = path2__default.join(DATA_DIR, "console_bot_requests.json");
+var NOTICE_FILE = path2__default.join(DATA_DIR, "console_bot_notices.json");
+var dbRef = null;
+function initBotPersistence(root3) {
+  try {
+    dbRef = root3.inject("database");
+  } catch {
+    dbRef = null;
+  }
+}
+function getReqModel() {
+  return dbRef?.db?.models?.get(TABLE_REQUESTS);
+}
+function getNoticeModel() {
+  return dbRef?.db?.models?.get(TABLE_NOTICES);
+}
+function ensureDir() {
+  if (!fs2__default.existsSync(DATA_DIR)) fs2__default.mkdirSync(DATA_DIR, { recursive: true });
+}
+function loadFile(file, empty) {
+  try {
+    if (!fs2__default.existsSync(file)) return { ...empty };
+    const raw = fs2__default.readFileSync(file, "utf-8");
+    const j = JSON.parse(raw);
+    if (!j || !Array.isArray(j.rows)) return { ...empty };
+    return {
+      nextId: typeof j.nextId === "number" ? j.nextId : 1,
+      rows: j.rows
+    };
+  } catch {
+    return { ...empty };
+  }
+}
+function saveFile(file, store) {
+  ensureDir();
+  fs2__default.writeFileSync(file, JSON.stringify(store, null, 0), "utf-8");
+}
+function normalizeReqRow(r) {
+  return {
+    ...r,
+    id: r.id,
+    consumed: r.consumed === 1 ? 1 : 0
+  };
+}
+function normalizeNoticeRow(r) {
+  return {
+    ...r,
+    id: r.id,
+    consumed: r.consumed === 1 ? 1 : 0
+  };
+}
+async function insertRequest(row) {
+  const model = getReqModel();
+  if (model) {
+    const created = await model.create({
+      ...row,
+      consumed: 0
+    });
+    const id2 = typeof created?.id === "number" ? created.id : created.id;
+    return { ...row, id: id2, consumed: 0 };
+  }
+  const store = loadFile(REQ_FILE, { nextId: 1, rows: [] });
+  const id = store.nextId++;
+  const full = { ...row, id, consumed: 0 };
+  store.rows.push(full);
+  saveFile(REQ_FILE, store);
+  return full;
+}
+async function insertNotice(row) {
+  const model = getNoticeModel();
+  if (model) {
+    const created = await model.create({
+      ...row,
+      consumed: 0
+    });
+    const id2 = typeof created?.id === "number" ? created.id : created.id;
+    return { ...row, id: id2, consumed: 0 };
+  }
+  const store = loadFile(NOTICE_FILE, { nextId: 1, rows: [] });
+  const id = store.nextId++;
+  const full = { ...row, id, consumed: 0 };
+  store.rows.push(full);
+  saveFile(NOTICE_FILE, store);
+  return full;
+}
+async function listUnconsumedRequests() {
+  const model = getReqModel();
+  if (model) {
+    const rows = await model.select().where({ consumed: 0 });
+    return (rows || []).map(normalizeReqRow).sort((a, b) => a.created_at - b.created_at);
+  }
+  const store = loadFile(REQ_FILE, { nextId: 1, rows: [] });
+  return store.rows.filter((r) => r.consumed === 0).sort((a, b) => a.created_at - b.created_at);
+}
+async function listUnconsumedNotices() {
+  const model = getNoticeModel();
+  if (model) {
+    const rows = await model.select().where({ consumed: 0 });
+    return (rows || []).map(normalizeNoticeRow).sort((a, b) => a.created_at - b.created_at);
+  }
+  const store = loadFile(NOTICE_FILE, { nextId: 1, rows: [] });
+  return store.rows.filter((r) => r.consumed === 0).sort((a, b) => a.created_at - b.created_at);
+}
+async function listRequestsForBot(adapter, botId) {
+  const all = await listUnconsumedRequests();
+  return all.filter((r) => r.adapter === adapter && r.bot_id === botId);
+}
+async function markRequestsConsumed(ids) {
+  if (!ids.length) return;
+  const model = getReqModel();
+  const now = Date.now();
+  if (model) {
+    for (const id of ids) {
+      await model.update({ consumed: 1, consumed_at: now }).where({ id });
+    }
+    return;
+  }
+  const store = loadFile(REQ_FILE, { nextId: 1, rows: [] });
+  const set = new Set(ids);
+  for (const r of store.rows) {
+    if (set.has(r.id) && r.consumed === 0) {
+      r.consumed = 1;
+      r.consumed_at = now;
+    }
+  }
+  saveFile(REQ_FILE, store);
+}
+async function markNoticesConsumed(ids) {
+  if (!ids.length) return;
+  const model = getNoticeModel();
+  const now = Date.now();
+  if (model) {
+    for (const id of ids) {
+      await model.update({ consumed: 1, consumed_at: now }).where({ id });
+    }
+    return;
+  }
+  const store = loadFile(NOTICE_FILE, { nextId: 1, rows: [] });
+  const set = new Set(ids);
+  for (const r of store.rows) {
+    if (set.has(r.id) && r.consumed === 0) {
+      r.consumed = 1;
+      r.consumed_at = now;
+    }
+  }
+  saveFile(NOTICE_FILE, store);
+}
+async function findRequestRow(adapter, botId, platformRequestId) {
+  const model = getReqModel();
+  if (model) {
+    const rows = await model.select().where({
+      adapter,
+      bot_id: botId,
+      platform_request_id: platformRequestId,
+      consumed: 0
+    });
+    return rows?.[0] ? normalizeReqRow(rows[0]) : void 0;
+  }
+  const store = loadFile(REQ_FILE, { nextId: 1, rows: [] });
+  const r = store.rows.find(
+    (x) => x.adapter === adapter && x.bot_id === botId && x.platform_request_id === platformRequestId && x.consumed === 0
+  );
+  return r;
+}
+async function getRequestRowById(id) {
+  const model = getReqModel();
+  if (model) {
+    const rows = await model.select().where({ id });
+    return rows?.[0] ? normalizeReqRow(rows[0]) : void 0;
+  }
+  const store = loadFile(REQ_FILE, { nextId: 1, rows: [] });
+  const r = store.rows.find((x) => x.id === id);
+  return r;
+}
+
+// src/bot-hub.ts
+var wssRef = null;
+var hubInited = false;
+function setBotHubWss(wss) {
+  wssRef = wss;
+}
+function broadcast(obj) {
+  const msg = JSON.stringify(obj);
+  const clients = wssRef?.clients;
+  if (!clients) return;
+  const list = clients instanceof Set ? [...clients] : clients;
+  for (const ws of list) {
+    if (ws.readyState === 1) ws.send(msg);
+  }
+}
+function requestMemoryKey(adapter, botId, platformId) {
+  return `${adapter}:${botId}:${platformId}`;
+}
+var pendingRequestObjects = /* @__PURE__ */ new Map();
+async function storePendingRequest(adapter, botId, req) {
+  const platformId = req.$id;
+  const key = requestMemoryKey(adapter, botId, platformId);
+  pendingRequestObjects.set(key, req);
+  const row = await insertRequest({
+    adapter,
+    bot_id: botId,
+    platform_request_id: platformId,
+    type: String(req.$type),
+    sender_id: String(req.$sender?.id ?? ""),
+    sender_name: String(req.$sender?.name ?? ""),
+    comment: String(req.$comment ?? ""),
+    channel_id: String(req.$channel?.id ?? ""),
+    channel_type: String(req.$channel?.type ?? "private"),
+    created_at: typeof req.$timestamp === "number" ? req.$timestamp : Date.now()
+  });
+  return row;
+}
+function rowToRequestPushData(row, canAct) {
+  return {
+    id: row.id,
+    adapter: row.adapter,
+    botId: row.bot_id,
+    platformRequestId: row.platform_request_id,
+    type: row.type,
+    sender: { id: row.sender_id, name: row.sender_name },
+    comment: row.comment,
+    channel: { id: row.channel_id, type: row.channel_type },
+    timestamp: row.created_at,
+    canAct
+  };
+}
+async function onRequestReceived(adapter, botId, req) {
+  const row = await storePendingRequest(adapter, botId, req);
+  const key = requestMemoryKey(adapter, botId, req.$id);
+  const canAct = pendingRequestObjects.has(key);
+  broadcast({ type: "bot:request", data: rowToRequestPushData(row, canAct) });
+}
+async function onNoticeReceived(adapter, botId, notice) {
+  let raw = {};
+  try {
+    raw = Object.fromEntries(
+      Object.entries(notice).filter(
+        ([k]) => !k.startsWith("$") && k !== "adapter" && k !== "bot"
+      )
+    );
+  } catch {
+    raw = {};
+  }
+  let payload;
+  try {
+    payload = JSON.stringify({
+      type: notice.$type,
+      subType: notice.$subType,
+      channel: notice.$channel,
+      raw
+    });
+  } catch {
+    payload = JSON.stringify({ type: notice.$type, error: "serialize_failed" });
+  }
+  const row = await insertNotice({
+    adapter,
+    bot_id: botId,
+    notice_type: String(notice.$type ?? "unknown"),
+    channel_type: String(notice.$channel?.type ?? ""),
+    channel_id: String(notice.$channel?.id ?? ""),
+    payload,
+    created_at: typeof notice.$timestamp === "number" ? notice.$timestamp : Date.now()
+  });
+  broadcast({
+    type: "bot:notice",
+    data: {
+      id: row.id,
+      adapter: row.adapter,
+      botId: row.bot_id,
+      noticeType: row.notice_type,
+      channel: { id: row.channel_id, type: row.channel_type },
+      payload: row.payload,
+      timestamp: row.created_at
+    }
+  });
+}
+function getPendingRequest(adapter, botId, platformRequestId) {
+  return pendingRequestObjects.get(requestMemoryKey(adapter, botId, platformRequestId));
+}
+function removePendingRequest(adapter, botId, platformRequestId) {
+  pendingRequestObjects.delete(requestMemoryKey(adapter, botId, platformRequestId));
+}
+async function markRequestConsumedByPlatformId(adapter, botId, platformRequestId) {
+  const row = await findRequestRow(adapter, botId, platformRequestId);
+  if (row) await markRequestsConsumed([row.id]);
+  removePendingRequest(adapter, botId, platformRequestId);
+}
+async function sendCatchUpToClient(ws) {
+  const reqs = await listUnconsumedRequests();
+  for (const row of reqs) {
+    const canAct = pendingRequestObjects.has(
+      requestMemoryKey(row.adapter, row.bot_id, row.platform_request_id)
+    );
+    if (ws.readyState === 1) {
+      ws.send(
+        JSON.stringify({
+          type: "bot:request",
+          data: rowToRequestPushData(row, canAct)
+        })
+      );
+    }
+  }
+  const notices = await listUnconsumedNotices();
+  for (const row of notices) {
+    if (ws.readyState === 1) {
+      ws.send(
+        JSON.stringify({
+          type: "bot:notice",
+          data: {
+            id: row.id,
+            adapter: row.adapter,
+            botId: row.bot_id,
+            noticeType: row.notice_type,
+            channel: { id: row.channel_id, type: row.channel_type },
+            payload: row.payload,
+            timestamp: row.created_at
+          }
+        })
+      );
+    }
+  }
+}
+function initBotHub(root3) {
+  if (hubInited) return;
+  hubInited = true;
+  const handlerReq = (req) => {
+    const adapter = String(req.$adapter);
+    const botId = String(req.$bot);
+    onRequestReceived(adapter, botId, req);
+  };
+  const handlerNotice = (notice) => {
+    const adapter = String(notice.$adapter);
+    const botId = String(notice.$bot);
+    onNoticeReceived(adapter, botId, notice);
+  };
+  root3.on("request.receive", handlerReq);
+  root3.on("notice.receive", handlerNotice);
+  const adapterNames = root3.adapters ? [...root3.adapters] : [];
+  const inject2 = root3.inject;
+  if (inject2 && typeof inject2 === "function" && adapterNames.length > 0) {
+    for (const name of adapterNames) {
+      try {
+        const ad = inject2(name);
+        if (ad && typeof ad.on === "function") {
+          ad.on("message.receive", (msg) => {
+            const payload = {
+              type: "bot:message",
+              data: {
+                adapter: name,
+                botId: msg?.$bot,
+                channelId: msg?.$channel?.id,
+                channelType: msg?.$channel?.type,
+                sender: msg?.$sender,
+                content: msg?.$content ?? [],
+                timestamp: typeof msg?.$timestamp === "number" ? msg.$timestamp : Date.now()
+              }
+            };
+            broadcast(payload);
+          });
+        }
+      } catch {
+      }
+    }
+  }
+}
+
+// src/websocket.ts
 var { root, logger } = usePlugin();
+function collectBotsList() {
+  const bots = [];
+  for (const name of root.adapters) {
+    const adapter = root.inject(name);
+    if (adapter instanceof Adapter) {
+      for (const [botName, bot] of adapter.bots.entries()) {
+        bots.push({
+          name: botName,
+          adapter: String(name),
+          connected: !!bot.$connected,
+          status: bot.$connected ? "online" : "offline"
+        });
+      }
+    }
+  }
+  return bots;
+}
+async function collectBotsListWithPending() {
+  const bots = collectBotsList();
+  let reqs = [];
+  let notices = [];
+  try {
+    [reqs, notices] = await Promise.all([listUnconsumedRequests(), listUnconsumedNotices()]);
+  } catch {
+  }
+  return bots.map((bot) => {
+    const pendingRequestCount = reqs.filter(
+      (r) => r.adapter === bot.adapter && r.bot_id === bot.name
+    ).length;
+    const pendingNoticeCount = notices.filter(
+      (n) => n.adapter === bot.adapter && n.bot_id === bot.name
+    ).length;
+    return {
+      ...bot,
+      pendingRequestCount,
+      pendingNoticeCount
+    };
+  });
+}
 var ENV_WHITELIST = [".env", ".env.development", ".env.production"];
 var FILE_MANAGER_ALLOWED = [
   "src",
@@ -33,7 +479,7 @@ var FILE_MANAGER_BLOCKED = /* @__PURE__ */ new Set([
   "coverage"
 ]);
 function isPathAllowed(relativePath) {
-  if (relativePath.includes("..") || path__default.isAbsolute(relativePath)) return false;
+  if (relativePath.includes("..") || path2__default.isAbsolute(relativePath)) return false;
   const normalized = relativePath.replace(/\\/g, "/").replace(/^\.\//, "");
   const firstSegment = normalized.split("/")[0];
   if (FILE_MANAGER_BLOCKED.has(firstSegment)) return false;
@@ -53,15 +499,20 @@ function getPluginKeys() {
   return Array.from(keys);
 }
 function getConfigFilePath() {
-  return path__default.resolve(process.cwd(), "zhin.config.yml");
+  return path2__default.resolve(process.cwd(), "zhin.config.yml");
 }
 function setupWebSocket(webServer) {
+  setBotHubWss(webServer.ws);
+  initBotHub(root);
   webServer.ws.on("connection", (ws) => {
     ws.send(JSON.stringify({
       type: "sync",
       data: { key: "entries", value: Object.values(webServer.entries) }
     }));
     ws.send(JSON.stringify({ type: "init-data", timestamp: Date.now() }));
+    void sendCatchUpToClient(ws).catch(
+      (e) => logger.warn("[console] bot catch-up failed", e.message)
+    );
     ws.on("message", async (data) => {
       try {
         const message = JSON.parse(data.toString());
@@ -93,7 +544,7 @@ async function handleWebSocketMessage(ws, message, webServer) {
     case "config:get-yaml":
       try {
         const filePath = getConfigFilePath();
-        const yaml = fs__default.existsSync(filePath) ? fs__default.readFileSync(filePath, "utf-8") : "";
+        const yaml = fs2__default.existsSync(filePath) ? fs2__default.readFileSync(filePath, "utf-8") : "";
         ws.send(JSON.stringify({ requestId, data: { yaml, pluginKeys: getPluginKeys() } }));
       } catch (error) {
         ws.send(JSON.stringify({ requestId, error: `Failed to read config: ${error.message}` }));
@@ -107,7 +558,7 @@ async function handleWebSocketMessage(ws, message, webServer) {
           break;
         }
         const filePath = getConfigFilePath();
-        fs__default.writeFileSync(filePath, yaml, "utf-8");
+        fs2__default.writeFileSync(filePath, yaml, "utf-8");
         const configService2 = root.inject("config");
         const loader = configService2.configs.get("zhin.config.yml");
         if (loader) loader.load();
@@ -230,7 +681,7 @@ async function handleWebSocketMessage(ws, message, webServer) {
         const cwd = process.cwd();
         const files = ENV_WHITELIST.map((name) => ({
           name,
-          exists: fs__default.existsSync(path__default.resolve(cwd, name))
+          exists: fs2__default.existsSync(path2__default.resolve(cwd, name))
         }));
         ws.send(JSON.stringify({ requestId, data: { files } }));
       } catch (error) {
@@ -244,8 +695,8 @@ async function handleWebSocketMessage(ws, message, webServer) {
           ws.send(JSON.stringify({ requestId, error: `Invalid env file: ${filename}` }));
           break;
         }
-        const envPath = path__default.resolve(process.cwd(), filename);
-        const content = fs__default.existsSync(envPath) ? fs__default.readFileSync(envPath, "utf-8") : "";
+        const envPath = path2__default.resolve(process.cwd(), filename);
+        const content = fs2__default.existsSync(envPath) ? fs2__default.readFileSync(envPath, "utf-8") : "";
         ws.send(JSON.stringify({ requestId, data: { content } }));
       } catch (error) {
         ws.send(JSON.stringify({ requestId, error: `Failed to read env file: ${error.message}` }));
@@ -262,8 +713,8 @@ async function handleWebSocketMessage(ws, message, webServer) {
           ws.send(JSON.stringify({ requestId, error: "content field is required" }));
           break;
         }
-        const envPath = path__default.resolve(process.cwd(), filename);
-        fs__default.writeFileSync(envPath, content, "utf-8");
+        const envPath = path2__default.resolve(process.cwd(), filename);
+        fs2__default.writeFileSync(envPath, content, "utf-8");
         ws.send(JSON.stringify({ requestId, data: { success: true, message: "\u73AF\u5883\u53D8\u91CF\u5DF2\u4FDD\u5B58\uFF0C\u9700\u91CD\u542F\u751F\u6548" } }));
       } catch (error) {
         ws.send(JSON.stringify({ requestId, error: `Failed to save env file: ${error.message}` }));
@@ -288,12 +739,12 @@ async function handleWebSocketMessage(ws, message, webServer) {
           ws.send(JSON.stringify({ requestId, error: `Access denied: ${fp}` }));
           break;
         }
-        const absPath = path__default.resolve(process.cwd(), fp);
-        if (!fs__default.existsSync(absPath)) {
+        const absPath = path2__default.resolve(process.cwd(), fp);
+        if (!fs2__default.existsSync(absPath)) {
           ws.send(JSON.stringify({ requestId, error: `File not found: ${fp}` }));
           break;
         }
-        const stat = fs__default.statSync(absPath);
+        const stat = fs2__default.statSync(absPath);
         if (!stat.isFile()) {
           ws.send(JSON.stringify({ requestId, error: `Not a file: ${fp}` }));
           break;
@@ -302,7 +753,7 @@ async function handleWebSocketMessage(ws, message, webServer) {
           ws.send(JSON.stringify({ requestId, error: `File too large: ${(stat.size / 1024).toFixed(0)}KB (max 1MB)` }));
           break;
         }
-        const fileContent = fs__default.readFileSync(absPath, "utf-8");
+        const fileContent = fs2__default.readFileSync(absPath, "utf-8");
         ws.send(JSON.stringify({ requestId, data: { content: fileContent, size: stat.size } }));
       } catch (error) {
         ws.send(JSON.stringify({ requestId, error: `Failed to read file: ${error.message}` }));
@@ -319,12 +770,12 @@ async function handleWebSocketMessage(ws, message, webServer) {
           ws.send(JSON.stringify({ requestId, error: "content field is required" }));
           break;
         }
-        const absPath = path__default.resolve(process.cwd(), fp);
-        const dir = path__default.dirname(absPath);
-        if (!fs__default.existsSync(dir)) {
-          fs__default.mkdirSync(dir, { recursive: true });
+        const absPath = path2__default.resolve(process.cwd(), fp);
+        const dir = path2__default.dirname(absPath);
+        if (!fs2__default.existsSync(dir)) {
+          fs2__default.mkdirSync(dir, { recursive: true });
         }
-        fs__default.writeFileSync(absPath, fileContent, "utf-8");
+        fs2__default.writeFileSync(absPath, fileContent, "utf-8");
         ws.send(JSON.stringify({ requestId, data: { success: true, message: `\u6587\u4EF6\u5DF2\u4FDD\u5B58: ${fp}` } }));
       } catch (error) {
         ws.send(JSON.stringify({ requestId, error: `Failed to save file: ${error.message}` }));
@@ -467,6 +918,494 @@ async function handleWebSocketMessage(ws, message, webServer) {
         ws.send(JSON.stringify({ requestId, error: `Failed to get entries: ${error.message}` }));
       }
       break;
+    // ================================================================
+    // 机器人管理（WebSocket）
+    // ================================================================
+    case "bot:list": {
+      try {
+        const botsWithPending = await collectBotsListWithPending();
+        ws.send(JSON.stringify({ requestId, data: { bots: botsWithPending } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: error.message }));
+      }
+      break;
+    }
+    case "bot:info": {
+      try {
+        const d = message.data || {};
+        const { adapter, botId } = d;
+        if (!adapter || !botId) {
+          ws.send(JSON.stringify({ requestId, error: "adapter and botId required" }));
+          break;
+        }
+        const ad = root.inject(adapter);
+        if (!(ad instanceof Adapter)) {
+          ws.send(JSON.stringify({ requestId, error: "adapter not found" }));
+          break;
+        }
+        const bot = ad.bots.get(botId);
+        if (!bot) {
+          ws.send(JSON.stringify({ requestId, error: "bot not found" }));
+          break;
+        }
+        ws.send(
+          JSON.stringify({
+            requestId,
+            data: {
+              name: botId,
+              adapter: String(adapter),
+              connected: !!bot.$connected,
+              status: bot.$connected ? "online" : "offline"
+            }
+          })
+        );
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: error.message }));
+      }
+      break;
+    }
+    case "bot:sendMessage": {
+      try {
+        const d = message.data || {};
+        const { adapter, botId, id, type: msgType, content } = d;
+        if (!adapter || !botId || !id || !msgType || content === void 0) {
+          ws.send(
+            JSON.stringify({
+              requestId,
+              error: "adapter, botId, id, type, content required"
+            })
+          );
+          break;
+        }
+        const ad = root.inject(adapter);
+        if (!(ad instanceof Adapter)) {
+          ws.send(JSON.stringify({ requestId, error: "adapter not found" }));
+          break;
+        }
+        const normalized = typeof content === "string" ? content : Array.isArray(content) ? content : String(content);
+        const messageId = await ad.sendMessage({
+          context: adapter,
+          bot: botId,
+          id: String(id),
+          type: msgType,
+          content: normalized
+        });
+        ws.send(JSON.stringify({ requestId, data: { messageId } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: error.message }));
+      }
+      break;
+    }
+    case "bot:friends":
+    case "bot:groups": {
+      try {
+        const d = message.data || {};
+        const { adapter, botId } = d;
+        if (!adapter || !botId) {
+          ws.send(JSON.stringify({ requestId, error: "adapter and botId required" }));
+          break;
+        }
+        if (adapter !== "icqq") {
+          ws.send(JSON.stringify({ requestId, error: "not supported for this adapter" }));
+          break;
+        }
+        const ad = root.inject("icqq");
+        const bot = ad?.bots?.get?.(botId);
+        if (!bot) {
+          ws.send(JSON.stringify({ requestId, error: "bot not found" }));
+          break;
+        }
+        if (type === "bot:friends") {
+          const fl = bot.fl;
+          const friends = Array.from((fl || /* @__PURE__ */ new Map()).values()).map((f) => ({
+            user_id: f.user_id,
+            nickname: f.nickname,
+            remark: f.remark
+          }));
+          ws.send(JSON.stringify({ requestId, data: { friends, count: friends.length } }));
+        } else {
+          const gl = bot.gl;
+          const groups = Array.from((gl || /* @__PURE__ */ new Map()).values()).map((g) => ({
+            group_id: g.group_id,
+            name: g.name
+          }));
+          ws.send(JSON.stringify({ requestId, data: { groups, count: groups.length } }));
+        }
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: error.message }));
+      }
+      break;
+    }
+    case "bot:channels": {
+      try {
+        const d = message.data || {};
+        const { adapter, botId } = d;
+        if (!adapter || !botId) {
+          ws.send(JSON.stringify({ requestId, error: "adapter and botId required" }));
+          break;
+        }
+        if (adapter === "icqq") {
+          ws.send(JSON.stringify({ requestId, error: "channels not supported for icqq" }));
+          break;
+        }
+        const ad = root.inject(adapter);
+        const bot = ad?.bots?.get?.(botId);
+        if (!bot) {
+          ws.send(JSON.stringify({ requestId, error: "bot not found" }));
+          break;
+        }
+        const channels = [];
+        if (adapter === "qq" && typeof bot.getGuilds === "function" && typeof bot.getChannels === "function") {
+          const guilds = await bot.getGuilds() || [];
+          for (const g of guilds) {
+            const gid = g?.id ?? g?.guild_id ?? String(g);
+            const chs = await bot.getChannels(gid) || [];
+            for (const c of chs) {
+              channels.push({
+                id: String(c?.id ?? c?.channel_id ?? c),
+                name: String(c?.name ?? c?.channel_name ?? c?.id ?? "")
+              });
+            }
+          }
+        } else if (typeof ad?.listChannels === "function") {
+          const result = await ad.listChannels(botId);
+          if (Array.isArray(result)) channels.push(...result.map((c) => ({ id: String(c?.id ?? c), name: String(c?.name ?? c?.id ?? "") })));
+          else if (result?.channels) channels.push(...result.channels.map((c) => ({ id: String(c?.id ?? c), name: String(c?.name ?? c?.id ?? "") })));
+        }
+        ws.send(JSON.stringify({ requestId, data: { channels, count: channels.length } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: error.message }));
+      }
+      break;
+    }
+    case "bot:deleteFriend": {
+      try {
+        const d = message.data || {};
+        const { adapter, botId, userId } = d;
+        if (!adapter || !botId || !userId) {
+          ws.send(JSON.stringify({ requestId, error: "adapter, botId, userId required" }));
+          break;
+        }
+        const ad = root.inject(adapter);
+        const bot = ad?.bots?.get?.(botId);
+        if (!bot) {
+          ws.send(JSON.stringify({ requestId, error: "bot not found" }));
+          break;
+        }
+        if (adapter === "icqq" && typeof bot.deleteFriend === "function") {
+          await bot.deleteFriend(Number(userId));
+          ws.send(JSON.stringify({ requestId, data: { success: true } }));
+        } else if (adapter === "icqq" && typeof bot.delete_friend === "function") {
+          await bot.delete_friend(Number(userId));
+          ws.send(JSON.stringify({ requestId, data: { success: true } }));
+        } else {
+          ws.send(JSON.stringify({ requestId, error: "\u5F53\u524D\u9002\u914D\u5668\u6682\u4E0D\u652F\u6301\u5220\u9664\u597D\u53CB" }));
+        }
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: error.message }));
+      }
+      break;
+    }
+    case "bot:requests": {
+      try {
+        const d = message.data || {};
+        const { adapter, botId } = d;
+        if (!adapter || !botId) {
+          ws.send(JSON.stringify({ requestId, error: "adapter and botId required" }));
+          break;
+        }
+        const rows = await listRequestsForBot(String(adapter), String(botId));
+        ws.send(
+          JSON.stringify({
+            requestId,
+            data: {
+              requests: rows.map((r) => ({
+                id: r.id,
+                platformRequestId: r.platform_request_id,
+                type: r.type,
+                sender: { id: r.sender_id, name: r.sender_name },
+                comment: r.comment,
+                channel: { id: r.channel_id, type: r.channel_type },
+                timestamp: r.created_at
+              }))
+            }
+          })
+        );
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: error.message }));
+      }
+      break;
+    }
+    case "bot:requestApprove":
+    case "bot:requestReject": {
+      try {
+        const d = message.data || {};
+        const { adapter, botId, requestId: platformReqId, remark, reason } = d;
+        if (!adapter || !botId || !platformReqId) {
+          ws.send(
+            JSON.stringify({
+              requestId,
+              error: "adapter, botId, requestId required"
+            })
+          );
+          break;
+        }
+        const req = getPendingRequest(String(adapter), String(botId), String(platformReqId));
+        if (!req) {
+          ws.send(
+            JSON.stringify({
+              requestId,
+              error: "request not in memory (restart?) \u2014 use bot:requestConsumed to dismiss"
+            })
+          );
+          break;
+        }
+        if (type === "bot:requestApprove") await req.$approve(remark);
+        else await req.$reject(reason);
+        await markRequestConsumedByPlatformId(String(adapter), String(botId), String(platformReqId));
+        ws.send(JSON.stringify({ requestId, data: { success: true } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: error.message }));
+      }
+      break;
+    }
+    case "bot:requestConsumed": {
+      try {
+        const d = message.data || {};
+        const ids = d.ids ?? (d.id != null ? [d.id] : []);
+        if (!Array.isArray(ids) || !ids.length) {
+          ws.send(JSON.stringify({ requestId, error: "id or ids required" }));
+          break;
+        }
+        const numIds = ids.map(Number);
+        for (const id of numIds) {
+          const row = await getRequestRowById(id);
+          if (row && row.consumed === 0) {
+            removePendingRequest(row.adapter, row.bot_id, row.platform_request_id);
+          }
+        }
+        await markRequestsConsumed(numIds);
+        ws.send(JSON.stringify({ requestId, data: { success: true } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: error.message }));
+      }
+      break;
+    }
+    case "bot:noticeConsumed": {
+      try {
+        const d = message.data || {};
+        const ids = d.ids ?? (d.id != null ? [d.id] : []);
+        if (!Array.isArray(ids) || !ids.length) {
+          ws.send(JSON.stringify({ requestId, error: "id or ids required" }));
+          break;
+        }
+        await markNoticesConsumed(ids.map(Number));
+        ws.send(JSON.stringify({ requestId, data: { success: true } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: error.message }));
+      }
+      break;
+    }
+    case "bot:inboxMessages": {
+      try {
+        const d = message.data || {};
+        const { adapter, botId, channelId, channelType, limit = 50, beforeId, beforeTs } = d;
+        if (!adapter || !botId || !channelId || !channelType) {
+          ws.send(JSON.stringify({ requestId, error: "adapter, botId, channelId, channelType required" }));
+          break;
+        }
+        let db;
+        try {
+          db = root.inject("database");
+        } catch {
+          ws.send(JSON.stringify({ requestId, data: { messages: [], inboxEnabled: false } }));
+          break;
+        }
+        const MessageModel = db?.models?.get("unified_inbox_message");
+        if (!MessageModel) {
+          ws.send(JSON.stringify({ requestId, data: { messages: [], inboxEnabled: false } }));
+          break;
+        }
+        const where = {
+          adapter: String(adapter),
+          bot_id: String(botId),
+          channel_id: String(channelId),
+          channel_type: String(channelType)
+        };
+        if (beforeTs != null) where.created_at = { $lt: Number(beforeTs) };
+        if (beforeId != null) where.id = { $lt: Number(beforeId) };
+        let q = MessageModel.select().where(where).orderBy("created_at", "DESC").limit(Math.min(Number(limit) || 50, 100));
+        const rows = await (typeof q.then === "function" ? q : Promise.resolve(q));
+        const messages = (rows || []).map((r) => ({
+          id: r.id,
+          platform_message_id: r.platform_message_id,
+          sender_id: r.sender_id,
+          sender_name: r.sender_name,
+          content: r.content,
+          raw: r.raw,
+          created_at: r.created_at
+        }));
+        ws.send(JSON.stringify({ requestId, data: { messages, inboxEnabled: true } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: error.message }));
+      }
+      break;
+    }
+    case "bot:inboxRequests": {
+      try {
+        const d = message.data || {};
+        const { adapter, botId, limit = 30, offset = 0 } = d;
+        if (!adapter || !botId) {
+          ws.send(JSON.stringify({ requestId, error: "adapter and botId required" }));
+          break;
+        }
+        let db;
+        try {
+          db = root.inject("database");
+        } catch {
+          ws.send(JSON.stringify({ requestId, data: { requests: [], inboxEnabled: false } }));
+          break;
+        }
+        const RequestModel = db?.models?.get("unified_inbox_request");
+        if (!RequestModel) {
+          ws.send(JSON.stringify({ requestId, data: { requests: [], inboxEnabled: false } }));
+          break;
+        }
+        const where = { adapter: String(adapter), bot_id: String(botId) };
+        const limitNum = Math.min(Number(limit) || 30, 100);
+        const offsetNum = Math.max(0, Number(offset) || 0);
+        let q = RequestModel.select().where(where).orderBy("created_at", "DESC").limit(limitNum).offset(offsetNum);
+        const rows = await (typeof q.then === "function" ? q : Promise.resolve(q));
+        const requests = (rows || []).map((r) => ({
+          id: r.id,
+          platform_request_id: r.platform_request_id,
+          type: r.type,
+          sub_type: r.sub_type,
+          channel_id: r.channel_id,
+          channel_type: r.channel_type,
+          sender_id: r.sender_id,
+          sender_name: r.sender_name,
+          comment: r.comment,
+          created_at: r.created_at,
+          resolved: r.resolved,
+          resolved_at: r.resolved_at
+        }));
+        ws.send(JSON.stringify({ requestId, data: { requests, inboxEnabled: true } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: error.message }));
+      }
+      break;
+    }
+    case "bot:inboxNotices": {
+      try {
+        const d = message.data || {};
+        const { adapter, botId, limit = 30, offset = 0 } = d;
+        if (!adapter || !botId) {
+          ws.send(JSON.stringify({ requestId, error: "adapter and botId required" }));
+          break;
+        }
+        let db;
+        try {
+          db = root.inject("database");
+        } catch {
+          ws.send(JSON.stringify({ requestId, data: { notices: [], inboxEnabled: false } }));
+          break;
+        }
+        const NoticeModel = db?.models?.get("unified_inbox_notice");
+        if (!NoticeModel) {
+          ws.send(JSON.stringify({ requestId, data: { notices: [], inboxEnabled: false } }));
+          break;
+        }
+        const where = { adapter: String(adapter), bot_id: String(botId) };
+        const limitNum = Math.min(Number(limit) || 30, 100);
+        const offsetNum = Math.max(0, Number(offset) || 0);
+        let q = NoticeModel.select().where(where).orderBy("created_at", "DESC").limit(limitNum).offset(offsetNum);
+        const rows = await (typeof q.then === "function" ? q : Promise.resolve(q));
+        const notices = (rows || []).map((r) => ({
+          id: r.id,
+          platform_notice_id: r.platform_notice_id,
+          type: r.type,
+          sub_type: r.sub_type,
+          channel_id: r.channel_id,
+          channel_type: r.channel_type,
+          operator_id: r.operator_id,
+          operator_name: r.operator_name,
+          target_id: r.target_id,
+          target_name: r.target_name,
+          payload: r.payload,
+          created_at: r.created_at
+        }));
+        ws.send(JSON.stringify({ requestId, data: { notices, inboxEnabled: true } }));
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: error.message }));
+      }
+      break;
+    }
+    case "bot:groupMembers":
+    case "bot:groupKick":
+    case "bot:groupMute":
+    case "bot:groupAdmin": {
+      try {
+        const d = message.data || {};
+        const { adapter, botId, groupId, userId, duration, enable } = d;
+        if (!adapter || !botId || !groupId) {
+          ws.send(
+            JSON.stringify({ requestId, error: "adapter, botId, groupId required" })
+          );
+          break;
+        }
+        const ad = root.inject(adapter);
+        if (!ad) {
+          ws.send(JSON.stringify({ requestId, error: "adapter not found" }));
+          break;
+        }
+        const gid = String(groupId);
+        if (type === "bot:groupMembers") {
+          if (typeof ad.listMembers !== "function") {
+            ws.send(JSON.stringify({ requestId, error: "adapter does not support listMembers" }));
+            break;
+          }
+          const r = await ad.listMembers(botId, gid);
+          ws.send(JSON.stringify({ requestId, data: r }));
+        } else if (type === "bot:groupKick") {
+          if (!userId) {
+            ws.send(JSON.stringify({ requestId, error: "userId required" }));
+            break;
+          }
+          if (typeof ad.kickMember !== "function") {
+            ws.send(JSON.stringify({ requestId, error: "adapter does not support kickMember" }));
+            break;
+          }
+          await ad.kickMember(botId, gid, String(userId));
+          ws.send(JSON.stringify({ requestId, data: { success: true } }));
+        } else if (type === "bot:groupMute") {
+          if (!userId) {
+            ws.send(JSON.stringify({ requestId, error: "userId required" }));
+            break;
+          }
+          if (typeof ad.muteMember !== "function") {
+            ws.send(JSON.stringify({ requestId, error: "adapter does not support muteMember" }));
+            break;
+          }
+          await ad.muteMember(botId, gid, String(userId), duration ?? 600);
+          ws.send(JSON.stringify({ requestId, data: { success: true } }));
+        } else {
+          if (!userId) {
+            ws.send(JSON.stringify({ requestId, error: "userId required" }));
+            break;
+          }
+          if (typeof ad.setAdmin !== "function") {
+            ws.send(JSON.stringify({ requestId, error: "adapter does not support setAdmin" }));
+            break;
+          }
+          await ad.setAdmin(botId, gid, String(userId), enable !== false);
+          ws.send(JSON.stringify({ requestId, data: { success: true } }));
+        }
+      } catch (error) {
+        ws.send(JSON.stringify({ requestId, error: error.message }));
+      }
+      break;
+    }
     default:
       ws.send(JSON.stringify({ requestId, error: `Unknown message type: ${type}` }));
   }
@@ -628,13 +1567,13 @@ async function kvGetEntries(table) {
 }
 function buildFileTree(cwd, relativePath, allowed) {
   const tree = [];
-  path__default.resolve(cwd, relativePath);
+  path2__default.resolve(cwd, relativePath);
   for (const entry of allowed) {
     const entryRelative = entry;
     if (entryRelative.includes("/")) continue;
-    const absPath = path__default.resolve(cwd, entry);
-    if (!fs__default.existsSync(absPath)) continue;
-    const stat = fs__default.statSync(absPath);
+    const absPath = path2__default.resolve(cwd, entry);
+    if (!fs2__default.existsSync(absPath)) continue;
+    const stat = fs2__default.statSync(absPath);
     if (stat.isDirectory()) {
       tree.push({
         name: entryRelative,
@@ -653,9 +1592,9 @@ function buildFileTree(cwd, relativePath, allowed) {
 }
 function buildDirectoryTree(cwd, relativePath, maxDepth) {
   if (maxDepth <= 0) return [];
-  const absDir = path__default.resolve(cwd, relativePath);
-  if (!fs__default.existsSync(absDir) || !fs__default.statSync(absDir).isDirectory()) return [];
-  const entries = fs__default.readdirSync(absDir, { withFileTypes: true });
+  const absDir = path2__default.resolve(cwd, relativePath);
+  if (!fs2__default.existsSync(absDir) || !fs2__default.statSync(absDir).isDirectory()) return [];
+  const entries = fs2__default.readdirSync(absDir, { withFileTypes: true });
   const result = [];
   for (const entry of entries) {
     if (FILE_MANAGER_BLOCKED.has(entry.name) || entry.name.startsWith(".")) continue;
@@ -700,7 +1639,7 @@ var cache = /* @__PURE__ */ new Map();
 var TRANSFORMABLE_EXTS = [".ts", ".tsx", ".jsx"];
 var RESOLVE_EXTS = [".tsx", ".ts", ".jsx", ".js"];
 function isTransformable(filePath) {
-  const ext = path.extname(filePath).toLowerCase();
+  const ext = path2.extname(filePath).toLowerCase();
   return TRANSFORMABLE_EXTS.includes(ext);
 }
 var IMPORT_RE = /(?:import|export)\s+.*?\s+from\s+['"]([^'"]+)['"]|import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
@@ -709,22 +1648,37 @@ function isRelative(specifier) {
   return specifier.startsWith("./") || specifier.startsWith("../");
 }
 function hasExtension(specifier) {
-  const base = path.basename(specifier);
+  const base = path2.basename(specifier);
   return base.includes(".") && !base.startsWith(".");
 }
+function resolveJsSpecifierToSource(specifier, fromFile) {
+  if (!isRelative(specifier) || !specifier.endsWith(".js")) return specifier;
+  const dir = path2.dirname(fromFile);
+  const jsPath = path2.resolve(dir, specifier);
+  if (fs2.existsSync(jsPath)) return specifier;
+  const base = specifier.slice(0, -3);
+  for (const ext of [".tsx", ".ts", ".jsx"]) {
+    if (fs2.existsSync(path2.resolve(dir, base + ext))) {
+      return base + ext;
+    }
+  }
+  return specifier;
+}
 function resolveRelativeImport(specifier, fromFile) {
   if (!isRelative(specifier)) return specifier;
-  if (hasExtension(specifier)) return specifier;
-  const dir = path.dirname(fromFile);
-  const target = path.resolve(dir, specifier);
+  if (hasExtension(specifier)) {
+    return resolveJsSpecifierToSource(specifier, fromFile);
+  }
+  const dir = path2.dirname(fromFile);
+  const target = path2.resolve(dir, specifier);
   for (const ext of RESOLVE_EXTS) {
-    if (fs.existsSync(target + ext)) {
+    if (fs2.existsSync(target + ext)) {
       return specifier + ext;
     }
   }
-  if (fs.existsSync(target) && fs.statSync(target).isDirectory()) {
+  if (fs2.existsSync(target) && fs2.statSync(target).isDirectory()) {
     for (const ext of RESOLVE_EXTS) {
-      if (fs.existsSync(path.join(target, `index${ext}`))) {
+      if (fs2.existsSync(path2.join(target, `index${ext}`))) {
         return specifier + `/index${ext}`;
       }
     }
@@ -736,7 +1690,6 @@ function rewriteImports(code, fromFile) {
   code = code.replace(IMPORT_RE, (match, fromSpecifier, dynamicSpecifier) => {
     const specifier = fromSpecifier || dynamicSpecifier;
     if (!specifier || !isRelative(specifier)) return match;
-    if (hasExtension(specifier)) return match;
     const resolved = resolveRelativeImport(specifier, fromFile);
     if (resolved === specifier) return match;
     return match.replace(specifier, resolved);
@@ -744,13 +1697,13 @@ function rewriteImports(code, fromFile) {
   return code;
 }
 async function transformFile(filePath) {
-  const stat = fs.statSync(filePath);
+  const stat = fs2.statSync(filePath);
   const cached = cache.get(filePath);
   if (cached && cached.mtime === stat.mtimeMs) {
     return cached.code;
   }
-  const source = fs.readFileSync(filePath, "utf-8");
-  const ext = path.extname(filePath).toLowerCase();
+  const source = fs2.readFileSync(filePath, "utf-8");
+  const ext = path2.extname(filePath).toLowerCase();
   const loader = ext === ".tsx" ? "tsx" : ext === ".ts" ? "ts" : ext === ".jsx" ? "jsx" : "js";
   const result = await transform(source, {
     loader,
@@ -775,6 +1728,8 @@ var {
   // 默认不延迟加载，避免 addEntry 等功能不可用
 } = consoleConfig;
 if (enabled) {
+  registerBotModels(root2);
+  initBotPersistence(root2);
   const createAddMsg = (key, value) => ({
     type: "add",
     data: { key, value }
@@ -788,11 +1743,11 @@ if (enabled) {
     const genToken = () => crypto.randomBytes(6).toString("hex");
     const watchedDirs = /* @__PURE__ */ new Set();
     const watchers = [];
-    path.join(import.meta.dirname, "../client");
-    const distDir = path.join(import.meta.dirname, "../dist");
+    path2.join(import.meta.dirname, "../client");
+    const distDir = path2.join(import.meta.dirname, "../dist");
     const resolveFile = (name) => {
-      const distPath = path.resolve(distDir, name);
-      if (fs.existsSync(distPath)) return distPath;
+      const distPath = path2.resolve(distDir, name);
+      if (fs2.existsSync(distPath)) return distPath;
       return null;
     };
     const webServer = {
@@ -800,8 +1755,8 @@ if (enabled) {
       addEntry(entry) {
         const hash = crypto.randomBytes(8).toString("hex");
         const entryFile = typeof entry === "string" ? entry : entry.production;
-        const dir = path.dirname(entryFile);
-        const filename = path.basename(entryFile);
+        const dir = path2.dirname(entryFile);
+        const filename = path2.basename(entryFile);
         let token;
         for (const [t, d] of entryBases) {
           if (d === dir) {
@@ -831,32 +1786,6 @@ if (enabled) {
       ws: router.ws("/server")
     };
     logger2.info(`Web \u63A7\u5236\u53F0\u5DF2\u542F\u52A8 (${"\u751F\u4EA7\u6A21\u5F0F, \u9759\u6001\u6587\u4EF6 + \u6309\u9700\u8F6C\u8BD1"})`);
-    const loginAssist = root2.inject("loginAssist");
-    if (loginAssist) {
-      router.get("/api/login-assist/pending", (ctx) => {
-        ctx.body = loginAssist.listPending();
-      });
-      router.post("/api/login-assist/submit", async (ctx) => {
-        const body = ctx.request?.body;
-        if (!body?.id) {
-          ctx.status = 400;
-          ctx.body = { error: "missing id" };
-          return;
-        }
-        const ok = loginAssist.submit(body.id, body.value ?? "");
-        ctx.body = { ok };
-      });
-      router.post("/api/login-assist/cancel", async (ctx) => {
-        const body = ctx.request?.body;
-        if (!body?.id) {
-          ctx.status = 400;
-          ctx.body = { error: "missing id" };
-          return;
-        }
-        const ok = loginAssist.cancel(body.id, body.reason);
-        ctx.body = { ok };
-      });
-    }
     router.all("*all", async (ctx, next) => {
       if (ctx.path.startsWith("/api/") || ctx.path === "/api" || ctx.path.startsWith("/pub/") || ctx.path === "/pub") {
         return next();
@@ -869,7 +1798,7 @@ if (enabled) {
       const name = ctx.path.slice(1);
       const sendFile = async (filename) => {
         try {
-          const stat = fs.statSync(filename);
+          const stat = fs2.statSync(filename);
           if (!stat.isFile()) {
             ctx.status = 404;
             return;
@@ -891,9 +1820,9 @@ if (enabled) {
             return;
           }
         }
-        ctx.type = path.extname(filename);
+        ctx.type = path2.extname(filename);
         ctx.type = mime.getType(filename) || ctx.type;
-        return ctx.body = fs.createReadStream(filename);
+        return ctx.body = fs2.createReadStream(filename);
       };
       if (ctx.path.startsWith("/vite/@ext/")) {
         const rest = ctx.path.replace("/vite/@ext/", "");
@@ -909,13 +1838,13 @@ if (enabled) {
           ctx.status = 404;
           return;
         }
-        const fullPath = path.resolve(baseDir, relPath);
-        const safePfx = baseDir.endsWith(path.sep) ? baseDir : baseDir + path.sep;
+        const fullPath = path2.resolve(baseDir, relPath);
+        const safePfx = baseDir.endsWith(path2.sep) ? baseDir : baseDir + path2.sep;
         if (!fullPath.startsWith(safePfx) && fullPath !== baseDir) {
           ctx.status = 403;
           return;
         }
-        if (fs.existsSync(fullPath)) {
+        if (fs2.existsSync(fullPath)) {
           return sendFile(fullPath);
         }
         ctx.status = 404;
@@ -924,7 +1853,7 @@ if (enabled) {
       const resolved = resolveFile(name);
       if (resolved) {
         try {
-          const fileState = fs.statSync(resolved);
+          const fileState = fs2.statSync(resolved);
           if (fileState.isFile() && !fileState.isSocket() && !fileState.isFIFO()) {
             return sendFile(resolved);
           }