import { runScenarios, scenarioName } from '../../../scripts/test-scenarios.mjs' import { mkdtemp, rm } from 'node:fs/promises' import { tmpdir } from 'node:os' import { join } from 'node:path' import type { ControlResult } from '../src/control-result.js' import { unwrapControlResult } from '../src/client/control-result.js' import { generateKeyPair, NoiseIkSession, createNoisePrologue, fromBase64Url, toBase64Url } from '@dsh-remote/crypto' import { createControlFrame } from '@dsh-remote/protocol' import { RemoteClientCore } from '@dsh-remote/client-core' import type { RtcPeerConnectionFactory } from '@dsh-remote/webrtc' import { afterEach, describe, expect, it, vi } from 'vitest' import { ClientModeRuntime, probeRemoteHostFeatures, remoteHostFeatures, type HostAuthorizationControl, type HostConnectionHandle, } from '../src/client-runtime.js' import type { ResolvedConfig } from '../src/config.js' import { CONTROL_RPC_PREFIX } from '../src/control-route.js' import { AcpVirtualHarness } from '../src/acp/virtual-harness.js' import { CodexVirtualHarness, paginateCodexNativeHistory, projectCodexNativeHistory } from '../src/codex/virtual-harness.js' import { IdentityStore } from '../src/identity-store.js' import type { SafeLogger } from '../src/logging.js' import type { ClientServerApi } from '../src/server-api.js' const directories: string[] = [] const cleanupScenario1 = async () => { await Promise.all(directories.splice(0).map((directory) => rm(directory, { recursive: true, force: true }))) } afterEach(cleanupScenario1) describe('ClientModeRuntime Host account control', () => { it('does not create or authorize a Client on a paired Host, including logout', async () => { const directory = await mkdtemp(join(tmpdir(), 'remote-host-only-')) directories.push(directory) const identities = new IdentityStore({ directory }) const create = vi.spyOn(identities, 'loadOrCreate') const server = { bindIdentity: vi.fn(), authenticate: vi.fn(), clearAuthorization: vi.fn(async () => {}) } as unknown as ClientServerApi const host = { hostStatus: () => ({ pairingHostOnly: true }) } as HostAuthorizationControl const runtime = new ClientModeRuntime(config(), identities, server, gatewayWithCarrier(), logger(), host) await runtime.start() try { expect(create).not.toHaveBeenCalled() await expect(runtime.devices()).rejects.toMatchObject({ code: 'DEVICE_SCOPE_REQUIRED' }) await expect(runtime.authorizeClientWithAccount('test@example.test', 'password')).rejects.toMatchObject({ code: 'DEVICE_SCOPE_REQUIRED' }) await runtime.clearClientAuthorization() expect(create).not.toHaveBeenCalled() expect(server.authenticate).not.toHaveBeenCalled() } finally { await runtime.close() } }) it('reuses the prepared device connection for tools without replacing or closing it', async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-client-shared-')) directories.push(directory) const runtime = new ClientModeRuntime(config(), new IdentityStore({ directory }), { bindIdentity: vi.fn() } as unknown as ClientServerApi, gatewayWithCarrier(), logger()) await runtime.start() const state = runtime as any const close = vi.fn(async () => undefined) const remote = { target: { deviceId: 'host-1' }, client: { close } } state.connected = remote const connect = vi.spyOn(state.connection, 'connect') try { expect(await state.withToolRemote('host-1', new AbortController().signal, async (value: unknown) => { expect(value).toBe(remote); return 'accepted' })).toBe('accepted') await expect(state.withToolRemote('host-1', new AbortController().signal, async () => { throw new Error('request failed') })).rejects.toThrow('request failed') expect(connect).not.toHaveBeenCalled() expect(close).not.toHaveBeenCalled() await expect(state.withToolRemote('host-1', new AbortController().signal, async () => { state.connected = undefined; return 'late'; })).rejects.toMatchObject({ code: 'CANCELLED' }) } finally { state.connected = undefined; await runtime.close() } }) it('retires pending connections on explicit exit, account sign-out and runtime shutdown', async () => { await runScenarios((['exit', 'sign-out', 'shutdown'] as const).flatMap(action => (['mode', 'directory'] as const).map(request => ({ name: `${action}: pending ${request}`, run: async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-client-exit-')) directories.push(directory) const runtime = new ClientModeRuntime(config(), new IdentityStore({ directory }), { bindIdentity: vi.fn(), revokeCurrentDevice: vi.fn(async () => undefined) } as unknown as ClientServerApi, gatewayWithCarrier(), logger()) await runtime.start() let resolve!: (remote: unknown) => void const state = runtime as unknown as { connection: { connect: (id: string) => Promise } } vi.spyOn(state.connection, 'connect').mockImplementation(() => new Promise(yes => { resolve = yes })) const client = { close: vi.fn(async () => undefined), getStats: () => ({ mode: 'Relay', connected: true }) } const pending = request === 'mode' ? runtime.setMode('remote', 'host-1') : runtime.listRemoteDirectory('host-1') const rejected = expect(pending).rejects.toMatchObject({ code: 'CANCELLED' }) if (action === 'exit') await runtime.setMode('local') else if (action === 'sign-out') await runtime.clearClientAuthorization() else await runtime.close() resolve({ client, target: { deviceId: 'host-1', name: 'Host' }, features: {}, progressRunId: 1 }) await rejected expect(client.close).toHaveBeenCalledOnce() expect(runtime.status()).toMatchObject({ mode: 'local', connected: false }) await runtime.close() } }))), cleanupScenario1) }) it('completes carrier teardown and local sign-out when an independent cleanup fails', async () => { await runScenarios((['stream', 'preview', 'carrier', 'revocation'] as const).map(failure => ({ name: failure, run: async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-client-exit-failure-')) directories.push(directory) const revoke = vi.fn(async () => { if (failure === 'revocation') throw new Error('revocation failed') }) const runtime = new ClientModeRuntime(config(), new IdentityStore({ directory }), { bindIdentity: vi.fn(), revokeCurrentDevice: revoke } as unknown as ClientServerApi, gatewayWithCarrier(), logger()) await runtime.start() const previousIdentity = runtime.status().deviceId const close = vi.fn(async () => { if (failure === 'carrier') throw new Error('carrier failed') }) const client = { close, getStats: () => ({ mode: 'Relay', connected: true }) } const streamClose = vi.fn(async () => { if (failure === 'stream') throw new Error('stream failed') }) const previewClose = vi.fn(async () => { if (failure === 'preview') throw new Error('preview failed') }) const state = runtime as unknown as { connected: unknown; preview: unknown; codexStreams: Map } state.connected = { client, target: { deviceId: 'host-1', name: 'Host' }, features: {} } state.preview = { close: previewClose } state.codexStreams.set('stream', { target: { kind: 'remote', client }, close: streamClose, unsubscribe: vi.fn(), wake: vi.fn(), }) await expect(runtime.clearClientAuthorization()).rejects.toThrow(`${failure} failed`) expect(close).toHaveBeenCalledOnce() expect(streamClose).toHaveBeenCalledOnce() expect(previewClose).toHaveBeenCalledOnce() expect(revoke).toHaveBeenCalledOnce() expect(state.codexStreams.size).toBe(0) expect(runtime.status()).toMatchObject({ mode: 'local', connected: false }) expect(runtime.status().deviceId).not.toBe(previousIdentity) await runtime.close() } })), cleanupScenario1) }) it('completes direct then TURN then Relay startup with a twenty-second Server budget', async () => { vi.useFakeTimers() const clientKeys = generateKeyPair(new Uint8Array(32).fill(41)) const hostKeys = generateKeyPair(new Uint8Array(32).fill(42)) const identity = { schemaVersion: 1, deviceId: 'client-1', name: 'Client', fingerprint: 'CLIENT', ...clientKeys } const host = { deviceId: 'host-1', name: 'Host', role: 'host', platform: 'linux', membershipId: 'member', identityKey: hostKeys.publicKey } const sockets: Socket[] = [] class Socket { static OPEN = 1 readyState = 0 binaryType = '' sent: { type: string; payload: Record }[] = [] onopen?: () => void onmessage?: (event: { data: string }) => void onclose?: (event: { code: number; reason: string }) => void readonly id = `connection-${sockets.length + 1}` constructor() { sockets.push(this); queueMicrotask(() => { this.readyState = 1; this.onopen?.() }) } receive(type: Parameters[0], payload: unknown) { queueMicrotask(() => this.onmessage?.({ data: JSON.stringify(createControlFrame(type, payload)) })) } send(raw: string) { const frame = JSON.parse(raw) this.sent.push(frame) if (frame.type === 'hello') this.receive('hello.ack', { protocol: 1, serverVersion: 'test', connectionSessionId: this.id, heartbeatIntervalMs: 25000, maxControlFrameBytes: 65536, maxRelayFrameBytes: 1048576, capabilities: ['transport.lan', 'transport.p2p', 'transport.turn', 'transport.relay'], webrtcFallbackTimeoutMs: 20000, }) if (frame.type === 'connect.request') this.receive('connect.accepted', { connectionId: this.id }) if (frame.type === 'secure.handshake') { const noise = new NoiseIkSession({ role: 'responder', localPrivateKey: hostKeys.privateKey, localPublicKey: hostKeys.publicKey, remotePublicKey: clientKeys.publicKey, prologue: createNoisePrologue(this.id, 'host-1', 'client-1') }) noise.readHandshake(fromBase64Url(frame.payload.data)) this.receive('secure.handshake', { connectionId: this.id, targetDeviceId: 'client-1', step: 2, data: toBase64Url(noise.writeHandshake()) }) noise.destroy() } } close() { this.readyState = 3; this.onclose?.({ code: 1000, reason: '' }) } } vi.stubGlobal('WebSocket', Socket) const create = vi.fn(() => ({ connectionState: 'new', iceConnectionState: 'new', iceGatheringState: 'new', createDataChannel: () => ({ label: 'dsh', ordered: true, readyState: 'connecting', bufferedAmount: 0, close() {} }), createOffer: async () => ({ type: 'offer', sdp: 'offer' }), setLocalDescription: async () => {}, getStats: async () => [], close() {}, })) const identities = { loadOrCreate: async () => identity, trustedPeer: () => undefined, trustPeer: async (input: unknown) => ({ ...input as object, trustedAt: 1, fingerprint: 'HOST' }), } as unknown as IdentityStore const server = { baseUrl: 'https://remote.test', bindIdentity() {}, listDevices: async () => [host], deviceFor: async () => host, presenceFor: async () => ({ online: true }), authenticate: async () => ({ accessToken: 'test-token' }), turnCredentials: async () => [], } as unknown as ClientServerApi vi.spyOn(RemoteClientCore.prototype, 'rpc').mockResolvedValue({ capabilities: ['harness.remote.v3'] }) const runtime = new ClientModeRuntime(config(), identities, server, gateway(), logger(), undefined, async () => ({ create }) as unknown as RtcPeerConnectionFactory) let connected: { client: RemoteClientCore } | undefined try { await runtime.start() const connecting = (runtime as unknown as { connect(id: string): Promise<{ client: RemoteClientCore }> }).connect('host-1') await vi.advanceTimersByTimeAsync(41000) connected = await connecting expect(sockets).toHaveLength(3) expect(sockets.map(socket => socket.sent.find(frame => frame.type === 'connect.request')?.payload.preferredTransports)).toEqual([ ['lan', 'p2p', 'relay'], ['turn', 'relay'], ['relay'], ]) expect(create).toHaveBeenCalledTimes(2) expect(sockets.slice(0, 2).every(socket => socket.readyState === 3)).toBe(true) expect(connected.client.getStats().mode).toBe('Relay') // Agent discovery uses the same real handshake/fallback path without // replacing the UI's connection or its progress state. const state = runtime as unknown as { connection: import('../src/client-connection.js').ClientConnection connected: unknown connectionProgress: unknown connectionProgressRun: number } state.connected = connected const progress = state.connectionProgress const run = state.connectionProgressRun const background = state.connection.connect('host-1', undefined, { background: true }) await vi.advanceTimersByTimeAsync(41000) const candidate = await background expect(state.connectionProgress).toBe(progress) expect(state.connectionProgressRun).toBe(run) expect(state.connected).toBe(connected) await candidate.client.close() expect(state.connected).toBe(connected) expect(connected.client.getStats().mode).toBe('Relay') state.connected = undefined } finally { await connected?.client.close() await runtime.close() vi.useRealTimers(); vi.restoreAllMocks(); vi.unstubAllGlobals() } }) it('discovers Host capabilities conservatively without inferring backend readiness', async () => { await runScenarios( [ { name: 'uses a conservative compatibility profile for legacy and unknown Hosts', run: () => { expect(remoteHostFeatures()).toEqual({ commandList: false, fileViewer: false, terminal: false, remoteGateway: false, codex: false, pluginRoute: false, cursor: false, antigravity: false, opencode: false, }) }, }, { name: 'requires authenticated capability discovery', run: async () => { const alphaClient = { rpc: vi.fn(async () => ({ capabilities: [ 'transport.relay', 'harness.remote.v1', 'harness.remote.transfer.v1', 'codex.appserver.v1', ], })), } await expect(probeRemoteHostFeatures(alphaClient as never, '0.3.15')).resolves.toEqual({ commandList: true, fileViewer: false, terminal: false, remoteGateway: true, codex: true, pluginRoute: false, cursor: false, antigravity: false, opencode: false, claude: false, }) alphaClient.rpc.mockResolvedValueOnce({ capabilities: ['transport.relay', 'harness.remote.v3', 'harness.remote.transfer.v1'], }) await expect(probeRemoteHostFeatures(alphaClient as never, '0.4.11')).resolves.toEqual({ commandList: true, fileViewer: false, terminal: false, remoteGateway: true, sessionFormat: 3, codex: false, pluginRoute: false, cursor: false, antigravity: false, opencode: false, claude: false, }) alphaClient.rpc.mockResolvedValueOnce({ capabilities: ['transport.relay', 'codex.appserver.v1', 'codex.appserver.transfer.v1'], }) await expect(probeRemoteHostFeatures(alphaClient as never, '0.4.19')).resolves.toEqual({ commandList: false, fileViewer: false, terminal: false, remoteGateway: false, codex: true, pluginRoute: false, cursor: false, antigravity: false, opencode: false, claude: false, }) const legacyClient = { rpc: vi.fn(async () => { throw Object.assign(new Error('unknown method'), { code: 'METHOD_NOT_FOUND' }) }), } await expect(probeRemoteHostFeatures(legacyClient as never, '0.3.17')).rejects.toMatchObject({ code: 'FEATURE_NOT_SUPPORTED' }) }, }, { name: 'does not infer a backend from the legacy generic ACP capability', run: async () => { const client = { rpc: vi.fn(async () => ({ capabilities: ['agent.acp.v1'] })) } await expect(probeRemoteHostFeatures(client as never)).rejects.toMatchObject({ code: 'FEATURE_NOT_SUPPORTED', }) client.rpc.mockResolvedValueOnce({ capabilities: ['agent.acp.v1', 'agent.acp.antigravity.v1'] }) expect(await probeRemoteHostFeatures(client as never)).toMatchObject({ cursor: false, antigravity: true, opencode: false, }) client.rpc.mockResolvedValueOnce({ capabilities: ['agent.acp.v1', 'agent.acp.opencode.v1'] }) expect(await probeRemoteHostFeatures(client as never)).toMatchObject({ cursor: false, antigravity: false, opencode: true, }) }, }, { name: 'probes workspaceTypes from remote Host and safely tolerates malformed values', run: async () => { const client = { rpc: vi.fn(async () => ({ capabilities: ['transport.relay', 'codex.appserver.v1'], workspaceTypes: [ { id: 'codex', name: 'CodeX', capability: 'codex.appserver.v1', available: true }, { id: 456, invalid: true }, ], })), } await expect(probeRemoteHostFeatures(client as never, '0.4.19')).resolves.toMatchObject({ codex: true, pluginRoute: false, workspaceTypes: [ { id: 'codex', name: 'CodeX', capability: 'codex.appserver.v1', available: true }, ], }) }, }, ], async () => { await cleanupScenario1() }, ) }, 20000) it('requires workspace readiness alongside each independent backend capability', async () => { const rows = ['cursor', 'antigravity', 'claude'] as const await runScenarios( rows.map((row, index) => { const backend = row return { name: scenarioName('uses %s workspace readiness alongside its independent capability', row, index), run: async () => { const capability = `agent.acp.${backend}.v1` const client = { rpc: vi.fn(async () => ({ capabilities: ['harness.remote.v1', capability], workspaceTypes: [{ id: backend, name: backend, capability, available: false }], })), } expect(await probeRemoteHostFeatures(client as never)).toMatchObject({ [backend]: false }) client.rpc.mockResolvedValueOnce({ capabilities: ['harness.remote.v1', capability], workspaceTypes: [{ id: backend, name: backend, capability, available: true }], }) expect(await probeRemoteHostFeatures(client as never)).toMatchObject({ [backend]: true }) }, } }), async () => { await cleanupScenario1() }, ) }) it('forwards opaque QR provider IDs and rejects malformed control input', async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-client-qr-provider-')) directories.push(directory) const startOAuthQrLogin = vi.fn(async (provider: string) => ({ qrId: `${provider}-qr-session-1234567890`, scanUrl: `https://dsh.r2049.cn/api/v1/auth/q/${provider}-qr-session-1234567890`, expiresIn: 600, })) const runtime = new ClientModeRuntime( config(), new IdentityStore({ directory }), { bindIdentity: vi.fn(), startOAuthQrLogin } as unknown as ClientServerApi, gateway(), logger(), ) await runtime.start() const signal = new AbortController().signal await expect(runtime.handleControl( 'client.account.qr.start', { provider: 'github' }, signal, )).resolves.toMatchObject({ ok: true, value: { expiresIn: 600 } }) expect(startOAuthQrLogin).toHaveBeenCalledWith('github') await expect(runtime.handleControl( 'client.account.qr.start', { provider: 'future-provider' }, signal, )).resolves.toMatchObject({ ok: true }) expect(startOAuthQrLogin).toHaveBeenCalledWith('future-provider') await expect(runtime.handleControl( 'client.account.qr.start', { provider: { id: 'github' } }, signal, )).resolves.toMatchObject({ ok: false, error: { code: 'internal', details: { remoteCode: 'INVALID_MESSAGE' } }, }) expect(startOAuthQrLogin).toHaveBeenCalledTimes(2) await runtime.close() }) it('keeps the selected remote Workspace until the browser opens it', async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-client-workspace-selection-')) directories.push(directory) const runtime = new ClientModeRuntime( config(), new IdentityStore({ directory }), { bindIdentity: vi.fn() } as unknown as ClientServerApi, gatewayWithCarrier(), logger(), ) await runtime.start() const rpc = vi.fn(async () => ({ ok: true, value: { workspace: { workspaceId: 'workspace-remote-1', path: '/srv/project', title: 'project', sessionIds: [] }, created: false }, })) const close = vi.fn(async () => undefined) ;(runtime as unknown as { connected: unknown }).connected = { client: { rpc, close, getStats: () => ({ mode: 'Relay', connected: true }) }, target: { deviceId: 'host-device-1', name: 'Workstation', platform: 'linux', publicKey: 'peer-key', fingerprint: 'PEER', trustedAt: 1, }, transport: {}, features: { commandList: true, fileViewer: true, remoteGateway: true, codex: false }, } await expect(runtime.openRemoteWorkspace('host-device-1', '/srv/project')).resolves.toMatchObject({ workspaceSelection: { targetDeviceId: 'host-device-1', workspaceId: 'workspace-remote-1' }, }) expect(runtime.status()).toMatchObject({ workspaceSelection: { targetDeviceId: 'host-device-1', workspaceId: 'workspace-remote-1' }, }) const signal = new AbortController().signal await runtime.handleControl('workspace.selection.consume', { targetDeviceId: 'host-device-1', workspaceId: 'another-workspace', }, signal) expect(runtime.status()).toHaveProperty('workspaceSelection') await runtime.handleControl('workspace.selection.consume', { targetDeviceId: 'host-device-1', workspaceId: 'workspace-remote-1', }, signal) expect(runtime.status()).not.toHaveProperty('workspaceSelection') await runtime.close() }) it('restores Codex navigation across detached connections without leaking Host or workspace memory', async () => { await runScenarios([ { name: 'replacement connection on the same Host and workspace', host: 'host-1', workspace: 'repo', expected: 'codex:older' }, { name: 'another Host with identical workspace and thread IDs', host: 'host-2', workspace: 'repo', expected: 'codex:latest' }, { name: 'another workspace on the same Host', host: 'host-1', workspace: 'other', expected: 'codex:other-latest' }, { name: 'remembered thread no longer in the Host catalog', host: 'host-1', workspace: 'repo', missing: true, expected: 'codex:latest' }, { name: 'native navigation remembers each actual workspace', host: 'host-1', workspace: 'other', nativeNavigation: true, expected: 'codex:other-older' }, { name: 'account sign-out clears all navigation memory', host: 'host-1', workspace: 'repo', signOut: true, expected: 'codex:latest' }, { name: 'late catalog cannot overwrite a newer workspace open', host: 'host-1', workspace: 'other', race: 'newer', expected: 'codex:other-latest' }, { name: 'late catalog cannot reinstall a disconnected carrier', host: 'host-1', workspace: 'repo', race: 'disconnect', expected: 'codex:older' }, { name: 'late catalog after sign-out cannot restore old memory', host: 'host-1', workspace: 'repo', race: 'logout', expected: 'codex:latest' }, { name: 'late old Host connection cannot close the newer Host', host: 'host-new', workspace: 'repo', race: 'connect-newer', expected: 'codex:latest' }, { name: 'late Host connection after sign-out never regains authority', host: 'host-1', workspace: 'repo', race: 'connect-logout', expected: 'codex:latest' }, { name: 'late CodeX teardown preserves the successor Cursor carrier', host: 'host-1', workspace: 'repo', successor: 'cursor' as const, expected: 'codex:older' }, { name: 'late CodeX teardown preserves the successor AGY carrier', host: 'host-1', workspace: 'repo', successor: 'antigravity' as const, expected: 'codex:older' }, ].map(scenario => ({ name: scenario.name, run: async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-client-codex-recovery-')) directories.push(directory) const runtime = new ClientModeRuntime(config(), new IdentityStore({ directory }), { bindIdentity: vi.fn(), revokeCurrentDevice: vi.fn(async () => undefined) } as unknown as ClientServerApi, gatewayWithCarrier(), logger()) const threads = [ { id: 'latest', cwd: '/srv/repo', name: 'Latest', updatedAt: 30, turns: [] }, { id: 'older', cwd: '/srv/repo', name: 'Older', updatedAt: 10, turns: [] }, { id: 'other-latest', cwd: '/srv/other', name: 'Other', updatedAt: 40, turns: [] }, { id: 'other-older', cwd: '/srv/other', name: 'Older other', updatedAt: 5, turns: [] }, ] let releaseCatalog!: () => void let catalogStarted!: () => void const catalogGate = new Promise(resolve => { releaseCatalog = resolve }) const catalogWaiting = new Promise(resolve => { catalogStarted = resolve }) let deferCatalog = false let deferStreamClose = false let acpRemoteSpy: { mockRestore(): void } | undefined let missing = false const transfers = new Map() const rpc = vi.fn(async (method: string, params: unknown): Promise => { if (method === 'codex.app.transfer.open') { transfers.set((params as { transferId: string }).transferId, []) return { opened: true } } if (method === 'codex.app.transfer.chunk') { const chunk = params as { transferId: string; data: string } transfers.get(chunk.transferId)!.push(Buffer.from(chunk.data, 'base64')) return { accepted: true } } if (method === 'codex.app.transfer.commit') { const id = (params as { transferId: string }).transferId return { kind: 'inline', response: await rpc('codex.app.call', JSON.parse(Buffer.concat(transfers.get(id)!).toString())) } } if (method === 'codex.app.transfer.close') { transfers.delete((params as { transferId: string }).transferId) return { closed: true } } if (method === 'harness.transport.describe') return { capabilities: ['harness.remote.v1', 'codex.appserver.v1', ...(scenario.successor === undefined ? [] : [`agent.acp.${scenario.successor}.v1`]), ] } if (method === 'codex.app.call') { const call = params as { method: string; params: Record } if (call.method === 'project/list') return { data: [ { id: 'repo', name: 'Repo', roots: [{ path: '/srv/repo' }] }, { id: 'other', name: 'Other', roots: [{ path: '/srv/other' }] }, ] } if (call.method === 'thread/list') { if (deferCatalog) { deferCatalog = false catalogStarted() await catalogGate } return { data: threads.filter(thread => !missing || thread.id !== 'older') } } if (call.method === 'model/list') return { data: [] } if (call.method === 'dsh/sessionHistory') { const thread = threads.find(thread => thread.id === call.params.threadId)! return paginateCodexNativeHistory(projectCodexNativeHistory(thread, `codex:${thread.id}`), {}) } } if (method === 'codex.app.stream.open') return { opened: true } if (method === 'codex.app.stream.close') { if (deferStreamClose) { deferStreamClose = false catalogStarted() await catalogGate } return { closed: true } } throw new Error(`unexpected method: ${method}`) }) const state = runtime as unknown as { connected: unknown; codexVirtual: CodexVirtualHarness; closeCodexVirtual(): Promise } const makeConnection = (host: string) => ({ client: { rpc, close: vi.fn(async () => undefined), getStats: () => ({ mode: 'Relay', connected: true }), onEvent: () => () => undefined }, target: { deviceId: host, name: 'Host', platform: 'linux', publicKey: 'peer-key', fingerprint: 'PEER', trustedAt: 1 }, transport: {}, features: remoteHostFeatures(), }) const connect = (host: string) => { state.connected = makeConnection(host) } try { await runtime.start() connect('host-1') const workspaces = await runtime.listCodexWorkspaces('host-1') const repo = workspaces.find(workspace => workspace.path === '/srv/repo')! await runtime.openCodexWorkspace('host-1', repo.workspaceId) const history = await state.codexVirtual.dispatch('session/history', { args: { request: { sessionId: 'codex:older' as never } } }, new AbortController().signal) expect(history.ok).toBe(true) await state.codexVirtual.open('session/follow', { args: { request: { address: { kind: 'session', sessionId: 'codex:older' } } } }, new AbortController().signal) if (scenario.nativeNavigation) { const otherHistory = await state.codexVirtual.dispatch('session/history', { args: { request: { sessionId: 'codex:other-older' as never } } }, new AbortController().signal) expect(otherHistory.ok).toBe(true) } if (scenario.successor !== undefined) { const workspace = { workspaceId: `${scenario.successor}:cwd:/srv/repo`, path: '/srv/repo', title: 'Repo', sessionIds: ['acp-successor'] } const successor = { close: vi.fn(async () => undefined), selectWorkspace: vi.fn(async () => workspace), preferredSessionId: vi.fn(async () => 'acp-successor'), } acpRemoteSpy = vi.spyOn(AcpVirtualHarness, 'remote').mockReturnValue(successor as unknown as AcpVirtualHarness) deferStreamClose = true const lateOpen = runtime.openCodexWorkspace('host-1', repo.workspaceId) const rejected = expect(lateOpen).rejects.toMatchObject({ code: 'CANCELLED' }) await catalogWaiting const selection = { targetDeviceId: 'host-1', workspaceId: workspace.workspaceId, backend: scenario.successor, sessionId: 'acp-successor' } await expect(runtime.openCursorWorkspace('host-1', workspace.workspaceId, undefined, scenario.successor)).resolves.toMatchObject({ workspaceSelection: selection }) expect(successor.close).not.toHaveBeenCalled() releaseCatalog() await rejected expect(successor.close).not.toHaveBeenCalled() expect((runtime as unknown as { cursorVirtual: unknown }).cursorVirtual).toBe(successor) expect(runtime.status()).toMatchObject({ workspaceSelection: selection }) } else if (scenario.race?.startsWith('connect-')) { state.connected = undefined await state.closeCodexVirtual() const staleConnection = makeConnection('host-stale') const newerConnection = makeConnection('host-new') vi.spyOn(runtime as unknown as { connect(host: string): Promise }, 'connect').mockImplementation(async host => { if (host === 'host-stale') { catalogStarted() await catalogGate return staleConnection } return newerConnection }) const lateOpen = runtime.openCodexWorkspace('host-stale', repo.workspaceId) const rejected = expect(lateOpen).rejects.toMatchObject({ code: 'CANCELLED' }) await catalogWaiting if (scenario.race === 'connect-newer') { await runtime.openCodexWorkspace('host-new', repo.workspaceId) } else { await runtime.clearClientAuthorization() } releaseCatalog() await rejected expect(staleConnection.client.close).toHaveBeenCalledTimes(1) if (scenario.race === 'connect-newer') { expect(state.connected).toBe(newerConnection) expect(newerConnection.client.close).not.toHaveBeenCalled() expect(runtime.status()).toMatchObject({ workspaceSelection: { targetDeviceId: 'host-new', sessionId: 'codex:latest' } }) } else { expect(state.connected).toBeUndefined() expect(state.codexVirtual).toBeUndefined() } } else if (scenario.race) { deferCatalog = true const lateOpen = runtime.openCodexWorkspace('host-1', repo.workspaceId) const rejected = expect(lateOpen).rejects.toMatchObject({ code: 'CANCELLED' }) await catalogWaiting if (scenario.race === 'newer') { const other = workspaces.find(workspace => workspace.path === '/srv/other')! await runtime.openCodexWorkspace('host-1', other.workspaceId) } else if (scenario.race === 'logout') { await runtime.clearClientAuthorization() } else { state.connected = undefined await state.closeCodexVirtual() } releaseCatalog() await rejected if (scenario.race === 'newer') { expect(runtime.status()).toMatchObject({ workspaceSelection: { sessionId: 'codex:other-latest' } }) } else { expect(state.codexVirtual).toBeUndefined() } } if (scenario.signOut) await runtime.clearClientAuthorization() // Mirror transport-close ordering: authority is detached before the // virtual carrier closes, so recovery must not depend on connected. state.connected = undefined await state.closeCodexVirtual() missing = scenario.missing === true connect(scenario.host) const workspace = workspaces.find(item => item.path === `/srv/${scenario.workspace}`)! await expect(runtime.openCodexWorkspace(scenario.host, workspace.workspaceId)).resolves.toMatchObject({ workspaceSelection: { targetDeviceId: scenario.host, workspaceId: workspace.workspaceId, backend: 'codex', sessionId: scenario.expected }, }) if (scenario.nativeNavigation) { await expect(runtime.openCodexWorkspace(scenario.host, repo.workspaceId)).resolves.toMatchObject({ workspaceSelection: { sessionId: 'codex:older' }, }) } expect(rpc.mock.calls.some(([method, params]) => method === 'codex.app.call' && ['thread/start', 'thread/resume', 'turn/start'].includes((params as { method: string }).method))).toBe(false) } finally { releaseCatalog() try { await runtime.close() } finally { acpRemoteSpy?.mockRestore() } } }, })), cleanupScenario1) }, 10000) it('exposes the independent Codex domain to Web through bounded loopback calls and event polling', async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-client-codex-loopback-')) directories.push(directory) const runtime = new ClientModeRuntime( config(), new IdentityStore({ directory }), { bindIdentity: vi.fn() } as unknown as ClientServerApi, gateway(), logger(), ) await runtime.start() let eventHandler: ((event: { event: string; data: unknown }) => void) | undefined const rpc = vi.fn(async (method: string, params: unknown) => { if (method === 'harness.transport.describe') return { capabilities: ['harness.api.v1', 'harness.api.transfer.v1', 'codex.appserver.v1'], } if (method === 'codex.app.call') return { data: [{ id: 'thr_1', cwd: '/srv/project' }] } if (method === 'codex.app.stream.open') { const streamId = (params as { streamId: string }).streamId eventHandler?.({ event: 'codex.app.frame', data: { streamId, frame: { method: 'item/agentMessage/delta', params: { delta: 'hello' } } }, }) return { opened: true } } if (method === 'codex.app.respond') return { resolved: true } if (method === 'codex.app.stream.close') return { closed: true } throw new Error(`unexpected method: ${method} ${JSON.stringify(params)}`) }) const client = { rpc, close: vi.fn(async () => undefined), getStats: () => ({ mode: 'Relay', connected: true }), onEvent: (handler: typeof eventHandler) => { eventHandler = handler; return () => { eventHandler = undefined } }, } ;(runtime as unknown as { connected: unknown }).connected = { client, target: { deviceId: 'host-device-1', name: 'Workstation', platform: 'linux', publicKey: 'peer-key', fingerprint: 'PEER', trustedAt: 1, }, transport: {}, features: { commandList: true, fileViewer: false, remoteGateway: false, codex: false }, } const signal = new AbortController().signal await expect(runtime.handleControl('codex.probe', {}, signal)).resolves.toMatchObject({ ok: true, value: { supported: true }, }) expect(runtime.status()).toMatchObject({ remoteFeatures: { codex: true } }) await expect(runtime.handleControl('codex.call', { method: 'thread/list', params: {}, }, signal)).resolves.toMatchObject({ ok: true, value: { data: [{ id: 'thr_1' }] } }) await expect(runtime.handleControl('codex.stream.open', { streamId: 'web-stream-1', threadId: 'thr_1', }, signal)).resolves.toMatchObject({ ok: true, value: { opened: true, streamId: 'web-stream-1' } }) await expect(runtime.handleControl('codex.stream.next', { streamId: 'web-stream-1', }, signal)).resolves.toMatchObject({ ok: true, value: { frames: [{ method: 'item/agentMessage/delta', params: { delta: 'hello' } }], closed: false }, }) await runtime.handleControl('codex.respond', { requestHandle: 'handle-1', decision: 'decline' }, signal) expect(rpc).toHaveBeenCalledWith('codex.app.respond', { requestHandle: 'handle-1', decision: 'decline' }, signal) await runtime.handleControl('codex.stream.close', { streamId: 'web-stream-1' }, signal) await runtime.close() }) it('creates a CodeX project and selects its virtual Workspace', async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-client-codex-project-')) directories.push(directory) const runtime = new ClientModeRuntime( config(), new IdentityStore({ directory }), { bindIdentity: vi.fn() } as unknown as ClientServerApi, gatewayWithCarrier(), logger(), ) await runtime.start() const project = { id: 'created-project', name: 'project', roots: [{ path: '/srv/project' }], position: 0, createdAt: 1, updatedAt: 1, } const rpc = vi.fn(async (method: string, params: unknown) => { if (method === 'harness.transport.describe') return { capabilities: ['codex.appserver.v1', 'codex.appserver.transfer.v1'], } if (method === 'codex.app.call') { const request = params as { method: string; params: Record } if (request.method === 'project/create') return { project } if (request.method === 'project/list') return { data: [project], nextCursor: null } if (request.method === 'thread/list') return { data: [], nextCursor: null } } throw new Error(`unexpected method: ${method} ${JSON.stringify(params)}`) }) const client = { rpc, close: vi.fn(async () => undefined), getStats: () => ({ mode: 'Relay', connected: true }), onEvent: () => () => undefined, } ;(runtime as unknown as { connected: unknown }).connected = { client, target: { deviceId: 'host-device-1', name: 'Workstation', platform: 'linux', publicKey: 'peer-key', fingerprint: 'PEER', trustedAt: 1, }, transport: {}, features: { commandList: false, fileViewer: false, remoteGateway: false, codex: true }, } await expect(runtime.createCodexWorkspace('host-device-1', '/srv/project')).resolves.toMatchObject({ mode: 'remote', backend: 'codex', workspaceSelection: { targetDeviceId: 'host-device-1', workspaceId: 'codex-workspace:project:created-project', backend: 'codex', }, workspace: { workspaceId: 'codex-workspace:project:created-project', path: '/srv/project', title: 'project', }, }) expect(rpc).toHaveBeenCalledWith('codex.app.call', { method: 'project/create', params: { name: 'project', roots: [{ path: '/srv/project' }], idempotencyKey: expect.stringMatching(/^[0-9a-f-]{36}$/u), }, }, undefined) await runtime.close() }) it('uses alpha Gateway directory and Workspace contracts before switching the native UI', async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-client-alpha-workspace-')) directories.push(directory) const runtime = new ClientModeRuntime( config(), new IdentityStore({ directory }), { bindIdentity: vi.fn() } as unknown as ClientServerApi, gatewayWithCarrier(), logger(), ) await runtime.start() let eventHandler: ((event: { event: string; data: unknown }) => void) | undefined const rpc = vi.fn(async (method: string, params: unknown) => { if (method === 'harness.remote.call') { const request = params as { endpoint: string; payload: unknown } if (request.endpoint === 'directoryPicker/list') { return { ok: true, value: { path: '/srv', home: '/home/remote', crumbs: [], entries: [], truncated: false } } } if (request.endpoint === 'workspace/create') { return { ok: true, value: { workspace: { workspaceId: 'workspace-alpha-1', path: '/srv/project', title: 'project' }, created: true, }, } } } if (method === 'harness.remote.stream.open') { const streamId = (params as { streamId: string }).streamId queueMicrotask(() => { eventHandler?.({ event: 'harness.remote.frame', data: { streamId, hasValue: true, value: { type: 'baseline', value: { items: [{ workspaceId: 'workspace-alpha-1', path: '/srv/project', title: 'project' }] }, }, }, }) eventHandler?.({ event: 'harness.remote.stream.closed', data: { streamId, reason: 'completed' } }) }) return { opened: true, streamId } } return { closed: true } }) const client = { rpc, close: vi.fn(async () => undefined), getStats: () => ({ mode: 'Relay', connected: true }), onEvent: (handler: typeof eventHandler) => { eventHandler = handler; return () => undefined }, onClose: () => () => undefined, } ;(runtime as unknown as { connected: unknown }).connected = { client, target: { deviceId: 'host-device-1', name: 'Workstation', platform: 'linux', publicKey: 'peer-key', fingerprint: 'PEER', trustedAt: 1, }, transport: {}, features: { commandList: true, fileViewer: false, remoteGateway: true, codex: false }, } await expect(runtime.listRemoteDirectory('host-device-1', '/srv')).resolves.toMatchObject({ path: '/srv' }) await expect(runtime.listRemoteWorkspaces('host-device-1')).resolves.toEqual([ { workspaceId: 'workspace-alpha-1', path: '/srv/project', title: 'project' }, ]) await expect(runtime.openRemoteWorkspace('host-device-1', '/srv/project')).resolves.toMatchObject({ mode: 'remote', workspace: { created: true, workspace: { workspaceId: 'workspace-alpha-1' } }, }) expect(rpc).toHaveBeenCalledWith('harness.remote.call', { endpoint: 'directoryPicker/list', payload: { args: { path: '/srv' } }, }, expect.any(AbortSignal)) expect(rpc).toHaveBeenCalledWith('harness.remote.stream.open', expect.objectContaining({ endpoint: 'workspace/follow', payload: { args: {} }, }), expect.any(AbortSignal)) expect(rpc).toHaveBeenCalledWith('harness.remote.call', { endpoint: 'workspace/create', payload: { args: { request: { path: '/srv/project' } } }, }, expect.any(AbortSignal)) await runtime.close() }) it('rejects incompatible carriers and selects compatible session generations', async () => { await runScenarios( [ { name: 'rejects Hosts without a transport compatible with the local Harness carrier', run: async () => { const alphaDirectory = await mkdtemp(join(tmpdir(), 'dsh-client-alpha-mismatch-')) const legacyDirectory = await mkdtemp(join(tmpdir(), 'dsh-client-legacy-mismatch-')) directories.push(alphaDirectory, legacyDirectory) const alphaGateway = gatewayWithCarrier() const alphaRuntime = new ClientModeRuntime( config(), new IdentityStore({ directory: alphaDirectory }), { bindIdentity: vi.fn() } as unknown as ClientServerApi, alphaGateway, logger(), ) const legacyRuntime = new ClientModeRuntime( config(), new IdentityStore({ directory: legacyDirectory }), { bindIdentity: vi.fn() } as unknown as ClientServerApi, gateway(), logger(), ) await alphaRuntime.start() await legacyRuntime.start() const alphaClient = { rpc: vi.fn(), close: vi.fn(async () => undefined), getStats: () => ({ mode: 'Relay', connected: true }), } const legacyClient = { rpc: vi.fn(), close: vi.fn(async () => undefined), getStats: () => ({ mode: 'Relay', connected: true }), } const target = { deviceId: 'host-device-1', name: 'Workstation', platform: 'linux', publicKey: 'peer-key', fingerprint: 'PEER', trustedAt: 1, } ;(alphaRuntime as unknown as { connected: unknown }).connected = { client: alphaClient, target, transport: {}, features: { commandList: true, fileViewer: false, remoteGateway: false, codex: false, pluginRoute: false, }, } ;(legacyRuntime as unknown as { connected: unknown }).connected = { client: legacyClient, target, transport: {}, features: { commandList: true, fileViewer: false, remoteGateway: true, codex: false, pluginRoute: false, }, } await expect( alphaRuntime.openRemoteWorkspace('host-device-1', '/srv/project'), ).rejects.toMatchObject({ code: 'HARNESS_VERSION_INCOMPATIBLE' }) await expect( legacyRuntime.openRemoteWorkspace('host-device-1', '/srv/project'), ).rejects.toMatchObject({ code: 'HARNESS_VERSION_INCOMPATIBLE' }) expect(alphaClient.rpc).not.toHaveBeenCalled() expect(legacyClient.rpc).not.toHaveBeenCalled() expect(alphaRuntime.status()).toMatchObject({ mode: 'local' }) expect(legacyRuntime.status()).toMatchObject({ mode: 'local' }) await alphaRuntime.close() await legacyRuntime.close() }, }, { name: 'rejects Session V3 Hosts when the local Typert carrier still uses the legacy session format', run: async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-client-v3-mismatch-')) directories.push(directory) const runtime = new ClientModeRuntime( config(), new IdentityStore({ directory }), { bindIdentity: vi.fn() } as unknown as ClientServerApi, gatewayWithCarrier(), logger(), { localHarnessVersion: () => '0.1.2-rc.1', hostStatus: () => ({ configured: true, online: false, reconnecting: false, authorized: false, accountRequired: false, }), } as unknown as HostAuthorizationControl, ) await runtime.start() const rpc = vi.fn() ;(runtime as unknown as { connected: unknown }).connected = { client: { rpc, close: vi.fn(async () => undefined), getStats: () => ({ mode: 'Relay', connected: true }), }, target: { deviceId: 'host-device-v3', name: 'V3 Host', platform: 'linux', publicKey: 'peer-key', fingerprint: 'PEER', trustedAt: 1, }, transport: {}, features: { commandList: true, fileViewer: false, remoteGateway: true, sessionFormat: 3, codex: false, pluginRoute: false, }, } await expect(runtime.openRemoteWorkspace('host-device-v3', '/srv/project')).rejects.toMatchObject({ code: 'HARNESS_VERSION_INCOMPATIBLE', }) expect(rpc).not.toHaveBeenCalled() await runtime.close() }, }, { name: 'rejects rc.2 Hosts even when the local Typert carrier exists', run: async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-client-dual-carrier-')) directories.push(directory) const runtime = new ClientModeRuntime( config(), new IdentityStore({ directory }), { bindIdentity: vi.fn() } as unknown as ClientServerApi, gatewayWithCarrier(), logger(), ) await runtime.start() const rpc = vi.fn(async (method: string, params: unknown) => { if ( method === 'harness.api.call' && (params as { method?: string }).method === 'workspace.create' ) { return { rpcId: (params as { rpcId: string }).rpcId, result: { ok: true, value: { workspace: { workspaceId: 'workspace-rc2-1' }, created: true }, }, } } throw new Error(`unexpected method: ${method} ${JSON.stringify(params)}`) }) ;(runtime as unknown as { connected: unknown }).connected = { client: { rpc, close: vi.fn(async () => undefined), getStats: () => ({ mode: 'Relay', connected: true }), }, target: { deviceId: 'host-device-rc2', name: 'RC2 Host', platform: 'linux', publicKey: 'peer-key', fingerprint: 'PEER', trustedAt: 1, }, transport: {}, features: { commandList: true, fileViewer: false, remoteGateway: false, codex: false, pluginRoute: false, }, } await expect(runtime.openRemoteWorkspace('host-device-rc2', '/srv/project')).rejects.toMatchObject({ code: 'HARNESS_VERSION_INCOMPATIBLE' }) expect(rpc).not.toHaveBeenCalled() await runtime.close() }, }, { name: 'allows Session V3 clients to open legacy Typert Remote Host workspaces', run: async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-client-v3-legacy-remote-')) directories.push(directory) const runtime = new ClientModeRuntime( config(), new IdentityStore({ directory }), { bindIdentity: vi.fn() } as unknown as ClientServerApi, gatewayWithCarrier(), logger(), { localHarnessVersion: () => '0.1.5-rc.1', hostStatus: () => ({ configured: true, online: false, reconnecting: false, authorized: false, accountRequired: false, }), } as unknown as HostAuthorizationControl, ) await runtime.start() const rpc = vi.fn(async (method: string, params: unknown) => { if ( method === 'harness.remote.call' && (params as { endpoint?: string }).endpoint === 'workspace/create' ) { return { ok: true, value: { workspace: { workspaceId: 'workspace-v2-1' }, created: true } } } return { ok: true, value: undefined } }) ;(runtime as unknown as { connected: unknown }).connected = { client: { rpc, close: vi.fn(async () => undefined), getStats: () => ({ mode: 'Relay', connected: true }), }, target: { deviceId: 'host-device-v2', name: 'V2 Host', platform: 'linux', publicKey: 'peer-key', fingerprint: 'PEER', trustedAt: 1, }, transport: {}, features: { commandList: true, fileViewer: false, remoteGateway: true, codex: false, pluginRoute: false, }, } await expect(runtime.openRemoteWorkspace('host-device-v2', '/srv/project')).resolves.toMatchObject({ mode: 'remote', workspace: { created: true, workspace: { workspaceId: 'workspace-v2-1' } }, }) expect(rpc).toHaveBeenCalledWith( 'harness.remote.call', { endpoint: 'workspace/create', payload: { args: { request: { path: '/srv/project' } } }, }, expect.any(AbortSignal), ) await runtime.close() }, }, ], async () => { await cleanupScenario1() }, ) }, 20000) it('exposes Host authorization status and forwards login only through loopback control', async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-client-runtime-')) directories.push(directory) const host = { hostStatus: vi.fn(() => ({ configured: true, online: false, reconnecting: false, error: 'ACCOUNT_AUTH_REQUIRED', authorized: false, accountRequired: true, })), reconnectHost: vi.fn(), clearHostAuthorization: vi.fn(), authorizeHostAsOwned: vi.fn(), authorizeHostWithAccount: vi.fn(async (email: string) => ({ account: email, expiresAt: Date.now() + 60_000, isAdmin: false })), authorizeHostWithCode: vi.fn(async () => ({ method: 'host_registration_code' })), } satisfies HostAuthorizationControl const hasStoredAuthorization = vi.fn(async () => false) const authenticate = vi.fn(async () => ({ accessToken: 'client-access-token', account: 'owner@example.com' })) const runtime = new ClientModeRuntime( config(), new IdentityStore({ directory }), { bindIdentity: vi.fn(), hasStoredAuthorization, authenticate, } as unknown as ClientServerApi, gateway(), logger(), host, ) await runtime.start() let handler: ((endpoint: string, payload: unknown, signal: AbortSignal) => Promise>) | undefined const connection = { rpc: { handle: vi.fn((_channel, next) => { handler = next return async () => undefined }), }, } as unknown as HostConnectionHandle const dispose = runtime.registerControl(connection) expect(connection.rpc.handle).toHaveBeenCalledWith(CONTROL_RPC_PREFIX, expect.any(Function), { authority: 'loopback', }) const signal = new AbortController().signal authenticate.mockClear() await expect(handler?.('client.authorization.status', {}, signal)).resolves.toMatchObject({ ok: true, value: { hasCredentials: false }, }) hasStoredAuthorization.mockResolvedValueOnce(true) await expect(handler?.('client.authorization.status', {}, signal)).resolves.toMatchObject({ ok: true, value: { hasCredentials: true }, }) hasStoredAuthorization.mockRejectedValueOnce(new Error('credential store unavailable')) await expect(handler?.('client.authorization.status', {}, signal)).resolves.toMatchObject({ ok: false }) expect(authenticate).not.toHaveBeenCalled() await expect(handler?.('status', {}, signal)).resolves.toMatchObject({ ok: true, value: { host: { accountRequired: true, error: 'ACCOUNT_AUTH_REQUIRED' } }, }) await expect(handler?.('host.account.login', { email: 'host@example.com', password: 'correct horse battery staple', }, signal)).resolves.toMatchObject({ ok: true, value: { account: 'host@example.com' } }) expect(host.authorizeHostWithAccount).toHaveBeenCalledWith('host@example.com', 'correct horse battery staple') await expect(handler?.('host.authorization.set', { enabled: true }, signal)).resolves.toMatchObject({ ok: true }) expect(host.authorizeHostAsOwned).toHaveBeenCalledWith('client-access-token', 'owner@example.com') await expect(handler?.('host.authorization.set', { enabled: false }, signal)).resolves.toMatchObject({ ok: true }) expect(host.clearHostAuthorization).toHaveBeenCalledOnce() await dispose() await runtime.close() }) it('re-authorizes a Host whose stored credential the Server no longer accepts', async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-client-host-repair-')) directories.push(directory) // The Server revoked the token family, but this process still holds the // credential in memory and the file is still on disk, so both local checks // keep claiming the Host is authorized while every credential_refresh fails // with AUTH_INVALID. Signing in again must repair the Host instead of // silently skipping it until the process restarts. const host = { hostStatus: vi.fn(() => ({ configured: true, online: false, reconnecting: false, error: 'AUTH_INVALID', authorized: true, accountRequired: true, })), hasStoredAuthorization: vi.fn(async () => true), reconnectHost: vi.fn(), clearHostAuthorization: vi.fn(), authorizeHostAsOwned: vi.fn(), authorizeHostWithAccount: vi.fn(), authorizeHostWithCode: vi.fn(), } satisfies HostAuthorizationControl const authenticate = vi.fn(async () => ({ accessToken: 'fresh-access-token', account: 'owner@example.com' })) const runtime = new ClientModeRuntime( config(), new IdentityStore({ directory }), { bindIdentity: vi.fn(), hasStoredAuthorization: vi.fn(async () => true), authenticate, pollOAuthQrLogin: vi.fn(async () => ({ status: 'complete' })), } as unknown as ClientServerApi, gateway(), logger(), host, ) await runtime.start() expect(host.authorizeHostAsOwned).not.toHaveBeenCalled() await runtime.pollClientOAuthQrLogin('qr-session-identifier-0001') expect(authenticate).toHaveBeenCalledOnce() expect(host.authorizeHostAsOwned).toHaveBeenCalledWith('fresh-access-token', 'owner@example.com') await runtime.close() }) it('leaves a working Host authorization untouched after signing in', async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-client-host-keep-')) directories.push(directory) const host = { hostStatus: vi.fn(() => ({ configured: true, online: true, reconnecting: false, authorized: true, accountRequired: false, })), hasStoredAuthorization: vi.fn(async () => true), reconnectHost: vi.fn(), clearHostAuthorization: vi.fn(), authorizeHostAsOwned: vi.fn(), authorizeHostWithAccount: vi.fn(), authorizeHostWithCode: vi.fn(), } satisfies HostAuthorizationControl const authenticate = vi.fn(async () => ({ accessToken: 'fresh-access-token', account: 'owner@example.com' })) const runtime = new ClientModeRuntime( config(), new IdentityStore({ directory }), { bindIdentity: vi.fn(), hasStoredAuthorization: vi.fn(async () => true), authenticate, pollOAuthQrLogin: vi.fn(async () => ({ status: 'complete' })), } as unknown as ClientServerApi, gateway(), logger(), host, ) await runtime.start() await runtime.pollClientOAuthQrLogin('qr-session-identifier-0002') expect(authenticate).not.toHaveBeenCalled() expect(host.authorizeHostAsOwned).not.toHaveBeenCalled() await runtime.close() }) it('requires local Host authorization before listing devices', async () => { const rows = ['ACCOUNT_AUTH_REQUIRED', 'DEVICE_OWNERSHIP_REQUIRED', 'DEVICE_REVOKED', 'AUTH_INVALID', 'TOKEN_EXPIRED'] as const await runScenarios( rows.map((row, index) => { const error = row return { name: scenarioName('does not list devices when the local Host authorization is %s', row, index), run: async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-client-host-auth-')) directories.push(directory) const listDevices = vi.fn(async () => []) const host = { hostStatus: vi.fn(() => ({ configured: true, online: false, reconnecting: false, error, authorized: true, accountRequired: true, })), } as unknown as HostAuthorizationControl const runtime = new ClientModeRuntime( config(), new IdentityStore({ directory }), { bindIdentity: vi.fn(), listDevices } as unknown as ClientServerApi, gateway(), logger(), host, ) await runtime.start() await expect(runtime.devices()).rejects.toMatchObject({ code: error }) // The browser must receive the domain code, not the envelope's // generic "internal" code, to return to account authorization. const result = await runtime.handleControl('devices', {}, new AbortController().signal) expect(() => unwrapControlResult(result, 'Request failed')).toThrow(expect.objectContaining({ code: error })) expect(listDevices).not.toHaveBeenCalled() await runtime.close() }, } }), async () => { await cleanupScenario1() }, ) }) it('hydrates paginated and legacy directories with bounded authorization work and stable order', async () => { await runScenarios([50, 301].map(pageSize => ({ name: `page size ${pageSize}`, run: async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-directory-pages-')) directories.push(directory) const identityKey = generateKeyPair(new Uint8Array(32).fill(21)).publicKey const hosts = Array.from({ length: 301 }, (_, i) => ({ deviceId: `host-${i}`, name: `Host ${i}`, role: 'host' as const, platform: 'linux', membershipId: `membership-${i}`, identityKey })) let active = 0, peak = 0, completed = 0 const server = { baseUrl: 'https://remote.test', bindIdentity() {}, async *devicePages() { for (let i = 0; i < hosts.length; i += pageSize) { expect(completed).toBe(i) yield hosts.slice(i, i + pageSize) } }, async deviceFor(id: string) { active++; peak = Math.max(peak, active) try { if (active > 8) throw new Error('directory request overload') await new Promise(resolve => setTimeout(resolve, Number(id.slice(5)) % 3)) return hosts.find(host => host.deviceId === id)! } finally { active-- } }, async presenceFor() { completed++; return { online: true } }, } as unknown as ClientServerApi const identities = new IdentityStore({ directory }) const runtime = new ClientModeRuntime(config(), identities, server, gateway(), logger()) await runtime.start() try { const devices = await runtime.devices() expect(devices.map(device => device.deviceId)).toEqual(hosts.map(host => host.deviceId)) expect(devices.every(device => device.online)).toBe(true) expect(peak).toBeGreaterThan(1) expect(peak).toBeLessThanOrEqual(8) expect(completed).toBe(301) expect(hosts.every(host => identities.trustedPeer(host.deviceId)?.publicKey === identityKey)).toBe(true) } finally { await runtime.close() } } })), cleanupScenario1) }) it('cancels queued discovery without starting another page or pinning late identities', async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-directory-cancel-')) directories.push(directory) let ready!: () => void const started = new Promise(resolve => { ready = resolve }) let calls = 0, pages = 0 const hosts = Array.from({ length: 50 }, (_, i) => ({ deviceId: `host-${i}`, name: `Host ${i}`, platform: 'linux', membershipId: `membership-${i}` })) const presenceFor = vi.fn() const server = { bindIdentity() {}, async *devicePages() { pages++; yield hosts; pages++; yield hosts }, async deviceFor(_id: string, signal: AbortSignal) { calls++ return new Promise((_, reject) => { signal.addEventListener('abort', () => reject(signal.reason), { once: true }) if (calls === 8) ready() }) }, presenceFor, } as unknown as ClientServerApi const identities = new IdentityStore({ directory }) const runtime = new ClientModeRuntime(config(), identities, server, gateway(), logger()) await runtime.start() const controller = new AbortController() const rejected = expect(runtime.devices(controller.signal)).rejects.toThrow('cancel discovery') try { await started controller.abort(new Error('cancel discovery')) await rejected expect(calls).toBe(8) expect(pages).toBe(1) expect(presenceFor).not.toHaveBeenCalled() expect(identities.trustedPeer('host-0')).toBeUndefined() } finally { controller.abort(); await runtime.close() } }) it('pins Host identity from an account-authorized device detail and rejects key replacement', async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-client-trust-')) directories.push(directory) const identities = new IdentityStore({ directory }) const first = generateKeyPair(new Uint8Array(32).fill(21)) const replacement = generateKeyPair(new Uint8Array(32).fill(22)) let identityKey = first.publicKey const server = { baseUrl: 'https://dsh.r2049.cn', bindIdentity: vi.fn(), devicePages: async function* () { yield [{ deviceId: 'host-device-1', name: 'Workstation', platform: 'linux', membershipId: 'membership-1', }] }, deviceFor: vi.fn(async () => ({ deviceId: 'host-device-1', name: 'Workstation', role: 'host' as const, platform: 'linux', identityKey, membershipId: 'membership-1', })), presenceFor: vi.fn(async () => ({ online: true })), } as unknown as ClientServerApi const runtime = new ClientModeRuntime(config(), identities, server, gateway(), logger()) await runtime.start() await expect(runtime.devices()).resolves.toMatchObject([{ deviceId: 'host-device-1', online: true }]) expect(identities.trustedPeer('host-device-1')).toMatchObject({ publicKey: first.publicKey, membershipId: 'membership-1', }) identityKey = replacement.publicKey await expect(runtime.devices()).rejects.toMatchObject({ code: 'PEER_IDENTITY_MISMATCH' }) expect(identities.trustedPeer('host-device-1')?.publicKey).toBe(first.publicKey) await runtime.close() }) it('fails plugin.route control calls closed when no Remote Host is connected', async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-client-plugin-route-')) directories.push(directory) const runtime = new ClientModeRuntime( config(), new IdentityStore({ directory }), { bindIdentity: vi.fn() } as unknown as ClientServerApi, gateway(), logger(), ) await runtime.start() const signal = new AbortController().signal await expect(runtime.handleControl('plugin.route', { route: 'api/bot', body: {} }, signal)).resolves.toMatchObject({ ok: false, error: { code: 'internal', details: { remoteCode: 'REMOTE_NOT_CONNECTED' } }, }) await expect(runtime.handleControl('plugin.route', { route: 'http://evil', body: {} }, signal)).resolves.toMatchObject({ ok: false, error: { code: 'internal', details: { remoteCode: 'INVALID_MESSAGE' } }, }) await expect(runtime.handleControl('plugin.route', { route: 'api/bot', body: 'not-an-object' }, signal)).resolves.toMatchObject({ ok: false, error: { code: 'internal', details: { remoteCode: 'INVALID_MESSAGE' } }, }) await runtime.close() }) }) function config(): ResolvedConfig { return { terminal: { enabled: false }, httpServerAllowlist: [], sidebar: { entry: 'standard' }, loopback: { ports: [] }, enabled: true, role: 'both', serverUrl: 'https://dsh.r2049.cn', deviceName: 'Local Harness', forceRelay: false, rotatePinnedPeerKey: false, logLevel: 'error', liteMode: false, reconnect: { enabled: true, initialDelayMs: 100, maxDelayMs: 1_000, jitter: 0 }, codex: { enabled: false, binary: 'codex' }, cursor: { enabled: false, binary: 'agent' }, } } function logger(): SafeLogger { return { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() } as unknown as SafeLogger } function gateway(): { invoke(request: unknown): Promise } { return { invoke: vi.fn(async () => undefined) } } function gatewayWithCarrier() { const open = vi.fn(async () => (async function* () {})()) return { invoke: vi.fn(async () => undefined), stream: vi.fn(async () => (async function* () {})()), dispatchRpc: vi.fn(async () => ({ ok: true as const })), openWireStream: open, wireStream: { open, failure: () => ({ code: 'internal', message: 'failed', details: {} }), }, } }