@voko/lite 0.3.1

package/src/core/worker-manager.js

@@ -0,0 +1,332 @@
+/**
+ * worker-manager.js — Agent Worker 进程管理
+ *
+ * 管理 WuKongIM 子进程（fork agent-worker.js）的全生命周期：
+ * 启动、停止、重启、状态追踪、系统消息发送。
+ * 纯 Node.js，无 Electron 依赖。
+ */
+
+const { fork, execSync } = require('child_process');
+const path = require('path');
+const EventEmitter = require('events');
+const fs = require('fs');
+
+class AgentWorkerManager extends EventEmitter {
+  /**
+   * @param {object} db - better-sqlite3 实例
+   * @param {object} [options]
+   * @param {object} [options.mainWindow] - Electron BrowserWindow（可选，用于 UI 通知）
+   */
+  constructor(db, options = {}) {
+    super();
+    this.db = db;
+    this.mainWindow = options.mainWindow || null;
+
+    // WuKongIM 多连接管理: agentId → { sdk, config }
+    this.wukongimConnections = new Map();
+
+    // Agent Worker 进程管理: agentId → { worker, config }
+    this.workers = new Map();
+
+    // Worker 上报的真实 IM 连接状态
+    this.connectionStatus = new Map();  // agentId → 'connected' | 'disconnected' | 'connecting' | 'kicked'
+
+    // 已连接 agent 追踪
+    this.connectedAgents = new Set();
+    this.publishedAgentIds = new Set();
+
+    // 主动停止的 agent（Map: agentId → timestamp，防止 auto-restart 重新拉起）
+    this._stoppedAgents = new Map();
+
+    // 所有 worker 进程引用（包括已从 workers Map 删除的，供 exit 兜底清理）
+    this._allWorkers = new Map();
+  }
+
+  /** 断开某个 agent 的 WuKongIM 连接 */
+  disconnect(agentId) {
+    const conn = this.wukongimConnections.get(agentId);
+    if (conn) {
+      conn.sdk.disconnect();
+      this.wukongimConnections.delete(agentId);
+      console.log(`[${agentId}] WuKongIM 已断开`);
+    }
+    return { success: true };
+  }
+
+  /** 获取某个 agent 的连接状态 */
+  getStatus(agentId) {
+    const entry = this.workers.get(agentId);
+    if (!entry) return { connected: false, uid: null };
+    const status = this.connectionStatus.get(agentId);
+    const isConnected = status === 'connected';
+    return { connected: isConnected, uid: entry.config.uid, status: status || 'unknown' };
+  }
+
+  /** 某个 agent 是否已在运行 */
+  isRunning(agentId) {
+    return this.workers.has(agentId);
+  }
+
+  /** 获取 worker 条目 */
+  getWorker(agentId) {
+    return this.workers.get(agentId);
+  }
+
+  /** 第一个已连接的 agent */
+  getFirstAgentId() {
+    const firstEntry = this.workers.values().next().value;
+    return firstEntry?.config?.agentId || Array.from(this.workers.keys())[0] || null;
+  }
+
+  /**
+   * 启动 Agent Worker 进程
+   * @param {string} agentId
+   * @param {object} config - { uid, token, serverUrl }
+   * @param {object} [appPaths] - { isPackaged, resourcesPath, userDataPath }
+   */
+  start(agentId, config, appPaths) {
+    if (this.workers.has(agentId)) {
+      console.log(`[Agent Worker] ${agentId} 已经运行，跳过启动`);
+      return;
+    }
+    // 清除旧停止标记，允许启动
+    this._stoppedAgents.delete(agentId);
+
+    const workerPath = appPaths?.isPackaged
+      ? path.join(appPaths.resourcesPath, 'app.asar.unpacked', 'src', 'workers', 'agent-worker.js')
+      : path.join(__dirname, '..', 'workers', 'agent-worker.js');
+
+    let worker;
+    try {
+      const env = { ...process.env };
+      if (appPaths?.userDataPath) {
+        env.WORKER_LOG_PATH = path.join(appPaths.userDataPath, 'agent-worker.log');
+      }
+      worker = fork(workerPath, [agentId, JSON.stringify(config)], { env });
+    } catch (err) {
+      console.error(`[Agent Worker] ${agentId} fork 失败:`, err.message);
+      return;
+    }
+    this.workers.set(agentId, { worker, config });
+    this._allWorkers.set(agentId, { worker, config });
+
+    worker.on('message', (msg) => {
+      if (msg.type === 'message') {
+        // 收到消息 → 由外部处理（handleAgentMessage）
+        this.emit('message', msg);
+      } else if (msg.type === 'status') {
+        this.connectionStatus.set(msg.agentId, msg.status);
+        console.log(`[Agent Worker] ${agentId} 状态: ${msg.status}`);
+
+        if (msg.status === 'kicked' || msg.statusCode === 4) {
+          // 忽略旧 worker 被踢（新 worker 已顶上或 agent 已被主动停止）
+          const currentEntry = this.workers.get(msg.agentId);
+          if (!currentEntry || currentEntry.worker !== worker) {
+            console.log(`[Agent Worker] ${msg.agentId} 忽略旧 worker 踢回`);
+            return;
+          }
+          const cfg = currentEntry.config;
+          console.log(`[Agent Worker] ${msg.agentId} 被踢，8s 后重启 worker`);
+          setTimeout(() => {
+            this.stop(msg.agentId);
+            setTimeout(() => {
+              if (cfg) this.start(msg.agentId, cfg, appPaths);
+            }, 500);
+          }, 8000);
+          return;
+        }
+
+        if (msg.status === 'connected' || msg.statusCode === 2) {
+          this.connectedAgents.add(msg.agentId);
+          // 触发外部监听器（用于离线同步等）
+          this.emit('agent-connected', msg.agentId);
+        }
+
+        this.emit('status', msg);
+      } else if (msg.type === 'sent') {
+        this.emit('sent', msg);
+      }
+    });
+
+    worker.on('exit', (code) => {
+      // 3~8 秒随机延迟，避免多个 worker 同时重启造成踢号风暴
+      const delay = 3000 + Math.floor(Math.random() * 5000);
+      console.log(`[Agent Worker] ${agentId} 退出，code=${code}，${delay}ms 后重启`);
+      const entry = this.workers.get(agentId);
+      if (entry && entry.worker === worker) {
+        this.workers.delete(agentId);
+        this.connectionStatus.delete(agentId);
+      }
+      setTimeout(() => {
+        // 主动停止的 agent 不自动重启（停止时间在 10 秒内视为主动停止）
+        const stoppedAt = this._stoppedAgents.get(agentId);
+        if (stoppedAt && Date.now() - stoppedAt < 10000) {
+          this._stoppedAgents.delete(agentId);
+          return;
+        }
+        if (!this.workers.has(agentId)) {
+          console.log(`[Agent Worker] 重启 ${agentId}`);
+          this.start(agentId, config, appPaths);
+        }
+      }, delay);
+    });
+
+    worker.on('error', (err) => {
+      console.error(`[Agent Worker] ${agentId} 错误:`, err.message);
+    });
+
+    console.log(`[Agent Worker] 已启动 ${agentId}，UID=${config.uid}`);
+  }
+
+  /**
+   * 停止 Agent Worker 进程
+   * @returns {Promise<void>}
+   */
+  stop(agentId) {
+    return new Promise(resolve => {
+      const entry = this.workers.get(agentId);
+      if (!entry) {
+        console.log(`[Agent Worker] ${agentId} 未运行`);
+        return resolve();
+      }
+      this.workers.delete(agentId);
+      this.connectionStatus.delete(agentId);
+      this._stoppedAgents.set(agentId, Date.now());
+      console.log(`[Agent Worker] 正在停止 ${agentId}...`);
+
+      let resolved = false;
+      const timer = setTimeout(() => {
+        resolved = true;
+        try { entry.worker.kill('SIGKILL'); } catch (_) {}
+        console.log(`[Agent Worker] ${agentId} 超时强制终止`);
+        resolve();
+      }, 3000);
+
+      entry.worker.once('exit', () => {
+        if (!resolved) {
+          clearTimeout(timer);
+          console.log(`[Agent Worker] ${agentId} 已退出`);
+          resolve();
+        }
+      });
+
+      entry.worker.send({ type: 'disconnect' });
+    });
+  }
+
+  /** 停止所有 worker */
+  async stopAll() {
+    const ids = [...this.workers.keys()];
+    await Promise.all(ids.map(id => this.stop(id)));
+  }
+
+  /** 同步强杀所有 worker（用于进程退出时，不等回调） */
+  killAll() {
+    const ids = [...this.workers.keys()];
+    if (ids.length === 0) return;
+    // 先标记所有 agent 为主动停止，防止 auto-restart 重新拉起
+    for (const id of ids) {
+      this._stoppedAgents.set(id, Date.now());
+    }
+    for (const id of ids) {
+      const entry = this.workers.get(id);
+      if (!entry) continue;
+      try { entry.worker.send({ type: 'disconnect' }); } catch (e) { console.error(`[WorkerManager] killAll ${id} send 失败:`, e.message); }
+      try { entry.worker.kill('SIGKILL'); } catch (e) { console.error(`[WorkerManager] killAll ${id} kill 失败:`, e.message); }
+      this.workers.delete(id);
+      this.connectionStatus.delete(id);
+    }
+  }
+
+  /**
+   * 发送系统消息给访客
+   */
+  sendSystemMessage(agentId, visitorId, content, serverTimestamp) {
+    if (!agentId || !visitorId || !content) {
+      console.error('[sendSystemMessage] 参数不完整', { agentId, visitorId, content });
+      return;
+    }
+    const agentRow = this.db.prepare(`SELECT imUid FROM agents WHERE agent_id = ?`).get(agentId);
+    if (!agentRow) {
+      console.error(`[sendSystemMessage] 未找到 agent: ${agentId}`);
+      return;
+    }
+    const fromUid = agentRow.imUid;
+    const timestamp = serverTimestamp ? (serverTimestamp + 1) : Math.floor(Date.now() / 1000);
+    const msgId = `sys-${agentId}-${visitorId}-${timestamp}-${Math.random().toString(36).substr(2, 4)}`;
+
+    try {
+      this.db.prepare(`INSERT INTO messages (id, from_uid, to_uid, content, channel_id, channel_type, agent_id, timestamp, is_me, status, message_seq, client_msg_no, no_persist, red_dot, sync_once, content_type)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(msgId, fromUid, visitorId, content, visitorId, 1, agentId, timestamp, 2, 'sent', null, null, 0, 0, 0, 1);
+    } catch (e) {
+      console.error('[sendSystemMessage] messages 写入失败:', e.message);
+    }
+
+    try {
+      const existConv = this.db.prepare(`SELECT user_uid FROM conversations WHERE user_uid = ? AND channel_id = ?`).get(fromUid, visitorId);
+      if (existConv) {
+        this.db.prepare(`UPDATE conversations SET last_message = ?, last_timestamp = ? WHERE user_uid = ? AND channel_id = ?`)
+          .run(content, timestamp, fromUid, visitorId);
+      } else {
+        this.db.prepare(`INSERT INTO conversations (user_uid, channel_id, channel_type, name, last_message, last_timestamp, unread_count, agent_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+          .run(fromUid, visitorId, 1, visitorId, content, timestamp, 0, agentId);
+      }
+    } catch (e) {
+      console.error('[sendSystemMessage] 会话更新失败:', e.message);
+    }
+
+    const workerEntry = this.workers.get(agentId);
+    if (workerEntry) {
+      workerEntry.worker.send({ type: 'send', channelId: visitorId, content, localMsgId: msgId });
+    } else {
+      console.error(`[sendSystemMessage] 未找到 agent worker: ${agentId}`);
+    }
+
+    this.emit('system-message', { agentId, fromUid, visitorId, content, msgId, timestamp });
+  }
+
+  /**
+   * 清理孤儿 worker 进程（来自前一个 Lite/Desktop 会话的残留）
+   * 在启动新 worker 前调用，防止同 UID 互踢。
+   */
+  static killOrphanedWorkers() {
+    try {
+      if (process.platform === 'win32') {
+        // 用 tasklist 查所有 node.exe，再用 PowerShell 确认命令行含 agent-worker / packages/lite
+        let pids = [];
+        try {
+          const tasks = execSync('tasklist /fi "imagename eq node.exe" /fo csv /nh', { encoding: 'utf8', timeout: 5000, windowsHide: true });
+          const allPids = tasks.trim().split('\n')
+            .map(l => l.split('","')[1]?.replace(/"/g, '').trim())
+            .filter(p => p && !isNaN(p));
+          for (const pid of allPids) {
+            if (pid === String(process.pid)) continue;
+            try {
+              const cmd = execSync(
+                `powershell -Command "try { (Get-CimInstance Win32_Process -Filter \\\"ProcessId=${pid}\\\").CommandLine } catch { '' }"`,
+                { encoding: 'utf8', timeout: 3000, windowsHide: true }
+              ).trim();
+              if (cmd.includes('agent-worker') || cmd.includes('packages/lite')) {
+                pids.push(pid);
+              }
+            } catch (_) {}
+          }
+        } catch (e) {
+          console.error('[WorkerManager] tasklist 失败:', e.message);
+        }
+        // 找到的残留进程逐个强杀
+        for (const pid of pids) {
+          try { execSync(`taskkill /f /t /pid ${pid}`, { stdio: 'ignore', timeout: 3000, windowsHide: true }); }
+          catch (e) { console.error(`[WorkerManager] 清理 PID ${pid} 失败:`, e.message); }
+        }
+        if (pids.length > 0) console.log(`[WorkerManager] 清理了 ${pids.length} 个残留进程 (worker+Lite)`);
+        else console.log('[WorkerManager] 无残留进程需清理');
+      }
+    } catch (e) {
+      console.error('[WorkerManager] 扫描残留进程失败:', e.message);
+    }
+  }
+}
+
+module.exports = { AgentWorkerManager };

package/src/endpoints.json

@@ -0,0 +1,21 @@
+{
+  "api": {
+    "baseUrl": "http://www.vokovoko.com"
+  },
+  "oss": {
+    "region": "oss-cn-beijing",
+    "bucket": "vokofiles",
+    "endpoint": "https://vokofiles.oss-cn-beijing.aliyuncs.com",
+    "publicUrl": "http://files.vokovoko.com"
+  },
+  "update": {
+    "baseUrl": "http://files.vokovoko.com/updates"
+  },
+  "im": {
+    "baseUrl": "http://im.vokovoko.com",
+    "wsUrl": "ws://im.vokovoko.com:5200"
+  },
+  "payment": {
+    "baseUrl": "http://www.vokovoko.com/api/external/v1"
+  }
+}