@raolin2025/claude-code-node 2.5.2 → 2.6.2

package/README.md

@@ -67,8 +67,25 @@ cc-node --resume session-1747000000000-abc123
 | `--resume` | `-r` | 恢复会话 ID | |
 | `--verbose` | `-v` | 详细输出 | `false` |
 | `--no-stream` | | 禁用流式响应 | `false` |
+| `--stdio` | | **JSON-RPC 服务器模式**（供桥接层/外部客户端接入，见下） | |
 | `--help` | `-h` | 显示帮助 | |
 
+### 🖥️ stdio 服务器模式（--stdio）
+
+以独立子进程形态提供 **JSON-RPC 2.0 over NDJSON** 服务，供外部客户端（VS Code 扩展 / Web / Telegram 等）接入。
+协议完整定义见 cc-node-bridge 项目 `docs/stdio-protocol.md`。
+
+```bash
+# 启动（stdin/stdout 为协议通道，stderr 为日志）
+cc-node --stdio --api-base http://127.0.0.1:11434/v1 --model qwen2.5:0.5b
+
+# 最小请求：initialize
+printf '{"jsonrpc":"2.0","id":1,"method":"initialize"}\n' | cc-node --stdio
+```
+
+能力：流式输出（event/delta）、多模态（images）、remote 工具执行（toolCall 回传）、
+会话管理、abort 中断、config 运行时配置。每个接入客户端建议独立子进程（由桥接层管理）。
+
 ### 权限模式
 
 | 模式 | 说明 |
@@ -206,10 +223,24 @@ cc-node --model kimi-k2-0711 --api-base https://api.moonshot.cn/v1
 # OpenAI
 cc-node --model gpt-4o --api-base https://api.openai.com/v1
 
