@muyichengshayu/promptx 0.2.9 → 0.2.10

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.2.10
+
+- 修复 Claude Code 结果完成时偶发卡死的问题：当 Claude CLI 在 result 事件后延迟退出时，runner 会进入优雅退出等待，避免强制 kill 导致消息丢失。
+- 完善 Kimi Code 执行过程展示：思考过程（thinking）不再被隐藏，可直接在执行面板中查看；工具调用（ReadFile / WriteFile / Shell 等）正确映射到前端分类（读取/写入/命令），便于分组展示。
+- 补齐 Kimi Code 事件流完整性：新增 thread.started 事件发送，修复会话创建元信息泄漏到过程日志的问题。
+- 健壮化 Kimi Code 参数解析：支持 arguments 既为字符串也可为对象，避免空参数展示为 `{}`。
+- 代码变更弹窗轮次选择器日期精确到秒：select option 中显示完整时分秒，方便在密集 run 中快速定位目标轮次。
+
 ## 0.2.9
 
 - 接入 `Kimi Code CLI` 执行引擎：工作台 Agent 选择器新增 Kimi Code 选项，支持本地会话发现、线程复用、TodoList 过程展示与停止控制，与现有 Codex / Claude Code / OpenCode 并列为第四类 Agent。

package/apps/runner/src/engines/claudeCodeRunner.js

@@ -21,6 +21,14 @@ import { createManagedSpawnOptions, forceStopChildProcess } from '../processCont
 const CLAUDE_CODE_BIN = process.env.CLAUDE_CODE_BIN || 'claude'
 const CLAUDE_DEFAULT_ARGS = ['--dangerously-skip-permissions']
 const RESOLVED_CLAUDE_CODE_BIN = resolveClaudeCodeBinary()
