@raolin2025/claude-code-node 2.7.0 → 2.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raolin2025/claude-code-node",
-  "version": "2.7.0",
+  "version": "2.7.1",
   "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__/multiline-input.test.js

@@ -0,0 +1,243 @@
+import { test } from 'node:test'
+import assert from 'node:assert'
+import { PassThrough, Writable } from 'node:stream'
+import { createMultilineInput } from '../core/multiline-input.js'
+
+// 创建一个模拟 TTY 的输入流和一个收集 stdout 的输出流
+function makeEnv() {
+  const input = new PassThrough()
+  input.isTTY = true
+  input.setRawMode = () => {}
+  const output = new Writable({ write(c, _e, cb) { this.buf += c.toString(); cb() } })
+  output.buf = ''
+  return { input, output }
+}
+
+// 让事件循环跑一下，等待异步提交
+const tick = () => new Promise((r) => setTimeout(r, 30))
+
+test('多行输入被完整提交（含内嵌换行，不被断句）', async () => {
+  const { input, output } = makeEnv()
+  const submitted = []
+  const ctrl = createMultilineInput({
+    stdin: input, stdout: output, prompt: '> ',
+    onSubmit: (t) => submitted.push(t),
+  })
+  ctrl.start()
+
+  input.write('第一行')
+  input.write('\n') // 文本换行 → 折行，不提交
+  input.write('第二行')
+  input.write('\r') // Enter → 提交
+
+  await tick()
+  assert.deepStrictEqual(submitted, ['第一行\n第二行'])
+})
+
+test('CRLF 提交后残留 \\n 被忽略，不产生脏输入', async () => {
+  const { input, output } = makeEnv()
+  const submitted = []
+  const ctrl = createMultilineInput({
+    stdin: input, stdout: output, prompt: '> ',
+    onSubmit: (t) => submitted.push(t),
+  })
+  ctrl.start()
+
+  input.write('A段')
+  input.write('\r\n') // CRLF
+  input.write('B段')
+  input.write('\r')
+
+  await tick()
+  assert.deepStrictEqual(submitted, ['A段', 'B段'])
+})
+
+test('连续多条输入互不干扰，各自完整', async () => {
+  const { input, output } = makeEnv()
+  const submitted = []
+  const ctrl = createMultilineInput({
+    stdin: input, stdout: output, prompt: '> ',
+    onSubmit: (t) => submitted.push(t),
+  })
+  ctrl.start()
+
+  input.write('文章一\n带换行')
+  input.write('\r')
+  input.write('文章二')
+  input.write('\r')
+
+  await tick()
+  assert.deepStrictEqual(submitted, ['文章一\n带换行', '文章二'])
+})
+
+test('上方向键调出输入历史', async () => {
+  const { input, output } = makeEnv()
+  const submitted = []
+  const ctrl = createMultilineInput({
+    stdin: input, stdout: output, prompt: '> ',
+    onSubmit: (t) => submitted.push(t),
+  })
+  ctrl.start()
+
+  input.write('历史输入')
+  input.write('\r')
+  input.write('\x1b[A') // 上方向键
+  input.write('\r')
+
+  await tick()
+  assert.deepStrictEqual(submitted, ['历史输入', '历史输入'])
+})
+
+test('ask() 单行问题返回用户回答', async () => {
+  const { input, output } = makeEnv()
+  const ctrl = createMultilineInput({
+    stdin: input, stdout: output, prompt: '> ',
+  })
+  ctrl.start()
+
+  const p = ctrl.ask('是否允许? (y/N)')
+  input.write('y')
+  input.write('\r')
+
+  const ans = await p
+  assert.strictEqual(ans, 'y')
+})
+
+test('ask() 在提问期间不污染主输入缓冲', async () => {
+  const { input, output } = makeEnv()
+  const submitted = []
+  const ctrl = createMultilineInput({
+    stdin: input, stdout: output, prompt: '> ',
+    onSubmit: (t) => submitted.push(t),
+  })
+  ctrl.start()
+
+  const p = ctrl.ask('选一个? ')
+  input.write('x')
+  input.write('\r')
+  await p
+
+  // 提问结束后，主输入缓冲应为空，输入新内容提交正常
+  input.write('新输入')
+  input.write('\r')
+  await tick()
+  assert.deepStrictEqual(submitted, ['新输入'])
+})
+
+test('单行输入回显稳定：不发出光标上移\\x1b[1A（防止乱跳）', async () => {
+  const { input, output } = makeEnv()
+  output.columns = 80
+  const ctrl = createMultilineInput({
+    stdin: input, stdout: output, prompt: '> ',
+    onSubmit: () => {},
+  })
+  ctrl.start()
+
+  input.write('hello')
+  await tick()
+
+  const raw = output.buf
+  // 单行输入时绝不出现光标上移序列（会导致屏幕乱跳）
+  assert.ok(!raw.includes('\x1b[1A'), `单行输入不应上移光标，实际输出: ${JSON.stringify(raw)}`)
+  // 应通过 \r + 清屏 + 重绘实现回显
+  assert.ok(raw.includes('\x1b[J'), '应有清屏序列')
+  // 最终内容应完整显示
+  assert.ok(raw.includes('> hello'), '输入内容应完整回显')
+})
+
+test('多行输入回显稳定：重绘只上移到首行一次，无多余跳转', async () => {
+  const { input, output } = makeEnv()
+  output.columns = 80
+  const ctrl = createMultilineInput({
+    stdin: input, stdout: output, prompt: '> ',
+    onSubmit: () => {},
+  })
+  ctrl.start()
+
+  input.write('第一行')
+  input.write('\n')   // 折行
+  input.write('第二行')
+  await tick()
+
+  const raw = output.buf
+  // 折行后输入第二行时，应只发出一次 \x1b[1A（上移到首行）+ 清屏 + 重绘
+  // 不应出现 \x1b[1B（下移）或 \x1b[nC 这类多余跳转组合
+  assert.ok(!raw.includes('\x1b[1B'), '不应有光标下移跳转')
+  // 内容应包含两行完整回显
+  assert.ok(raw.includes('> 第一行'), '第一行应回显')
+  assert.ok(raw.includes('第二行'), '第二行应回显')
+})
+
+test('Alt+Enter（Esc+Enter）折行、普通 Enter 提交 — 跨终端可靠多行输入', async () => {
+  const { input, output } = makeEnv()
+  const submitted = []
+  const ctrl = createMultilineInput({
+    stdin: input, stdout: output, prompt: '> ',
+    onSubmit: (t) => submitted.push(t),
+  })
+  ctrl.start()
+
+  // 第一行 + Alt+Enter（\x1b\r → meta+return）折行
+  input.write('第一行')
+  input.write('\x1b\r')
+  // 第二行 + 普通 Enter 提交
+  input.write('第二行')
+  input.write('\r')
+
+  await tick()
+  assert.deepStrictEqual(submitted, ['第一行\n第二行'])
+})
+
+test('普通 Enter 仍是提交（单行输入不受影响）', async () => {
+  const { input, output } = makeEnv()
+  const submitted = []
+  const ctrl = createMultilineInput({
+    stdin: input, stdout: output, prompt: '> ',
+    onSubmit: (t) => submitted.push(t),
+  })
+  ctrl.start()
+
+  input.write('hello world')
+  input.write('\r')
+
+  await tick()
+  assert.deepStrictEqual(submitted, ['hello world'])
+})
+
+test('独立 ESC 事件 + Enter（终端把 Alt+Enter 拆成两事件）也折行', async () => {
+  const { input, output } = makeEnv()
+  const submitted = []
+  const ctrl = createMultilineInput({
+    stdin: input, stdout: output, prompt: '> ',
+    onSubmit: (t) => submitted.push(t),
+  })
+  ctrl.start()
+
+  // 模拟终端把 Alt+Enter 拆成独立 ESC 事件和独立 \r 事件（分两次写入）
+  input.write('第一行')
+  input.write('\x1b')   // 独立 ESC 事件
+  input.write('\r')     // 随后的 Enter → 应视为 Alt+Enter 折行
+  input.write('第二行')
+  input.write('\r')     // 普通 Enter 提交
+
+  await tick()
+  assert.deepStrictEqual(submitted, ['第一行\n第二行'])
+})
+
+test('CSI 序列 \\x1b[13~（部分终端的 Ctrl/Alt+Enter）折行', async () => {
+  const { input, output } = makeEnv()
+  const submitted = []
+  const ctrl = createMultilineInput({
+    stdin: input, stdout: output, prompt: '> ',
+    onSubmit: (t) => submitted.push(t),
+  })
+  ctrl.start()
+
+  input.write('第一行')
+  input.write('\x1b[13~') // CSI 序列 → f3 → 折行
+  input.write('第二行')
+  input.write('\r')       // 普通 Enter 提交
+
+  await tick()
+  assert.deepStrictEqual(submitted, ['第一行\n第二行'])
+})

