@raolin2025/claude-code-node 2.7.0 → 2.7.2

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 记录回复目标
@@ -568,10 +588,14 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
   let currentSource = 'cli'
   // 等待中的 Telegram 权限确认（resolve 回调）— 远程用户回复 y/n/a 时响应
   let pendingConfirm = null
+  // 等待中的 Telegram AskUserQuestion 回答（resolve 回调）— 远程用户回复任意文本时响应
+  let pendingAskUser = null
   // 最近一次 /models 拉取的模型列表（供 /model <编号> 选择）
   let modelList = []
   // /models 从 Telegram 发出后，等待用户回复编号/名字来选择模型
   let pendingModelSelect = false
+  // 流式输出标志 — onDelta 已实时把回答输出到终端时，不再重复打印完整 response
+  let streamedText = false
 
   // 处理输入行
   // source: 'cli' 来自终端输入, 'telegram' 来自 Telegram
@@ -585,6 +609,13 @@ 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
+      ask(trimmed)
+      return
+    }
     if (source === 'telegram' && pendingConfirm && !trimmed.startsWith('/')) {
       const confirm = pendingConfirm
       pendingConfirm = null
@@ -867,9 +898,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 +940,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 +1066,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) => {
       // 如果已经启用会话全局自动允许，直接通过
@@ -1071,6 +1111,29 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
   }
   engine.config.readline = rl
 
+  // AskUserQuestion 工具回调 — 按当前来源分流：
+  // - Telegram 远程模式：推送问题到 Telegram 并等待远程回复（带超时兜底，避免死锁）
+  // - CLI 本地模式：走本地终端交互（inputCtrl.ask）
+  engine.config.onAskUser = (question) => {
+    if (currentSource === 'telegram' && tgListener?.bot) {
+      const promptText = `❓ ${question}\n\n请直接回复你的回答。`
+      sendTelegram(promptText, null).catch(() => {})
+      return new Promise((resolve) => {
+        // 60 秒内未回复则自动跳过，避免远程提问永久挂起阻塞引擎
+        const timer = setTimeout(() => {
+          if (pendingAskUser === resolve) pendingAskUser = null
+          resolve('(用户未在 60 秒内回答)')
+        }, 60000)
+        pendingAskUser = (val) => {
+          clearTimeout(timer)
+          resolve(val)
+        }
+      })
+    }
+    // CLI 本地模式
+    return askQuestion(`❓ ${question}\n> `)
+  }
+
   // ============================================================
   // Telegram 双向通道启动（可选）
   // 配置了 CC_NODE_CHANNEL_TELEGRAM_TOKEN 或 config 中 telegram 时启用：
@@ -1146,6 +1209,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

@@ -44,6 +44,7 @@ export class QueryEngineConfig {
     this.tokenBudget = options.tokenBudget || null
     this.initialMessages = options.initialMessages || []
     this.onConfirmTool = options.onConfirmTool || null  // ask 模式确认回调
+    this.onAskUser = options.onAskUser || null            // AskUserQuestion 工具回调（宿主按来源分流，避免远程死锁）
     this.readline = options.readline || null              // 用于 AskUserQuestion 工具
     this.onDelta = options.onDelta || null                // 流式增量回调 {type:'text'|'reasoning', text}（供 VS Code 扩展等 UI 消费）
   }
@@ -63,6 +64,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 +79,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 +409,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 })

package/src/tools/ask-user.js

@@ -1,6 +1,13 @@
 /**
  * AskUserQuestion 工具 — 向用户提问
  * 对应原版: src/tools/AskUserQuestionTool/
+ *
+ * 交互策略（按优先级）：
+ * 1. ctx.engine.config.onAskUser — 由宿主（cli.js）注入，按当前来源（CLI/Telegram）分流，
+ *    Telegram 模式推送问题到远程并等待回复（带超时兜底），CLI 模式走本地终端交互。
+ *    这是最完善的路径，避免远程模式下本地阻塞导致引擎死锁。
+ * 2. ctx.readline — 回退：本地 CLI 终端 question。
+ * 3. 都不存在 — 返回提示信息（不阻塞）。
  */
 import { ToolDef } from '../types/index.js'
 
@@ -19,7 +26,13 @@ Use this when you need clarification or user input to proceed.`,
     required: ['question'],
   },
   async (input, ctx) => {
-    // 在 CLI 模式下，通过 ctx 的 readline 接口提问
+    // 优先级 1：宿主注入的 onAskUser（处理 CLI / Telegram 分流，含远程等待与超时兜底）
+    const onAskUser = ctx?.engine?.config?.onAskUser
+    if (typeof onAskUser === 'function') {
+      return onAskUser(input.question)
+    }
+
+    // 优先级 2：CLI 模式，通过 readline 接口提问
     if (ctx?.readline) {
       return new Promise((resolve) => {
         ctx.readline.question(`\n❓ ${input.question}\n> `, (answer) => {
@@ -27,7 +40,8 @@ Use this when you need clarification or user input to proceed.`,
         })
       })
     }
-    // 非 CLI 模式 — 返回提示信息
+
+    // 优先级 3：非 CLI 模式 — 返回提示信息，不阻塞
     return `[AskUserQuestion: ${input.question} (no interactive terminal available)]`
   },
   'always-allow'

package/src/tools/index.js

@@ -11,6 +11,7 @@ import { webFetchTool } from './web-fetch.js'
 import { webSearchTool } from './web-search.js'
 import { askUserTool } from './ask-user.js'
 import { gitTool } from './git-tool.js'
+import { npmPublishTool } from './npm-publish.js'
 // Telegram 工具（替代原 QQ Bot 工具，QQ 通道已放弃）
 import { telegramTools } from './telegram-tools.js'
 
@@ -28,6 +29,7 @@ export const builtinTools = [
   webSearchTool,
   askUserTool,
   gitTool,
+  npmPublishTool,
   ...telegramTools
 ]