@raolin2025/claude-code-node 1.0.0

package/src/core/streaming.js

@@ -0,0 +1,119 @@
+/**
+ * 流式响应处理
+ * OpenAI 兼容 SSE 格式（全行业通用）
+ *
+ * 适用于: DeepSeek / Qwen / GLM / Kimi / Ollama / vLLM / OpenAI / 任何兼容接口
+ */
+
+/**
+ * 解析 SSE 流式响应
+ */
+export async function* parseStream(response) {
+  const reader = response.body.getReader()
+  const decoder = new TextDecoder()
+  let buffer = ''
+  const toolCallBuffers = new Map() // index → { id, name, arguments }
+
+  const result = {
+    content: '',
+    toolCalls: [],
+    usage: { input_tokens: 0, output_tokens: 0 },
+  }
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+
+      buffer += decoder.decode(value, { stream: true })
+      const lines = buffer.split('\n')
+      buffer = lines.pop()
+
+      for (const line of lines) {
+        if (!line.startsWith('data: ')) continue
+        const data = line.slice(6).trim()
+        if (data === '[DONE]') continue
+
+        try {
+          const chunk = JSON.parse(data)
+          const delta = chunk.choices?.[0]?.delta
+
+          if (!delta) continue
+
+          // 文本
+          if (delta.content) {
+            result.content += delta.content
+            yield { type: 'text', text: delta.content }
+          }
+
+          // 工具调用
+          if (delta.tool_calls) {
+            for (const tc of delta.tool_calls) {
+              const idx = tc.index
+              if (!toolCallBuffers.has(idx)) {
+                toolCallBuffers.set(idx, {
+                  id: tc.id || '',
+                  name: tc.function?.name || '',
+                  arguments: '',
+                })
+              }
+              const buf = toolCallBuffers.get(idx)
+              if (tc.id) buf.id = tc.id
+              if (tc.function?.name) buf.name = tc.function.name
+              if (tc.function?.arguments) buf.arguments += tc.function.arguments
+            }
+          }
+
+          // 流结束 — 处理积攒的工具调用
+          if (chunk.choices?.[0]?.finish_reason) {
+            for (const [_, buf] of toolCallBuffers) {
+              let input = {}
+              try { input = JSON.parse(buf.arguments) } catch {}
+              result.toolCalls.push({ id: buf.id, name: buf.name, input })
+              yield { type: 'tool_use', toolCall: { id: buf.id, name: buf.name, input } }
+            }
+          }
+
+          // usage
+          if (chunk.usage) {
+            result.usage.input_tokens = chunk.usage.prompt_tokens || 0
+            result.usage.output_tokens = chunk.usage.completion_tokens || 0
+          }
+        } catch {
+          // 忽略解析错误
+        }
+      }
+    }
+  } finally {
+    reader.releaseLock()
+  }
+
+  yield { type: 'done', result }
+}
+
+/**
+ * 解析非流式响应
+ */
+export function parseNonStreamResponse(data) {
+  const result = { content: '', toolCalls: [], usage: {} }
+  const choice = data.choices?.[0]
+
+  if (choice?.message?.content) {
+    result.content = choice.message.content
+  }
+
+  for (const tc of (choice?.message?.tool_calls || [])) {
+    let input = {}
+    try { input = JSON.parse(tc.function.arguments) } catch {}
+    result.toolCalls.push({ id: tc.id, name: tc.function.name, input })
+  }
+
+  if (data.usage) {
+    result.usage = {
+      input_tokens: data.usage.prompt_tokens,
+      output_tokens: data.usage.completion_tokens,
+    }
+  }
+
+  return result
+}

package/src/core/token-budget.js

