@muyichengshayu/promptx 0.2.7 → 0.2.8

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

@@ -0,0 +1,93 @@
+import assert from 'node:assert/strict'
+import http from 'node:http'
+import test from 'node:test'
+
+import { getInternalAuthHeaderName, getInternalAuthToken } from './internalAuth.js'
+import { createServerClient } from './serverClient.js'
+
+function startJsonServer(handler) {
+  return new Promise((resolve) => {
+    const server = http.createServer(handler)
+    server.listen(0, '127.0.0.1', () => {
+      const address = server.address()
+      resolve({
+        server,
+        baseUrl: `http://127.0.0.1:${address.port}`,
+      })
+    })
+  })
+}
+
+test('serverClient attaches internal auth header and posts JSON payload', async () => {
+  const { server, baseUrl } = await startJsonServer(async (request, response) => {
+    assert.equal(request.headers[getInternalAuthHeaderName()], getInternalAuthToken())
+
+    const chunks = []
+    for await (const chunk of request) {
+      chunks.push(chunk)
+    }
+    const body = JSON.parse(Buffer.concat(chunks).toString('utf8'))
+    assert.equal(body.items.length, 1)
+
+    response.writeHead(200, { 'Content-Type': 'application/json' })
+    response.end(JSON.stringify({ ok: true }))
+  })
+
+  try {
+    const client = createServerClient({ baseUrl, timeoutMs: 1000 })
+    const payload = await client.postEvents([{ id: 1 }], { runnerId: 'runner-1' })
+    assert.deepEqual(payload, { ok: true })
+  } finally {
+    await new Promise((resolve) => server.close(resolve))
+  }
+})
+
+test('serverClient fails fast on timeout', async () => {
+  const { server, baseUrl } = await startJsonServer((_request, response) => {
+    setTimeout(() => {
+      response.writeHead(200, { 'Content-Type': 'application/json' })
+      response.end(JSON.stringify({ ok: true }))
+    }, 700)
+  })
+
+  try {
+    const client = createServerClient({ baseUrl, timeoutMs: 500 })
+    await assert.rejects(
+      () => client.postStatus({ ok: true }),
+      (error) => error?.statusCode === 504 && /超时/.test(String(error?.message || ''))
+    )
+  } finally {
+    await new Promise((resolve) => server.close(resolve))
+  }
+})
+
+test('serverClient reads system config with internal auth header', async () => {
+  const { server, baseUrl } = await startJsonServer((request, response) => {
+    assert.equal(request.method, 'GET')
+    assert.equal(request.url, '/internal/system-config')
+    assert.equal(request.headers[getInternalAuthHeaderName()], getInternalAuthToken())
+
+    response.writeHead(200, { 'Content-Type': 'application/json' })
+    response.end(JSON.stringify({
+      config: {
+        runner: {
+          maxConcurrentRuns: 4,
+        },
+      },
+    }))
+  })
+
+  try {
+    const client = createServerClient({ baseUrl, timeoutMs: 1000 })
+    const payload = await client.getSystemConfig()
+    assert.deepEqual(payload, {
+      config: {
+        runner: {
+          maxConcurrentRuns: 4,
+        },
+      },
+    })
+  } finally {
+    await new Promise((resolve) => server.close(resolve))
+  }
+})

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

