fix(opencode): answer a failed TUI worker request instead of hanging

packages/opencode/src/util/rpc.ts

@@ -1,17 +1,28 @@
+import { errorMessage } from "@/util/error"
+
 type Definition = {
   [method: string]: (input: any) => any
 }
 
 export function listen(rpc: Definition) {
   onmessage = async (evt) => {
     const parsed = JSON.parse(evt.data)
-    if (parsed.type === "rpc.request") {
-      const result = await rpc[parsed.method](parsed.input)
-      postMessage(JSON.stringify({ type: "rpc.result", result, id: parsed.id }))
-    }
+    if (parsed.type !== "rpc.request") return
+    // A request that throws must still be answered, or its caller waits forever.
+    const reply = await Promise.resolve()
+      .then(() => rpc[parsed.method](parsed.input))
+      .then((result) => JSON.stringify({ type: "rpc.result", result, id: parsed.id }))
+      .catch((error) => JSON.stringify({ type: "rpc.result", error: failureMessage(error), id: parsed.id }))
+    postMessage(reply)
   }
 }
 
+// Some failures keep their text on the cause: a taken --port rejects with an empty ServeError.
+function failureMessage(error: unknown): string {
+  if (error instanceof Error && !error.message && error.cause) return failureMessage(error.cause)
+  return errorMessage(error)
+}
+
 export function emit(event: string, data: unknown) {
   postMessage(JSON.stringify({ type: "rpc.event", event, data }))
 }
@@ -20,17 +31,17 @@ export function client<T extends Definition>(target: {
   postMessage: (data: string) => void | null
   onmessage: ((this: Worker, ev: MessageEvent<any>) => any) | null
 }) {
-  const pending = new Map<number, (result: any) => void>()
+  const pending = new Map<number, { resolve: (result: any) => void; reject: (error: Error) => void }>()
   const listeners = new Map<string, Set<(data: any) => void>>()
   let id = 0
   target.onmessage = async (evt) => {
     const parsed = JSON.parse(evt.data)
     if (parsed.type === "rpc.result") {
-      const resolve = pending.get(parsed.id)
-      if (resolve) {
-        resolve(parsed.result)
-        pending.delete(parsed.id)
-      }
+      const request = pending.get(parsed.id)
+      if (!request) return
+      pending.delete(parsed.id)
+      if (typeof parsed.error === "string") return request.reject(new Error(parsed.error))
+      return request.resolve(parsed.result)
     }
     if (parsed.type === "rpc.event") {
       const handlers = listeners.get(parsed.event)
@@ -44,8 +55,8 @@ export function client<T extends Definition>(target: {
   return {
     call<Method extends keyof T>(method: Method, input: Parameters<T[Method]>[0]): Promise<ReturnType<T[Method]>> {
       const requestId = id++
-      return new Promise((resolve) => {
-        pending.set(requestId, resolve)
+      return new Promise((resolve, reject) => {
+        pending.set(requestId, { resolve, reject })
         target.postMessage(JSON.stringify({ type: "rpc.request", method, input, id: requestId }))
       })
     },