@muyichengshayu/promptx 0.2.7 → 0.2.8

package/apps/server/src/agents/openCodeRunner.test.js

@@ -0,0 +1,236 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  createOpenCodeNormalizationState,
+  extractOpenCodeErrorMessage,
+  extractOpenCodeSessionId,
+  extractOpenCodeText,
+  extractOpenCodeUsage,
+  normalizeOpenCodeEvent,
+  normalizeOpenCodeEvents,
+} from './openCodeRunner.js'
+
+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'
+  )
+})
+
+test('normalizeOpenCodeEvents maps sub-agent task tool_use to collaboration events', () => {
+  assert.deepEqual(
+    normalizeOpenCodeEvents({
+      type: 'tool_use',
+      sessionID: 'ses_main',
+      part: {
+        type: 'tool',
+        tool: 'task',
+        state: {
+          status: 'completed',
+          input: {
+            description: '分析 a.js 文件',
+            prompt: '请分析 /tmp/demo/a.js 文件',
+            subagent_type: 'explore',
+          },
+          output: 'task_id: ses_child_1\n\n<task_result>ok</task_result>',
+          metadata: {
+            sessionId: 'ses_child_1',
+            model: {
+              providerID: 'opencode',
+              modelID: 'minimax-m2.5-free',
+            },
+          },
+        },
+      },
+    }),
+    [
+      {
+        type: 'item.completed',
+        item: {
+          type: 'collab_tool_call',
+          tool: 'spawn_agent',
+          receiver_thread_ids: ['ses_child_1'],
+          prompt: '请分析 /tmp/demo/a.js 文件',
+          agents_states: {
+            ses_child_1: {
+              status: 'completed',
+              message: 'task_id: ses_child_1\n\n<task_result>ok</task_result>',
+              title: '分析 a.js 文件',
+              role: 'explore',
+              target: 'a.js',
+              model: 'opencode/minimax-m2.5-free',
+            },
+          },
+        },
+      },
+      {
+        type: 'item.completed',
+        item: {
+          type: 'collab_tool_call',
+          tool: 'wait',
+          receiver_thread_ids: ['ses_child_1'],
+          prompt: '请分析 /tmp/demo/a.js 文件',
+          agents_states: {
+            ses_child_1: {
+              status: 'completed',
+              message: 'task_id: ses_child_1\n\n<task_result>ok</task_result>',
+              title: '分析 a.js 文件',
+              role: 'explore',
+              target: 'a.js',
+              model: 'opencode/minimax-m2.5-free',
+            },
+          },
+        },
+      },
+    ]
+  )
+})

package/apps/server/src/agents/runnerContract.test.js