package/src/channel/tg-listener.js

@@ -16,6 +16,11 @@
 // MarkdownV2 安全编码
 // ============================================================
 
+// 静态导入用于 offset 持久化（ESM 顶层导入，可在构造函数内同步使用）
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'fs'
+import { homedir } from 'os'
+import { join, dirname } from 'path'
+
 const TG_MD_ESCAPE_CHARS = /[_*[\]()~`>#+\-=|{}.!]/g
 const TG_CODE_ESCAPE_CHARS = /[`\\]/g
 const TG_LINK_ESCAPE_CHARS = /[()]/g
@@ -270,7 +275,8 @@ export class TelegramListener {
     this.proxyAddr = ch.proxy || process.env.CC_NODE_CHANNEL_TELEGRAM_PROXY || ''
     this.apiBase = ch.apiBase || ''
     this.bot = this.token ? new TelegramBotClient(this.token, { proxy: this.proxyAddr, apiBase: this.apiBase }) : null
-    this.lastUpdateId = 0
+    // 从磁盘恢复持久化的 offset，避免进程重启后重放旧消息（含 /quit 等历史命令）
+    this.lastUpdateId = this._loadOffset()
     this.running = false
     this._pollTimer = null
     this._retryDelay = 1000
@@ -350,6 +356,9 @@ export class TelegramListener {
         if (data.result?.length) {
           for (const update of data.result) {
             this.lastUpdateId = Math.max(this.lastUpdateId, update.update_id)
+            // 推进 offset 后立即持久化到磁盘，保证进程异常退出（如 /quit）
+            // 重启后从正确位置继续，不重放旧消息。
+            this._saveOffset()
 
             // 处理回调查询（按钮点击）— 快速操作，直接 await
             if (update.callback_query) {
@@ -638,6 +647,77 @@ export class TelegramListener {
   _sleep(ms) {
     return new Promise(r => setTimeout(r, ms))
   }
+
+  // ============================================================
+  // Offset 持久化 — 防止进程重启后重放旧消息（含 /quit 等）
+  // Telegram 的 getUpdates 用 offset 确认消费；若 offset 只存内存，
+  // 进程异常退出（如 /quit 的 process.exit）后重启 lastUpdateId 归零，
+  // 会重放服务器上所有未确认的 update，导致 /quit 死循环起不来。
+  // 将 offset 持久化到磁盘，重启后从正确位置继续，彻底根治此问题。
+  // ============================================================
+
+  /** offset 状态文件路径 */
+  _offsetFile() {
+    return join(homedir(), '.cc-node', 'tg-offset.json')
+  }
+
+  /** 从磁盘加载已持久化的 offset */
+  _loadOffset() {
+    try {
+      const file = this._offsetFile()
+      if (!existsSync(file)) return 0
+      const raw = readFileSync(file, 'utf8').trim()
+      if (!raw) return 0
+      const data = JSON.parse(raw)
+      const id = Number(data.lastUpdateId) || 0
+      if (id > 0) log(`[TG] Restored offset ${id} (persisted, skip replayed updates)`)
+      return id
+    } catch {
+      return 0
+    }
+  }
+
+  /** 持久化当前 offset 到磁盘 */
+  _saveOffset() {
+    try {
+      const file = this._offsetFile()
+      mkdirSync(dirname(file), { recursive: true })
+      writeFileSync(file, JSON.stringify({ lastUpdateId: this.lastUpdateId, updatedAt: Date.now() }), 'utf8')
+    } catch (e) {
+      log(`[TG] Failed to persist offset: ${e.message}`)
+    }
+  }
+
+  /**
+   * 退出前确认消费已接收的 update（双保险）。
+   * 正常路径下 next poll 会提交 offset，但 /quit 等命令走 process.exit
+   * 同步强杀进程，没有机会再 poll 一次 → 未确认的 update 残留在服务器。
+   * 调用 getUpdates(offset=lastUpdateId+1) 可让 Telegram 立即确认消费。
+   * 返回 Promise，调用方应 await 后再退出。
+   */
+  async flushOffset() {
+    if (!this.bot) return
+    try {
+      const url = `${this.bot.apiBase}/getUpdates`
+      const res = await this._fetch(url, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        timeout: 10000,
+        body: JSON.stringify({
+          offset: this.lastUpdateId + 1,
+          timeout: 0,
+          allowed_updates: ['message', 'callback_query', 'edited_message'],
+        }),
+      })
+      if (res.ok) {
+        const data = await res.json()
+        if (data.ok) {
+          log(`[TG] Flushed offset ${this.lastUpdateId + 1} before exit`)
+          return
+        }
+      }
+    } catch {}
+  }
 }
 
 // ============================================================

package/src/core/cli.js

@@ -5,6 +5,7 @@
  * v1.2: 增加 Unix socket 服务，让 cc-notify 能发现并转发消息
  */
 import * as readline from 'readline'
+import { createMultilineInput } from './multiline-input.js'
 import { createServer as createNetServer } from 'net'
 import { writeFileSync, unlinkSync, existsSync, mkdirSync, readFileSync, chmodSync } from 'fs'
 import { join } from 'path'
@@ -527,7 +528,8 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
       engine.config.onConfirmTool = async () => true
     }
     const result = await engine.processMessage(cliArgs.oneShot)
-    console.log(result.response)
+    // 引擎已流式输出正文（无 onDelta 时引擎内部直写终端）→ 不再重复打印，避免"回答两次"
+    if (!engine.lastStreamed) console.log(result.response)
     // 保存会话
     session = await sessionManager.create(`one-shot: ${cliArgs.oneShot.slice(0, 50)}`)
     await sessionManager.appendMessage({ role: 'user', content: cliArgs.oneShot })
@@ -545,19 +547,37 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
   startSocketServer(engine, session, sessionManager, channelManager, verbose)
 
   // ============================================================
-  // REPL 输入处理
+  // REPL 输入处理 — 多行输入（读取完整输入再处理）
   //
-  // 使用标准 readline 的 line 事件（terminal: true）实现输入读取：
-  //   - 字符回显、退格删除、行回绕、方向键历史由 readline 原生处理，
-  //     行为与 v2.5 一致，避免手动 keypress 回显导致的显示错乱。
-  //   - Enter 提交；Ctrl+C 退出。
-  //   - 非 TTY（管道/重定向）模式复用同一 readline 接口。
+  // 不再用 readline 的 line 事件（它遇到 \n 就提交当前行，导致
+  // 多行文本被断句，后续行在引擎忙时被丢弃）。
+  // 改用 keypress + raw mode 自己管理输入缓冲（见 multiline-input.js）：
+  //   - Enter（\r）→ 提交整段输入（含内嵌换行）
+  //   - Ctrl+Enter / Alt+Enter / Ctrl+J → 折行，多行输入（不提交）
+  //   - 可打印字符回显、退格、上下方向键历史、Ctrl+C
+  //   - 非 TTY（管道/重定向）回退到 readline line 事件
   // ============================================================
-  const rl = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: '> ' })
+  const inputCtrl = createMultilineInput({
+    prompt: '> ',
+    onSubmit: (text) => { processInputLine(text) },
+    onExit: () => { process.exit(0) },
+  })
 
   // 显示提示符
   function showPrompt() {
-    rl.prompt()
+    inputCtrl.showPrompt()
+  }
+
+  // 单行问题收集（权限确认 / /models 选择 / AskUserQuestion）
+  // 返回 Promise<string>，在 keypress 模式下与多行输入共用同一 stdin，
+  // 避免 readline 的 question 与主循环 keypress 互相干扰。
+  function askQuestion(questionText) {
+    return inputCtrl.ask(questionText)
+  }
+
+  // 兼容对象：供 AskUserQuestion 工具和引擎的 ctx.readline.question() 使用
+  const rl = {
+    question: (q, cb) => { askQuestion(q).then(cb) },
   }
 
   // Telegram 双向通道（可选）：tgListener 监听 Telegram 消息，tgChatId 记录回复目标
@@ -572,6 +592,8 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
   let modelList = []
   // /models 从 Telegram 发出后，等待用户回复编号/名字来选择模型
   let pendingModelSelect = false
+  // 流式输出标志 — onDelta 已实时把回答输出到终端时，不再重复打印完整 response
+  let streamedText = false
 
   // 处理输入行
   // source: 'cli' 来自终端输入, 'telegram' 来自 Telegram
@@ -867,9 +889,15 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
           }
           break
         }
