@raolin2025/claude-code-node 2.7.6 → 2.7.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raolin2025/claude-code-node",
-  "version": "2.7.6",
+  "version": "2.7.8",
   "description": "Node.js AI Code Agent CLI - Zero dependencies, pure JavaScript, security hardened, multi-channel notifications, Telegram & QQ Bot remote programming, rich media upload, multi-account management",
   "type": "module",
   "main": "src/core/index.js",

package/src/__tests__/tg-listener-flush.test.js

@@ -0,0 +1,92 @@
+import { test } from 'node:test'
+import assert from 'node:assert'
+import { TelegramListener } from '../channel/tg-listener.js'
+
+const tick = (ms = 10) => new Promise((r) => setTimeout(r, ms))
+
+/**
+ * 构造一个用 mock _fetch 的 TelegramListener，用于验证 flushOffset 的排他锁逻辑。
+ * 为避免 _poll 无限循环导致测试进程无法退出，测试通过直接设置挂起状态来驱动。
+ */
+function makeListener() {
+  const listener = new TelegramListener({ channels: { telegram: { token: 'test-token' } } })
+  listener._loadOffset = () => 0
+  listener._saveOffset = () => {}
+
+  const calls = []
+  // 模拟一个可被 abort 的挂起请求（等价于 _poll 正在长轮询挂起）
+  listener._fetch = async (url, options = {}) => {
+    const body = JSON.parse(options.body || '{}')
+    calls.push({ tgTimeout: body.timeout, httpTimeout: options.timeout })
+
+    // Telegram 长轮询 = body.timeout > 0（如 _poll 传 30）；flushOffset 传 0 立即返回。
+    if ((body.timeout || 0) > 0) {
+      return new Promise((resolve, reject) => {
+        if (options.signal) {
+          options.signal.addEventListener('abort', () => {
+            const e = new Error('aborted')
+            e.name = 'AbortError'
+            reject(e)
+          }, { once: true })
+        }
+      })
+    }
+    return { ok: true, json: async () => ({ ok: true, result: [] }) }
+  }
+
+  return { listener, calls }
+}
+
+test('flushOffset 会取消挂起的 _poll 长轮询并独占连接（消除 409 竞态）', async () => {
+  const { listener, calls } = makeListener()
+
+  // 模拟 _poll 正处于长轮询挂起：设置 _polling 与一个可 abort 的 AbortController
+  const pollAbort = new AbortController()
+  listener._polling = true
+  listener._pollAbort = pollAbort
+  // 让 mock 的挂起请求真正绑定到该 signal（模拟 _poll 正在 await 它）
+  const pendingReq = listener._fetch(`${listener.bot.apiBase}/getUpdates`, {
+    method: 'POST', headers: {}, timeout: 60000, signal: pollAbort.signal,
+    body: JSON.stringify({ offset: 1, timeout: 30 }),
+  })
+  // 预先消费可能的拒绝（flush 会 abort 它），避免 unhandled rejection 被记为测试失败
+  const pendingReqSettled = pendingReq.catch(() => {})
+
+  // 调用 flushOffset（模拟 /quit 前的确认消费）
+  const flushPromise = listener.flushOffset()
+  await tick(20)
+
+  // flush 应立即 abort 掉挂起的 poll 请求
+  assert.strictEqual(pollAbort.signal.aborted, true, 'flushOffset 应 abort 挂起的 _poll 长轮询')
+  // 等待挂起请求因 abort 结束
+  await pendingReqSettled
+  // flushOffset 自身不应直接修改 _polling（由 _poll 的 finally 清理）
+  assert.strictEqual(listener._polling, true, 'flush 不应直接改 _polling（由 _poll 的 finally 清理）')
+  // 模拟真实 _poll 的 finally：请求结束后立即清理 _polling（真实 _poll 会这样做），
+  // 使 flushOffset 的等待循环立即退出，贴近真实时序并避免 2s deadline。
+  listener._polling = false
+  await flushPromise
+
+  assert.strictEqual(listener._flushLock, false, 'flush 应释放排他锁')
+
+  // flush 应发起 body.timeout:0 的 getUpdates（确认消费），且不与他人并发
+  const flushCall = calls.find((c) => c.tgTimeout === 0)
+  assert.strictEqual(flushCall !== undefined, true, 'flushOffset 应发起 timeout:0 的 getUpdates')
+  // 恰好 2 次请求：1 次挂起的长轮询 + 1 次 flush（无并发重复请求）
+  assert.strictEqual(calls.length, 2, '不应有多余的并发 getUpdates')
+
+  listener.conversations.destroy() // 清理 setInterval 定时器，避免测试进程残留
+})
+
+test('flushOffset 未挂起长轮询时也能正常 flush', async () => {
+  const { listener, calls } = makeListener()
+
+  await listener.flushOffset()
+
+  const flushCall = calls.find((c) => c.tgTimeout === 0)
+  assert.strictEqual(flushCall !== undefined, true, 'flushOffset 应发起确认消费请求')
+  assert.strictEqual(calls.length, 1, '仅 1 次请求（flush）')
+  assert.strictEqual(listener._flushLock, false, 'flush 应释放排他锁')
+
+  listener.conversations.destroy() // 清理 setInterval 定时器，避免测试进程残留
+})

