From 7efca20bbd4dfc9339f3ae04a2a84203cb8d977d Mon Sep 17 00:00:00 2001 From: QQ Date: Sat, 14 Nov 2026 15:01:52 +0800 Subject: [PATCH] Import packages/plugin/tests/multi-client-runtime.test.ts --- .../plugin/tests/multi-client-runtime.test.ts | 608 ++++++++++++++++++ 1 file changed, 608 insertions(+) create mode 100644 packages/plugin/tests/multi-client-runtime.test.ts diff --git a/packages/plugin/tests/multi-client-runtime.test.ts b/packages/plugin/tests/multi-client-runtime.test.ts new file mode 100644 index 0000000..238632e --- /dev/null +++ b/packages/plugin/tests/multi-client-runtime.test.ts @@ -0,0 +1,608 @@ +import { runScenarios, scenarioName } from '../../../scripts/test-scenarios.mjs' +import { randomUUID } from 'node:crypto' +import { once } from 'node:events' +import { createServer } from 'node:http' +import { createRpcRequest, type LoopbackRead, type LoopbackWsRead, type RemoteMessage, type RpcErrorPayload, type RpcResponsePayload } from '@dsh-remote/protocol' +import { describe, expect, it, vi } from 'vitest' +import { WebSocketServer } from 'ws' +import type { ResolvedConfig } from '../src/config.js' +import type { HostIdentity, IdentityStore } from '../src/identity-store.js' +import type { SafeLogger } from '../src/logging.js' +import { HostPluginRuntime } from '../src/service.js' +import { probeRemoteHostFeatures } from '../src/client-capabilities.js' +import { HostServerConnection } from '../src/server-connection.js' +import { CodexRemoteDomain } from '../src/codex/domain.js' +import { CodexAppServerError, type CodexAppServerLike } from '../src/codex/app-server.js' +import type { AuthenticatedPeerChannel } from '../src/types.js' +import type { LocalTypertGateway } from '../src/typert-gateway-contract.js' + +describe('HostPluginRuntime multi-Client routing', () => { + it('does not start inbound Host authorization when control is disabled at startup', async () => { + const start = vi.spyOn(HostServerConnection.prototype, 'start').mockImplementation(() => undefined) + try { + await runScenarios([false, true].map(enabled => ({ name: 'hostControl=' + enabled, run: async () => { + start.mockClear() + const runtime = new HostPluginRuntime({ ...config(), serverUrl: 'https://server.example', hostControl: { enabled } }, Object.assign(identities(), { directory: '/fixture/host-identity' }), logger()) + try { + await runtime.start() + expect(start).toHaveBeenCalledTimes(enabled ? 1 : 0) + if (!enabled) expect(runtime.hostStatus()).toMatchObject({ online: false, authorized: false, accountRequired: false }) + } finally { await runtime.close() } + } }))) + } finally { start.mockRestore() } + }) + + it('advertises CodeX readiness over the authenticated channel', async () => { + const rows = [ + 'ready', + 'disabled', + 'protocol-failure', + 'permission-denied', + 'signed-out', + 'account-failure', + 'not-ready', + ] as const + await runScenarios( + rows.map((row, index) => { + const scenario = row + return { + name: scenarioName( + 'advertises CodeX workspace types over the authenticated channel only when %s', + row, + index, + ), + run: async () => { + const settings = { ...config(), codex: { enabled: scenario !== 'disabled', binary: '/test/codex' } } + const runtime = new HostPluginRuntime(settings, identities(), logger()) + let ready = false + const app: CodexAppServerLike = { + start: vi.fn(async () => { + if (scenario === 'protocol-failure' || scenario === 'permission-denied') { + throw new CodexAppServerError('CODEX_START_FAILED', scenario) + } + ready = scenario !== 'not-ready' + }), + isReady: () => ready, + call: vi.fn(async (method) => { + if (method !== 'account/read') + throw new Error('Capability discovery must not query projects or sessions.') + if (scenario === 'account-failure') + throw new CodexAppServerError('CODEX_REQUEST_TIMEOUT', 'account unavailable') + return { + requiresOpenaiAuth: true, + account: scenario === 'signed-out' ? null : { type: 'chatgpt' }, + projectPath: '/private/workspace', + prompt: 'private prompt', + fileContent: 'private source', + toolOutput: 'private output', + } + }), + respond: vi.fn(async () => undefined), + respondError: vi.fn(async () => undefined), + onInbound: () => () => undefined, + onUnavailable: () => () => undefined, + close: vi.fn(async () => { + ready = false + }), + } + const factory = vi.fn(() => app) + // Exercise the real domain startup/auth state machine with a controlled upstream. + ;(runtime as unknown as { codex: CodexRemoteDomain }).codex = new CodexRemoteDomain( + settings.codex, + logger(), + factory, + ) + const channel = fakeChannel('workspace-types', 'client-phone') + const describe = async () => { + const request = createRpcRequest('harness.transport.describe', {}) + channel.push(request) + let response: RemoteMessage | undefined + await vi.waitFor(() => { + response = channel + .sent() + .find( + (message) => + message.type === 'rpc.response' && + (message.payload as RpcResponsePayload).requestId === request.id, + ) + expect(response).toBeDefined() + }) + return (response!.payload as RpcResponsePayload).result as { + capabilities: string[] + workspaceTypes: unknown[] + } + } + try { + await runtime.start() + await runtime.acceptAuthenticatedPeer(channel) + const result = await describe() + expect(result.capabilities).toEqual( + scenario === 'ready' + ? [ + 'workspace.upload.v1', + 'codex.appserver.v1', + 'codex.appserver.transfer.v1', + 'remote.history.compact.v1', + ] + : ['workspace.upload.v1', 'remote.history.compact.v1'], + ) + expect(result.workspaceTypes).toEqual( + scenario === 'ready' + ? [{ id: 'codex', name: 'CodeX', capability: 'codex.appserver.v1', available: true }] + : [], + ) + expect(JSON.stringify(result)).not.toMatch(/private|projectPath|prompt|fileContent|toolOutput/) + if (scenario === 'disabled') expect(factory).not.toHaveBeenCalled() + if (scenario === 'ready') { + expect(app.call).toHaveBeenCalledWith('account/read', { refreshToken: false }, 15_000) + // The advertisement must reflect a lost upstream immediately, without cached readiness. + ready = false + const disconnected = await describe() + expect(disconnected.workspaceTypes).toEqual([]) + expect(disconnected.capabilities).not.toContain('codex.appserver.v1') + expect(disconnected.capabilities).not.toContain('codex.appserver.transfer.v1') + } + } finally { + await runtime.close() + } + }, + } + }), + ) + }) + + it('starts the Harness Host without waiting for ACP and advertises enabled backend support during warmup', async () => { + const settings = { ...config(), serverUrl: 'https://example.invalid', acp: { enabled: true, backends: [ + { id: 'antigravity', enabled: true, command: 'agy', args: [] }, + { id: 'cursor', enabled: false, command: 'agent', args: ['acp'] }, + ] } } + const runtime = new HostPluginRuntime(settings, { ...identities(), directory: '/tmp/dsh-remote-startup-test' } as IdentityStore, logger(), localGateway()) + let release!: () => void + const pending = new Promise(resolve => { release = resolve }) + const start = vi.fn() + const stop = vi.fn(async () => undefined) + const internal = runtime as unknown as { + acp: { start(): Promise } + readHarnessVersion(): Promise + createServerConnection(): unknown + } + vi.spyOn(internal.acp, 'start').mockReturnValue(pending) + vi.spyOn(internal, 'readHarnessVersion').mockResolvedValue('0.2.0-rc.1') + vi.spyOn(internal, 'createServerConnection').mockReturnValue({ start, stop, isOnline: () => true, lastError: () => undefined }) + try { + await runtime.start() + expect(start).toHaveBeenCalledTimes(1) + const capabilities = runtime.diagnostics().capabilities + expect(capabilities).toContain('harness.remote.v3') + expect(capabilities).toContain('agent.acp.antigravity.v1') + expect(capabilities).not.toContain('agent.acp.cursor.v1') + expect(runtime.diagnostics().workspaceTypes).toEqual([{ + id: 'antigravity', name: 'Antigravity', capability: 'agent.acp.antigravity.v1', available: false, + }]) + } finally { + await runtime.close() + release() + await pending + } + expect(stop).toHaveBeenCalledTimes(1) + }) + + it('withholds Harness transport when the Host Session API is absent', async () => { + const gateway = localGateway() + const dispatch = vi.mocked(gateway.dispatch) + dispatch.mockResolvedValueOnce({ ok: false, error: { + code: 'gateway/invocation-unavailable', message: 'Unavailable', details: {}, + } }) + const log = logger() + const runtime = new HostPluginRuntime(config(), identities(), log, gateway) + const channel = fakeChannel('missing-host-api', 'client-phone') + try { + await runtime.start() + await runtime.acceptAuthenticatedPeer(channel) + const describe = async (): Promise => { + const request = createRpcRequest('harness.transport.describe', {}) + channel.push(request) + let response: RemoteMessage | undefined + await vi.waitFor(() => { + response = channel.sent().find(message => message.type === 'rpc.response' + && (message.payload as RpcResponsePayload).requestId === request.id) + expect(response).toBeDefined() + }) + return ((response!.payload as RpcResponsePayload).result as { capabilities: string[] }).capabilities + } + const missing = await describe() + expect(dispatch).toHaveBeenCalledWith('session/list', { args: { _request: {} } }, expect.any(AbortSignal)) + expect(missing.some(value => value.startsWith('harness.remote.'))).toBe(false) + expect(missing).not.toContain('harness.remote.stream.transfer.v1') + await expect(probeRemoteHostFeatures({ rpc: async () => ({ capabilities: missing }) } as never)) + .rejects.toMatchObject({ code: 'FEATURE_NOT_SUPPORTED' }) + expect(log.warn).toHaveBeenCalledOnce() + const recovered = await describe() + expect(recovered.some(value => value === 'harness.remote.v1' || value === 'harness.remote.v3')).toBe(true) + expect(recovered).toContain('harness.remote.stream.transfer.v1') + } finally { await runtime.close() } + }) + + it('reports an unready or unverified Session API as a retryable discovery failure', async () => { + await runScenarios([ + { name: 'service unavailable', answer: { ok: false as const, error: { + code: 'gateway/service-unavailable', message: 'Service unavailable', details: {}, + } }, message: 'The Host Session API is not ready.' }, + { name: 'invalid arguments', answer: { ok: false as const, error: { + code: 'gateway/arguments-invalid', message: 'Invalid arguments', details: {}, + } }, message: 'Cannot verify the Host Session API.' }, + { name: 'timeout', answer: new DOMException('Timed out', 'TimeoutError'), message: 'Cannot verify the Host Session API.' }, + ].map(({ name, answer, message }) => ({ name, run: async () => { + const gateway = localGateway() + const dispatch = vi.mocked(gateway.dispatch) + if (answer instanceof Error) dispatch.mockRejectedValueOnce(answer) + else dispatch.mockResolvedValueOnce(answer) + const log = logger() + const runtime = new HostPluginRuntime(config(), identities(), log, gateway) + const channel = fakeChannel(`unverified-${name}`, 'client-phone') + try { + await runtime.start() + await runtime.acceptAuthenticatedPeer(channel) + const request = createRpcRequest('harness.transport.describe', {}) + channel.push(request) + await vi.waitFor(() => expect(channel.sent().find(row => row.type === 'rpc.error' + && (row.payload as RpcErrorPayload).requestId === request.id)).toBeDefined()) + const response = channel.sent().find(row => row.type === 'rpc.error' + && (row.payload as RpcErrorPayload).requestId === request.id)! + expect(response.payload).toMatchObject({ code: 'CONNECTION_FAILED', message, retryable: true }) + expect(log.warn).not.toHaveBeenCalledWith(expect.stringContaining('Install @deepseek-ai/dsh-api-remotes')) + const recovered = createRpcRequest('harness.transport.describe', {}) + channel.push(recovered) + await vi.waitFor(() => expect(channel.sent().find(row => row.type === 'rpc.response' + && (row.payload as RpcResponsePayload).requestId === recovered.id)).toBeDefined()) + const restored = channel.sent().find(row => row.type === 'rpc.response' + && (row.payload as RpcResponsePayload).requestId === recovered.id)! + const capabilities = ((restored.payload as RpcResponsePayload).result as { capabilities: string[] }).capabilities + expect(capabilities.some(value => value === 'harness.remote.v1' || value === 'harness.remote.v3')).toBe(true) + } finally { await runtime.close() } + } }))) + }) + + it('advertises ApiProxy alongside compatible Session V3 versions', async () => { + const rows = ['0.1.5-rc.1', '0.2.0-rc.1'] as const + await runScenarios( + rows.map((row, index) => { + const version = row + return { + name: scenarioName('advertises ApiProxy alongside Session V3 on %s', row, index), + run: async () => { + const runtime = new HostPluginRuntime( + config(), + identities(), + logger(), + localGateway(), + ) + await runtime.start() + ;(runtime as unknown as { harnessVersion: string }).harnessVersion = version + + expect(runtime.diagnostics()).toMatchObject({ + capabilities: expect.arrayContaining([ + 'harness.remote.v3', + 'harness.remote.transfer.v1', + ]), + }) + await runtime.close() + }, + } + }), + ) + }) + + it('allows identical stream ids on different Client connections without crossing frames', async () => { + const streamSignals: AbortSignal[] = [] + const gateway = localGateway() + gateway.open = async (_endpoint, payload, signal) => (async function* () { + streamSignals.push(signal) + yield { marker: (payload as { args: { sessionId: string } }).args.sessionId } + await new Promise(resolve => signal.addEventListener('abort', () => resolve(), { once: true })) + })() + const runtime = new HostPluginRuntime( + config(), + identities(), + logger(), + gateway, + ) + await runtime.start() + + const phone = fakeChannel('connection-phone', 'client-phone') + const desktop = fakeChannel('connection-desktop', 'client-desktop') + await runtime.acceptAuthenticatedPeer(phone) + await runtime.acceptAuthenticatedPeer(desktop) + + phone.push(streamRequest('phone-open')) + desktop.push(streamRequest('desktop-open')) + + await vi.waitFor(() => { + expect(streamSignals).toHaveLength(2) + expect(phone.sent()).toContainEqual(expect.objectContaining({ type: 'rpc.response' })) + expect(desktop.sent()).toContainEqual(expect.objectContaining({ type: 'rpc.response' })) + expect(streamFrameRpcIds(phone.sent())).toEqual(['phone-open']) + expect(streamFrameRpcIds(desktop.sent())).toEqual(['desktop-open']) + }) + expect(runtime.diagnostics()).toMatchObject({ + online: true, + activeConnections: 2, + }) + expect(runtime.connections.peerDeviceIds()).toEqual(['client-phone', 'client-desktop']) + expect(runtime.hostStatus().connectedClients).toEqual([ + { deviceId: 'client-phone', name: 'Phone', platform: 'android', mode: 'LAN' }, + { deviceId: 'client-desktop', name: 'Laptop', platform: 'darwin', mode: 'P2P' }, + ]) + expect(phone.sent()).not.toContainEqual(expect.objectContaining({ type: 'rpc.error' })) + expect(desktop.sent()).not.toContainEqual(expect.objectContaining({ type: 'rpc.error' })) + + await runtime.close() + expect(streamSignals.every(signal => signal.aborted)).toBe(true) + }) + + it('isolates HTTP preview handles and keeps previews working after another Client disconnects or reconnects', async () => { + const server = createServer((request, response) => { + response.writeHead(200) + response.write(request.url!) + }) + server.listen(0, '127.0.0.1') + await once(server, 'listening') + const port = (server.address() as { port: number }).port + const settings = config() + settings.loopback.ports = [port] + const runtime = new HostPluginRuntime(settings, identities(), logger()) + try { + await runtime.start() + const phone = fakeChannel('connection-phone', 'client-phone') + const desktop = fakeChannel('connection-desktop', 'client-desktop') + await runtime.acceptAuthenticatedPeer(phone) + await runtime.acceptAuthenticatedPeer(desktop) + const id = randomUUID() + const open = { op: 'http.open', id, port, path: '/phone', method: 'GET', headers: [] } + await peerRpc(phone, open) + await expect(peerRpc(desktop, { op: 'http.read', id })).rejects.toMatchObject({ code: 'LOOPBACK_CLOSED' }) + // Identical ids must be usable independently on different connections. + await peerRpc(desktop, { ...open, path: '/desktop' }) + expect(await runtime.connections.closeConnection('connection-desktop')).toBe(true) + const phoneRead = await peerRpc(phone, { op: 'http.read', id }) + expect(Buffer.from(phoneRead.data, 'base64').toString()).toBe('/phone') + + const reconnected = fakeChannel('connection-desktop-2', 'client-desktop') + await runtime.acceptAuthenticatedPeer(reconnected) + await expect(peerRpc(reconnected, { op: 'http.read', id })).rejects.toMatchObject({ code: 'LOOPBACK_CLOSED' }) + await peerRpc(reconnected, { ...open, path: '/reconnected' }) + const reconnectRead = await peerRpc(reconnected, { op: 'http.read', id }) + expect(Buffer.from(reconnectRead.data, 'base64').toString()).toBe('/reconnected') + expect(await peerRpc(phone, { op: 'describe' })).toEqual({ ports: [port] }) + } finally { + await runtime.close() + server.closeAllConnections() + await new Promise(resolve => server.close(() => resolve())) + } + }) + + it('keeps another Client WebSocket preview alive during connection replacement and closes sockets on Host shutdown', async () => { + const server = createServer() + const upstream = new WebSocketServer({ server }) + upstream.on('connection', socket => socket.on('message', (data, binary) => socket.send(data, { binary }))) + server.listen(0, '127.0.0.1') + await once(server, 'listening') + const port = (server.address() as { port: number }).port + const settings = config() + settings.loopback.ports = [port] + const runtime = new HostPluginRuntime(settings, identities(), logger()) + try { + await runtime.start() + const phone = fakeChannel('connection-phone', 'client-phone') + const desktop = fakeChannel('connection-desktop', 'client-desktop') + await runtime.acceptAuthenticatedPeer(phone) + await runtime.acceptAuthenticatedPeer(desktop) + const id = randomUUID() + const open = { op: 'ws.open', id, port, path: '/', headers: [], protocols: [] } + await peerRpc(phone, open) + await peerRpc(desktop, open) + const replacement = fakeChannel('connection-desktop-2', 'client-desktop') + await runtime.acceptAuthenticatedPeer(replacement) + await vi.waitFor(() => expect(upstream.clients.size).toBe(1)) + await peerRpc(phone, { op: 'ws.send', id, data: Buffer.from('phone still connected').toString('base64'), binary: false }) + const echo = await peerRpc(phone, { op: 'ws.read', id }) + expect(echo.closed).toBe(false) + expect(echo.messages.map(message => Buffer.from(message.data, 'base64').toString())).toEqual(['phone still connected']) + await peerRpc(replacement, open) + await runtime.close() + await vi.waitFor(() => expect(upstream.clients.size).toBe(0)) + } finally { + await runtime.close() + for (const socket of upstream.clients) socket.terminate() + upstream.close() + server.closeAllConnections() + await new Promise(resolve => server.close(() => resolve())) + } + }) + + it('applies changed preview ports to current and reconnected Clients', async () => { + const settings = config() + settings.loopback.ports = [5173] + const runtime = new HostPluginRuntime(settings, identities(), logger()) + try { + await runtime.start() + const phone = fakeChannel('connection-phone', 'client-phone') + const desktop = fakeChannel('connection-desktop', 'client-desktop') + await runtime.acceptAuthenticatedPeer(phone) + await runtime.acceptAuthenticatedPeer(desktop) + runtime.setLoopbackPorts([8080]) + for (const client of [phone, desktop]) { + expect(await peerRpc(client, { op: 'describe' })).toEqual({ ports: [8080] }) + await expect(peerRpc(client, { op: 'http.open', id: randomUUID(), port: 5173, path: '/', method: 'GET', headers: [] })) + .rejects.toMatchObject({ code: 'LOOPBACK_PORT_DENIED' }) + } + const replacement = fakeChannel('connection-desktop-2', 'client-desktop') + await runtime.acceptAuthenticatedPeer(replacement) + expect(await peerRpc(replacement, { op: 'describe' })).toEqual({ ports: [8080] }) + runtime.setLoopbackPorts([]) + expect(runtime.diagnostics().capabilities).not.toContain('loopback.http-ws.v1') + expect(await peerRpc(phone, { op: 'describe' })).toEqual({ ports: [] }) + expect(await peerRpc(replacement, { op: 'describe' })).toEqual({ ports: [] }) + } finally { + await runtime.close() + } + }) + + it('revokes preview ports for every connected Client while retaining allowed sockets', async () => { + const servers = [createServer(), createServer()] + const upstreams = servers.map(server => new WebSocketServer({ server })) + const runtime = new HostPluginRuntime(config(), identities(), logger()) + try { + const ports = await Promise.all(servers.map(async server => { + await new Promise(resolve => server.listen(0, '127.0.0.1', resolve)) + return (server.address() as { port: number }).port + })) + runtime.setLoopbackPorts(ports) + await runtime.start() + const phone = fakeChannel('connection-phone', 'client-phone') + const desktop = fakeChannel('connection-desktop', 'client-desktop') + await runtime.acceptAuthenticatedPeer(phone) + await runtime.acceptAuthenticatedPeer(desktop) + const call = async (channel: typeof phone, params: unknown): Promise => { + const request = createRpcRequest('loopback.call', params) + channel.push(request) + let response: RemoteMessage | undefined + await vi.waitFor(() => { + response = channel.sent().find(message => (message.type === 'rpc.response' || message.type === 'rpc.error') + && (message.payload as RpcResponsePayload | RpcErrorPayload).requestId === request.id) + expect(response).toBeDefined() + }) + if (response!.type === 'rpc.error') throw response!.payload + return (response!.payload as RpcResponsePayload).result + } + const open = { op: 'ws.open', path: '/', headers: [], protocols: [] } + const revokedIds = [randomUUID(), randomUUID()]; const keptId = randomUUID() + await call(phone, { ...open, id: revokedIds[0], port: ports[0] }) + await call(desktop, { ...open, id: revokedIds[1], port: ports[0] }) + await call(desktop, { ...open, id: keptId, port: ports[1] }) + expect(upstreams[0]!.clients.size).toBe(2) + runtime.setLoopbackPorts([ports[1]!]) + await vi.waitFor(() => expect(upstreams[0]!.clients.size).toBe(0)) + expect(upstreams[1]!.clients.size).toBe(1) + for (const [index, channel] of [phone, desktop].entries()) { + await expect(call(channel, { op: 'ws.send', id: revokedIds[index], data: '', binary: false })) + .rejects.toMatchObject({ code: 'LOOPBACK_CLOSED' }) + await expect(call(channel, { ...open, id: randomUUID(), port: ports[0] })) + .rejects.toMatchObject({ code: 'LOOPBACK_PORT_DENIED' }) + } + await expect(call(desktop, { op: 'ws.send', id: keptId, data: '', binary: false })).resolves.toEqual({ sent: true }) + } finally { + await runtime.close() + for (const upstream of upstreams) { for (const socket of upstream.clients) socket.terminate(); upstream.close() } + await Promise.all(servers.map(server => new Promise(resolve => server.close(() => resolve())))) + } + }) +}) + +async function peerRpc(channel: ReturnType, params: unknown): Promise { + const request = createRpcRequest('loopback.call', params) + channel.push(request) + let response: RemoteMessage | undefined + await vi.waitFor(() => { + response = channel.sent().find(message => (message.type === 'rpc.response' || message.type === 'rpc.error') + && (message.payload as RpcResponsePayload | RpcErrorPayload).requestId === request.id) + expect(response).toBeDefined() + }) + if (response!.type === 'rpc.error') { + const error = response!.payload as RpcErrorPayload + throw Object.assign(new Error(error.message), { code: error.code }) + } + return (response!.payload as RpcResponsePayload).result as T +} + +function streamRequest(rpcId: string): RemoteMessage { + return createRpcRequest('harness.remote.stream.open', { + streamId: 'same-client-stream-id', + endpoint: 'session/follow', + payload: { args: { sessionId: rpcId } }, + }) +} + +function streamFrameRpcIds(messages: RemoteMessage[]): unknown[] { + return messages + .filter(message => message.type === 'event' + && (message.payload as { event?: string }).event === 'harness.remote.frame') + .map(message => ( + message.payload as { data: { value: { marker: unknown } } } + ).data.value.marker) +} + +function identities(): IdentityStore { + const identity: HostIdentity = { + schemaVersion: 1, + deviceId: 'host-1', + name: 'Host', + publicKey: 'host-public-key', + privateKey: 'host-private-key', + fingerprint: 'HOST', + } + const peers = new Map([ + ['client-phone', { deviceId: 'client-phone', name: 'Phone', platform: 'android' }], + ['client-desktop', { deviceId: 'client-desktop', name: 'Laptop', platform: 'darwin' }], + ]) + return { + loadOrCreate: vi.fn(async () => identity), + isTrusted: vi.fn(() => true), + listTrustedPeers: vi.fn(() => [...peers.values()]), + trustedPeer: vi.fn((deviceId: string) => peers.get(deviceId)), + } as unknown as IdentityStore +} + +function localGateway(): LocalTypertGateway { + return { + invoke: vi.fn(async () => undefined), + dispatch: vi.fn(async () => ({ ok: true as const })), + open: vi.fn(async () => (async function* () { return })()), + failure: vi.fn(() => ({ code: 'internal', message: 'failed', details: {} })), + supportsCarrier: true, + } +} + +function fakeChannel( + connectionId: string, + peerDeviceId: string, +): AuthenticatedPeerChannel & { push(message: RemoteMessage): void; sent(): RemoteMessage[] } { + let handler: (message: RemoteMessage) => void = () => undefined + const sentMessages: RemoteMessage[] = [] + const send = vi.fn(async (message: RemoteMessage) => { sentMessages.push(message) }) + return { + security: { protocol: 'Noise_IK_25519_ChaChaPoly_SHA256', connectionId, membershipId: 'membership-1' }, + peerDeviceId, + peerIdentityKey: `key-${peerDeviceId}`, + mode: peerDeviceId === 'client-desktop' ? 'P2P' : 'LAN', + send, + close: vi.fn(async () => undefined), + onMessage: vi.fn(next => { handler = next; return () => { handler = () => undefined } }), + push: message => handler(message), + sent: () => [...sentMessages], + } +} + +function config(): ResolvedConfig { + return { + terminal: { enabled: false }, + httpServerAllowlist: [], + sidebar: { entry: 'standard' }, + loopback: { ports: [] }, + enabled: true, + role: 'host', + serverUrl: undefined, + deviceName: 'Host', + forceRelay: true, + rotatePinnedPeerKey: false, + logLevel: 'error', + liteMode: false, + reconnect: { enabled: false, 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 +}