wechat-opencode-bot 0.1.0 → 0.2.1

package/README.md

@@ -41,11 +41,11 @@ wechat-bot install   # macOS 生成 launchd plist 并加载
 | 变量 | 默认值 | 说明 |
 |---|---|---|
 | `WECHAT_BOT_HOME` | `~/.wechat-bot` | 数据目录（sessions/tasks/media/logs/pids） |
-| `WECHAT_STATE_DIR` | `~/.claude/channels/wechat/<profile>` | cc-wechat 状态目录 |
-| `WECHAT_PROFILE` | `default` | cc-wechat 账号 profile |
+| `WECHAT_PROFILE` | `default` | cc-wechat 账号 profile，状态目录为 `~/.claude/channels/wechat/<profile>` |
 | `OPENCODE_SERVER_URL` | `http://127.0.0.1:4100` | opencode serve 地址 |
 | `OPENCODE_PORT` | `4100` | opencode serve 端口 |
-| `OPENCODE_BIN` | `opencode` | opencode 可执行文件 |
+| `OPENCODE_BIN` | 自动探测 | opencode 可执行文件路径 |
+| `OPENCODE_SERVER_PASSWORD` | 空 | 可选: opencode serve 鉴权密码（设置后 bridge 自动携带） |
 | `LLM_TIMEOUT_MS` | `300000` | LLM 响应超时 |
 | `BOT_PREFIX` | 空 | 仅响应带此前缀的消息 |
 
@@ -58,6 +58,27 @@ wechat-bot install   # macOS 生成 launchd plist 并加载
 - **图片/文件**：接收时下载到本地供 AI 读取（`[图片: 路径]`）；发送时用 `[media: /绝对/路径]` 标记上传。
 - **自动重连**：网络错误指数退避，session 过期自动提示重新登录。
 
