1324 lines
58 KiB
TypeScript
1324 lines
58 KiB
TypeScript
import { runScenarios } from '../../../scripts/test-scenarios.mjs'
|
|
import { describe, expect, it, vi } from 'vitest'
|
|
import {
|
|
CodexVirtualHarness,
|
|
discoverCodexVirtualWorkspaces,
|
|
paginateCodexNativeHistory,
|
|
projectCodexNativeHistory,
|
|
} from '../src/codex/virtual-harness.js'
|
|
import { CodexSessionHistoryCache } from '../src/session-history-cache.js'
|
|
|
|
describe('CodexVirtualHarness', () => {
|
|
it('forwards CodeX workspace files and terminal calls to the Host carrier', async () => {
|
|
const client = fakeCodex()
|
|
const hostCarrier = {
|
|
invoke: vi.fn(async () => undefined),
|
|
dispatch: vi.fn(async (endpoint: string) => ({ ok: true as const, value: { endpoint } })),
|
|
open: vi.fn(async () => (async function* () { yield { type: 'ready' } })()),
|
|
}
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }, 'legacy', hostCarrier)
|
|
const signal = new AbortController().signal
|
|
await expect(target.dispatch('workspaceFiles/list', { args: { workspaceFileScopeId: 'codex:thr_1', path: '.' } }, signal))
|
|
.resolves.toEqual({ ok: true, value: { endpoint: 'workspaceFiles/list' } })
|
|
await expect(target.dispatch('terminal/environment', { args: { agentId: 'codex:thr_1' } }, signal))
|
|
.resolves.toEqual({ ok: true, value: { endpoint: 'terminal/environment' } })
|
|
const stream = await target.open('terminal/follow', { args: { agentId: 'codex:thr_1', id: 't1' } }, signal)
|
|
await expect(stream[Symbol.asyncIterator]().next()).resolves.toEqual({ done: false, value: { type: 'ready' } })
|
|
expect(hostCarrier.open).toHaveBeenCalledWith('terminal/follow', expect.anything(), signal)
|
|
await target.close()
|
|
})
|
|
|
|
it('returns RC.1 sequenced projections from CodeX history without forwarding its identity to Harness', async () => {
|
|
const hostCarrier = { invoke: vi.fn(), dispatch: vi.fn(), open: vi.fn() }
|
|
const target = new CodexVirtualHarness(fakeCodex(), { deviceId: 'host-1', name: 'Host' }, 'v3', hostCarrier)
|
|
const signal = new AbortController().signal
|
|
try {
|
|
await expect(target.dispatch('session/projections', { args: { request: { sessionId: 'codex:thr_1' } } }, signal))
|
|
.resolves.toMatchObject({ ok: true, value: { kind: 'sequenced', asOfSeq: expect.any(Number), values: { title: expect.any(String) } } })
|
|
await expect(target.dispatch('session/projections', { args: { request: { sessionId: 'codex:absent' } } }, signal))
|
|
.resolves.toEqual({ ok: true, value: null })
|
|
expect(hostCarrier.dispatch).not.toHaveBeenCalled()
|
|
} finally { await target.close() }
|
|
})
|
|
|
|
it('answers the background-job roster without a terminal stream failure', async () => {
|
|
const target = new CodexVirtualHarness(fakeCodex(), { deviceId: 'host-1', name: 'Host' })
|
|
const rosterController = new AbortController()
|
|
const roster = await target.open('job/list', { args: { request: { sessionId: 'codex:thr_1' } } }, rosterController.signal)
|
|
const rosterIterator = roster[Symbol.asyncIterator]()
|
|
await expect(rosterIterator.next()).resolves.toEqual({ done: false, value: { type: 'rows', jobs: [] } })
|
|
rosterController.abort()
|
|
await expect(rosterIterator.next()).resolves.toMatchObject({ done: true })
|
|
await target.close()
|
|
})
|
|
|
|
it('switches the native Session permission projection between workspace and Full access', async () => {
|
|
const client = fakeCodex()
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
const signal = new AbortController().signal
|
|
const control = await target.open('session/control', { args: {} }, signal)
|
|
const iterator = control[Symbol.asyncIterator]()
|
|
await iterator.next()
|
|
|
|
await expect(target.invoke({ namespace: 'commands', method: 'list', args: { agentId: 'codex:thr_1' } }))
|
|
.resolves.toEqual([expect.objectContaining({ name: 'permission' })])
|
|
await expect(target.invoke({
|
|
namespace: 'commands',
|
|
method: 'execute',
|
|
args: { agentId: 'codex:thr_1', line: '/permission danger-full-access', images: [] },
|
|
})).resolves.toMatchObject({ result: { kind: 'success' } })
|
|
const projectionFrame = await iterator.next()
|
|
expect(projectionFrame).toMatchObject({ value: {
|
|
type: 'projection',
|
|
sessionId: 'codex:thr_1',
|
|
key: 'permissions',
|
|
value: { currentValue: 'danger-full-access' },
|
|
changes: [{ key: 'permissions', val: { currentValue: 'danger-full-access' } }],
|
|
} })
|
|
|
|
const prompted = await target.dispatch('session/prompt', { args: { request: {
|
|
sessionId: 'codex:thr_1',
|
|
content: [{ type: 'text', text: 'Use full access' }],
|
|
} } }, signal)
|
|
expect(prompted.ok).toBe(true)
|
|
expect(client.request).toHaveBeenCalledWith('turn/start', expect.objectContaining({
|
|
threadId: 'thr_1',
|
|
}), expect.any(AbortSignal))
|
|
expect(client.request.mock.calls.find(([method]) => method === 'turn/start')?.[1]).not.toHaveProperty('permissionPreset')
|
|
await iterator.return?.()
|
|
await target.close()
|
|
})
|
|
|
|
it('uses the CodeX project list as the virtual Workspace baseline', async () => {
|
|
const client = fakeCodex([], {
|
|
projects: [
|
|
codexProject('repo-project', 'Repo from CodeX', ['/workspace/repo'], 2),
|
|
codexProject('empty-project', 'Empty CodeX', ['/workspace/empty'], 1),
|
|
],
|
|
})
|
|
|
|
const workspaces = await discoverCodexVirtualWorkspaces(client)
|
|
expect(workspaces).toHaveLength(2)
|
|
expect(workspaces.map(item => item.title)).toEqual(['Empty CodeX', 'Repo from CodeX'])
|
|
expect(workspaces[0]).toMatchObject({
|
|
workspaceId: 'codex-workspace:project:empty-project',
|
|
path: '/workspace/empty',
|
|
sessionIds: [],
|
|
sessionCount: 0,
|
|
})
|
|
expect(workspaces[1]).toMatchObject({
|
|
workspaceId: 'codex-workspace:project:repo-project',
|
|
path: '/workspace/repo',
|
|
sessionIds: ['codex:thr_1'],
|
|
sessionCount: 1,
|
|
})
|
|
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
await target.selectWorkspace('codex-workspace:project:repo-project')
|
|
const result = await target.dispatch('workspace/list', { args: {} }, new AbortController().signal)
|
|
expect(result).toMatchObject({ ok: true, value: { items: [
|
|
{ workspaceId: 'codex-workspace:project:repo-project', sessionIds: ['codex:thr_1'] },
|
|
] } })
|
|
expect(result).not.toMatchObject({ value: { items: [
|
|
expect.objectContaining({ workspaceId: 'codex-workspace:project:empty-project' }),
|
|
] } })
|
|
await target.close()
|
|
|
|
const emptyTarget = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
await emptyTarget.selectWorkspace('codex-workspace:project:empty-project')
|
|
const emptyResult = await emptyTarget.dispatch('workspace/list', { args: {} }, new AbortController().signal)
|
|
expect(emptyResult).toMatchObject({ ok: true, value: { items: [
|
|
{ workspaceId: 'codex-workspace:project:empty-project', sessionIds: [] },
|
|
{ workspaceId: 'codex-workspace:project:repo-project', sessionIds: ['codex:thr_1'] },
|
|
] } })
|
|
await emptyTarget.close()
|
|
})
|
|
|
|
it('hydrates read-only permission snapshots through Typert history and follow and clears unsupported live policies', async () => {
|
|
for (const carrier of ['history', 'follow']) {
|
|
const client = fakeCodex()
|
|
const request = client.request.getMockImplementation()!
|
|
client.request.mockImplementation(async (method: string, params: unknown, signal?: AbortSignal) => {
|
|
const response = await request(method, params, signal)
|
|
return method === 'dsh/sessionHistory' ? { ...response, permissionPreset: 'danger-full-access' } : response
|
|
})
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
const signal = new AbortController().signal
|
|
let stream: AsyncIterator<unknown> | undefined
|
|
if (carrier === 'history') {
|
|
expect(await target.dispatch('session/history', { args: { request: { sessionId: 'codex:thr_1' } } }, signal))
|
|
.toMatchObject({ value: { projections: { values: { permissions: { currentValue: 'danger-full-access' } } } } })
|
|
} else {
|
|
stream = (await target.open('session/follow', { args: { request: { address: { kind: 'session', sessionId: 'codex:thr_1' } } } }, signal))[Symbol.asyncIterator]()
|
|
expect(await stream.next()).toMatchObject({ value: { projections: { values: { permissions: { currentValue: 'danger-full-access' } } } } })
|
|
}
|
|
stream ??= (await target.open('session/follow', { args: { request: { address: { kind: 'session', sessionId: 'codex:thr_1' } } } }, signal))[Symbol.asyncIterator]()
|
|
expect(client.request.mock.calls.some(([method]) => method === 'thread/resume')).toBe(false)
|
|
client.emit('thr_1', { method: 'thread/settings/updated', params: { threadSettings: {
|
|
approvalPolicy: 'never', sandboxPolicy: { type: 'readOnly' },
|
|
} } })
|
|
expect(await target.dispatch('session/list', { args: {} }, signal)).toMatchObject({ value: {
|
|
items: [expect.objectContaining({ projections: expect.objectContaining({ values: expect.objectContaining({
|
|
permissions: expect.objectContaining({ currentValue: 'Host settings (not reported)' }),
|
|
}) }) })],
|
|
} })
|
|
await stream?.return?.()
|
|
await target.close()
|
|
}
|
|
})
|
|
|
|
it('derives exact cwd authority when project listings are unavailable or empty', async () => {
|
|
await runScenarios([
|
|
{
|
|
name: 'derives exact cwd workspaces when CodeX project/list is unavailable',
|
|
run: async () => {
|
|
const client = fakeCodex([codexThread('thr_2', '/workspace/other', 'Other workspace')], {
|
|
projectListError: Object.assign(
|
|
new Error('The requested Codex method is not available over Remote.'),
|
|
{
|
|
code: 'METHOD_NOT_ALLOWED',
|
|
},
|
|
),
|
|
})
|
|
|
|
const workspaces = await discoverCodexVirtualWorkspaces(client)
|
|
expect(workspaces).toHaveLength(2)
|
|
expect(workspaces).toEqual([
|
|
expect.objectContaining({ path: '/workspace/repo', title: 'repo', sessionIds: ['codex:thr_1'] }),
|
|
expect.objectContaining({ path: '/workspace/other', title: 'other', sessionIds: ['codex:thr_2'] }),
|
|
])
|
|
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
const sessions = await target.dispatch('session/list', { args: {} }, new AbortController().signal)
|
|
expect(sessions).toMatchObject({
|
|
ok: true,
|
|
value: { items: [{ sessionId: 'codex:thr_1' }, { sessionId: 'codex:thr_2' }] },
|
|
})
|
|
await target.close()
|
|
},
|
|
},
|
|
{
|
|
name: 'derives exact cwd workspaces when CodeX project/list is empty',
|
|
run: async () => {
|
|
const client = fakeCodex([], { projects: [] })
|
|
|
|
const workspaces = await discoverCodexVirtualWorkspaces(client)
|
|
expect(workspaces).toEqual([
|
|
expect.objectContaining({ path: '/workspace/repo', title: 'repo', sessionIds: ['codex:thr_1'] }),
|
|
])
|
|
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
const sessions = await target.dispatch('session/list', { args: {} }, new AbortController().signal)
|
|
expect(sessions).toMatchObject({ ok: true, value: { items: [{ sessionId: 'codex:thr_1' }] } })
|
|
await target.close()
|
|
},
|
|
},
|
|
])
|
|
}, 10000)
|
|
|
|
it('filters CodeX threads that do not belong to an advertised project', async () => {
|
|
const client = fakeCodex([
|
|
codexThread('thr_2', '/workspace/other', 'Other workspace'),
|
|
codexThread('thr_3', undefined, 'Project metadata only', 'repo-project'),
|
|
])
|
|
|
|
const workspaces = await discoverCodexVirtualWorkspaces(client)
|
|
expect(workspaces).toHaveLength(1)
|
|
expect(workspaces[0]).toMatchObject({
|
|
workspaceId: 'codex-workspace:project:repo-project',
|
|
sessionIds: ['codex:thr_1', 'codex:thr_3'],
|
|
sessionCount: 2,
|
|
})
|
|
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
const sessions = await target.dispatch('session/list', { args: {} }, new AbortController().signal)
|
|
expect(sessions).toMatchObject({ ok: true, value: { items: [
|
|
{ sessionId: 'codex:thr_1' },
|
|
{ sessionId: 'codex:thr_3' },
|
|
] } })
|
|
expect(JSON.stringify(sessions)).not.toContain('codex:thr_2')
|
|
await target.close()
|
|
})
|
|
|
|
it('reopens Typert follows after the Host closes the CodeX stream without reviving the old subscriber', async () => {
|
|
await runScenarios(['legacy', 'v3'].map(generation => ({ name: generation, run: async () => {
|
|
const client = fakeCodex()
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }, generation as 'legacy' | 'v3')
|
|
const controller = new AbortController()
|
|
const payload = { args: { request: { address: { kind: 'session', sessionId: 'codex:thr_1' } } } }
|
|
try {
|
|
const first = (await target.open('session/follow', payload, controller.signal))[Symbol.asyncIterator]()
|
|
expect((await first.next()).done).toBe(false)
|
|
client.closeStream('thr_1', 'failed')
|
|
expect((await first.next()).done).toBe(true)
|
|
const second = (await target.open('session/follow', payload, controller.signal))[Symbol.asyncIterator]()
|
|
expect((await second.next()).done).toBe(false)
|
|
expect(client.subscribe).toHaveBeenCalledTimes(2)
|
|
client.emit('thr_1', { method: 'turn/started', params: { turn: { id: 'turn_recovered', status: 'inProgress', items: [] } } })
|
|
expect((await second.next()).value).toMatchObject({ type: 'event', event: { type: 'turn/start' } })
|
|
expect((await first.next()).done).toBe(true)
|
|
} finally { controller.abort(); await target.close() }
|
|
} })))
|
|
})
|
|
|
|
it('projects persisted CodeX history and live frames into native session events', async () => {
|
|
const client = fakeCodex()
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
const controller = new AbortController()
|
|
const source = await target.open('session/follow', {
|
|
args: { request: { address: { kind: 'session', sessionId: 'codex:thr_1' } } },
|
|
}, controller.signal)
|
|
const iterator = source[Symbol.asyncIterator]()
|
|
|
|
const snapshot = await iterator.next()
|
|
expect(snapshot.value).toMatchObject({
|
|
type: 'snapshot',
|
|
header: { id: 'codex:thr_1', cwd: '/workspace/repo' },
|
|
projections: { values: { modelSelection: { next: {
|
|
provider: 'codex', model: 'gpt-5.6-sol', reasoningEffort: 'low',
|
|
} } } },
|
|
records: [
|
|
{ event: { type: 'turn/start', seq: 0 } },
|
|
{ event: { type: 'step/start', seq: 1 } },
|
|
{ event: { type: 'user/message', seq: 2, data: { content: [{ type: 'text', text: 'Use native UI' }] } } },
|
|
{ event: { type: 'assistant/message', seq: 3 } },
|
|
{ event: { type: 'tool/call', seq: 4 } },
|
|
{ event: { type: 'tool/result', seq: 5 } },
|
|
{ event: { type: 'tool/call', seq: 6 } },
|
|
{ event: { type: 'tool/result', seq: 7 } },
|
|
{ event: { type: 'step/end', seq: 8 } },
|
|
{ event: { type: 'turn/end', seq: 9 } },
|
|
],
|
|
})
|
|
expect(snapshot.value.records[2].event.surfaceOp).toBe('append')
|
|
expect(snapshot.value.records[3].event.surfaceOp).toBe('append')
|
|
expect(snapshot.value.records[4].view).toEqual({
|
|
for: 'call',
|
|
view: { card: 'terminal', title: 'pnpm test' },
|
|
})
|
|
expect(snapshot.value.records[5]).toMatchObject({
|
|
event: { surfaceOp: 'append' },
|
|
view: { for: 'result', view: { card: 'terminal', output: '3 passed', exitCode: 0 } },
|
|
})
|
|
expect(snapshot.value.records[6]).toMatchObject({
|
|
view: { for: 'call', view: { card: 'generic', kind: 'edit', locations: [{ path: 'src/native.ts' }] } },
|
|
})
|
|
expect(snapshot.value.records[7].event.surfaceOp).toBe('append')
|
|
expect(JSON.stringify(snapshot.value)).not.toContain('private diff body')
|
|
|
|
client.emit('thr_1', {
|
|
method: 'turn/started',
|
|
params: { turn: { id: 'turn_2', status: 'inProgress', items: [] } },
|
|
})
|
|
await expect(iterator.next()).resolves.toMatchObject({ value: { type: 'event', event: { type: 'turn/start', seq: 10 } } })
|
|
await expect(iterator.next()).resolves.toMatchObject({ value: { type: 'event', event: { type: 'step/start', seq: 11 } } })
|
|
|
|
client.emit('thr_1', {
|
|
method: 'item/agentMessage/delta',
|
|
params: { turnId: 'turn_2', itemId: 'assistant_2', delta: 'Streaming' },
|
|
})
|
|
await expect(iterator.next()).resolves.toMatchObject({
|
|
value: { type: 'event', event: { type: 'assistant/chunk', data: { chunk: { type: 'block-start' } } } },
|
|
})
|
|
await expect(iterator.next()).resolves.toMatchObject({
|
|
value: { type: 'event', event: { type: 'assistant/chunk', data: { chunk: { type: 'text-delta', text: 'Streaming' } } } },
|
|
})
|
|
|
|
client.emit('thr_1', {
|
|
method: 'item/completed',
|
|
params: { turnId: 'turn_2', item: { id: 'assistant_2', type: 'agentMessage', text: 'Streaming', status: 'completed' } },
|
|
})
|
|
await expect(iterator.next()).resolves.toMatchObject({
|
|
value: { type: 'event', event: { type: 'assistant/chunk', data: { chunk: {
|
|
type: 'block-end', block: { type: 'text', text: 'Streaming' },
|
|
} } } },
|
|
})
|
|
await expect(iterator.next()).resolves.toMatchObject({
|
|
value: { type: 'event', event: { type: 'assistant/chunk', data: { chunk: {
|
|
type: 'finish', reason: { kind: 'stop' },
|
|
} } } },
|
|
})
|
|
await expect(iterator.next()).resolves.toMatchObject({
|
|
value: { type: 'event', event: { type: 'assistant/message', data: {
|
|
message: { content: [{ type: 'text', text: 'Streaming' }] },
|
|
} } },
|
|
})
|
|
|
|
controller.abort()
|
|
await iterator.return?.()
|
|
await target.close()
|
|
})
|
|
|
|
it('preserves the model reported by a persisted CodeX Turn', async () => {
|
|
const client = fakeCodex([{
|
|
id: 'thr_model',
|
|
name: 'Model thread',
|
|
cwd: '/workspace/repo',
|
|
createdAt: 1_700_000_000,
|
|
updatedAt: 1_700_000_100,
|
|
status: { type: 'idle' },
|
|
turns: [{
|
|
id: 'turn_model', model: 'gpt-5.6-terra', effort: 'high',
|
|
items: [{ id: 'assistant_model', type: 'agentMessage', text: 'Using Terra', status: 'completed' }],
|
|
}],
|
|
}])
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
const controller = new AbortController()
|
|
try {
|
|
const source = await target.open('session/follow', {
|
|
args: { request: { address: { kind: 'session', sessionId: 'codex:thr_model' } } },
|
|
}, controller.signal)
|
|
const snapshot = await source[Symbol.asyncIterator]().next()
|
|
expect(snapshot.value).toMatchObject({
|
|
projections: { values: { modelSelection: { next: { model: 'gpt-5.6-terra' } } } },
|
|
})
|
|
const records = (snapshot.value as {
|
|
records: Array<{ event: { data: { message?: { source?: { model?: string } } } } }>
|
|
}).records
|
|
expect(records.some(record => record.event.data.message?.source?.model === 'gpt-5.6-terra')).toBe(true)
|
|
} finally {
|
|
controller.abort()
|
|
await target.close()
|
|
}
|
|
})
|
|
|
|
it('projects CodeX message and MCP result images into native image blocks and virtual attachments', async () => {
|
|
const imageData = 'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAFgwJ/lJihxwAAAABJRU5ErkJggg=='
|
|
const client = fakeCodex([{
|
|
id: 'thr_image',
|
|
name: 'Image prompt',
|
|
cwd: '/workspace/repo',
|
|
createdAt: 1_700_000_000,
|
|
updatedAt: 1_700_000_100,
|
|
status: { type: 'idle' },
|
|
turns: [{
|
|
id: 'turn_image',
|
|
status: 'completed',
|
|
items: [
|
|
{
|
|
id: 'user_image',
|
|
type: 'userMessage',
|
|
content: [
|
|
{ type: 'text', text: 'Describe this image' },
|
|
{ type: 'image', url: `data:image/png;base64,${imageData}`, name: 'screen.png' },
|
|
{ type: 'image', url: 'https://example.test/not-allowed.png', name: 'external.png' },
|
|
],
|
|
},
|
|
{
|
|
id: 'screenshot_tool',
|
|
type: 'mcpToolCall',
|
|
server: 'cua_repl',
|
|
tool: 'js',
|
|
status: 'completed',
|
|
result: {
|
|
content: [
|
|
{ type: 'text', text: '/workspace/current-browser.png' },
|
|
{ type: 'image', data: imageData, mimeType: 'image/png', name: 'current-browser.png' },
|
|
],
|
|
isError: false,
|
|
},
|
|
},
|
|
{
|
|
id: 'assistant_image',
|
|
type: 'agentMessage',
|
|
content: [{ type: 'text', text: '' }],
|
|
status: 'completed',
|
|
},
|
|
],
|
|
}],
|
|
}])
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
|
|
const history = await target.dispatch('session/history', { args: { request: { sessionId: 'codex:thr_image' as never } } }, new AbortController().signal)
|
|
|
|
expect(history.ok).toBe(true)
|
|
if (!history.ok) throw new Error('history failed')
|
|
const message = (history.value as { events: Array<{ event: { type: string; seq: number; data: unknown } }> }).events.find(entry => entry.event.type === 'user/message')!.event.data as {
|
|
content: Array<{ type: string; attachment?: { attachmentId?: string }; data?: string; url?: string; name?: string }>
|
|
}
|
|
expect(message.content).toMatchObject([
|
|
{ type: 'text', text: 'Describe this image' },
|
|
{
|
|
type: 'image',
|
|
mediaType: 'image/png',
|
|
data: imageData,
|
|
url: `data:image/png;base64,${imageData}`,
|
|
name: 'screen.png',
|
|
attachment: { mediaType: 'image/png', width: 1, height: 1, name: 'screen.png' },
|
|
},
|
|
])
|
|
expect(JSON.stringify(message)).not.toContain('example.test')
|
|
|
|
const assistant = (history.value as { events: Array<{ event: { type: string; seq: number; data: unknown } }> }).events.find(entry => entry.event.type === 'assistant/message')!.event.data as {
|
|
message: { content: Array<{ type: string; attachment?: { attachmentId?: string }; data?: string; name?: string }> }
|
|
}
|
|
expect(assistant.message.content).toMatchObject([
|
|
{ type: 'text', text: '' },
|
|
{
|
|
type: 'image',
|
|
mediaType: 'image/png',
|
|
data: imageData,
|
|
name: 'current-browser.png',
|
|
attachment: { mediaType: 'image/png', width: 1, height: 1, name: 'current-browser.png' },
|
|
},
|
|
])
|
|
|
|
const attachmentId = message.content[1]!.attachment!.attachmentId!
|
|
const attachment = await target.dispatch('session/attachment', { args: { request: { sessionId: 'codex:thr_image' as never, attachmentId: attachmentId as never } } }, new AbortController().signal)
|
|
expect(attachment).toMatchObject({
|
|
ok: true,
|
|
value: {
|
|
attachment: { attachmentId, mediaType: 'image/png', name: 'screen.png' },
|
|
data: imageData,
|
|
},
|
|
})
|
|
// 0.2.2 clients send the full image reference instead of the bare id.
|
|
await expect(target.dispatch('session/attachment', {
|
|
args: { request: { sessionId: 'codex:thr_image' as never, attachment: message.content[1]!.attachment } },
|
|
}, new AbortController().signal)).resolves.toMatchObject({
|
|
ok: true,
|
|
value: { attachment: { attachmentId, mediaType: 'image/png', name: 'screen.png' }, data: imageData },
|
|
})
|
|
const toolAttachmentId = assistant.message.content[1]!.attachment!.attachmentId!
|
|
await expect(target.dispatch('session/attachment', { args: { request: { sessionId: 'codex:thr_image' as never, attachmentId: toolAttachmentId as never } } }, new AbortController().signal)).resolves.toMatchObject({
|
|
ok: true,
|
|
value: {
|
|
attachment: { attachmentId: toolAttachmentId, mediaType: 'image/png', name: 'current-browser.png' },
|
|
data: imageData,
|
|
},
|
|
})
|
|
await target.close()
|
|
})
|
|
|
|
it('emits Session V3 history, replacements, and assistant stream frames for v0.1.5', async () => {
|
|
const sessionSurface = await import('@deepseek-ai/dsh-session/surface') as unknown as {
|
|
validateSurfaceMetadata(event: unknown): void
|
|
validateSessionEventData(event: unknown, subject: string): void
|
|
}
|
|
const assertV3Event = (event: unknown): void => {
|
|
sessionSurface.validateSurfaceMetadata(event)
|
|
sessionSurface.validateSessionEventData(event, 'CodeX V3 fixture')
|
|
}
|
|
const client = fakeCodex()
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' }, 'v3')
|
|
const controller = new AbortController()
|
|
const source = await target.open('session/follow', {
|
|
args: { request: {
|
|
address: { kind: 'session', sessionId: 'codex:thr_1' },
|
|
assistantStream: true,
|
|
} },
|
|
}, controller.signal)
|
|
const iterator = source[Symbol.asyncIterator]()
|
|
const snapshot = await iterator.next()
|
|
expect(snapshot.value).toMatchObject({
|
|
type: 'snapshot',
|
|
header: { version: 3, id: 'codex:thr_1', isSeeded: false },
|
|
assistantStream: { revision: 0 },
|
|
})
|
|
for (const record of snapshot.value.records) {
|
|
expect(() => assertV3Event(record.event)).not.toThrow()
|
|
if (record.event.type === 'assistant/message') expect(record.event.data.stream).toEqual([])
|
|
}
|
|
|
|
client.emit('thr_1', {
|
|
method: 'turn/started',
|
|
params: { turn: { id: 'turn_v3', status: 'inProgress', items: [] } },
|
|
})
|
|
await iterator.next()
|
|
await iterator.next()
|
|
client.emit('thr_1', {
|
|
method: 'item/started',
|
|
params: { turnId: 'turn_v3', item: {
|
|
id: 'command_v3', type: 'commandExecution', command: 'pnpm test', status: 'inProgress',
|
|
} },
|
|
})
|
|
await iterator.next()
|
|
client.emit('thr_1', {
|
|
method: 'item/commandExecution/outputDelta',
|
|
params: { turnId: 'turn_v3', itemId: 'command_v3', delta: 'one' },
|
|
})
|
|
const firstResult = await iterator.next()
|
|
client.emit('thr_1', {
|
|
method: 'item/commandExecution/outputDelta',
|
|
params: { turnId: 'turn_v3', itemId: 'command_v3', delta: ' two' },
|
|
})
|
|
const replacement = await iterator.next()
|
|
expect(replacement).toMatchObject({ value: { event: {
|
|
type: 'tool/result',
|
|
surfaceOp: {
|
|
op: 'replace',
|
|
startSeq: firstResult.value.event.seq,
|
|
endSeq: firstResult.value.event.seq,
|
|
},
|
|
sourceEventSeqs: [firstResult.value.event.seq],
|
|
} } })
|
|
expect(() => assertV3Event(replacement.value.event)).not.toThrow()
|
|
|
|
client.emit('thr_1', {
|
|
method: 'item/agentMessage/delta',
|
|
params: { turnId: 'turn_v3', itemId: 'assistant_v3', delta: 'hello' },
|
|
})
|
|
await expect(iterator.next()).resolves.toMatchObject({ value: { type: 'assistant-stream', frame: {
|
|
type: 'start', attemptId: expect.any(String), revision: 1,
|
|
} } })
|
|
await expect(iterator.next()).resolves.toMatchObject({ value: { type: 'assistant-stream', frame: {
|
|
type: 'chunk', index: 0, chunk: { type: 'block-start' },
|
|
} } })
|
|
await expect(iterator.next()).resolves.toMatchObject({ value: { type: 'assistant-stream', frame: {
|
|
type: 'chunk', index: 1, chunk: { type: 'text-delta', text: 'hello' },
|
|
} } })
|
|
client.emit('thr_1', {
|
|
method: 'item/completed',
|
|
params: { turnId: 'turn_v3', item: {
|
|
id: 'assistant_v3', type: 'agentMessage', text: 'hello', status: 'completed',
|
|
} },
|
|
})
|
|
await iterator.next()
|
|
await iterator.next()
|
|
const settlement = await iterator.next()
|
|
expect(settlement.value).toMatchObject({ type: 'event', event: {
|
|
type: 'assistant/message',
|
|
surfaceOp: 'append',
|
|
data: { stream: expect.any(Array), message: { content: [{ type: 'text', text: 'hello' }] } },
|
|
} })
|
|
expect(() => assertV3Event(settlement.value.event)).not.toThrow()
|
|
await expect(iterator.next()).resolves.toMatchObject({ value: { type: 'assistant-stream', frame: {
|
|
type: 'end',
|
|
outcome: { kind: 'committed', eventType: 'assistant/message', seq: settlement.value.event.seq },
|
|
} } })
|
|
|
|
controller.abort()
|
|
await iterator.return?.()
|
|
await target.close()
|
|
})
|
|
|
|
it('routes text and image composer prompts to CodeX', async () => {
|
|
await runScenarios([
|
|
{
|
|
name: 'routes the native composer prompt back to CodeX resume and turn/start',
|
|
run: async () => {
|
|
const client = fakeCodex()
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
await expect(
|
|
target.dispatch(
|
|
'session/selectModel',
|
|
{
|
|
args: {
|
|
request: {
|
|
sessionId: 'codex:thr_1',
|
|
provider: 'codex',
|
|
model: 'gpt-5.6-terra',
|
|
reasoningEffort: 'high',
|
|
},
|
|
},
|
|
},
|
|
new AbortController().signal,
|
|
),
|
|
).resolves.toEqual({
|
|
ok: true,
|
|
value: { selected: { provider: 'codex', model: 'gpt-5.6-terra', reasoningEffort: 'high' } },
|
|
})
|
|
const result = await target.dispatch(
|
|
'session/prompt',
|
|
{
|
|
args: {
|
|
request: {
|
|
sessionId: 'codex:thr_1',
|
|
requestId: 'rpc-1',
|
|
content: [{ type: 'text', text: 'Continue here' }],
|
|
},
|
|
},
|
|
},
|
|
new AbortController().signal,
|
|
)
|
|
|
|
expect(result).toEqual({ ok: true, value: { accepted: true } })
|
|
expect(client.request).toHaveBeenCalledWith(
|
|
'thread/resume',
|
|
{
|
|
threadId: 'thr_1',
|
|
model: 'gpt-5.6-terra',
|
|
},
|
|
expect.any(AbortSignal),
|
|
)
|
|
expect(client.request).toHaveBeenCalledWith(
|
|
'turn/start',
|
|
{
|
|
threadId: 'thr_1',
|
|
input: [{ type: 'text', text: 'Continue here' }],
|
|
model: 'gpt-5.6-terra',
|
|
effort: 'high',
|
|
},
|
|
expect.any(AbortSignal),
|
|
)
|
|
await target.close()
|
|
},
|
|
},
|
|
{
|
|
name: 'routes pasted Composer images through the CodeX prompt input',
|
|
run: async () => {
|
|
const client = fakeCodex()
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
const result = await target.dispatch(
|
|
'session/prompt',
|
|
{
|
|
args: {
|
|
request: {
|
|
sessionId: 'codex:thr_1',
|
|
requestId: 'rpc-image-1',
|
|
content: [
|
|
{ type: 'text', text: 'Describe this screenshot' },
|
|
{ type: 'image', mediaType: 'image/png', data: 'aW1hZ2U=' },
|
|
],
|
|
},
|
|
},
|
|
},
|
|
new AbortController().signal,
|
|
)
|
|
|
|
expect(result).toEqual({ ok: true, value: { accepted: true } })
|
|
expect(client.request).toHaveBeenCalledWith(
|
|
'turn/start',
|
|
expect.objectContaining({
|
|
threadId: 'thr_1',
|
|
input: [
|
|
{ type: 'text', text: 'Describe this screenshot' },
|
|
{ type: 'image', mediaType: 'image/png', data: 'aW1hZ2U=' },
|
|
],
|
|
}),
|
|
expect.any(AbortSignal),
|
|
)
|
|
await target.close()
|
|
},
|
|
},
|
|
])
|
|
}, 10000)
|
|
|
|
it('uses the effective App Server permission returned by resume', async () => {
|
|
const client = fakeCodex([codexThread('thr_full', '/workspace/repo', 'Full access thread')])
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
const result = await target.dispatch('session/prompt', {
|
|
args: {
|
|
request: {
|
|
sessionId: 'codex:thr_full',
|
|
content: [{ type: 'text', text: 'Continue with the saved permission' }],
|
|
},
|
|
},
|
|
}, new AbortController().signal)
|
|
|
|
expect(result).toEqual({ ok: true, value: { accepted: true } })
|
|
expect(client.request).toHaveBeenCalledWith('thread/resume', {
|
|
threadId: 'thr_full',
|
|
model: 'gpt-5.6-sol',
|
|
}, expect.any(AbortSignal))
|
|
expect(client.request).toHaveBeenCalledWith('turn/start', expect.objectContaining({
|
|
threadId: 'thr_full',
|
|
}), expect.any(AbortSignal))
|
|
expect(client.request.mock.calls.find(([method]) => method === 'turn/start')?.[1]).not.toHaveProperty('permissionPreset')
|
|
expect(await target.dispatch('session/list', { args: {} }, new AbortController().signal))
|
|
.toMatchObject({ value: { items: expect.arrayContaining([expect.objectContaining({
|
|
sessionId: 'codex:thr_full', projections: { kind: 'sequenced', asOfSeq: 0, values: expect.objectContaining({ permissions: expect.objectContaining({ currentValue: 'danger-full-access' }) }) },
|
|
})]) } })
|
|
await target.close()
|
|
})
|
|
|
|
it('cancels the active turn restored from CodeX history', async () => {
|
|
await runScenarios([
|
|
{
|
|
name: 'keeps active CodeX history open and exposes the turn id for cancellation',
|
|
run: async () => {
|
|
const history = projectCodexNativeHistory(
|
|
{
|
|
id: 'thr_active',
|
|
cwd: '/workspace/repo',
|
|
status: { type: 'active', activeFlags: [] },
|
|
turns: [
|
|
{
|
|
id: 'turn_active',
|
|
status: 'inProgress',
|
|
items: [
|
|
{ id: 'assistant_active', type: 'agentMessage', text: 'Working', status: 'inProgress' },
|
|
],
|
|
},
|
|
],
|
|
},
|
|
'codex:thr_active',
|
|
)
|
|
|
|
expect(history.activeTurnId).toBe('turn_active')
|
|
expect(history.entries.map((entry) => entry.event.type)).toEqual([
|
|
'turn/start',
|
|
'step/start',
|
|
'assistant/message',
|
|
])
|
|
expect(paginateCodexNativeHistory(history, {}).activeTurnId).toBe('turn_active')
|
|
},
|
|
},
|
|
{
|
|
name: 'uses the active turn id restored from paginated history when cancelling',
|
|
run: async () => {
|
|
const client = fakeCodex([
|
|
{
|
|
id: 'thr_active',
|
|
cwd: '/workspace/repo',
|
|
name: 'Active',
|
|
status: { type: 'active', activeFlags: [] },
|
|
turns: [{ id: 'turn_active', status: 'inProgress', items: [] }],
|
|
},
|
|
])
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
|
|
await target.dispatch(
|
|
'session/history',
|
|
{
|
|
args: { request: { sessionId: 'codex:thr_active' } },
|
|
},
|
|
new AbortController().signal,
|
|
)
|
|
await target.open('session/follow', { args: { request: { address: { kind: 'session', sessionId: 'codex:thr_active' } } } }, new AbortController().signal)
|
|
await expect(
|
|
target.dispatch(
|
|
'session/cancel',
|
|
{
|
|
args: { request: { sessionId: 'codex:thr_active' } },
|
|
},
|
|
new AbortController().signal,
|
|
),
|
|
).resolves.toEqual({ ok: true, value: { accepted: true } })
|
|
|
|
expect(client.request).toHaveBeenCalledWith(
|
|
'turn/interrupt',
|
|
{
|
|
threadId: 'thr_active',
|
|
turnId: 'turn_active',
|
|
},
|
|
expect.any(AbortSignal),
|
|
)
|
|
await target.close()
|
|
},
|
|
},
|
|
])
|
|
}, 10000)
|
|
|
|
it('serves paged CodeX history with the legacy Host fallback', async () => {
|
|
await runScenarios([
|
|
{
|
|
name: 'serves rc.2 and alpha History as message-aligned backwards pages',
|
|
run: async () => {
|
|
const client = fakeCodex()
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
const tail = await target.dispatch('session/history', { args: { request: { sessionId: 'codex:thr_1' as never, maxMessages: 3 } } }, new AbortController().signal)
|
|
expect(tail).toMatchObject({ ok: true, value: { hasMore: true } })
|
|
if (!tail.ok) throw new Error('tail history failed')
|
|
expect((tail.value as { events: Array<{ event: { type: string; seq: number; data: unknown } }> }).events.map((entry) => entry.event.seq)).toEqual([3, 4, 5, 6, 7, 8, 9])
|
|
|
|
const older = await target.dispatch(
|
|
'session/page',
|
|
{
|
|
args: {
|
|
request: {
|
|
address: { kind: 'session', sessionId: 'codex:thr_1' },
|
|
throughSeq: 9,
|
|
beforeSeq: 3,
|
|
maxMessages: 3,
|
|
},
|
|
},
|
|
},
|
|
new AbortController().signal,
|
|
)
|
|
expect(older).toMatchObject({ ok: true, value: { hasMore: false } })
|
|
if (!older.ok) throw new Error('older history failed')
|
|
expect(
|
|
(older.value as { records: Array<{ event: { seq: number } }> }).records.map(
|
|
(entry) => entry.event.seq,
|
|
),
|
|
).toEqual([0, 1, 2])
|
|
await target.close()
|
|
},
|
|
},
|
|
{
|
|
name: 'bounds the native 500-message follow window to the Remote page limit',
|
|
run: async () => {
|
|
const client = fakeCodex()
|
|
const originalRequest = client.request.getMockImplementation()!
|
|
client.request.mockImplementation(async (method: string, params?: Record<string, unknown>, signal?: AbortSignal) => {
|
|
if (method === 'dsh/sessionHistory' && params?.maxMessages === 500) {
|
|
throw Object.assign(new Error('The CodeX call parameters are invalid.'), { code: 'INVALID_MESSAGE' })
|
|
}
|
|
return originalRequest(method, params, signal)
|
|
})
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
const controller = new AbortController()
|
|
try {
|
|
const stream = await target.open(
|
|
'session/follow',
|
|
{ args: { request: { address: { kind: 'session', sessionId: 'codex:thr_1' }, maxMessages: 500 } } },
|
|
controller.signal,
|
|
)
|
|
const iterator = stream[Symbol.asyncIterator]()
|
|
await expect(iterator.next()).resolves.toMatchObject({ done: false, value: { type: 'snapshot' } })
|
|
expect(client.request).toHaveBeenCalledWith(
|
|
'dsh/sessionHistory',
|
|
{ threadId: 'thr_1', maxMessages: 200 },
|
|
expect.any(AbortSignal),
|
|
)
|
|
await iterator.return?.()
|
|
} finally {
|
|
controller.abort()
|
|
await target.close()
|
|
}
|
|
},
|
|
},
|
|
{
|
|
name: 'falls back to thread/read history when a remote Host lacks the paginated DSH method',
|
|
run: async () => {
|
|
const client = fakeCodex()
|
|
const originalRequest = client.request.getMockImplementation() as
|
|
| ((method: string, params?: Record<string, unknown>, signal?: AbortSignal) => Promise<unknown>)
|
|
| undefined
|
|
client.request.mockImplementation(
|
|
async (method: string, params?: Record<string, unknown>, signal?: AbortSignal) => {
|
|
if (method === 'dsh/sessionHistory') {
|
|
throw Object.assign(new Error('The requested Codex method is not available over Remote.'), {
|
|
code: 'METHOD_NOT_ALLOWED',
|
|
})
|
|
}
|
|
return originalRequest?.(method, params, signal)
|
|
},
|
|
)
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
|
|
const history = await target.dispatch('session/history', { args: { request: { sessionId: 'codex:thr_1' as never, maxMessages: 3 } } }, new AbortController().signal)
|
|
|
|
expect(history).toMatchObject({ ok: true, value: { hasMore: true } })
|
|
if (!history.ok) throw new Error('history failed')
|
|
expect((history.value as { events: Array<{ event: { type: string; seq: number; data: unknown } }> }).events.map((entry) => entry.event.seq)).toEqual([3, 4, 5, 6, 7, 8, 9])
|
|
expect(client.request).toHaveBeenCalledWith(
|
|
'thread/read',
|
|
{ threadId: 'thr_1', includeTurns: true },
|
|
expect.any(AbortSignal),
|
|
)
|
|
await target.close()
|
|
},
|
|
},
|
|
{
|
|
name: 'projects a just-created blank Session when an old Host cannot read an unmaterialized Thread',
|
|
run: async () => {
|
|
const client = fakeCodex()
|
|
const originalRequest = client.request.getMockImplementation() as
|
|
| ((method: string, params?: Record<string, unknown>, signal?: AbortSignal) => Promise<unknown>)
|
|
| undefined
|
|
client.request.mockImplementation(
|
|
async (method: string, params?: Record<string, unknown>, signal?: AbortSignal) => {
|
|
if (method === 'dsh/sessionHistory') {
|
|
throw Object.assign(new Error('The requested Codex method is not available over Remote.'), {
|
|
code: 'METHOD_NOT_ALLOWED',
|
|
})
|
|
}
|
|
if (method === 'thread/read' && params?.includeTurns === true
|
|
&& String(params.threadId).startsWith('new_')) {
|
|
throw Object.assign(new Error('Codex App Server rejected the request.'), {
|
|
code: 'CODEX_UPSTREAM_ERROR',
|
|
})
|
|
}
|
|
return originalRequest?.(method, params, signal)
|
|
},
|
|
)
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
await target.selectWorkspace('codex-workspace:project:repo-project')
|
|
const created = await target.dispatch('session/create', {
|
|
args: { request: { workspaceId: 'codex-workspace:project:repo-project' } },
|
|
}, new AbortController().signal)
|
|
expect(created).toEqual({ ok: true, value: { sessionId: 'codex:new_1' } })
|
|
|
|
const history = await target.dispatch('session/history', { args: { request: { sessionId: 'codex:new_1' as never } } }, new AbortController().signal)
|
|
expect(history).toMatchObject({
|
|
ok: true,
|
|
value: {
|
|
events: [],
|
|
hasMore: false,
|
|
projections: { values: { sessionListMetadata: { blank: true } } },
|
|
},
|
|
})
|
|
expect(client.request).toHaveBeenCalledWith(
|
|
'thread/read',
|
|
{ threadId: 'new_1', includeTurns: true },
|
|
expect.any(AbortSignal),
|
|
)
|
|
await target.close()
|
|
},
|
|
},
|
|
])
|
|
}, 10000)
|
|
|
|
it('starts the first turn in a freshly created CodeX Thread without resuming it first', async () => {
|
|
const client = fakeCodex()
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
await target.selectWorkspace('codex-workspace:project:repo-project')
|
|
|
|
const created = await target.dispatch('session/create', {
|
|
args: { request: { workspaceId: 'codex-workspace:project:repo-project' } },
|
|
}, new AbortController().signal)
|
|
expect(created).toEqual({ ok: true, value: { sessionId: 'codex:new_1' } })
|
|
|
|
const prompted = await target.dispatch('session/prompt', {
|
|
args: {
|
|
request: {
|
|
sessionId: 'codex:new_1',
|
|
content: [{ type: 'text', text: 'Start here' }],
|
|
},
|
|
},
|
|
}, new AbortController().signal)
|
|
|
|
expect(prompted).toEqual({ ok: true, value: { accepted: true } })
|
|
expect(client.request).not.toHaveBeenCalledWith('thread/resume', expect.objectContaining({
|
|
threadId: 'new_1',
|
|
}), expect.any(AbortSignal))
|
|
expect(client.request).toHaveBeenCalledWith('turn/start', {
|
|
threadId: 'new_1',
|
|
input: [{ type: 'text', text: 'Start here' }],
|
|
model: 'gpt-5.6-sol',
|
|
effort: 'low',
|
|
}, expect.any(AbortSignal))
|
|
await target.close()
|
|
})
|
|
|
|
it('opens a freshly created blank CodeX Thread with empty history and a follow snapshot', async () => {
|
|
const client = fakeCodex()
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
const controller = new AbortController()
|
|
await target.selectWorkspace('codex-workspace:project:repo-project')
|
|
const created = await target.dispatch('session/create', {
|
|
args: { request: { workspaceId: 'codex-workspace:project:repo-project' } },
|
|
}, controller.signal)
|
|
expect(created).toEqual({ ok: true, value: { sessionId: 'codex:new_1' } })
|
|
|
|
const history = await target.dispatch('session/history', {
|
|
args: { request: { sessionId: 'codex:new_1' } },
|
|
}, controller.signal)
|
|
expect(history).toMatchObject({
|
|
ok: true,
|
|
value: {
|
|
events: [],
|
|
hasMore: false,
|
|
projections: { values: { sessionListMetadata: { blank: true } } },
|
|
},
|
|
})
|
|
|
|
const source = await target.open('session/follow', {
|
|
args: { request: { address: { kind: 'session', sessionId: 'codex:new_1' } } },
|
|
}, controller.signal)
|
|
const iterator = source[Symbol.asyncIterator]()
|
|
const snapshot = await iterator.next()
|
|
expect(snapshot.value).toMatchObject({
|
|
type: 'snapshot',
|
|
cursor: -1,
|
|
records: [],
|
|
projections: { values: { sessionListMetadata: { blank: true } } },
|
|
})
|
|
await iterator.return?.()
|
|
await target.close()
|
|
})
|
|
|
|
it('restores catalog sessions without busy-read probes or cross-workspace navigation', async () => {
|
|
await runScenarios([
|
|
{ name: 'restores the most recent running thread even without a title', preferred: undefined, expected: 'codex:latest' },
|
|
{ name: 'retains the previously opened older thread', preferred: 'codex:older', expected: 'codex:older' },
|
|
{ name: 'ignores remembered threads from another workspace', preferred: 'codex:outside', expected: 'codex:latest' },
|
|
{ name: 'falls back to the latest after a remembered thread disappears', preferred: 'codex:missing', expected: 'codex:latest' },
|
|
{ name: 'an empty workspace does not pick another workspace thread', empty: true, expected: undefined },
|
|
{ name: 'an aborted reconnect does not choose a session', aborted: true, expected: undefined },
|
|
].map(scenario => ({
|
|
name: scenario.name,
|
|
run: async () => {
|
|
const client = fakeCodex([
|
|
{ ...codexThread('older', '/workspace/repo', 'Older'), updatedAt: 1_700_000_101 },
|
|
{ ...codexThread('latest', '/workspace/repo', ''), updatedAt: 1_700_000_200, status: { type: 'active' } },
|
|
{ ...codexThread('outside', '/workspace/other', 'Other'), updatedAt: 1_700_000_300 },
|
|
], { projects: [
|
|
codexProject('repo-project', 'repo', ['/workspace/repo'], 0),
|
|
codexProject('empty-project', 'empty', ['/workspace/empty'], 1),
|
|
codexProject('outside-project', 'other', ['/workspace/other'], 2),
|
|
] })
|
|
const original = client.request.getMockImplementation()!
|
|
client.request.mockImplementation(async (method, params) => {
|
|
if (method === 'thread/read') throw new Error('busy')
|
|
return original(method, params)
|
|
})
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
try {
|
|
const workspaces = await target.workspaces()
|
|
await target.selectWorkspace(workspaces.find(workspace => workspace.path === (scenario.empty ? '/workspace/empty' : '/workspace/repo'))!.workspaceId)
|
|
const controller = new AbortController()
|
|
if (scenario.aborted) controller.abort()
|
|
if (scenario.aborted) {
|
|
await expect(target.preferredSessionId(controller.signal, scenario.preferred)).rejects.toMatchObject({ name: 'AbortError' })
|
|
} else {
|
|
await expect(target.preferredSessionId(controller.signal, scenario.preferred)).resolves.toBe(scenario.expected)
|
|
}
|
|
expect(client.request.mock.calls.some(([method]) => method === 'thread/read' || method === 'thread/start' || method === 'thread/resume')).toBe(false)
|
|
} finally {
|
|
await target.close()
|
|
}
|
|
},
|
|
})))
|
|
})
|
|
|
|
it('remembers only successful initial history or follow opens for session recovery', async () => {
|
|
await runScenarios(['history', 'follow'].map(mode => ({
|
|
name: mode,
|
|
run: async () => {
|
|
const client = fakeCodex([codexThread('older', '/workspace/repo', 'Older')])
|
|
const target = new CodexVirtualHarness(client, { deviceId: 'host-1', name: 'Host' })
|
|
const controller = new AbortController()
|
|
try {
|
|
const workspace = (await target.workspaces())[0]!
|
|
await target.selectWorkspace(workspace.workspaceId)
|
|
expect(target.openedSessionId).toBeUndefined()
|
|
if (mode === 'follow') {
|
|
await target.open('session/follow', { args: { request: { address: { kind: 'session', sessionId: 'codex:older' } } } }, controller.signal)
|
|
} else {
|
|
const response = await target.dispatch('session/history', { args: { request: { sessionId: 'codex:older' as never } } }, new AbortController().signal)
|
|
expect(response.ok).toBe(true)
|
|
}
|
|
expect(target.openedSessionId).toBe('codex:older')
|
|
await expect(target.preferredSessionId()).resolves.toBe('codex:older')
|
|
const page = await target.dispatch('session/history', { args: { request: { sessionId: 'codex:thr_1' as never, beforeSeq: 3 } } }, new AbortController().signal)
|
|
expect(page.ok).toBe(true)
|
|
expect(target.openedSessionId).toBe('codex:older')
|
|
const original = client.request.getMockImplementation()!
|
|
client.request.mockImplementation(async (method, params) => {
|
|
if (method === 'dsh/sessionHistory') throw new Error('history temporarily unavailable')
|
|
return original(method, params)
|
|
})
|
|
const failed = await target.dispatch('session/history', { args: { request: { sessionId: 'codex:thr_1' as never } } }, new AbortController().signal)
|
|
expect(failed.ok).toBe(false)
|
|
expect(target.openedSessionId).toBe('codex:older')
|
|
} finally {
|
|
controller.abort()
|
|
await target.close()
|
|
}
|
|
},
|
|
})))
|
|
})
|
|
|
|
it('reuses cached Codex history across project switches and falls back to cached pages on transient failures', async () => {
|
|
const client = fakeCodex()
|
|
const cache = new CodexSessionHistoryCache()
|
|
const signal = new AbortController().signal
|
|
const first = new CodexVirtualHarness(client, { deviceId: 'host_1', name: 'Workstation' }, 'v3', undefined, cache)
|
|
try {
|
|
await first.selectWorkspace('codex-workspace:project:repo-project')
|
|
const [history, projections] = await Promise.all([
|
|
first.dispatch('session/history', { args: { request: { sessionId: 'codex:thr_1' as never } } }, signal),
|
|
first.dispatch('session/projections', { args: { request: { sessionId: 'codex:thr_1' as never } } }, signal),
|
|
])
|
|
expect(history).toMatchObject({ ok: true })
|
|
expect(projections).toMatchObject({ ok: true })
|
|
} finally {
|
|
await first.close()
|
|
}
|
|
const historyCallsAfterFirstOpen = client.request.mock.calls.filter(call => call[0] === 'dsh/sessionHistory').length
|
|
expect(historyCallsAfterFirstOpen).toBeLessThanOrEqual(2)
|
|
|
|
const second = new CodexVirtualHarness(client, { deviceId: 'host_1', name: 'Workstation' }, 'v3', undefined, cache)
|
|
try {
|
|
await second.selectWorkspace('codex-workspace:project:repo-project')
|
|
await expect(second.dispatch('session/projections', { args: { request: { sessionId: 'codex:thr_1' as never } } }, signal)).resolves.toMatchObject({ ok: true })
|
|
await expect(second.dispatch('session/history', { args: { request: { sessionId: 'codex:thr_1' as never } } }, signal)).resolves.toMatchObject({ ok: true })
|
|
expect(client.request.mock.calls.filter(call => call[0] === 'dsh/sessionHistory')).toHaveLength(historyCallsAfterFirstOpen)
|
|
|
|
await second.dispatch('session/prompt', { args: { request: { sessionId: 'codex:thr_1' as never, prompt: [{ type: 'text', text: 'next' }] } } }, signal)
|
|
const original = client.request.getMockImplementation()!
|
|
client.request.mockImplementation(async (method, params) => {
|
|
if (method === 'dsh/sessionHistory') throw new Error('network timeout')
|
|
return original(method, params)
|
|
})
|
|
await expect(second.dispatch('session/history', { args: { request: { sessionId: 'codex:thr_1' as never } } }, signal)).resolves.toMatchObject({ ok: true })
|
|
} finally {
|
|
await second.close()
|
|
}
|
|
})
|
|
})
|
|
|
|
interface FakeCodexOptions {
|
|
projects?: Array<Record<string, unknown>>
|
|
projectListError?: Error
|
|
}
|
|
|
|
function fakeCodex(extraThreads: Array<Record<string, unknown>> = [], options: FakeCodexOptions = {}): {
|
|
request: ReturnType<typeof vi.fn>
|
|
subscribe: ReturnType<typeof vi.fn>
|
|
respond: ReturnType<typeof vi.fn>
|
|
emit(threadId: string, frame: { method: string; params: unknown }): void
|
|
closeStream(threadId: string, reason: 'cancelled' | 'completed' | 'failed' | 'peer-disconnected'): void
|
|
} {
|
|
const subscribers = new Map<string, Set<{
|
|
onFrame: (frame: { method: string; params: unknown }) => void
|
|
onClose?: (reason: 'cancelled' | 'completed' | 'failed' | 'peer-disconnected') => void
|
|
}>>()
|
|
const thread = {
|
|
id: 'thr_1',
|
|
name: 'Native renderer',
|
|
cwd: '/workspace/repo',
|
|
createdAt: 1_700_000_000,
|
|
updatedAt: 1_700_000_100,
|
|
status: { type: 'idle' },
|
|
turns: [{
|
|
id: 'turn_1',
|
|
status: 'completed',
|
|
createdAt: 1_700_000_000,
|
|
updatedAt: 1_700_000_100,
|
|
items: [
|
|
{ id: 'user_1', type: 'userMessage', content: [{ type: 'text', text: 'Use native UI' }] },
|
|
{ id: 'assistant_1', type: 'agentMessage', text: 'Done.', status: 'completed' },
|
|
{
|
|
id: 'command_1',
|
|
type: 'commandExecution',
|
|
command: 'pnpm test',
|
|
aggregatedOutput: '3 passed',
|
|
exitCode: 0,
|
|
status: 'completed',
|
|
},
|
|
{
|
|
id: 'files_1',
|
|
type: 'fileChange',
|
|
status: 'completed',
|
|
changes: [{ path: 'src/native.ts', kind: { type: 'update' }, diff: 'private diff body' }],
|
|
},
|
|
],
|
|
}],
|
|
}
|
|
const threads = [thread, ...extraThreads]
|
|
const projects = options.projects ?? [codexProject('repo-project', 'repo', ['/workspace/repo'], 0)]
|
|
let nextThread = 1
|
|
const request = vi.fn(async (method: string, params?: Record<string, unknown>) => {
|
|
if (method === 'model/list') return { data: [
|
|
{
|
|
id: 'gpt-5.6-sol',
|
|
model: 'gpt-5.6-sol',
|
|
displayName: 'GPT-5.6-Sol',
|
|
description: 'Latest frontier agentic coding model.',
|
|
supportedReasoningEfforts: [
|
|
{ reasoningEffort: 'low', description: 'Fast responses with lighter reasoning' },
|
|
{ reasoningEffort: 'high', description: 'Greater reasoning depth for complex problems' },
|
|
],
|
|
defaultReasoningEffort: 'low',
|
|
isDefault: true,
|
|
},
|
|
{
|
|
id: 'gpt-5.6-terra',
|
|
model: 'gpt-5.6-terra',
|
|
displayName: 'GPT-5.6-Terra',
|
|
supportedReasoningEfforts: [
|
|
{ reasoningEffort: 'medium' },
|
|
{ reasoningEffort: 'high' },
|
|
],
|
|
defaultReasoningEffort: 'medium',
|
|
isDefault: false,
|
|
},
|
|
], nextCursor: null }
|
|
if (method === 'project/list') {
|
|
if (options.projectListError !== undefined) throw options.projectListError
|
|
return { data: projects, nextCursor: null }
|
|
}
|
|
if (method === 'thread/list') return { data: threads }
|
|
if (method === 'thread/read') {
|
|
return { thread: threads.find(item => item.id === params?.threadId) ?? thread }
|
|
}
|
|
if (method === 'dsh/sessionHistory') {
|
|
const source = threads.find(item => item.id === params?.threadId) ?? thread
|
|
return paginateCodexNativeHistory(
|
|
projectCodexNativeHistory(source, `codex:${String(source.id)}`),
|
|
{
|
|
beforeSeq: typeof params?.beforeSeq === 'number' ? params.beforeSeq : undefined,
|
|
throughSeq: typeof params?.throughSeq === 'number' ? params.throughSeq : undefined,
|
|
maxMessages: typeof params?.maxMessages === 'number' ? params.maxMessages : undefined,
|
|
},
|
|
)
|
|
}
|
|
if (method === 'dsh/directoryList') {
|
|
const path = String(params?.path ?? '/workspace/repo')
|
|
return {
|
|
path,
|
|
home: '/workspace/repo',
|
|
crumbs: path === '/workspace/repo'
|
|
? [{ name: 'repo', path: '/workspace/repo', hidden: false }]
|
|
: [
|
|
{ name: 'repo', path: '/workspace/repo', hidden: false },
|
|
{ name: 'src', path: '/workspace/repo/src', hidden: false },
|
|
],
|
|
entries: path === '/workspace/repo'
|
|
? [{ name: 'src', path: '/workspace/repo/src', hidden: false }]
|
|
: [],
|
|
truncated: false,
|
|
}
|
|
}
|
|
if (method === 'thread/start') {
|
|
const created = codexThread(`new_${nextThread++}`, String(params?.cwd), '')
|
|
threads.push(created)
|
|
return { thread: created }
|
|
}
|
|
if (method === 'thread/resume') {
|
|
const resumed = threads.find(item => item.id === params?.threadId) ?? thread
|
|
return params?.threadId === 'thr_full' || params?.permissionPreset === 'danger-full-access'
|
|
? { thread: resumed, approvalPolicy: 'never', sandbox: { type: 'dangerFullAccess' } }
|
|
: { thread: resumed }
|
|
}
|
|
if (method === 'turn/start') return { turn: { id: 'turn_2', status: 'inProgress', items: [] } }
|
|
return {}
|
|
})
|
|
const subscribe = vi.fn(async (
|
|
threadId: string,
|
|
onFrame: (frame: { method: string; params: unknown }) => void,
|
|
_signal?: AbortSignal,
|
|
onClose?: (reason: 'cancelled' | 'completed' | 'failed' | 'peer-disconnected') => void,
|
|
) => {
|
|
const listeners = subscribers.get(threadId) ?? new Set()
|
|
const listener = { onFrame, onClose }
|
|
listeners.add(listener)
|
|
subscribers.set(threadId, listeners)
|
|
return { close: vi.fn(async () => { listeners.delete(listener) }) }
|
|
})
|
|
return {
|
|
request,
|
|
subscribe,
|
|
respond: vi.fn(async () => undefined),
|
|
emit(threadId, frame) {
|
|
for (const listener of subscribers.get(threadId) ?? []) listener.onFrame(frame)
|
|
},
|
|
closeStream(threadId, reason) {
|
|
const listeners = subscribers.get(threadId)
|
|
for (const listener of [...(listeners ?? [])]) {
|
|
listeners?.delete(listener)
|
|
listener.onClose?.(reason)
|
|
}
|
|
},
|
|
}
|
|
}
|
|
|
|
function codexThread(id: string, cwd: string | undefined, name: string, projectId?: string): Record<string, unknown> {
|
|
return {
|
|
id,
|
|
name,
|
|
...(projectId === undefined ? {} : { projectId }),
|
|
...(cwd === undefined ? {} : { cwd }),
|
|
createdAt: 1_700_000_000,
|
|
updatedAt: 1_700_000_100,
|
|
status: { type: 'idle' },
|
|
turns: [],
|
|
}
|
|
}
|
|
|
|
function codexProject(id: string, name: string, roots: string[], position: number): Record<string, unknown> {
|
|
return {
|
|
id,
|
|
name,
|
|
roots: roots.map(path => ({ path })),
|
|
metadata: {},
|
|
position,
|
|
createdAt: 1_700_000_000,
|
|
updatedAt: 1_700_000_100,
|
|
}
|
|
}
|