@muyichengshayu/promptx 0.2.13 → 0.2.15

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

@@ -1,376 +0,0 @@
-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

@@ -1,160 +0,0 @@
-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
-    }
-  }
-})