ds-harness-remote-fast/packages/plugin/tests/host-websocket-origin.test.ts

555 lines
20 KiB
TypeScript

import { createServer, type Server } from 'node:http'
import { generateKeyPair } from '@dsh-remote/crypto'
import {
createControlFrame,
createRelayDataFrame,
decodeControlFrame,
decodeRelayDataFrame,
encodeRelayDataFrame,
} from '@dsh-remote/protocol'
import { afterEach, describe, expect, it, vi } from 'vitest'
import { WebSocket as NodeWebSocket, WebSocketServer } from 'ws'
import type { ConnectionController } from '../src/connection-controller.js'
import type { ResolvedConfig } from '../src/config.js'
import type { HostIdentity, IdentityStore } from '../src/identity-store.js'
import type { SafeLogger } from '../src/logging.js'
import { createNodeWebSocket } from '../src/node-websocket.js'
import type { HostServerApi } from '../src/server-api.js'
import type { WebSocketFactory } from '../src/server-connection.js'
// Opt in to exercising the committed release artifact, including its bundled ws.
const releaseBundle = process.env.DSH_TEST_RELEASE_BUNDLE === '1'
const { HostServerConnection } = await (releaseBundle
? import(/* @vite-ignore */ new URL('../dist/index.js', import.meta.url).href)
: import('../src/server-connection.js')) as typeof import('../src/server-connection.js')
/**
* #353 Host-only coverage: real bundled `ws` + a local Server that mirrors
* Gateway Origin checks (reject Origin ≠ DSH_SERVER_PUBLIC_URL).
*
* AdaptiveTransport / RelayTransport / browser globals are intentionally
* unchanged; a regression case below asserts the browser default still uses
* globalThis.WebSocket.
*/
const PUBLIC_ORIGIN = 'http://10.10.10.30:8081'
const PAGE_ORIGIN = 'http://127.0.0.1:3080'
interface UpgradeRecord {
origin: string | undefined
url: string
}
afterEach(() => {
vi.useRealTimers()
vi.restoreAllMocks()
})
describe('Host WebSocket Origin gate (#353)', () => {
it.runIf(releaseBundle)('times out a pending release-bundle ws upgrade and stops cleanly', async () => {
const gate = await listenGate({ holdUpgrade: true })
const unhandled = trackUnhandled()
const host = hostConnection(gate.baseUrl)
try {
host.server.start()
await vi.waitFor(() => expect(gate.upgrades.length).toBe(1))
await vi.waitFor(() => expect(host.server.lastError()).toBe('CONNECTION_FAILED'), { timeout: 35_000, interval: 100 })
await host.server.stop()
await settle()
expect(host.server.isOnline()).toBe(false)
expect(host.server.isReconnecting()).toBe(false)
unhandled.expectClean()
} finally {
await host.server.stop()
unhandled.stop()
await gate.close()
}
}, 40_000)
it.runIf(releaseBundle)('times out a release-bundle socket without hello.ack and closes it', async () => {
const gate = await listenGate({ noHello: true })
const unhandled = trackUnhandled()
const host = hostConnection(gate.baseUrl)
try {
host.server.start()
await vi.waitFor(() => expect(gate.controlSockets.length).toBe(1))
await vi.waitFor(() => expect(host.server.lastError()).toBe('CONNECTION_FAILED'), { timeout: 15_000, interval: 100 })
await host.server.stop()
await settle()
expect(openCount(gate.controlSockets)).toBe(0)
unhandled.expectClean()
} finally {
await host.server.stop()
unhandled.stop()
await gate.close()
}
}, 20_000)
it('createNodeWebSocket omits Origin and is accepted when the public URL differs from the page Origin', async () => {
const gate = await listenGate()
const unhandled = trackUnhandled()
try {
const socket = createNodeWebSocket(`${gate.baseUrl.replace('http', 'ws')}/ws/v1/connect`)
await onceOpen(socket)
socket.close(1000, 'done')
await onceClose(socket)
expect(gate.upgrades.map(entry => entry.origin)).toEqual([undefined])
unhandled.expectClean()
} finally {
unhandled.stop()
await gate.close()
}
})
it('rejects an Origin-bearing upgrade the way a self-hosted Server rejects dsh web globals', async () => {
const gate = await listenGate()
const unhandled = trackUnhandled()
try {
const socket = new NodeWebSocket(`${gate.baseUrl.replace('http', 'ws')}/ws/v1/connect`, {
origin: PAGE_ORIGIN,
perMessageDeflate: false,
})
await Promise.race([onceClose(socket), onceError(socket)])
expect(gate.upgrades.map(entry => entry.origin)).toEqual([PAGE_ORIGIN])
expect(gate.controlSockets).toHaveLength(0)
unhandled.expectClean()
} finally {
unhandled.stop()
await gate.close()
}
})
it('HostServerConnection default factory brings the Host online without Origin on control and Relay data', async () => {
const gate = await listenGate({ relayAttach: true })
const unhandled = trackUnhandled()
const peerKey = generateKeyPair(new Uint8Array(32).fill(71)).publicKey
const host = hostConnection(gate.baseUrl)
try {
host.server.start()
await vi.waitFor(() => expect(host.server.isOnline()).toBe(true))
expect(gate.upgrades.every(entry => entry.origin === undefined)).toBe(true)
expect(gate.upgrades.some(entry => entry.url === '/ws/v1/connect')).toBe(true)
const control = gate.controlSockets[0]!
control.send(JSON.stringify(createControlFrame('connect.incoming', {
connectionId: 'connection-relay',
clientDeviceId: 'client-1',
clientIdentityKey: peerKey,
authorization: 'account',
preferredTransports: ['relay'],
relayEndpoint: gate.relayUrl,
relayTicket: 'dshrt.host-ticket',
relayNodeId: 'relay-1',
relayEpoch: 4,
})))
await vi.waitFor(() => expect(gate.hostFrames.some(frame => frame.type === 'connect.accepted')).toBe(true))
control.send(JSON.stringify(createControlFrame('transport.selected', {
connectionId: 'connection-relay',
targetDeviceId: host.identity.deviceId,
transport: 'relay',
})))
await vi.waitFor(() => expect(gate.dataSockets.length).toBeGreaterThanOrEqual(1))
expect(gate.upgrades.filter(entry => entry.url.startsWith('/relay')).every(entry => entry.origin === undefined)).toBe(true)
await vi.waitFor(() => expect(gate.dataSockets.some(socket => socket.readyState === NodeWebSocket.OPEN)).toBe(true))
unhandled.expectClean()
} finally {
await host.server.stop()
await settle()
expect(openCount(gate.controlSockets)).toBe(0)
expect(openCount(gate.dataSockets)).toBe(0)
unhandled.expectClean()
unhandled.stop()
await gate.close()
}
})
it('reconnects control after Server drop without Origin and without duplicate live sockets', async () => {
vi.spyOn(Math, 'random').mockReturnValue(0)
const gate = await listenGate()
const unhandled = trackUnhandled()
const host = hostConnection(gate.baseUrl, {
enabled: true, initialDelayMs: 10, maxDelayMs: 20, jitter: 0,
})
try {
host.server.start()
await vi.waitFor(() => expect(host.server.isOnline()).toBe(true))
const before = gate.upgrades.length
const firstControl = gate.controlSockets[0]!
gate.dropControl()
await vi.waitFor(() => expect(gate.upgrades.length).toBeGreaterThan(before), { timeout: 5_000 })
await vi.waitFor(() => expect(host.server.isOnline()).toBe(true), { timeout: 5_000 })
expect(gate.upgrades.every(entry => entry.origin === undefined)).toBe(true)
expect(openCount(gate.controlSockets)).toBe(1)
expect(gate.controlSockets.some(socket => socket !== firstControl && socket.readyState === NodeWebSocket.OPEN)).toBe(true)
unhandled.expectClean()
} finally {
await host.server.stop()
await settle()
expect(openCount(gate.controlSockets)).toBe(0)
unhandled.expectClean()
unhandled.stop()
await gate.close()
}
})
it('recovers after abrupt control reset without Origin and without accumulating open sockets', async () => {
vi.spyOn(Math, 'random').mockReturnValue(0)
const gate = await listenGate()
const unhandled = trackUnhandled()
const host = hostConnection(gate.baseUrl, {
enabled: true, initialDelayMs: 10, maxDelayMs: 20, jitter: 0,
})
try {
host.server.start()
await vi.waitFor(() => expect(host.server.isOnline()).toBe(true))
const before = gate.upgrades.length
const live = gate.controlSockets.find(socket => socket.readyState === NodeWebSocket.OPEN)
expect(live).toBeDefined()
live!.terminate()
await vi.waitFor(() => expect(gate.upgrades.length).toBeGreaterThan(before), { timeout: 5_000 })
await vi.waitFor(() => expect(host.server.isOnline()).toBe(true), { timeout: 5_000 })
expect(gate.upgrades.every(entry => entry.origin === undefined)).toBe(true)
expect(openCount(gate.controlSockets)).toBe(1)
unhandled.expectClean()
} finally {
await host.server.stop()
await settle()
expect(openCount(gate.controlSockets)).toBe(0)
unhandled.expectClean()
unhandled.stop()
await gate.close()
}
})
it('stops cleanly while online and clears sockets and timers', async () => {
const gate = await listenGate()
const unhandled = trackUnhandled()
const host = hostConnection(gate.baseUrl, {
enabled: true, initialDelayMs: 10, maxDelayMs: 20, jitter: 0,
})
try {
host.server.start()
await vi.waitFor(() => expect(host.server.isOnline()).toBe(true))
await host.server.stop()
await settle()
expect(host.server.isOnline()).toBe(false)
expect(host.server.isReconnecting()).toBe(false)
expect(openCount(gate.controlSockets)).toBe(0)
unhandled.expectClean()
} finally {
unhandled.stop()
await gate.close()
}
})
it('cancels a pending upgrade without unhandled errors or leaked sockets', async () => {
const gate = await listenGate({ holdUpgrade: true })
const unhandled = trackUnhandled()
const host = hostConnection(gate.baseUrl)
try {
host.server.start()
await vi.waitFor(() => expect(gate.upgrades.length).toBeGreaterThanOrEqual(1), { timeout: 5_000 })
expect(host.server.isOnline()).toBe(false)
await host.server.stop()
await settle()
expect(host.server.isOnline()).toBe(false)
expect(host.server.isReconnecting()).toBe(false)
expect(openCount(gate.controlSockets)).toBe(0)
unhandled.expectClean()
} finally {
gate.releaseHeld()
unhandled.stop()
await gate.close()
}
})
it('handles Origin-rejected upgrades without unhandled errors and without staying online', async () => {
const gate = await listenGate()
const unhandled = trackUnhandled()
const withPageOrigin: WebSocketFactory = url => new NodeWebSocket(url, {
origin: PAGE_ORIGIN,
perMessageDeflate: false,
}) as unknown as ReturnType<WebSocketFactory>
const host = hostConnection(gate.baseUrl, undefined, withPageOrigin)
try {
host.server.start()
await settle(300)
expect(host.server.isOnline()).toBe(false)
expect(gate.upgrades.some(entry => entry.origin === PAGE_ORIGIN)).toBe(true)
expect(gate.controlSockets).toHaveLength(0)
await host.server.stop()
await settle()
unhandled.expectClean()
} finally {
unhandled.stop()
await gate.close()
}
})
it('survives repeated reconnect cycles without duplicate live control sockets', async () => {
vi.spyOn(Math, 'random').mockReturnValue(0)
const gate = await listenGate()
const unhandled = trackUnhandled()
const host = hostConnection(gate.baseUrl, {
enabled: true, initialDelayMs: 10, maxDelayMs: 20, jitter: 0,
})
try {
host.server.start()
await vi.waitFor(() => expect(host.server.isOnline()).toBe(true))
for (let cycle = 0; cycle < 3; cycle++) {
const before = gate.upgrades.length
gate.dropControl()
await vi.waitFor(() => expect(gate.upgrades.length).toBeGreaterThan(before), { timeout: 5_000 })
await vi.waitFor(() => expect(host.server.isOnline()).toBe(true), { timeout: 5_000 })
expect(openCount(gate.controlSockets)).toBe(1)
}
expect(gate.upgrades.every(entry => entry.origin === undefined)).toBe(true)
unhandled.expectClean()
} finally {
await host.server.stop()
await settle()
expect(openCount(gate.controlSockets)).toBe(0)
unhandled.expectClean()
unhandled.stop()
await gate.close()
}
})
})
describe('browser / shared transport defaults (regression)', () => {
it('AdaptiveTransport still constructs sockets via the global WebSocket by default', async () => {
const { AdaptiveTransport } = await import('@dsh-remote/webrtc')
const GlobalWebSocket = vi.fn(function Fake(this: { url: string }, url: string) {
this.url = url
return {
url,
readyState: 0,
binaryType: '',
onopen: null,
onmessage: null,
onerror: null,
onclose: null,
send: vi.fn(),
close: vi.fn(),
}
})
vi.stubGlobal('WebSocket', Object.assign(GlobalWebSocket, { OPEN: 1, CONNECTING: 0, CLOSING: 2, CLOSED: 3 }))
const transport = new AdaptiveTransport('wss://remote.example/ws/v1/connect', {
role: 'client',
deviceId: 'client-1',
accessToken: 'token',
targetDeviceId: 'host-1',
forceRelay: true,
})
const connecting = transport.connect()
expect(GlobalWebSocket).toHaveBeenCalledWith('wss://remote.example/ws/v1/connect')
await transport.close()
await expect(connecting).rejects.toThrow()
})
})
function hostConnection(
baseUrl: string,
reconnect?: ResolvedConfig['reconnect'],
createWebSocket?: WebSocketFactory,
) {
const identity: HostIdentity = {
schemaVersion: 1,
deviceId: 'host-origin',
name: 'Host',
fingerprint: 'HOST',
...generateKeyPair(new Uint8Array(32).fill(17)),
}
const api = {
baseUrl,
authenticate: vi.fn(async () => ({ accessToken: 'access-token' })),
deviceFor: vi.fn(async () => ({
deviceId: 'client-1',
name: 'Phone',
role: 'client',
platform: 'android',
identityKey: generateKeyPair(new Uint8Array(32).fill(71)).publicKey,
membershipId: 'membership-1',
})),
} as unknown as HostServerApi
const server = new HostServerConnection(
{
terminal: { enabled: false },
httpServerAllowlist: [],
sidebar: { entry: 'standard' },
loopback: { ports: [] },
enabled: true,
role: 'host',
serverUrl: baseUrl,
deviceName: 'Host',
forceRelay: true,
liteMode: true,
rotatePinnedPeerKey: false,
logLevel: 'error',
reconnect: reconnect ?? { enabled: false, initialDelayMs: 10, maxDelayMs: 20, jitter: 0 },
codex: { enabled: false, binary: 'codex' },
cursor: { enabled: false, binary: 'agent' },
},
identity,
{
trustedPeer: vi.fn(() => undefined),
trustPeer: vi.fn(async input => ({ ...input, fingerprint: 'CLIENT', trustedAt: 1 })),
} as unknown as IdentityStore,
api,
{
accept: vi.fn(async () => undefined),
closeConnection: vi.fn(async () => true),
close: vi.fn(async () => undefined),
} as unknown as ConnectionController,
{ debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() } as unknown as SafeLogger,
createWebSocket,
)
return { server, api, identity }
}
async function listenGate(options: { relayAttach?: boolean; holdUpgrade?: boolean; noHello?: boolean } = {}) {
const upgrades: UpgradeRecord[] = []
const controlSockets: NodeWebSocket[] = []
const dataSockets: NodeWebSocket[] = []
const hostFrames: Array<{ type: string }> = []
// Node types `upgrade` sockets as Duplex; we only need destroy/end for cleanup.
const held: Array<{ destroy(): void }> = []
const http: Server = createServer((_req, res) => {
res.writeHead(404)
res.end()
})
const wss = new WebSocketServer({ noServer: true })
http.on('upgrade', (req, socket, head) => {
const url = req.url ?? ''
const origin = typeof req.headers.origin === 'string' ? req.headers.origin : undefined
upgrades.push({ origin, url })
if (origin && origin !== PUBLIC_ORIGIN) {
socket.end('HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n')
return
}
if (options.holdUpgrade) {
held.push(socket)
return
}
wss.handleUpgrade(req, socket, head, ws => {
if (url.startsWith('/relay')) {
dataSockets.push(ws)
ws.on('message', raw => {
try {
const frame = decodeRelayDataFrame(typeof raw === 'string' ? raw : raw.toString())
if (frame.type === 'relay.attach') {
ws.send(encodeRelayDataFrame(createRelayDataFrame('relay.ready', {
connectionId: frame.payload.connectionId,
epoch: 4,
})))
}
} catch {
ws.close(1002, 'bad relay frame')
}
})
return
}
controlSockets.push(ws)
ws.on('message', raw => {
try {
const frame = decodeControlFrame(typeof raw === 'string' ? raw : raw.toString())
hostFrames.push({ type: frame.type })
if (frame.type === 'hello' && !options.noHello) {
ws.send(JSON.stringify(createControlFrame('hello.ack', {
protocol: 1,
serverVersion: 'test',
connectionSessionId: `control-${controlSockets.length}`,
heartbeatIntervalMs: 25_000,
maxControlFrameBytes: 65_536,
maxRelayFrameBytes: 1_048_576,
capabilities: options.relayAttach
? ['transport.relay', 'transport.relay.attach']
: ['transport.relay'],
})))
}
} catch {
ws.close(1002, 'bad control frame')
}
})
})
})
await new Promise<void>((resolve, reject) => {
http.once('error', reject)
http.listen(0, '127.0.0.1', () => resolve())
})
const port = (http.address() as { port: number }).port
const baseUrl = `http://127.0.0.1:${port}`
return {
baseUrl,
relayUrl: `${baseUrl.replace('http', 'ws')}/relay`,
upgrades,
controlSockets,
dataSockets,
hostFrames,
dropControl() {
for (const socket of [...controlSockets]) {
if (socket.readyState === NodeWebSocket.OPEN) socket.close(1001, 'server restart')
}
},
releaseHeld() {
for (const entry of held.splice(0)) {
try { entry.destroy() } catch { /* ignore */ }
}
},
async close() {
for (const entry of held.splice(0)) {
try { entry.destroy() } catch { /* ignore */ }
}
for (const socket of [...controlSockets, ...dataSockets]) {
try { socket.terminate() } catch { /* ignore */ }
}
await new Promise<void>(resolve => wss.close(() => resolve()))
await new Promise<void>((resolve, reject) => {
http.close(error => error ? reject(error) : resolve())
})
},
}
}
function trackUnhandled() {
const errors: unknown[] = []
const onRejection = (reason: unknown) => { errors.push(reason) }
const onException = (error: Error) => { errors.push(error) }
process.on('unhandledRejection', onRejection)
process.on('uncaughtException', onException)
return {
expectClean() {
expect(errors, errors[0] instanceof Error ? errors[0].stack : String(errors[0])).toEqual([])
},
stop() {
process.off('unhandledRejection', onRejection)
process.off('uncaughtException', onException)
},
}
}
function openCount(sockets: NodeWebSocket[]): number {
return sockets.filter(socket => socket.readyState === NodeWebSocket.OPEN).length
}
function onceOpen(socket: NodeWebSocket): Promise<void> {
return new Promise((resolve, reject) => {
socket.once('open', () => resolve())
socket.once('error', reject)
})
}
function onceClose(socket: NodeWebSocket): Promise<void> {
return new Promise(resolve => { socket.once('close', () => resolve()) })
}
function onceError(socket: NodeWebSocket): Promise<Error> {
return new Promise(resolve => {
socket.once('error', error => resolve(error instanceof Error ? error : new Error(String(error))))
})
}
function settle(ms = 50): Promise<void> {
return new Promise(resolve => setTimeout(resolve, ms))
}