@zhin.js/console 1.0.51 → 1.0.52

package/lib/websocket.js

@@ -1,10 +1,334 @@
-import fs from 'fs';
-import path from 'path';
+import fs2 from 'fs';
+import path2 from 'path';
 import WebSocket from 'ws';
-import { usePlugin } from '@zhin.js/core';
+import { usePlugin, Adapter } from '@zhin.js/core';
+
+// src/websocket.ts
+
+// src/bot-persistence.ts
+var DATA_DIR = path2.join(process.cwd(), "data");
+var REQ_FILE = path2.join(DATA_DIR, "console_bot_requests.json");
+var NOTICE_FILE = path2.join(DATA_DIR, "console_bot_notices.json");
+function ensureDir() {
+  if (!fs2.existsSync(DATA_DIR)) fs2.mkdirSync(DATA_DIR, { recursive: true });
+}
+function loadFile(file, empty) {
+  try {
+    if (!fs2.existsSync(file)) return { ...empty };
+    const raw = fs2.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.writeFileSync(file, JSON.stringify(store, null, 0), "utf-8");
+}
+async function insertRequest(row) {
+  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 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 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 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 now = Date.now();
+  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 now = Date.now();
+  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 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 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(root2) {
+  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);
+  };
+  root2.on("request.receive", handlerReq);
+  root2.on("notice.receive", handlerNotice);
+  const adapterNames = root2.adapters ? [...root2.adapters] : [];
+  const inject = root2.inject;
+  if (inject && typeof inject === "function" && adapterNames.length > 0) {
+    for (const name of adapterNames) {
+      try {
+        const ad = inject(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",
@@ -28,7 +352,7 @@ var FILE_MANAGER_BLOCKED = /* @__PURE__ */ new Set([
   "coverage"
 ]);
 function isPathAllowed(relativePath) {
-  if (relativePath.includes("..") || path.isAbsolute(relativePath)) return false;
+  if (relativePath.includes("..") || path2.isAbsolute(relativePath)) return false;
   const normalized = relativePath.replace(/\\/g, "/").replace(/^\.\//, "");
   const firstSegment = normalized.split("/")[0];
   if (FILE_MANAGER_BLOCKED.has(firstSegment)) return false;
@@ -48,15 +372,20 @@ function getPluginKeys() {
   return Array.from(keys);
 }
 function getConfigFilePath() {
-  return path.resolve(process.cwd(), "zhin.config.yml");
+  return path2.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());
@@ -88,7 +417,7 @@ async function handleWebSocketMessage(ws, message, webServer) {
     case "config:get-yaml":
       try {
         const filePath = getConfigFilePath();
-        const yaml = fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf-8") : "";
+        const yaml = fs2.existsSync(filePath) ? fs2.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}` }));
@@ -102,7 +431,7 @@ async function handleWebSocketMessage(ws, message, webServer) {
           break;
         }
         const filePath = getConfigFilePath();
-        fs.writeFileSync(filePath, yaml, "utf-8");
+        fs2.writeFileSync(filePath, yaml, "utf-8");
         const configService = root.inject("config");
         const loader = configService.configs.get("zhin.config.yml");
         if (loader) loader.load();
@@ -225,7 +554,7 @@ async function handleWebSocketMessage(ws, message, webServer) {
         const cwd = process.cwd();
         const files = ENV_WHITELIST.map((name) => ({
           name,
-          exists: fs.existsSync(path.resolve(cwd, name))
+          exists: fs2.existsSync(path2.resolve(cwd, name))
         }));
         ws.send(JSON.stringify({ requestId, data: { files } }));
       } catch (error) {
@@ -239,8 +568,8 @@ async function handleWebSocketMessage(ws, message, webServer) {
           ws.send(JSON.stringify({ requestId, error: `Invalid env file: ${filename}` }));
           break;
         }
-        const envPath = path.resolve(process.cwd(), filename);
-        const content = fs.existsSync(envPath) ? fs.readFileSync(envPath, "utf-8") : "";
+        const envPath = path2.resolve(process.cwd(), filename);
+        const content = fs2.existsSync(envPath) ? fs2.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}` }));
@@ -257,8 +586,8 @@ async function handleWebSocketMessage(ws, message, webServer) {
           ws.send(JSON.stringify({ requestId, error: "content field is required" }));
           break;
         }
-        const envPath = path.resolve(process.cwd(), filename);
-        fs.writeFileSync(envPath, content, "utf-8");
+        const envPath = path2.resolve(process.cwd(), filename);
+        fs2.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}` }));
@@ -283,12 +612,12 @@ async function handleWebSocketMessage(ws, message, webServer) {
           ws.send(JSON.stringify({ requestId, error: `Access denied: ${fp}` }));
           break;
         }
-        const absPath = path.resolve(process.cwd(), fp);
-        if (!fs.existsSync(absPath)) {
+        const absPath = path2.resolve(process.cwd(), fp);
+        if (!fs2.existsSync(absPath)) {
           ws.send(JSON.stringify({ requestId, error: `File not found: ${fp}` }));
           break;
         }
-        const stat = fs.statSync(absPath);
+        const stat = fs2.statSync(absPath);
         if (!stat.isFile()) {
           ws.send(JSON.stringify({ requestId, error: `Not a file: ${fp}` }));
           break;
@@ -297,7 +626,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.readFileSync(absPath, "utf-8");
+        const fileContent = fs2.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}` }));
@@ -314,12 +643,12 @@ async function handleWebSocketMessage(ws, message, webServer) {
           ws.send(JSON.stringify({ requestId, error: "content field is required" }));
           break;
         }
-        const absPath = path.resolve(process.cwd(), fp);
-        const dir = path.dirname(absPath);
-        if (!fs.existsSync(dir)) {
-          fs.mkdirSync(dir, { recursive: true });
+        const absPath = path2.resolve(process.cwd(), fp);
+        const dir = path2.dirname(absPath);
+        if (!fs2.existsSync(dir)) {
+          fs2.mkdirSync(dir, { recursive: true });
         }
-        fs.writeFileSync(absPath, fileContent, "utf-8");
+        fs2.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}` }));
@@ -462,6 +791,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}` }));
   }