@@ -0,0 +1,127 @@
+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'
+
+import {
+  decodeClaudeProjectPath,
+  listKnownClaudeCodeSessions,
+  listKnownOpenCodeSessions,
+} from './agentSessionDiscovery.js'
+
+test('decodeClaudeProjectPath decodes unix-style project keys', () => {
+  assert.equal(
+    decodeClaudeProjectPath('-Users-bravf-code-promptx'),
+    '/Users/bravf/code/promptx'
+  )
+})
+
+test('listKnownClaudeCodeSessions merges transcripts and project files', () => {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'promptx-claude-discovery-'))
+  const claudeHome = path.join(tempRoot, '.claude')
+  const transcriptDir = path.join(claudeHome, 'transcripts')
+  const projectsDir = path.join(claudeHome, 'projects', '-Users-bravf-code-promptx')
+
+  fs.mkdirSync(transcriptDir, { recursive: true })
+  fs.mkdirSync(projectsDir, { recursive: true })
+
+  const transcriptPath = path.join(transcriptDir, 'ses_transcript_only.jsonl')
+  const projectPath = path.join(projectsDir, 'ses_project.jsonl')
+
+  fs.writeFileSync(transcriptPath, `${JSON.stringify({ type: 'user', message: { text: '请继续修复 PromptX' } })}\n`)
+  fs.writeFileSync(projectPath, `${JSON.stringify({ type: 'user', message: { text: '帮我看下项目源码' } })}\n`)
+
+  const now = new Date('2026-04-13T08:00:00.000Z')
+  fs.utimesSync(transcriptPath, now, now)
+  fs.utimesSync(projectPath, new Date(now.getTime() + 1000), new Date(now.getTime() + 1000))
+
+  try {
+    const items = listKnownClaudeCodeSessions({
+      claudeHome,
+      limit: 10,
+      cwd: '/Users/bravf/code/promptx',
+    })
+
+    assert.equal(items.length, 2)
+    assert.deepEqual(
+      items.map((item) => ({
+        id: item.id,
+        cwd: item.cwd,
+        matchedCwd: item.matchedCwd,
+      })),
+      [
+        {
+          id: 'ses_project',
+          cwd: '/Users/bravf/code/promptx',
+          matchedCwd: true,
+        },
+        {
+          id: 'ses_transcript_only',
+          cwd: '',
+          matchedCwd: false,
+        },
+      ]
+    )
+    assert.match(items[0].label, /项目源码|promptx/i)
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true })
+  }
+})
+
+test('listKnownOpenCodeSessions discovers sessions from desktop dat files', () => {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'promptx-opencode-discovery-'))
+  const dataDir = path.join(tempRoot, 'ai.opencode.desktop')
+  fs.mkdirSync(dataDir, { recursive: true })
+
+  const globalPath = path.join(dataDir, 'opencode.global.dat')
+  const workspacePath = path.join(
+    dataDir,
+    `opencode.workspace.${Buffer.from('/Users/bravf/code/promptx').toString('base64')}.test.dat`
+  )
+
+  fs.writeFileSync(globalPath, JSON.stringify({
+    'layout.page': JSON.stringify({
+      lastProjectSession: {
+        '/Users/bravf/code/promptx': {
+          directory: '/Users/bravf/code/promptx',
+          id: 'ses_global',
+          at: '2026-04-13T08:00:00.000Z',
+        },
+      },
+      lastSession: {
+        '/Users/bravf/code/promptx': 'ses_last',
+      },
+    }),
+  }))
+
+  fs.writeFileSync(workspacePath, JSON.stringify({
+    'session:ses_global:comments': '[]',
+    'session:ses_workspace:prompt': '请继续处理前端主题',
+  }))
+
+  try {
+    const items = listKnownOpenCodeSessions({
+      openCodeDataDir: dataDir,
+      openCodeDbPath: path.join(tempRoot, 'missing-opencode.db'),
+      cwd: '/Users/bravf/code/promptx',
+      limit: 10,
+    })
+
+    assert.deepEqual(
+      items.map((item) => ({
+        id: item.id,
+        cwd: item.cwd,
+        matchedCwd: item.matchedCwd,
+      })),
+      [
+        { id: 'ses_global', cwd: '/Users/bravf/code/promptx', matchedCwd: true },
+        { id: 'ses_workspace', cwd: '/Users/bravf/code/promptx', matchedCwd: true },
+        { id: 'ses_last', cwd: '/Users/bravf/code/promptx', matchedCwd: true },
+      ]
+    )
+    assert.match(items[1].label, /前端主题/)
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true })
+  }
+})

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

