From 6dafbea3071ec93e1554e187685d2c5bf0419abb Mon Sep 17 00:00:00 2001 From: QQ Date: Sat, 14 Nov 2026 14:55:17 +0800 Subject: [PATCH] Import packages/plugin/src/connection-controller.ts --- packages/plugin/src/connection-controller.ts | 279 +++++++++++++++++++ 1 file changed, 279 insertions(+) create mode 100644 packages/plugin/src/connection-controller.ts diff --git a/packages/plugin/src/connection-controller.ts b/packages/plugin/src/connection-controller.ts new file mode 100644 index 0000000..c76136a --- /dev/null +++ b/packages/plugin/src/connection-controller.ts @@ -0,0 +1,279 @@ +import { + MAX_SECURE_MESSAGE_BYTES, + createRpcError, + encodeMessage, + type RemoteMessage, +} from '@dsh-remote/protocol' +import type { IdentityStore } from './identity-store.js' +import type { SafeLogger } from './logging.js' +import type { RpcRouter } from './rpc-router.js' +import type { AuthenticatedPeerChannel } from './types.js' + +interface ActiveConnection { + channel: AuthenticatedPeerChannel + router: RpcRouter + unsubscribe: () => void +} + +export interface PeerConnectionContext { + transportMode?: () => AuthenticatedPeerChannel['mode'] + connectionId: string + peerDeviceId: string +} + +export interface ConnectedPeer { + deviceId: string + mode?: 'LAN' | 'P2P' | 'TURN' | 'Relay' +} + +/** + * Who closed the logical peer connection. `CONNECTION_FAILED` exists as both + * a Server-issued code and a Host fallback, so the disconnect log must name the + * source or operators cannot tell the two paths apart. + */ +export interface ConnectionCloseDetail { + closedBy: 'server' | 'host' + retryable?: boolean +} + +export type RpcRouterFactory = ( + context: PeerConnectionContext, + send: (message: RemoteMessage) => Promise, +) => RpcRouter + +export class ConnectionController { + private readonly active = new Map() + private acceptQueue: Promise = Promise.resolve() + + constructor( + private readonly identities: IdentityStore, + private readonly createRouter: RpcRouterFactory, + private readonly logger?: SafeLogger, + ) {} + + accept(channel: AuthenticatedPeerChannel): Promise { + const operation = this.acceptQueue.then(() => this.acceptOne(channel)) + this.acceptQueue = operation.catch(() => undefined) + return operation + } + + private async acceptOne(channel: AuthenticatedPeerChannel): Promise { + if (channel.security?.protocol !== 'Noise_IK_25519_ChaChaPoly_SHA256' + || channel.security.connectionId === '' + || channel.security.membershipId === '') { + await channel.close('SECURE_CHANNEL_FAILED') + throw new ConnectionRejectedError('SECURE_CHANNEL_FAILED', 'The channel is missing its authenticated Noise or membership context.') + } + if (!this.identities.isTrusted(channel.peerDeviceId, channel.peerIdentityKey)) { + await channel.close('PEER_IDENTITY_MISMATCH') + throw new ConnectionRejectedError('PEER_IDENTITY_MISMATCH', 'The peer identity does not match local trust.') + } + const connectionId = channel.security.connectionId + const connectionConflict = this.active.get(connectionId) + if (connectionConflict !== undefined && connectionConflict.channel.peerDeviceId !== channel.peerDeviceId) { + await channel.close('SECURE_CHANNEL_FAILED') + throw new ConnectionRejectedError('SECURE_CHANNEL_FAILED', 'The connection id is already bound to another peer.') + } + + const replaced = [...this.active.values()].filter(connection => ( + connection.channel.peerDeviceId === channel.peerDeviceId + || connection.channel.security.connectionId === connectionId + )) + if (replaced.length > 0) { + this.logger?.warn('replacing active peer connection', { + peerDeviceId: shortId(channel.peerDeviceId), + replacedCount: replaced.length, + replacedPeerDeviceIds: replaced.map(connection => shortId(connection.channel.peerDeviceId)), + }) + } + await Promise.all(replaced.map(connection => this.disconnect(connection, 'CONNECTION_REPLACED'))) + + const router = this.createRouter( + { connectionId, peerDeviceId: channel.peerDeviceId, transportMode: () => channel.mode }, + message => this.sendTo(connectionId, channel, message), + ) + const connection: ActiveConnection = { + channel, + router, + unsubscribe: () => undefined, + } + this.active.set(connectionId, connection) + try { + connection.unsubscribe = channel.onMessage(message => { void this.handle(connection, message) }) + } catch (error) { + await this.disconnect(connection) + throw error + } + this.logger?.info('peer connection accepted', { + peerDeviceId: shortId(channel.peerDeviceId), + connectionId: shortId(connectionId), + mode: channel.mode, + }) + } + + isOnline(): boolean { return this.active.size > 0 } + + connectionCount(): number { return this.active.size } + + peerDeviceIds(): string[] { + return this.connectedPeers().map(peer => peer.deviceId) + } + + connectedPeers(): ConnectedPeer[] { + const peers: ConnectedPeer[] = [] + const seen = new Set() + for (const connection of this.active.values()) { + const deviceId = connection.channel.peerDeviceId + if (seen.has(deviceId)) continue + seen.add(deviceId) + peers.push({ + deviceId, + ...(connection.channel.mode === undefined ? {} : { mode: connection.channel.mode }), + }) + } + return peers + } + + peerDeviceId(): string | undefined { + const peers = this.peerDeviceIds() + return peers.length === 1 ? peers[0] : undefined + } + + connectionMode(): 'LAN' | 'P2P' | 'TURN' | 'Relay' | 'Disconnected' { + const connection = this.active.values().next().value as ActiveConnection | undefined + return connection?.channel.mode ?? (connection === undefined ? 'Disconnected' : 'Relay') + } + + async send(message: RemoteMessage): Promise { + await Promise.all([...this.active.values()].map(connection => this.sendConnection(connection, message))) + } + + async revoke(deviceId: string): Promise { + const revoked = [...this.active.values()].filter(connection => connection.channel.peerDeviceId === deviceId) + await Promise.all(revoked.map(connection => this.disconnect(connection, 'DEVICE_REVOKED'))) + } + + async closeConnection(connectionId: string, code?: string, detail?: ConnectionCloseDetail): Promise { + const connection = this.active.get(connectionId) + if (connection === undefined) return false + await this.disconnect(connection, code, detail) + return true + } + + async close(): Promise { + await this.acceptQueue + await Promise.all([...this.active.values()].map(connection => this.disconnect(connection))) + } + + private async handle(connection: ActiveConnection, message: RemoteMessage): Promise { + if (!this.isActive(connection)) return + try { + const response = await connection.router.handle(message) + if (!this.isActive(connection)) return + const responseBytes = encodeMessage(response).byteLength + let outbound: RemoteMessage + if (responseBytes <= MAX_SECURE_MESSAGE_BYTES) { + outbound = response + } else { + const endpoint = extractEndpoint(message) + this.logger?.warn('host response exceeds secure channel', { + endpoint, + bytes: responseBytes, + limit: MAX_SECURE_MESSAGE_BYTES, + }) + outbound = createRpcError( + message.id, + 'RESPONSE_TOO_LARGE', + 'The Host response is too large for the secure Remote channel. Request a smaller page.', + { maxBytes: MAX_SECURE_MESSAGE_BYTES }, + true, + ) + } + await connection.channel.send(outbound) + } catch (error) { + this.logger?.warn('peer message handling failed; disconnecting', { + peerDeviceId: shortId(connection.channel.peerDeviceId), + reason: diagnosticReason(error), + }) + await this.disconnect(connection) + } + } + + private async sendTo(connectionId: string, channel: AuthenticatedPeerChannel, message: RemoteMessage): Promise { + const connection = this.active.get(connectionId) + if (connection === undefined || connection.channel !== channel) { + throw new Error('peer channel is not active') + } + await this.sendConnection(connection, message) + } + + private async sendConnection(connection: ActiveConnection, message: RemoteMessage): Promise { + if (!this.isActive(connection)) { + throw new Error('peer channel is not active') + } + try { + await connection.channel.send(message) + } catch (error) { + this.logger?.warn('peer send failed; disconnecting', { + peerDeviceId: shortId(connection.channel.peerDeviceId), + messageType: message.type, + reason: diagnosticReason(error), + }) + await this.disconnect(connection) + throw error instanceof Error ? error : new Error('peer send failed', { cause: error }) + } + } + + private async disconnect( + connection: ActiveConnection, + code?: string, + detail?: ConnectionCloseDetail, + ): Promise { + if (!this.isActive(connection)) return + this.active.delete(connection.channel.security.connectionId) + connection.unsubscribe() + try { + await connection.router.closePeerStreams() + } finally { + await connection.channel.close(code) + } + this.logger?.info('peer connection disconnected', { + peerDeviceId: shortId(connection.channel.peerDeviceId), + connectionId: shortId(connection.channel.security.connectionId), + code: code ?? 'closed', + closedBy: detail?.closedBy ?? 'host', + ...(detail?.retryable === undefined ? {} : { retryable: detail.retryable }), + }) + } + + private isActive(connection: ActiveConnection): boolean { + return this.active.get(connection.channel.security.connectionId) === connection + } +} + +export class ConnectionRejectedError extends Error { + constructor(readonly code: string, message: string) { super(message) } +} + +function diagnosticReason(error: unknown): string { + const message = error instanceof Error ? error.message : String(error) + return message.replace(/\s+/g, ' ').slice(0, 160) || 'Unknown peer connection failure.' +} + +function extractEndpoint(message: RemoteMessage): string | undefined { + if (!isRecord(message) || !isRecord(message.payload)) return undefined + const payload = message.payload + if (isRecord(payload.params)) { + if (typeof payload.params.endpoint === 'string') return payload.params.endpoint + if (typeof payload.params.method === 'string') return payload.params.method + } + if (typeof payload.endpoint === 'string') return payload.endpoint + if (typeof payload.method === 'string') return payload.method + return undefined +} + +function isRecord(value: unknown): value is Record { + return typeof value === 'object' && value !== null && !Array.isArray(value) +} + +function shortId(value: string): string { return value.length <= 12 ? value : `${value.slice(0, 8)}…${value.slice(-4)}` }