@@ -0,0 +1,88 @@
+/**
+ * Token 预算管理
+ * 对应原版: src/query/tokenBudget.ts
+ */
+
+/**
+ * 简单的 token 估算器
+ * 规则：英文 ~4 字符/token，中文 ~1.5 字符/token
+ */
+export function estimateTokens(text) {
+  if (!text) return 0
+  // 统计中文字符
+  const cjkCount = (text.match(/[\u4e00-\u9fff\u3400-\u4dbf]/g) || []).length
+  const nonCjk = text.length - cjkCount
+  return Math.ceil(cjkCount / 1.5 + nonCjk / 4)
+}
+
+export class TokenBudget {
+  constructor(options = {}) {
+    this.maxTokens = options.maxTokens || 200_000
+    this.maxOutputTokens = options.maxOutputTokens || 8192
+    this.reservedForSystem = options.reservedForSystem || 20_000
+    this.reservedForOutput = options.reservedForOutput || 8192
+    this.used = 0
+    this.inputTokens = 0
+    this.outputTokens = 0
+  }
+
+  /** 可用于上下文的最大 token 数 */
+  get availableForContext() {
+    return this.maxTokens - this.reservedForSystem - this.reservedForOutput - this.inputTokens
+  }
+
+  /** 是否还有预算 */
+  get hasBudget() {
+    return this.availableForContext > 1000
+  }
+
+  /** 使用率百分比 */
+  get usagePercent() {
+    return Math.round((this.inputTokens / this.maxTokens) * 100)
+  }
+
+  /** 记录一次 API 调用的 token 使用 */
+  recordUsage(usage) {
+    if (usage.input_tokens) this.inputTokens += usage.input_tokens
+    if (usage.output_tokens) this.outputTokens += usage.output_tokens
+    if (usage.cache_read_input_tokens) this.inputTokens += usage.cache_read_input_tokens
+    this.used = this.inputTokens + this.outputTokens
+  }
+
+  /** 估算消息列表的 token 数 */
+  estimateMessages(messages) {
+    let total = 0
+    for (const msg of messages) {
+      if (typeof msg.content === 'string') {
+        total += estimateTokens(msg.content)
+      } else if (Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block.type === 'text') total += estimateTokens(block.text)
+          else if (block.type === 'tool_result') total += estimateTokens(block.content)
+          else if (block.type === 'tool_use') total += estimateTokens(JSON.stringify(block.input))
+        }
+      }
+      // 每条消息有固定开销
+      total += 10
+    }
+    return total
+  }
+
+  /** 检查是否可以在预算内发送这些消息 */
+  canAfford(messages) {
+    const estimated = this.estimateMessages(messages)
+    return (this.inputTokens + estimated) < (this.maxTokens - this.reservedForOutput)
+  }
+
+  /** 格式化 token 使用情况 */
+  format() {
+    return `Token Budget: ${this.inputTokens.toLocaleString()}/${this.maxTokens.toLocaleString()} (${this.usagePercent}% used) | Output: ${this.outputTokens.toLocaleString()}`
+  }
+
+  /** 重置 */
+  reset() {
+    this.used = 0
+    this.inputTokens = 0
+    this.outputTokens = 0
+  }
+}

package/src/index.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+
+/**
+ * Claude Code — Node.js Edition
+ * 入口文件
+ */
+
+import { main } from './core/cli.js'
+
+main().catch((err) => {
+  console.error('Fatal error:', err.message)
+  process.exit(1)
+})

package/src/mcp/client.js

