@raolin2025/claude-code-node 2.6.1 → 2.6.3

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 运行时配置。每个接入客户端建议独立子进程（由桥接层管理）。
+
 ### 权限模式
 
 | 模式 | 说明 |

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@raolin2025/claude-code-node",
-  "version": "2.6.1",
+  "version": "2.6.3",
   "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/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))
-    }
-  })
-}
+}

package/src/core/cli.js

@@ -18,6 +18,8 @@ import { CostTracker } from './cost-tracker.js'
 import { autoCompact } from './compact.js'
 import { isLocalLlmServer } from '../utils/index.js'
 import { SOCK_DIR, SOCK_PATH, CC_NODE_PID } from './paths.js'
+import { TelegramListener } from '../channel/tg-listener.js'
+import { fetchViaSocks5 } from '../channel/tg-proxy.js'
 
 // ============================================================
 // Unix Socket — 让 cc-notify 能发现 cc-node
@@ -96,11 +98,19 @@ function startSocketServer(engine, session, sessionManager, channelManager, verb
 
   server.listen(SOCK_PATH, () => {
     // v1.1 修复: socket 文件权限 0600（仅所有者可读写），阻止其他用户连接
-    try { chmodSync(SOCK_PATH, 0o600) } catch {}
+    // Windows named pipe 不支持 chmod，跳过
+    try { if (!process.platform.startsWith('win')) chmodSync(SOCK_PATH, 0o600) } catch {}
     // 写 PID 文件（权限 0644）
     writeFileSync(CC_NODE_PID, String(process.pid), { mode: 0o644 })
   })
 
+  // 关键修复: 监听 socket 失败时绝不能崩溃（如 Windows 权限 / 端口占用）。
+  // 否则触发 Unhandled 'error' event 导致整个 cc-node 进程退出。
+  server.on('error', (err) => {
+    console.error(`⚠️  Socket 监听失败（${err.code || err.message}）— cc-notify 远程转发将不可用，但 REPL 仍可正常使用。`)
+    console.error(`   Path: ${SOCK_PATH}`)
+  })
+
   // 退出时清理
   const cleanup = () => {
     try { unlinkSync(SOCK_PATH) } catch {}
@@ -315,7 +325,7 @@ const DETAILED_HELP = {
 
   compact: "/compact\n  Manually trigger context compression.\n  Compresses the conversation history to fit within the token budget.\n  Keeps recent turns intact, compresses older ones.\n\n  Typically triggered automatically at 80% budget usage.",
 
-  cd:      "/cd <path>\n  Change the working directory of cc-node.\n  Affects all subsequent tool executions (Bash, Read, Write, etc.).\n\n  Without path: show the current working directory.\n\n  Example: /cd /home/raolin/projects\n  Example: /cd ..",
+  cd:      "/cd <path>\n  Change the working directory of cc-node.\n  Affects all subsequent tool executions (Bash, Read, Write, etc.).\n\n  Without path: show the current working directory.\n\n  Example: /cd /home/yourname/projects\n  Example: /cd ..",
 
   allow:   "/allow [tool|all|reset]\n  Manage tool permissions for this session.\n\n  Options:\n    <tool>   — allow a specific tool (e.g. Bash, Write, Read)\n    all      — automatically allow ALL remaining tools for this session\n    reset    — reset to ask mode (ask for each tool)\n    (no arg) — same as /allow all\n\n  When asked to confirm a tool, you can also type:\n    y — allow this once\n    a — allow all for the rest of the session\n\n  Example: /allow Bash\n  Example: /allow all\n  Example: /allow reset",
 
@@ -352,6 +362,8 @@ function parseArgs(argv) {
       case '--resume': case '-r': args.resume = argv[++i]; break
       case '--verbose': case '-v': args.verbose = true; break
       case '--no-stream': args.noStream = true; break
+      case '--stdio': args.stdio = true; break
+      case '--with-notify': args.withNotify = true; break
       case '--version':
         const pkg = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'))
         console.log(pkg.version)
@@ -370,6 +382,8 @@ Options:
   --version                 Show version
   -v, --verbose             Verbose mode
   --no-stream               Disable streaming
+  --with-notify             Start built-in channel listener (Telegram)
+                            (replaces cc-notify daemon — no external script needed)
   -h, --help                Show this help
 
 Environment variables:
@@ -405,6 +419,14 @@ Unix Socket (for cc-notify):
 export async function main() {
   const cliArgs = parseArgs(process.argv)
 
+  // P1: stdio 服务器模式（JSON-RPC 2.0 over NDJSON，供桥接层/外部客户端接入）
+  if (cliArgs.stdio) {
+    const { StdioServer } = await import('../stdio/server.js')
+    const server = new StdioServer({ cliArgs })
+    server.start()
+    return
+  }
+
   const config = new Config()
   await config.load(process.cwd())
 
@@ -566,8 +588,14 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
     rl.prompt()
   }
 
+  // Telegram 双向通道（可选）：tgListener 监听 Telegram 消息，tgChatId 记录回复目标
+  let tgListener = null
+  let tgChatId = null
+  let tgReplyTarget = null
+
   // 处理输入行
-  async function processInputLine(input) {
+  // source: 'cli' 来自终端输入, 'telegram' 来自 Telegram
+  async function processInputLine(input, source = 'cli', tgChatId = null) {
     const trimmed = input.trim()
     if (!trimmed) { showPrompt(); return }
 
@@ -800,8 +828,15 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
       if (engine.costTracker && engine.costTracker.totalApiCalls > 0) {
         console.log(engine.costTracker.formatShort())
       }
+      // 将 AI 回复同步发送到 Telegram（镜像 CLI 显示）
+      if (tgListener?.bot && result?.response) {
+        await sendTelegram(result.response, tgChatId || null)
+      }
     } catch (err) {
       console.error(`\nError: ${err.message}\n`)
+      if (tgListener?.bot) {
+        await sendTelegram(`❌ Error: ${err.message}`, tgChatId || null)
+      }
       if (channelManager.list().length > 0) {
         await channelManager.sendTemplate('error', {
           task: input.slice(0, 80), error: err.message.slice(0, 200),
@@ -811,6 +846,33 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
     showPrompt()
   }
 
+  // 发送文本到 Telegram（支持分片，>4000 字符自动拆分）
+  async function sendTelegram(text, chatId = null) {
+    try {
+      const target = chatId || tgChatId
+      if (!target) return
+      const MAX_LEN = 4000
+      if (text.length <= MAX_LEN) {
+        await tgListener.bot.sendMessage(target, text, { parseMode: 'HTML' })
+      } else {
+        const parts = []
+        let cur = ''
+        for (const line of text.split('\n')) {
+          if (cur.length + line.length > 3800) { parts.push(cur); cur = line }
+          else { cur += (cur ? '\n' : '') + line }
+        }
+        if (cur) parts.push(cur)
+        for (let i = 0; i < parts.length; i++) {
+          const header = i > 0 ? `📎 (${i + 1}/${parts.length})\n` : ''
+          await tgListener.bot.sendMessage(target, header + parts[i], { parseMode: 'HTML' })
+          await new Promise(r => setTimeout(r, 300))
+        }
+      }
+    } catch (e) {
+      console.error(`[TG] send failed: ${e.message}`)
+    }
+  }
+
   // REPL 主循环 — 由 readline 原生处理回显、退格、行回绕与 Enter 提交
   rl.on('line', (line) => {
     processInputLine(line)
@@ -838,6 +900,63 @@ const systemPrompt = cliArgs.systemPrompt || DEFAULT_SYSTEM_PROMPT
   }
   engine.config.readline = rl
 
+  // ============================================================
+  // Telegram 双向通道启动（可选）
+  // 配置了 CC_NODE_CHANNEL_TELEGRAM_TOKEN 或 config 中 telegram 时启用：
+  //  - CLI 的 AI 回复会同步镜像发送到 Telegram
+  //  - Telegram 消息会作为 REPL 输入，与 CLI 共享同一个引擎和对话记忆
+  // ============================================================
+  const tgToken = process.env.CC_NODE_CHANNEL_TELEGRAM_TOKEN || config.get('channels')?.telegram?.token || ''
+  if (tgToken) {
+    try {
+      tgListener = new TelegramListener({
+        channels: {
+          telegram: {
+            token: tgToken,
+            proxy: process.env.CC_NODE_CHANNEL_TELEGRAM_PROXY || config.get('channels')?.telegram?.proxy || '',
+            apiBase: process.env.CC_NODE_CHANNEL_TELEGRAM_API_BASE || config.get('channels')?.telegram?.apiBase || '',
+          },
+        },
+      })
+      tgListener.start(async (msg) => {
+        // Telegram 消息 → 复用 REPL 引擎处理（共享同一份对话记忆）
+        tgChatId = msg.chatId || tgChatId
+        tgReplyTarget = msg.replyTo || null
+        const text = msg.text || msg.callbackData || ''
+        if (!text) return
+        // 命令由 listener 内部处理，普通消息转给引擎
+        if (!text.startsWith('/')) {
+          await processInputLine(text, 'telegram', msg.chatId)
+        }
+      }).catch(e => console.error(`[TG] listener error: ${e.message}`))
+      console.log(`✅ Telegram channel ready (bot ${tgToken.slice(0, 12)}...)`)
+    } catch (e) {
+      console.error(`[TG] init failed: ${e.message}`)
+    }
+  }
+
+  // ============================================================
+  // --with-notify: 内置频道监听器（替代 cc-notify 守护进程）
+  // 当 cc-node 启动时同时启动 Telegram 监听器，
+  // 无需外部 bash 脚本，跨平台（Windows/Linux/macOS）都能用。
+  // ============================================================
+  if (cliArgs.withNotify) {
+    const { startBuiltinListeners } = await import('../channel/notify-daemon.js')
+    // 启动内部的 notify 监听器（不 fork 新进程，直接在当前进程运行）
+    const builtinNotify = await startBuiltinListeners({
+      channels: config.get('channels') || {},
+      defaultChannel: config.get('defaultChannel') || process.env.CC_NODE_CHANNEL_DEFAULT || null,
+      onMessage: async (msg) => {
+        // 来自外部的消息 → 转发到 REPL 引擎
+        const text = msg.text || ''
+        if (text && !text.startsWith('/')) {
+          await processInputLine(text, msg.channel || 'external', msg.chatId)
+        }
+      },
+    })
+    console.log('📡 Built-in channel listeners started (--with-notify)')
+  }
+
   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/index.js

@@ -1,3 +1,5 @@
+export { UserMessage, AssistantMessage, ToolCall } from "../types/index.js"
+
 /**
  * 核心模块统一导出
  */

package/src/core/paths.js

@@ -3,9 +3,15 @@
  */
 import { join } from 'path'
 import { homedir } from 'os'
+import { platform } from 'process'
+
+const isWindows = platform === 'win32'
 
 export const SOCK_DIR = join(homedir(), '.cc-node')
-export const SOCK_PATH = join(SOCK_DIR, 'repl.sock')
+// Windows 不支持传统 Unix domain socket（会抛 EACCES），改用 named pipe。
+// Unix socket: C:\Users\xxx\.cc-node\repl.sock  → 报错
+// named pipe : \\.\pipe\cc-node                 → 正常
+export const SOCK_PATH = isWindows ? '\\\\.\\pipe\\cc-node' : join(SOCK_DIR, 'repl.sock')
 export const CC_NODE_PID = join(SOCK_DIR, 'cc-node.pid')
 export const CC_NOTIFY_PID = join(SOCK_DIR, 'cc-notify.pid')
 export const CC_NOTIFY_LOG = join(SOCK_DIR, 'cc-notify.log')