@@ -623,13 +1440,13 @@ async function kvGetEntries(table) {
 }
 function buildFileTree(cwd, relativePath, allowed) {
   const tree = [];
-  path.resolve(cwd, relativePath);
+  path2.resolve(cwd, relativePath);
   for (const entry of allowed) {
     const entryRelative = entry;
     if (entryRelative.includes("/")) continue;
-    const absPath = path.resolve(cwd, entry);
-    if (!fs.existsSync(absPath)) continue;
-    const stat = fs.statSync(absPath);
+    const absPath = path2.resolve(cwd, entry);
+    if (!fs2.existsSync(absPath)) continue;
+    const stat = fs2.statSync(absPath);
     if (stat.isDirectory()) {
       tree.push({
         name: entryRelative,
@@ -648,9 +1465,9 @@ function buildFileTree(cwd, relativePath, allowed) {
 }
 function buildDirectoryTree(cwd, relativePath, maxDepth) {
   if (maxDepth <= 0) return [];
-  const absDir = path.resolve(cwd, relativePath);
-  if (!fs.existsSync(absDir) || !fs.statSync(absDir).isDirectory()) return [];
-  const entries = fs.readdirSync(absDir, { withFileTypes: true });
+  const absDir = path2.resolve(cwd, relativePath);
+  if (!fs2.existsSync(absDir) || !fs2.statSync(absDir).isDirectory()) return [];
+  const entries = fs2.readdirSync(absDir, { withFileTypes: true });
   const result = [];
   for (const entry of entries) {
     if (FILE_MANAGER_BLOCKED.has(entry.name) || entry.name.startsWith(".")) continue;