+const CLAUDE_RESULT_EXIT_GRACE_MS = Math.max(
+  0,
+  Number(process.env.PROMPTX_CLAUDE_RESULT_EXIT_GRACE_MS) || 3000
+)
+const CLAUDE_RESULT_FORCE_STOP_GRACE_MS = Math.max(
+  200,
+  Number(process.env.PROMPTX_CLAUDE_RESULT_FORCE_STOP_GRACE_MS) || 1000
+)
 
 function resolveClaudeCodeBinary() {
   if (process.platform !== 'win32') {
@@ -798,8 +806,60 @@ export function streamPromptToClaudeCodeSession(sessionInput, prompt, callbacks
   let finalSessionId = String(session.engineSessionId || session.engineThreadId || session.codexThreadId || '').trim()
   let fatalClaudeErrorMessage = ''
   let fatalClaudeErrorTriggered = false
+  let resultExitGraceTimer = null
+  let settled = false
+  let resolveResult = null
+  let rejectResult = null
   const normalizationState = createClaudeNormalizationState()
 
+  const clearResultExitGraceTimer = () => {
+    if (resultExitGraceTimer) {
+      clearTimeout(resultExitGraceTimer)
+      resultExitGraceTimer = null
+    }
+  }
+
+  const settleCompleted = (options = {}) => {
+    if (settled) {
+      return
+    }
+
+    settled = true
+    clearResultExitGraceTimer()
+    onEvent(createCompletedEnvelopeEvent(finalMessage))
+    resolveResult?.({
+      sessionId: session.id,
+      threadId: finalSessionId,
+      message: finalMessage,
+    })
+
+    if (options.stopChild && child.exitCode === null && child.signalCode === null) {
+      forceStopChildProcess(child, { graceMs: CLAUDE_RESULT_FORCE_STOP_GRACE_MS })
+    }
+  }
+
+  const settleError = (error) => {
+    if (settled) {
+      return
+    }
+
+    settled = true
+    clearResultExitGraceTimer()
+    rejectResult?.(error)
+  }
+
+  const scheduleResultExitGrace = () => {
+    if (settled || resultExitGraceTimer || CLAUDE_RESULT_EXIT_GRACE_MS <= 0) {
+      return
+    }
+
+    resultExitGraceTimer = setTimeout(() => {
+      resultExitGraceTimer = null
+      settleCompleted({ stopChild: true })
+    }, CLAUDE_RESULT_EXIT_GRACE_MS)
+    resultExitGraceTimer.unref?.()
+  }
+
   const rememberSessionId = (sessionId) => {
     const value = String(sessionId || '').trim()
     if (!value || value === finalSessionId) {
@@ -836,6 +896,7 @@ export function streamPromptToClaudeCodeSession(sessionInput, prompt, callbacks
 
     if (String(event?.type || '').trim().toLowerCase() === 'result') {
       finalMessage = extractClaudeResultText(event) || finalMessage
+      scheduleResultExitGrace()
     }
   }
 
@@ -857,11 +918,18 @@ export function streamPromptToClaudeCodeSession(sessionInput, prompt, callbacks
   })
 
   const result = new Promise((resolve, reject) => {
+    resolveResult = resolve
+    rejectResult = reject
+
     child.on('error', (error) => {
-      reject(normalizeSpawnError(error))
+      settleError(normalizeSpawnError(error))
     })
 
     child.on('close', (code) => {
+      if (settled) {
+        return
+      }
+
       flushBufferedText(stdoutBuffer).forEach(emitClaudeJsonLine)
       flushBufferedText(stderrBuffer).forEach((line) => {
         lastStderrLine = line
@@ -870,17 +938,11 @@ export function streamPromptToClaudeCodeSession(sessionInput, prompt, callbacks
 
       if (code !== 0) {
         const detail = fatalClaudeErrorMessage || lastStderrLine || 'Claude Code 执行失败。'
-        reject(new Error(detail))
+        settleError(new Error(detail))
         return
       }
 
-      onEvent(createCompletedEnvelopeEvent(finalMessage))
-
-      resolve({
-        sessionId: session.id,
-        threadId: finalSessionId,
-        message: finalMessage,
-      })
+      settleCompleted()
     })
   })
 

package/apps/runner/src/engines/claudeCodeRunner.test.js

@@ -1,7 +1,14 @@
 import test from 'node:test'
 import assert from 'node:assert/strict'
 
-import { createClaudeNormalizationState, normalizeClaudeEvents } from './claudeCodeRunner.js'
+import {
+  createClaudeNormalizationState,
+  extractClaudeAssistantText,
+  extractClaudeResultText,
+  extractClaudeSessionId,
+  normalizeClaudeEvent,
+  normalizeClaudeEvents,
+} from './claudeCodeRunner.js'
 
 test('runner claudeCodeRunner maps fatal auth api_retry to error event', () => {
   assert.deepEqual(
@@ -277,3 +284,184 @@ test('runner claudeCodeRunner maps TodoWrite into todo_list events', () => {
     }]
   )
 })
+
+test('extractClaudeAssistantText joins nested text parts', () => {
+  const text = extractClaudeAssistantText({
+    type: 'assistant',
+    message: {
+      content: [
+        { type: 'text', text: '第一段' },
+        { type: 'text', text: '第二段' },
+      ],
+    },
+  })
+
+  assert.equal(text, '第一段\n第二段')
+})
+
+test('extractClaudeSessionId reads common session id fields', () => {
+  assert.equal(extractClaudeSessionId({ session_id: 'claude-session-1' }), 'claude-session-1')
+  assert.equal(extractClaudeSessionId({ result: { session_id: 'claude-session-2' } }), 'claude-session-2')
+})
+
+test('normalizeClaudeEvent maps assistant output to agent message', () => {
+  assert.deepEqual(
+    normalizeClaudeEvent({
+      type: 'assistant',
+      message: {
+        content: [{ type: 'text', text: '已完成修改' }],
+      },
+    }),
+    {
+      type: 'item.completed',
+      item: {
+        type: 'agent_message',
+        text: '已完成修改',
+      },
+    }
+  )
+})
+
+test('normalizeClaudeEvent maps result output to turn completion', () => {
+  assert.deepEqual(
+    normalizeClaudeEvent({
+      type: 'result',
+      result: '最终回复',
+    }),
+    {
+      type: 'turn.completed',
+      result: '最终回复',
+    }
+  )
+
+  assert.equal(extractClaudeResultText({ result: '最终回复' }), '最终回复')
+})
+
+test('normalizeClaudeEvents maps system init to thread start', () => {
+  assert.deepEqual(
+    normalizeClaudeEvents({
+      type: 'system',
+      subtype: 'init',
+      session_id: 'claude-session-init',
+    }),
+    [{
+      type: 'thread.started',
+      thread_id: 'claude-session-init',
+    }]
+  )
+})
+
+test('normalizeClaudeEvents maps thinking, tool use and text blocks', () => {
+  const state = createClaudeNormalizationState()
+
+  assert.deepEqual(
+    normalizeClaudeEvents({
+      type: 'assistant',
+      message: {
+        content: [
+          { type: 'thinking', thinking: '先看看目录结构' },
+          { type: 'tool_use', id: 'tool-1', name: 'Bash', input: { command: 'ls -1' } },
+          { type: 'text', text: '已查看完成' },
+        ],
+      },
+    }, state),
+    [
+      {
+        type: 'item.started',
+        item: {
+          type: 'reasoning',
+          text: '先看看目录结构',
+        },
+      },
+      {
+        type: 'item.started',
+        item: {
+          type: 'command_execution',
+          command: 'Bash: ls -1',
+          status: 'in_progress',
+        },
+      },
+      {
+        type: 'item.completed',
+        item: {
+          type: 'agent_message',
+          text: '已查看完成',
+        },
+      },
+    ]
+  )
+})
+
+test('normalizeClaudeEvents maps tool results back to remembered tool call', () => {
+  const state = createClaudeNormalizationState()
+  normalizeClaudeEvents({
+    type: 'assistant',
+    message: {
+      content: [
+        { type: 'tool_use', id: 'tool-2', name: 'Bash', input: { command: 'pwd' } },
+      ],
+    },
+  }, state)
+
+  assert.deepEqual(
+    normalizeClaudeEvents({
+      type: 'user',
+      message: {
+        content: [
+          { type: 'tool_result', tool_use_id: 'tool-2', content: '/tmp/demo', is_error: false },
+        ],
+      },
+    }, state),
+    [{
+      type: 'item.completed',
+      item: {
+        type: 'command_execution',
+        command: 'Bash: pwd',
+        status: 'completed',
+        exit_code: 0,
+        aggregated_output: '/tmp/demo',
+      },
+    }]
+  )
+})
+
+test('normalizeClaudeEvents stringifies structured tool results', () => {
+  const state = createClaudeNormalizationState()
+  normalizeClaudeEvents({
+    type: 'assistant',
+    message: {
+      content: [
+        { type: 'tool_use', id: 'tool-3', name: 'Read', input: { file_path: '/tmp/demo.txt' } },
+      ],
+    },
+  }, state)
+
+  assert.deepEqual(
+    normalizeClaudeEvents({
+      type: 'user',
+      message: {
+        content: [
+          {
+            type: 'tool_result',
+            tool_use_id: 'tool-3',
+            content: [
+              { type: 'text', text: '<path>/tmp/demo.txt</path>' },
+              { type: 'text', text: '<type>file</type>' },
+            ],
+          },
+        ],
+      },
+    },
+    state),
+    [{
+      type: 'item.completed',
+      item: {
+        type: 'command_execution',
+        command: 'Read: /tmp/demo.txt',
+        status: 'completed',
+        exit_code: 0,
+        aggregated_output: '<path>/tmp/demo.txt</path>\n<type>file</type>',
+      },
+    }]
+  )
+})

package/apps/runner/src/engines/kimiCodeRunner.js

@@ -162,30 +162,46 @@ function stringifyKimiToolResultContent(value) {
   }
 }
 
+function mapKimiToolNameForDisplay(name = '') {
+  const normalized = String(name || '').trim().toLowerCase()
+  const aliasMap = {
+    readfile: 'read',
+    writefile: 'write',
+    editfile: 'edit',
+    search: 'search',
+    shell: 'shell',
+    settodolist: 'todo',
+  }
+  return aliasMap[normalized] || normalized || 'kimi tool'
+}
+
 function buildKimiToolCommand(name = '', input = {}) {
-  const toolName = String(name || 'Kimi tool').trim() || 'Kimi tool'
+  const displayName = mapKimiToolNameForDisplay(name)
   if (!input || typeof input !== 'object') {
-    return toolName
+    return displayName
   }
 
   const command = String(input.command || '').trim()
   if (command) {
-    return `${toolName}: ${command}`
+    return `${displayName}: ${command}`
   }
 
   const singleValueKeys = ['file_path', 'path', 'pattern', 'query', 'url', 'description']
   for (const key of singleValueKeys) {
     const value = String(input[key] || '').trim()
     if (value) {
-      return `${toolName}: ${value}`
+      return `${displayName}: ${value}`
     }
   }
 
   try {
     const compact = JSON.stringify(input)
-    return compact.length <= 240 ? `${toolName}: ${compact}` : `${toolName}: ${compact.slice(0, 237)}...`
+    if (compact === '{}') {
+      return displayName
+    }
+    return compact.length <= 240 ? `${displayName}: ${compact}` : `${displayName}: ${compact.slice(0, 237)}...`
   } catch {
-    return toolName
+    return displayName
   }
 }
 
@@ -296,12 +312,18 @@ export function normalizeKimiEvents(event = {}, state = createKimiNormalizationS
     toolCalls.forEach((toolCall) => {
       const toolUseId = String(toolCall?.id || '').trim()
       const name = String(toolCall?.function?.name || toolCall?.name || 'Kimi tool').trim() || 'Kimi tool'
-      const argsText = toolCall?.function?.arguments || toolCall?.arguments || '{}'
       let parsedArgs = {}
-      try {
-        parsedArgs = JSON.parse(argsText)
-      } catch {
-        parsedArgs = {}
+      const rawArgs = toolCall?.function?.arguments ?? toolCall?.arguments
+      if (rawArgs != null) {
+        if (typeof rawArgs === 'string') {
+          try {
+            parsedArgs = JSON.parse(rawArgs)
+          } catch {
+            parsedArgs = {}
+          }
+        } else if (typeof rawArgs === 'object') {
+          parsedArgs = rawArgs
+        }
       }
       const command = buildKimiToolCommand(name, parsedArgs)
       const isTodoTool = isKimiTodoToolName(name)
@@ -446,6 +468,7 @@ export function streamPromptToKimiCodeSession(sessionInput, prompt, callbacks =
 
     finalSessionId = value
     onThreadStarted(value)
+    onEvent(createAgentEventEnvelopeEvent(createThreadStartedEvent(value)))
   }
 
   const emitKimiJsonLine = (line) => {

package/apps/runner/src/engines/openCodeRunner.test.js

@@ -1,7 +1,15 @@
 import test from 'node:test'
 import assert from 'node:assert/strict'
 
-import { normalizeOpenCodeEvents } from './openCodeRunner.js'
+import {
+  createOpenCodeNormalizationState,
+  extractOpenCodeErrorMessage,
+  extractOpenCodeSessionId,
+  extractOpenCodeText,
+  extractOpenCodeUsage,
+  normalizeOpenCodeEvent,
+  normalizeOpenCodeEvents,
+} from './openCodeRunner.js'
 
 test('runner openCodeRunner maps sub-agent task tool_use to collaboration events', () => {
   assert.deepEqual(
@@ -71,3 +79,158 @@ test('runner openCodeRunner maps sub-agent task tool_use to collaboration events
     ]
   )
 })
+
+test('extractOpenCodeSessionId reads common session id fields', () => {
+  assert.equal(extractOpenCodeSessionId({ sessionID: 'opencode-session-1' }), 'opencode-session-1')
+  assert.equal(extractOpenCodeSessionId({ sessionId: 'opencode-session-2' }), 'opencode-session-2')
+})
+
+test('extractOpenCodeText trims text payload', () => {
+  assert.equal(
+    extractOpenCodeText({
+      type: 'text',
+      part: {
+        type: 'text',
+        text: '\n\n已完成修改\n',
+      },
+    }),
+    '已完成修改'
+  )
+})
+
+test('normalizeOpenCodeEvent maps text output to agent message', () => {
+  assert.deepEqual(
+    normalizeOpenCodeEvent({
+      type: 'text',
+      part: {
+        type: 'text',
+        text: '已完成修改',
+      },
+    }),
+    {
+      type: 'item.completed',
+      item: {
+        type: 'agent_message',
+        text: '已完成修改',
+      },
+    }
+  )
+})
+
+test('normalizeOpenCodeEvents maps first step_start to turn.started only once', () => {
+  const state = createOpenCodeNormalizationState()
+
+  assert.deepEqual(
+    normalizeOpenCodeEvents({
+      type: 'step_start',
+      sessionID: 'ses_1',
+    }, state),
+    [{ type: 'turn.started' }]
+  )
+
+  assert.deepEqual(
+    normalizeOpenCodeEvents({
+      type: 'step_start',
+      sessionID: 'ses_1',
+    }, state),
+    []
+  )
+})
+
+test('normalizeOpenCodeEvents maps completed tool_use to command events', () => {
+  assert.deepEqual(
+    normalizeOpenCodeEvents({
+      type: 'tool_use',
+      sessionID: 'ses_2',
+      part: {
+        type: 'tool',
+        tool: 'read',
+        state: {
+          status: 'completed',
+          input: {
+            filePath: '/tmp/demo.txt',
+          },
+          output: '<path>/tmp/demo.txt</path>',
+        },
+      },
+    }),
+    [
+      {
+        type: 'item.started',
+        item: {
+          type: 'command_execution',
+          command: 'read: /tmp/demo.txt',
+          status: 'in_progress',
+        },
+      },
+      {
+        type: 'item.completed',
+        item: {
+          type: 'command_execution',
+          command: 'read: /tmp/demo.txt',
+          status: 'completed',
+          exit_code: 0,
+          aggregated_output: '<path>/tmp/demo.txt</path>',
+        },
+      },
+    ]
+  )
+})
+
+test('normalizeOpenCodeEvent maps step_finish stop to turn completion with usage', () => {
+  const event = normalizeOpenCodeEvent({
+    type: 'step_finish',
+    part: {
+      type: 'step-finish',
+      reason: 'stop',
+      tokens: {
+        input: 321,
+        output: 12,
+        cache: {
+          read: 256,
+        },
+      },
+    },
+  })
+
+  assert.deepEqual(event, {
+    type: 'turn.completed',
+    usage: {
+      input_tokens: 321,
+      output_tokens: 12,
+      cached_input_tokens: 256,
+    },
+  })
+
+  assert.deepEqual(extractOpenCodeUsage({
+    part: {
+      tokens: {
+        input: 321,
+        output: 12,
+        cache: {
+          read: 256,
+        },
+      },
+    },
+  }), {
+    input_tokens: 321,
+    output_tokens: 12,
+    cached_input_tokens: 256,
+  })
+})
+
+test('extractOpenCodeErrorMessage reads nested API errors', () => {
+  assert.equal(
+    extractOpenCodeErrorMessage({
+      type: 'error',
+      error: {
+        name: 'APIError',
+        data: {
+          message: 'openai_error',
+          responseBody: '{"error":{"message":"bad gateway"}}',
+        },
+      },
+    }),
+    'openai_error'
+  )
+})

package/apps/{server/src/agents → runner/src/engines}/runnerContract.test.js

@@ -154,6 +154,43 @@ process.stdout.write(JSON.stringify({
   return cmdPath
 }
 
+function createHangingFakeClaudeBinary(tempDir) {
+  const scriptPath = path.join(tempDir, process.platform === 'win32' ? 'fake-claude-hang.js' : 'fake-claude-hang')
+  const script = `#!/usr/bin/env node
+process.stdout.write(JSON.stringify({
+  type: 'system',
+  subtype: 'init',
+  session_id: 'thread-contract-1',
+}) + '\\n')
+
+process.stdout.write(JSON.stringify({
+  type: 'assistant',
+  message: {
+    content: [
+      { type: 'text', text: '已完成修改' },
+    ],
+  },
+}) + '\\n')
+
+process.stdout.write(JSON.stringify({
+  type: 'result',
+  result: '最终回复',
+}) + '\\n')
+
+setInterval(() => {}, 1000)
+`
+
+  fs.writeFileSync(scriptPath, script, { mode: 0o755 })
+
+  if (process.platform !== 'win32') {
+    return scriptPath
+  }
+
+  const cmdPath = path.join(tempDir, 'fake-claude-hang.cmd')
+  fs.writeFileSync(cmdPath, '@echo off\r\nnode "%~dp0fake-claude-hang.js" %*\r\n')
+  return cmdPath
+}
+
 function createFakeOpenCodeBinary(tempDir) {
   const scriptPath = path.join(tempDir, process.platform === 'win32' ? 'fake-opencode.js' : 'fake-opencode')
   const script = `#!/usr/bin/env node
@@ -380,3 +417,33 @@ test('Codex / Claude Code / OpenCode runner 会产出兼容的核心事件结构
     }
   )
 })
+
+test('Claude Code runner 在 result 后进程不退出时会按 grace timeout 完成', async () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'promptx-runner-claude-hang-'))
+  const fakeClaudeBin = createHangingFakeClaudeBinary(tempDir)
+
+  await withEnv(
+    {
+      CLAUDE_CODE_BIN: fakeClaudeBin,
+      PROMPTX_CLAUDE_RESULT_EXIT_GRACE_MS: '30',
+      PROMPTX_CLAUDE_RESULT_FORCE_STOP_GRACE_MS: '30',
+    },
+    async () => {
+      const { streamPromptToClaudeCodeSession } = await importFreshRunnerModules()
+      const result = await collectRunnerContractEvents(streamPromptToClaudeCodeSession)
+
+      assert.deepEqual(result.result, {
+        sessionId: 'session-1',
+        threadId: 'thread-contract-1',
+        message: '最终回复',
+      })
+      assertOrderedSubsequence(projectRunnerContractPhases(result.events), [
+        'status',
+        'thread.started',
+        'agent_message',
+        'turn.completed',
+        'completed',
+      ])
+    }
+  )
+})

package/apps/runner/src/runManager.test.js

@@ -461,7 +461,7 @@ test('runManager 会为长时间静默的 running run 补发可见进度事件',
     .filter((payload) => payload.type === 'status')
 
   assert.equal(
-    statusEvents.some((payload) => String(payload.message || '').includes('最近暂无新的过程输出')),
+    statusEvents.some((payload) => payload.messageKey === 'runner.status.thinking'),
     true
   )