import { createRpcRequest, decodeMessage, encodeMessage, type EventPayload, type RemoteEventName, type RemoteMessage, type RpcErrorPayload, type RpcMethod, type RpcResponsePayload, } from '@dsh-remote/protocol' import type { RemoteTransport } from '@dsh-remote/webrtc' export type RemoteClientErrorCode = | 'RPC_TIMEOUT' | 'RPC_ABORTED' | 'TRANSPORT_CLOSED' | 'CLIENT_CLOSED' export class RemoteClientError extends Error { constructor( readonly code: RemoteClientErrorCode, message: string, options?: ErrorOptions, ) { super(message, options) this.name = 'RemoteClientError' } } interface PendingCall { method: string resolve: (value: unknown) => void reject: (error: Error) => void timer: ReturnType removeAbort?: () => void } /** Per-call override for endpoints that legitimately outlive the client-wide deadline. */ export interface RemoteRpcOptions { timeoutMs?: number } export class RemoteClientCore { private readonly pending = new Map() private readonly eventHandlers = new Set<(event: EventPayload) => void>() private unsubscribeTransport?: () => void private unsubscribeClose?: () => void private readonly closeHandlers = new Set<(error?: Error) => void>() private closeNotified = false // Keep the first close reason so late stream cleanup fails without a new timer. private terminalCode?: 'TRANSPORT_CLOSED' | 'CLIENT_CLOSED' constructor(private readonly transport: RemoteTransport, private readonly timeoutMs = 30_000) {} async connect(): Promise { if (this.terminalCode !== undefined) throw new RemoteClientError(this.terminalCode, 'The remote client has closed.') if (this.unsubscribeTransport !== undefined) return this.closeNotified = false this.unsubscribeTransport = this.transport.onMessage(data => this.handleMessage(data)) this.unsubscribeClose = this.transport.onClose?.(error => this.handleTransportClose(error)) try { await this.transport.connect() } catch (error) { this.unsubscribeTransport() this.unsubscribeTransport = undefined this.unsubscribeClose?.() this.unsubscribeClose = undefined throw error } } async rpc( method: string, params: TParams, signal?: AbortSignal, options?: RemoteRpcOptions | number, ): Promise { if (signal?.aborted) throw rpcAbortedError(method, signal.reason) if (this.terminalCode !== undefined) { throw new RemoteClientError(this.terminalCode, `RPC ${method} cannot start after the remote client closed`) } const timeoutMs = typeof options === 'number' ? options : callTimeoutMs(this.timeoutMs, options) const request = createRpcRequest(method as RpcMethod, params) const result = new Promise((resolve, reject) => { const timer = setTimeout(() => { this.rejectPending( request.id, new RemoteClientError('RPC_TIMEOUT', `RPC ${method} timed out after ${timeoutMs}ms`), ) }, timeoutMs) const pending: PendingCall = { method, resolve: resolve as (value: unknown) => void, reject, timer, } if (signal !== undefined) { const onAbort = () => { if (this.pending.get(request.id) !== pending) return this.rejectPending(request.id, rpcAbortedError(method, signal.reason)) } signal.addEventListener('abort', onAbort, { once: true }) pending.removeAbort = () => signal.removeEventListener('abort', onAbort) } this.pending.set(request.id, pending) }) // Do not await the write: timeout, abort, or close must be able to settle // the RPC even when the transport send itself never completes. try { const send = this.transport.send(encodeMessage(request)) void send.catch(error => { this.rejectPending(request.id, transportSendError(error)) }) } catch (error) { this.rejectPending(request.id, transportSendError(error)) } return result } onEvent(handler: (event: EventPayload) => void): () => void { this.eventHandlers.add(handler) return () => this.eventHandlers.delete(handler) } onClose(handler: (error?: Error) => void): () => void { this.closeHandlers.add(handler) return () => this.closeHandlers.delete(handler) } getStats() { return this.transport.getStats() } async close(): Promise { this.terminalCode ??= 'CLIENT_CLOSED' this.unsubscribeTransport?.() this.unsubscribeTransport = undefined this.unsubscribeClose?.() this.unsubscribeClose = undefined this.rejectAllPending( pending => new RemoteClientError( 'CLIENT_CLOSED', `RPC ${pending.method} terminated because the remote client closed`, ), ) this.notifyClose(new RemoteClientError('CLIENT_CLOSED', 'The remote client was closed.')) await this.transport.close() } private handleTransportClose(error?: Error): void { this.terminalCode ??= 'TRANSPORT_CLOSED' this.rejectAllPending( pending => new RemoteClientError( 'TRANSPORT_CLOSED', `RPC ${pending.method} terminated because the remote transport closed`, ), ) this.notifyClose(error) } private handleMessage(data: Uint8Array): void { const message = decodeMessage(data) if (message.type === 'rpc.response') this.handleResponse(message as RemoteMessage) if (message.type === 'rpc.error') this.handleError(message as RemoteMessage) if (message.type === 'event') { const event = message.payload as EventPayload for (const handler of this.eventHandlers) handler(event) } } private handleResponse(message: RemoteMessage): void { const pending = this.takePending(message.payload.requestId) if (pending === undefined) return pending.resolve(message.payload.result) } private handleError(message: RemoteMessage): void { const pending = this.takePending(message.payload.requestId) if (pending === undefined) return pending.reject(Object.assign(new Error(message.payload.message), { code: message.payload.code })) } private takePending(requestId: string): PendingCall | undefined { const pending = this.pending.get(requestId) if (pending === undefined) return undefined this.pending.delete(requestId) clearTimeout(pending.timer) pending.removeAbort?.() return pending } private rejectPending(requestId: string, error: Error): boolean { const pending = this.takePending(requestId) if (pending === undefined) return false pending.reject(error) return true } private rejectAllPending(createError: (pending: PendingCall) => Error): void { for (const requestId of [...this.pending.keys()]) { const pending = this.takePending(requestId) if (pending !== undefined) pending.reject(createError(pending)) } } private notifyClose(error?: Error): void { if (this.closeNotified) return this.closeNotified = true for (const handler of this.closeHandlers) handler(error) } } function rpcAbortedError(method: string, reason: unknown): RemoteClientError { return new RemoteClientError( 'RPC_ABORTED', `RPC ${method} was aborted`, reason === undefined ? undefined : { cause: reason }, ) } function callTimeoutMs(fallback: number, options: RemoteRpcOptions | undefined): number { const timeoutMs = options?.timeoutMs if (typeof timeoutMs !== 'number') return fallback return Number.isSafeInteger(timeoutMs) && timeoutMs > 0 && timeoutMs <= 2_147_483_647 ? timeoutMs : fallback } function transportSendError(error: unknown): Error { return error instanceof Error ? error : new Error('remote transport send failed', { cause: error }) } export type { EventPayload, RemoteEventName, RemoteTransport } export * from './remote-gateway.js' export * from './harness-alpha-client.js' export * from './codex-client.js' export * from './acp-client.js'