Import packages/webrtc/src/index.ts

This commit is contained in:
QQ 2026-11-14 15:05:39 +08:00
parent 06643d378e
commit 6420de56f7
1 changed files with 363 additions and 0 deletions

View File

@ -0,0 +1,363 @@
import { waitForRelayCapacity } from './websocket-backpressure.js'
import {
PROTOCOL_VERSION,
acceptNegotiatedCapabilities,
createControlFrame,
createRelayDataFrame,
decodeControlFrame,
decodeRelayDataFrame,
encodeControlFrame,
encodeRelayDataFrame,
type ControlFrameByteLimits,
type ConnectAcceptedPayload,
type HelloAckPayload,
type RelayPayload,
type SecureHandshakePayload,
type TransportStats,
} from '@dsh-remote/protocol'
import { BaseTransport } from './transport.js'
import { fromBase64Url, toBase64Url } from './util.js'
export * from './transport.js'
export * from './rtc-adapter.js'
export * from './rtc-chunking.js'
export * from './rtc-data-channel.js'
export * from './adaptive-transport.js'
export interface RelayTransportOptions {
role: 'client'
deviceId: string
accessToken: string
targetDeviceId: string
capabilities?: string[]
preferredTransports?: Array<'lan' | 'p2p' | 'turn' | 'relay'>
handshakeTimeoutMs?: number
}
type RelayAssignment = Pick<ConnectAcceptedPayload, 'relayEndpoint' | 'relayTicket' | 'relayNodeId' | 'relayEpoch'>
export class RelayTransport extends BaseTransport {
private readonly handshakeHandlers = new Set<(step: number, data: Uint8Array) => void>()
private socket?: WebSocket
private dataSocket?: WebSocket
private bytesSent = 0
private bytesReceived = 0
private connectionId?: string
private relayCounter = 0
private readyResolve?: () => void
private readyReject?: (error: Error) => void
private handshakeTimer?: ReturnType<typeof setTimeout>
private controlFrameLimits: ControlFrameByteLimits = {}
private dataReadyResolve?: () => void
private dataReadyReject?: (error: Error) => void
private dataReady = false
constructor(
private readonly url: string,
private readonly options: RelayTransportOptions,
) {
super()
}
async connect(): Promise<void> {
if (this.socket !== undefined) return
this.socket = new WebSocket(this.url)
this.controlFrameLimits = {}
this.socket.binaryType = 'arraybuffer'
await new Promise<void>((resolve, reject) => {
this.readyResolve = resolve
this.readyReject = reject
this.handshakeTimer = setTimeout(
() => this.failConnection(new Error('Relay control handshake timed out')),
this.options.handshakeTimeoutMs ?? 10_000,
)
const socket = this.socket!
socket.onmessage = event => {
void this.handleSocketMessage(event.data)
}
socket.onopen = () => {
this.sendControl('hello', {
role: this.options.role,
deviceId: this.options.deviceId,
accessToken: this.options.accessToken,
protocols: [PROTOCOL_VERSION],
capabilities: this.options.capabilities ?? ['transport.relay', 'transport.relay.attach'],
})
}
socket.onerror = () => this.failConnection(new Error(`RelayTransport failed to connect to ${this.url}`))
socket.onclose = () => {
const pending = this.readyReject !== undefined
if (pending) this.failConnection(new Error('Relay control channel closed before it was ready'))
this.socket = undefined
this.connectionId = undefined
this.emitClose()
}
})
}
async send(data: Uint8Array): Promise<void> {
const socket = this.dataSocket ?? this.socket
if (socket?.readyState !== WebSocket.OPEN) throw new Error('relay transport is not connected')
if (this.connectionId === undefined) throw new Error('relay connection has not been authorized')
await waitForRelayCapacity(socket)
const payload = {
connectionId: this.connectionId,
targetDeviceId: this.options.targetDeviceId,
counter: this.relayCounter,
ciphertext: toBase64Url(data),
} satisfies RelayPayload
if (this.dataSocket !== undefined) {
this.dataSocket.send(encodeRelayDataFrame(createRelayDataFrame('relay', payload), this.controlFrameLimits))
}
else this.sendControl('relay', payload)
this.bytesSent += data.byteLength
this.relayCounter += 1
}
connectionInfo(): { connectionId: string; localDeviceId: string; remoteDeviceId: string } {
if (this.connectionId === undefined) throw new Error('relay connection has not been authorized')
return {
connectionId: this.connectionId,
localDeviceId: this.options.deviceId,
remoteDeviceId: this.options.targetDeviceId,
}
}
async sendHandshake(step: number, data: Uint8Array): Promise<void> {
if (this.socket?.readyState !== WebSocket.OPEN || this.connectionId === undefined) {
throw new Error('relay connection has not been authorized')
}
this.sendControl('secure.handshake', {
connectionId: this.connectionId,
targetDeviceId: this.options.targetDeviceId,
step,
data: toBase64Url(data),
} satisfies SecureHandshakePayload)
}
onHandshake(cb: (step: number, data: Uint8Array) => void): () => void {
this.handshakeHandlers.add(cb)
return () => this.handshakeHandlers.delete(cb)
}
async close(): Promise<void> {
this.clearHandshake()
this.dataSocket?.close()
this.dataSocket = undefined
this.dataReady = false
this.socket?.close()
this.socket = undefined
this.connectionId = undefined
}
getStats(): TransportStats {
return {
mode: this.socket?.readyState === WebSocket.OPEN ? 'Relay' : 'Disconnected',
connected: this.socket?.readyState === WebSocket.OPEN,
bytesSent: this.bytesSent,
bytesReceived: this.bytesReceived,
}
}
private async handleSocketMessage(raw: string | ArrayBuffer | Blob): Promise<void> {
try {
if (typeof raw !== 'string') throw new Error('Relay control frames must be text JSON')
const frame = decodeControlFrame(raw, this.controlFrameLimits)
if (frame.type === 'hello.ack') {
const payload = frame.payload as Partial<HelloAckPayload>
if (payload.protocol !== PROTOCOL_VERSION) throw new Error('Server selected an unsupported protocol version')
const offered = this.options.capabilities ?? ['transport.relay', 'transport.relay.attach']
const negotiated = acceptNegotiatedCapabilities(offered, payload.capabilities)
this.controlFrameLimits = {
maxControlFrameBytes: payload.maxControlFrameBytes,
maxRelayFrameBytes: payload.maxRelayFrameBytes,
}
if (!negotiated.includes('transport.relay')) {
throw new Error('Server did not negotiate the required Relay capability')
}
this.sendControl('connect.request', {
hostDeviceId: this.options.targetDeviceId,
preferredTransports: ['relay'],
})
return
}
if (frame.type === 'connect.accepted') {
const payload = frame.payload as Partial<ConnectAcceptedPayload>
if (typeof payload.connectionId !== 'string' || payload.connectionId.length === 0) {
throw new Error('connect.accepted did not include a connectionId')
}
this.connectionId = payload.connectionId
const assignment = payload as RelayAssignment
if (typeof assignment.relayEndpoint === 'string' && typeof assignment.relayTicket === 'string') {
await this.openDataSocket(assignment)
}
this.finishConnection()
return
}
if (frame.type === 'connect.rejected' || frame.type === 'error') {
const payload = frame.payload as { message?: unknown; code?: unknown }
const message = typeof payload.message === 'string' ? payload.message : 'Server rejected the relay connection'
throw Object.assign(new Error(message), { code: payload.code })
}
if (frame.type === 'relay') {
if (this.dataSocket !== undefined) return
const payload = frame.payload as Partial<RelayPayload>
if (payload.connectionId !== this.connectionId
|| payload.targetDeviceId !== this.options.deviceId
|| !Number.isSafeInteger(payload.counter)
|| typeof payload.ciphertext !== 'string') {
throw new Error('Received a relay frame for an unknown connection')
}
const data = fromBase64Url(payload.ciphertext)
this.bytesReceived += data.byteLength
this.emit(data)
return
}
if (frame.type === 'secure.handshake') {
const payload = frame.payload as Partial<SecureHandshakePayload>
if (payload.connectionId !== this.connectionId
|| payload.targetDeviceId !== this.options.deviceId
|| !Number.isSafeInteger(payload.step)
|| typeof payload.data !== 'string') {
throw new Error('Received a secure handshake frame for an unknown connection')
}
const data = fromBase64Url(payload.data)
for (const handler of this.handshakeHandlers) handler(payload.step!, data)
return
}
if (frame.type === 'ping') this.sendControl('pong', frame.payload)
} catch (error) {
this.failConnection(error instanceof Error ? error : new Error('Invalid relay control frame'))
}
}
private sendControl(type: Parameters<typeof createControlFrame>[0], payload: unknown): void {
if (this.socket?.readyState !== WebSocket.OPEN) throw new Error('relay control socket is not open')
this.socket.send(encodeControlFrame(createControlFrame(type, payload), this.controlFrameLimits))
}
private async openDataSocket(assignment: RelayAssignment): Promise<void> {
if (this.connectionId === undefined || this.dataSocket !== undefined) return
const socket = new WebSocket(assignment.relayEndpoint!)
socket.binaryType = 'arraybuffer'
this.dataSocket = socket
await new Promise<void>((resolve, reject) => {
this.dataReadyResolve = resolve
this.dataReadyReject = reject
const timer = setTimeout(() => {
this.dataReadyResolve = undefined
this.dataReadyReject = undefined
reject(new Error('Relay data attach timed out'))
socket.close()
}, this.options.handshakeTimeoutMs ?? 10_000)
socket.onopen = () => {
socket.send(encodeRelayDataFrame(createRelayDataFrame('relay.attach', {
connectionId: this.connectionId,
deviceId: this.options.deviceId,
peerDeviceId: this.options.targetDeviceId,
ticket: assignment.relayTicket,
}), this.controlFrameLimits))
}
socket.onmessage = event => {
try {
if (typeof event.data !== 'string') throw new Error('Relay data frames must be text JSON')
const data = decodeRelayDataFrame(event.data, this.controlFrameLimits)
if (data.type === 'relay.ready') {
if (data.payload.connectionId !== this.connectionId
|| (assignment.relayEpoch !== undefined && data.payload.epoch !== assignment.relayEpoch)) {
throw new Error('Relay data attach assignment mismatch')
}
clearTimeout(timer)
this.dataReady = true
this.dataReadyResolve = undefined
this.dataReadyReject = undefined
resolve()
return
}
void this.handleDataSocketFrame(data.type, data.payload).catch(error => {
this.failConnection(error instanceof Error ? error : new Error('Invalid Relay data frame'))
})
} catch (error) {
clearTimeout(timer)
reject(error instanceof Error ? error : new Error('Invalid Relay data frame'))
this.failConnection(error instanceof Error ? error : new Error('Invalid Relay data frame'))
}
}
socket.onerror = () => {
clearTimeout(timer)
reject(new Error('Relay data socket failed'))
}
socket.onclose = () => {
clearTimeout(timer)
if (!this.dataReady) reject(new Error('Relay data socket closed before attach'))
else this.failConnection(new Error('Relay data socket closed'))
}
})
}
private async handleDataSocketFrame(type: string, payload: Record<string, unknown>): Promise<void> {
if (type === 'relay.detach') {
this.failConnection(new Error('Relay peer detached'))
return
}
if (type === 'ping') {
if (this.dataSocket?.readyState === WebSocket.OPEN) {
this.dataSocket.send(encodeRelayDataFrame(createRelayDataFrame('pong', payload), this.controlFrameLimits))
}
return
}
if (type === 'relay') {
if (payload.connectionId !== this.connectionId || payload.targetDeviceId !== this.options.deviceId
|| !Number.isSafeInteger(payload.counter) || typeof payload.ciphertext !== 'string') {
throw new Error('Received a relay frame for an unknown connection')
}
const data = fromBase64Url(payload.ciphertext)
this.bytesReceived += data.byteLength
this.emit(data)
return
}
if (type === 'secure.handshake') {
if (payload.connectionId !== this.connectionId || payload.targetDeviceId !== this.options.deviceId
|| !Number.isSafeInteger(payload.step) || typeof payload.data !== 'string') {
throw new Error('Received a secure handshake frame for an unknown connection')
}
const data = fromBase64Url(payload.data)
for (const handler of this.handshakeHandlers) handler(payload.step as number, data)
}
}
private finishConnection(): void {
this.clearHandshake()
this.readyResolve?.()
this.readyResolve = undefined
this.readyReject = undefined
}
private failConnection(error: Error): void {
this.clearHandshake()
const reject = this.readyReject
this.readyResolve = undefined
this.readyReject = undefined
reject?.(error)
const dataSocket = this.dataSocket
this.dataSocket = undefined
this.dataReady = false
this.dataReadyResolve = undefined
this.dataReadyReject = undefined
dataSocket?.close()
this.socket?.close()
this.socket = undefined
this.connectionId = undefined
}
private clearHandshake(): void {
if (this.handshakeTimer !== undefined) clearTimeout(this.handshakeTimer)
this.handshakeTimer = undefined
}
}
export { waitForRelayCapacity } from './websocket-backpressure.js'
export { SerialSend } from './serial-send.js'
export * from './control-lease.js'