@muyichengshayu/promptx 0.2.7 → 0.2.8

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

@@ -0,0 +1,376 @@
+import assert from 'node:assert/strict'
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import Fastify from 'fastify'
+import test from 'node:test'
+
+import {
+  createWorkspaceSuggestionService,
+  registerCodexRoutes,
+} from './codexRoutes.js'
+
+test('workspace suggestion service merges and deduplicates sources', () => {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'promptx-workspaces-'))
+  const workspaceRootDir = path.join(tempRoot, 'promptx')
+  const siblingA = path.join(tempRoot, 'repo-a')
+  const siblingB = path.join(tempRoot, 'repo-b')
+  const knownOnly = path.join(tempRoot, 'known-only')
+
+  fs.mkdirSync(workspaceRootDir, { recursive: true })
+  fs.mkdirSync(siblingA, { recursive: true })
+  fs.mkdirSync(siblingB, { recursive: true })
+  fs.mkdirSync(knownOnly, { recursive: true })
+
+  try {
+    const service = createWorkspaceSuggestionService({
+      listKnownWorkspacesByEngine: () => [siblingA, knownOnly],
+      listPromptxCodexSessions: () => [
+        { cwd: siblingB },
+        { cwd: workspaceRootDir },
+      ],
+      workspaceParentDir: tempRoot,
+      workspaceRootDir,
+    })
+
+    const items = service.listWorkspaceSuggestions(10, 'codex')
+    assert.deepEqual(items, [
+      workspaceRootDir,
+      knownOnly,
+      siblingA,
+      siblingB,
+    ])
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true })
+  }
+})
+
+test('codex routes return stop acceptance and event history', async () => {
+  const app = Fastify()
+  registerCodexRoutes(app, {
+    broadcastServerEvent: () => {},
+    clearTaskCodexSessionReferences: () => [],
+    createPromptxCodexSession: () => ({ id: 'session-1' }),
+    decorateCodexSession: (session) => session,
+    decorateCodexSessionList: (items) => items,
+    deletePromptxCodexSession: () => null,
+    getCodexRunById(runId) {
+      if (runId !== 'run-1') {
+        return null
+      }
+      return {
+        id: 'run-1',
+        status: 'running',
+      }
+    },
+    getPromptxCodexSessionById: () => null,
+    getRunningCodexRunBySessionId: () => null,
+    isActiveRunStatus: (status) => ['queued', 'starting', 'running', 'stopping'].includes(status),
+    listCodexRunEvents: () => [{ seq: 1, type: 'stdout', text: 'hello' }],
+    listDirectoryPickerTree: () => ({}),
+    listPromptxCodexSessions: () => [],
+    listWorkspaceSuggestions: () => [],
+    listWorkspaceTree: () => ({}),
+    runDispatchService: {
+      async requestRunStop() {
+        return {
+          accepted: true,
+          run: {
+            id: 'run-1',
+            status: 'stopping',
+          },
+        }
+      },
+    },
+    searchDirectoryPickerEntries: () => ({}),
+    searchWorkspaceFileContent: () => ({}),
+    searchWorkspaceEntries: () => ({}),
+    updatePromptxCodexSession: () => null,
+  })
+  await app.ready()
+
+  try {
+    const stopResponse = await app.inject({
+      method: 'POST',
+      url: '/api/codex/runs/run-1/stop',
+      payload: {
+        reason: 'user_requested',
+      },
+    })
+    assert.equal(stopResponse.statusCode, 202)
+    assert.equal(stopResponse.json().run.status, 'stopping')
+
+    const eventsResponse = await app.inject({
+      method: 'GET',
+      url: '/api/codex/runs/run-1/events',
+    })
+    assert.equal(eventsResponse.statusCode, 200)
+    assert.deepEqual(eventsResponse.json(), {
+      items: [{ seq: 1, type: 'stdout', text: 'hello' }],
+    })
+  } finally {
+    await app.close()
+  }
+})
+
+test('codex routes expose local session candidates by engine', async () => {
+  const app = Fastify()
+  registerCodexRoutes(app, {
+    broadcastServerEvent: () => {},
+    clearTaskCodexSessionReferences: () => [],
+    createPromptxCodexSession: () => ({ id: 'session-1' }),
+    decorateCodexSession: (session) => session,
+    decorateCodexSessionList: (items) => items,
+    deletePromptxCodexSession: () => null,
+    getCodexRunById: () => null,
+    getPromptxCodexSessionById: () => null,
+    getRunningCodexRunBySessionId: () => null,
+    isActiveRunStatus: () => false,
+    listCodexRunEvents: () => [],
+    listDirectoryPickerTree: () => ({}),
+    listKnownSessionsByEngine(engine, options) {
+      return [{
+        id: `${engine}-session-1`,
+        engine,
+        cwd: options.cwd,
+        updatedAt: '2026-04-13T08:00:00.000Z',
+      }]
+    },
+    listPromptxCodexSessions: () => [],
+    listWorkspaceSuggestions: () => [],
+    listWorkspaceTree: () => ({}),
+    runDispatchService: {
+      async requestRunStop() {
+        return null
+      },
+    },
+    searchDirectoryPickerEntries: () => ({}),
+    searchWorkspaceFileContent: () => ({}),
+    searchWorkspaceEntries: () => ({}),
+    updatePromptxCodexSession: () => null,
+  })
+  await app.ready()
+
+  try {
+    const response = await app.inject({
+      method: 'GET',
+      url: '/api/codex/session-candidates?engine=claude-code&cwd=%2Ftmp%2Fproject&limit=20',
+    })
+
+    assert.equal(response.statusCode, 200)
+    assert.deepEqual(response.json(), {
+      items: [{
+        id: 'claude-code-session-1',
+        engine: 'claude-code',
+        cwd: '/tmp/project',
+        updatedAt: '2026-04-13T08:00:00.000Z',
+      }],
+    })
+  } finally {
+    await app.close()
+  }
+})
+
+test('codex routes broadcast task updates when deleting a session with references', async () => {
+  const broadcasts = []
+  const app = Fastify()
+  registerCodexRoutes(app, {
+    broadcastServerEvent(type, payload) {
+      broadcasts.push({ type, payload })
+    },
+    clearTaskCodexSessionReferences: () => ['task-a', 'task-b'],
+    createPromptxCodexSession: () => ({ id: 'session-1' }),
+    decorateCodexSession: (session) => session,
+    decorateCodexSessionList: (items) => items,
+    deletePromptxCodexSession: () => ({ id: 'session-1' }),
+    getCodexRunById: () => null,
+    getPromptxCodexSessionById: () => ({ id: 'session-1', agentBindings: [] }),
+    getRunningCodexRunBySessionId: () => null,
+    isActiveRunStatus: () => false,
+    listCodexRunEvents: () => [],
+    listDirectoryPickerTree: () => ({}),
+    listPromptxCodexSessions: () => [],
+    listWorkspaceSuggestions: () => [],
+    listWorkspaceTree: () => ({}),
+    runDispatchService: {
+      async requestRunStop() {
+        return null
+      },
+    },
+    searchDirectoryPickerEntries: () => ({}),
+    searchWorkspaceFileContent: () => ({}),
+    searchWorkspaceEntries: () => ({}),
+    updatePromptxCodexSession: () => null,
+  })
+  await app.ready()
+
+  try {
+    const response = await app.inject({
+      method: 'DELETE',
+      url: '/api/codex/sessions/session-1',
+    })
+
+    assert.equal(response.statusCode, 204)
+    assert.deepEqual(broadcasts, [
+      {
+        type: 'sessions.changed',
+        payload: { sessionId: 'session-1' },
+      },
+      {
+        type: 'tasks.changed',
+        payload: { taskSlug: 'task-a', reason: 'session-cleared' },
+      },
+      {
+        type: 'tasks.changed',
+        payload: { taskSlug: 'task-b', reason: 'session-cleared' },
+      },
+    ])
+  } finally {
+    await app.close()
+  }
+})
+
+test('codex routes reset session and clear related run history', async () => {
+  const broadcasts = []
+  const deletedTaskRuns = []
+  const app = Fastify()
+  registerCodexRoutes(app, {
+    broadcastServerEvent(type, payload) {
+      broadcasts.push({ type, payload })
+    },
+    clearTaskCodexSessionReferences: () => [],
+    createPromptxCodexSession: () => ({ id: 'session-1' }),
+    decorateCodexSession: (session) => ({ ...session, decorated: true }),
+    decorateCodexSessionList: (items) => items,
+    deletePromptxCodexSession: () => null,
+    deleteTaskCodexRuns(taskSlug) {
+      deletedTaskRuns.push(taskSlug)
+    },
+    getCodexRunById: () => null,
+    getPromptxCodexSessionById: () => ({ id: 'session-1' }),
+    getRunningCodexRunBySessionId: () => null,
+    getRunningCodexRunByTaskSlug: () => null,
+    isActiveRunStatus: () => false,
+    listCodexRunEvents: () => [],
+    listDirectoryPickerTree: () => ({}),
+    listPromptxCodexSessions: () => [],
+    listTaskSlugsByCodexSessionId: () => ['task-a', 'task-b'],
+    listWorkspaceSuggestions: () => [],
+    listWorkspaceTree: () => ({}),
+    resetPromptxCodexSession: () => ({ id: 'session-1', title: '项目 A' }),
+    runDispatchService: {
+      async requestRunStop() {
+        return null
+      },
+    },
+    searchDirectoryPickerEntries: () => ({}),
+    searchWorkspaceFileContent: () => ({}),
+    searchWorkspaceEntries: () => ({}),
+    updatePromptxCodexSession: () => null,
+  })
+  await app.ready()
+
+  try {
+    const response = await app.inject({
+      method: 'POST',
+      url: '/api/codex/sessions/session-1/reset',
+    })
+
+    assert.equal(response.statusCode, 200)
+    assert.deepEqual(response.json(), {
+      session: {
+        id: 'session-1',
+        title: '项目 A',
+        decorated: true,
+      },
+      affectedTaskSlugs: ['task-a', 'task-b'],
+    })
+    assert.deepEqual(deletedTaskRuns, ['task-a', 'task-b'])
+    assert.deepEqual(broadcasts, [
+      {
+        type: 'sessions.changed',
+        payload: { sessionId: 'session-1' },
+      },
+      {
+        type: 'runs.changed',
+        payload: { taskSlug: 'task-a' },
+      },
+      {
+        type: 'runs.changed',
+        payload: { taskSlug: 'task-b' },
+      },
+    ])
+  } finally {
+    await app.close()
+  }
+})
+
+test('codex routes expose workspace content search for source browser', async () => {
+  const app = Fastify()
+  registerCodexRoutes(app, {
+    broadcastServerEvent: () => {},
+    clearTaskCodexSessionReferences: () => [],
+    createPromptxCodexSession: () => ({ id: 'session-1' }),
+    decorateCodexSession: (session) => session,
+    decorateCodexSessionList: (items) => items,
+    deletePromptxCodexSession: () => null,
+    getCodexRunById: () => null,
+    getPromptxCodexSessionById: (sessionId) => (sessionId === 'session-1' ? { id: 'session-1', cwd: '/tmp/project' } : null),
+    getRunningCodexRunBySessionId: () => null,
+    isActiveRunStatus: () => false,
+    listCodexRunEvents: () => [],
+    listDirectoryPickerTree: () => ({}),
+    listPromptxCodexSessions: () => [],
+    listWorkspaceSuggestions: () => [],
+    listWorkspaceTree: () => ({}),
+    readWorkspaceFileContent: () => ({}),
+    runDispatchService: {
+      async requestRunStop() {
+        return null
+      },
+    },
+    searchDirectoryPickerEntries: () => ({}),
+    searchWorkspaceEntries: () => ({}),
+    searchWorkspaceFileContent(cwd, options) {
+      return {
+        cwd,
+        query: options.query,
+        items: [
+          {
+            path: 'src/main.ts',
+            line: 3,
+            column: 5,
+            preview: 'const needle = true',
+          },
+        ],
+        truncated: false,
+      }
+    },
+    updatePromptxCodexSession: () => null,
+  })
+  await app.ready()
+
+  try {
+    const response = await app.inject({
+      method: 'GET',
+      url: '/api/codex/sessions/session-1/files/content-search?q=needle',
+    })
+
+    assert.equal(response.statusCode, 200)
+    assert.deepEqual(response.json(), {
+      cwd: '/tmp/project',
+      query: 'needle',
+      items: [
+        {
+          path: 'src/main.ts',
+          line: 3,
+          column: 5,
+          preview: 'const needle = true',
+        },
+      ],
+      truncated: false,
+    })
+  } finally {
+    await app.close()
+  }
+})

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