-        case 'exit': case 'quit':
+        case 'exit': case 'quit': {
+          // 退出前确认消费 Telegram update（避免 /quit 等命令残留在服务器缓冲区，
+          // 下次启动重放导致死循环起不来）。配合 tg-listener 的 offset 持久化双保险。
+          if (tgListener?.bot) {
+            try { await tgListener.flushOffset() } catch {}
+          }
           console.log('Goodbye!')
           process.exit(0)
+        }
         default:
           console.log(`Unknown command: /${cmd}. Type /help for available commands.`)
       }
@@ -903,7 +931,11 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
       // 处理结束，清掉思维链流（最终回复随后发送）
       tgThinkingEnd()
       console.log()
-      console.log(result.response)
+      // 正文已被 onDelta 实时流式输出到终端 → 不重复打印（否则出现"回答两次"的双层显示）。
+      // 仅当没有流式输出（noStream / 流式失败 / 无 onDelta 回调）时才打印完整 response。
+      if (!engine.lastStreamed && !streamedText) {
+        console.log(result.response)
+      }
       console.log()
       await sessionManager.appendMessage({ role: 'user', content: input })
       await sessionManager.appendMessage({ role: 'assistant', content: result.response })
@@ -1025,12 +1057,11 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
     tgThinking.flushing = false
   }
 
