init claude-code

utils/computerUse/drainRunLoop.ts

@@ -0,0 +1,79 @@
+import { logForDebugging } from '../debug.js'
+import { withResolvers } from '../withResolvers.js'
+import { requireComputerUseSwift } from './swiftLoader.js'
+
+/**
+ * Shared CFRunLoop pump. Swift's four `@MainActor` async methods
+ * (captureExcluding, captureRegion, apps.listInstalled, resolvePrepareCapture)
+ * and `@ant/computer-use-input`'s key()/keys() all dispatch to
+ * DispatchQueue.main. Under libuv (Node/bun) that queue never drains — the
+ * promises hang. Electron drains it via CFRunLoop so Cowork doesn't need this.
+ *
+ * One refcounted setInterval calls `_drainMainRunLoop` (RunLoop.main.run)
+ * every 1ms while any main-queue-dependent call is pending. Multiple
+ * concurrent drainRunLoop() calls share the single pump via retain/release.
+ */
+
+let pump: ReturnType<typeof setInterval> | undefined
+let pending = 0
+
+function drainTick(cu: ReturnType<typeof requireComputerUseSwift>): void {
+  cu._drainMainRunLoop()
+}
+
+function retain(): void {
+  pending++
+  if (pump === undefined) {
+    pump = setInterval(drainTick, 1, requireComputerUseSwift())
+    logForDebugging('[drainRunLoop] pump started', { level: 'verbose' })
+  }
+}
+
+function release(): void {
+  pending--
+  if (pending <= 0 && pump !== undefined) {
+    clearInterval(pump)
+    pump = undefined
+    logForDebugging('[drainRunLoop] pump stopped', { level: 'verbose' })
+    pending = 0
+  }
+}
+
+const TIMEOUT_MS = 30_000
+
+function timeoutReject(reject: (e: Error) => void): void {
+  reject(new Error(`computer-use native call exceeded ${TIMEOUT_MS}ms`))
+}
+
+/**
+ * Hold a pump reference for the lifetime of a long-lived registration
+ * (e.g. the CGEventTap Escape handler). Unlike `drainRunLoop(fn)` this has
+ * no timeout — the caller is responsible for calling `releasePump()`. Same
+ * refcount as drainRunLoop calls, so nesting is safe.
+ */
+export const retainPump = retain
+export const releasePump = release
+
+/**
+ * Await `fn()` with the shared drain pump running. Safe to nest — multiple
+ * concurrent drainRunLoop() calls share one setInterval.
+ */
+export async function drainRunLoop<T>(fn: () => Promise<T>): Promise<T> {
+  retain()
+  let timer: ReturnType<typeof setTimeout> | undefined
+  try {
+    // If the timeout wins the race, fn()'s promise is orphaned — a late
+    // rejection from the native layer would become an unhandledRejection.
+    // Attaching a no-op catch swallows it; the timeout error is what surfaces.
+    // fn() sits inside try so a synchronous throw (e.g. NAPI argument
+    // validation) still reaches release() — otherwise the pump leaks.
+    const work = fn()
+    work.catch(() => {})
+    const timeout = withResolvers<never>()
+    timer = setTimeout(timeoutReject, TIMEOUT_MS, timeout.reject)
+    return await Promise.race([work, timeout.promise])
+  } finally {
+    clearTimeout(timer)
+    release()
+  }
+}