@@ -0,0 +1,160 @@
+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'
+
+test('listTaskCodexRunsWithOptions 支持 events=none|latest|all，并兼容旧参数', async () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'promptx-codex-runs-'))
+  const originalCwd = process.cwd()
+  const originalDataDir = process.env.PROMPTX_DATA_DIR
+  const dataDir = path.join(tempDir, 'data')
+  fs.mkdirSync(dataDir, { recursive: true })
+  process.chdir(tempDir)
+  process.env.PROMPTX_DATA_DIR = dataDir
+
+  try {
+    const { run } = await import('./db.js')
+    const {
+      appendCodexRunEvent,
+      listTaskCodexRunsWithOptions,
+    } = await import(`./codexRuns.js?test=${Date.now()}`)
+
+    const now = new Date().toISOString()
+    const earlier = new Date(Date.now() - 60_000).toISOString()
+
+    run(
+      `INSERT INTO tasks (slug, edit_token, title, auto_title, last_prompt_preview, codex_session_id, visibility, expires_at, created_at, updated_at)
+       VALUES (?, ?, '', '', '', ?, 'private', NULL, ?, ?)`,
+      ['task-1', 'token-1', 'session-1', now, now]
+    )
+    run(
+      `INSERT INTO codex_sessions (id, title, cwd, codex_thread_id, created_at, updated_at)
+       VALUES (?, ?, ?, '', ?, ?)`,
+      ['session-1', 'Repo Session', tempDir, now, now]
+    )
+    run(
+      `INSERT INTO codex_runs (id, task_slug, session_id, prompt, prompt_blocks_json, status, response_message, error_message, created_at, updated_at, started_at, finished_at)
+       VALUES (?, ?, ?, ?, ?, 'completed', '', '', ?, ?, ?, ?)`,
+      ['run-1', 'task-1', 'session-1', 'hello', JSON.stringify([
+        { type: 'text', content: '请看这张图', meta: {} },
+        { type: 'image', content: '/uploads/demo.png', meta: {} },
+      ]), now, now, now, now]
+    )
+    run(
+      `INSERT INTO codex_runs (id, task_slug, session_id, prompt, prompt_blocks_json, status, response_message, error_message, created_at, updated_at, started_at, finished_at)
+       VALUES (?, ?, ?, ?, ?, 'completed', '', '', ?, ?, ?, ?)`,
+      ['run-2', 'task-1', 'session-1', 'older', '[]', earlier, earlier, earlier, earlier]
+    )
+
+    appendCodexRunEvent('run-1', 1, { type: 'turn.started' })
+    appendCodexRunEvent('run-1', 2, { type: 'turn.completed' })
+    appendCodexRunEvent('run-2', 1, { type: 'thread.started', thread_id: 'thread-older' })
+
+    const summaryRuns = listTaskCodexRunsWithOptions('task-1', { limit: 20, events: 'none' })
+    assert.equal(summaryRuns?.length, 2)
+    assert.equal(summaryRuns[0].id, 'run-1')
+    assert.equal(summaryRuns[0].eventCount, 2)
+    assert.equal(summaryRuns[0].lastEventSeq, 2)
+    assert.equal(summaryRuns[0].eventsIncluded, false)
+    assert.deepEqual(summaryRuns[0].events, [])
+    assert.deepEqual(summaryRuns[0].promptBlocks, [
+      { type: 'text', content: '请看这张图', meta: {} },
+      { type: 'image', content: '/uploads/demo.png', meta: {} },
+    ])
+    assert.equal(summaryRuns[1].id, 'run-2')
+    assert.equal(summaryRuns[1].eventsIncluded, false)
+    assert.deepEqual(summaryRuns[1].events, [])
+
+    const latestRuns = listTaskCodexRunsWithOptions('task-1', { limit: 20, events: 'latest' })
+    assert.equal(latestRuns?.length, 2)
+    assert.equal(latestRuns[0].eventsIncluded, true)
+    assert.deepEqual(latestRuns[0].events.map((item) => item.seq), [1, 2])
+    assert.equal(latestRuns[1].eventsIncluded, false)
+    assert.deepEqual(latestRuns[1].events, [])
+
+    const detailedRuns = listTaskCodexRunsWithOptions('task-1', { limit: 20, events: 'all' })
+    assert.equal(detailedRuns?.length, 2)
+    assert.equal(detailedRuns[0].eventsIncluded, true)
+    assert.deepEqual(detailedRuns[0].events.map((item) => item.seq), [1, 2])
+    assert.equal(detailedRuns[1].eventsIncluded, true)
+    assert.deepEqual(detailedRuns[1].events.map((item) => item.seq), [1])
+
+    const legacyAllRuns = listTaskCodexRunsWithOptions('task-1', { limit: 20, includeEvents: true })
+    assert.equal(legacyAllRuns?.[0]?.eventsIncluded, true)
+    assert.equal(legacyAllRuns?.[1]?.eventsIncluded, true)
+
+    const legacyLatestRuns = listTaskCodexRunsWithOptions('task-1', { limit: 20, includeLatestEvents: true })
+    assert.equal(legacyLatestRuns?.[0]?.eventsIncluded, true)
+    assert.equal(legacyLatestRuns?.[1]?.eventsIncluded, false)
+  } finally {
+    process.chdir(originalCwd)
+    if (typeof originalDataDir === 'string') {
+      process.env.PROMPTX_DATA_DIR = originalDataDir
+    } else {
+      delete process.env.PROMPTX_DATA_DIR
+    }
+  }
+})
+
+test('listStaleActiveCodexRuns 会把最近事件视为运行活跃信号', async () => {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'promptx-codex-stale-'))
+  const originalCwd = process.cwd()
+  const originalDataDir = process.env.PROMPTX_DATA_DIR
+  const dataDir = path.join(tempDir, 'data')
+  fs.mkdirSync(dataDir, { recursive: true })
+  process.chdir(tempDir)
+  process.env.PROMPTX_DATA_DIR = dataDir
+
+  try {
+    const { run } = await import('./db.js')
+    const {
+      appendCodexRunEvent,
+      listStaleActiveCodexRuns,
+    } = await import(`./codexRuns.js?test=${Date.now() + 1}`)
+
+    const suffix = Date.now().toString(36)
+    const staleAt = new Date(Date.now() - 60_000).toISOString()
+    const now = new Date().toISOString()
+    const taskSlug = `task-${suffix}`
+    const sessionId = `session-${suffix}`
+    const activeRunId = `run-active-${suffix}`
+    const staleRunId = `run-stale-${suffix}`
+
+    run(
+      `INSERT INTO tasks (slug, edit_token, title, auto_title, last_prompt_preview, codex_session_id, visibility, expires_at, created_at, updated_at)
+       VALUES (?, ?, '', '', '', ?, 'private', NULL, ?, ?)`,
+      [taskSlug, `token-${suffix}`, sessionId, now, now]
+    )
+    run(
+      `INSERT INTO codex_sessions (id, title, cwd, codex_thread_id, created_at, updated_at)
+       VALUES (?, ?, ?, '', ?, ?)`,
+      [sessionId, 'Session 1', tempDir, now, now]
+    )
+    run(
+      `INSERT INTO codex_runs (id, task_slug, session_id, prompt, prompt_blocks_json, status, response_message, error_message, created_at, updated_at, started_at, finished_at)
+       VALUES (?, ?, ?, ?, '[]', 'running', '', '', ?, ?, ?, NULL)`,
+      [activeRunId, taskSlug, sessionId, 'hello', staleAt, staleAt, staleAt]
+    )
+    run(
+      `INSERT INTO codex_runs (id, task_slug, session_id, prompt, prompt_blocks_json, status, response_message, error_message, created_at, updated_at, started_at, finished_at)
+       VALUES (?, ?, ?, ?, '[]', 'running', '', '', ?, ?, ?, NULL)`,
+      [staleRunId, taskSlug, sessionId, 'hello again', staleAt, staleAt, staleAt]
+    )
+
+    appendCodexRunEvent(activeRunId, {
+      type: 'stdout',
+      text: 'heartbeat',
+    }, 1)
+
+    const staleRuns = listStaleActiveCodexRuns(1000)
+    assert.deepEqual(staleRuns.map((item) => item.id), [staleRunId])
+  } finally {
+    process.chdir(originalCwd)
+    if (typeof originalDataDir === 'string') {
+      process.env.PROMPTX_DATA_DIR = originalDataDir
+    } else {
+      delete process.env.PROMPTX_DATA_DIR
+    }
+  }
+})