@raolin2025/claude-code-node 2.6.12 → 2.6.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raolin2025/claude-code-node",
-  "version": "2.6.12",
+  "version": "2.6.14",
   "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/channel/tg-listener.js

@@ -385,14 +385,15 @@ export class TelegramListener {
     }
   }
 
-  /** 将消息加入串行处理队列（不阻塞轮询循环） */
+  /** 异步处理一条消息（不串行排队，避免权限确认死锁） */
   _enqueueMessage(msg) {
-    this._msgQueue = this._msgQueue.then(async () => {
-      try {
-        await this._handleMessage(msg)
-      } catch (e) {
-        log(`[TG] handle error: ${e.message}`)
-      }
+    // 关键：不能串行排队等待前一条消息处理完。
+    // 若第一条消息触发权限确认而挂起（await pendingConfirm），
+    // 后续的权限确认回复 a 会排在后面积压，造成死锁（a 永远处理不到）。
+    // 因此每条消息独立异步处理：权限确认回复能立即响应，普通消息由
+    // processInputLine 内部处理"引擎忙"的情况。
+    this._handleMessage(msg).catch((e) => {
+      log(`[TG] handle error: ${e.message}`)
     })
   }
 

package/src/core/cli.js

@@ -855,9 +855,24 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
       return
     }
 
+    // 发送到引擎 — 引擎忙（如正在处理上一条消息）时，提示而不是崩溃/吞掉
+    if (engine.state.isRunning) {
+      const busyMsg = '⏳ 引擎正在处理其他任务，请稍候或输入 /stop 停止当前任务。'
+      console.log(busyMsg)
+      if (source === 'telegram' && tgListener?.bot) {
+        await sendTelegram(busyMsg, tgChatId || null).catch(() => {})
+      }
+      return
+    }
+
     // 发送到引擎
     try {
+      // 有 Telegram 通道时，流式推送思维链到当前回复目标，避免远程"以为没回应"
+      const streamTarget = (source === 'telegram') ? (tgChatId || null) : (tgListener?.bot ? tgChatId || null : null)
+      if (streamTarget) tgThinkingStart(streamTarget)
       const result = await processInput(input)
+      // 处理结束，清掉思维链流（最终回复随后发送）
+      tgThinkingEnd()
       console.log()
       console.log(result.response)
       console.log()
@@ -876,6 +891,7 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
         await sendTelegram(result.response, tgChatId || null)
       }
     } catch (err) {
+      tgThinkingEnd()
       console.error(`\nError: ${err.message}\n`)
       if (tgListener?.bot) {
         await sendTelegram(`❌ Error: ${err.message}`, tgChatId || null)
@@ -916,6 +932,63 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
     }
   }
 
