wechat-opencode-bot 0.2.2 → 0.2.4

package/README.md

@@ -31,11 +31,16 @@ wechat-bot status    # 查看状态
 或使用自启动:
 
 ```bash
-wechat-bot install   # macOS 生成 launchd plist 并加载
+wechat-bot install   # macOS: 生成 launchd plist 到 ~/Library/LaunchAgents
+# 然后加载（一次性）：
+launchctl load ~/Library/LaunchAgents/com.opencode-wechat-bot.serve.plist
+launchctl load ~/Library/LaunchAgents/com.opencode-wechat-bot.bridge.plist
 ./bin/start.sh start # 或手动启动脚本（macOS/Linux）
 ./bin/start.bat start# Windows
 ```
 
+> 注：`install` 生成的 plist 含 `RunAtLoad` + `KeepAlive`，开机自启 + 崩溃自动重启。若 `opencode` 不在 PATH，`install` 会自动探测并把其目录加入 plist 的 PATH。
+
 ## 环境变量
 
 | 变量 | 默认值 | 说明 |
@@ -52,10 +57,13 @@ wechat-bot install   # macOS 生成 launchd plist 并加载
 ## 功能
 
 - **自动回复**：每用户独立 opencode session（会话历史持久化）。
+- **流式回复**：AI 边生成边分段推送到微信（块约 400 字，句号/换行处断句）。
+- **可靠发送**：校验微信业务返回码（`ret!=0` 自动指数退避重试），发送间隔 1s 避免高频触发微信限流。
 - **定时任务**：对 bot 说"每天早上9点提醒我喝水"，AI 输出 `[schedule: 09:00 | 提醒喝水]` 标记，bridge 解析存储，到点主动推送。
   - 时间表达式：`HH:MM`(每天) / `每N小时` / `每N分钟` / `YYYY-MM-DD HH:MM`(一次性)
   - 查看/删除：`[schedule_list]` / `[schedule_del: id]`
 - **图片/文件**：接收时下载到本地供 AI 读取（`[图片: 路径]`）；发送时用 `[media: /绝对/路径]` 标记上传。
+- **微信友好格式**：系统提示要求 AI 不用 ASCII 表格（box-drawing 字符），改纯文本列表，避免微信显示乱码。
 - **自动重连**：网络错误指数退避，session 过期自动提示重新登录。
 
 ## 权限配置

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wechat-opencode-bot",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "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: /绝对/路径] 标记，一行一个，其余内容按普通文本发送。
 定时任务指令（用户要求定时提醒/推送时使用）:
@@ -414,142 +413,20 @@ async function askOpenCodeStream(sessionId, text, onChunk) {
   // 确认 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);
+  return textParts.join('\n').trim();
 }
 
 // ─── 微信消息处理 ─────────────────────────────────────
@@ -682,17 +559,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,7 +567,7 @@ async function handleMessage(msg) {
 
   await sendTypingIndicator(fromUser, contextToken, 2);
 
-  // 流式已把文本发出，最后处理媒体与 schedule 标记
+  // 处理 schedule 标记，再发送媒体
   if (fullReply) {
     let textToSend = processScheduleMarks(fullReply, fromUser);
     try {
@@ -710,8 +577,18 @@ async function handleMessage(msg) {
     } catch (err) {
       log(`媒体处理失败: ${String(err)}`);
     }
+    // 一次性分段发送
     if (textToSend.trim()) {
-      log(`已回复(流式) from=${fromUser}`);
+      const plainText = stripMarkdown(textToSend);
+      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 {
+      log(`已回复(仅媒体) from=${fromUser}`);
     }
   }
 }