+## 权限配置
+
+opencode serve 为无人值守环境。建议在 opencode 配置（`~/.config/opencode/opencode.json`）中设置权限，让工具自动执行而不触发权限确认（权限确认在无头环境会卡住会话）：
+
+```json
+{
+  "permission": {
+    "bash": { "*": "allow" },
+    "read": { "*": "allow" },
+    "write": { "*": "allow" },
+    "edit": { "*": "allow" },
+    "skill": { "*": "deny" },
+    "question": "allow",
+    "webfetch": "allow"
+  }
+}
+```
+
+- `bash`/`read` 等放行：微信里可直接让 AI 执行 `tea`、`git` 等命令并读取文件
+- `skill` 设为 `deny`：skill 工具在 serve 环境可能不触发事件结束（卡住会话），建议禁止
+
 ## 数据文件
 
 - `sessions.json`：微信用户 → opencode session 映射

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wechat-opencode-bot",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "微信 ⇄ opencode 桥接机器人：微信消息通过 opencode serve 驱动 AI 回复，支持定时任务主动推送、媒体收发，跨平台（macOS/Windows/Linux）。",
   "type": "module",
   "bin": {

package/src/bridge.js

@@ -12,7 +12,6 @@ import { join } from 'node:path';
 import { readFileSync, writeFileSync, existsSync } from 'node:fs';
 import {
   findCcWechatDir,
-  STATE_DIR,
   SESSION_MAP_FILE,
   MEDIA_DIR,
   TASKS_FILE,
@@ -54,8 +53,23 @@ let pollingAbort = null;
 const sessionMap = loadSessionMap();
 const typingTicketCache = new Map();
 const processedIds = new Set();
+const userQueues = new Map(); // userId -> Promise 链，同用户串行、不同用户并发
 let account = null;
 
+/** 将消息处理任务按用户排队：同一用户串行，不同用户并发 */
+function enqueueHandle(msg) {
+  const fromUser = msg.from_user_id ?? '';
+  const prev = userQueues.get(fromUser) || Promise.resolve();
+  const next = prev
+    .then(() => handleMessage(msg))
+    .catch((err) => log(`处理消息失败 from=${fromUser}: ${String(err)}`))
+    .finally(() => {
+      if (userQueues.get(fromUser) === next) userQueues.delete(fromUser);
+    });
+  userQueues.set(fromUser, next);
+  return next;
+}
+
 function loadSessionMap() {
   try {
     if (existsSync(SESSION_MAP_FILE)) {
@@ -204,17 +218,18 @@ async function fireTask(task) {
   const prompt = `【定时任务触发】${task.prompt}\n请据此生成一条发给用户的微信消息。`;
   let reply = '';
   try {
-    reply = await askOpenCode(sessionId, prompt);
+    reply = await askOpenCodeStream(sessionId, prompt, async (chunk) => {
+      const plainText = stripMarkdown(chunk);
+      if (!plainText.trim()) return;
+      for (const c of chunkText(plainText, 3900)) {
+        await sendMessage(account.token, task.userId, c, '', account.baseUrl, undefined);
+      }
+    });
   } catch (err) {
     reply = `[定时任务执行失败: ${String(err.message ?? err)}]`;
   }
   if (reply) {
-    const plainText = stripMarkdown(reply);
-    const chunks = chunkText(plainText, 3900);
-    for (const chunk of chunks) {
-      await sendMessage(account.token, task.userId, chunk, '', account.baseUrl, undefined);
-    }
-    log(`定时任务已推送 ${task.id} chunks=${chunks.length}`);
+    log(`定时任务已推送 ${task.id}`);
   }
   // 一次性任务执行后移除
   if (task.parsed.type === 'once') {
@@ -280,6 +295,16 @@ function sleep(ms, signal) {
 }
 
 // ─── opencode serve 调用 ─────────────────────────────
+// 可选鉴权：与 cli.js startServe 的 OPENCODE_SERVER_PASSWORD 配合
+const SERVER_PASSWORD = process.env.OPENCODE_SERVER_PASSWORD || '';
+const authHeader = SERVER_PASSWORD
+  ? { Authorization: `Basic ${Buffer.from(`opencode:${SERVER_PASSWORD}`).toString('base64')}` }
+  : {};
+
+function buildHeaders(extra = {}) {
+  return { 'Content-Type': 'application/json', ...authHeader, ...extra };
+}
+
 async function api(path, options = {}, timeoutMs = 30_000) {
   const ctrl = new AbortController();
   const t = setTimeout(() => ctrl.abort(), timeoutMs);
@@ -287,7 +312,7 @@ async function api(path, options = {}, timeoutMs = 30_000) {
     const resp = await fetch(`${SERVER_BASE}${path}`, {
       ...options,
       signal: ctrl.signal,
-      headers: { 'Content-Type': 'application/json', ...(options.headers || {}) },
+      headers: buildHeaders(options.headers || {}),
     });
     const text = await resp.text();
     if (!resp.ok) {
@@ -319,28 +344,160 @@ async function getSessionForUser(userId) {
   return session.id;
 }
 
-/** 向 opencode session 发送消息并等待完整回复文本 */
-async function askOpenCode(sessionId, text) {
-  const SYSTEM_HINT = `你是微信自动回复助手。收到 [图片: 路径] 或 [文件: 路径] 标记时，可用 read 工具读取内容。
+/**
+ * 向 opencode session 异步发送消息，通过 SSE 事件流实时获取回复。
+ * 流式累积文本，按边界分块回调 onChunk（用于实时推送到微信），
+ * 返回完整回复文本（供媒体标记/schedule 处理）。
+ */
+async function askOpenCodeStream(sessionId, text, onChunk) {
+  const SYSTEM_HINT = `你是微信自动回复助手，收到 [图片: 路径] 或 [文件: 路径] 标记时，可用 read 工具读取内容。
 如需在回复中发送媒体文件（本地绝对路径），在回复文本中用 [media: /绝对/路径] 标记，一行一个，其余内容按普通文本发送。
 定时任务指令（用户要求定时提醒/推送时使用）:
   [schedule: 时间表达式 | 任务提示]   添加定时任务。时间表达式支持: HH:MM(每天) / 每N小时 / 每N分钟 / YYYY-MM-DD HH:MM(一次性)
   [schedule_list]                     查看当前定时任务
   [schedule_del: 任务ID]              删除指定定时任务
-到点后系统会调用你生成内容并主动推送给用户。`;
-  const resp = await api(
-    `/session/${sessionId}/message`,
+到点后系统会调用你生成内容并主动推送给用户。
+回复要求: 请给出完整、详细、原样的回答，把你在命令行中会输出的全部内容直接发过来，不要缩略、不要只给总结或要点提示，确保用户看到完整答案。如果执行了代码或命令，把关键输出也一并附上。`;
+
+  // 确认 session 存在
+  await api(`/session/${sessionId}`, {}, 5000);
+
+  // 1. 建立 SSE 事件流
+  const ctrl = new AbortController();
+  const eventFetch = fetch(`${SERVER_BASE}/event`, { signal: ctrl.signal, headers: buildHeaders() });
+  // 2. 异步发送消息（204 立即返回）
+  await api(
+    `/session/${sessionId}/prompt_async`,
     {
       method: 'POST',
       body: JSON.stringify({ parts: [{ type: 'text', text: `${SYSTEM_HINT}\n\n微信消息:\n${text}` }] }),
     },
-    MAX_LLM_RESPONSE_TIME_MS,
+    10_000,
   );
-  const parts = resp?.parts || [];
-  const textParts = parts
-    .filter((p) => p.type === 'text' && typeof p.text === 'string')
-    .map((p) => p.text);
-  return textParts.join('\n').trim();
+
+  let accumulated = '';
+  let streamingBuffer = '';
+  let done = false;
+  const reasoningPartIDs = new Set();
+
+  const resp = await eventFetch;
+  if (!resp.ok || !resp.body) {
+    throw new Error(`SSE 连接失败: HTTP ${resp.status}`);
+  }
+  const reader = resp.body.getReader();
+  const decoder = new TextDecoder();
+  let buf = '';
+
+  let sendChain = Promise.resolve();
+  const flushBuffer = () => {
+    if (!streamingBuffer.trim()) return sendChain;
+    const chunk = streamingBuffer.trim();
+    streamingBuffer = '';
+    accumulated += chunk;
+    if (onChunk) {
+      // 串行发送队列，保证 onChunk 顺序执行（避免并发乱序）
+      sendChain = sendChain.then(() => onChunk(chunk));
+    }
+    return sendChain;
+  };
+
+  const timeout = setTimeout(async () => {
+    if (!done) {
+      log(`流式超时(${MAX_LLM_RESPONSE_TIME_MS / 1000}s)，abort session ${sessionId}`);
+      try {
+        await api(`/session/${sessionId}/abort`, { method: 'POST', body: '{}' }, 5000);
+      } catch {}
+      ctrl.abort();
+      done = true;
+    }
+  }, MAX_LLM_RESPONSE_TIME_MS);
+
+  // 兜底检测：SSE 可能漏发 idle 事件（工具执行后），定期轮询 session 状态判断是否真正结束；
+  // 长时间无任何新 part 则视为卡死，abort session 避免永久 busy
+  let lastProgress = Date.now();
+  const stallTimer = setInterval(async () => {
+    if (done) return;
+    // 兜底：SSE 漏发 idle 时，主动查 session 状态结束循环
+    try {
+      const status = await api(`/session/status`, {}, 5000);
+      const entry = status?.[sessionId];
+      const st = typeof entry?.type === 'string' ? entry.type : entry?.status?.type;
+      if (st === 'idle') {
+        log(`SSE 未收到 idle，经轮询确认 session 已空闲`);
+        done = true;
+        return;
+      }
+    } catch {}
+    if (Date.now() - lastProgress > 90_000) {
+      log(`流式无进度超时(90s)，abort session ${sessionId}`);
+      try {
+        await api(`/session/${sessionId}/abort`, { method: 'POST', body: '{}' }, 5000);
+      } catch {}
+      ctrl.abort();
+      done = true;
+    }
+  }, 10_000);
+
+  try {
+    while (!done) {
+      const { done: streamDone, value } = await reader.read();
+      if (streamDone) break;
+      buf += decoder.decode(value, { stream: true });
+      const lines = buf.split('\n');
+      buf = lines.pop();
+      for (const line of lines) {
+        if (!line.startsWith('data:')) continue;
+        const raw = line.slice(5).trim();
+        if (!raw) continue;
+        let evt;
+        try {
+          evt = JSON.parse(raw);
+        } catch {
+          continue;
+        }
+        const p = evt.properties ?? {};
+        if (p.sessionID && p.sessionID !== sessionId) continue;
+        switch (evt.type) {
+          case 'message.part.delta': {
+            if (p.field === 'text' && typeof p.delta === 'string') {
+              if (p.partID && reasoningPartIDs.has(p.partID)) break;
+              lastProgress = Date.now();
+              streamingBuffer += p.delta;
+              // 达到块大小或句子边界即推送
+              if (
+                streamingBuffer.length >= 60 ||
+                /[。！？\n]/.test(streamingBuffer.slice(-2))
+              ) {
+                await flushBuffer();
+              }
+            }
+            break;
+          }
+          case 'message.part.updated': {
+            const part = p.part ?? {};
+            if (part.type === 'reasoning' && part.id) {
+              reasoningPartIDs.add(part.id);
+            }
+            lastProgress = Date.now(); // 任何 part 更新都算进度
+            break;
+          }
+          case 'session.status': {
+            const st = p.status ?? {};
+            if (st.type === 'idle') done = true;
+            break;
+          }
+          default:
+            break;
+        }
+      }
+    }
+  } finally {
+    clearTimeout(timeout);
+    clearInterval(stallTimer);
+    ctrl.abort();
+  }
+  await flushBuffer();
+  return accumulated.trim();
 }
 
 // ─── 微信消息处理 ─────────────────────────────────────
@@ -471,20 +628,31 @@ async function handleMessage(msg) {
     return;
   }
 
-  let reply = '';
+  let fullReply = '';
   try {
-    reply = await askOpenCode(sessionId, text);
+    fullReply = await askOpenCodeStream(sessionId, text, async (chunk) => {
+      // 实时推送：边生成边发
+      const plainText = stripMarkdown(chunk);
+      if (!plainText.trim()) return;
+      const chunks = chunkText(plainText, 3900);
+      for (const c of chunks) {
+        try {
+          await sendMessage(account.token, fromUser, c, contextToken, account.baseUrl, messageId);
+        } catch (err) {
+          log(`发送失败: ${String(err)}`);
+        }
+      }
+    });
   } catch (err) {
     log(`调用 opencode 失败: ${String(err)}`);
-    reply = `[处理失败: ${String(err.message ?? err)}]`;
+    fullReply = `[处理失败: ${String(err.message ?? err)}]`;
   }
 
   await sendTypingIndicator(fromUser, contextToken, 2);
 
-  if (reply) {
-    // 处理定时任务标记（schedule_*）
-    let textToSend = processScheduleMarks(reply, fromUser);
-    // 再发送媒体标记
+  // 流式已把文本发出，最后处理媒体与 schedule 标记
+  if (fullReply) {
+    let textToSend = processScheduleMarks(fullReply, fromUser);
     try {
       const { text, mediaSent } = await sendMediaMarks(fromUser, contextToken, textToSend);
       textToSend = text;
@@ -492,19 +660,8 @@ async function handleMessage(msg) {
     } catch (err) {
       log(`媒体处理失败: ${String(err)}`);
     }
-    if (textToSend) {
-      const plainText = stripMarkdown(textToSend);
-      const chunks = chunkText(plainText, 3900);
-      for (const chunk of chunks) {
-        try {
-          await sendMessage(account.token, fromUser, chunk, contextToken, account.baseUrl, messageId);
-        } catch (err) {
-          log(`发送失败: ${String(err)}`);
-        }
-      }
-      log(`已回复 from=${fromUser} chunks=${chunks.length}`);
-    } else {
-      log(`已回复(仅媒体) from=${fromUser}`);
+    if (textToSend.trim()) {
+      log(`已回复(流式) from=${fromUser}`);
     }
   }
 }
@@ -553,11 +710,8 @@ async function pollLoop() {
         saveSyncBuf(buf);
       }
       for (const msg of resp.msgs ?? []) {
-        try {
-          await handleMessage(msg);
-        } catch (err) {
-          log(`处理消息失败: ${String(err)}`);
-        }
+        // 按用户排队并发处理：不同用户并行，同用户串行，避免单条阻塞全部轮询
+        enqueueHandle(msg);
       }
     } catch (err) {
       if (pollingAbort?.signal.aborted) return;
@@ -593,7 +747,7 @@ function stopPolling() {
 }
 
 // ─── 主入口 ───────────────────────────────────────────
-export async function startBridge() {
+async function startBridge() {
   account = getActiveAccount();
   if (!account) {
     log('未找到账号。请先登录: npx cc-wechat login');
@@ -640,6 +794,7 @@ export async function startBridge() {
 }
 
 export {
+  startBridge,
   parseScheduleExpr,
   addTask,
   deleteTask,

package/src/cli.js

@@ -10,10 +10,11 @@
  *   wechat-bot install          安装自启服务（macOS: launchd；Windows: 计划任务）
  *   wechat-bot uninstall        卸载自启服务
  */
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
-import { join } from 'node:path';
+import { join, dirname } from 'node:path';
+import { homedir } from 'node:os';
 import {
   SERVER_BASE,
   SERVE_PORT,
@@ -25,6 +26,37 @@ import {
 
 const isWin = process.platform === 'win32';
 
+/** 探测 opencode 可执行文件真实路径（launchd/计划任务环境 PATH 可能不含它） */
+function resolveOpenCodeBin() {
+  const fromEnv = process.env.OPENCODE_BIN;
+  if (fromEnv) return fromEnv;
+  if (!isWin) {
+    const which = spawnSync('which', ['opencode'], { encoding: 'utf-8' });
+    if (which.status === 0 && which.stdout.trim()) return which.stdout.trim();
+    // 常见安装位置
+    const candidates = [
+      join(homedir(), '.local', 'bin', 'opencode'),
+      join(homedir(), '.opencode', 'bin', 'opencode'),
+      '/usr/local/bin/opencode',
+      '/opt/homebrew/bin/opencode',
+    ];
+    for (const c of candidates) {
+      if (existsSync(c)) return c;
+    }
+  } else {
+    const where = spawnSync('where', ['opencode'], { encoding: 'utf-8' });
+    if (where.status === 0 && where.stdout.trim()) return where.stdout.trim().split('\n')[0];
+    const winCandidates = [
+      join(process.env.USERPROFILE || homedir(), '.local', 'bin', 'opencode.exe'),
+      join(process.env.USERPROFILE || homedir(), 'AppData', 'Roaming', 'npm', 'opencode.cmd'),
+    ];
+    for (const c of winCandidates) {
+      if (existsSync(c)) return c;
+    }
+  }
+  return null;
+}
+
 function usage() {
   console.log(`opencode-wechat-bot
 用法:
@@ -37,10 +69,11 @@ function usage() {
 
 环境变量:
   WECHAT_BOT_HOME     数据目录（默认 ~/.wechat-bot）
-  WECHAT_STATE_DIR    cc-wechat 状态目录（默认 ~/.claude/channels/wechat/<profile>）
-  WECHAT_PROFILE      cc-wechat 账号 profile（默认 default）
+  WECHAT_PROFILE      cc-wechat 账号 profile（默认 default），状态目录为 ~/.claude/channels/wechat/<profile>
   OPENCODE_SERVER_URL opencode serve 地址（默认 http://127.0.0.1:4100）
   OPENCODE_PORT       opencode serve 端口（默认 4100）
+  OPENCODE_BIN        opencode 可执行文件路径（默认自动探测）
+  OPENCODE_SERVER_PASSWORD 可选: opencode serve 鉴权密码（设置后 bridge 自动携带）
   LLM_TIMEOUT_MS      LLM 响应超时（默认 300000）
   BOT_PREFIX          可选: 仅响应带此前缀的消息
 `);
@@ -48,9 +81,13 @@ function usage() {
 
 async function startServe() {
   ensureDirs();
-  const opencodeBin = process.env.OPENCODE_BIN || 'opencode';
+  const opencodeBin = resolveOpenCodeBin();
+  if (!opencodeBin) {
+    console.error('[serve] 找不到 opencode。请安装或在 OPENCODE_BIN 指定可执行文件路径');
+    process.exit(1);
+  }
   const args = ['serve', '--port', String(SERVE_PORT)];
-  // 禁用 wechat MCP，避免与 bridge 抢轮询
+  // 禁用 wechat MCP，避免与 bridge 抢轮询；可选鉴权
   const env = {
     ...process.env,
     OPENCODE_CONFIG_CONTENT: '{"mcp":{"wechat":{"enabled":false}}}',
@@ -147,7 +184,13 @@ async function installService() {
       ['serve'],
       {
         OPENCODE_CONFIG_CONTENT: '{"mcp":{"wechat":{"enabled":false}}}',
-        PATH: process.env.PATH || '',
+        PATH: [
+          dirname(resolveOpenCodeBin() || ''),
+          process.env.PATH || '',
+          '/usr/local/bin',
+          '/opt/homebrew/bin',
+          join(homedir(), '.local', 'bin'),
+        ].filter(Boolean).join(':'),
       },
     ),
     bridge: makePlist(
@@ -155,7 +198,13 @@ async function installService() {
       ['bridge'],
       {
         WECHAT_BOT_HOME: BOT_HOME,
-        PATH: process.env.PATH || '',
+        PATH: [
+          dirname(resolveOpenCodeBin() || ''),
+          process.env.PATH || '',
+          '/usr/local/bin',
+          '/opt/homebrew/bin',
+          join(homedir(), '.local', 'bin'),
+        ].filter(Boolean).join(':'),
       },
     ),
   };

package/src/paths.js

@@ -3,8 +3,8 @@
  *
  * 约定:
  *  - WECHAT_BOT_HOME   桥接自身数据目录（sessions/tasks/media/logs/pids），默认 ~/.wechat-bot
- *  - WECHAT_STATE_DIR  cc-wechat 状态目录（account.json/sync-buf），默认 ~/.claude/channels/wechat/<profile>
- *  - WECHAT_PROFILE    cc-wechat 账号 profile（默认 'default'），与 cc-wechat store.js 保持一致
+ *  - WECHAT_PROFILE    cc-wechat 账号 profile（默认 'default'），状态目录固定为
+ *                      ~/.claude/channels/wechat/<profile>（由 cc-wechat 内部决定）
  *  - OPENCODE_SERVER_URL / OPENCODE_PORT  opencode serve 地址（默认 http://127.0.0.1:4100）
  */
 import { homedir } from 'node:os';
@@ -16,9 +16,6 @@ const require = createRequire(import.meta.url);
 
 const home = homedir();
 const BOT_HOME = process.env.WECHAT_BOT_HOME || join(home, '.wechat-bot');
-const STATE_DIR =
-  process.env.WECHAT_STATE_DIR ||
-  join(home, '.claude', 'channels', 'wechat', process.env.WECHAT_PROFILE || 'default');
 const MEDIA_DIR = join(BOT_HOME, 'media');
 const SESSION_MAP_FILE = join(BOT_HOME, 'sessions.json');
 const TASKS_FILE = join(BOT_HOME, 'tasks.json');
@@ -75,7 +72,6 @@ function ensureDirs() {
 export {
   home,
   BOT_HOME,
-  STATE_DIR,
   MEDIA_DIR,
   SESSION_MAP_FILE,
   TASKS_FILE,