From 8eb047a67a8ebab6c84b64509a47a6db13a9fcdf Mon Sep 17 00:00:00 2001 From: QQ Date: Sat, 14 Nov 2026 14:44:24 +0800 Subject: [PATCH] Import packages/client-core/src/index.ts --- packages/client-core/src/index.ts | 241 ++++++++++++++++++++++++++++++ 1 file changed, 241 insertions(+) create mode 100644 packages/client-core/src/index.ts diff --git a/packages/client-core/src/index.ts b/packages/client-core/src/index.ts new file mode 100644 index 0000000..06f9289 --- /dev/null +++ b/packages/client-core/src/index.ts @@ -0,0 +1,241 @@ +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'