ds-harness-remote-fast/packages/plugin/tests/codex-domain.test.ts

1539 lines
66 KiB
TypeScript

import { runScenarios, scenarioName } from '../../../scripts/test-scenarios.mjs'
import { mkdtemp, mkdir, realpath, rm, symlink, utimes, writeFile } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { afterEach, describe, expect, it, vi } from 'vitest'
import type {
CodexAppServerInbound,
CodexAppServerInboundHandler,
CodexAppServerLike,
CodexAppServerUnavailableHandler,
} from '../src/codex/app-server.js'
import {
CODEX_THREAD_UNMATERIALIZED,
CODEX_UNMATERIALIZED_THREAD_MESSAGE,
CodexAppServerError,
} from '../src/codex/app-server.js'
import { CodexRemoteDomain, codexBinaryCandidates } from '../src/codex/domain.js'
import type { SafeLogger } from '../src/logging.js'
const cleanup: string[] = []
const cleanupScenario1 = async () => {
await Promise.all(cleanup.splice(0).map((path) => rm(path, { recursive: true, force: true })))
}
afterEach(cleanupScenario1)
describe('CodexRemoteDomain', () => {
it('enables and disables CodeX live without replacing authenticated peers', async () => {
const app = new FakeAppServer('/unused')
const domain = new CodexRemoteDomain({ enabled: false, binary: 'codex' }, logger(), () => app)
await domain.start()
const peer = domain.createPeer({ connectionId: 'live-peer', peerDeviceId: 'device' } as never, async () => undefined)!
expect(peer).toBeDefined()
await domain.reconfigure({ enabled: true, binary: 'codex' })
expect(domain.isAvailable()).toBe(true)
await expect(peer.call({ method: 'project/list', params: {} })).resolves.toBeDefined()
await domain.reconfigure({ enabled: false, binary: 'codex' })
expect(domain.isAvailable()).toBe(false)
await expect(peer.call({ method: 'project/list', params: {} })).rejects.toMatchObject({ code: 'CODEX_UNAVAILABLE' })
await domain.reconfigure({ enabled: true, binary: 'codex' })
await expect(peer.call({ method: 'project/list', params: {} })).resolves.toBeDefined()
await domain.close()
})
it('stays unavailable when the optional domain is disabled', async () => {
const create = vi.fn(() => new FakeAppServer('/unused'))
const domain = new CodexRemoteDomain({ enabled: false, binary: 'codex' }, logger(), create)
await domain.start()
expect(create).not.toHaveBeenCalled()
expect(domain.status()).toEqual({
enabled: false,
available: false,
state: 'disabled',
restartAttempt: 0,
})
await domain.close()
})
it('deduplicates concurrent workspace authority reads without retaining stale roots', async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
await domain.start()
await Promise.all([
domain.call('connection-1', { method: 'thread/read', params: { threadId: 'allowed-thread' } }),
domain.call('connection-2', { method: 'thread/read', params: { threadId: 'allowed-thread' } }),
])
expect(app.calls.filter(call => call.method === 'project/list')).toHaveLength(1)
// One authorization read is shared; each caller still receives its own
// official thread/read response.
expect(app.calls.filter(call => call.method === 'thread/read')).toHaveLength(3)
await domain.call('connection-1', { method: 'thread/read', params: { threadId: 'allowed-thread' } })
expect(app.calls.filter(call => call.method === 'project/list')).toHaveLength(2)
await domain.close()
})
it('enforces CodeX workspace authority for thread and project operations', async () => {
await runScenarios(
[
{
name: 'sanitizes CodeX listings using CodeX as the workspace source of truth',
run: async () => {
const { root, outside } = await directories()
const app = new FakeAppServer(root, outside)
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
await domain.start()
const result = await domain.call('connection-1', { method: 'thread/list', params: {} })
expect(result).toMatchObject({
data: [
{ id: 'allowed-thread', cwd: root, projectId: 'allowed-project' },
{ id: 'outside-thread', cwd: outside, projectId: 'outside-project' },
{ id: 'project-only-thread', projectId: 'allowed-project' },
],
})
expect(JSON.stringify(result)).not.toContain('unprojected-thread')
expect(JSON.stringify(result)).not.toContain('missing-cwd')
const projects = await domain.call('connection-1', { method: 'project/list', params: {} })
expect(projects).toMatchObject({
data: [
{
id: 'allowed-project',
name: 'Allowed Project',
roots: [{ path: root }],
},
{
id: 'outside-project',
name: 'Outside Project',
roots: [{ path: outside }],
},
],
})
expect(JSON.stringify(projects)).not.toContain('private metadata')
expect(JSON.stringify(result)).not.toContain('private rollout path')
await expect(
domain.call('connection-1', {
method: 'thread/shellCommand',
params: { threadId: 'allowed-thread', command: 'whoami' },
}),
).rejects.toMatchObject({ code: 'METHOD_NOT_ALLOWED' })
await expect(
domain.call('connection-1', {
method: 'thread/read',
params: { threadId: 'outside-thread', includeTurns: true },
}),
).resolves.toMatchObject({ thread: { id: 'outside-thread', cwd: outside } })
await expect(
domain.call('connection-1', {
method: 'thread/read',
params: { threadId: 'unprojected-thread', includeTurns: true },
}),
).rejects.toMatchObject({ code: 'CODEX_THREAD_NOT_ALLOWED' })
await domain.close()
},
},
{
name: 'starts new threads only from CodeX advertised workspace paths',
run: async () => {
const { base, root, outside } = await directories()
const child = join(root, 'new-workspace')
await mkdir(child)
const link = join(root, 'outside-link')
await symlink(outside, link, 'dir')
const app = new FakeAppServer(root, outside)
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
await domain.start()
await expect(
domain.call('connection-1', {
method: 'thread/start',
params: { cwd: join(base, 'missing') },
}),
).rejects.toMatchObject({ code: 'CODEX_PATH_NOT_ALLOWED' })
await expect(
domain.call('connection-1', {
method: 'thread/start',
params: { cwd: link },
}),
).rejects.toMatchObject({ code: 'CODEX_PATH_NOT_ALLOWED' })
await expect(
domain.call('connection-1', {
method: 'thread/start',
params: { cwd: root },
}),
).resolves.toMatchObject({ thread: { id: 'new-thread' } })
expect(app.calls.find((call) => call.method === 'thread/start')?.params).toMatchObject({
cwd: root,
approvalPolicy: 'on-request',
sandbox: 'workspace-write',
serviceName: 'deepseek_harness_remote',
})
await expect(
domain.call('connection-1', {
method: 'thread/start',
params: { cwd: child },
}),
).resolves.toMatchObject({ thread: { id: 'new-thread', cwd: child } })
expect(app.calls.filter((call) => call.method === 'thread/start').at(-1)?.params).toMatchObject({
cwd: child,
})
await expect(
domain.call('connection-1', {
method: 'thread/start',
params: { cwd: outside },
}),
).resolves.toMatchObject({ thread: { id: 'new-thread' } })
expect(base).toContain(tmpdir())
await domain.close()
},
},
{
name: 'creates a sanitized CodeX project only for an existing absolute directory',
run: async () => {
const { base, root } = await directories()
const canonicalRoot = await realpath(root)
const link = join(base, 'selected-project-link')
await symlink(root, link, 'dir')
const app = new FakeAppServer(root)
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
await domain.start()
await expect(
domain.call('connection-1', {
method: 'project/create',
params: {
name: ' New Project ',
roots: [{ path: link }],
idempotencyKey: '018f47f6-5f5a-7b5a-8d74-2e797b4d749c',
},
}),
).resolves.toEqual({
project: {
id: 'created-project',
name: 'New Project',
roots: [{ path: canonicalRoot }],
position: 2,
createdAt: 3,
updatedAt: 3,
},
})
expect(app.calls.find((call) => call.method === 'project/create')).toEqual({
method: 'project/create',
params: {
name: 'New Project',
roots: [{ path: canonicalRoot }],
idempotencyKey: '018f47f6-5f5a-7b5a-8d74-2e797b4d749c',
},
})
await expect(
domain.call('connection-1', {
method: 'project/create',
params: {
name: 'Missing',
roots: [{ path: join(base, 'missing') }],
idempotencyKey: '018f47f6-5f5a-7b5a-8d74-2e797b4d749d',
},
}),
).rejects.toMatchObject({ code: 'CODEX_PATH_NOT_ALLOWED' })
await domain.close()
},
},
{
name: 'lists only directories inside the CodeX workspace authority',
run: async () => {
const { base, root, outside } = await directories()
const child = join(root, 'child')
const hidden = join(root, '.hidden')
const outsideLink = join(root, 'outside-link')
await mkdir(child)
await mkdir(hidden)
await symlink(outside, outsideLink, 'dir')
const app = new FakeAppServer(root, outside)
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
await domain.start()
const result = await domain.call('connection-1', {
method: 'dsh/directoryList',
params: { path: root },
})
expect(result).toMatchObject({
path: root,
home: root,
crumbs: [{ name: 'allowed', path: root, hidden: false }],
entries: expect.arrayContaining([
{ name: 'child', path: child, hidden: false },
{ name: '.hidden', path: hidden, hidden: true },
]),
truncated: false,
})
expect(JSON.stringify(result)).not.toContain('outside-link')
await expect(
domain.call('connection-1', {
method: 'dsh/directoryList',
params: { path: outsideLink },
}),
).rejects.toMatchObject({ code: 'CODEX_PATH_NOT_ALLOWED' })
await expect(
domain.call('connection-1', {
method: 'dsh/directoryList',
params: { path: join(base, 'never-advertised') },
}),
).rejects.toMatchObject({ code: 'CODEX_PATH_NOT_ALLOWED' })
await domain.close()
},
},
],
async () => {
await cleanupScenario1()
},
)
}, 20000)
it('uses exact thread cwd authority for unavailable and empty project listings', async () => {
const rows = ['empty', 'unsupported'] as const
await runScenarios(
rows.map((row, index) => {
const projectListMode = row
return {
name: scenarioName('uses exact thread cwd authority when project/list is %s', row, index),
run: async () => {
const { base, root, outside } = await directories()
const app = new FakeAppServer(root, outside)
app.projectListMode = projectListMode
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
await domain.start()
const result = await domain.call('connection-1', { method: 'thread/list', params: {} })
expect(result).toMatchObject({
data: [
{ id: 'allowed-thread', cwd: root },
{ id: 'outside-thread', cwd: outside },
{ id: 'unprojected-thread', cwd: `${root}-unprojected` },
],
})
expect(JSON.stringify(result)).not.toContain('project-only-thread')
expect(JSON.stringify(result)).not.toContain('missing-cwd')
expect(app.calls.filter((call) => call.method === 'thread/list')).toHaveLength(1)
await expect(
domain.call('connection-1', {
method: 'thread/read',
params: { threadId: 'unprojected-thread' },
}),
).resolves.toMatchObject({ thread: { id: 'unprojected-thread', cwd: `${root}-unprojected` } })
await expect(
domain.call('connection-1', {
method: 'thread/start',
params: { cwd: root },
}),
).resolves.toMatchObject({ thread: { id: 'new-thread', cwd: root } })
await expect(
domain.call('connection-1', {
method: 'thread/start',
params: { cwd: join(base, 'never-advertised') },
}),
).rejects.toMatchObject({ code: 'CODEX_PATH_NOT_ALLOWED' })
await domain.close()
},
}
}),
async () => {
await cleanupScenario1()
},
)
})
it('uses explicit presets and authoritative App Server permission defaults', async () => {
await runScenarios(
[
{
name: 'maps the explicit Full access preset to fixed App Server policies',
run: async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
await domain.start()
await domain.call('connection-1', {
method: 'thread/resume',
params: { threadId: 'allowed-thread', permissionPreset: 'danger-full-access' },
})
await domain.call('connection-1', {
method: 'turn/start',
params: {
threadId: 'allowed-thread',
input: [{ type: 'text', text: 'Run without approval prompts' }],
permissionPreset: 'danger-full-access',
},
})
expect(app.calls.find((call) => call.method === 'thread/settings/update')?.params).toMatchObject({
approvalPolicy: 'never',
sandboxPolicy: { type: 'dangerFullAccess' },
})
expect(app.calls.find((call) => call.method === 'turn/start')?.params).toMatchObject({
approvalPolicy: 'never',
sandboxPolicy: { type: 'dangerFullAccess' },
})
expect(JSON.stringify(app.calls)).not.toContain('permissionPreset')
await domain.close()
},
},
{
name: 'inherits App Server permission defaults when no preset is provided',
run: async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
await domain.start()
await domain.call('connection-1', {
method: 'thread/resume',
params: { threadId: 'allowed-thread' },
})
await domain.call('connection-1', {
method: 'turn/start',
params: {
threadId: 'allowed-thread',
input: [{ type: 'text', text: 'Use the thread defaults' }],
},
})
const resume = app.calls.find((call) => call.method === 'thread/resume')?.params as Record<
string,
unknown
>
const turn = app.calls.find((call) => call.method === 'turn/start')?.params as Record<
string,
unknown
>
expect(resume.approvalPolicy).toBeUndefined()
expect(resume.sandbox).toBeUndefined()
expect(turn.approvalPolicy).toBeUndefined()
expect(turn.sandboxPolicy).toBeUndefined()
await domain.close()
},
},
],
async () => {
await cleanupScenario1()
},
)
}, 10000)
it('confirms permission changes and fails closed on rejected updates', async () => {
await runScenarios(
[
{
name: 'confirms loaded-thread permission changes and exposes them in read-only history',
run: async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
await domain.start()
const history = () =>
domain.call('observer', { method: 'dsh/sessionHistory', params: { threadId: 'allowed-thread' } })
await expect(history()).resolves.toMatchObject({ permissionPreset: null })
expect(app.calls.some((call) => call.method === 'thread/resume')).toBe(false)
await expect(
domain.call('writer', {
method: 'thread/resume',
params: { threadId: 'allowed-thread', permissionPreset: 'danger-full-access' },
}),
).resolves.toMatchObject({ approvalPolicy: 'never', sandbox: { type: 'dangerFullAccess' } })
expect(app.calls.find((call) => call.method === 'thread/settings/update')?.params).toEqual({
threadId: 'allowed-thread',
approvalPolicy: 'never',
sandboxPolicy: { type: 'dangerFullAccess' },
})
await expect(history()).resolves.toMatchObject({ permissionPreset: 'danger-full-access' })
app.emit({
kind: 'notification',
method: 'thread/settings/updated',
params: {
threadId: 'allowed-thread',
threadSettings: { approvalPolicy: 'never', sandboxPolicy: { type: 'readOnly' } },
},
})
await expect(history()).resolves.toMatchObject({ permissionPreset: null })
await expect(
domain.call('observer', {
method: 'dsh/sessionHistory',
params: { threadId: 'unprojected-thread' },
}),
).rejects.toMatchObject({ code: 'CODEX_THREAD_NOT_ALLOWED' })
await domain.close()
},
},
{
name: 'does not confirm a rejected setting or let an observer change an active writer policy',
run: async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
await domain.start()
app.rejectSettings = true
const change = () =>
domain.call('observer', {
method: 'thread/resume',
params: { threadId: 'allowed-thread', permissionPreset: 'danger-full-access' },
})
await expect(change()).rejects.toMatchObject({ code: 'CODEX_UPSTREAM_ERROR' })
await expect(
domain.call('observer', {
method: 'dsh/sessionHistory',
params: { threadId: 'allowed-thread' },
}),
).resolves.toMatchObject({ permissionPreset: null })
await domain.call('writer', {
method: 'turn/start',
params: { threadId: 'allowed-thread', input: [{ type: 'text', text: 'Run' }] },
})
const resumes = app.calls.filter((call) => call.method === 'thread/resume').length
await expect(change()).rejects.toMatchObject({ code: 'CODEX_THREAD_BUSY' })
expect(app.calls.filter((call) => call.method === 'thread/resume')).toHaveLength(resumes)
await domain.close()
},
},
{
name: 'supports older App Servers only when resume confirms the requested policy',
run: async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
app.rejectSettings = true
const upstream = app.call.bind(app)
vi.spyOn(app, 'call').mockImplementation(async (method, params) => {
const result = await upstream(method, params)
return method === 'thread/resume'
? {
...(isRecord(result) ? result : {}),
approvalPolicy: 'never',
sandbox: { type: 'dangerFullAccess' },
}
: result
})
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
await domain.start()
await expect(
domain.call('writer', {
method: 'thread/resume',
params: { threadId: 'allowed-thread', permissionPreset: 'danger-full-access' },
}),
).resolves.toMatchObject({ approvalPolicy: 'never', sandbox: { type: 'dangerFullAccess' } })
expect(app.calls.filter((call) => call.method === 'thread/settings/update')).toHaveLength(1)
await domain.close()
},
},
{
name: 'does not hide rejection when both permission update paths fail',
run: async () => {
const { root, outside } = await directories()
const app = new FakeAppServer(root, outside)
app.rejectResume = true
app.rejectSettings = true
const domain = new CodexRemoteDomain(
{ enabled: true, binary: '/custom/codex' },
logger(),
() => app,
)
await domain.start()
await expect(
domain.call('connection-1', {
method: 'thread/resume',
params: { threadId: 'allowed-thread', permissionPreset: 'danger-full-access' },
}),
).rejects.toMatchObject({ code: 'CODEX_UPSTREAM_ERROR' })
await domain.close()
},
},
{
name: 'keeps new-session permission changes working before the App Server persists the thread',
run: async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
app.rejectSettings = true
app.resumeRolloutMissing = true
const domain = new CodexRemoteDomain(
{ enabled: true, binary: '/custom/codex' },
logger(),
() => app,
)
await domain.start()
// Regression: ChatGPT.app codex 0.162 rejects thread/resume with
// "no rollout found" for threads created in this process, which
// surfaced as "Codex App Server rejected the request." on the
// Remote client during new-session permission changes.
await expect(
domain.call('connection-1', {
method: 'thread/resume',
params: { threadId: 'allowed-thread', permissionPreset: 'danger-full-access' },
}),
).resolves.toMatchObject({
thread: { id: 'allowed-thread', cwd: root },
approvalPolicy: 'never',
sandbox: { type: 'dangerFullAccess' },
})
expect(app.calls.some((call) => call.method === 'thread/settings/updated')).toBe(false)
await domain.close()
},
},
{
name: 'keeps generic permission-update rejections failing closed',
run: async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
app.rejectSettings = true
app.rejectResume = true
const domain = new CodexRemoteDomain(
{ enabled: true, binary: '/custom/codex' },
logger(),
() => app,
)
await domain.start()
await expect(
domain.call('connection-1', {
method: 'thread/resume',
params: { threadId: 'allowed-thread', permissionPreset: 'danger-full-access' },
}),
).rejects.toMatchObject({ code: 'CODEX_UPSTREAM_ERROR' })
await domain.close()
},
},
],
async () => {
await cleanupScenario1()
},
)
}, 20000)
it('maps bounded remote image input to an App Server data URL', async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
await domain.start()
await domain.call('connection-1', {
method: 'turn/start',
params: {
threadId: 'allowed-thread',
input: [
{ type: 'text', text: 'Describe the image' },
{ type: 'image', mediaType: 'image/png', data: 'aW1hZ2U=' },
],
},
})
expect(app.calls.find(call => call.method === 'turn/start')?.params).toMatchObject({
input: [
{ type: 'text', text: 'Describe the image' },
{ type: 'image', url: 'data:image/png;base64,aW1hZ2U=' },
],
})
await expect(domain.call('connection-1', {
method: 'turn/start',
params: {
threadId: 'allowed-thread',
input: [{ type: 'image', mediaType: 'image/png', data: 'not-base64' }],
},
})).rejects.toMatchObject({ code: 'INVALID_MESSAGE' })
await domain.close()
})
it('pages CodeX history with a bounded legacy fallback', async () => {
await runScenarios(
[
{
name: 'projects and paginates CodeX History on the Host before returning it to the Client',
run: async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
await domain.start()
const tail = await domain.call('connection-1', {
method: 'dsh/sessionHistory',
params: { threadId: 'allowed-thread', maxMessages: 1 },
})
expect(tail).toMatchObject({ cursor: 5, hasMore: true })
expect(
(tail as { records: Array<{ event: { seq: number } }> }).records.map((entry) => entry.event.seq),
).toEqual([3, 4, 5])
expect(app.calls.at(-1)).toEqual({
method: 'thread/turns/list',
params: { threadId: 'allowed-thread', limit: 25, sortDirection: 'asc', itemsView: 'full' },
})
const older = await domain.call('connection-1', {
method: 'dsh/sessionHistory',
params: { threadId: 'allowed-thread', beforeSeq: 3, throughSeq: 5, maxMessages: 1 },
})
expect(
(older as { records: Array<{ event: { seq: number } }> }).records.map((entry) => entry.event.seq),
).toEqual([2])
await domain.close()
},
},
{
name: 'keeps genuine successful empty history distinct from failed reads',
run: async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
const original = app.call.bind(app)
vi.spyOn(app, 'call').mockImplementation((method, params) => method === 'thread/turns/list'
? Promise.resolve({ data: [], nextCursor: null }) : original(method, params))
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
try {
await domain.start()
await expect(domain.call('connection-1', {
method: 'dsh/sessionHistory', params: { threadId: 'allowed-thread' },
})).resolves.toMatchObject({ cursor: -1, records: [], hasMore: false })
} finally {
await domain.close()
}
},
},
{
name: 'falls back to legacy full Thread reads when paginated history is unavailable',
run: async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
app.rejectTurnPagination = true
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
await domain.start()
const history = await domain.call('connection-1', {
method: 'dsh/sessionHistory',
params: { threadId: 'allowed-thread', maxMessages: 1 },
})
expect(history).toMatchObject({ cursor: 5, hasMore: true })
expect(app.calls.map((call) => call.method)).toContain('thread/turns/list')
expect(app.calls.at(-1)).toEqual({
method: 'thread/read',
params: { threadId: 'allowed-thread', includeTurns: true },
})
await domain.close()
},
},
],
async () => {
await cleanupScenario1()
},
)
}, 10000)
it('reads summary history item pages in parallel while retaining turn order', async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
const original = app.call.bind(app)
let activeItemReads = 0
let maxActiveItemReads = 0
vi.spyOn(app, 'call').mockImplementation(async (method, params) => {
if (method === 'thread/turns/list') {
if (isRecord(params) && params.itemsView === 'full') {
throw new CodexAppServerError('METHOD_NOT_FOUND', 'method not found')
}
return {
data: [1, 2, 3].map(index => ({
id: `turn-${index}`,
status: 'completed',
itemsView: 'summary',
})),
nextCursor: null,
}
}
if (method === 'thread/items/list') {
const turnId = isRecord(params) && typeof params.turnId === 'string' ? params.turnId : 'unknown'
activeItemReads += 1
maxActiveItemReads = Math.max(maxActiveItemReads, activeItemReads)
await new Promise(resolve => setTimeout(resolve, 10))
activeItemReads -= 1
return {
data: [{ item: { id: `item-${turnId}`, type: 'userMessage', text: turnId } }],
nextCursor: null,
}
}
return original(method, params)
})
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
try {
await domain.start()
const history = await domain.call('connection-1', {
method: 'dsh/sessionHistory',
params: { threadId: 'allowed-thread' },
}) as { records: Array<{ event: { data: unknown } }> }
expect(maxActiveItemReads).toBe(3)
const text = history.records
.map(record => JSON.stringify(record.event.data))
.filter(value => value.includes('turn-'))
expect(text.join('\n')).toMatch(/turn-1[\s\S]*turn-2[\s\S]*turn-3/)
} finally {
await domain.close()
}
}, 10000)
it('projects a new unmaterialized Thread as empty history so it can be followed', async () => {
await runScenarios([
{
name: 'empty first turn page from an unmaterialized Thread',
run: async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
app.unmaterializedThread = true
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
try {
await domain.start()
const history = await domain.call('connection-1', {
method: 'dsh/sessionHistory',
params: { threadId: 'allowed-thread', maxMessages: 1 },
})
expect(history).toMatchObject({ cursor: -1, records: [], hasMore: false })
expect(app.calls.filter(call => call.method === 'thread/turns/list')).toHaveLength(1)
expect(app.calls.some(call => call.method === 'thread/read'
&& isRecord(call.params) && call.params.includeTurns === true)).toBe(false)
} finally {
await domain.close()
}
},
},
{
name: 'legacy full Thread read on an unmaterialized Thread',
run: async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
app.legacyUnmaterializedThread = true
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
try {
await domain.start()
const history = await domain.call('connection-1', {
method: 'dsh/sessionHistory',
params: { threadId: 'allowed-thread', maxMessages: 1 },
})
expect(history).toMatchObject({ cursor: -1, records: [], hasMore: false })
expect(app.calls.some(call => call.method === 'thread/read'
&& isRecord(call.params) && call.params.includeTurns === true)).toBe(true)
} finally {
await domain.close()
}
},
},
{
name: 'a later page failure never replaces already-read history with a blank',
run: async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
app.unmaterializedAfterFirstPage = true
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
try {
await domain.start()
await expect(domain.call('connection-1', {
method: 'dsh/sessionHistory',
params: { threadId: 'allowed-thread' },
})).rejects.toMatchObject({ code: CODEX_THREAD_UNMATERIALIZED })
expect(app.calls.some(call => isRecord(call.params) && call.params.cursor === 'page-2')).toBe(true)
} finally {
await domain.close()
}
},
},
])
}, 10000)
it('does not replace a populated reconnect baseline with empty history on read failures', async () => {
const scenarios = [
{ name: 'busy turn read', stage: 'turns', error: new CodexAppServerError('CODEX_UPSTREAM_ERROR', 'Thread has an active writer.'), code: 'CODEX_THREAD_BUSY' },
{ name: 'timed out turn read', stage: 'turns', error: new CodexAppServerError('CODEX_REQUEST_TIMEOUT', 'Request timed out.'), code: 'CODEX_REQUEST_TIMEOUT' },
{ name: 'timed out item read', stage: 'items', error: new CodexAppServerError('CODEX_REQUEST_TIMEOUT', 'Request timed out.'), code: 'CODEX_REQUEST_TIMEOUT' },
{ name: 'all history APIs unavailable', stage: 'all', error: new CodexAppServerError('CODEX_UPSTREAM_ERROR', 'History unavailable.'), code: 'CODEX_UPSTREAM_ERROR' },
{ name: 'malformed turn page', stage: 'invalid-turns', code: 'CODEX_INVALID_RESPONSE' },
{ name: 'malformed item page', stage: 'invalid-items', code: 'CODEX_INVALID_RESPONSE' },
{ name: 'malformed turn entry', stage: 'invalid-turn', code: 'CODEX_INVALID_RESPONSE' },
{ name: 'full turn missing items', stage: 'invalid-full', code: 'CODEX_INVALID_RESPONSE' },
{ name: 'malformed pagination cursor', stage: 'invalid-cursor', code: 'CODEX_INVALID_RESPONSE' },
{ name: 'malformed legacy full history', stage: 'invalid-legacy', error: new CodexAppServerError('CODEX_UPSTREAM_ERROR', 'Pagination unavailable.'), code: 'CODEX_INVALID_RESPONSE' },
{ name: 'nonempty summary cannot replace a failed second item page', stage: 'items-late', error: new CodexAppServerError('CODEX_UPSTREAM_ERROR', 'History unavailable.'), code: 'CODEX_UPSTREAM_ERROR' },
{ name: 'turn pagination budget does not return the oldest prefix', stage: 'turn-limit', code: 'PAYLOAD_TOO_LARGE' },
{ name: 'item pagination budget does not return a partial turn', stage: 'item-limit', code: 'PAYLOAD_TOO_LARGE' },
]
await runScenarios(scenarios.map(scenario => ({
name: scenario.name,
run: async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
const original = app.call.bind(app)
let failing = false
vi.spyOn(app, 'call').mockImplementation(async (method, params) => {
const result = await original(method, params)
if (!failing) return result
if (method === 'thread/turns/list') {
if (scenario.stage === 'invalid-turns') return {}
if (scenario.stage === 'invalid-turn') return { data: [null], nextCursor: null }
if (scenario.stage === 'invalid-full') return { data: [{ id: 'turn-1', itemsView: 'full' }], nextCursor: null }
if (scenario.stage === 'turn-limit') return { data: [], nextCursor: 'more' }
if (scenario.stage === 'invalid-cursor') return { data: [], nextCursor: 1 }
if (['turns', 'all', 'invalid-legacy'].includes(scenario.stage)) throw scenario.error
// Summary turns need a separate items read; even a nonempty
// summary cannot replace failed full content on a later page.
return { data: [{ id: 'turn-1', status: 'completed', itemsView: 'summary', items: [
{ id: 'summary-user', type: 'userMessage', text: 'Summary only' },
] }], nextCursor: null }
}
if (method === 'thread/items/list') {
if (scenario.stage === 'invalid-items') return { data: [{}], nextCursor: null }
if (scenario.stage === 'item-limit') return { data: [], nextCursor: 'more' }
if (scenario.stage === 'items-late' && isRecord(params) && params.cursor === undefined) {
return { data: [{ item: { id: 'full-user', type: 'userMessage', text: 'Full first page' } }], nextCursor: 'page-2' }
}
throw scenario.error
}
if (method === 'thread/read' && isRecord(params) && params.includeTurns === true) {
if (scenario.stage === 'invalid-legacy') return { thread: { id: 'allowed-thread', cwd: root, turns: [{}] } }
if (['all', 'items-late'].includes(scenario.stage)) throw scenario.error
}
return result
})
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
try {
await domain.start()
const read = (connectionId: string) => domain.call(connectionId, {
method: 'dsh/sessionHistory', params: { threadId: 'allowed-thread', maxMessages: 1 },
})
const baseline = await read('connection-1')
failing = true
app.calls.length = 0
await expect(read('replacement-connection')).rejects.toMatchObject({ code: scenario.code })
if (scenario.code === 'CODEX_THREAD_BUSY' || scenario.code === 'CODEX_REQUEST_TIMEOUT') {
expect(app.calls.filter(call => call.method === 'thread/turns/list')).toHaveLength(1)
expect(app.calls.some(call => call.method === 'thread/read' && isRecord(call.params) && call.params.includeTurns === true)).toBe(false)
}
failing = false
await expect(read('replacement-connection')).resolves.toEqual(baseline)
expect(app.calls.some(call => call.method === 'thread/resume' || call.method === 'turn/start')).toBe(false)
} finally {
await domain.close()
}
},
})), cleanupScenario1)
}, 10000)
it('treats resume as idempotent when App Server already has the allowed thread loaded', async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
app.rejectResume = true
const domain = new CodexRemoteDomain({ enabled: true, binary: '/custom/codex' }, logger(), () => app)
await domain.start()
await expect(domain.call('connection-1', {
method: 'thread/resume', params: { threadId: 'allowed-thread' },
})).resolves.toMatchObject({ thread: { id: 'allowed-thread', cwd: root } })
expect(app.calls.filter(call => call.method === 'thread/read')).toHaveLength(1)
expect(app.calls.filter(call => call.method === 'thread/resume')).toHaveLength(1)
await domain.close()
})
it('fails silent turns after the watchdog timeout and releases the writer lease', async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
const domain = new CodexRemoteDomain(
{ enabled: true, binary: 'codex' },
logger(),
() => app,
[1_000],
50,
)
await domain.start()
const frames: Array<{ event: string; data: unknown }> = []
const owner = domain.createPeer(
{ connectionId: 'connection-1', peerDeviceId: 'peer-1' },
async (event, data) => { frames.push({ event, data }) },
)!
const waiter = domain.createPeer(
{ connectionId: 'connection-2', peerDeviceId: 'peer-2' },
async () => undefined,
)!
await owner.openStream({ streamId: 'stream-1', threadId: 'allowed-thread' })
await owner.call({
method: 'turn/start',
params: { threadId: 'allowed-thread', input: [{ type: 'text', text: 'Hello' }] },
})
await expect(waiter.call({
method: 'turn/start',
params: { threadId: 'allowed-thread', input: [{ type: 'text', text: 'Compete' }] },
})).rejects.toMatchObject({ code: 'CODEX_TURN_OWNED' })
await vi.waitFor(() => {
const completed = frames.find(frame => frame.event === 'codex.app.frame'
&& isRecord(frame.data)
&& isRecord(frame.data.frame)
&& frame.data.frame.method === 'turn/completed')
expect(completed).toBeDefined()
const turn = isRecord(completed?.data)
&& isRecord(completed.data.frame)
&& isRecord(completed.data.frame.params)
? completed.data.frame.params.turn
: undefined
expect(turn).toMatchObject({
status: 'failed',
error: {
message: expect.stringContaining('timed out waiting for the App Server'),
codex_error_info: 'remote_turn_silence',
},
})
})
await expect(waiter.call({
method: 'turn/start',
params: { threadId: 'allowed-thread', input: [{ type: 'text', text: 'Retry after silence' }] },
})).resolves.toMatchObject({ turn: { id: 'turn-1' } })
await domain.close()
})
it('isolates streams and approval handles to the active turn owner', async () => {
const { root, outside } = await directories()
const app = new FakeAppServer(root, outside)
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
await domain.start()
const peerOneFrames: Array<{ event: string; data: unknown }> = []
const peerTwoFrames: Array<{ event: string; data: unknown }> = []
const peerOne = domain.createPeer(
{ connectionId: 'connection-1', peerDeviceId: 'peer-1' },
async (event, data) => { peerOneFrames.push({ event, data }) },
)!
const peerTwo = domain.createPeer(
{ connectionId: 'connection-2', peerDeviceId: 'peer-2' },
async (event, data) => { peerTwoFrames.push({ event, data }) },
)!
await peerOne.openStream({ streamId: 'stream-1', threadId: 'allowed-thread' })
await peerTwo.openStream({ streamId: 'stream-2', threadId: 'allowed-thread' })
await peerOne.call({
method: 'thread/fork',
params: { threadId: 'allowed-thread', permissionPreset: 'workspace-write' },
})
expect(app.calls.find(call => call.method === 'thread/fork')?.params).toMatchObject({
cwd: root,
approvalPolicy: 'on-request',
sandbox: 'workspace-write',
})
await peerOne.call({
method: 'turn/start',
params: {
threadId: 'allowed-thread',
input: [{ type: 'text', text: 'Run tests' }],
permissionPreset: 'workspace-write',
},
})
const enforcedTurn = app.calls.find(call => call.method === 'turn/start')?.params
expect(enforcedTurn).toMatchObject({
approvalPolicy: 'on-request',
sandboxPolicy: {
type: 'workspaceWrite',
networkAccess: false,
excludeTmpdirEnvVar: false,
excludeSlashTmp: false,
},
})
expect(isRecord(enforcedTurn) && typeof enforcedTurn.cwd === 'string' && enforcedTurn.cwd.endsWith('/allowed')).toBe(true)
expect(isRecord(enforcedTurn) && isRecord(enforcedTurn.sandboxPolicy)
? enforcedTurn.sandboxPolicy.writableRoots
: undefined).toEqual(isRecord(enforcedTurn) ? [enforcedTurn.cwd] : undefined)
await expect(peerTwo.call({
method: 'turn/start',
params: { threadId: 'allowed-thread', input: [{ type: 'text', text: 'Compete' }] },
})).rejects.toMatchObject({ code: 'CODEX_TURN_OWNED' })
// A terminal Thread status is sufficient to release the writer lease;
// not every App Server failure path emits turn/completed afterwards.
app.emit({
kind: 'notification',
method: 'thread/status/changed',
params: { threadId: 'allowed-thread', status: { type: 'systemError' } },
})
await flush()
await expect(peerTwo.call({
method: 'turn/start',
params: { threadId: 'allowed-thread', input: [{ type: 'text', text: 'Retry after failure' }] },
})).resolves.toMatchObject({ turn: { id: 'turn-1' } })
app.emit({
kind: 'notification',
method: 'turn/completed',
params: { threadId: 'allowed-thread', turn: { id: 'turn-1', status: 'completed', items: [] } },
})
await peerOne.call({
method: 'turn/start',
params: { threadId: 'allowed-thread', input: [{ type: 'text', text: 'Continue' }] },
})
app.emit({
kind: 'request',
id: 91,
method: 'item/commandExecution/requestApproval',
params: {
threadId: 'allowed-thread',
turnId: 'turn-1',
itemId: 'item-1',
command: 'pnpm test',
proposedExecpolicyAmendment: ['never expose'],
availableDecisions: ['accept', 'acceptForSession', 'decline'],
},
})
await flush()
const approvalFrame = peerOneFrames.find(frame => JSON.stringify(frame.data).includes('requestHandle'))
expect(approvalFrame).toBeDefined()
expect(JSON.stringify(approvalFrame)).not.toContain('acceptForSession')
expect(JSON.stringify(approvalFrame)).not.toContain('proposedExecpolicyAmendment')
expect(peerTwoFrames.some(frame => JSON.stringify(frame.data).includes('requestHandle'))).toBe(false)
const requestHandle = extractRequestHandle(approvalFrame!.data)
await expect(peerTwo.respond({ requestHandle, decision: 'accept' })).rejects.toMatchObject({
code: 'CODEX_APPROVAL_NOT_FOUND',
})
await peerOne.respond({ requestHandle, decision: 'accept' })
expect(app.responses).toContainEqual({ id: 91, result: { decision: 'accept' } })
await peerOne.closeAll()
await expect(peerTwo.call({
method: 'turn/interrupt',
params: { threadId: 'allowed-thread', turnId: 'turn-1' },
})).resolves.toEqual({})
await peerTwo.closeAll()
await domain.close()
})
it('lets a replacement connection from the same peer stop its recovered active turn', async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
await domain.start()
const peerOne = domain.createPeer(
{ connectionId: 'connection-1', peerDeviceId: 'phone-1' },
async () => undefined,
)!
const peerReplacement = domain.createPeer(
{ connectionId: 'connection-2', peerDeviceId: 'phone-1' },
async () => undefined,
)!
await peerOne.call({
method: 'turn/start',
params: { threadId: 'allowed-thread', input: [{ type: 'text', text: 'Run tests' }] },
})
await expect(peerOne.call({
method: 'dsh/sessionHistory',
params: { threadId: 'allowed-thread', maxMessages: 1 },
})).resolves.toMatchObject({ activeTurnId: 'turn-1' })
await expect(peerReplacement.call({
method: 'turn/interrupt',
params: { threadId: 'allowed-thread', turnId: 'turn-1' },
})).resolves.toEqual({})
await peerOne.closeAll()
await peerReplacement.closeAll()
await domain.close()
})
it('maps active writer rejections to a CodeX busy error', async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
app.rejectTurnStartBusy = true
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
await domain.start()
await expect(domain.call('connection-1', {
method: 'turn/start',
params: { threadId: 'allowed-thread', input: [{ type: 'text', text: 'Run tests' }] },
})).rejects.toMatchObject({
code: 'CODEX_THREAD_BUSY',
message: 'The selected CodeX thread is already active in another CodeX client.',
})
await domain.close()
})
it('invalidates pending workspace authority when its connection or App Server changes', async () => {
await runScenarios(['disconnect', 'replace', 'close'].flatMap(action =>
['thread/start', 'turn/start', 'permission', 'workspace'].map(operation => ({
name: `${operation}: ${action}`,
run: async () => {
const { root } = await directories()
const first = new FakeAppServer(root)
const second = new FakeAppServer(root)
const create = vi.fn().mockReturnValueOnce(first).mockReturnValueOnce(second)
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), create)
await domain.start()
const peer = domain.createPeer({ connectionId: 'old', peerDeviceId: 'device' }, async () => undefined)!
let release!: () => void
let entered!: () => void
const blocked = new Promise<void>(resolve => { release = resolve })
const waiting = new Promise<void>(resolve => { entered = resolve })
const original = first.call.bind(first)
vi.spyOn(first, 'call').mockImplementation(async (method, params) => {
const result = await original(method, params)
if (method === 'project/list') { entered(); await blocked }
return result
})
const pending = operation === 'workspace'
? domain.resolveThreadWorkspace('old', 'allowed-thread')
: peer.call(operation === 'thread/start'
? { method: operation, params: { cwd: root } }
: operation === 'permission'
? { method: 'thread/resume', params: { threadId: 'allowed-thread', permissionPreset: 'workspace-write' } }
: { method: operation, params: { threadId: 'allowed-thread', input: [{ type: 'text', text: 'hello' }] } })
const outcome = pending.then(value => ({ value }), error => ({ error }))
try {
await Promise.race([waiting, outcome.then(result => { throw new Error(`Request settled before authority check: ${JSON.stringify(result)}`) })])
if (action === 'disconnect') await peer.closeAll()
else if (action === 'replace') await domain.reconfigure({ enabled: true, binary: 'replacement' })
else await domain.close()
release()
expect(await outcome).toHaveProperty('error')
expect([...first.calls, ...second.calls].some(call =>
['thread/start', 'turn/start', 'thread/resume', 'thread/settings/update'].includes(call.method))).toBe(false)
} finally {
release()
await outcome
await domain.close()
}
},
}))), cleanupScenario1)
})
it('keeps a replacement writer lease when an old turn settles late', async () => {
await runScenarios(['success', 'failure'].map(result => ({
name: `late ${result}`,
run: async () => {
const { root } = await directories()
const app = new FakeAppServer(root)
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), () => app)
await domain.start()
let finishClose!: () => void
const closeGate = new Promise<void>(resolve => { finishClose = resolve })
const old = domain.createPeer({ connectionId: 'old', peerDeviceId: 'old-device' }, async event => {
if (event === 'codex.app.stream.closed') await closeGate
})!
await old.openStream({ streamId: 'existing', threadId: 'allowed-thread' })
const next = domain.createPeer({ connectionId: 'next', peerDeviceId: 'next-device' }, async () => undefined)!
const observer = domain.createPeer({ connectionId: 'observer', peerDeviceId: 'observer-device' }, async () => undefined)!
let release!: () => void
let entered!: () => void
const blocked = new Promise<void>(resolve => { release = resolve })
const waiting = new Promise<void>(resolve => { entered = resolve })
const original = app.call.bind(app)
let first = true
vi.spyOn(app, 'call').mockImplementation(async (method, params) => {
if (method === 'turn/start' && first) {
first = false
entered()
await blocked
if (result === 'failure') throw new CodexAppServerError('CODEX_UPSTREAM_ERROR', 'Rejected')
}
return original(method, params)
})
const request = { method: 'turn/start', params: { threadId: 'allowed-thread', input: [{ type: 'text', text: 'hello' }] } }
const outcome = old.call(request).then(value => ({ value }), error => ({ error }))
let closing: Promise<void> | undefined
try {
await waiting
closing = old.closeAll()
await next.call(request)
release()
expect(await outcome).toHaveProperty('error')
await expect(observer.call(request)).rejects.toMatchObject({ code: 'CODEX_TURN_OWNED' })
await expect(next.call({ method: 'turn/interrupt', params: { threadId: 'allowed-thread', turnId: 'turn-1' } })).resolves.toEqual({})
} finally {
release()
finishClose()
await closing
await outcome
await domain.close()
}
},
})), cleanupScenario1)
})
it('closes live streams and restarts after an App Server crash without replaying mutations', async () => {
const { root } = await directories()
const first = new FakeAppServer(root)
const second = new FakeAppServer(root)
const create = vi.fn()
.mockReturnValueOnce(first)
.mockReturnValueOnce(second)
const domain = new CodexRemoteDomain({ enabled: true, binary: 'codex' }, logger(), create, [0])
await domain.start()
const frames: Array<{ event: string; data: unknown }> = []
const peer = domain.createPeer(
{ connectionId: 'connection-1', peerDeviceId: 'peer-1' },
async (event, data) => { frames.push({ event, data }) },
)!
await peer.openStream({ streamId: 'stream-1', threadId: 'allowed-thread' })
await peer.call({
method: 'turn/start',
params: { threadId: 'allowed-thread', input: [{ type: 'text', text: 'Do not replay me' }] },
})
first.crash('CODEX_APP_SERVER_EXITED')
await flush()
await flush()
expect(create).toHaveBeenCalledTimes(2)
expect(domain.status()).toMatchObject({ available: true, state: 'ready', restartAttempt: 0 })
expect(frames).toContainEqual({
event: 'codex.app.stream.closed',
data: { streamId: 'stream-1', reason: 'failed' },
})
expect(second.calls.some(call => call.method === 'turn/start')).toBe(false)
expect(second.calls.map(call => call.method)).toContain('account/read')
await peer.closeAll()
await domain.close()
})
})
class FakeAppServer implements CodexAppServerLike {
private handler?: CodexAppServerInboundHandler
private unavailableHandler?: CodexAppServerUnavailableHandler
private ready = false
readonly responses: Array<{ id: string | number; result?: unknown; error?: unknown }> = []
readonly calls: Array<{ method: string; params: unknown }> = []
rejectResume = false
resumeRolloutMissing = false
rejectTurnPagination = false
unmaterializedThread = false
unmaterializedAfterFirstPage = false
legacyUnmaterializedThread = false
rejectTurnStartBusy = false
rejectSettings = false
projectListMode: 'normal' | 'empty' | 'unsupported' = 'normal'
constructor(private readonly root: string, private readonly outside = root) {}
async start(): Promise<void> { this.ready = true }
isReady(): boolean { return this.ready }
async call(method: string, params: unknown): Promise<unknown> {
this.calls.push({ method, params })
if (method === 'account/read') return { account: { type: 'chatgpt', email: 'private@example.com' }, requiresOpenaiAuth: true }
if (method === 'thread/list') return {
data: [
{ id: 'allowed-thread', projectId: 'allowed-project', cwd: this.root, createdAt: 1, updatedAt: 2, path: 'private rollout path' },
{ id: 'outside-thread', projectId: 'outside-project', cwd: this.outside, createdAt: 1, updatedAt: 2, path: 'private rollout path' },
{ id: 'project-only-thread', projectId: 'allowed-project', createdAt: 1, updatedAt: 2, path: 'private rollout path' },
{ id: 'unprojected-thread', cwd: `${this.root}-unprojected`, createdAt: 1, updatedAt: 2, path: 'private rollout path' },
{ id: 'missing-cwd', createdAt: 1, updatedAt: 2 },
],
nextCursor: null,
}
if (method === 'project/list') {
if (this.projectListMode === 'unsupported') {
throw new CodexAppServerError('CODEX_UPSTREAM_ERROR', 'Codex App Server rejected the request.')
}
if (this.projectListMode === 'empty') return { data: [], nextCursor: null }
return {
data: [
{
id: 'allowed-project',
name: 'Allowed Project',
roots: [{ path: this.root }],
metadata: { secret: 'private metadata' },
position: 0,
createdAt: 1,
updatedAt: 2,
},
{
id: 'outside-project',
name: 'Outside Project',
roots: [{ path: this.outside }],
position: 1,
createdAt: 1,
updatedAt: 2,
},
],
nextCursor: null,
}
}
if (method === 'project/create') {
const source = isRecord(params) ? params : {}
return {
project: {
id: 'created-project',
name: source.name,
roots: source.roots,
metadata: { secret: 'private metadata' },
position: 2,
createdAt: 3,
updatedAt: 3,
},
}
}
if (method === 'thread/read') {
const threadId = isRecord(params) ? params.threadId : undefined
const includeTurns = isRecord(params) && params.includeTurns === true
if (includeTurns && (this.unmaterializedThread || this.legacyUnmaterializedThread)) {
throw new CodexAppServerError(CODEX_THREAD_UNMATERIALIZED, CODEX_UNMATERIALIZED_THREAD_MESSAGE)
}
const cwd = threadId === 'outside-thread'
? this.outside
: threadId === 'unprojected-thread'
? `${this.root}-unprojected`
: this.root
return { thread: {
id: threadId,
...(threadId === 'project-only-thread' ? { projectId: 'allowed-project' } : { cwd }),
turns: includeTurns ? [{
id: 'turn-1',
status: 'completed',
items: [
{ id: 'user-1', type: 'userMessage', text: 'First' },
{ id: 'assistant-1', type: 'agentMessage', text: 'Second' },
],
}] : [],
} }
}
if (method === 'thread/turns/list') {
if (this.unmaterializedThread) {
throw new CodexAppServerError(CODEX_THREAD_UNMATERIALIZED, CODEX_UNMATERIALIZED_THREAD_MESSAGE)
}
if (this.legacyUnmaterializedThread) {
throw new CodexAppServerError('METHOD_NOT_FOUND', 'method not found')
}
if (this.unmaterializedAfterFirstPage) {
if (isRecord(params) && params.cursor !== undefined) {
throw new CodexAppServerError(CODEX_THREAD_UNMATERIALIZED, CODEX_UNMATERIALIZED_THREAD_MESSAGE)
}
return {
data: [{
id: 'turn-1',
status: 'completed',
itemsView: 'full',
items: [{ id: 'user-1', type: 'userMessage', text: 'First' }],
}],
nextCursor: 'page-2',
backwardsCursor: null,
}
}
if (this.rejectTurnPagination) {
throw new CodexAppServerError('CODEX_UPSTREAM_ERROR', 'Codex App Server rejected the request.')
}
return {
data: [{
id: 'turn-1',
status: 'completed',
startedAt: 1,
completedAt: 2,
itemsView: 'full',
items: [
{ id: 'user-1', type: 'userMessage', text: 'First' },
{ id: 'assistant-1', type: 'agentMessage', text: 'Second' },
],
}],
nextCursor: null,
backwardsCursor: null,
}
}
if (method === 'thread/items/list') return { data: [], nextCursor: null, backwardsCursor: null }
if (method === 'thread/start') return { thread: { id: 'new-thread', cwd: isRecord(params) ? params.cwd : undefined } }
if (method === 'thread/resume' && this.resumeRolloutMissing) {
throw new CodexAppServerError('CODEX_UPSTREAM_ERROR', 'Codex thread state is not persisted yet.')
}
if (method === 'thread/resume' && this.rejectResume) {
throw new CodexAppServerError('CODEX_UPSTREAM_ERROR', 'Codex App Server rejected the request.')
}
if (method === 'thread/resume' || method === 'thread/fork' || method === 'thread/unarchive') {
return { thread: { id: 'allowed-thread', cwd: this.root } }
}
if (method === 'thread/settings/update' && this.rejectSettings) {
throw new CodexAppServerError('CODEX_UPSTREAM_ERROR', 'Codex App Server rejected the setting.')
}
if (method === 'turn/start') {
if (this.rejectTurnStartBusy) {
throw new CodexAppServerError('CODEX_UPSTREAM_ERROR', 'Codex thread already has an active writer.')
}
return { turn: { id: 'turn-1', status: 'inProgress', items: [] } }
}
return {}
}
async respond(id: string | number, result: unknown): Promise<void> { this.responses.push({ id, result }) }
async respondError(id: string | number, code: number, message: string): Promise<void> {
this.responses.push({ id, error: { code, message } })
}
onInbound(handler: CodexAppServerInboundHandler): () => void {
this.handler = handler
return () => { this.handler = undefined }
}
onUnavailable(handler: CodexAppServerUnavailableHandler): () => void {
this.unavailableHandler = handler
return () => { this.unavailableHandler = undefined }
}
emit(message: CodexAppServerInbound): void { this.handler?.(message) }
crash(code: string): void {
this.ready = false
this.unavailableHandler?.(code)
}
async close(): Promise<void> { this.ready = false }
}
async function directories(): Promise<{ base: string; root: string; outside: string }> {
const base = await mkdtemp(join(tmpdir(), 'dsh-codex-domain-'))
cleanup.push(base)
const root = join(base, 'allowed')
const outside = join(base, 'allowed-sibling')
await mkdir(root)
await mkdir(outside)
return { base, root, outside }
}
function extractRequestHandle(data: unknown): string {
if (!isRecord(data) || !isRecord(data.frame) || !isRecord(data.frame.params)
|| typeof data.frame.params.requestHandle !== 'string') throw new Error('missing request handle')
return data.frame.params.requestHandle
}
function logger(): SafeLogger {
return { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() } as unknown as SafeLogger
}
function isRecord(value: unknown): value is Record<string, unknown> {
return typeof value === 'object' && value !== null && !Array.isArray(value)
}
async function flush(): Promise<void> { await new Promise(resolve => setTimeout(resolve, 0)) }
describe('codexBinaryCandidates', () => {
it('discovers the Windows Codex desktop build and falls back to the configured CLI', async () => {
const localAppData = await mkdtemp(join(tmpdir(), 'dsh-codex-bin-'))
cleanup.push(localAppData)
const binRoot = join(localAppData, 'OpenAI', 'Codex', 'bin')
const olderBuild = join(binRoot, 'aaaa1111')
const newerBuild = join(binRoot, 'bbbb2222')
await mkdir(olderBuild, { recursive: true })
await mkdir(newerBuild, { recursive: true })
const older = join(olderBuild, 'codex.exe')
const newer = join(newerBuild, 'codex.exe')
await writeFile(older, '')
await writeFile(newer, '')
const oldTime = new Date(Date.now() - 60_000)
await utimes(older, oldTime, oldTime)
const previous = process.env.LOCALAPPDATA
process.env.LOCALAPPDATA = localAppData
try {
// Newest build first, then the configured `codex` fallback.
expect(codexBinaryCandidates('codex', 'win32', join(localAppData, 'home'))).toEqual([newer, older, 'codex'])
// An explicitly configured binary is never replaced.
expect(codexBinaryCandidates('C:\\tools\\codex.exe', 'win32', '/unused')).toEqual(['C:\\tools\\codex.exe'])
// Non-Windows platforms keep the plain configured value when no desktop app matches.
expect(codexBinaryCandidates('codex', 'linux', '/unused')).toEqual(['codex'])
} finally {
if (previous === undefined) delete process.env.LOCALAPPDATA
else process.env.LOCALAPPDATA = previous
}
})
})