@@ -0,0 +1,214 @@
+/**
+ * MCP (Model Context Protocol) 客户端
+ * 对应原版: src/services/mcp/
+ * 简化版：支持 stdio 传输，JSON-RPC 2.0
+ */
+import { spawn } from 'child_process'
+
+/**
+ * JSON-RPC 2.0 请求 ID 计数器
+ */
+let requestId = 0
+
+function nextId() {
+  return ++requestId
+}
+
+/**
+ * MCP 客户端 — 通过 stdio 与 MCP 服务器通信
+ */
+export class MCPClient {
+  constructor(serverConfig) {
+    this.config = serverConfig
+    this.process = null
+    this.pending = new Map() // id → { resolve, reject }
+    this.buffer = ''
+    this.tools = []
+    this.resources = []
+  }
+
+  /** 启动 MCP 服务器进程 */
+  async connect() {
+    const { command, args = [], env = {} } = this.config
+
+    this.process = spawn(command, args, {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: { ...process.env, ...env },
+    })
+
+    this.process.stdout.on('data', (data) => {
+      this.buffer += data.toString()
+      this._processBuffer()
+    })
+
+    this.process.stderr.on('data', (data) => {
+      // MCP 服务器日志输出到 stderr
+      if (this.config.debug) {
+        console.error(`[MCP stderr] ${data.toString().trim()}`)
+      }
+    })
+
+    this.process.on('error', (err) => {
+      // 拒绝所有等待中的请求
+      for (const [id, { reject }] of this.pending) {
+        reject(new Error(`MCP server error: ${err.message}`))
+      }
+      this.pending.clear()
+    })
+
+    this.process.on('close', (code) => {
+      for (const [id, { reject }] of this.pending) {
+        reject(new Error(`MCP server exited with code ${code}`))
+      }
+      this.pending.clear()
+    })
+
+    // 初始化握手
+    await this._initialize()
+  }
+
+  /** 初始化协议 */
+  async _initialize() {
+    const result = await this._sendRequest('initialize', {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: {
+        name: 'claude-code-node',
+        version: '1.0.0',
+      },
+    })
+
+    // 发送 initialized 通知
+    this._sendNotification('notifications/initialized', {})
+
+    // 获取工具列表
+    try {
+      const toolsResult = await this._sendRequest('tools/list', {})
+      this.tools = toolsResult?.tools || []
+    } catch {
+      this.tools = []
+    }
+
+    // 获取资源列表
+    try {
+      const resourcesResult = await this._sendRequest('resources/list', {})
+      this.resources = resourcesResult?.resources || []
+    } catch {
+      this.resources = []
+    }
+
+    return result
+  }
+
+  /** 调用 MCP 工具 */
+  async callTool(name, args = {}) {
+    return this._sendRequest('tools/call', {
+      name,
+      arguments: args,
+    })
+  }
+
+  /** 读取 MCP 资源 */
+  async readResource(uri) {
+    return this._sendRequest('resources/read', { uri })
+  }
+
+  /** 发送 JSON-RPC 请求 */
+  _sendRequest(method, params) {
+    return new Promise((resolve, reject) => {
+      const id = nextId()
+      const message = JSON.stringify({
+        jsonrpc: '2.0',
+        id,
+        method,
+        params,
+      })
+
+      this.pending.set(id, { resolve, reject })
+
+      // 每条消息以换行符分隔
+      this.process.stdin.write(message + '\n', (err) => {
+        if (err) {
+          this.pending.delete(id)
+          reject(new Error(`Failed to send message: ${err.message}`))
+        }
+      })
+    })
+  }
+
+  /** 发送 JSON-RPC 通知（无响应） */
+  _sendNotification(method, params) {
+    const message = JSON.stringify({
+      jsonrpc: '2.0',
+      method,
+      params,
+    })
+    this.process.stdin.write(message + '\n')
+  }
+
+  /** 处理接收缓冲区 */
+  _processBuffer() {
+    const lines = this.buffer.split('\n')
+    this.buffer = lines.pop() // 保留不完整的行
+
+    for (const line of lines) {
+      if (!line.trim()) continue
+      try {
+        const message = JSON.parse(line)
+
+        if (message.id && this.pending.has(message.id)) {
+          const { resolve, reject } = this.pending.get(message.id)
+          this.pending.delete(message.id)
+
+          if (message.error) {
+            reject(new Error(message.error.message || 'MCP error'))
+          } else {
+            resolve(message.result)
+          }
+        }
+        // 忽略通知和未知消息
+      } catch {
+        // 忽略解析错误
+      }
+    }
+  }
+
+  /** 关闭连接 */
+  async close() {
+    if (this.process) {
+      try {
+        await this._sendRequest('shutdown', {})
+      } catch {
+        // 忽略关闭错误
+      }
+      this.process.kill('SIGTERM')
+      this.process = null
+    }
+  }
+
+  /** 获取工具定义 — tool_use 格式（兼容多种 API） */
+  getToolDefinitions() {
+    return this.tools.map(t => ({
+      name: t.name,
+      description: t.description,
+      input_schema: t.inputSchema,
+    }))
+  }
+
+  /** @deprecated 使用 getToolDefinitions() 替代 */
+  getAnthropicTools() {
+    return this.getToolDefinitions()
+  }
+
+  /** 获取工具定义（适配 OpenAI function-calling 格式） */
+  getOpenAITools() {
+    return this.tools.map(t => ({
+      type: 'function',
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.inputSchema,
+      },
+    }))
+  }
+}

package/src/mcp/index.js

@@ -0,0 +1,5 @@
+/**
+ * MCP 模块统一导出
+ */
+export { MCPClient } from './client.js'
+export { MCPRegistry } from './registry.js'

package/src/mcp/registry.js

