import { ControlLease } from '@dsh-remote/webrtc' import { runScenarios, scenarioName } from '../../../scripts/test-scenarios.mjs' import { NoiseIkSession, createNoisePrologue, generateKeyPair, toBase64Url } from '@dsh-remote/crypto' import { createControlFrame, createRpcRequest, decodeMessage, encodeMessage, type RemoteMessage } from '@dsh-remote/protocol' import { describe, expect, it, vi } from 'vitest' import type { ConnectionController } from '../src/connection-controller.js' import type { ResolvedConfig } from '../src/config.js' import type { HostIdentity, IdentityStore, TrustedPeer } from '../src/identity-store.js' import type { SafeLogger } from '../src/logging.js' import { ServerApiError, HostServerApi } from '../src/server-api.js' import { HostServerConnection } from '../src/server-connection.js' import type { AuthenticatedPeerChannel } from '../src/types.js' import { PLUGIN_VERSION } from '../src/version.js' import { ServerCredentialStore } from '../src/server-credentials.js' import { mkdtemp, rm } from 'node:fs/promises' import { tmpdir } from 'node:os' import { join } from 'node:path' import type { RtcPeerConnectionFactory } from '@dsh-remote/webrtc' class FakeWebSocket { readyState = 0 sent: string[] = [] onopen: ((event: unknown) => void) | null = null onmessage: ((event: { data: unknown }) => void) | null = null onerror: ((event: unknown) => void) | null = null onclose: ((event: { code: number; reason: string }) => void) | null = null onSend?: (frame: unknown) => void open(): void { this.readyState = 1; this.onopen?.({}) } receive(frame: unknown): void { this.onmessage?.({ data: JSON.stringify(frame) }) } send(data: string): void { this.sent.push(data) this.onSend?.(JSON.parse(data)) } close(code = 1000, reason = ''): void { this.readyState = 3; this.onclose?.({ code, reason }) } } describe('HostServerConnection', () => { it('starts the hello timeout after the WebSocket upgrade completes', async () => { vi.useFakeTimers() const socket = new FakeWebSocket() const api = { baseUrl: 'https://remote.test', authenticate: async () => ({ accessToken: 'test-token' }), } as unknown as HostServerApi const server = new HostServerConnection( config(), { schemaVersion: 1, deviceId: 'host-1', name: 'Host', fingerprint: 'HOST', ...generateKeyPair(new Uint8Array(32).fill(51)) }, { trustedPeer: () => undefined } as unknown as IdentityStore, api, { close: async () => {} } as unknown as ConnectionController, logger(), () => socket, ) try { server.start() await vi.advanceTimersByTimeAsync(0) await vi.advanceTimersByTimeAsync(15_000) expect(socket.readyState).toBe(0) socket.open() socket.receive(createControlFrame('hello.ack', helloAck('control-1'))) await vi.advanceTimersByTimeAsync(0) expect(server.isOnline()).toBe(true) } finally { try { await server.stop() expect(vi.getTimerCount()).toBe(0) } finally { vi.useRealTimers(); vi.restoreAllMocks() } } }) it('keeps the responder alive for the Server RTC budget and preserves legacy defaults', async () => { await runScenarios([ { name: 'twenty-second Server', timeout: 20000, expected: 20000 }, { name: 'legacy Server without timeout', timeout: undefined, expected: 12000 }, { name: 'shorter Server budget preserves local minimum', timeout: 8000, expected: 12000 }, ].map(row => ({ name: row.name, run: async () => { vi.useFakeTimers() const hostKeys = generateKeyPair(new Uint8Array(32).fill(51)) const clientKeys = generateKeyPair(new Uint8Array(32).fill(52)) const peer = { deviceId: 'client-1', name: 'Client', platform: 'linux', publicKey: clientKeys.publicKey, fingerprint: 'CLIENT', membershipId: 'member', trustedAt: 1 } const socket = new FakeWebSocket() const pc = { connectionState: 'new', iceConnectionState: 'new', iceGatheringState: 'new', setRemoteDescription: async () => {}, createAnswer: async () => ({ type: 'answer', sdp: 'answer' }), setLocalDescription: async () => {}, getStats: async () => [], close: vi.fn() } const server = new HostServerConnection({ ...config(), forceRelay: false }, { schemaVersion: 1, deviceId: 'host-1', name: 'Host', fingerprint: 'HOST', ...hostKeys }, { trustedPeer: () => peer } as unknown as IdentityStore, { baseUrl: 'https://remote.test', authenticate: async () => ({ accessToken: 'test-token' }), deviceFor: async () => ({ ...peer, role: 'client', identityKey: clientKeys.publicKey }), turnCredentials: async () => [], } as unknown as HostServerApi, { close: async () => {} } as unknown as ConnectionController, logger(), () => socket, async () => ({ create: () => pc }) as unknown as RtcPeerConnectionFactory) try { server.start() await vi.advanceTimersByTimeAsync(0) socket.open() socket.receive(createControlFrame('hello.ack', { ...helloAck('control-1'), capabilities: ['transport.p2p', 'transport.turn', 'transport.relay'], ...(row.timeout === undefined ? {} : { webrtcFallbackTimeoutMs: row.timeout }), })) socket.receive(createControlFrame('connect.incoming', { connectionId: 'connection-1', clientDeviceId: 'client-1', clientIdentityKey: clientKeys.publicKey, authorization: 'account', preferredTransports: ['p2p', 'turn', 'relay'], })) socket.receive(createControlFrame('signal.offer', { connectionId: 'connection-1', targetDeviceId: 'host-1', sdp: 'offer' })) await vi.advanceTimersByTimeAsync(row.expected - 1) expect(socket.sent.map(frame => JSON.parse(frame).type)).toContain('signal.answer') expect(pc.close).not.toHaveBeenCalled() await vi.advanceTimersByTimeAsync(1) expect(pc.close).toHaveBeenCalledOnce() expect(socket.readyState).toBe(1) } finally { try { await server.stop() expect(vi.getTimerCount()).toBe(0) } finally { vi.useRealTimers(); vi.restoreAllMocks() } } } }))) }) it('matches the deployed Server frames and exposes RPC only after Noise IK', async () => { const hostKeys = generateKeyPair(new Uint8Array(32).fill(11)) const clientKeys = generateKeyPair(new Uint8Array(32).fill(12)) const identity: HostIdentity = { schemaVersion: 1, deviceId: 'host-1', name: 'Host', fingerprint: 'HOST', ...hostKeys, } const peer: TrustedPeer = { deviceId: 'client-1', name: 'Phone', platform: 'android', publicKey: clientKeys.publicKey, fingerprint: 'CLIENT', trustedAt: 1, membershipId: 'membership-1', } const socket = new FakeWebSocket() let accepted: AuthenticatedPeerChannel | undefined let acceptedAtHandshakeReply: AuthenticatedPeerChannel | undefined socket.onSend = frame => { const value = frame as { type?: unknown; payload?: { step?: unknown } } if (value.type === 'secure.handshake' && value.payload?.step === 2) { acceptedAtHandshakeReply = accepted } } const connections = { accept: vi.fn(async (channel: AuthenticatedPeerChannel) => { accepted = channel }), closeConnection: vi.fn(async (connectionId: string, code?: string) => { if (accepted?.security.connectionId !== connectionId) return false await accepted.close(code) return true }), close: vi.fn(async () => undefined), } as unknown as ConnectionController const api = { baseUrl: 'https://dsh.r2049.cn', authenticate: vi.fn(async () => ({ accessToken: 'access-token-value' })), refreshCredentials: vi.fn(), deviceFor: vi.fn(async () => ({ deviceId: peer.deviceId, name: peer.name, role: 'client', platform: peer.platform, identityKey: peer.publicKey, membershipId: peer.membershipId!, })), } as unknown as HostServerApi const trustPeer = vi.fn(async (input: Omit) => ({ ...input, fingerprint: 'CLIENT', trustedAt: 1, })) const log = logger() const server = new HostServerConnection( config(), identity, { trustedPeer: vi.fn(() => undefined), trustPeer } as unknown as IdentityStore, api, connections, log, () => socket, undefined, () => ['harness.api.v1', 'fileviewer.read.v1'], '0.1.0-rc.8', ) server.start() await flush() socket.open() expect(JSON.parse(socket.sent[0]!)).toMatchObject({ type: 'hello', payload: { role: 'host', deviceId: 'host-1', clientVersion: PLUGIN_VERSION, harnessVersion: '0.1.0-rc.8', capabilities: ['transport.relay.resume.v1', 'transport.relay', 'transport.relay.attach', 'harness.api.v1', 'fileviewer.read.v1'], }, }) socket.receive(createControlFrame('hello.ack', { protocol: 1, serverVersion: '0.1.0', connectionSessionId: 'control-1', heartbeatIntervalMs: 25_000, maxControlFrameBytes: 65_536, maxRelayFrameBytes: 1_048_576, capabilities: ['transport.relay', 'harness.api.v1', 'fileviewer.read.v1'], })) socket.receive(createControlFrame('connect.incoming', { connectionId: 'connection-1', clientDeviceId: 'client-1', clientIdentityKey: clientKeys.publicKey, authorization: 'account', preferredTransports: ['relay'], })) await flush() expect(JSON.parse(socket.sent[1]!)).toEqual(expect.objectContaining({ type: 'connect.accepted', payload: { connectionId: 'connection-1' }, })) expect(trustPeer).toHaveBeenCalledWith(expect.objectContaining({ deviceId: 'client-1', publicKey: clientKeys.publicKey, membershipId: 'membership-1', })) const clientNoise = new NoiseIkSession({ role: 'initiator', localPrivateKey: clientKeys.privateKey, localPublicKey: clientKeys.publicKey, remotePublicKey: hostKeys.publicKey, prologue: createNoisePrologue('connection-1', 'host-1', 'client-1'), }) socket.receive(createControlFrame('secure.handshake', { connectionId: 'connection-1', targetDeviceId: 'host-1', step: 1, data: toBase64Url(clientNoise.writeHandshake()), })) await flush() const handshakeReply = JSON.parse(socket.sent[2]!) expect(handshakeReply).toMatchObject({ type: 'secure.handshake', payload: { step: 2, targetDeviceId: 'client-1' } }) expect(acceptedAtHandshakeReply).toBe(accepted) clientNoise.readHandshake(fromBase64UrlForTest(handshakeReply.payload.data)) expect(accepted?.security).toEqual({ protocol: 'Noise_IK_25519_ChaChaPoly_SHA256', connectionId: 'connection-1', membershipId: 'membership-1', }) let received: RemoteMessage | undefined accepted!.onMessage(message => { received = message }) const request = createRpcRequest('harness.api.call', { method: 'host.describe', rpcId: 'native-1', payload: {} }) socket.receive(createControlFrame('relay', { connectionId: 'connection-1', targetDeviceId: 'host-1', counter: 0, ciphertext: toBase64Url(clientNoise.encrypt(encodeMessage(request))), })) await flush() expect(received).toEqual(request) await accepted!.send(request) const relay = JSON.parse(socket.sent[3]!) expect(relay).toMatchObject({ type: 'relay', payload: { counter: 0, targetDeviceId: 'client-1' } }) expect(decodeMessage(clientNoise.decrypt(fromBase64UrlForTest(relay.payload.ciphertext)))).toEqual(request) socket.receive(createControlFrame('error', { code: 'CONNECTION_FAILED', message: 'the remote peer disconnected', retryable: true, connectionId: 'connection-1', })) await flush() expect(connections.closeConnection).toHaveBeenCalledWith( 'connection-1', 'CONNECTION_FAILED', { closedBy: 'server', retryable: true }, ) // The default log level must show that the Server closed this tunnel. // CONNECTION_FAILED is also the Host's local fallback code, so a debug-only // message made both paths look identical in production logs. expect(log.info).toHaveBeenCalledWith('server closed a remote connection', { code: 'CONNECTION_FAILED', connectionId: 'connection-1', retryable: true, }) expect(log.debug).not.toHaveBeenCalledWith( 'server closed a remote connection', expect.anything(), ) expect(server.lastError()).toBeUndefined() expect(socket.readyState).toBe(1) // A disconnected Client can leave an already-queued Relay frame behind. // The stale connection must be isolated instead of taking down the Host's // long-lived Server control socket or another Client tunnel. socket.receive(createControlFrame('relay', { connectionId: 'connection-1', targetDeviceId: 'host-1', counter: 1, ciphertext: toBase64Url(clientNoise.encrypt(encodeMessage(request))), })) await flush() expect(socket.readyState).toBe(1) await server.stop() }) it('attaches assigned Relay data sockets and keeps ciphertext off control', async () => { const hostKeys = generateKeyPair(new Uint8Array(32).fill(71)) const clientKeys = generateKeyPair(new Uint8Array(32).fill(72)) const identity: HostIdentity = { schemaVersion: 1, deviceId: 'host-relay', name: 'Host', fingerprint: 'HOST', ...hostKeys, } const peer: TrustedPeer = { deviceId: 'client-relay', name: 'Phone', platform: 'android', publicKey: clientKeys.publicKey, fingerprint: 'CLIENT', trustedAt: 1, membershipId: 'membership-relay', } const control = new FakeWebSocket() const sockets = [control] const createWebSocket = vi.fn((url: string) => { if (url.endsWith('/ws/v1/connect')) return control const socket = new FakeWebSocket() sockets.push(socket) return socket }) let accepted: AuthenticatedPeerChannel | undefined const connections = { accept: vi.fn(async (channel: AuthenticatedPeerChannel) => { accepted = channel }), closeConnection: vi.fn(async () => true), close: vi.fn(async () => undefined), } as unknown as ConnectionController const api = { baseUrl: 'https://dsh.r2049.cn', authenticate: vi.fn(async () => ({ accessToken: 'access-token-value' })), deviceFor: vi.fn(async () => ({ deviceId: peer.deviceId, name: peer.name, role: 'client', platform: peer.platform, identityKey: peer.publicKey, membershipId: peer.membershipId!, })), } as unknown as HostServerApi const server = new HostServerConnection( { ...config(), forceRelay: true }, identity, { trustedPeer: vi.fn(() => undefined), trustPeer: vi.fn(async (input: Omit) => ({ ...input, fingerprint: 'CLIENT', trustedAt: 1 })) } as unknown as IdentityStore, api, connections, logger(), createWebSocket, ) server.start() await flush() control.open() control.receive(createControlFrame('hello.ack', { ...helloAck('control-relay'), capabilities: ['transport.relay', 'transport.relay.attach'] })) control.receive(createControlFrame('connect.incoming', { connectionId: 'connection-relay', clientDeviceId: peer.deviceId, clientIdentityKey: peer.publicKey, authorization: 'account', preferredTransports: ['relay'], relayEndpoint: 'wss://relay.example/ws', relayTicket: 'dshrt.host-ticket', relayNodeId: 'relay-1', relayEpoch: 4, })) await flush() expect(JSON.parse(control.sent[1]!)).toMatchObject({ type: 'connect.accepted', payload: { connectionId: 'connection-relay' } }) control.receive(createControlFrame('transport.selected', { connectionId: 'connection-relay', targetDeviceId: identity.deviceId, transport: 'relay', })) await flush() expect(sockets).toHaveLength(2) const data = sockets[1]! data.open() expect(JSON.parse(data.sent[0]!)).toMatchObject({ type: 'relay.attach', payload: { connectionId: 'connection-relay', deviceId: identity.deviceId, peerDeviceId: peer.deviceId, ticket: 'dshrt.host-ticket', }, }) data.receive({ v: 1, id: 'ready', type: 'relay.ready', timestamp: Date.now(), payload: { connectionId: 'connection-relay', epoch: 4 } }) await flush() const clientNoise = new NoiseIkSession({ role: 'initiator', localPrivateKey: clientKeys.privateKey, localPublicKey: clientKeys.publicKey, remotePublicKey: hostKeys.publicKey, prologue: createNoisePrologue('connection-relay', identity.deviceId, peer.deviceId), }) control.receive(createControlFrame('secure.handshake', { connectionId: 'connection-relay', targetDeviceId: identity.deviceId, step: 1, data: toBase64Url(clientNoise.writeHandshake()), })) await flush() const handshakeReply = JSON.parse(control.sent.find(frame => JSON.parse(frame).type === 'secure.handshake')!) clientNoise.readHandshake(fromBase64UrlForTest(handshakeReply.payload.data)) expect(accepted).toBeDefined() const request = createRpcRequest('harness.api.call', { method: 'host.describe', rpcId: 'relay-1', payload: {} }) data.receive({ v: 1, id: 'relay-in', type: 'relay', timestamp: Date.now(), payload: { connectionId: 'connection-relay', targetDeviceId: identity.deviceId, counter: 0, ciphertext: toBase64Url(clientNoise.encrypt(encodeMessage(request))), }, }) await flush() await accepted!.send(request) const outgoing = JSON.parse(data.sent[1]!) expect(outgoing).toMatchObject({ type: 'relay', payload: { connectionId: 'connection-relay', targetDeviceId: peer.deviceId, counter: 0 } }) expect(control.sent.filter(frame => JSON.parse(frame).type === 'relay')).toHaveLength(0) await server.stop() }) it('stops reconnecting until account authorization is supplied', async () => { const keys = generateKeyPair(new Uint8Array(32).fill(13)) const api = { baseUrl: 'https://dsh.r2049.cn', authenticate: vi.fn(async () => { throw new ServerApiError('ACCOUNT_AUTH_REQUIRED', 'account login required', false, 401) }), } as unknown as HostServerApi const server = new HostServerConnection( { ...config(), reconnect: { ...config().reconnect, enabled: true } }, { schemaVersion: 1, deviceId: 'host-2', name: 'Host', fingerprint: 'HOST', ...keys }, { trustedPeer: vi.fn() } as unknown as IdentityStore, api, { close: vi.fn(async () => undefined) } as unknown as ConnectionController, logger(), () => new FakeWebSocket(), ) server.start() await flush() expect(api.authenticate).toHaveBeenCalledTimes(1) expect(server.lastError()).toBe('ACCOUNT_AUTH_REQUIRED') await server.stop() }) it('reconnects immediately on request and retains the last Server activity time', async () => { const keys = generateKeyPair(new Uint8Array(32).fill(14)) const sockets = [new FakeWebSocket(), new FakeWebSocket()] let socketIndex = 0 const createWebSocket = vi.fn(() => sockets[socketIndex++]!) const api = { baseUrl: 'https://dsh.r2049.cn', authenticate: vi.fn(async () => ({ accessToken: 'access-token-value' })), } as unknown as HostServerApi const server = new HostServerConnection( config(), { schemaVersion: 1, deviceId: 'host-3', name: 'Host', fingerprint: 'HOST', ...keys }, { trustedPeer: vi.fn() } as unknown as IdentityStore, api, { close: vi.fn(async () => undefined) } as unknown as ConnectionController, logger(), createWebSocket, ) server.start() await flush() sockets[0]!.open() sockets[0]!.receive(createControlFrame('hello.ack', helloAck('control-1'))) await flush() expect(server.isOnline()).toBe(true) expect(server.lastActivity()).toEqual(expect.any(Number)) server.reconnect() expect(sockets[0]!.readyState).toBe(3) await flush() expect(createWebSocket).toHaveBeenCalledTimes(2) expect(server.isReconnecting()).toBe(true) sockets[1]!.open() sockets[1]!.receive(createControlFrame('hello.ack', helloAck('control-2'))) await flush() expect(server.isOnline()).toBe(true) expect(server.lastError()).toBeUndefined() await server.stop() }) it('recovers control authentication only within the authorized retry budget', async () => { const rows = [ 'recover', 'recover-error-frame', 'recover-4001-token-expired', 'recover-after-heartbeat-timeout', 'reject-again', 'reject-again-error-frame', 'refresh-rejected', 'revoked', 'revoked-frame', 'replaced', 'replaced-before-ack', 'stopped', ] as const await runScenarios( rows.map((row, index) => { const scenario = row return { name: scenarioName('handles control authentication recovery: %s', row, index), run: async () => { const keys = generateKeyPair(new Uint8Array(32).fill(24)) const sockets: FakeWebSocket[] = [] let refreshed = false const api = { baseUrl: 'https://dsh.r2049.cn', authenticate: vi.fn(async () => ({ accessToken: refreshed ? 'new-access-value' : 'old-access-value', })), refreshCredentials: vi.fn(async () => { if (scenario === 'refresh-rejected') throw new ServerApiError('AUTH_INVALID', 'refresh rejected', false, 401, 'credential_refresh') refreshed = true }), clearAuthorization: vi.fn(async () => undefined), } as unknown as HostServerApi const logs = logger() const server = new HostServerConnection( { ...config(), reconnect: { enabled: true, initialDelayMs: 1, maxDelayMs: 1, jitter: 0 } }, { schemaVersion: 1, deviceId: 'host-recovery', name: 'Host', fingerprint: 'HOST', ...keys }, { trustedPeer: vi.fn() } as unknown as IdentityStore, api, { close: vi.fn(async () => undefined) } as unknown as ConnectionController, logs, () => { const socket = new FakeWebSocket() sockets.push(socket) return socket }, ) try { server.start() await flush() sockets[0]!.open() if (scenario === 'replaced') { sockets[0]!.receive(createControlFrame('hello.ack', helloAck('control-first'))) await flush() } if (scenario === 'stopped') await server.stop() else if (scenario === 'revoked-frame') { sockets[0]!.receive(createControlFrame('hello.ack', helloAck('control-revoked'))) await flush() sockets[0]!.receive( createControlFrame('error', { code: 'DEVICE_REVOKED', message: 'device revoked', retryable: false, }), ) } else if (scenario === 'recover-error-frame' || scenario === 'reject-again-error-frame') { sockets[0]!.receive( createControlFrame('error', { code: 'AUTH_INVALID', message: 'invalid access token', retryable: false, }), ) } else if (scenario === 'recover-4001-token-expired') { sockets[0]!.receive( createControlFrame('error', { code: 'TOKEN_EXPIRED', message: 'TOKEN_EXPIRED', retryable: false, }), ) sockets[0]!.close(4001, 'TOKEN_EXPIRED') } else if (scenario === 'recover-after-heartbeat-timeout') { sockets[0]!.receive(createControlFrame('hello.ack', helloAck('control-initial'))) await flush() sockets[0]!.close(4009, 'heartbeat timeout') await new Promise((resolve) => setTimeout(resolve, 15)) expect(sockets).toHaveLength(2) sockets[1]!.open() sockets[1]!.receive( createControlFrame('error', { code: 'AUTH_INVALID', message: 'invalid access token', retryable: false, }), ) } else { sockets[0]!.close(scenario.startsWith('replaced') ? 4003 : scenario === 'revoked' ? 4004 : 4002) } await flush() if (scenario === 'recover-after-heartbeat-timeout') { expect(sockets).toHaveLength(3) expect(api.refreshCredentials).toHaveBeenCalledWith('old-access-value') sockets[2]!.open() expect(JSON.parse(sockets[2]!.sent[0]!).payload.accessToken).toBe('new-access-value') sockets[2]!.receive(createControlFrame('hello.ack', helloAck('control-recovered-after-4009'))) await flush() expect(server.isOnline()).toBe(true) expect(server.lastError()).toBeUndefined() expect(api.refreshCredentials).toHaveBeenCalledTimes(1) } else if ( scenario === 'recover' || scenario === 'recover-error-frame' || scenario === 'recover-4001-token-expired' || scenario === 'reject-again' || scenario === 'reject-again-error-frame' ) { expect(sockets).toHaveLength(2) expect(api.refreshCredentials).toHaveBeenCalledWith('old-access-value') sockets[1]!.open() expect(JSON.parse(sockets[1]!.sent[0]!).payload.accessToken).toBe('new-access-value') if ( scenario === 'recover' || scenario === 'recover-error-frame' || scenario === 'recover-4001-token-expired' ) { sockets[1]!.receive(createControlFrame('hello.ack', helloAck('control-recovered'))) await flush() expect(server.isOnline()).toBe(true) expect(server.lastError()).toBeUndefined() } else { if (scenario === 'reject-again-error-frame') { sockets[1]!.receive( createControlFrame('error', { code: 'AUTH_INVALID', message: 'invalid access token', retryable: false, }), ) } else { sockets[1]!.close(4002) } await new Promise((resolve) => setTimeout(resolve, 20)) expect(sockets).toHaveLength(2) expect(server.lastError()).toBe('AUTH_INVALID') expect(server.isReconnecting()).toBe(false) } expect(api.refreshCredentials).toHaveBeenCalledTimes(1) } else { await new Promise((resolve) => setTimeout(resolve, 20)) expect(sockets).toHaveLength(1) expect(server.isReconnecting()).toBe(false) expect(api.refreshCredentials).toHaveBeenCalledTimes(scenario === 'refresh-rejected' ? 1 : 0) expect(api.clearAuthorization).toHaveBeenCalledTimes(scenario.startsWith('revoked') ? 1 : 0) if (scenario !== 'stopped') expect(server.lastError()).toBe( scenario.startsWith('replaced') ? 'CONNECTION_REPLACED' : scenario.startsWith('revoked') ? 'DEVICE_REVOKED' : 'AUTH_INVALID', ) if (scenario === 'refresh-rejected') expect(logs.warn).toHaveBeenCalledWith('server control connection failed', { code: 'AUTH_INVALID', retryable: false, phase: 'credential_refresh', status: 401, }) } } finally { await server.stop() } }, } }), ) }) it('recovers retryable refresh failures without spending the handshake retry', async () => { const rows = ['RATE_LIMITED', 'CONNECTION_FAILED', 'SERVER_CREDENTIALS_BUSY'] as const await runScenarios( rows.map((row, index) => { const code = row return { name: scenarioName( 'recovers after a retryable refresh failure (%s) without spending the handshake retry', row, index, ), run: async () => { const sockets: FakeWebSocket[] = [] let accessToken = 'old-access-value' const refreshCredentials = vi .fn() .mockRejectedValueOnce( new ServerApiError( code, 'temporary refresh failure', true, code === 'RATE_LIMITED' ? 429 : undefined, 'credential_refresh', ), ) .mockImplementation(async () => { accessToken = 'new-access-value' }) const api = { baseUrl: 'https://dsh.r2049.cn', authenticate: vi.fn(async () => ({ accessToken })), refreshCredentials, } as unknown as HostServerApi const server = new HostServerConnection( { ...config(), reconnect: { enabled: true, initialDelayMs: 1, maxDelayMs: 1, jitter: 0 } }, { schemaVersion: 1, deviceId: 'host-retry-refresh', name: 'Host', fingerprint: 'HOST', ...generateKeyPair(), }, { trustedPeer: vi.fn() } as unknown as IdentityStore, api, { close: vi.fn(async () => undefined) } as unknown as ConnectionController, logger(), () => { const socket = new FakeWebSocket() sockets.push(socket) return socket }, ) try { server.start() await vi.waitFor(() => expect(sockets).toHaveLength(1)) sockets[0]!.open() sockets[0]!.close(4002) await vi.waitFor(() => expect(sockets).toHaveLength(2)) expect(server.lastError()).toBe(code) expect(server.isReconnecting()).toBe(true) sockets[1]!.open() expect(JSON.parse(sockets[1]!.sent[0]!).payload.accessToken).toBe('old-access-value') sockets[1]!.close(4002) await vi.waitFor(() => expect(sockets).toHaveLength(3)) expect(refreshCredentials).toHaveBeenCalledTimes(2) expect(refreshCredentials).toHaveBeenNthCalledWith(2, 'old-access-value') sockets[2]!.open() expect(JSON.parse(sockets[2]!.sent[0]!).payload.accessToken).toBe('new-access-value') sockets[2]!.receive(createControlFrame('hello.ack', helloAck('control-retry-refresh'))) await vi.waitFor(() => expect(server.isOnline()).toBe(true)) expect(server.lastError()).toBeUndefined() } finally { await server.stop() } }, } }), ) }) it('notifies the Server and closes the RTC when an authenticated channel is closed directly', async () => { const hostKeys = generateKeyPair() const clientKeys = generateKeyPair() const noise = new NoiseIkSession({ role: 'responder', localPrivateKey: hostKeys.privateKey, localPublicKey: hostKeys.publicKey, remotePublicKey: clientKeys.publicKey, prologue: createNoisePrologue('connection-1', 'host-1', 'client-1') }) const initiator = new NoiseIkSession({ role: 'initiator', localPrivateKey: clientKeys.privateKey, localPublicKey: clientKeys.publicKey, remotePublicKey: hostKeys.publicKey, prologue: createNoisePrologue('connection-1', 'host-1', 'client-1') }) const rtc = { send: vi.fn(async () => undefined), close: vi.fn(async () => undefined) } const dataSocket = { close: vi.fn() } const socket = new FakeWebSocket() socket.readyState = 1 let channel: AuthenticatedPeerChannel | undefined const server = new HostServerConnection( config(), { schemaVersion: 1, deviceId: 'host-1', name: 'Host', fingerprint: 'HOST', ...hostKeys }, {} as IdentityStore, { baseUrl: 'https://dsh.r2049.cn' } as HostServerApi, { accept: vi.fn(async (value: AuthenticatedPeerChannel) => { channel = value }), close: vi.fn(async () => undefined) } as unknown as ConnectionController, logger(), () => socket, ) const requests: Array<{ connectionId: string; requestId: string; ticket: string }> = [] const lease = new ControlLease('connection-1', 'ticket', payload => { requests.push(payload) }, () => {}) lease.start() lease.acknowledge({ ...requests[0]!, ticket: 'confirmed', leaseMs: 300_000 }) const tunnel = { connectionId: 'connection-1', membershipId: 'membership-1', peer: { deviceId: 'client-1', publicKey: clientKeys.publicKey }, noise, transport: 'p2p', rtc, dataSocket, lease } const internals = server as unknown as { socket: FakeWebSocket; tunnels: Map; completeHandshake(tunnel: unknown, payload: unknown): Promise; dropTunnel(id: string): Promise } internals.socket = socket internals.tunnels.set('connection-1', tunnel) try { await internals.completeHandshake(tunnel, { connectionId: 'connection-1', targetDeviceId: 'host-1', step: 1, data: toBase64Url(initiator.writeHandshake()) }) await channel!.close() await channel!.close() await internals.dropTunnel('connection-1') expect(socket.sent.map(raw => JSON.parse(raw)).filter(frame => frame.type === 'connection.lease.close')) .toEqual([expect.objectContaining({ payload: { connectionId: 'connection-1' } })]) expect(rtc.close).toHaveBeenCalledOnce() expect(dataSocket.close).toHaveBeenCalledOnce() expect(lease.canDetach()).toBe(false) expect(internals.tunnels.size).toBe(0) } finally { lease.stop(); initiator.destroy(); await server.stop() } }) it('disconnects an authenticated peer when its selected WebRTC channel fails', async () => { const keys = generateKeyPair(new Uint8Array(32).fill(15)) const closeConnection = vi.fn(async () => true) const rtc = { close: vi.fn(async () => undefined) } const tunnel = { connectionId: 'connection-rtc', membershipId: 'membership-rtc', peer: { deviceId: 'client-rtc' }, noise: { destroy: vi.fn() }, transport: 'p2p', rtc, channel: {}, } const server = new HostServerConnection( config(), { schemaVersion: 1, deviceId: 'host-rtc', name: 'Host', fingerprint: 'HOST', ...keys }, { trustedPeer: vi.fn() } as unknown as IdentityStore, { baseUrl: 'https://dsh.r2049.cn' } as HostServerApi, { closeConnection } as unknown as ConnectionController, logger(), () => new FakeWebSocket(), ) const internals = server as unknown as { tunnels: Map handleRtcFailed(tunnel: unknown, rtc: unknown, error: Error): Promise } internals.tunnels.set(tunnel.connectionId, tunnel) await internals.handleRtcFailed(tunnel, rtc, new Error('data channel closed')) expect(closeConnection).toHaveBeenCalledWith(tunnel.connectionId, 'CONNECTION_FAILED') expect(rtc.close).toHaveBeenCalledOnce() expect(internals.tunnels.has(tunnel.connectionId)).toBe(false) }) it('closes an established WebRTC peer when the Server Control socket closes', async () => { const socket = new FakeWebSocket() const rtc = { close: vi.fn(async () => undefined) } const channel = { close: vi.fn(async () => undefined) } const connections = { close: vi.fn(async () => undefined) } as unknown as ConnectionController const server = new HostServerConnection( config(), { schemaVersion: 1, deviceId: 'host-rtc', name: 'Host', fingerprint: 'HOST', ...generateKeyPair() }, { trustedPeer: vi.fn() } as unknown as IdentityStore, { baseUrl: 'https://dsh.r2049.cn', authenticate: vi.fn(async () => ({ accessToken: 'access-token' })) } as unknown as HostServerApi, connections, logger(), () => socket, ) const internals = server as unknown as { tunnels: Map } try { server.start() await flush() socket.open() socket.receive(createControlFrame('hello.ack', helloAck('control-rtc'))) await vi.waitFor(() => expect(server.isOnline()).toBe(true)) internals.tunnels.set('connection-rtc', { transport: 'p2p', rtc, channel }) socket.close(1012, 'Server restart') await vi.waitFor(() => expect(channel.close).toHaveBeenCalledOnce()) expect(rtc.close).toHaveBeenCalledOnce() expect(connections.close).toHaveBeenCalledOnce() expect(internals.tunnels.size).toBe(0) } finally { await server.stop() } }) it('closes a confirmed RTC tunnel when control fails and automatic reconnect is disabled', async () => { const socket = new FakeWebSocket() const rtc = { close: vi.fn(async () => undefined) } const channel = { close: vi.fn(async () => undefined) } const connections = { close: vi.fn(async () => undefined) } as unknown as ConnectionController const cfg = config() const server = new HostServerConnection( { ...cfg, forceRelay: false }, { schemaVersion: 1, deviceId: 'host-rtc', name: 'Host', fingerprint: 'HOST', ...generateKeyPair() }, { trustedPeer: vi.fn() } as unknown as IdentityStore, { baseUrl: 'https://dsh.r2049.cn', authenticate: vi.fn(async () => ({ accessToken: 'access-token' })) } as unknown as HostServerApi, connections, logger(), () => socket, async () => undefined, ) const requests: Array<{ connectionId: string; requestId: string; ticket: string }> = [] const lease = new ControlLease('connection-rtc', 'ticket', payload => { requests.push(payload) }, () => {}) lease.start() lease.acknowledge({ ...requests[0]!, ticket: 'confirmed', leaseMs: 300_000 }) try { server.start() await flush() socket.open() socket.receive(createControlFrame('hello.ack', { ...helloAck('control-rtc'), capabilities: ['transport.p2p', 'transport.webrtc.resume.v1'] })) await vi.waitFor(() => expect(server.isOnline()).toBe(true)) const internals = server as unknown as { tunnels: Map } internals.tunnels.set('connection-rtc', { connectionId: 'connection-rtc', transport: 'p2p', rtc, channel, lease }) socket.close(1012, 'Server restart') await vi.waitFor(() => expect(channel.close).toHaveBeenCalledOnce()) expect(rtc.close).toHaveBeenCalledOnce() expect(internals.tunnels.size).toBe(0) expect(lease.canDetach()).toBe(false) } finally { await server.stop() lease.stop() } }) it('retains confirmed RTC on recovery and falls back safely after a Server rollback', async () => { // Hosted Server shutdown closes with 4001/'server shutdown'; apps/server // uses 4009. Both must retain because the reason string is the semantic // key; the label only names the row. await runScenarios(['supported Server', 'rolled-back Server', 'recovery rejected', 'legacy recovery rejected', 'expired access token', 'Server unavailable', '4009 shutdown', '4001 shutdown', '4009 heartbeat timeout'].map(name => ({ name, run: async () => { const sockets: FakeWebSocket[] = [] const rtc = { close: vi.fn(async () => undefined) } const channel = { close: vi.fn(async () => undefined) } const cfg = config() const server = new HostServerConnection( // Backoff draws from [0, maxDelayMs]; keep the window tight so the // multi-step recovery scenario rows finish well inside the test timeout. { ...cfg, forceRelay: false, reconnect: { ...cfg.reconnect, enabled: true, initialDelayMs: 20, maxDelayMs: 120 } }, { schemaVersion: 1, deviceId: 'host-rtc', name: 'Host', fingerprint: 'HOST', ...generateKeyPair() }, { trustedPeer: vi.fn() } as unknown as IdentityStore, { baseUrl: 'https://dsh.r2049.cn', authenticate: vi.fn(async () => ({ accessToken: 'access-token' })), refreshCredentials: vi.fn(async () => undefined) } as unknown as HostServerApi, { close: vi.fn(async () => undefined) } as unknown as ConnectionController, logger(), () => { const socket = new FakeWebSocket(); sockets.push(socket); return socket }, async () => undefined, ) const requests: Array<{ connectionId: string; requestId: string; ticket: string }> = [] const lease = new ControlLease('connection-rtc', 'ticket', payload => { requests.push(payload) }, () => {}) lease.start() lease.acknowledge({ ...requests[0]!, ticket: 'confirmed', leaseMs: 300_000 }) try { server.start() await flush() const socket = sockets[0]! socket.open() socket.receive(createControlFrame('hello.ack', { ...helloAck('control-rtc'), capabilities: ['transport.p2p', 'transport.webrtc.resume.v1'] })) await vi.waitFor(() => expect(server.isOnline()).toBe(true)) const internals = server as unknown as { tunnels: Map } internals.tunnels.set('connection-rtc', { connectionId: 'connection-rtc', transport: 'p2p', rtc, channel, lease }) if (name === '4009 shutdown') socket.close(4009, 'server shutdown') else if (name === '4001 shutdown') socket.close(4001, 'server shutdown') else if (name === '4009 heartbeat timeout') socket.close(4009, 'heartbeat timeout') else socket.close(1012, 'Server restart') await vi.waitFor(() => expect(sockets).toHaveLength(2)) expect(rtc.close).not.toHaveBeenCalled() expect(channel.close).not.toHaveBeenCalled() const next = sockets[1]! if (name === 'Server unavailable') { next.close(1006, 'offline') await vi.waitFor(() => expect(sockets).toHaveLength(3)) expect(rtc.close).not.toHaveBeenCalled() expect(channel.close).not.toHaveBeenCalled() } const reconnect = name === 'Server unavailable' ? sockets[2]! : next reconnect.open() expect(JSON.parse(reconnect.sent[0]!).payload.recoveryTickets).toEqual(['confirmed']) if (name === 'rolled-back Server' || name === 'recovery rejected' || name === 'legacy recovery rejected' || name === 'expired access token') { // Keep each row's historical (code, reason) pair: 'legacy recovery // rejected' is 4002 + a distinct reason, not a shutdown. next.close(name === 'rolled-back Server' ? 4008 : name === 'recovery rejected' ? 4012 : 4002, name === 'legacy recovery rejected' ? 'recovery authorization rejected' : 'rejected') await vi.waitFor(() => expect(sockets).toHaveLength(3)) const legacy = sockets[2]! legacy.open() if (name === 'expired access token') { expect(JSON.parse(legacy.sent[0]!).payload.recoveryTickets).toEqual(['confirmed']) expect(rtc.close).not.toHaveBeenCalled() legacy.receive(createControlFrame('hello.ack', { ...helloAck('recovered'), capabilities: ['transport.p2p', 'transport.webrtc.resume.v1'] })) } else { expect(JSON.parse(legacy.sent[0]!).payload.recoveryTickets).toBeUndefined() legacy.receive(createControlFrame('hello.ack', helloAck('legacy'))) } } else { reconnect.receive(createControlFrame('hello.ack', { ...helloAck('recovered'), capabilities: ['transport.p2p', 'transport.webrtc.resume.v1'] })) } await vi.waitFor(() => expect(server.isOnline()).toBe(true)) expect(internals.tunnels.size).toBe(['rolled-back Server', 'recovery rejected', 'legacy recovery rejected'].includes(name) ? 0 : 1) } finally { await server.stop() lease.stop() } expect(rtc.close).toHaveBeenCalledOnce() expect(channel.close).toHaveBeenCalledOnce() } }))) }) it('backs off the first reconnect after every close into the maxDelayMs window', async () => { await runScenarios([ { name: '4001/server shutdown', code: 4001, reason: 'server shutdown' }, { name: '4009/server shutdown', code: 4009, reason: 'server shutdown' }, { name: '4009/heartbeat timeout', code: 4009, reason: 'heartbeat timeout' }, { name: '1006/network drop', code: 1006, reason: '' }, ].map(row => ({ name: row.name, run: async () => { try { const sockets: FakeWebSocket[] = [] const cfg = config() const server = new HostServerConnection( // Host reconnect config here is initial 100ms / max 400ms; every // close now draws from the full [0, maxDelayMs] window, so the same // 0.9 draw waits 360ms regardless of the close reason. { ...cfg, forceRelay: false, reconnect: { ...cfg.reconnect, enabled: true, initialDelayMs: 100, maxDelayMs: 400, jitter: 0 } }, { schemaVersion: 1, deviceId: 'host-shutdown', name: 'Host', fingerprint: 'HOST', ...generateKeyPair() }, { trustedPeer: vi.fn() } as unknown as IdentityStore, { baseUrl: 'https://dsh.r2049.cn', authenticate: vi.fn(async () => ({ accessToken: 'access-token' })) } as unknown as HostServerApi, { close: vi.fn(async () => undefined) } as unknown as ConnectionController, logger(), () => { const socket = new FakeWebSocket(); sockets.push(socket); return socket }, async () => undefined, ) const random = vi.spyOn(Math, 'random') random.mockReturnValue(0.9) try { server.start() await flush() sockets[0]!.open() sockets[0]!.receive(createControlFrame('hello.ack', helloAck('control-shutdown'))) await vi.waitFor(() => expect(server.isOnline()).toBe(true)) sockets[0]!.close(row.code, row.reason) // The close handler runs on a later turn; wait for the backoff draw, // then assert no socket was created ahead of its timer. await vi.waitFor(() => expect(random).toHaveBeenCalled()) expect(sockets).toHaveLength(1) await new Promise(resolve => setTimeout(resolve, 200)) // 0.9 x 400ms = 360ms: still waiting at 200ms, connected by ~400ms. expect(sockets).toHaveLength(1) await vi.waitFor(() => expect(sockets).toHaveLength(2), { timeout: 2_000 }) expect(server.isOnline()).toBe(false) } finally { await server.stop() } } finally { vi.useRealTimers() vi.restoreAllMocks() vi.unstubAllGlobals() } } }))) }) it('closes retained tunnels and stops retrying when the Server rejects the protocol version', async () => { vi.useFakeTimers() vi.spyOn(Math, 'random').mockReturnValue(1) const sockets: FakeWebSocket[] = [] const rtc = { close: vi.fn(async () => undefined) } const channel = { close: vi.fn(async () => undefined) } const cfg = config() const server = new HostServerConnection( { ...cfg, forceRelay: false, reconnect: { ...cfg.reconnect, enabled: true } }, { schemaVersion: 1, deviceId: 'host-rtc', name: 'Host', fingerprint: 'HOST', ...generateKeyPair() }, { trustedPeer: vi.fn() } as unknown as IdentityStore, { baseUrl: 'https://dsh.r2049.cn', authenticate: vi.fn(async () => ({ accessToken: 'access-token' })) } as unknown as HostServerApi, { close: vi.fn(async () => undefined) } as unknown as ConnectionController, logger(), () => { const socket = new FakeWebSocket(); sockets.push(socket); return socket }, async () => undefined, ) const requests: Array<{ connectionId: string; requestId: string; ticket: string }> = [] const lease = new ControlLease('connection-rtc', 'ticket', payload => { requests.push(payload) }, () => {}) lease.start() lease.acknowledge({ ...requests[0]!, ticket: 'confirmed', leaseMs: 300_000 }) try { server.start() await vi.advanceTimersByTimeAsync(0) sockets[0]!.open() sockets[0]!.receive(createControlFrame('hello.ack', { ...helloAck('control-rtc'), capabilities: ['transport.p2p', 'transport.webrtc.resume.v1'] })) await vi.advanceTimersByTimeAsync(0) expect(server.isOnline()).toBe(true) const internals = server as unknown as { tunnels: Map } internals.tunnels.set('connection-rtc', { connectionId: 'connection-rtc', transport: 'p2p', rtc, channel, lease }) sockets[0]!.close(1012, 'Server restart') // Exercise the maximum jitter delay without racing a wall-clock timeout. await vi.advanceTimersByTimeAsync(cfg.reconnect.maxDelayMs - 1) expect(sockets).toHaveLength(1) await vi.advanceTimersByTimeAsync(1) expect(sockets).toHaveLength(2) sockets[1]!.open() sockets[1]!.close(4011, 'unsupported protocol version') await vi.advanceTimersByTimeAsync(0) expect(channel.close).toHaveBeenCalledOnce() expect(rtc.close).toHaveBeenCalledOnce() expect(internals.tunnels.size).toBe(0) expect(server.lastError()).toBe('UNSUPPORTED_VERSION') await vi.advanceTimersByTimeAsync(cfg.reconnect.maxDelayMs * 2) expect(sockets).toHaveLength(2) } finally { try { await server.stop(); lease.stop() } finally { vi.useRealTimers(); vi.restoreAllMocks() } } }) it('keeps an authenticated Relay fallback when the parallel WebRTC negotiation later fails', async () => { const keys = generateKeyPair(new Uint8Array(32).fill(16)) const closeConnection = vi.fn(async () => true) const rtc = { close: vi.fn(async () => undefined) } const tunnel = { connectionId: 'connection-negotiating', membershipId: 'membership-negotiating', peer: { deviceId: 'client-negotiating' }, noise: { destroy: vi.fn() }, transport: 'relay', rtc, channel: {}, } const server = new HostServerConnection( config(), { schemaVersion: 1, deviceId: 'host-negotiating', name: 'Host', fingerprint: 'HOST', ...keys }, { trustedPeer: vi.fn() } as unknown as IdentityStore, { baseUrl: 'https://dsh.r2049.cn' } as HostServerApi, { closeConnection } as unknown as ConnectionController, logger(), () => new FakeWebSocket(), ) const internals = server as unknown as { tunnels: Map handleRtcFailed(tunnel: unknown, rtc: unknown, error: Error): Promise } internals.tunnels.set(tunnel.connectionId, tunnel) await internals.handleRtcFailed(tunnel, rtc, new Error('negotiation failed')) expect(tunnel.transport).toBe('relay') expect(tunnel.rtc).toBeUndefined() expect(rtc.close).toHaveBeenCalledOnce() expect(closeConnection).not.toHaveBeenCalled() expect(internals.tunnels.get(tunnel.connectionId)).toBe(tunnel) expect(tunnel.channel).toEqual({}) }) it('binds Noise replies to WebRTC when Server forwarding delivers the handshake before P2P selection', async () => { const hostKeys = generateKeyPair(new Uint8Array(32).fill(17)) const clientKeys = generateKeyPair(new Uint8Array(32).fill(18)) const socket = new FakeWebSocket() socket.open() let accepted: AuthenticatedPeerChannel | undefined const connections = { accept: vi.fn(async (channel: AuthenticatedPeerChannel) => { accepted = channel }), } as unknown as ConnectionController const server = new HostServerConnection( { ...config(), forceRelay: false }, { schemaVersion: 1, deviceId: 'host-race', name: 'Host', fingerprint: 'HOST', ...hostKeys }, {} as IdentityStore, {} as HostServerApi, connections, logger(), () => socket, ) const rtcSend = vi.fn(async (_ciphertext: Uint8Array) => undefined) const rtc = { send: rtcSend, close: vi.fn(async () => undefined), selectedPathMode: vi.fn(() => 'LAN' as const), } const tunnel = { connectionId: 'connection-race', membershipId: 'membership-race', peer: { deviceId: 'client-race', name: 'Client', platform: 'linux', publicKey: clientKeys.publicKey, fingerprint: 'CLIENT', trustedAt: 1, membershipId: 'membership-race', }, preferredTransports: ['lan', 'p2p', 'turn', 'relay'], noise: new NoiseIkSession({ role: 'responder', localPrivateKey: hostKeys.privateKey, localPublicKey: hostKeys.publicKey, remotePublicKey: clientKeys.publicKey, prologue: createNoisePrologue('connection-race', 'host-race', 'client-race'), }), transport: 'negotiating', rtc, } const internals = server as unknown as { socket: FakeWebSocket negotiatedCapabilities: string[] tunnels: Map handleTransportSelected(payload: unknown): Promise handleHandshake(payload: unknown): Promise } internals.socket = socket internals.negotiatedCapabilities = ['transport.lan', 'transport.p2p', 'transport.turn', 'transport.relay'] internals.tunnels.set(tunnel.connectionId, tunnel) const clientNoise = new NoiseIkSession({ role: 'initiator', localPrivateKey: clientKeys.privateKey, localPublicKey: clientKeys.publicKey, remotePublicKey: hostKeys.publicKey, prologue: createNoisePrologue('connection-race', 'host-race', 'client-race'), }) await internals.handleHandshake({ connectionId: tunnel.connectionId, targetDeviceId: 'host-race', step: 1, data: toBase64Url(clientNoise.writeHandshake()), }) expect(accepted).toBeUndefined() expect(socket.sent).toHaveLength(0) await internals.handleTransportSelected({ connectionId: tunnel.connectionId, targetDeviceId: 'host-race', transport: 'lan', }) expect(tunnel).toMatchObject({ transport: 'lan', transportMode: 'LAN' }) const handshakeReply = socket.sent.map(frame => JSON.parse(frame)) .find(frame => frame.type === 'secure.handshake') clientNoise.readHandshake(fromBase64UrlForTest(handshakeReply.payload.data)) const response = createRpcRequest('harness.transport.describe', {}) await accepted!.send(response) expect(accepted?.mode).toBe('LAN') expect(rtcSend).toHaveBeenCalledOnce() expect(socket.sent.map(frame => JSON.parse(frame)).some(frame => frame.type === 'relay')).toBe(false) expect(decodeMessage(clientNoise.decrypt(rtcSend.mock.calls[0]![0]))).toEqual(response) }) it('downgrades a selected LAN path for an older Server without transport.lan', () => { const server = new HostServerConnection( config(), {} as HostIdentity, {} as IdentityStore, {} as HostServerApi, {} as ConnectionController, logger(), ) const socket = new FakeWebSocket() const rtc = { selectedPathMode: vi.fn(() => 'LAN' as const), diagnostics: vi.fn(() => undefined), } const tunnel = { connectionId: 'connection-lan-compat', peer: { deviceId: 'client-1' }, noise: { destroy: vi.fn() }, rtc, transport: 'negotiating', } const internals = server as unknown as { socket: FakeWebSocket negotiatedCapabilities: string[] tunnels: Map handleRtcOpened(value: unknown, transport: 'lan' | 'p2p' | 'turn'): void } internals.socket = socket socket.open() internals.negotiatedCapabilities = ['transport.p2p', 'transport.relay'] internals.tunnels.set(tunnel.connectionId, tunnel) internals.handleRtcOpened(tunnel, 'lan') expect(tunnel).toMatchObject({ transport: 'p2p' }) expect(socket.sent.map(frame => JSON.parse(frame))).toContainEqual(expect.objectContaining({ type: 'transport.selected', payload: expect.objectContaining({ transport: 'p2p' }), })) }) it('rejects selected transports outside negotiated capabilities', async () => { const rows = [ { negotiated: 'transport.turn', selected: 'p2p' as const, relay: true }, { negotiated: 'transport.p2p', selected: 'turn' as const, relay: false }, ] as const await runScenarios( rows.map((row, index) => { const { negotiated, selected, relay } = row return { name: scenarioName('rejects $selected when only $negotiated was negotiated', row, index), run: async () => { const server = new HostServerConnection( config(), {} as HostIdentity, {} as IdentityStore, {} as HostServerApi, {} as ConnectionController, logger(), ) const rtc = { close: vi.fn(async () => undefined), diagnostics: vi.fn(() => undefined), } const tunnel = { connectionId: 'connection-1', peer: { deviceId: 'client-1' }, noise: { destroy: vi.fn() }, rtc, transport: 'negotiating', } const internals = server as unknown as { negotiatedCapabilities: string[] tunnels: Map handleRtcOpened(value: unknown, transport: 'lan' | 'p2p' | 'turn'): void } internals.negotiatedCapabilities = relay ? [negotiated, 'transport.relay'] : [negotiated] internals.tunnels.set(tunnel.connectionId, tunnel) internals.handleRtcOpened(tunnel, selected) await flush() expect(rtc.close).toHaveBeenCalledOnce() if (relay) { expect(tunnel).toMatchObject({ transport: 'relay', rtc: undefined }) } else { expect(internals.tunnels.has(tunnel.connectionId)).toBe(false) expect(tunnel.noise.destroy).toHaveBeenCalledOnce() } }, } }), ) }) }) function helloAck(connectionSessionId: string) { return { protocol: 1, serverVersion: '0.1.0', connectionSessionId, heartbeatIntervalMs: 25_000, maxControlFrameBytes: 65_536, maxRelayFrameBytes: 1_048_576, } } function config(): ResolvedConfig { return { terminal: { enabled: false }, httpServerAllowlist: [], sidebar: { entry: 'standard' }, loopback: { ports: [] }, enabled: true, role: 'host', serverUrl: 'https://dsh.r2049.cn', 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 } function fromBase64UrlForTest(value: string): Uint8Array { return new Uint8Array(Buffer.from(value.replaceAll('-', '+').replaceAll('_', '/'), 'base64')) } async function flush(): Promise { await new Promise(resolve => setTimeout(resolve, 0)) } describe('pinned peer identity rotation', () => { const OLD_KEY = generateKeyPair(new Uint8Array(32).fill(61)).publicKey const NEW_KEY = generateKeyPair(new Uint8Array(32).fill(62)).publicKey const stalePin: TrustedPeer = { deviceId: 'client-1', name: 'Phone', platform: 'android', publicKey: OLD_KEY, fingerprint: 'STALE', trustedAt: 1, membershipId: 'membership-1', } async function rotationHarness(opts: { rotate: boolean; descriptorMembershipId?: string }) { const peer = { ...stalePin, publicKey: NEW_KEY } const socket = new FakeWebSocket() const api = { baseUrl: 'https://dsh.r2049.cn', authenticate: vi.fn(async () => ({ accessToken: 'access-token-value' })), refreshCredentials: vi.fn(), deviceFor: vi.fn(async () => ({ deviceId: peer.deviceId, name: peer.name, role: 'client', platform: peer.platform, identityKey: peer.publicKey, membershipId: opts.descriptorMembershipId ?? peer.membershipId!, })), } as unknown as HostServerApi const trustPeer = vi.fn(async (input: Omit) => ({ ...input, fingerprint: 'ROTATED', trustedAt: 2, })) const connections = { accept: vi.fn(async () => undefined), closeConnection: vi.fn(async () => undefined), close: vi.fn(async () => undefined), } as unknown as ConnectionController const identity = { schemaVersion: 1, deviceId: 'host-1', name: 'Host', fingerprint: 'HOST', ...generateKeyPair(new Uint8Array(32).fill(51)) } as unknown as HostIdentity const resolvedConfig = { ...config(), rotatePinnedPeerKey: opts.rotate } as ResolvedConfig const server = new HostServerConnection( resolvedConfig, identity, { trustedPeer: vi.fn(() => stalePin), trustPeer } as unknown as IdentityStore, api, connections, logger(), () => socket, undefined, () => ['harness.api.v1'], '0.1.0-rc.8', ) server.start() await flush() socket.open() await flush() socket.receive(createControlFrame('hello.ack', { protocol: 1, serverVersion: '0.1.0', connectionSessionId: 'control-1', heartbeatIntervalMs: 25_000, maxControlFrameBytes: 65_536, maxRelayFrameBytes: 1_048_576, capabilities: ['transport.relay'], })) await flush() socket.receive(createControlFrame('connect.incoming', { connectionId: 'connection-rotation', clientDeviceId: 'client-1', clientIdentityKey: NEW_KEY, authorization: 'account', preferredTransports: ['relay'], })) await flush() const types = socket.sent.map(frame => (JSON.parse(frame) as { type?: string }).type) return { trustPeer, types } } it('rejects a stale pinned peer key by default', async () => { const { trustPeer, types } = await rotationHarness({ rotate: false }) expect(types).toContain('connect.rejected') expect(types).not.toContain('connect.accepted') expect(trustPeer).not.toHaveBeenCalled() }) it('rotates the stale pin for the same membership when opted in', async () => { const { trustPeer, types } = await rotationHarness({ rotate: true }) expect(types).not.toContain('connect.rejected') expect(types).toContain('connect.accepted') expect(trustPeer).toHaveBeenCalledWith(expect.objectContaining({ deviceId: 'client-1', publicKey: NEW_KEY, membershipId: 'membership-1', })) }) it('still rejects cross-membership rotation attempts', async () => { const { trustPeer, types } = await rotationHarness({ rotate: true, descriptorMembershipId: 'membership-OTHER' }) expect(types).toContain('connect.rejected') expect(types).not.toContain('connect.accepted') expect(trustPeer).not.toHaveBeenCalled() }) }) it('reconnects after temporary 1013 handshakes without spending another credential refresh', async () => { await runScenarios([ { name: 'temporary failures before authentication recovery', closes: [1013, 1013, 4002] }, { name: 'temporary failures after authentication recovery', closes: [4002, 1013, 1013] }, { name: 'only temporary failures', closes: [1013, 1013] }, ].map(row => ({ name: row.name, run: async () => { const sockets: FakeWebSocket[] = [] let accessToken = 'old-access-value' const api = { baseUrl: 'https://dsh.r2049.cn', authenticate: vi.fn(async () => ({ accessToken })), refreshCredentials: vi.fn(async () => { accessToken = 'new-access-value' }), clearAuthorization: vi.fn(), } const server = new HostServerConnection( { ...config(), reconnect: { enabled: true, initialDelayMs: 1, maxDelayMs: 1, jitter: 0 } }, { schemaVersion: 1, deviceId: 'host-temporary', name: 'Host', fingerprint: 'HOST', ...generateKeyPair() }, {} as IdentityStore, api as unknown as HostServerApi, { close: vi.fn(async () => undefined) } as unknown as ConnectionController, logger(), () => { const socket = new FakeWebSocket(); sockets.push(socket); return socket }, ) try { server.start() for (const [index, code] of row.closes.entries()) { await vi.waitFor(() => expect(sockets).toHaveLength(index + 1)) sockets[index]!.open() sockets[index]!.close(code) } await vi.waitFor(() => expect(sockets).toHaveLength(row.closes.length + 1)) const last = sockets.at(-1)! last.open() expect(JSON.parse(last.sent[0]!).payload.accessToken).toBe(accessToken) last.receive(createControlFrame('hello.ack', helloAck('recovered-after-startup'))) await vi.waitFor(() => expect(server.isOnline()).toBe(true)) expect(api.refreshCredentials).toHaveBeenCalledTimes(row.closes.filter(code => code === 4002).length) expect(api.clearAuthorization).not.toHaveBeenCalled() expect(server.lastError()).toBeUndefined() } finally { await server.stop() } } }))) }) it('keeps reconnecting through non-protocol gateway 401 responses and becomes online after recovery', async () => { const directory = await mkdtemp(join(tmpdir(), 'dsh-connection-gateway-')) let server: HostServerConnection | undefined try { const identity: HostIdentity = { schemaVersion: 1, deviceId: 'host-gateway', name: 'Host', fingerprint: 'HOST', ...generateKeyPair(), } const store = new ServerCredentialStore(directory) const initial = await store.save({ serverUrl: 'https://dsh.r2049.cn', deviceId: identity.deviceId, authorizationMethod: 'account', accessToken: 'old-access-token-value', accessTokenExpiresAt: Date.now() - 1, refreshToken: 'old-refresh-token-value', refreshTokenExpiresAt: Date.now() + 86400000, }) const responses = [ new Response('gateway challenge', { status: 401 }), new Response('', { status: 401 }), new Response('{"detail":"gateway startup"}', { status: 401 }), new Response(JSON.stringify({ accessToken: 'recovered-access-token', accessTokenExpiresAt: Date.now() + 600000, refreshToken: 'recovered-refresh-token', refreshTokenExpiresAt: initial.refreshTokenExpiresAt, }), { status: 200 }), ] const fetcher = vi.fn(async () => { expect(await store.load('https://dsh.r2049.cn', identity.deviceId)).toEqual(initial) return responses.shift()! }) const api = new HostServerApi('https://dsh.r2049.cn', store, fetcher) const sockets: FakeWebSocket[] = [] const logs = logger() server = new HostServerConnection( { ...config(), reconnect: { enabled: true, initialDelayMs: 1, maxDelayMs: 1, jitter: 0 } }, identity, {} as IdentityStore, api, { close: vi.fn(async () => undefined) } as unknown as ConnectionController, logs, () => { const socket = new FakeWebSocket(); sockets.push(socket); return socket }, ) server.start() await vi.waitFor(() => expect(sockets).toHaveLength(1)) sockets[0]!.open() expect(JSON.parse(sockets[0]!.sent[0]!).payload.accessToken).toBe('recovered-access-token') sockets[0]!.receive(createControlFrame('hello.ack', helloAck('gateway-recovered'))) await vi.waitFor(() => expect(server!.isOnline()).toBe(true)) expect(fetcher).toHaveBeenCalledTimes(4) expect(responses).toHaveLength(0) expect(logs.warn).not.toHaveBeenCalledWith('server control connection failed', expect.objectContaining({ code: 'AUTH_INVALID' })) expect((await store.load('https://dsh.r2049.cn', identity.deviceId))?.refreshToken).toBe('recovered-refresh-token') } finally { await server?.stop() await rm(directory, { recursive: true, force: true }) } }) it('reconnects when the control WebSocket goes silent beyond 3x heartbeatIntervalMs, even on a half-open socket', async () => { vi.useFakeTimers() const sockets: FakeWebSocket[] = [] const logs = logger() const api = { baseUrl: 'https://dsh.r2049.cn', authenticate: vi.fn(async () => ({ accessToken: 'access-token' })), } as unknown as HostServerApi const server = new HostServerConnection( { ...config(), reconnect: { enabled: true, initialDelayMs: 10, maxDelayMs: 100, jitter: 0 } }, { schemaVersion: 1, deviceId: 'host-watchdog', name: 'Host', fingerprint: 'HOST', ...generateKeyPair() }, { trustedPeer: () => undefined } as unknown as IdentityStore, api, { close: vi.fn(async () => undefined) } as unknown as ConnectionController, logs, () => { const socket = new FakeWebSocket() // Simulate a half-open TCP socket where close() does not fire onclose on its own. socket.close = vi.fn(() => { socket.readyState = 2 }) sockets.push(socket) return socket }, ) try { server.start() await vi.advanceTimersByTimeAsync(0) expect(sockets).toHaveLength(1) sockets[0]!.open() sockets[0]!.receive(createControlFrame('hello.ack', helloAck('watchdog-1'))) await vi.advanceTimersByTimeAsync(0) expect(server.isOnline()).toBe(true) // Pings arriving inside the 75s window reset the silence watchdog. await vi.advanceTimersByTimeAsync(50_000) sockets[0]!.receive(createControlFrame('ping', { nonce: 'n-1' })) await vi.advanceTimersByTimeAsync(0) await vi.advanceTimersByTimeAsync(50_000) expect(server.isOnline()).toBe(true) expect(sockets).toHaveLength(1) // Silence reaching 75_000ms after the last frame triggers close + reconnect. await vi.advanceTimersByTimeAsync(25_000) expect(logs.warn).toHaveBeenCalledWith( 'server control heartbeat timeout; reconnecting', expect.objectContaining({ heartbeatIntervalMs: 25_000 }), ) expect(server.isOnline()).toBe(false) await vi.advanceTimersByTimeAsync(200) expect(sockets).toHaveLength(2) sockets[1]!.open() sockets[1]!.receive(createControlFrame('hello.ack', helloAck('watchdog-2'))) await vi.advanceTimersByTimeAsync(0) expect(server.isOnline()).toBe(true) } finally { await server.stop() expect(vi.getTimerCount()).toBe(0) vi.useRealTimers() vi.restoreAllMocks() } }) it('completes watchdog reconnect and stop even when an async control frame handler is stalled, and ignores late completion', async () => { vi.useFakeTimers() const sockets: FakeWebSocket[] = [] let resolveDeviceLookup: ((value: unknown) => void) | undefined const api = { baseUrl: 'https://dsh.r2049.cn', authenticate: vi.fn(async () => ({ accessToken: 'access-token' })), deviceFor: vi.fn(() => new Promise(resolve => { resolveDeviceLookup = resolve })), } as unknown as HostServerApi const server = new HostServerConnection( { ...config(), reconnect: { enabled: true, initialDelayMs: 10, maxDelayMs: 100, jitter: 0 } }, { schemaVersion: 1, deviceId: 'host-stalled', name: 'Host', fingerprint: 'HOST', ...generateKeyPair() }, { trustedPeer: () => undefined } as unknown as IdentityStore, api, { close: vi.fn(async () => undefined) } as unknown as ConnectionController, logger(), () => { const socket = new FakeWebSocket() socket.close = vi.fn(() => { socket.readyState = 2 }) sockets.push(socket) return socket }, ) try { server.start() await vi.advanceTimersByTimeAsync(0) sockets[0]!.open() sockets[0]!.receive(createControlFrame('hello.ack', helloAck('stalled-1'))) await vi.advanceTimersByTimeAsync(0) expect(server.isOnline()).toBe(true) // Start an async connect.incoming handler whose deviceFor lookup never resolves yet. const clientKeys = generateKeyPair() sockets[0]!.receive(createControlFrame('connect.incoming', { connectionId: 'conn-stalled-1', clientDeviceId: 'client-stalled-1', clientIdentityKey: clientKeys.publicKey, authorization: 'account', preferredTransports: ['relay'], })) await vi.advanceTimersByTimeAsync(0) expect(api.deviceFor).toHaveBeenCalledTimes(1) // Also simulate a lease callback setting readyState = 2 (CLOSING) without firing onclose. sockets[0]!.readyState = 2 // Watchdog expiry still settles the half-open/CLOSING socket and reconnects despite the stalled handler. await vi.advanceTimersByTimeAsync(75_000) expect(server.isOnline()).toBe(false) await vi.advanceTimersByTimeAsync(200) expect(sockets).toHaveLength(2) sockets[1]!.open() sockets[1]!.receive(createControlFrame('hello.ack', helloAck('stalled-2'))) await vi.advanceTimersByTimeAsync(0) expect(server.isOnline()).toBe(true) // Late resolution of the old socket's stalled deviceFor lookup must not send frames on sockets[1]. const sentBefore = sockets[1]!.sent.length resolveDeviceLookup?.({ deviceId: 'client-stalled-1', role: 'client', name: 'Client', platform: 'android', identityKey: clientKeys.publicKey, membershipId: 'membership-1', }) await vi.advanceTimersByTimeAsync(0) expect(sockets[1]!.sent).toHaveLength(sentBefore) expect(server.isOnline()).toBe(true) // Wire a real ControlLease onto an active tunnel and verify its heartbeat-expiry // callback path when socket.close() rejects non-WHATWG codes (like 1012) and // sets readyState = 2 (CLOSING) without emitting onclose. let closedCode: number | undefined const terminated = vi.fn() ;(sockets[1] as unknown as { terminate: () => void }).terminate = terminated sockets[1]!.close = vi.fn((code?: number) => { if (code !== undefined && code !== 1000 && (code < 3000 || code > 4999)) { throw new Error('InvalidAccessError: close code out of range') } closedCode = code sockets[1]!.readyState = 2 }) const hostKeys = (server as unknown as { identity: { privateKey: string; publicKey: string; deviceId: string } }).identity const responder = new NoiseIkSession({ role: 'responder', localPrivateKey: hostKeys.privateKey, localPublicKey: hostKeys.publicKey, remotePublicKey: clientKeys.publicKey, prologue: createNoisePrologue('conn-lease-1', hostKeys.deviceId, 'client-stalled-1'), }) const initiator = new NoiseIkSession({ role: 'initiator', localPrivateKey: clientKeys.privateKey, localPublicKey: clientKeys.publicKey, remotePublicKey: hostKeys.publicKey, prologue: createNoisePrologue('conn-lease-1', hostKeys.deviceId, 'client-stalled-1'), }) const internals = server as unknown as { lastActiveAt?: number negotiatedCapabilities: string[] tunnels: Map connections: { accept: ReturnType } completeHandshake(tunnel: unknown, payload: unknown): Promise } internals.connections.accept = vi.fn(async () => undefined) internals.negotiatedCapabilities = ['transport.relay', 'transport.webrtc.resume'] const leaseTunnel = { connectionId: 'conn-lease-1', membershipId: 'membership-1', peer: { deviceId: 'client-stalled-1', publicKey: clientKeys.publicKey }, noise: responder, rtc: { send: vi.fn(async () => undefined), close: vi.fn(async () => undefined) }, transport: 'p2p', recoveryTicket: 'lease-ticket-1', } internals.tunnels.set('conn-lease-1', leaseTunnel) await internals.completeHandshake(leaseTunnel, { connectionId: 'conn-lease-1', targetDeviceId: hostKeys.deviceId, step: 1, data: toBase64Url(initiator.writeHandshake()), }) expect(leaseTunnel).toHaveProperty('lease') internals.lastActiveAt = Date.now() - 80_000 ;(leaseTunnel as unknown as { lease: { tick(force?: boolean): void } }).lease.tick(true) await vi.advanceTimersByTimeAsync(0) expect(closedCode).toBe(4009) expect(terminated).toHaveBeenCalledTimes(1) expect(sockets[1]!.onopen).toBeNull() expect(sockets[1]!.onmessage).toBeNull() expect(sockets[1]!.onerror).toBeTypeOf('function') expect(server.isOnline()).toBe(false) await vi.advanceTimersByTimeAsync(200) expect(sockets).toHaveLength(3) sockets[2]!.open() sockets[2]!.receive(createControlFrame('hello.ack', helloAck('stalled-3'))) await vi.advanceTimersByTimeAsync(0) expect(server.isOnline()).toBe(true) initiator.destroy() } finally { await server.stop() expect(vi.getTimerCount()).toBe(0) vi.useRealTimers() vi.restoreAllMocks() } }) it('automatically recovers from a stalled CONNECTING upgrade or stalled 4002 credential refresh, and disposes late-opening abandoned sockets', async () => { vi.useFakeTimers() const sockets: FakeWebSocket[] = [] let resolveRefresh: (() => void) | undefined let resolveSlowLookup: ((value: unknown) => void) | undefined const api = { baseUrl: 'https://dsh.r2049.cn', authenticate: vi.fn(async () => ({ accessToken: 'access-token' })), refreshCredentials: vi.fn(() => new Promise(resolve => { resolveRefresh = resolve })), deviceFor: vi.fn(() => new Promise(resolve => { resolveSlowLookup = resolve })), } as unknown as HostServerApi const server = new HostServerConnection( { ...config(), reconnect: { enabled: true, initialDelayMs: 10, maxDelayMs: 100, jitter: 0 } }, { schemaVersion: 1, deviceId: 'host-cancel', name: 'Host', fingerprint: 'HOST', ...generateKeyPair() }, { trustedPeer: () => undefined, trustPeer: vi.fn(async (input: Record) => ({ ...input, fingerprint: 'CLIENT', trustedAt: 1 })), } as unknown as IdentityStore, api, { close: vi.fn(async () => undefined) } as unknown as ConnectionController, logger(), () => { const socket = new FakeWebSocket() if (sockets.length === 0) { // First socket remains stuck in CONNECTING (readyState 0) and throws on close() while CONNECTING, // but succeeds once readyState transitions to OPEN (1). const originalClose = socket.close.bind(socket) socket.close = vi.fn((code?: number, reason?: string) => { if (socket.readyState === 0) throw new Error('closing while CONNECTING') originalClose(code, reason) }) } sockets.push(socket) return socket }, ) try { server.start() await vi.advanceTimersByTimeAsync(0) expect(sockets).toHaveLength(1) // Without any manual reconnect(), the 30_000ms upgrade deadline automatically // abandons the stalled CONNECTING socket and opens a replacement socket. await vi.advanceTimersByTimeAsync(30_000) expect(sockets[0]!.onopen).toBeTypeOf('function') await vi.advanceTimersByTimeAsync(200) expect(sockets).toHaveLength(2) // Establish the second socket, then let the abandoned first socket finish opening: // the disposal onopen handler must immediately close sockets[0] (readyState -> 3) // and produce no sends, timers, or state changes on sockets[1]. sockets[1]!.open() sockets[1]!.receive(createControlFrame('hello.ack', helloAck('cancel-2'))) await vi.advanceTimersByTimeAsync(0) expect(server.isOnline()).toBe(true) const sentOnSecond = sockets[1]!.sent.length sockets[0]!.open() expect(sockets[0]!.readyState).toBe(3) expect(sockets[0]!.onopen).toBeNull() expect(sockets[1]!.sent).toHaveLength(sentOnSecond) // Close sockets[1] with 4002 so handleClose enters pending refreshCredentials. // Without calling reconnect(), the 15_000ms refresh timeout automatically settles // and reconnects onto sockets[2]. sockets[1]!.close(4002, 'expired token') await vi.advanceTimersByTimeAsync(60) expect(api.refreshCredentials).toHaveBeenCalledTimes(1) await vi.advanceTimersByTimeAsync(15_000) await vi.advanceTimersByTimeAsync(200) expect(sockets).toHaveLength(3) sockets[2]!.open() sockets[2]!.receive(createControlFrame('hello.ack', helloAck('cancel-3'))) await vi.advanceTimersByTimeAsync(0) expect(server.isOnline()).toBe(true) // Resolving the old refresh promise afterward must not mutate authRecoveryAttempted on the live connection. resolveRefresh?.() await vi.advanceTimersByTimeAsync(0) expect((server as unknown as { authRecoveryAttempted: boolean }).authRecoveryAttempted).toBe(false) // Verify that on a natural close, even if a preceding handler stays stalled beyond // the 50ms drain window, a queued terminal error (UNSUPPORTED_VERSION) is still // recorded and stops automatic retries. const clientKeys = generateKeyPair() sockets[2]!.receive(createControlFrame('connect.incoming', { connectionId: 'conn-drain-1', clientDeviceId: 'client-drain-1', clientIdentityKey: clientKeys.publicKey, authorization: 'account', preferredTransports: ['relay'], })) sockets[2]!.receive(createControlFrame('error', { code: 'UNSUPPORTED_VERSION', message: 'unsupported version', retryable: false, })) sockets[2]!.close(1000, 'closing after terminal error') await vi.advanceTimersByTimeAsync(200) expect(server.lastError()).toBe('UNSUPPORTED_VERSION') expect(server.isReconnecting()).toBe(false) expect(sockets).toHaveLength(3) resolveSlowLookup?.({ deviceId: 'client-drain-1', role: 'client', name: 'Client', platform: 'android', identityKey: clientKeys.publicKey, membershipId: 'membership-1', }) await vi.advanceTimersByTimeAsync(0) } finally { await server.stop() expect(vi.getTimerCount()).toBe(0) vi.useRealTimers() vi.restoreAllMocks() } }) it('stops sending remaining fragments when a relay tunnel is dropped mid-send', async () => { const hostKeys = generateKeyPair(new Uint8Array(32).fill(71)) const clientKeys = generateKeyPair(new Uint8Array(32).fill(72)) const socket = new FakeWebSocket() socket.open() let accepted: AuthenticatedPeerChannel | undefined const server = new HostServerConnection( config(), { schemaVersion: 1, deviceId: 'host-frag', name: 'Host', fingerprint: 'HOST', ...hostKeys }, { trustedPeer: () => undefined } as unknown as IdentityStore, { baseUrl: 'https://dsh.r2049.cn' } as HostServerApi, { accept: vi.fn(async (ch: AuthenticatedPeerChannel) => { accepted = ch }), closeConnection: vi.fn(async () => false), close: vi.fn(async () => undefined), } as unknown as ConnectionController, logger(), () => socket, ) const noise = new NoiseIkSession({ role: 'responder', localPrivateKey: hostKeys.privateKey, localPublicKey: hostKeys.publicKey, remotePublicKey: clientKeys.publicKey, prologue: createNoisePrologue('connection-frag', 'host-frag', 'client-frag'), }) const initiator = new NoiseIkSession({ role: 'initiator', localPrivateKey: clientKeys.privateKey, localPublicKey: clientKeys.publicKey, remotePublicKey: hostKeys.publicKey, prologue: createNoisePrologue('connection-frag', 'host-frag', 'client-frag'), }) const tunnel = { connectionId: 'connection-frag', membershipId: 'membership-frag', peer: { deviceId: 'client-frag', publicKey: clientKeys.publicKey }, noise, transport: 'relay', } const internals = server as unknown as { socket: FakeWebSocket tunnels: Map completeHandshake(tunnel: unknown, payload: unknown): Promise dropTunnel(id: string, code?: string): Promise } internals.socket = socket internals.tunnels.set('connection-frag', tunnel) let relaySent = 0 socket.onSend = frame => { if ((frame as { type?: unknown }).type === 'relay') { relaySent += 1 if (relaySent === 1) void internals.dropTunnel('connection-frag', 'CONNECTION_FAILED') } } try { await internals.completeHandshake(tunnel, { connectionId: 'connection-frag', targetDeviceId: 'host-frag', step: 1, data: toBase64Url(initiator.writeHandshake()), }) const largePayload = 'x'.repeat(200_000) await expect( accepted!.send(createRpcRequest('harness.api.call', { method: 'host.describe', rpcId: 'big-1', payload: { text: largePayload } })), ).rejects.toThrow(/Relay tunnel closed|Secure channel closed/) expect(relaySent).toBe(1) } finally { initiator.destroy() await server.stop() } })