@@ -0,0 +1,382 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+function withEnv(overrides, fn) {
+  const previous = new Map()
+
+  for (const [key, value] of Object.entries(overrides)) {
+    previous.set(key, process.env[key])
+    if (typeof value === 'undefined') {
+      delete process.env[key]
+    } else {
+      process.env[key] = value
+    }
+  }
+
+  return Promise.resolve()
+    .then(fn)
+    .finally(() => {
+      for (const [key, value] of previous.entries()) {
+        if (typeof value === 'undefined') {
+          delete process.env[key]
+        } else {
+          process.env[key] = value
+        }
+      }
+    })
+}
+
+async function importFreshRunnerModules() {
+  const suffix = `test=${Date.now()}-${Math.random().toString(16).slice(2)}`
+  const [
+    { streamPromptToCodexSession },
+    { streamPromptToClaudeCodeSession },
+    { streamPromptToOpenCodeSession },
+  ] = await Promise.all([
+    import(`../codex.js?${suffix}`),
+    import(`./claudeCodeRunner.js?${suffix}`),
+    import(`./openCodeRunner.js?${suffix}`),
+  ])
+
+  return {
+    streamPromptToCodexSession,
+    streamPromptToClaudeCodeSession,
+    streamPromptToOpenCodeSession,
+  }
+}
+
+function createFakeCodexBinary(tempDir) {
+  const scriptPath = path.join(tempDir, process.platform === 'win32' ? 'fake-codex.js' : 'fake-codex')
+  const script = `#!/usr/bin/env node
+const fs = require('node:fs')
+
+const args = process.argv.slice(2)
+const outputIndex = args.indexOf('--output-last-message')
+const outputFile = outputIndex >= 0 ? args[outputIndex + 1] : ''
+const threadId = 'thread-contract-1'
+
+let prompt = ''
+process.stdin.setEncoding('utf8')
+process.stdin.on('data', (chunk) => {
+  prompt += chunk
+})
+process.stdin.on('end', () => {
+  if (outputFile) {
+    fs.writeFileSync(outputFile, '最终回复')
+  }
+
+  process.stdout.write(JSON.stringify({ type: 'thread.started', thread_id: threadId }) + '\\n')
+  process.stdout.write(JSON.stringify({ type: 'item.started', item: { type: 'reasoning', text: '先分析' } }) + '\\n')
+  process.stdout.write(JSON.stringify({ type: 'item.started', item: { type: 'command_execution', command: 'Bash: pwd', status: 'in_progress' } }) + '\\n')
+  process.stdout.write(JSON.stringify({ type: 'item.completed', item: { type: 'command_execution', command: 'Bash: pwd', status: 'completed', exit_code: 0, aggregated_output: '/tmp/demo' } }) + '\\n')
+  process.stdout.write(JSON.stringify({ type: 'item.completed', item: { type: 'agent_message', text: '已完成修改' } }) + '\\n')
+  process.stdout.write(JSON.stringify({ type: 'turn.completed', result: '最终回复' }) + '\\n')
+})
+`
+
+  fs.writeFileSync(scriptPath, script, { mode: 0o755 })
+
+  if (process.platform !== 'win32') {
+    return scriptPath
+  }
+
+  const cmdPath = path.join(tempDir, 'fake-codex.cmd')
+  fs.writeFileSync(cmdPath, '@echo off\r\nnode "%~dp0fake-codex.js" %*\r\n')
+  return cmdPath
+}
+
+function createFakeClaudeBinary(tempDir) {
+  const scriptPath = path.join(tempDir, process.platform === 'win32' ? 'fake-claude.js' : 'fake-claude')
+  const script = `#!/usr/bin/env node
+const args = process.argv.slice(2)
+const promptIndex = args.indexOf('-p')
+const prompt = promptIndex >= 0 ? args[promptIndex + 1] || '' : ''
+const resumeIndex = args.indexOf('--resume')
+const threadId = resumeIndex >= 0 ? args[resumeIndex + 1] || 'thread-contract-1' : 'thread-contract-1'
+
+if (!prompt) {
+  process.stderr.write('missing prompt\\n')
+  process.exit(1)
+  return
+}
+
+process.stdout.write(JSON.stringify({
+  type: 'system',
+  subtype: 'init',
+  session_id: threadId,
+}) + '\\n')
+
+process.stdout.write(JSON.stringify({
+  type: 'assistant',
+  message: {
+    content: [
+      { type: 'thinking', thinking: '先分析' },
+      { type: 'tool_use', id: 'tool-1', name: 'Bash', input: { command: 'pwd' } },
+    ],
+  },
+}) + '\\n')
+
+process.stdout.write(JSON.stringify({
+  type: 'user',
+  message: {
+    content: [
+      { type: 'tool_result', tool_use_id: 'tool-1', content: '/tmp/demo', is_error: false },
+    ],
+  },
+}) + '\\n')
+
+process.stdout.write(JSON.stringify({
+  type: 'assistant',
+  message: {
+    content: [
+      { type: 'text', text: '已完成修改' },
+    ],
+  },
+}) + '\\n')
+
+process.stdout.write(JSON.stringify({
+  type: 'result',
+  result: '最终回复',
+}) + '\\n')
+`
+
+  fs.writeFileSync(scriptPath, script, { mode: 0o755 })
+
+  if (process.platform !== 'win32') {
+    return scriptPath
+  }
+
+  const cmdPath = path.join(tempDir, 'fake-claude.cmd')
+  fs.writeFileSync(cmdPath, '@echo off\r\nnode "%~dp0fake-claude.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
+const args = process.argv.slice(2)
+const sessionIndex = args.indexOf('--session')
+const sessionId = sessionIndex >= 0 ? args[sessionIndex + 1] || 'thread-contract-1' : 'thread-contract-1'
+const prompt = args[args.length - 1] || ''
+
+if (!prompt) {
+  process.stderr.write('missing prompt\\n')
+  process.exit(1)
+  return
+}
+
+process.stdout.write(JSON.stringify({
+  type: 'step_start',
+  sessionID: sessionId,
+  part: {
+    type: 'step-start',
+  },
+}) + '\\n')
+
+process.stdout.write(JSON.stringify({
+  type: 'tool_use',
+  sessionID: sessionId,
+  part: {
+    type: 'tool',
+    tool: 'read',
+    state: {
+      status: 'completed',
+      input: {
+        filePath: '/tmp/demo',
+      },
+      output: 'demo output',
+    },
+  },
+}) + '\\n')
+
+process.stdout.write(JSON.stringify({
+  type: 'text',
+  sessionID: sessionId,
+  part: {
+    type: 'text',
+    text: '最终回复',
+  },
+}) + '\\n')
+
+process.stdout.write(JSON.stringify({
+  type: 'step_finish',
+  sessionID: sessionId,
+  part: {
+    type: 'step-finish',
+    reason: 'stop',
+    tokens: {
+      input: 100,
+      output: 20,
+      cache: {
+        read: 10,
+      },
+    },
+  },
+}) + '\\n')
+`
+
+  fs.writeFileSync(scriptPath, script, { mode: 0o755 })
+
+  if (process.platform !== 'win32') {
+    return scriptPath
+  }
+
+  const cmdPath = path.join(tempDir, 'fake-opencode.cmd')
+  fs.writeFileSync(cmdPath, '@echo off\r\nnode "%~dp0fake-opencode.js" %*\r\n')
+  return cmdPath
+}
+
+function simplifyEvent(event = {}) {
+  if (event.type === 'status') {
+    return {
+      type: 'status',
+      stage: event.stage,
+      message: event.message,
+    }
+  }
+
+  if (event.type === 'completed') {
+    return {
+      type: 'completed',
+      message: event.message,
+    }
+  }
+
+  if (event.type !== 'agent_event') {
+    return { type: event.type }
+  }
+
+  return {
+    type: 'agent_event',
+    event: event.event,
+  }
+}
+
+async function collectRunnerContractEvents(streamSessionPrompt) {
+  const events = []
+  const stream = streamSessionPrompt(
+    { id: 'session-1', cwd: process.cwd() },
+    'runner-contract-case',
+    {
+      onEvent(event) {
+        events.push(simplifyEvent(event))
+      },
+    }
+  )
+
+  const result = await stream.result
+  return {
+    events,
+    result,
+  }
+}
+
+function projectRunnerContractPhases(events = []) {
+  return events.map((event) => {
+    if (event.type === 'status') {
+      return 'status'
+    }
+
+    if (event.type === 'completed') {
+      return 'completed'
+    }
+
+    if (event.type !== 'agent_event') {
+      return ''
+    }
+
+    const payload = event.event || {}
+    if (payload.type === 'thread.started') {
+      return 'thread.started'
+    }
+
+    if (payload.type === 'turn.started') {
+      return 'turn.started'
+    }
+
+    if (payload.type === 'item.started' && payload.item?.type === 'command_execution') {
+      return 'command.started'
+    }
+
+    if (payload.type === 'item.completed' && payload.item?.type === 'command_execution') {
+      return 'command.completed'
+    }
+
+    if (payload.type === 'item.completed' && payload.item?.type === 'agent_message') {
+      return 'agent_message'
+    }
+
+    if (payload.type === 'turn.completed') {
+      return 'turn.completed'
+    }
+
+    return ''
+  }).filter(Boolean)
+}
+
+function assertOrderedSubsequence(actual = [], expected = []) {
+  let actualIndex = 0
+
+  expected.forEach((item) => {
+    while (actualIndex < actual.length && actual[actualIndex] !== item) {
+      actualIndex += 1
+    }
+
+    assert.ok(actualIndex < actual.length, `未找到预期阶段：${item}，实际阶段：${actual.join(' -> ')}`)
+    actualIndex += 1
+  })
+}
+
+function assertRunnerContract(result, expectedThreadId) {
+  assert.deepEqual(result.result, {
+    sessionId: 'session-1',
+    threadId: expectedThreadId,
+    message: '最终回复',
+  })
+
+  const phases = projectRunnerContractPhases(result.events)
+  assertOrderedSubsequence(phases, [
+    'status',
+    'thread.started',
+    'command.started',
+    'command.completed',
+    'agent_message',
+    'turn.completed',
+    'completed',
+  ])
+}
+
+test('Codex / Claude Code / OpenCode runner 会产出兼容的核心事件结构', async () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'promptx-runner-contract-'))
+  const fakeCodexBin = createFakeCodexBinary(tempDir)
+  const fakeClaudeBin = createFakeClaudeBinary(tempDir)
+  const fakeOpenCodeBin = createFakeOpenCodeBinary(tempDir)
+
+  await withEnv(
+    {
+      CODEX_BIN: fakeCodexBin,
+      CLAUDE_CODE_BIN: fakeClaudeBin,
+      OPENCODE_BIN: fakeOpenCodeBin,
+    },
+    async () => {
+      const {
+        streamPromptToCodexSession,
+        streamPromptToClaudeCodeSession,
+        streamPromptToOpenCodeSession,
+      } = await importFreshRunnerModules()
+
+      const [codexResult, claudeResult, openCodeResult] = await Promise.all([
+        collectRunnerContractEvents(streamPromptToCodexSession),
+        collectRunnerContractEvents(streamPromptToClaudeCodeSession),
+        collectRunnerContractEvents(streamPromptToOpenCodeSession),
+      ])
+
+      assertRunnerContract(codexResult, 'thread-contract-1')
+      assertRunnerContract(claudeResult, 'thread-contract-1')
+      assertRunnerContract(openCodeResult, 'thread-contract-1')
+    }
+  )
+})

package/apps/server/src/appPaths.test.js

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import test from 'node:test'
+
+function withEnv(overrides, fn) {
+  const previous = new Map()
+
+  for (const [key, value] of Object.entries(overrides)) {
+    previous.set(key, process.env[key])
+    if (typeof value === 'undefined') {
+      delete process.env[key]
+    } else {
+      process.env[key] = value
+    }
+  }
+
+  return Promise.resolve()
+    .then(fn)
+    .finally(() => {
+      for (const [key, value] of previous.entries()) {
+        if (typeof value === 'undefined') {
+          delete process.env[key]
+        } else {
+          process.env[key] = value
+        }
+      }
+    })
+}
+
+test('appPaths resolves storage under PROMPTX_HOME by default', async () => {
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), 'promptx-home-'))
+
+  await withEnv(
+    {
+      PROMPTX_HOME: tempHome,
+      PROMPTX_DATA_DIR: undefined,
+      PROMPTX_UPLOADS_DIR: undefined,
+      PROMPTX_TMP_DIR: undefined,
+    },
+    async () => {
+      const appPaths = await import(`./appPaths.js?test=${Date.now()}`)
+      const resolved = appPaths.ensurePromptxStorageReady()
+
+      assert.equal(resolved.promptxHomeDir, tempHome)
+      assert.equal(resolved.dataDir, path.join(tempHome, 'data'))
+      assert.equal(resolved.uploadsDir, path.join(tempHome, 'uploads'))
+      assert.equal(resolved.tmpDir, path.join(tempHome, 'tmp'))
+    }
+  )
+})