@@ -0,0 +1,176 @@
+/**
+ * MCP 服务器注册表
+ * 对应原版: src/services/mcp/mcpServerApproval.tsx + 配置加载
+ */
+import { readFile, writeFile, mkdir } from 'fs/promises'
+import { resolve, join } from 'path'
+import { existsSync } from 'fs'
+import { MCPClient } from './client.js'
+
+/**
+ * MCP 服务器注册表 — 管理多个 MCP 服务器连接
+ */
+export class MCPRegistry {
+  constructor(options = {}) {
+    this.configPath = options.configPath || null
+    this.servers = new Map() // name → MCPClient
+    this.serverConfigs = new Map() // name → config
+  }
+
+  /** 从配置文件加载 MCP 服务器列表 */
+  async loadFromConfig(configPath) {
+    this.configPath = configPath
+    try {
+      const raw = await readFile(configPath, 'utf-8')
+      const config = JSON.parse(raw)
+      const mcpServers = config.mcpServers || {}
+
+      for (const [name, serverConfig] of Object.entries(mcpServers)) {
+        this.serverConfigs.set(name, serverConfig)
+      }
+    } catch {
+      // 配置文件不存在 — 空注册表
+    }
+  }
+
+  /** 注册一个 MCP 服务器 */
+  register(name, config) {
+    this.serverConfigs.set(name, config)
+  }
+
+  /** 注销一个 MCP 服务器 */
+  unregister(name) {
+    this.serverConfigs.delete(name)
+    const client = this.servers.get(name)
+    if (client) {
+      client.close()
+      this.servers.delete(name)
+    }
+  }
+
+  /** 连接指定服务器 */
+  async connect(name) {
+    const config = this.serverConfigs.get(name)
+    if (!config) {
+      throw new Error(`MCP server not registered: ${name}`)
+    }
+
+    const client = new MCPClient(config)
+    await client.connect()
+    this.servers.set(name, client)
+    return client
+  }
+
+  /** 连接所有注册的服务器 */
+  async connectAll() {
+    const results = {}
+    for (const [name, _] of this.serverConfigs) {
+      try {
+        results[name] = await this.connect(name)
+      } catch (err) {
+        results[name] = { error: err.message }
+      }
+    }
+    return results
+  }
+
+  /** 关闭所有连接 */
+  async closeAll() {
+    const promises = []
+    for (const [name, client] of this.servers) {
+      promises.push(
+        client.close().catch(() => {})
+      )
+    }
+    await Promise.all(promises)
+    this.servers.clear()
+  }
+
+  /** 获取所有已连接服务器的工具列表 */
+  getAllTools() {
+    const tools = []
+    for (const [name, client] of this.servers) {
+      for (const tool of client.tools) {
+        tools.push({
+          ...tool,
+          _mcpServer: name, // 标记来源
+        })
+      }
+    }
+    return tools
+  }
+
+  /** 获取所有已连接服务器的资源列表 */
+  getAllResources() {
+    const resources = []
+    for (const [name, client] of this.servers) {
+      for (const resource of client.resources) {
+        resources.push({
+          ...resource,
+          _mcpServer: name,
+        })
+      }
+    }
+    return resources
+  }
+
+  /** 调用指定服务器上的工具 */
+  async callTool(serverName, toolName, args) {
+    const client = this.servers.get(serverName)
+    if (!client) {
+      throw new Error(`MCP server not connected: ${serverName}`)
+    }
+    return client.callTool(toolName, args)
+  }
+
+  /** 通过工具名查找并调用（自动路由到正确的服务器） */
+  async callToolByName(toolName, args) {
+    for (const [name, client] of this.servers) {
+      const tool = client.tools.find(t => t.name === toolName)
+      if (tool) {
+        return client.callTool(toolName, args)
+      }
+    }
+    throw new Error(`Tool not found on any connected MCP server: ${toolName}`)
+  }
+
+  /** 读取指定服务器上的资源 */
+  async readResource(serverName, uri) {
+    const client = this.servers.get(serverName)
+    if (!client) {
+      throw new Error(`MCP server not connected: ${serverName}`)
+    }
+    return client.readResource(uri)
+  }
+
+  /** 保存当前配置到文件 */
+  async saveConfig(configPath) {
+    const path = configPath || this.configPath
+    if (!path) throw new Error('No config path specified')
+
+    const mcpServers = {}
+    for (const [name, config] of this.serverConfigs) {
+      mcpServers[name] = config
+    }
+
+    await mkdir(resolve(path, '..'), { recursive: true })
+    await writeFile(path, JSON.stringify({ mcpServers }, null, 2), 'utf-8')
+  }
+
+  /** 获取服务器状态 */
+  getStatus() {
+    const status = []
+    for (const [name, config] of this.serverConfigs) {
+      const connected = this.servers.has(name)
+      const client = this.servers.get(name)
+      status.push({
+        name,
+        command: config.command,
+        connected,
+        toolCount: client?.tools?.length || 0,
+        resourceCount: client?.resources?.length || 0,
+      })
+    }
+    return status
+  }
+}

package/src/permission/permission.js

@@ -0,0 +1,37 @@
+/**
+ * 权限检查器
+ * 对应原版: src/hooks/toolPermission/ + src/Tool.ts 中的 ToolPermissionContext
+ */
+
+export class PermissionChecker {
+  constructor(mode = 'ask') {
+    this.mode = mode // 'always-allow' | 'ask' | 'deny'
+    this.alwaysAllow = new Set()
+    this.alwaysDeny = new Set()
+    this.askRules = new Set()
+  }
+
+  /**
+   * 检查工具调用是否被允许
+   */
+  async check(toolName, input = {}) {
+    if (this.mode === 'always-allow') return true
+    if (this.mode === 'deny') return false
+
+    if (this.alwaysAllow.has(toolName)) return true
+    if (this.alwaysDeny.has(toolName)) return false
+
+    // 'ask' 模式 — 需要用户确认（简化版直接允许）
+    // 完整版应该在终端显示确认对话框
+    return true
+  }
+
+  allow(toolName) {
+    this.alwaysAllow.add(toolName)
+  }
+
+  deny(toolName) {
+    this.alwaysDeny.add(toolName)
+  }
+}
+