+  // ============================================================
+  // 思维链流式推送 → Telegram
+  // 把引擎 onDelta 产出的 reasoning（思考过程）实时推送到 Telegram，
+  // 让远程用户看到 AI 正在工作，而不是"以为没回应"。
+  // 采用节流 + 编辑同一消息的方式，避免刷屏和触发速率限制。
+  // ============================================================
+  const tgThinking = { buffer: '', timer: null, target: null, lastMsgId: null }
+
+  function tgThinkingStart(target) {
+    tgThinking.target = target || null
+    tgThinking.buffer = ''
+    tgThinking.lastMsgId = null
+    // 先发送 typing 动作，让 Telegram 立即显示"正在输入"
+    if (tgListener?.bot && tgThinking.target) {
+      tgListener.bot.sendChatAction(tgThinking.target, 'typing').catch(() => {})
+    }
+  }
+
+  function tgThinkingPush(text) {
+    if (!text || !tgListener?.bot || !tgThinking.target) return
+    tgThinking.buffer += text
+    // 只保留最近 8000 字符，避免无限增长
+    if (tgThinking.buffer.length > 8000) tgThinking.buffer = tgThinking.buffer.slice(-8000)
+    // 节流：2 秒内最多刷新一次
+    if (tgThinking.timer) clearTimeout(tgThinking.timer)
+    tgThinking.timer = setTimeout(() => tgThinkingFlush(), 2000)
+  }
+
+  async function tgThinkingFlush() {
+    if (tgThinking.timer) { clearTimeout(tgThinking.timer); tgThinking.timer = null }
+    if (!tgListener?.bot || !tgThinking.target || !tgThinking.buffer) return
+    const target = tgThinking.target
+    const body = `🧠 思考中…\n\n${tgThinking.buffer.slice(-3500)}`
+    try {
+      if (tgThinking.lastMsgId) {
+        await tgListener.bot.editMessage(target, tgThinking.lastMsgId, body, { parseMode: 'HTML' })
+      } else {
+        const res = await tgListener.bot.sendMessage(target, body, { parseMode: 'HTML' })
+        tgThinking.lastMsgId = res?.message_id || null
+      }
+    } catch (e) {
+      // 编辑失败（如消息被删）→ 重发一条新的
+      tgThinking.lastMsgId = null
+      try {
+        const res = await tgListener.bot.sendMessage(target, body, { parseMode: 'HTML' })
+        tgThinking.lastMsgId = res?.message_id || null
+      } catch {}
+    }
+  }
+
+  function tgThinkingEnd() {
+    if (tgThinking.timer) { clearTimeout(tgThinking.timer); tgThinking.timer = null }
+    tgThinking.buffer = ''
+    tgThinking.lastMsgId = null
+    tgThinking.target = null
+  }
+
   // REPL 主循环 — 由 readline 原生处理回显、退格、行回绕与 Enter 提交
   rl.on('line', (line) => {
     processInputLine(line)
@@ -1027,6 +1100,23 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
     console.log('📡 Built-in channel listeners started (--with-notify)')
   }
 
+  // ============================================================
+  // 引擎流式回调 — 保持 CLI 实时输出，并把思维链推送到 Telegram
+  // onDelta 会在流式生成时被调用（{type:'text'|'reasoning', text}）。
+  // 设置 onDelta 后引擎不再直接写终端，因此这里需手动维持终端输出。
+  // ============================================================
+  engine.config.onDelta = ({ type, text }) => {
+    if (type === 'text') {
+      // 保持 CLI 实时输出（与未设置 onDelta 时行为一致）
+      process.stdout.write(text)
+    } else if (type === 'reasoning') {
+      // CLI 也显示思维链
+      process.stdout.write(text)
+      // 实时推送到 Telegram（节流）
+      tgThinkingPush(text)
+    }
+  }
+
   console.log(buildBanner({ model, permissionMode, session, maxTokens: tokenBudget.maxTokens }))
   console.log(`Model: ${model} | Permission: ${permissionMode} | Tools: ${registry.getNames().join(', ')}`)
   console.log(`Socket: ${SOCK_PATH} (cc-notify can connect)`)

package/src/core/query-engine.js

@@ -413,9 +413,11 @@ export class QueryEngine {
           }
           currentText += event.text
         } else if (event.type === 'reasoning') {
-          // 推理内容（thinking）同样支持回调
+          // 推理内容（thinking）同样支持回调；无 onDelta 时在终端展示思维链
           if (typeof this.config.onDelta === 'function') {
             this.config.onDelta({ type: 'reasoning', text: event.text })
+          } else if (this.config.verbose) {
+            process.stdout.write(event.text)
           }
         } else if (event.type === 'tool_use') {
           // 收集工具调用
@@ -426,6 +428,7 @@ export class QueryEngine {
           ))
         } else if (event.type === 'done') {
           result.content = event.result.content || currentText
+          result.reasoningContent = event.result.reasoningContent || result.reasoningContent
           result.toolCalls = event.result.toolCalls?.map(tc =>
             new ToolCall(tc.id, tc.name, tc.input)
           ) || result.toolCalls

package/src/core/streaming.js

@@ -44,6 +44,8 @@ export async function* parseStream(response) {
           // reasoning_content (DeepSeek thinking mode)
           if (delta.reasoning_content) {
             result.reasoningContent += delta.reasoning_content
+            // 实时产出 reasoning 事件，供 onDelta 回调（如推送思维链到 Telegram）消费
+            yield { type: 'reasoning', text: delta.reasoning_content }
           }
 
           // 文本

package/src/tools/telegram-tools.js

@@ -15,26 +15,84 @@
 
 import { ToolDef } from '../types/index.js'
 import { TelegramBotClient } from '../channel/tg-listener.js'
+import { readFileSync, statSync } from 'fs'
+import { homedir } from 'os'
+import { join } from 'path'
 
 const API_BASE = (token) => `https://api.telegram.org/bot${token}`
 
-/** 读取配置 */
+/**
+ * 读取 Telegram 配置（环境变量优先，其次 config.json 的 channels.telegram）
+ *
+ * 配置优先级：
+ *   1. 环境变量 CC_NODE_CHANNEL_TELEGRAM_*
+ *   2. 用户级 ~/.claude-code/config.json → channels.telegram
+ *   3. 项目级 .claude-code/config.json → channels.telegram（覆盖用户级）
+ */
+let _cachedTgConfig = null
+let _cachedTgConfigMtime = null
+
+function loadTgConfigFromFile() {
+  const files = [
+    join(homedir(), '.claude-code/config.json'),   // 用户级
+    '.claude-code/config.json',                      // 项目级（覆盖用户级）
+  ]
+  let merged = {}
+  for (const file of files) {
+    try {
+      const raw = readFileSync(file, 'utf-8')
+      const data = JSON.parse(raw)
+      if (data?.channels?.telegram) {
+        merged = { ...merged, ...data.channels.telegram }
+      }
+    } catch { /* 文件不存在或解析失败则跳过 */ }
+  }
+  return merged
+}
+
+/** 读取 Telegram 配置（带缓存，文件 mtime 变化自动失效） */
+function getTgConfig() {
+  const userFile = join(homedir(), '.claude-code/config.json')
+  const projectFile = '.claude-code/config.json'
+  let mtimeKey = ''
+  for (const f of [userFile, projectFile]) {
+    try { mtimeKey += statSync(f).mtimeMs } catch {}
+  }
+  if (_cachedTgConfigMtime !== mtimeKey) {
+    _cachedTgConfig = loadTgConfigFromFile()
+    _cachedTgConfigMtime = mtimeKey
+  }
+  return _cachedTgConfig
+}
+
+/** 读取 token（环境变量优先，其次 config.json） */
 function getToken() {
-  return process.env.CC_NODE_CHANNEL_TELEGRAM_TOKEN || ''
+  return process.env.CC_NODE_CHANNEL_TELEGRAM_TOKEN || getTgConfig().token || ''
 }
 
+/** 读取默认聊天 ID（环境变量优先，其次 config.json） */
 function getDefaultChatId() {
-  return process.env.CC_NODE_CHANNEL_TELEGRAM_CHAT_ID || ''
+  return process.env.CC_NODE_CHANNEL_TELEGRAM_CHAT_ID || getTgConfig().chatId || ''
+}
+
+/** 读取代理（环境变量优先，其次 config.json） */
+function getProxy() {
+  return process.env.CC_NODE_CHANNEL_TELEGRAM_PROXY || getTgConfig().proxy || ''
+}
+
+/** 读取 API Base（环境变量优先，其次 config.json） */
+function getApiBase(token) {
+  return process.env.CC_NODE_CHANNEL_TELEGRAM_API_BASE || getTgConfig().apiBase || API_BASE(token)
 }
 
 /** 创建 TelegramBotClient 实例 */
 function getClient() {
   const token = getToken()
   if (!token) {
-    throw new Error('未配置 Telegram Token（请设置 CC_NODE_CHANNEL_TELEGRAM_TOKEN）')
+    throw new Error('未配置 Telegram Token（请设置 CC_NODE_CHANNEL_TELEGRAM_TOKEN 或 config.json 的 channels.telegram.token）')
   }
-  const proxy = process.env.CC_NODE_CHANNEL_TELEGRAM_PROXY || ''
-  const apiBase = process.env.CC_NODE_CHANNEL_TELEGRAM_API_BASE || API_BASE(token)
+  const proxy = getProxy()
+  const apiBase = getApiBase(token)
   return new TelegramBotClient(token, { proxy, apiBase })
 }
 
@@ -93,7 +151,7 @@ async function sendMedia(args) {
 
   const client = getClient()
   const token = getToken()
-  const apiBase = client.apiBase || API_BASE(token)
+  const apiBase = client.apiBase || getApiBase(token)
 
   // 检测文件类型
   const ext = absPath.split('.').pop().toLowerCase()
@@ -156,7 +214,7 @@ async function channelApi(args) {
 
   const client = getClient()
   const token = getToken()
-  const apiBase = client.apiBase || API_BASE(token)
+  const apiBase = client.apiBase || getApiBase(token)
 
   const url = new URL(apiBase + (path.startsWith('/') ? path : '/' + path))
   for (const [k, v] of Object.entries(query)) url.searchParams.append(k, String(v))