ds-harness-remote-fast/packages/plugin/tests/server-connection.test.ts

1967 lines
84 KiB
TypeScript

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<TrustedPeer, 'fingerprint' | 'trustedAt'>) => ({
...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<TrustedPeer, 'fingerprint' | 'trustedAt'>) => ({ ...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<string, unknown>; completeHandshake(tunnel: unknown, payload: unknown): Promise<void>; dropTunnel(id: string): Promise<void> }
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<string, unknown>
handleRtcFailed(tunnel: unknown, rtc: unknown, error: Error): Promise<void>
}
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<string, unknown> }
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<string, unknown> }
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<string, unknown> }
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<string, unknown> }
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<string, unknown>
handleRtcFailed(tunnel: unknown, rtc: unknown, error: Error): Promise<void>
}
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<string, unknown>
handleTransportSelected(payload: unknown): Promise<void>
handleHandshake(payload: unknown): Promise<void>
}
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<string, unknown>
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<string, unknown>
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<void> { 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<TrustedPeer, 'fingerprint' | 'trustedAt'>) => ({
...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('<html>gateway challenge</html>', { 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<string, unknown>
connections: { accept: ReturnType<typeof vi.fn> }
completeHandshake(tunnel: unknown, payload: unknown): Promise<void>
}
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<void>(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<string, unknown>) => ({ ...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<string, unknown>
completeHandshake(tunnel: unknown, payload: unknown): Promise<void>
dropTunnel(id: string, code?: string): Promise<void>
}
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()
}
})