fix(cli): replace unsafe WebSocket double cast with typed adapter

Author: jerome-benoit

ui/cli/src/client/lifecycle.ts

@@ -50,6 +50,9 @@ export const executeCommand = async (options: ExecuteOptions): Promise<void> =>
   activeSpinner = spinner ?? undefined
   activeClient = client
 
+  const budget = timeoutMs ?? UI_WEBSOCKET_REQUEST_TIMEOUT_MS
+  const startTime = Date.now()
+
   let connectTimeoutId: ReturnType<typeof setTimeout> | undefined
   try {
     const connectPromise = client.connect()
@@ -59,7 +62,7 @@ export const executeCommand = async (options: ExecuteOptions): Promise<void> =>
       new Promise<never>((_resolve, reject) => {
         connectTimeoutId = setTimeout(() => {
           reject(new Error(`Connection to ${url} timed out`))
-        }, timeoutMs ?? UI_WEBSOCKET_REQUEST_TIMEOUT_MS)
+        }, budget)
       }),
     ])
   } catch (error: unknown) {
@@ -70,11 +73,18 @@ export const executeCommand = async (options: ExecuteOptions): Promise<void> =>
     clearTimeout(connectTimeoutId)
   }
 
+  const remaining = budget - (Date.now() - startTime)
+  if (remaining <= 0) {
+    spinner?.fail()
+    client.disconnect()
+    throw new ConnectionError(url, new Error('Connection consumed entire timeout budget'))
+  }
+
   try {
     if (spinner != null) {
       spinner.text = `Sending ${procedureName}...`
     }
-    const response: ResponsePayload = await client.sendRequest(procedureName, payload)
+    const response: ResponsePayload = await client.sendRequest(procedureName, payload, remaining)
     spinner?.stop()
     formatter.output(response)
   } catch (error: unknown) {

ui/cli/src/client/ws-adapter.ts

@@ -0,0 +1,101 @@
+import { Buffer } from 'node:buffer'
+
+import type { WebSocketLike } from 'ui-common'
+import { WebSocketReadyState } from 'ui-common'
+import { WebSocket as WsWebSocket } from 'ws'
+
+const toDataString = (data: WsWebSocket.Data): string => {
+  if (Buffer.isBuffer(data)) {
+    return data.toString('utf-8')
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(data).toString('utf-8')
+  }
+  if (Array.isArray(data)) {
+    return Buffer.concat(data as Buffer[]).toString('utf-8')
+  }
+  return data
+}
+
+export const createWsAdapter = (ws: WsWebSocket): WebSocketLike => {
+  let onmessageCallback: ((event: { data: string }) => void) | null = null
+  let onerrorCallback: ((event: { error: unknown; message: string }) => void) | null = null
+  let oncloseCallback: ((event: { code: number; reason: string }) => void) | null = null
+  let onopenCallback: (() => void) | null = null
+
+  ws.onmessage = (event) => {
+    if (onmessageCallback != null) {
+      const data = toDataString(event.data)
+      onmessageCallback({ data })
+    }
+  }
+
+  ws.onerror = (event) => {
+    if (onerrorCallback != null) {
+      let error: Error
+      let message: string
+      if (event instanceof Error) {
+        error = event
+        message = event.message
+      } else {
+        message = typeof event === 'string' ? event : 'Unknown error'
+        error = new Error(message)
+      }
+      onerrorCallback({ error, message })
+    }
+  }
+
+  ws.onclose = (event) => {
+    if (oncloseCallback != null) {
+      oncloseCallback({ code: event.code, reason: event.reason })
+    }
+  }
+
+  ws.onopen = () => {
+    if (onopenCallback != null) {
+      onopenCallback()
+    }
+  }
+
+  return {
+    get onclose (): ((event: { code: number; reason: string }) => void) | null {
+      return oncloseCallback
+    },
+    set onclose (callback: ((event: { code: number; reason: string }) => void) | null) {
+      oncloseCallback = callback
+    },
+
+    get onerror (): ((event: { error: unknown; message: string }) => void) | null {
+      return onerrorCallback
+    },
+    set onerror (callback: ((event: { error: unknown; message: string }) => void) | null) {
+      onerrorCallback = callback
+    },
+
+    get onmessage (): ((event: { data: string }) => void) | null {
+      return onmessageCallback
+    },
+    set onmessage (callback: ((event: { data: string }) => void) | null) {
+      onmessageCallback = callback
+    },
+
+    get onopen (): (() => void) | null {
+      return onopenCallback
+    },
+    set onopen (callback: (() => void) | null) {
+      onopenCallback = callback
+    },
+
+    close (code?: number, reason?: string): void {
+      ws.close(code, reason)
+    },
+
+    get readyState (): WebSocketReadyState {
+      return ws.readyState as WebSocketReadyState
+    },
+
+    send (data: string): void {
+      ws.send(data)
+    },
+  }
+}