80 lines
2.8 KiB
TypeScript
80 lines
2.8 KiB
TypeScript
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()
|
|
}
|
|
}
|