package/src/channel/tg-listener.js

@@ -284,6 +284,11 @@ export class TelegramListener {
     this._lastPollError = null      // 最近一次轮询错误消息（用于去抖刷屏）
     this._lastPollErrorAt = 0       // 最近一次轮询错误时间戳
     this._msgQueue = Promise.resolve()  // 消息串行处理队列（避免阻塞轮询循环）
+    // 排他锁 — 解决 flushOffset 与 _poll 长轮询并发触发 getUpdates 导致 409 Conflict。
+    // Telegram 同一 bot token 同一时刻只允许一个 getUpdates 长轮询。
+    this._pollAbort = null          // 当前 _poll 挂起请求的 AbortController（供 flush 取消）
+    this._flushLock = false         // true = flushOffset 正在独占 bot 连接
+    this._polling = false           // 是否正处于 _poll 请求挂起中（await 未返回）
     this.conversations = new ConversationState()
     this._onMessage = null
     this._handlers = {}
@@ -329,11 +334,23 @@ export class TelegramListener {
   /** 内部轮询 */
   async _poll() {
     while (this.running) {
+      // flushOffset 持有排他锁时，不发起新的 getUpdates，避免与 flush 并发导致 409。
+      // flush 会 abort 当前挂起请求并设置锁，这里等待锁释放后再继续。
+      if (this._flushLock) {
+        await this._sleep(50)
+        continue
+      }
+
+      // 为本次请求创建 AbortController，flushOffset 可通过它取消挂起的长轮询，
+      // 从而独占 bot 连接、消除 409 竞态。
+      this._pollAbort = new AbortController()
+      this._polling = true
       try {
         const url = `${this.bot.apiBase}/getUpdates`
         const res = await this._fetch(url, {
           method: 'POST',
           headers: { 'Content-Type': 'application/json' },
+          signal: this._pollAbort.signal,
           // 长轮询本身最多等 30s（Telegram API 参数），HTTP 层超时必须更长，
           // 否则代理路径（fetchViaSocks5）30s 硬超时会误杀长轮询 → HTTP request timeout 刷屏。
           timeout: 60000,
@@ -379,6 +396,11 @@ export class TelegramListener {
         this._retryDelay = 1000
 
       } catch (e) {
+        // flushOffset 通过 abort 取消挂起请求以独占连接 — 属于预期中断，静默处理不告警。
+        // 回到循环顶部，等待 flushOffset 释放 _flushLock 后继续轮询。
+        if (this._flushLock && e.name === 'AbortError') {
+          continue
+        }
         // 错误去抖：连续相同的错误（如长轮询超时）只在首次/状态变化时打印，
         // 避免 AI 处理长任务时 getUpdates 空转超时不断刷屏。
         const msg = e.message || 'unknown'
@@ -392,6 +414,10 @@ export class TelegramListener {
         }
         await this._sleep(this._retryDelay)
         this._retryDelay = Math.min(this._retryDelay * 2, this.maxRetryDelay)
+      } finally {
+        // 请求结束（成功/失败/abort）— 清理挂起状态，供 flushOffset 判断 poll 已让出
+        this._polling = false
+        this._pollAbort = null
       }
     }
   }
@@ -694,10 +720,28 @@ export class TelegramListener {
    * 同步强杀进程，没有机会再 poll 一次 → 未确认的 update 残留在服务器。
    * 调用 getUpdates(offset=lastUpdateId+1) 可让 Telegram 立即确认消费。
    * 返回 Promise，调用方应 await 后再退出。
+   *
+   * 加固：Telegram 同一 bot token 同时只允许一个 getUpdates 长轮询，
+   * 若 flush 与 _poll 正在挂起的长轮询并发，会触发 409 Conflict。
+   * 因此 flush 先通过 AbortController 取消当前 _poll 请求、独占 bot 连接，
+   * 再发起自己的 getUpdates，彻底消除 409 竞态。
    */
   async flushOffset() {
     if (!this.bot) return
+    // 已持有排他锁（理论上不会重入，防御性直接返回）
+    if (this._flushLock) return
+
+    // 1. 取得排他锁：先取消正在挂起的 _poll 长轮询，再等它完全让出连接。
+    this._flushLock = true
     try {
+      if (this._pollAbort) this._pollAbort.abort()
+      // 等待 _poll 从 await 返回并清理 _polling（最长 2s，防止极端情况下卡死退出）
+      const deadline = Date.now() + 2000
+      while (this._polling && Date.now() < deadline) {
+        await this._sleep(20)
+      }
+
+      // 2. 独占发起 getUpdates 确认消费（timeout:0 立即返回，不挂长轮询）
       const url = `${this.bot.apiBase}/getUpdates`
       const res = await this._fetch(url, {
         method: 'POST',
@@ -716,7 +760,12 @@ export class TelegramListener {
           return
         }
       }
-    } catch {}
+    } catch {
+      // flush 失败不影响退出，offset 已持久化到磁盘，双保险兜底
+    } finally {
+      // 3. 释放排他锁，_poll 循环顶部检测到后继续轮询（进程随即退出，正常路径用不到）
+      this._flushLock = false
+    }
   }
 }
 

package/src/channel/tg-proxy.js

@@ -279,12 +279,28 @@ export async function fetchViaSocks5(url, options = {}, proxyAddr) {
       reject(new Error('HTTP request timeout'))
     }, timeoutMs)
 
+    // 支持 AbortController 取消（如 flushOffset 想中断挂起的长轮询以独占 bot 连接）。
+    // 触发 abort 时销毁 socket，使挂起的请求立即以 AbortError 结束，而不是等 HTTP 超时。
+    const signal = options.signal
+    const onAbort = () => {
+      const err = new Error('The operation was aborted')
+      err.name = 'AbortError'
+      clearTimeout(timeout)
+      socket.destroy()
+      reject(err)
+    }
+    if (signal) {
+      if (signal.aborted) return onAbort()
+      signal.addEventListener('abort', onAbort, { once: true })
+    }
+
     socket.write(reqBuf)
     socket.on('data', (chunk) => {
       responseData += chunk.toString()
     })
     socket.on('end', () => {
       clearTimeout(timeout)
+      if (signal) signal.removeEventListener('abort', onAbort)
       // 解析 HTTP 响应
       const headerEnd = responseData.indexOf('\r\n\r\n')
       if (headerEnd < 0) {
@@ -306,6 +322,7 @@ export async function fetchViaSocks5(url, options = {}, proxyAddr) {
     })
     socket.on('error', (err) => {
       clearTimeout(timeout)
+      if (signal) signal.removeEventListener('abort', onAbort)
       reject(err)
     })
   })

package/src/core/cli.js

@@ -588,10 +588,6 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
   let currentSource = 'cli'
   // 等待中的 Telegram 权限确认（resolve 回调）— 远程用户回复 y/n/a 时响应
   let pendingConfirm = null
-  // 等待中的 Telegram AskUserQuestion 回答（resolve 回调）— 远程用户回复任意文本时响应
-  let pendingAskUser = null
-  // 取消当前等待中的 AskUserQuestion（用户 /stop 时调用，resolve 为取消标记，避免死锁）
-  let cancelAskUser = null
   // 最近一次 /models 拉取的模型列表（供 /model <编号> 选择）
   let modelList = []
   // /models 从 Telegram 发出后，等待用户回复编号/名字来选择模型
@@ -611,14 +607,8 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
     // 关键：来自 Telegram 的消息，如果当前正在等待远程权限确认（pendingConfirm），
     // 则把它当作确认回复（y/n/a）处理，而不是当作新的 REPL 输入。
     // 注意：/ 开头的命令优先走命令分支，不被权限确认拦截（否则 /quit、/stop 会被吞）。
-    // 优先处理 pendingAskUser（AskUserQuestion 需要任意文本答案，且通常是用户正在等待的问题）。
-    if (source === 'telegram' && pendingAskUser && !trimmed.startsWith('/')) {
-      const ask = pendingAskUser
-      pendingAskUser = null
-      cancelAskUser = null
-      ask.fn(trimmed)
-      return
-    }
+    // （AskUserQuestion 已改为异步发问，不再依赖 pendingAskUser 挂起结构——用户回复
+    //   作为正常消息进入引擎处理，无锁死/发呆问题。）
     if (source === 'telegram' && pendingConfirm && !trimmed.startsWith('/')) {
       const confirm = pendingConfirm
       pendingConfirm = null
@@ -812,13 +802,7 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
           break
         case 'stop':
           // 停止当前正在运行的 AI 工作（如卡死 / 长时间无响应时）。
-          // 若正在等待 AskUserQuestion 回答，先取消提问（resolve 取消标记），避免引擎挂起。
-          if (pendingAskUser) {
-            const cancel = cancelAskUser
-            pendingAskUser = null
-            cancelAskUser = null
-            if (cancel) cancel()
-          }
+          // AskUserQuestion 已改为异步发问（不挂起），无需在此取消 pending 等待。
           if (engine.state.isRunning) {
             engine.abort()
             console.log('⏹️  已发送停止信号，正在中止当前工作...')
@@ -1157,25 +1141,19 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
   }
   engine.config.readline = rl
 
-  // AskUserQuestion 工具回调 — 按当前来源分流：
-  // - Telegram 远程模式：推送问题到 Telegram 并等待远程回复（带超时兜底，避免死锁）
-  // - CLI 本地模式：走本地终端交互（inputCtrl.ask）
+  // AskUserQuestion 工具回调 — 按通道分流：
+  // - Telegram 可用时：异步发问——发问题到 Telegram 后立即返回（不挂起 Promise、不锁死引擎），
+  //   用户后续回复作为正常消息进入，由下一轮引擎处理时把回复当作回答。
+  //   避免旧"挂起等待"结构导致会话卡死/发呆。
+  // - CLI 本地模式：同步等待本地终端输入。
   engine.config.onAskUser = (question) => {
-    if (currentSource === 'telegram' && tgListener?.bot) {
-      const promptText = `❓ ${question}\n\n请直接回复你的回答。\n（发 /stop 可取消本次提问）`
+    if (tgListener?.bot && tgChatId) {
+      const promptText = `❓ ${question}\n\n请直接回复你的回答。`
       sendTelegram(promptText, null).catch(() => {})
-      return new Promise((resolve) => {
-        // 一直等待用户回答——不设超时自行结束（超时会吞掉迟到回答，违背"等待回答"语义）。
-        // 用户回复任意文本即作为回答；用户 /stop 则通过 cancelAskUser 取消（resolve 取消标记，避免死锁）。
-        pendingAskUser = { fn: (val) => resolve(val) }
-        cancelAskUser = () => {
-          if (pendingAskUser) pendingAskUser = null
-          cancelAskUser = null
-          resolve('(提问已取消)')
-        }
-      })
+      // 立即返回，不挂起；用户回复会在下一轮以正常消息进入
+      return `(已向用户提问，等待回复): ${question}`
     }
-    // CLI 本地模式
+    // CLI 本地模式：同步等待终端输入
     return askQuestion(`❓ ${question}\n> `)
   }