-  // REPL 主循环 — 由 readline 原生处理回显、退格、行回绕与 Enter 提交
-  rl.on('line', (line) => {
-    processInputLine(line)
-  })
+  // REPL 主循环 — 由 multiline-input 处理多行输入（keypress / 非TTY readline）
+  // 输入由 createMultilineInput 在创建时挂接，start() 显示初始提示符
+  inputCtrl.start()
 
-  // 将 readline 注入引擎配置，用于 ask 模式确认和 AskUserQuestion 工具
+  // 将 readline 兼容对象注入引擎配置，用于 ask 模式确认和 AskUserQuestion 工具
   if (permissionMode === 'ask') {
     engine.config.onConfirmTool = async (toolName, input) => {
       // 如果已经启用会话全局自动允许，直接通过
@@ -1146,6 +1177,8 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
   engine.config.onDelta = ({ type, text }) => {
     // 保持 CLI 实时输出
     process.stdout.write(text)
+    // 记录已有文本被实时输出到终端（供 processInputLine 判断是否需重复打印 response）
+    if (type === 'text' && text) streamedText = true
     // 无论 text 还是 reasoning，都实时推送到 Telegram（节流）
     tgThinkingPush(text)
   }

package/src/core/multiline-input.js

@@ -0,0 +1,301 @@
+// ============================================================
+//  multiline-input.js — REPL 多行输入（读取完整输入再处理）
+// ------------------------------------------------------------
+//  解决「输入缓存未读完就按 \n 断句」的根因问题：
+//    readline 的 line 事件遇到 \n 就提交当前行，导致多行文本
+//    被拆成多段，且后续行在引擎忙时被丢弃。
+//
+//  本模块改用 keypress + raw mode 自己管理输入缓冲：
+//    - Enter（\r / CR）                  → 提交整段输入（含内嵌换行）
+//    - Ctrl+Enter / Alt+Enter / Ctrl+J  → 折行，累积到缓冲，不提交（多行输入）
+//    - 可打印字符            → 回显并累积
+//    - 退格                  → 删除并回显
+//    - 上/下方向键            → 浏览输入历史
+//    - Ctrl+C                → 清空 / 退出
+//    - 非 TTY（管道/重定向）  → 回退到 readline line 事件
+//
+//  接口：
+//    createMultilineInput({ prompt, onSubmit, onExit, stdin, stdout })
+//      -> { start(), showPrompt(), ask(questionText), dispose() }
+//         onSubmit(text)    完整输入（可能含 \n）提交回调
+//         ask(qText)        单行问题收集（返回 Promise<string>）
+// ============================================================
+
+import * as readline from 'readline'
+
+export function createMultilineInput({ prompt = '> ', onSubmit, onExit, stdin, stdout } = {}) {
+  const input = stdin || process.stdin
+  const output = stdout || process.stdout
+  const isTTY = input.isTTY
+
+  let inputBuffer = ''      // 当前多行输入缓冲
+  let inputHistory = []     // 输入历史
+  let historyIndex = -1     // 历史浏览索引（-1 = 编辑新输入）
+  let skipNextLF = false    // CRLF 提交后忽略残留 \n
+  let questioning = false   // 是否正在收集单行问题（权限确认等）
+  let questionResolve = null
+  let questionBuf = ''
+  let escPending = false    // 刚收到独立 ESC 事件（某些终端把 Alt+Enter 拆成 ESC 和 Enter 两个事件）
+  let escTimer = null       // ESC 后跟 Enter 的超时还原定时器
+
+  const PROMPT = prompt
+  let displayedRows = 0     // 当前输入区在终端实际占用的屏幕行数（含提示符行，考虑换行与CJK宽字符）
+
+  // ============================================================
+  // 非 TTY 模式：回退到 readline line 事件（管道/重定向）
+  // ============================================================
+  if (!isTTY) {
+    const rl = readline.createInterface({ input, output, prompt })
+    return {
+      start() { rl.on('line', (line) => onSubmit(line)); rl.prompt() },
+      showPrompt() { rl.prompt() },
+      ask(q) {
+        return new Promise((resolve) => { rl.question(q + ' ', resolve) })
+      },
+      dispose() { rl.close() },
+    }
+  }
+
+  // ============================================================
+  // TTY 模式：keypress + raw mode 多行输入
+  // ============================================================
+  readline.emitKeypressEvents(input)
+  try { input.setRawMode(true) } catch {}
+
+  // 终端列数（缺省 80）
+  function cols() {
+    return (output.columns && output.columns > 0) ? output.columns : 80
+  }
+
+  // 单字符在终端占用的列宽（CJK/全角 = 2，其余 = 1）
+  function charWidth(ch) {
+    const code = ch.codePointAt(0)
+    if (
+      (code >= 0x1100 && code <= 0x115F) ||
+      (code >= 0x2E80 && code <= 0x303E) ||
+      (code >= 0x3041 && code <= 0x33FF) ||
+      (code >= 0x3400 && code <= 0x4DBF) ||
+      (code >= 0x4E00 && code <= 0x9FFF) ||
+      (code >= 0xA000 && code <= 0xA4CF) ||
+      (code >= 0xAC00 && code <= 0xD7A3) ||
+      (code >= 0xF900 && code <= 0xFAFF) ||
+      (code >= 0xFE30 && code <= 0xFE4F) ||
+      (code >= 0xFF00 && code <= 0xFF60) ||
+      (code >= 0xFFE0 && code <= 0xFFE6)
+    ) return 2
+    return 1
+  }
+
+  // 文本可见列宽（按 CJK 宽字符计数）
+  function visibleWidth(text) {
+    let w = 0
+    for (const ch of text) w += charWidth(ch)
+    return w
+  }
+
+  // 渲染文本占用的终端屏幕行数（考虑自动换行；每逻辑行至少 1 行）
+  function renderedRows(text) {
+    const c = cols()
+    let rows = 0
+    for (const segment of text.split('\n')) {
+      const w = visibleWidth(segment)
+      rows += Math.max(1, Math.ceil(w / c))
+    }
+    return rows
+  }
+
+  // 生成要显示的文本（提示符 + 输入缓冲；换行后按提示符宽度缩进）
+  function displayText() {
+    return PROMPT + inputBuffer.replace(/\n/g, '\n' + ' '.repeat(PROMPT.length))
+  }
+
+  // 清空并重绘整个输入区（保证回显稳定、光标不乱跳）
+  //   - 先把光标移回输入区首行行首
+  //   - 清到屏尾，重绘全部内容
+  //   - 重绘后光标自然停在输入末尾
+  function render() {
+    // 上移到输入区首行（若是多行）；单行时不动
+    if (displayedRows > 1) output.write(`\x1b[${displayedRows - 1}A`)
+    output.write('\r')       // 回到首行行首
+    output.write('\x1b[J')   // 清到屏尾
+
+    const rendered = displayText()
+    output.write(rendered)
+    displayedRows = renderedRows(rendered)
+  }
+
+  function showPrompt() {
+    output.write(PROMPT)
+    displayedRows = 1
+  }
+
+  function submit() {
+    const inputText = inputBuffer
+    inputBuffer = ''
+    skipNextLF = true
+    displayedRows = 0
+    output.write('\n')
+    if (inputText.trim()) {
+      inputHistory.push(inputText)
+      historyIndex = inputHistory.length
+    }
+    if (onSubmit) onSubmit(inputText)
+    else showPrompt()
+  }
+
+  function loadHistory(dir) {
+    if (inputHistory.length === 0) return
+    if (dir === -1) {
+      if (historyIndex <= 0) { historyIndex = 0; inputBuffer = inputHistory[0]; render(); return }
+      historyIndex--
+    } else {
+      if (historyIndex >= inputHistory.length) return
+      historyIndex++
+    }
+    inputBuffer = historyIndex < inputHistory.length ? inputHistory[historyIndex] : ''
+    render()
+  }
+
+  function onKeypress(str, key) {
+    if (!key) return
+
+    // 正在收集单行问题（权限确认 / AskUserQuestion）
+    if (questioning) {
+      if (key.ctrl && key.name === 'c') {
+        output.write('\n')
+        const r = questionResolve; questionResolve = null; questioning = false
+        if (r) r('')
+        return
+      }
+      if (key.name === 'return' || key.name === 'enter') {
+        output.write('\n')
+        const ans = questionBuf; questionBuf = ''
+        const r = questionResolve; questionResolve = null; questioning = false
+        if (r) r(ans)
+        return
+      }
+      if (key.name === 'backspace') {
+        questionBuf = questionBuf.slice(0, -1)
+        output.write('\b \b')
+        return
+      }
+      if (str && key.name !== 'enter') {
+        questionBuf += str
+        output.write(str)
+      }
+      return
+    }
+
+    // Ctrl+C
+    if (key.ctrl && key.name === 'c') {
+      if (inputBuffer) {
+        inputBuffer = ''
+        displayedRows = 0
+        output.write('\n')
+        showPrompt()
+      } else {
+        output.write('\nGoodbye!\n')
+        if (onExit) onExit()
+      }
+      return
+    }
+
+    // ESC 键 — 单独出现（未与后续字符合并）时，标记 escPending，
+    // 下一个 Enter 视为 Alt+Enter → 折行（兼容部分终端把 Alt+Enter 拆成两个事件）
+    if (key.name === 'escape') {
+      escPending = true
+      // 清掉 pending 状态：若后续 300ms 无 Enter 则还原，避免误把普通 Enter 当折行
+      if (escTimer) clearTimeout(escTimer)
+      escTimer = setTimeout(() => { escPending = false }, 400)
+      return
+    }
+
+    // Enter / 换行
+    //
+    // 提交 vs 折行判定：
+    //   - 普通 Enter（\r，无 ctrl/meta）          → 提交整段输入
+    //   - Ctrl+Enter（部分终端发送 ctrl+return）  → 折行（多行输入）
+    //   - Alt+Enter / Esc+Enter（meta+return）    → 折行（跨终端可靠）
+    //   - Ctrl+J / 字面 \n（key.name === enter）  → 折行
+    //   - 某些终端的 Ctrl/Alt+Enter 发送 CSI 序列 \x1b[13~（key.name === 'f3'）→ 折行
+    //
+    // 注意：多数终端按下 Ctrl+Enter 发送的仍是 \r，与普通 Enter 无法区分，
+    // 因此跨终端可靠的多行换行键是 Alt+Enter（Esc+Enter）和 Ctrl+J（\n）。两者都支持。
+    if (key.name === 'return' || key.name === 'enter' || key.name === 'f3') {
+      // 紧跟 ESC 的 Enter → 视为 Alt+Enter，折行
+      if (escPending) {
+        escPending = false
+        if (escTimer) { clearTimeout(escTimer); escTimer = null }
+        inputBuffer += '\n'
+        render()
+        return
+      }
+      // CSI 序列 \x1b[13~（某些终端的 Ctrl/Alt+Enter）→ 折行
+      if (key.name === 'f3') {
+        inputBuffer += '\n'
+        render()
+        return
+      }
+      if (key.name === 'enter') {
+        // 字面换行 \n / Ctrl+J → 折行累积
+        if (skipNextLF) { skipNextLF = false; return } // CRLF 残留 \n
+        inputBuffer += '\n'
+        render()
+      } else {
+        // key.name === 'return'（\r）
+        if (key.ctrl || key.meta) {
+          // Ctrl+Enter 或 Alt+Enter/Esc+Enter → 折行（多行输入）
+          if (skipNextLF) { skipNextLF = false; return }
+          inputBuffer += '\n'
+          render()
+        } else {
+          submit() // 普通 Enter → 提交
+        }
+      }
+      return
+    }
+
+    // 非 Enter 键输入会清除 escPending（ESC 后跟普通字符不是 Alt+Enter）
+    if (escPending && str) {
+      escPending = false
+      if (escTimer) { clearTimeout(escTimer); escTimer = null }
+    }
+
+    // 退格
+    if (key.name === 'backspace') {
+      if (inputBuffer.length > 0) {
+        inputBuffer = inputBuffer.slice(0, -1)
+        render()
+      }
+      return
+    }
+
+    // 方向键上/下：历史
+    if (key.name === 'up') { loadHistory(-1); return }
+    if (key.name === 'down') { loadHistory(1); return }
+
+    // 普通可打印字符（含中文，str 为完整字符）
+    if (str && !key.ctrl && !key.meta) {
+      inputBuffer += str
+      render()
+    }
+  }
+
+  input.on('keypress', onKeypress)
+
+  function ask(q) {
+    return new Promise((resolve) => {
+      output.write('\n' + q + ' ')
+      questioning = true
+      questionResolve = resolve
+      questionBuf = ''
+    })
+  }
+
+  function dispose() {
+    try { input.setRawMode(false) } catch {}
+    input.removeListener('keypress', onKeypress)
+  }
+
+  return { start: showPrompt, showPrompt, ask, dispose }
+}

package/src/core/query-engine.js

@@ -63,6 +63,8 @@ export class QueryEngine {
     this.abortController = null
     this.costTracker = this.config.costTracker || new CostTracker({ model: this.config.model })
     this.tokenBudget = this.config.tokenBudget || null
+    // 最近一次 processMessage 是否已通过流式回调/直写把正文输出（供调用方避免重复打印 response）
+    this.lastStreamed = false
   }
 
   /**
@@ -76,6 +78,7 @@ export class QueryEngine {
     }
     this.state.isRunning = true
     this.state.turnCount++
+    this.lastStreamed = false  // 本轮是否已流式输出正文
     this.abortController = new AbortController()
     const userMsg = new UserMessage(userInput, images)
     this.state.messages.push(userMsg)
@@ -405,6 +408,8 @@ export class QueryEngine {
     try {
       for await (const event of parseStream(response)) {
         if (event.type === 'text') {
+          // 记录已流式输出正文（供调用方避免重复打印最终 response）
+          if (event.text) this.lastStreamed = true
           // 实时输出（有 onDelta 回调时交给调用方，如 VS Code 扩展；否则写终端）
           if (typeof this.config.onDelta === 'function') {
             this.config.onDelta({ type: 'text', text: event.text })