@@ -0,0 +1,433 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+
+import {
+  createClaudeNormalizationState,
+  extractClaudeAssistantText,
+  extractClaudeResultText,
+  extractClaudeSessionId,
+  normalizeClaudeEvent,
+  normalizeClaudeEvents,
+} from './claudeCodeRunner.js'
+
+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 fatal auth api_retry to error event', () => {
+  assert.deepEqual(
+    normalizeClaudeEvents({
+      type: 'system',
+      subtype: 'api_retry',
+      attempt: 1,
+      max_retries: 10,
+      error_status: 401,
+      error: 'authentication_failed',
+    }),
+    [{
+      type: 'error',
+      message: 'Claude Code 认证失败（HTTP 401 authentication_failed）。请重新登录 Claude Code，或检查当前环境中的认证令牌配置。',
+    }]
+  )
+})
+
+test('normalizeClaudeEvents maps transient api_retry to reconnecting error event', () => {
+  assert.deepEqual(
+    normalizeClaudeEvents({
+      type: 'system',
+      subtype: 'api_retry',
+      attempt: 2,
+      max_retries: 10,
+      error_status: 503,
+      error: 'overloaded',
+    }),
+    [{
+      type: 'error',
+      message: 'Reconnecting... 2/10 (HTTP 503 overloaded)',
+    }]
+  )
+})
+
+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>',
+      },
+    }]
+  )
+})
+
+test('normalizeClaudeEvents keeps full TodoWrite input for downstream todo parsing', () => {
+  const state = createClaudeNormalizationState()
+
+  const events = normalizeClaudeEvents({
+    type: 'assistant',
+    message: {
+      content: [
+        {
+          type: 'tool_use',
+          id: 'tool-todo-1',
+          name: 'TodoWrite',
+          input: {
+            todos: [
+              { content: '定位 Codex CLI 相关源码', activeForm: '正在定位 Codex CLI 相关源码', status: 'in_progress' },
+              { content: '阅读核心模块与数据流', activeForm: '正在阅读核心模块与数据流', status: 'pending' },
+              { content: '整理架构与关键设计', activeForm: '正在整理架构与关键设计', status: 'pending' },
+            ],
+          },
+        },
+      ],
+    },
+  }, state)
+
+  assert.equal(events[0]?.type, 'item.started')
+  assert.match(events[0]?.item?.command || '', /TodoWrite: \{"todos":\[/)
+  assert.doesNotMatch(events[0]?.item?.command || '', /\.\.\.$/)
+  assert.match(events[0]?.item?.command || '', /"activeForm":"正在阅读核心模块与数据流"/)
+})
+
+test('normalizeClaudeEvents maps Agent sub-agents into collaboration events', () => {
+  const state = createClaudeNormalizationState()
+
+  assert.deepEqual(
+    normalizeClaudeEvents({
+      type: 'assistant',
+      message: {
+        content: [
+          {
+            type: 'tool_use',
+            id: 'agent-tool-1',
+            name: 'Agent',
+            input: {
+              description: 'Analyze a.js exports',
+              subagent_type: 'general-purpose',
+              prompt: 'Analyze a.js in the current directory.',
+              model: 'sonnet',
+            },
+          },
+        ],
+      },
+    }, state),
+    [{
+      type: 'item.started',
+      item: {
+        type: 'collab_tool_call',
+        tool: 'spawn_agent',
+        receiver_thread_ids: [],
+        prompt: 'Analyze a.js in the current directory.',
+        agents_states: {},
+      },
+    }]
+  )
+
+  assert.deepEqual(
+    normalizeClaudeEvents({
+      type: 'system',
+      subtype: 'task_started',
+      tool_use_id: 'agent-tool-1',
+      task_id: 'task-a',
+      description: 'Analyze a.js exports',
+    }, state),
+    [{
+      type: 'item.completed',
+      item: {
+        type: 'collab_tool_call',
+        tool: 'spawn_agent',
+        receiver_thread_ids: ['task-a'],
+        prompt: 'Analyze a.js in the current directory.',
+        agents_states: {
+          'task-a': {
+            status: 'running',
+            message: '',
+            title: 'Analyze a.js exports',
+            role: 'general-purpose',
+            target: 'a.js',
+            model: 'sonnet',
+            task_id: 'task-a',
+          },
+        },
+      },
+    }]
+  )
+
+  assert.deepEqual(
+    normalizeClaudeEvents({
+      type: 'user',
+      message: {
+        content: [
+          {
+            type: 'tool_result',
+            tool_use_id: 'agent-tool-1',
+            content: 'found 2 exports',
+            is_error: false,
+          },
+        ],
+      },
+    }, state),
+    [{
+      type: 'item.completed',
+      item: {
+        type: 'collab_tool_call',
+        tool: 'wait',
+        receiver_thread_ids: ['task-a'],
+        prompt: 'Analyze a.js in the current directory.',
+        agents_states: {
+          'task-a': {
+            status: 'completed',
+            message: 'found 2 exports',
+            title: 'Analyze a.js exports',
+            role: 'general-purpose',
+            target: 'a.js',
+            model: 'sonnet',
+            task_id: 'task-a',
+          },
+        },
+      },
+    }]
+  )
+})
+
+test('normalizeClaudeEvents maps task_completed and ignores duplicate tool_result for Agent sub-agents', () => {
+  const state = createClaudeNormalizationState()
+
+  normalizeClaudeEvents({
+    type: 'assistant',
+    message: {
+      content: [
+        {
+          type: 'tool_use',
+          id: 'agent-tool-2',
+          name: 'Agent',
+          input: {
+            description: 'Analyze b.js exports',
+            subagent_type: 'general-purpose',
+            prompt: 'Analyze b.js in the current directory.',
+            model: 'sonnet',
+          },
+        },
+      ],
+    },
+  }, state)
+
+  normalizeClaudeEvents({
+    type: 'system',
+    subtype: 'task_started',
+    tool_use_id: 'agent-tool-2',
+    task_id: 'task-b',
+    description: 'Analyze b.js exports',
+  }, state)
+
+  assert.deepEqual(
+    normalizeClaudeEvents({
+      type: 'system',
+      subtype: 'task_completed',
+      task_id: 'task-b',
+      result: 'found 2 exports',
+      description: 'Analyze b.js exports',
+    }, state),
+    [{
+      type: 'item.completed',
+      item: {
+        type: 'collab_tool_call',
+        tool: 'wait',
+        receiver_thread_ids: ['task-b'],
+        prompt: 'Analyze b.js in the current directory.',
+        agents_states: {
+          'task-b': {
+            status: 'completed',
+            message: 'found 2 exports',
+            title: 'Analyze b.js exports',
+            role: 'general-purpose',
+            target: 'b.js',
+            model: 'sonnet',
+            task_id: 'task-b',
+          },
+        },
+      },
+    }]
+  )
+
+  assert.deepEqual(
+    normalizeClaudeEvents({
+      type: 'user',
+      message: {
+        content: [
+          {
+            type: 'tool_result',
+            tool_use_id: 'agent-tool-2',
+            content: 'duplicate result',
+            is_error: false,
+          },
+        ],
+      },
+    }, state),
+    []
+  )
+})