@raolin2025/claude-code-node 1.2.0 → 2.1.0

package/src/core/query-engine.js

@@ -12,8 +12,12 @@
  * 适用于: OpenAI / DeepSeek / Qwen / GLM / Kimi / Ollama / vLLM / LM Studio / 任何兼容接口
  */
 import crypto from 'crypto'
-import { Message, UserMessage, AssistantMessage, SystemMessage, ToolCall, ToolResult, SessionState } from '../types/index.js'
+import { UserMessage, AssistantMessage, ToolCall, ToolResult, SessionState } from '../types/index.js'
+import { parseStream, parseNonStreamResponse } from './streaming.js'
+import { autoCompact } from './compact.js'
+import { CostTracker } from './cost-tracker.js'
 import { EnhancedPermissionChecker } from '../security/enhanced-permission.js'
+import { checkHostSafety } from '../security/ssrf-guard.js'
 
 /**
  * 配置选项
@@ -35,7 +39,12 @@ export class QueryEngineConfig {
     this.apiKey = options.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 || ''
     // API Base — DeepSeek 为默认
     this.apiBase = options.apiBase || process.env.LLM_API_BASE || 'https://api.deepseek.com/v1'
+    this.noStream = options.noStream || false
+    this.costTracker = options.costTracker || null
+    this.tokenBudget = options.tokenBudget || null
     this.initialMessages = options.initialMessages || []
+    this.onConfirmTool = options.onConfirmTool || null  // ask 模式确认回调
+    this.readline = options.readline || null              // 用于 AskUserQuestion 工具
   }
 }
 
@@ -51,6 +60,8 @@ export class QueryEngine {
       projectDir: this.config.cwd,
     })
     this.abortController = null
+    this.costTracker = this.config.costTracker || new CostTracker({ model: this.config.model })
+    this.tokenBudget = this.config.tokenBudget || null
   }
 
   /**
@@ -66,6 +77,15 @@ export class QueryEngine {
     const userMsg = new UserMessage(userInput)
     this.state.messages.push(userMsg)
 
+    // M3: 自动上下文压缩
+    if (this.tokenBudget) {
+      const { compacted, messages } = autoCompact(this.state.messages, this.tokenBudget)
+      if (compacted) {
+        this.state.messages = messages
+        if (this.config.verbose) console.error('[compact] Context compressed to fit token budget')
+      }
+    }
+
     try {
       const result = await this._runToolLoop(userMsg)
       return result
@@ -81,12 +101,11 @@ export class QueryEngine {
    * 最多跑 maxTurns 次
    */
   async _runToolLoop(userMessage) {
-    let currentMessages = [...this.state.messages]
     let finalResponse = ''
 
     for (let turn = 0; turn < this.config.maxTurns; turn++) {
-      const requestMessages = this._buildRequest(currentMessages)
-      const response = await this._callLLM(requestMessages, currentMessages)
+      const requestMessages = this._buildRequest(this.state.messages)
+      const response = await this._callLLM(requestMessages, this.state.messages)
 
       if (this.abortController.signal.aborted) {
         throw new Error('操作已取消')
@@ -95,40 +114,22 @@ export class QueryEngine {
       // 没有工具调用 → 最终回复
       if (!response.toolCalls || response.toolCalls.length === 0) {
         finalResponse = response.content
-        const assistantMsg = new AssistantMessage(response.content)
-        this.state.messages.push(assistantMsg)
+        this.state.messages.push(new AssistantMessage(response.content))
         break
       }
 
-      // 有工具调用 → 记录助手消息
-      const assistantMsg = new AssistantMessage(response.content, response.toolCalls)
-      this.state.messages.push(assistantMsg)
+      // 有工具调用 → 记录 assistant 消息（含 tool_calls）
+      this.state.messages.push(new AssistantMessage(response.content, response.toolCalls))
 
       // 执行工具
       const toolResults = await this._executeToolCalls(response.toolCalls)
 
-      // 工具结果加入消息流（OpenAI 兼容格式）
+      // 工具结果加入 state.messages（OpenAI 兼容格式）
       for (const result of toolResults) {
-        // 先加 assistant 的 tool_calls 消息
-        currentMessages.push({
-          role: 'assistant',
-          content: null,
-          tool_calls: [{
-            id: result.toolCallId,
-            type: 'function',
-            function: {
-              name: result.toolName || '',
-              arguments: '{}',
-            },
-          }],
-        })
-        // 再加 tool 结果消息
-        currentMessages.push({
+        this.state.messages.push({
           role: 'tool',
           tool_call_id: result.toolCallId,
-          content: result.isError
-            ? `[ERROR] ${result.content}`
-            : result.content,
+          content: result.isError ? `[ERROR] ${result.content}` : result.content,
         })
         this.state.toolResults.set(result.toolCallId, result)
       }
@@ -150,7 +151,7 @@ export class QueryEngine {
   }
 
   /**
-   * 构建 LLM 请求消息列表
+   * 构建 LLM 请求消息列表 — 统一 OpenAI 兼容格式
    */
   _buildRequest(messages) {
     const request = []
@@ -160,76 +161,101 @@ export class QueryEngine {
       request.push({ role: 'system', content: this.config.systemPrompt })
     }
 
-    // 历史消息
+    // 历史消息 — 转换为 OpenAI 兼容格式
     for (const msg of messages) {
       if (msg.role === 'system') {
         request.push({ role: 'system', content: msg.content })
       } else if (msg.role === 'user') {
         request.push({ role: 'user', content: this._formatContent(msg.content) })
       } else if (msg.role === 'assistant') {
-        const content = []
-        if (msg.content) content.push({ type: 'text', text: msg.content })
-        if (msg.toolCalls) {
-          for (const tc of msg.toolCalls) {
-            content.push({ type: 'tool_use', id: tc.id, name: tc.name, input: tc.input })
-          }
+        // 带 tool_calls 的 assistant 消息：OpenAI 格式
+        if (msg.toolCalls && msg.toolCalls.length > 0) {
+          request.push({
+            role: 'assistant',
+            content: msg.content || null,
+            tool_calls: msg.toolCalls.map(tc => ({
+              id: tc.id,
+              type: 'function',
+              function: { name: tc.name, arguments: typeof tc.input === 'string' ? tc.input : JSON.stringify(tc.input) },
+            })),
+          })
+        } else {
+          // 纯文本 assistant 消息
+          request.push({ role: 'assistant', content: this._formatContent(msg.content) })
         }
-        request.push({ role: 'assistant', content })
+      } else if (msg.role === 'tool') {
+        // tool 结果消息 — 直接透传
+        request.push({
+          role: 'tool',
+          tool_call_id: msg.tool_call_id,
+          content: typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content),
+        })
       }
     }
 
     return request
   }
 
+
   /**
-   * 执行工具调用
+   * 执行工具调用 — 两阶段策略
+   * 阶段1（串行）：安全检查 + ask 模式确认（需要用户交互，必须串行）
+   * 阶段2（并行）：批准后的工具并行执行，互不依赖的工具同时跑
    */
   async _executeToolCalls(toolCalls) {
-    const results = []
+    // 阶段1：串行安全检查
+    const approved = []
     for (const tc of toolCalls) {
-      // 安全检查（一票否决）
       const permResult = await this.permissionChecker.check(tc.name, tc.input)
       if (!permResult.allowed) {
-        results.push(new ToolResult(tc.id, `工具调用被安全策略拒绝: ${tc.name} — ${permResult.reason || ''}`, true))
-        continue
+        if (permResult.requiresConfirmation && this.config.onConfirmTool) {
+          const confirmed = await this.config.onConfirmTool(tc.name, tc.input)
+          if (!confirmed) {
+            approved.push({ tc, error: '用户未确认' })
+            continue
+          }
+        } else {
+          approved.push({ tc, error: `安全策略拒绝: ${permResult.reason || ""}` })
+          continue
+        }
       }
 
-      // 查找工具
       const tool = this.config.tools.find(t => t.name === tc.name)
       if (!tool) {
-        results.push(new ToolResult(tc.id, `未找到工具: ${tc.name}`, true))
+        approved.push({ tc, error: `未找到工具: ${tc.name}` })
         continue
       }
 
+      approved.push({ tc, tool })
+    }
+
+    // 阶段2：并行执行已批准的工具
+    const execPromises = approved.map(async (item) => {
+      if (item.error) {
+        const r = new ToolResult(item.tc.id, item.error, true)
+        r.toolName = item.tc.name
+        return r
+      }
+      const { tc, tool } = item
+      tc.status = 'running'
       try {
-        tc.status = 'running'
-        const content = await tool.handler(tc.input, { cwd: this.config.cwd, engine: this })
+        const content = await tool.handler(tc.input, { cwd: this.config.cwd, engine: this, readline: this.config.readline })
         tc.status = 'done'
-        results.push(new ToolResult(tc.id, typeof content === 'string' ? content : JSON.stringify(content), false))
-        // 记录工具名用于消息构建
-        results[results.length - 1].toolName = tc.name
+        const r = new ToolResult(tc.id, typeof content === 'string' ? content : JSON.stringify(content), false)
+        r.toolName = tc.name
+        return r
       } catch (err) {
         tc.status = 'error'
-        results.push(new ToolResult(tc.id, `工具执行错误: ${err.message}`, true))
-        results[results.length - 1].toolName = tc.name
+        const r = new ToolResult(tc.id, `工具执行错误: ${err.message}`, true)
+        r.toolName = tc.name
+        return r
       }
-    }
+    })
+
+    const results = await Promise.all(execPromises)
     return results
   }
 
-  /**
-   * 调用 LLM API — OpenAI 兼容协议（全行业通用）
-   *
-   * 支持的提供商（举例）:
-   * - DeepSeek:      https://api.deepseek.com/v1
-   * - 通义千问:       https://dashscope.aliyuncs.com/compatible-mode/v1
-   * - 智谱 GLM:       https://open.bigmodel.cn/api/paas/v4
-   * - Moonshot Kimi:  https://api.moonshot.cn/v1
-   * - Ollama 本地:    http://localhost:11434/v1
-   * - vLLM:          http://localhost:8000/v1
-   * - LM Studio:     http://localhost:1234/v1
-   * - OpenAI:        https://api.openai.com/v1
-   */
   async _callLLM(messages, contextMessages) {
     const apiKey = this.config.apiKey
     const apiBase = this.config.apiBase
@@ -237,96 +263,176 @@ export class QueryEngine {
     if (!apiKey) {
       throw new Error(
         `未设置 API Key。请设置以下环境变量之一:\n` +
-        `  LLM_API_KEY=xxx          (通用，推荐)\n` +
-        `  DEEPSEEK_API_KEY=xxx     (DeepSeek)\n` +
-        `  OPENAI_API_KEY=xxx       (OpenAI)\n` +
-        `  QWEN_API_KEY=xxx         (通义千问)\n` +
-        `  GLM_API_KEY=xxx          (智谱 GLM)\n` +
-        `  KIMI_API_KEY=xxx         (Moonshot Kimi)\n` +
+        `  LLM_API_KEY=xxx (通用，推荐)\n` +
+        `  DEEPSEEK_API_KEY=xxx (DeepSeek)\n` +
+        `  OPENAI_API_KEY=xxx (OpenAI)\n` +
+        `  QWEN_API_KEY=xxx (通义千问)\n` +
+        `  GLM_API_KEY=xxx (智谱 GLM)\n` +
+        `  KIMI_API_KEY=xxx (Moonshot Kimi)\n` +
         `或通过 --api-key 参数传入`
       )
     }
 
     if (!apiBase) {
       throw new Error(
-        `未设置 API Base URL。默认使用 https://api.deepseek.com/v1
-` +
-        `可通过 LLM_API_BASE 或 --api-base 参数切换其他提供商，例如:\n` +
-        `  --api-base https://dashscope.aliyuncs.com/compatible-mode/v1   (通义千问)\n` +
-        `  --api-base https://open.bigmodel.cn/api/paas/v4              (智谱 GLM)\n` +
-        `  --api-base https://api.moonshot.cn/v1                         (Moonshot Kimi)\n` +
-        `  --api-base http://localhost:11434/v1                          (Ollama 本地)\n` +
-        `  --api-base http://localhost:8000/v1                           (vLLM 本地)\n` +
-        `  --api-base https://api.openai.com/v1                          (OpenAI)`
+        `未设置 API Base URL。默认使用 https://api.deepseek.com/v1 ` +
+        `可通过 LLM_API_BASE 或 --api-base 参数切换其他提供商`
       )
     }
 
-    // 构建工具定义 — OpenAI function-calling 格式
+    // 构建工具定义
     const tools = this.config.tools.map(t => ({
       type: 'function',
-      function: {
-        name: t.name,
-        description: t.description,
-        parameters: t.parameters,
-      },
+      function: { name: t.name, description: t.description, parameters: t.parameters },
     }))
 
+    const useStream = !this.config.noStream
     const body = {
       model: this.config.model,
       messages,
       max_tokens: 4096,
       ...(tools.length && { tools }),
+      ...(useStream && { stream: true }),
     }
 
     const url = apiBase.replace(/\/+$/, '') + '/chat/completions'
 
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'Authorization': `Bearer ${apiKey}`,
-      },
-      body: JSON.stringify(body),
-      signal: this.abortController?.signal,
-    })
+    // H3 修复：SSRF 防护 — 在 fetch 之前检查 API 主机名
+    try {
+      const parsedUrl = new URL(url)
+      const hostResult = await checkHostSafety(parsedUrl.hostname)
+      if (!hostResult.allowed) {
+        throw new Error(`SSRF blocked: ${hostResult.reason}`)
+      }
+    } catch (err) {
+      if (err.message.startsWith('SSRF blocked:')) {
+        throw err
+      }
+      // URL 解析错误忽略，让 fetch 自己处理
+    }
 
-    if (!response.ok) {
-      const errText = await response.text()
-      throw new Error(`API 错误 ${response.status}: ${errText}`)
+    // 带重试的 fetch
+    const maxRetries = 3
+    // Jitter 退避 — 指数退避 + 随机 ±50%，防止惊群效应
+    const retryDelay = (baseMs, attempt) => {
+      const ms = baseMs * Math.pow(2, attempt - 1)
+      const jitter = ms * (0.5 + Math.random() * 0.5) // 50%-100% of base
+      return Math.round(jitter)
     }
+    let lastError = null
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      try {
+        if (this.abortController?.signal?.aborted) {
+          throw new Error('请求已取消')
+        }
+
+        const response = await fetch(url, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiKey}`,
+          },
+          body: JSON.stringify(body),
+          signal: this.abortController?.signal,
+        })
+
+        if (!response.ok) {
+          const errText = await response.text()
+          // 429/503 可重试
+          if ((response.status === 429 || response.status === 503) && attempt < maxRetries) {
+            const waitMs = retryDelay(response.status === 429 ? 2000 : 1000, attempt)
+            if (this.config.verbose) {
+              console.error(`[retry] API ${response.status}, waiting ${waitMs}ms (attempt ${attempt}/${maxRetries})`)
+            }
+            await new Promise(r => setTimeout(r, waitMs))
+            continue
+          }
+          throw new Error(`API 错误 ${response.status}: ${errText}`)
+        }
 
-    const data = await response.json()
-    return this._parseResponse(data)
+        // 流式或非流式处理
+        if (useStream && response.body) {
+          const result = await this._handleStreamResponse(response)
+          if (result.usage && this.costTracker) {
+            this.costTracker.recordUsage(result.usage)
+          }
+          if (this.tokenBudget && result.usage) {
+            this.tokenBudget.recordUsage(result.usage)
+          }
+          return result
+        } else {
+          const data = await response.json()
+          const result = parseNonStreamResponse(data)
+          if (result.usage && this.costTracker) {
+            this.costTracker.recordUsage(result.usage)
+          }
+          if (this.tokenBudget && result.usage) {
+            this.tokenBudget.recordUsage(result.usage)
+          }
+          return result
+        }
+      } catch (err) {
+        lastError = err
+        // 网络错误重试
+        if (err.name !== 'AbortError' && attempt < maxRetries && !err.message.startsWith('API 错误')) {
+          const waitMs = retryDelay(1000, attempt)
+          if (this.config.verbose) {
+            console.error(`[retry] Network error: ${err.message}, waiting ${waitMs}ms (attempt ${attempt}/${maxRetries})`)
+          }
+          await new Promise(r => setTimeout(r, waitMs))
+          continue
+        }
+        throw err
+      }
+    }
+    throw lastError
   }
 
   /**
-   * 解析 OpenAI 兼容响应
+   * 处理流式响应 — 逐 token 输出
    */
-  _parseResponse(data) {
-    const result = { content: '', toolCalls: [] }
-    const choice = data.choices?.[0]
-    if (!choice) return result
-
-    const message = choice.message
-    if (message.content) {
-      result.content = message.content
-    }
+  async _handleStreamResponse(response) {
+    const result = { content: '', toolCalls: [], usage: {} }
+    let currentText = ''
 
-    for (const tc of (message.tool_calls || [])) {
-      let input = {}
-      try {
-        input = JSON.parse(tc.function.arguments || '{}')
-      } catch {
-        input = { _raw: tc.function.arguments }
+    try {
+      for await (const event of parseStream(response)) {
+        if (event.type === 'text') {
+          // 实时输出到终端
+          process.stdout.write(event.text)
+          currentText += event.text
+        } else if (event.type === 'tool_use') {
+          // 收集工具调用
+          result.toolCalls.push(new ToolCall(
+            event.toolCall.id,
+            event.toolCall.name,
+            event.toolCall.input
+          ))
+        } else if (event.type === 'done') {
+          result.content = event.result.content || currentText
+          result.toolCalls = event.result.toolCalls?.map(tc =>
+            new ToolCall(tc.id, tc.name, tc.input)
+          ) || result.toolCalls
+          result.usage = event.result.usage || {}
+        }
+      }
+    } catch (err) {
+      // 流中断 — 返回已收到的内容
+      result.content = currentText || ''
+      if (this.config.verbose) {
+        console.error(`[stream] interrupted: ${err.message}`)
       }
-      result.toolCalls.push(new ToolCall(tc.id, tc.function.name, input))
     }
 
+    // 流式输出后换行
+    if (currentText) process.stdout.write('\n')
+
     return result
   }
 
   /** 格式化内容 */
   _formatContent(content) {
+    if (content == null) return ''
     if (typeof content === 'string') return content
     if (typeof content === 'object') return JSON.stringify(content)
     return String(content)

package/src/core/session.js

@@ -2,10 +2,9 @@
  * 会话管理
  * 对应原版: src/utils/sessionState.ts + src/utils/sessionStorage.ts
  */
-import { readFile, writeFile, mkdir, readdir, rm } from 'fs/promises'
+import { readFile, writeFile, mkdir, readdir, rm, chmod } from 'fs/promises'
 import { resolve, join } from 'path'
-import { existsSync } from 'fs'
-import { SessionState } from '../types/index.js'
+import { randomBytes } from 'crypto'
 
 const DEFAULT_SESSIONS_DIR = '.claude-code/sessions'
 
@@ -15,15 +14,16 @@ export class SessionManager {
     this.currentSession = null
   }
 
-  /** 确保会话目录存在 */
+  /** 确保会话目录存在（v1.1: 目录权限 0700） */
   async ensureDir() {
-    await mkdir(this.sessionsDir, { recursive: true })
+    await mkdir(this.sessionsDir, { recursive: true, mode: 0o700 })
   }
 
   /** 创建新会话 */
   async create(title = '') {
     await this.ensureDir()
-    const id = `session-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+    // M4 fix: 使用 crypto.randomBytes 生成不可预测的会话 ID
+    const id = `session-${Date.now()}-${randomBytes(8).toString('hex')}`
     const session = {
       id,
       title: title || `Session ${new Date().toISOString().slice(0, 19)}`,
@@ -37,12 +37,12 @@ export class SessionManager {
     return session
   }
 
-  /** 保存会话 */
+  /** 保存会话（v1.1: 文件权限 0600，防止其他用户读取敏感对话内容） */
   async save(session) {
     await this.ensureDir()
     session.updated = new Date().toISOString()
     const filePath = join(this.sessionsDir, `${session.id}.json`)
-    await writeFile(filePath, JSON.stringify(session, null, 2), 'utf-8')
+    await writeFile(filePath, JSON.stringify(session, null, 2), { encoding: 'utf-8', mode: 0o600 })
     return session
   }
 
@@ -109,11 +109,28 @@ export class SessionManager {
   /** 追加消息到当前会话 */
   async appendMessage(message) {
     if (!this.currentSession) await this.getOrCreate()
-    this.currentSession.messages.push({
+
+    const entry = {
       role: message.role,
       content: typeof message.content === 'string' ? message.content : JSON.stringify(message.content),
       timestamp: new Date().toISOString(),
-    })
+    }
+
+    // 保存 tool_calls 信息（assistant 消息可能包含工具调用）
+    if (message.toolCalls && message.toolCalls.length > 0) {
+      entry.toolCalls = message.toolCalls.map(tc => ({
+        id: tc.id,
+        name: tc.name,
+        input: tc.input,
+      }))
+    }
+
+    // 保存 tool_call_id（tool 结果消息）
+    if (message.tool_call_id) {
+      entry.tool_call_id = message.tool_call_id
+    }
+
+    this.currentSession.messages.push(entry)
     await this.save(this.currentSession)
     return this.currentSession
   }