@voko/lite 0.3.1

package/src/index.js

@@ -0,0 +1,712 @@
+#!/usr/bin/env node
+
+/**
+ * VOKO Lite — Node.js 轻量版入口
+ *
+ * 用法：
+ *   voko                   默认启动 MCP Server
+ *   voko start             启动 MCP Server
+ *   voko list              列出 agents
+ *   voko status            查看运行状态
+ *   voko register-capabilities <agentId>  注册能力
+ *
+ * @package @voko/lite
+ */
+
+// ── 优先加载本地编译的 better-sqlite3（避免与 Electron 版冲突） ──
+require('./preload');
+
+const path = require('path');
+const os = require('os');
+const express = require('express');
+
+// ── core 模块 ──
+const { initDatabase, createDatabaseAPI } = require('./core/database');
+const { createAgentRegistration } = require('./core/agent-registration');
+const { generateOSSSignature } = require('./server/oss');
+const { AgentWorkerManager } = require('./core/worker-manager');
+
+// ── Lite 模块 ──
+const { createContext } = require('./context');
+const cli = require('./cli');
+
+// ── MCP 模块 ──
+const { createMcpServer } = require('./mcp/server');
+const { createToolHandlers } = require('./mcp/tools');
+const { createHttpTransport } = require('./mcp/transport/http');
+
+const pkg = require('../package.json');
+
+// ═══════════════════════════════════════════════
+//  工具函数
+// ═══════════════════════════════════════════════
+
+function parseArgs(argv) {
+  const args = {};
+  for (let i = 0; i < argv.length; i++) {
+    if (argv[i].startsWith('--')) {
+      const eq = argv[i].indexOf('=');
+      if (eq > 0) {
+        args[argv[i].slice(2, eq)] = argv[i].slice(eq + 1);
+      } else {
+        const key = argv[i].slice(2);
+        const next = argv[i + 1];
+        if (next && !next.startsWith('--')) {
+          args[key] = next;
+          i++;
+        } else {
+          args[key] = true;
+        }
+      }
+    }
+  }
+  return args;
+}
+
+function getDesktopDbPath() {
+  const platform = process.platform;
+  if (platform === 'win32' && process.env.APPDATA) {
+    return path.join(process.env.APPDATA, 'voko', 'wukongim.db');
+  }
+  if (platform === 'darwin') {
+    return path.join(os.homedir(), 'Library', 'Application Support', 'voko', 'wukongim.db');
+  }
+  const xdg = process.env.XDG_CONFIG_HOME;
+  const configDir = xdg || path.join(os.homedir(), '.config');
+  return path.join(configDir, 'voko', 'wukongim.db');
+}
+
+function resolveDbPath(args) {
+  if (args.db) return args.db;
+  const desktopDb = getDesktopDbPath();
+  if (require('fs').existsSync(desktopDb)) {
+    console.error('[VOKO Lite] 使用数据库:', desktopDb);
+    return desktopDb;
+  }
+  const fallbackDir = path.join(os.homedir(), '.voko');
+  try { require('fs').mkdirSync(fallbackDir, { recursive: true }); } catch (_) {}
+  const fallback = path.join(fallbackDir, 'data.db');
+  console.error('[VOKO Lite] 使用默认数据库:', fallback);
+  return fallback;
+}
+
+function initCore(args) {
+  const dbPath = resolveDbPath(args);
+  const db = initDatabase(dbPath);
+  const databaseAPI = createDatabaseAPI(db);
+  const agentRegistration = createAgentRegistration({ db });
+  const agentManager = new AgentWorkerManager(db);
+  AgentWorkerManager.killOrphanedWorkers();
+  return { db, databaseAPI, agentRegistration, agentManager };
+}
+
+// ═══════════════════════════════════════════════
+//  MCP Server 模式
+// ═══════════════════════════════════════════════
+
+async function startMcpServer(args, core) {
+  const { db, databaseAPI, agentRegistration, agentManager } = core;
+
+  // ── 自动恢复已发布的 agent（仅当前用户名下） ──
+  const userEmail = getCurrentUserEmail(db);
+  const published = userEmail
+    ? db.prepare("SELECT * FROM agents WHERE publish_status = 'published' AND owner_email = ?").all(userEmail)
+    : db.prepare("SELECT * FROM agents WHERE publish_status = 'published'").all();
+  for (const agent of published) {
+    const config = { uid: agent.imUid, token: agent.imToken, serverUrl: agent.im_server_url };
+    agentManager.start(agent.agent_id, config);
+    console.error(`[VOKO Lite] 已恢复 agent: ${agent.agent_name || agent.agent_id}`);
+  }
+
+  // ── 处理 worker 上报的消息 ──
+  agentManager.on('message', (msg) => {
+    try {
+      const d = msg.data || msg;
+      databaseAPI.saveMessage({
+        id: d.messageId || `wk-${msg.agentId}-${Date.now()}`,
+        channelId: d.channelId,
+        channelType: d.channelType || 1,
+        fromUid: d.fromUid,
+        toUid: d.toUid || msg.agentId,
+        agentId: msg.agentId,
+        content: d.content || '',
+        timestamp: d.timestamp || Math.floor(Date.now() / 1000),
+        isMe: false,
+        status: 'received',
+        messageSeq: d.messageSeq,
+        clientMsgNo: d.clientMsgNo,
+        contentType: d.contentType || 1,
+      });
+    } catch (e) {
+      console.error('[VOKO Lite] 消息写入失败:', e.message);
+    }
+  });
+
+  // ── 版本检查（异步，不阻塞） ──
+  cli.checkVersion();
+
+  // ── 启动心跳（仅上报 IM 状态） ──
+  startHeartbeat(db, agentManager, null, null);
+
+  const cx = createContext({ db, databaseAPI, agentRegistration, agentManager });
+  const handlers = createToolHandlers(cx);
+  const mcpServer = createMcpServer(handlers, { version: pkg.version });
+
+  if (args.transport === 'stdio') {
+    const { createStdioTransport } = require('./mcp/transport/stdio');
+    await createStdioTransport(mcpServer);
+    return;
+  }
+
+  const port = parseInt(args.port, 10) || 3100;
+  const app = express();
+  app.use(express.json());
+
+  const httpTransport = createHttpTransport(mcpServer, { version: pkg.version });
+  app.use('/mcp', httpTransport);
+  app.get('/health', (req, res) => res.json({ status: 'ok', uptime: process.uptime() }));
+  app.post('/api/quit', (req, res) => {
+    res.json({ success: true, message: 'Lite 正在关闭' });
+    shutdownAll(agentManager, db, 'api-quit');
+  });
+
+  // 模拟访客消息（供测试用，写入 DB）
+  app.post('/api/simulate-message', (req, res) => {
+    try {
+      const { fromUid, toUid, content, agentId } = req.body;
+      if (!fromUid || !toUid || !content || !agentId) {
+        return res.status(400).json({ success: false, error: '缺少参数: fromUid, toUid, content, agentId' });
+      }
+      const now = Math.floor(Date.now() / 1000);
+      const msgId = `sim_${agentId}_${Date.now()}`;
+      databaseAPI.saveMessage({
+        id: msgId, channelId: fromUid, channelType: 1,
+        fromUid, toUid, agentId, content, timestamp: now,
+        isMe: false, status: 'received',
+        messageSeq: null, clientMsgNo: null,
+        contentType: 1,
+      });
+      res.json({ success: true, messageId: msgId, note: '已写入 DB（Lite 模式，不触发 agent 处理）' });
+    } catch (e) {
+      res.status(500).json({ success: false, error: e.message });
+    }
+  });
+
+  // 退出清理 —— 跨平台
+  process.on('SIGINT', () => shutdownAll(agentManager, db, 'SIGINT'));    // Ctrl+C (全平台)
+  process.on('SIGTERM', () => shutdownAll(agentManager, db, 'SIGTERM')); // kill (Unix), taskkill (Win)
+  if (process.platform === 'win32') {
+    process.on('SIGBREAK', () => shutdownAll(agentManager, db, 'SIGBREAK')); // taskkill / 任务管理器 (Win)
+  } else {
+    process.on('SIGHUP', () => shutdownAll(agentManager, db, 'SIGHUP'));    // 终端关闭 (Unix/macOS)
+  }
+
+  // 子进程退出时也清理（Desktop 作为父进程关闭的场景）
+  process.on('disconnect', () => shutdownAll(agentManager, db, 'disconnect'));
+
+  // 父进程死亡检测（终端关闭、客户端断连时主动退出）
+  const _parentCheck = setInterval(() => {
+    try { process.kill(process.ppid, 0); } catch (_) {
+      clearInterval(_parentCheck);
+      console.error('[VOKO Lite] 父进程已退出，自动终止');
+      shutdownAll(agentManager, db, 'parent-dead');
+    }
+  }, 3000);
+
+  // 兜底：进程退出前强杀所有 worker
+  process.on('exit', () => {
+    if (agentManager && agentManager._allWorkers.size > 0) {
+      for (const [id, entry] of agentManager._allWorkers) {
+        try { entry.worker?.kill('SIGKILL'); } catch (_) {}
+      }
+    }
+    try { if (db?.open) db.close(); } catch (_) {}
+  });
+
+  (function tryListen(port, maxAttempts = 10) {
+    app.listen(port)
+      .on('listening', () => console.error(`[VOKO Lite] 已启动 → http://localhost:${port}/mcp`))
+      .on('error', (err) => {
+        if (err.code === 'EADDRINUSE' && maxAttempts > 0) {
+          console.error(`[VOKO Lite] 端口 ${port} 已被占用，尝试 ${port + 1}...`);
+          tryListen(port + 1, maxAttempts - 1);
+        } else {
+          console.error(`[VOKO Lite] 端口 ${port} 启动失败:`, err.message);
+          process.exit(1);
+        }
+      });
+  })(port);
+}
+
+// ═══════════════════════════════════════════════
+//  createHandlers — 创建后端处理器（OpenClaw + Hermes）
+// ═══════════════════════════════════════════════
+
+/**
+ * 创建后端处理器实例，供 Desktop 调用。
+ * OpenClawWSHandler / HermesHandler 的 mainWindow 参数传 null，
+ * 因为两者实际不使用 mainWindow（已确认仅存储未引用）。
+ *
+ * @param {object} params
+ * @param {object}   params.databaseAPI - 来自 createDatabaseAPI()
+ * @param {string}   [params.openclawMode='ws'] - 'ws' | 'cli'
+ * @param {object}   [params.hermesConfig] - { apiHost, apiPort, apiKey, profiles }
+ * @param {Function} [params.onAgentReply] - callback(data) 收到 agent 回复时触发
+ * @returns {{ openclawHandler: object|null, hermesHandler: object|null }}
+ */
+function createHandlers({ databaseAPI, openclawMode = 'ws', hermesConfig = {}, onAgentReply } = {}) {
+  let openclawHandler = null;
+  let hermesHandler = null;
+
+  // ── OpenClaw 处理器 ──
+  try {
+    const OpenClawHandler = openclawMode === 'ws'
+      ? require('./server/openclaw-websocket-handler')
+      : require('./server/openclaw-handler-cli');
+    openclawHandler = new OpenClawHandler(databaseAPI, null); // mainWindow=null（未使用）
+
+    if (openclawMode === 'ws') {
+      const status = openclawHandler.getStatus();
+      if (!status.hasToken) {
+        console.warn('[Lite] OpenClaw WebSocket 模式需要配置 Gateway token');
+      }
+    }
+
+    if (onAgentReply) {
+      openclawHandler.on('agent.reply', onAgentReply);
+    }
+
+    // 异步启动 gateway
+    if (openclawMode === 'ws') {
+      openclawHandler._ensureGatewayRunning().then(running => {
+        if (!running) console.warn('[Lite] OpenClaw Gateway 启动失败');
+        openclawHandler.setEnabled(true);
+      });
+    } else {
+      openclawHandler.setEnabled(true);
+    }
+    console.error(`[Lite] OpenClaw 处理器已创建 (${openclawMode} 模式)`);
+  } catch (err) {
+    console.error('[Lite] OpenClaw 处理器创建失败:', err.message);
+  }
+
+  // ── Hermes 处理器 ──
+  try {
+    const HermesHandler = require('./server/hermes-handler');
+    hermesHandler = new HermesHandler(databaseAPI, null, { // mainWindow=null（未使用）
+      host: hermesConfig.apiHost || '127.0.0.1',
+      port: hermesConfig.apiPort || 8642,
+      apiKey: hermesConfig.apiKey || '',
+      profiles: hermesConfig.profiles || {},
+    });
+    if (onAgentReply) {
+      hermesHandler.on('agent.reply', onAgentReply);
+    }
+    hermesHandler.setEnabled(true);
+    const keyHint = hermesConfig.apiKey ? `${hermesConfig.apiKey.substring(0, 8)}...` : '(空)';
+    console.error(`[Lite] Hermes 处理器已创建 host=${hermesConfig.apiHost || '127.0.0.1'}:${hermesConfig.apiPort || 8642} apiKey=${keyHint}`);
+  } catch (err) {
+    console.error('[Lite] Hermes 处理器创建失败:', err.message);
+  }
+
+  return { openclawHandler, hermesHandler };
+}
+
+// ═══════════════════════════════════════════════
+//  createMessageHandler — 创建消息处理器
+// ═══════════════════════════════════════════════
+
+/**
+ * 创建 MessageHandler 实例。
+ * MessageHandler 本身在 packages/lite/src/core/messenger.js，纯 Node.js 无 Electron 依赖。
+ * Desktop 通过 params 注入回调（notifyUI、enqueueIntervention 等）。
+ *
+ * @param {object} db - better-sqlite3 实例
+ * @param {object} params - 与 MessageHandler 构造器 options 一致
+ * @returns {object} MessageHandler 实例
+ */
+function createMessageHandler(db, params) {
+  const { MessageHandler } = require('./core/messenger');
+  return new MessageHandler(db, params);
+}
+
+// ═══════════════════════════════════════════════
+//  createLiteApp — 程序化入口，供 Desktop 和外部调用
+// ═══════════════════════════════════════════════
+
+/**
+ * 创建 Lite 应用实例（清孤儿 → 初始化 DB → 自动恢复 worker → 按需创建处理器/消息处理/心跳）
+ *
+ * @param {object} [options]
+ * @param {string} [options.dbPath] - 数据库路径，默认自动检测
+ * @param {boolean} [options.autoStartWorkers] - 是否自动恢复 worker，默认 true
+ * @param {object} [options.appPaths] - Electron 打包路径（isPackaged/resourcesPath/userDataPath），
+ *                                      仅 Desktop 传入，纯 Node.js 环境不需要
+ * @param {object} [options.handlers] - 后端处理器配置（传入则自动创建 OpenClaw + Hermes）
+ * @param {string} [options.handlers.openclawMode='ws']
+ * @param {object} [options.handlers.hermesConfig]
+ * @param {Function} [options.handlers.onAgentReply] - agent.reply 回调
+ * @param {object} [options.messageHandler] - MessageHandler 配置（传入则自动创建）
+ * @param {object} [options.messageHandler.callbacks] - notifyUI/enqueueIntervention 等回调
+ * @param {object} [options.messageHandler.ac] - access-control 模块
+ * @param {object} [options.heartbeat] - 心跳配置（传入则自动启动）
+ * @param {Function} [options.heartbeat.onWarnings] - 警告回调
+ * @returns {Promise<{
+ *   db, databaseAPI, agentManager, agentRegistration,
+ *   openclawHandler, hermesHandler, messageHandler,
+ *   stopHeartbeat: Function,
+ *   dispose: Function
+ * }>}
+ */
+async function createLiteApp(options = {}) {
+  const dbPath = options.dbPath || resolveDbPath({});
+  const db = initDatabase(dbPath);
+  const databaseAPI = createDatabaseAPI(db);
+  const agentRegistration = createAgentRegistration({ db });
+  const agentManager = new AgentWorkerManager(db);
+  AgentWorkerManager.killOrphanedWorkers();
+
+  // ── 读取当前登录用户邮箱 ──
+  const currentUserEmail = getCurrentUserEmail(db);
+  if (currentUserEmail) {
+    console.error(`[Auth] 当前登录用户: ${currentUserEmail}`);
+  } else {
+    console.error('[Auth] 未检测到登录用户，跳过 worker 启动');
+  }
+
+  // ── 自动恢复 worker（仅启动当前用户名下 agent） ──
+  if (options.autoStartWorkers !== false) {
+    const sql = currentUserEmail
+      ? "SELECT * FROM agents WHERE publish_status = 'published' AND owner_email = ?"
+      : "SELECT * FROM agents WHERE publish_status = 'published'";
+    const published = currentUserEmail ? db.prepare(sql).all(currentUserEmail) : db.prepare(sql).all();
+    for (const agent of published) {
+      const config = { uid: agent.imUid, token: agent.imToken, serverUrl: agent.im_server_url };
+      agentManager.start(agent.agent_id, config, options.appPaths);
+      console.error(`[VOKO Lite] 已恢复 agent: ${agent.agent_name || agent.agent_id}`);
+    }
+
+    agentManager.on('message', (msg) => {
+      try {
+        const d = msg.data || msg;
+        databaseAPI.saveMessage({
+          id: d.messageId || `wk-${msg.agentId}-${Date.now()}`,
+          channelId: d.channelId,
+          channelType: d.channelType || 1,
+          fromUid: d.fromUid,
+          toUid: d.toUid || msg.agentId,
+          agentId: msg.agentId,
+          content: d.content || '',
+          timestamp: d.timestamp || Math.floor(Date.now() / 1000),
+          isMe: false,
+          status: 'received',
+          messageSeq: d.messageSeq,
+          clientMsgNo: d.clientMsgNo,
+          contentType: d.contentType || 1,
+        });
+      } catch (e) {
+        console.error('[VOKO Lite] 消息写入失败:', e.message);
+      }
+    });
+  }
+
+  // ── 创建 MessageHandler（可选） ──
+  let messageHandler = null;
+  if (options.messageHandler) {
+    const { MessageHandler } = require('./core/messenger');
+    messageHandler = new MessageHandler(db, {
+      databaseAPI,
+      agentWorkers: agentManager.workers,
+      ac: options.messageHandler.ac || null,
+      ...options.messageHandler.callbacks,
+    });
+  }
+
+  // ── 创建后端处理器（可选） ──
+  let openclawHandler = null;
+  let hermesHandler = null;
+  if (options.handlers) {
+    const h = options.handlers;
+    // 如果未提供 hermesConfig 或 apiKey 为空，从数据库读取 channel_config
+    let hermesConfig = h.hermesConfig || {};
+    if (!hermesConfig.apiKey) {
+      try {
+        const channelCfg = databaseAPI.getConfigFromDb();
+        const hc = channelCfg?.hermes_config || {};
+        hermesConfig = {
+          apiHost: hc.apiHost || '127.0.0.1',
+          apiPort: hc.apiPort || 8642,
+          apiKey: hc.apiKey || '',
+          profiles: hc.profiles || {},
+        };
+      } catch (_) {}
+    }
+    const result = createHandlers({
+      databaseAPI,
+      openclawMode: h.openclawMode || 'ws',
+      hermesConfig,
+      onAgentReply: h.onAgentReply
+        ? (data) => h.onAgentReply(data, messageHandler)
+        : undefined,
+    });
+    openclawHandler = result.openclawHandler;
+    hermesHandler = result.hermesHandler;
+    messageHandler?.setOpenclawHandler(openclawHandler);
+    messageHandler?.setHermesHandler(hermesHandler);
+  }
+
+  // ── 启动心跳（可选） ──
+  let stopHeartbeat = null;
+  if (options.heartbeat !== false) {
+    const hbOpts = options.heartbeat || {};
+    stopHeartbeat = startHeartbeat(db, agentManager, openclawHandler, hermesHandler, {
+      onWarnings: hbOpts.onWarnings || undefined,
+    });
+  }
+
+  // ── 版本检查（异步，不阻塞） ──
+  cli.checkVersion();
+
+  return {
+    db, databaseAPI, agentManager, agentRegistration,
+    openclawHandler, hermesHandler, messageHandler,
+    currentUserEmail,
+    stopHeartbeat: stopHeartbeat || (() => {}),
+    dispose: () => shutdownAll(agentManager, db, 'dispose'),
+  };
+}
+
+/**
+ * 获取当前登录用户邮箱
+ */
+function getCurrentUserEmail(db) {
+  try {
+    const { loadUserAccessTokenConfig } = require('./core/database');
+    const map = loadUserAccessTokenConfig(db);
+    const emails = Object.keys(map);
+    if (emails.length > 0) return emails[0];
+  } catch (_) {}
+  return null;
+}
+
+/**
+ * 启动心跳检测（每 60 秒上报 agent 状态到服务端）
+ *
+ * 完整模式（传 handler 引用）：健康检查 + 网关恢复 + 逐 agent IM ping/pong + 心跳上报
+ * 简单模式（handler=null）：仅上报 IM 连接数
+ *
+ * @param {object}   db - better-sqlite3 实例
+ * @param {object}   agentManager - AgentWorkerManager 实例
+ * @param {object}   [openclawHandler] - OpenClawWSHandler 实例（可选）
+ * @param {object}   [hermesHandler] - HermesHandler 实例（可选）
+ * @param {object}   [options]
+ * @param {Function} [options.onWarnings] - 警告回调 (warnings[])
+ * @returns {Function} stop - 调用此函数停止心跳
+ */
+function startHeartbeat(db, agentManager, openclawHandler, hermesHandler, options = {}) {
+  const { onWarnings } = options;
+  const ENDPOINTS = require('./endpoints.json');
+  const BASE_URL = ENDPOINTS.im.baseUrl;
+
+  const timer = setInterval(async () => {
+    try {
+      const userEmail = getCurrentUserEmail(db);
+      // ── Hermes 健康检查 + 自动恢复 ──
+      if (hermesHandler?.client) {
+        try { await hermesHandler.healthCheck(); } catch (_) {}
+        if (!hermesHandler.connected) {
+          try {
+            const sql = userEmail
+              ? `SELECT agent_id FROM agents WHERE backend_type = 'hermes' AND publish_status = 'published' AND owner_email = ?`
+              : `SELECT agent_id FROM agents WHERE backend_type = 'hermes' AND publish_status = 'published'`;
+            const downAgents = userEmail ? db.prepare(sql).all(userEmail) : db.prepare(sql).all();
+            for (const { agent_id } of downAgents) {
+              try { await hermesHandler._ensureGatewayRunning(agent_id); }
+              catch (e) { console.error('[Lite] Hermes gateway 恢复失败:', agent_id, e.message); }
+            }
+          } catch (_) {}
+        }
+      }
+
+      // ── 遍历 agent 检测状态 ──
+      const warnings = [];
+      const agentSql = userEmail
+        ? "SELECT agent_id, agent_name, imUid, backend_type FROM agents WHERE publish_status = 'published' AND owner_email = ?"
+        : "SELECT agent_id, agent_name, imUid, backend_type FROM agents WHERE publish_status = 'published'";
+      const rows = userEmail ? db.prepare(agentSql).all(userEmail) : db.prepare(agentSql).all();
+      let imOnline = 0, backendOnline = 0, posted = 0;
+
+      for (const agent of rows) {
+        // IM 状态
+        let imOk = agentManager?.getStatus(agent.agent_id)?.connected || false;
+        if (!imOk && agentManager) {
+          try {
+            const workers = agentManager.workers;
+            const entry = workers?.get(agent.agent_id);
+            if (entry?.worker) {
+              imOk = await new Promise(resolve => {
+                const timer2 = setTimeout(() => resolve(false), 2000);
+                entry.worker.once('message', (msg) => {
+                  if (msg?.type === 'pong') { clearTimeout(timer2); resolve(msg.connected === true); }
+                });
+                entry.worker.send({ type: 'ping' });
+              });
+            }
+          } catch (_) {}
+        }
+
+        // 后端状态
+        let backendOk = false;
+        if (agent.backend_type === 'hermes') {
+          const ca = hermesHandler?.connectedAgents;
+          backendOk = ca ? ca.has(agent.agent_id) : !!hermesHandler?.connected;
+        } else {
+          backendOk = openclawHandler?.getStatus?.()?.connected || false;
+        }
+
+        if (imOk) imOnline++;
+        if (backendOk) backendOnline++;
+
+        const agentName = agent.agent_name || agent.agent_id;
+        if (!imOk) warnings.push({ type: 'agent-im-offline', message: `⚠️ ${agentName} IM 连接断开`, action: 'agent-detail', agentId: agent.agent_id });
+        if (!backendOk) warnings.push({ type: 'agent-backend-offline', message: `⚠️ ${agentName} 后端连接断开`, action: 'agent-detail', agentId: agent.agent_id });
+
+        if (imOk && backendOk) {
+          try {
+            const r = await fetch(`${BASE_URL}/api/heartbeat`, { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ uid: agent.imUid }) });
+            if (r.ok) posted++;
+          } catch (_) {}
+        }
+      }
+
+      // ── OpenClaw gateway 恢复 ──
+      if (openclawHandler) {
+        const ocStatus = openclawHandler.getStatus?.();
+        if (!ocStatus?.connected && !ocStatus?.connecting && openclawHandler._ensureGatewayRunning) {
+          openclawHandler._ensureGatewayRunning();
+        }
+      }
+
+      // ── 收集网关级警告 ──
+      if (openclawHandler?.getStatus) {
+        const s = openclawHandler.getStatus();
+        if (!s?.hasToken) warnings.push({ type: 'ws-no-token', message: '⚠️ OpenClaw Gateway 未配置 Token', action: 'settings-ws' });
+        else if (!s?.connected && !s?.connecting) warnings.push({ type: 'ws-disconnected', message: '⚠️ OpenClaw Gateway 未连接', action: null });
+        else if (s?.connecting) warnings.push({ type: 'ws-connecting', message: '⏳ OpenClaw Gateway 连接中', action: null });
+      }
+      if (hermesHandler && !hermesHandler.connected) {
+        warnings.push({ type: 'hermes-disconnected', message: '⚠️ Hermes Gateway 异常', action: 'settings-hermes' });
+      }
+
+      // ── 上报 ──
+      const ts = new Date().toLocaleTimeString();
+      console.error(`[${ts}][心跳] IM=${imOnline}/${rows.length} 后端=${backendOnline}/${rows.length}`);
+      if (posted > 0 || rows.length > 0) {
+        console.error(`[${ts}][心跳] 上报=${posted}个agent`);
+      }
+
+      if (warnings.length > 0) {
+        console.error(`[${ts}][心跳] 发现 ${warnings.length} 个异常:`, warnings.map(w => w.type).join(', '));
+      }
+      if (onWarnings) onWarnings(warnings);
+    } catch (e) {
+      console.error('[Lite] 心跳异常:', e.message);
+    }
+  }, 60000);
+
+  console.error('[Lite] 心跳检测已启动（60 秒间隔）');
+  return () => { clearInterval(timer); };
+}
+
+// ═══════════════════════════════════════════════
+//  退出清理
+// ═══════════════════════════════════════════════
+
+async function shutdownAll(agentManager, db, signal) {
+  console.error(`[VOKO Lite] 收到 ${signal}，正在清理...`);
+  // 先发 disconnect 让 worker 主动断开 IM（防止 zombie 连接）
+  if (agentManager) {
+    for (const [id, entry] of agentManager._allWorkers) {
+      try { entry.worker?.send({ type: 'disconnect' }); } catch (_) {}
+    }
+  }
+  // 等一刹那让消息发出去
+  await new Promise(r => setTimeout(r, 200));
+  if (db && db.open) {
+    try { db.close(); } catch (_) {}
+    console.error('[VOKO Lite] 数据库已关闭');
+  }
+  // process.exit 会触发 exit 事件兜底强杀所有 worker
+  process.exit(0);
+}
+
+// ── CLI 命令入口 ──
+
+function printUsage() {
+  console.log(`
+VOKO Lite — 纯 Node.js 轻量版
+
+用法:
+  voko                       启动 MCP Server（默认）
+  voko start                 启动 MCP Server
+  voko start --port 3100     指定端口
+  voko start --transport stdio  标准输入/输出模式
+  voko list                  列出所有 agents
+  voko status                查看运行状态
+  voko register-capabilities <agentId>  注册能力
+  voko update                升级到最新版本
+  voko --help                显示帮助
+`);
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  const subcommand = argv[0];
+
+  // 帮助
+  if (subcommand === '--help' || subcommand === '-h') {
+    printUsage();
+    return;
+  }
+
+  // 解析 --port 等参数（兼容 subcommand 后的参数）
+  const args = parseArgs(argv);
+
+  // 初始化 core（DB + AgentManager）
+  const core = initCore(args);
+
+  // 路由
+  if (!subcommand || subcommand === 'start') {
+    // MCP Server 模式
+    await startMcpServer(args, core);
+  } else if (subcommand === 'list') {
+    cli.listAgents(core);
+    core.db.close();
+  } else if (subcommand === 'status') {
+    cli.showStatus(core);
+    core.db.close();
+  } else if (subcommand === 'register-capabilities') {
+    const agentId = argv[1];
+    await cli.registerCapabilities(core, agentId);
+    core.db.close();
+  } else if (subcommand === 'update') {
+    cli.updateLite();
+  } else {
+    console.error(`未知命令: ${subcommand}`);
+    printUsage();
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main().catch(err => {
+    console.error('[VOKO Lite] 启动失败:', err);
+    process.exit(1);
+  });
+}
+
+// ═══════════════════════════════════════════════
+//  程序化导出 — 供 Desktop 和外部调用
+// ═══════════════════════════════════════════════
+
+module.exports = { initCore, createContext, createLiteApp, createHandlers, createMessageHandler, startHeartbeat, getCurrentUserEmail, syncOfflineMessages: require('./core/offline-sync').syncOfflineMessages, processPendingPaymentOrder: require('./core/payment').processPendingPaymentOrder, startPaymentPolling: require('./core/payment').startPaymentPolling, AgentWorkerManager, MessageFile: require('./workers/message-content').MessageFile };