wechat-opencode-bot 0.2.3 → 0.2.5

package/README.md

@@ -87,6 +87,12 @@ opencode serve 为无人值守环境。建议在 opencode 配置（`~/.config/op
 - `bash`/`read` 等放行：微信里可直接让 AI 执行 `tea`、`git` 等命令并读取文件
 - `skill` 设为 `deny`：skill 工具在 serve 环境可能不触发事件结束（卡住会话），建议禁止
 
+### PATH 注意事项
+
+serve 由 launchd / 计划任务启动时，PATH 常缺少 `/opt/homebrew/bin`（macOS）或 WinGet 目录（Windows），会导致 AI 执行 `which ffmpeg`、`tea` 等找不到工具而误判"未安装"。
+
+本工具的 `wechat-bot install` 生成的 plist 已自动补全这些路径（`buildPath()`）；`wechat-bot serve` 也会把补全后的 PATH 传给 opencode serve。若你手动用 launchd 跑 `opencode serve`，请自行在 plist 的 `EnvironmentVariables.PATH` 加入 `/opt/homebrew/bin` 等目录。
+
 ## 数据文件
 
 - `sessions.json`：微信用户 → opencode session 映射

package/package.json

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

package/src/bridge.js

@@ -218,19 +218,19 @@ async function fireTask(task) {
   const prompt = `【定时任务触发】${task.prompt}\n请据此生成一条发给用户的微信消息。`;
   let reply = '';
   try {
-    reply = await askOpenCodeStream(sessionId, prompt, async (chunk) => {
-      const plainText = stripMarkdown(chunk);
-      if (!plainText.trim()) return;
-      for (const c of chunkText(plainText, 3900)) {
-        await sendWechat(task.userId, c, '', undefined);
-        await sleep(1000);
-      }
-    });
+    reply = await askOpenCode(sessionId, prompt);
   } catch (err) {
     reply = `[定时任务执行失败: ${String(err.message ?? err)}]`;
   }
   if (reply) {
-    log(`定时任务已推送 ${task.id}`);
+    // 一次性分段发送
+    const plainText = stripMarkdown(reply);
+    const chunks = chunkText(plainText, 3900);
+    for (const c of chunks) {
+      await sendWechat(task.userId, c, '', undefined);
+      await sleep(1000);
+    }
+    log(`定时任务已推送 ${task.id} chunks=${chunks.length}`);
   }
   // 一次性任务执行后移除
   if (task.parsed.type === 'once') {
@@ -396,11 +396,10 @@ async function getSessionForUser(userId) {
 }
 
 /**
- * 向 opencode session 异步发送消息，通过 SSE 事件流实时获取回复。
- * 流式累积文本，按边界分块回调 onChunk（用于实时推送到微信），
- * 返回完整回复文本（供媒体标记/schedule 处理）。
+ * 向 opencode session 发送消息并等待完整回复（同步接口）。
+ * 返回完整回复文本，供媒体标记/schedule 处理后统一发送。
  */
-async function askOpenCodeStream(sessionId, text, onChunk) {
+async function askOpenCode(sessionId, text) {
   const SYSTEM_HINT = `你是微信自动回复助手，收到 [图片: 路径] 或 [文件: 路径] 标记时，可用 read 工具读取内容。
 如需在回复中发送媒体文件（本地绝对路径），在回复文本中用 [media: /绝对/路径] 标记，一行一个，其余内容按普通文本发送。
 定时任务指令（用户要求定时提醒/推送时使用）:
@@ -409,147 +408,36 @@ async function askOpenCodeStream(sessionId, text, onChunk) {
   [schedule_del: 任务ID]              删除指定定时任务
 到点后系统会调用你生成内容并主动推送给用户。
 回复要求: 请给出完整、详细、原样的回答，把你在命令行中会输出的全部内容直接发过来，不要缩略、不要只给总结或要点提示，确保用户看到完整答案。如果执行了代码或命令，把关键输出也一并附上。
-微信格式: 不要使用 ASCII 艺术表格（┌─┬─┐ box-drawing 字符），微信会显示错乱。表格/列表改用纯文本（如 "编号 - 标题 (状态)"、"- 项目"、用缩进和符号组织），代码块用围栏标记即可。`;
+微信格式: 不要使用 ASCII 艺术表格（┌─┬─┐ box-drawing 字符），微信会显示错乱。表格/列表改用纯文本（如 "编号 - 标题 (状态)"、"- 项目"、用缩进和符号组织），代码块用围栏标记即可。
+截图能力: 用户要求"截图/截屏"网页时，用 headless Chrome 截取 URL 并保存 PNG，再用 [media:] 标记发出：
+  /Applications/Google Chrome.app/Contents/MacOS/Google Chrome --headless --disable-gpu --screenshot=/tmp/wechat-shot.png --window-size=1280,800 "目标URL"
+  截图后回复 [media: /tmp/wechat-shot.png]。URL 若需登录可提示用户；若截图失败把错误告诉用户。`;
 
   // 确认 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`,
+  // 同步发送并等待完整回复
+  const resp = await api(
+    `/session/${sessionId}/message`,
     {
       method: 'POST',
       body: JSON.stringify({ parts: [{ type: 'text', text: `${SYSTEM_HINT}\n\n微信消息:\n${text}` }] }),
     },
-    10_000,
+    MAX_LLM_RESPONSE_TIME_MS,
   );
-
-  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;
-              // 达到块大小或句子边界即推送（块放大到 400，避免高频小消息被微信限流吞掉）
-              if (
-                streamingBuffer.length >= 400 ||
-                (/[。！？\n]/.test(streamingBuffer.slice(-2)) && streamingBuffer.length >= 40)
-              ) {
-                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();
+  const parts = resp?.parts || [];
+  const textParts = parts
+    .filter((p) => p.type === 'text' && typeof p.text === 'string')
+    .map((p) => p.text);
+  const answer = textParts.join('\n').trim();
+  if (answer) return answer;
+  // 回退：模型有时把结论只写在 reasoning 里，text 为空，此时用 reasoning 兜底
+  const reasoning = parts
+    .filter((p) => p.type === 'reasoning' && typeof p.text === 'string')
+    .map((p) => p.text)
+    .join('\n')
+    .trim();
+  return reasoning;
 }
 
 // ─── 微信消息处理 ─────────────────────────────────────
@@ -682,17 +570,7 @@ async function handleMessage(msg) {
 
   let fullReply = '';
   try {
-    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) {
-        const ok = await sendWechat(fromUser, c, contextToken, messageId);
-        if (ok) log(`流式已发送 from=${fromUser} len=${c.length}`);
-        await sleep(1000); // 发送间隔，避免高频触发微信限流
-      }
-    });
+    fullReply = await askOpenCode(sessionId, text);
   } catch (err) {
     log(`调用 opencode 失败: ${String(err)}`);
     fullReply = `[处理失败: ${String(err.message ?? err)}]`;
@@ -700,19 +578,39 @@ async function handleMessage(msg) {
 
   await sendTypingIndicator(fromUser, contextToken, 2);
 
-  // 流式已把文本发出，最后处理媒体与 schedule 标记
+  // 处理 schedule 标记，再发送媒体
   if (fullReply) {
     let textToSend = processScheduleMarks(fullReply, fromUser);
+    let mediaSent = 0;
     try {
-      const { text, mediaSent } = await sendMediaMarks(fromUser, contextToken, textToSend);
-      textToSend = text;
+      const r = await sendMediaMarks(fromUser, contextToken, textToSend);
+      textToSend = r.text;
+      mediaSent = r.mediaSent;
       if (mediaSent > 0) log(`已发送 ${mediaSent} 个媒体文件 from=${fromUser}`);
     } catch (err) {
       log(`媒体处理失败: ${String(err)}`);
     }
-    if (textToSend.trim()) {
-      log(`已回复(流式) from=${fromUser}`);
+    // 一次性分段发送
+    const plainText = textToSend.trim() ? stripMarkdown(textToSend) : '';
+    if (plainText) {
+      const chunks = chunkText(plainText, 3900);
+      for (const c of chunks) {
+        const ok = await sendWechat(fromUser, c, contextToken, messageId);
+        if (ok) log(`已发送 from=${fromUser} len=${c.length}`);
+        await sleep(1000); // 发送间隔，避免高频触发微信限流
+      }
+      log(`已回复 from=${fromUser} chunks=${chunks.length}`);
+    } else if (mediaSent > 0) {
+      log(`已回复(仅媒体) from=${fromUser}`);
+    } else {
+      // AI 既无文本也无媒体，发提示避免静默无响应
+      await sendWechat(fromUser, '（我这边没有生成有效回复，请再试一次或换个说法）', contextToken, messageId);
+      log(`已回复(空回复兜底) from=${fromUser}`);
     }
+  } else {
+    // 完全空回复（模型只思考未产出文本）
+    await sendWechat(fromUser, '（我这边没有生成有效回复，请再试一次或换个说法）', contextToken, messageId);
+    log(`已回复(空回复兜底) from=${fromUser}`);
   }
 }
 

package/src/cli.js

@@ -13,7 +13,7 @@
 import { spawn, spawnSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
-import { join, dirname } from 'node:path';
+import { join } from 'node:path';
 import { homedir } from 'node:os';
 import {
   SERVER_BASE,
@@ -57,6 +57,20 @@ function resolveOpenCodeBin() {
   return null;
 }
 
+/**
+ * 补全 PATH：launchd/计划任务环境下 PATH 常缺 homebrew 等目录，
+ * 会导致 AI 在 serve 里执行 `which ffmpeg` 等找不到工具。
+ * 把常见工具目录加入 PATH 最前面。
+ */
+function buildPath() {
+  const sep = isWin ? ';' : ':';
+  const extra = isWin
+    ? [join(homedir(), 'AppData', 'Local', 'Microsoft', 'WinGet', 'Links')]
+    : ['/opt/homebrew/bin', '/usr/local/bin', join(homedir(), '.local', 'bin')];
+  const cur = (process.env.PATH || '').split(sep);
+  return [...new Set([...extra, ...cur])].filter(Boolean).join(sep);
+}
+
 function usage() {
   console.log(`opencode-wechat-bot
 用法:
@@ -90,6 +104,7 @@ async function startServe() {
   // 禁用 wechat MCP，避免与 bridge 抢轮询；可选鉴权
   const env = {
     ...process.env,
+    PATH: buildPath(),
     OPENCODE_CONFIG_CONTENT: '{"mcp":{"wechat":{"enabled":false}}}',
   };
   console.log(`[serve] 启动 ${opencodeBin} ${args.join(' ')}`);
@@ -184,13 +199,7 @@ async function installService() {
       ['serve'],
       {
         OPENCODE_CONFIG_CONTENT: '{"mcp":{"wechat":{"enabled":false}}}',
-        PATH: [
-          dirname(resolveOpenCodeBin() || ''),
-          process.env.PATH || '',
-          '/usr/local/bin',
-          '/opt/homebrew/bin',
-          join(homedir(), '.local', 'bin'),
-        ].filter(Boolean).join(':'),
+        PATH: buildPath(),
       },
     ),
     bridge: makePlist(
@@ -198,13 +207,7 @@ async function installService() {
       ['bridge'],
       {
         WECHAT_BOT_HOME: BOT_HOME,
-        PATH: [
-          dirname(resolveOpenCodeBin() || ''),
-          process.env.PATH || '',
-          '/usr/local/bin',
-          '/opt/homebrew/bin',
-          join(homedir(), '.local', 'bin'),
-        ].filter(Boolean).join(':'),
+        PATH: buildPath(),
       },
     ),
   };