-# Ollama 本地
-cc-node --model qwen2.5 --api-base http://localhost:11434/v1
+# Ollama / 自建本地服务（Ollama / llama.cpp / vLLM 等）
+# 指向 localhost 或内网地址时【无需 apiKey】，直接可用
+cc-node --api-base http://localhost:11434/v1 --model qwen2.5
+
+# 内网自建服务（局域网 IP，同样无需 apiKey）
+# 将 <内网IP> 替换为你的服务器地址，如 192.168.x.x
+cc-node --api-base http://<内网IP>:11434/v1 --model qwen3.6:27b
+
+# 未指定模型 → 自动拉取服务端 /models 列表供交互选择
+cc-node --api-base http://localhost:11434/v1
 ```
 
+> 💡 **自建本地服务支持**：cc-node 会自动识别 apiBase 指向本地/内网
+> （`localhost`、回环、`192.168.x` / `10.x` / `172.16-31.x` 私有段、`.local` 域名）
+> 的自建 LLM 服务（Ollama、llama.cpp、vLLM 等 OpenAI 兼容端点），
+> 此类服务**无需 apiKey 也能正常调用**，且不会强制附加 `Bearer undefined` 头。
+> 云端厂商（DeepSeek/OpenAI/Kimi 等）仍需 apiKey。
+
 [![npm version](https://img.shields.io/npm/v/@raolin2025/claude-code-node.svg)](https://www.npmjs.com/package/@raolin2025/claude-code-node) [![GitHub](https://img.shields.io/badge/GitHub-bg1avd%2Fclaude--code--node-blue)](https://github.com/bg1avd/claude-code-node) [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 ---
 

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@raolin2025/claude-code-node",
-  "version": "2.5.2",
+  "version": "2.6.2",
   "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/index.js",
+  "main": "src/core/index.js",
   "bin": {
     "cc-node": "src/index.js",
     "cc-notify": "src/channel/notify-daemon.js"

package/src/__tests__/llm-server.test.js

@@ -0,0 +1,62 @@
+/**
+ * llm-server 单元测试
+ *
+ * 覆盖 isLocalLlmServer / isLocalHostname / buildAuthHeaders
+ * 用于验证自建本地 LLM 服务（Ollama / llama.cpp / vLLM）识别逻辑
+ */
+
+import { test, describe } from 'node:test'
+import assert from 'node:assert'
+
+import { isLocalLlmServer, isLocalHostname, buildAuthHeaders } from '../utils/llm-server.js'
+
+describe('isLocalHostname', () => {
+  const localCases = ['localhost', '127.0.0.1', '192.168.1.50', '10.0.0.5', '172.20.1.1',
+    '172.16.1.1', '172.31.255.255', '169.254.1.1', 'myhost.local', 'server.lan', '::1', 'fc00::1']
+  localCases.forEach(h => {
+    test(`应识别为本地: ${h}`, () => assert.strictEqual(isLocalHostname(h), true))
+  })
+
+  // 172.5 不在私有段（172.16-31）
+  const nonLocalCases = ['172.5.1.1', '8.8.8.8', '114.114.114.114', 'api.deepseek.com', 'example.com']
+  nonLocalCases.forEach(h => {
+    test(`不应识别为本地: ${h}`, () => assert.strictEqual(isLocalHostname(h), false))
+  })
+})
+
+describe('isLocalLlmServer', () => {
+  test('Ollama 本机', () => assert.strictEqual(isLocalLlmServer('http://localhost:11434/v1'), true))
+  test('Ollama 回环', () => assert.strictEqual(isLocalLlmServer('http://127.0.0.1:11434/v1'), true))
+  test('Ollama 内网', () => assert.strictEqual(isLocalLlmServer('http://192.168.1.50:11434/v1'), true))
+  test('vLLM 内网 10.x', () => assert.strictEqual(isLocalLlmServer('http://10.0.0.5:8000/v1'), true))
+  test('llama.cpp 内网 172.x', () => assert.strictEqual(isLocalLlmServer('http://172.20.1.1:8000/v1'), true))
+  test('无端口内网', () => assert.strictEqual(isLocalLlmServer('http://192.168.1.50/v1'), true))
+  test('.local 域名', () => assert.strictEqual(isLocalLlmServer('http://myhost.local:11434/v1'), true))
+  test('无 /v1 前缀也可', () => assert.strictEqual(isLocalLlmServer('http://192.168.1.50:11434'), true))
+
+  test('DeepSeek 云端', () => assert.strictEqual(isLocalLlmServer('https://api.deepseek.com/v1'), false))
+  test('OpenAI 云端', () => assert.strictEqual(isLocalLlmServer('https://api.openai.com/v1'), false))
+  test('通义云端', () => assert.strictEqual(isLocalLlmServer('https://dashscope.aliyuncs.com/v1'), false))
+  test('公网 IP', () => assert.strictEqual(isLocalLlmServer('http://114.114.114.114:11434/v1'), false))
+  test('空值', () => assert.strictEqual(isLocalLlmServer(''), false))
+})
+
+describe('buildAuthHeaders', () => {
+  test('本地服务 + 有 key → 带 Bearer', () => {
+    assert.deepStrictEqual(buildAuthHeaders('http://192.168.1.50:11434/v1', 'secret'),
+      { 'Authorization': 'Bearer secret' })
+  })
+  test('本地服务 + 无 key → 空对象(不带Authorization)', () => {
+    assert.deepStrictEqual(buildAuthHeaders('http://192.168.1.50:11434/v1', ''), {})
+  })
+  test('云端 + 有 key → 带 Bearer', () => {
+    assert.deepStrictEqual(buildAuthHeaders('https://api.deepseek.com/v1', 'sk-x'),
+      { 'Authorization': 'Bearer sk-x' })
+  })
+  test('云端 + 无 key → undefined', () => {
+    assert.strictEqual(buildAuthHeaders('https://api.deepseek.com/v1', ''), undefined)
+  })
+  test('空 apiBase + 无 key → undefined', () => {
+    assert.strictEqual(buildAuthHeaders('', ''), undefined)
+  })
+})

package/src/channel/notify-daemon.js

@@ -26,6 +26,7 @@ import {
   mkdirSync, openSync, closeSync,
 } from 'node:fs'
 import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
 import { homedir } from 'node:os'
 import { spawn, execSync } from 'node:child_process'
 import { createConnection } from 'node:net'
@@ -181,12 +182,36 @@ function sendToExistingNode(socketPath, text) {
 function spawnNewNode(ccNodePath, text) {
   return new Promise((resolve) => {
     const timeout = 180000  // 3分钟超时
+    // 用 let 在 setTimeout 之前声明 child，避免 TDZ / 时序问题导致 "child is not defined"
+    let child = null
+    let finished = false
+    const finish = (val) => {
+      if (finished) return
+      finished = true
+      if (timer) { clearTimeout(timer); timer = null }
+      resolve(val)
+    }
     let timer = setTimeout(() => {
-      child.kill()
-      resolve({ type: 'reply', text: '⏰ 执行超时（3 分钟）' })
+      try { if (child && child.kill) child.kill() } catch {}
+      finish({ type: 'reply', text: '⏰ 执行超时（3 分钟）' })
     }, timeout)
     try {
-      const child = spawn(ccNodePath, [text], {
+      // 一次性模式必须显式传 --api-key / --api-base / --model，
+      // 因为 cc-node 的 cli.js 只从命令行参数或 config 读取 apiKey，不读 LLM_API_KEY 环境变量。
+      // 注意：cc-node 的 parseArgs 在遇到第一个非 '-' 参数（prompt）后会跳过后续选项，
+      // 所以选项必须放在 prompt 之前。
+      const args = []
+      const apiKey = process.env.LLM_API_KEY || process.env.DEEPSEEK_API_KEY || process.env.OPENAI_API_KEY || process.env.QWEN_API_KEY || process.env.GLM_API_KEY || process.env.KIMI_API_KEY || ''
+      const apiBase = process.env.LLM_API_BASE || ''
+      // 仅在显式指定时传 --model，否则让 cli.js 使用默认模型，避免硬编码不存在的模型名导致一次性节点失败
+      const model = process.env.CC_NODE_ONESHOT_MODEL || ''
+      if (apiKey) args.push('--api-key', apiKey)
+      if (apiBase) args.push('--api-base', apiBase)
+      if (model) args.push('--model', model)
+      args.push('--no-stream')
+      args.push(text)
+
+      child = spawn(ccNodePath, args, {
         stdio: ['pipe', 'pipe', 'pipe'],
         env: { ...process.env, CC_NODE_ONESHOT: '1' },
         timeout,
@@ -196,25 +221,19 @@ function spawnNewNode(ccNodePath, text) {
       child.stdout.on('data', (d) => (stdout += d.toString()))
       child.stderr.on('data', (d) => (stderr += d.toString()))
       child.on('close', (code) => {
-        clearTimeout(timer)
-        timer = null
         if (stdout.trim()) {
-          resolve({ type: 'reply', text: stdout.trim().slice(0, 4000) })
+          finish({ type: 'reply', text: stdout.trim().slice(0, 4000) })
         } else if (stderr.trim()) {
-          resolve({ type: 'reply', text: `❌ Error: ${stderr.trim().slice(0, 1000)}` })
+          finish({ type: 'reply', text: `❌ Error: ${stderr.trim().slice(0, 1000)}` })
         } else {
-          resolve({ type: 'reply', text: `(completed with code ${code})` })
+          finish({ type: 'reply', text: `(completed with code ${code})` })
         }
       })
       child.on('error', (e) => {
-        clearTimeout(timer)
-        timer = null
-        resolve({ type: 'reply', text: `❌ Failed: ${e.message}` })
+        finish({ type: 'reply', text: `❌ Failed: ${e.message}` })
       })
     } catch (e) {
-      clearTimeout(timer)
-      timer = null
-      resolve({ type: 'reply', text: `❌ Failed: ${e.message}` })
+      finish({ type: 'reply', text: `❌ Failed: ${e.message}` })
     }
   })
 }
@@ -225,6 +244,11 @@ async function routeMessage(text, config) {
     log(`[route] cc-node running → forwarding via socket`)
     try {
       const reply = await sendToExistingNode(nodeInfo.socketPath, text)
+      // 如果 socket 返回的是错误类型（如"引擎正在运行中"），回退到一次性模式
+      if (reply && reply.type === 'error') {
+        log(`[route] socket returned error (${reply.text}) → spawning new one-shot node`)
+        return (await spawnNewNode(config.ccNodePath, text)).text
+      }
       return reply.text || JSON.stringify(reply)
     } catch (e) {
       log(`[route] socket forward failed: ${e.message} → spawning new`)
@@ -821,7 +845,70 @@ async function main() {
   setInterval(() => {}, 60000)
 }
 
-main().catch((err) => {
-  console.error('Fatal error:', err.message)
-  process.exit(1)
-})
+// 仅当 notify-daemon.js 作为主入口直接运行时才启动守护进程。
+// 被 cli.js 通过 import() 引入（--with-notify 模式）时，只导出 startBuiltinListeners，
+// 避免 import 副作用重复启动 HTTP 服务 / QQ 监听器 / PID 文件。
+const isMainEntry = (() => {
+  try {
+    return process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href
+  } catch {
+    return false
+  }
+})()
+
+if (isMainEntry) {
+  main().catch((err) => {
+    console.error('Fatal error:', err.message)
+    process.exit(1)
+  })
+}
+
+// ============================================================
+// --with-notify: 内置监听器（由 cli.js 调用，无需 fork 新进程）
+// ============================================================
+
+/**
+ * 在 cc-node 主进程中启动频道监听器（Telegram），
+ * 替代外部 bash 脚本启动 cc-notify 的方式。
+ * 跨平台兼容 — 不依赖 bash / nohup / PID 文件。
+ *
+ * @param {object} opts
+ * @param {object} opts.channels - 频道配置对象
+ * @param {string|null} opts.defaultChannel - 默认频道
+ * @param {function} opts.onMessage - 消息回调 (msg) => void
+ * @returns {Promise<{tgListener: object|null, stop: function}>}
+ */
+export async function startBuiltinListeners(opts = {}) {
+  const { channels = {}, defaultChannel = null, onMessage } = opts
+
+  const config = {
+    channels,
+    defaultChannel: defaultChannel || process.env.CC_NODE_CHANNEL_DEFAULT || null,
+  }
+
+  let tgListener = null
+
+  // 启动 Telegram 监听器
+  if (config.channels.telegram?.token) {
+    try {
+      const { TelegramListener } = await import('./tg-listener.js')
+      tgListener = new TelegramListener(config)
+      if (tgListener.bot) {
+        tgListener.start(async (msg) => {
+          msg.channel = 'telegram'
+          await onMessage(msg)
+        }).catch(e => console.error(`[builtin-notify] TG listener error: ${e.message}`))
+        console.log(`[builtin-notify] ✅ Telegram listener started`)
+      }
+    } catch (e) {
+      console.error(`[builtin-notify] TG init failed: ${e.message}`)
+    }
+  }
+
+  return {
+    tgListener,
+    stop() {
+      tgListener?.stop()
+    },
+  }
+}

package/src/channel/qqbot-listener.js

@@ -269,13 +269,9 @@ export class QQBot {
   }
 
   async _getWSURL() {
-    const token = await this._t()
-    const res = await fetch(`${API_BASE}/websocket`, {
-      headers: { Authorization: `QQBot ${token}` },
-    })
-    if (!res.ok) throw new Error(`WS URL ${res.status}`)
-    const data = await res.json()
-    return data.url
+    // QQ Bot API v2 的 /websocket 端点需要 WebSocket 升级请求，不能用 HTTP fetch
+    // 直接使用固定的 WebSocket URL
+    return 'wss://api.sgroup.qq.com/websocket'
   }
 
   _handleWS(msg) {

package/src/channel/tg-listener.js

@@ -91,7 +91,7 @@ class RateLimiter {
 // Telegram Bot 客户端
 // ============================================================
 
-class TelegramBotClient {
+export class TelegramBotClient {
   constructor(token, opts = {}) {
     this.token = token
     this.apiBase = opts.apiBase || API_BASE(token)

package/src/channel/tg-proxy.js

@@ -35,11 +35,14 @@ export function socks5Connect(proxyHost, proxyPort, targetHost, targetPort, opts
 
     socket.once('connect', async () => {
       try {
+        // 创建持久的字节缓冲读取器，避免多次 readBytes 丢失多余字节
+        const reader = createByteReader(socket)
+
         // Step 1: 握手 — 协商认证方式
         const authMethods = opts.username ? [0x00, 0x02] : [0x00]  // 无认证 + 用户名密码
         socket.write(Buffer.from([0x05, authMethods.length, ...authMethods]))
 
-        const handshake = await readBytes(socket, 2)
+        const handshake = await reader.read(2)
         if (handshake[0] !== 0x05) {
           throw new Error('SOCKS5: 版本不匹配')
         }
@@ -51,7 +54,7 @@ export function socks5Connect(proxyHost, proxyPort, targetHost, targetPort, opts
           const p = Buffer.from(opts.password, 'utf8')
           const authReq = Buffer.from([0x01, u.length, ...u, p.length, ...p])
           socket.write(authReq)
-          const authResp = await readBytes(socket, 2)
+          const authResp = await reader.read(2)
           if (authResp[1] !== 0x00) throw new Error('SOCKS5: 认证失败')
         } else if (handshake[1] !== 0x00) {
           throw new Error('SOCKS5: 代理不支持不需要的认证方式')
@@ -72,7 +75,7 @@ export function socks5Connect(proxyHost, proxyPort, targetHost, targetPort, opts
         const connectReq = Buffer.from([0x05, 0x01, 0x00, hostType, ...addr, ...portBuf])
         socket.write(connectReq)
 
-        const connectResp = await readBytes(socket, 4)
+        const connectResp = await reader.read(4)
         if (connectResp[0] !== 0x05 || connectResp[1] !== 0x00) {
           const errors = { 0x01: '通用错误', 0x02: '不允许', 0x03: '网络不可达', 0x04: '主机不可达', 0x05: '连接被拒', 0x06: 'TTL超时', 0x07: '命令不支持', 0x08: '地址类型不支持' }
           throw new Error(`SOCKS5: 连接失败 — ${errors[connectResp[1]] || `错误码 ${connectResp[1]}`}`)
@@ -80,11 +83,14 @@ export function socks5Connect(proxyHost, proxyPort, targetHost, targetPort, opts
 
         // 读取剩余响应包头（根据地址类型）
         const addrType = connectResp[3]
-        if (addrType === 0x01) await readBytes(socket, 6)  // IPv4 + port
+        if (addrType === 0x01) await reader.read(6)  // IPv4 + port
         else if (addrType === 0x03) {
-          const len = (await readBytes(socket, 1))[0]
-          await readBytes(socket, len + 2)  // hostname + port
-        } else if (addrType === 0x04) await readBytes(socket, 18)  // IPv6 + port
+          const len = (await reader.read(1))[0]
+          await reader.read(len + 2)  // hostname + port
+        } else if (addrType === 0x04) await reader.read(18)  // IPv6 + port
+
+        // 清理 reader 的监听器，确保隧道建立后数据完整交给调用方
+        reader.detach()
 
         clearTimeout(timeout)
         resolve(socket)
@@ -102,6 +108,85 @@ export function socks5Connect(proxyHost, proxyPort, targetHost, targetPort, opts
   })
 }
 
+/**
+ * 创建持久的字节缓冲读取器。
+ *
+ * 原实现每次 readBytes 都重新注册 'data' 监听器，当 SOCKS5 代理
+ * 一次性返回多段响应时，首个 readBytes 会消费掉多余字节并丢弃，
+ * 导致后续 readBytes 永远等待，最终触发超时。此读取器用统一的
+ * 内部缓冲队列累积所有到达的字节，保证多次读取之间字节不丢失。
+ *
+ * @param {import('node:net').Socket} socket
+ */
+function createByteReader(socket) {
+  let buffer = Buffer.alloc(0)
+  let closed = false
+  const waiters = []
+
+  const onData = (chunk) => {
+    buffer = Buffer.concat([buffer, chunk])
+    flush()
+  }
+
+  const onError = () => {
+    closed = true
+    flush()
+  }
+
+  const onEnd = () => {
+    closed = true
+    flush()
+  }
+
+  socket.on('data', onData)
+  socket.once('error', onError)
+  socket.once('end', onEnd)
+
+  function flush() {
+    while (waiters.length > 0) {
+      const waiter = waiters[0]
+      if (buffer.length >= waiter.n) {
+        waiters.shift()
+        const out = buffer.slice(0, waiter.n)
+        buffer = buffer.slice(waiter.n)
+        waiter.resolve(out)
+      } else {
+        break
+      }
+    }
+    // 所有等待者都已满足，但连接已关闭且字节不足 -> 报错
+    if (closed && waiters.length > 0 && buffer.length === 0) {
+      const waiter = waiters.shift()
+      waiter.reject(new Error('SOCKS5: 连接意外关闭'))
+    }
+  }
+
+  return {
+    read(n) {
+      return new Promise((resolve, reject) => {
+        if (n === 0) return resolve(Buffer.alloc(0))
+        // 先检查已有缓冲
+        if (buffer.length >= n) {
+          const out = buffer.slice(0, n)
+          buffer = buffer.slice(n)
+          return resolve(out)
+        }
+        // 连接已关闭且缓冲不足
+        if (closed) {
+          return reject(new Error('SOCKS5: 连接意外关闭'))
+        }
+        waiters.push({ n, resolve, reject })
+        flush()
+      })
+    },
+    detach() {
+      socket.removeListener('data', onData)
+      socket.removeListener('error', onError)
+      socket.removeListener('end', onEnd)
+    },
+  }
+}
+
 /**
  * 创建通过 SOCKS5 代理的 TLS 连接
  *
@@ -171,8 +256,18 @@ export async function fetchViaSocks5(url, options = {}, proxyAddr) {
   // 构建 HTTP 请求
   const path = parsedUrl.pathname + parsedUrl.search
   const headers = Object.entries(options.headers || {}).map(([k, v]) => `${k}: ${v}`).join('\r\n')
+  // body 必须是字符串/Buffer；FormData/Blob 等 multipart 正文当前不支持
+  // （仅用于 Telegram Bot API 的 JSON 请求），遇到非字符串 body 给出清晰错误而非崩溃。
   const body = options.body || ''
-  const req = `${options.method || 'GET'} ${path} HTTP/1.1\r\nHost: ${host}\r\n${headers ? headers + '\r\n' : ''}Content-Length: ${body.length}\r\nConnection: close\r\n\r\n${body}`
+  if (typeof body !== 'string' && !Buffer.isBuffer(body)) {
+    socket.destroy()
+    return Promise.reject(new Error('fetchViaSocks5: 仅支持 string/Buffer 请求体（不支持 FormData 等 multipart）'))
+  }
+  // 注意：Content-Length 必须用 UTF-8 字节数，不能用字符串字符数，
+  // 否则包含中文/emoji 时会导致服务器读不完整请求体。
+  const bodyLen = Buffer.byteLength(body, 'utf8')
+  const head = `${options.method || 'GET'} ${path} HTTP/1.1\r\nHost: ${host}\r\n${headers ? headers + '\r\n' : ''}Content-Length: ${bodyLen}\r\nConnection: close\r\n\r\n`
+  const reqBuf = Buffer.concat([Buffer.from(head, 'utf8'), Buffer.isBuffer(body) ? body : Buffer.from(body, 'utf8')])
 
   return new Promise((resolve, reject) => {
     let responseData = ''
@@ -181,7 +276,7 @@ export async function fetchViaSocks5(url, options = {}, proxyAddr) {
       reject(new Error('HTTP request timeout'))
     }, 30000)
 
-    socket.write(req)
+    socket.write(reqBuf)
     socket.on('data', (chunk) => {
       responseData += chunk.toString()
     })
@@ -211,26 +306,4 @@ export async function fetchViaSocks5(url, options = {}, proxyAddr) {
       reject(err)
     })
   })
-}
-
-/** 从 socket 读取指定字节数 */
-function readBytes(socket, n) {
-  return new Promise((resolve, reject) => {
-    if (n === 0) return resolve(Buffer.alloc(0))
-    let buf = Buffer.alloc(0)
-    const onData = (chunk) => {
-      buf = Buffer.concat([buf, chunk])
-      if (buf.length >= n) {
-        socket.removeListener('data', onData)
-        resolve(buf.slice(0, n))
-      }
-    }
-    socket.on('data', onData)
-    socket.once('error', reject)
-    // 处理已经缓冲的数据
-    if (buf.length >= n) {
-      socket.removeListener('data', onData)
-      resolve(buf.slice(0, n))
-    }
-  })
-}
+}