Orca is the place for working with a fleet of agents (e.g. Grok Bot, Claude Code). Run any coding agent with your own subscription. Available on desktop, mobile and remote runtime.
TypeScript adeagent-ideai-agentsautomationbotclaude-codecodexghosttygrok-bothermes-agentmobile-appmuseopenclawopencodeorchestrationpiruntimeterminalworktreesyc-backed
import { mkdtemp, writeFile } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import {
startRendererTimingProbe,
stopRendererTimingProbe
} from './idle-cpu-renderer-timing-probe.mjs'
// Called with an already-attached main Orca page; never launches, focuses, or reloads it.
export async function captureLiveInputLag(page, durationMs = 30_000) {
if (!Number.isFinite(durationMs) || durationMs < 1_000 || durationMs > 60_000) {
throw new Error('Capture duration must be 1–60 seconds')
}
const identity = await page.evaluate(async () => {
if (!window.api?.app?.getIdentity) {
throw new Error('Target is not the main Orca renderer')
}
if (window.__orcaLiveInputLag || window.__orcaIdleCpuTimingProbe) {
throw new Error('A renderer timing probe already exists; stop it before capturing')
}
return window.api.app.getIdentity()
})
const directory = await mkdtemp(join(tmpdir(), 'orca-input-lag-'))
const cdp = await page.context().newCDPSession(page)
let timingStarted = false
let inputStarted = false
let profilingStarted = false
try {
await startRendererTimingProbe(page)
timingStarted = true
await page.evaluate(() => {
const events = []
const frames = []
const observers = []
const maxEntries = 3_000
let dropped = 0
const retain = (list, value) => {
if (list.length < maxEntries) {
list.push(value)
} else {
dropped++
}
}
const surface = (target) => {
if (!(target instanceof Element)) {
return 'other'
}
if (target.closest('.xterm')) {
return 'terminal'
}
if (target.closest('.monaco-editor')) {
return 'editor'
}
if (target.closest('[contenteditable="true"]')) {
return 'contenteditable'
}
return target.matches('input, textarea') ? 'text-input' : 'other'
}
const onInput = (event) => {
retain(events, {
kind: 'listener',
type: event.type,
surface: surface(event.target),
eventAt: event.timeStamp,
handlerAt: performance.now(),
trusted: event.isTrusted
})
}
const types = ['keydown', 'beforeinput', 'input', 'compositionstart', 'compositionend']
for (const type of types) {
document.addEventListener(type, onInput, true)
}
const supported = PerformanceObserver.supportedEntryTypes ?? []
if (supported.includes('event')) {
const observer = new PerformanceObserver((list) => {
for (const event of list.getEntries()) {
if (!types.includes(event.name)) {
continue
}
retain(events, {
kind: 'event-timing',
type: event.name,
surface: surface(event.target),
eventAt: event.startTime,
processingStart: event.processingStart,
processingEnd: event.processingEnd,
duration: event.duration,
interactionId: event.interactionId
})
}
})
observer.observe({ type: 'event', durationThreshold: 16 })
observers.push(observer)
}
let last = performance.now()
let frameId
const frame = (now) => {
if (now - last > 32) {
retain(frames, { at: now, gapMs: now - last })
}
last = now
frameId = requestAnimationFrame(frame)
}
frameId = requestAnimationFrame(frame)
const startedAt = performance.now()
const startedAtIso = new Date().toISOString()
window.__orcaLiveInputLag = {
stop: () => {
cancelAnimationFrame(frameId)
for (const type of types) {
document.removeEventListener(type, onInput, true)
}
for (const observer of observers) {
observer.disconnect()
}
delete window.__orcaLiveInputLag
return {
startedAt,
startedAtIso,
endedAt: performance.now(),
visibility: document.visibilityState,
events,
frames,
dropped,
eventTimingSupported: supported.includes('event')
}
}
}
})
inputStarted = true
await cdp.send('Profiler.enable')
const profileStartWindow = [await page.evaluate(() => performance.now())]
await cdp.send('Profiler.start')
profilingStarted = true
profileStartWindow.push(await page.evaluate(() => performance.now()))
await new Promise((resolve) => setTimeout(resolve, durationMs))
const { profile } = await cdp.send('Profiler.stop')
profilingStarted = false
const input = await page.evaluate(() => window.__orcaLiveInputLag.stop())
inputStarted = false
const timing = await stopRendererTimingProbe(page)
await page.evaluate(() => {
delete window.__orcaIdleCpuTimingProbe
})
timingStarted = false
await writeFile(join(directory, 'renderer.cpuprofile'), JSON.stringify(profile), {
mode: 0o600
})
await writeFile(
join(directory, 'input-timing.json'),
JSON.stringify(
{
identity,
input,
timing,
profileStartWindow,
limitation:
'Keyboard dispatch, handlers and frames only; not PTY echo latency. Event Timing omits short events and rounds durations.'
},
null,
2
),
{ mode: 0o600 }
)
return { directory, eventRecords: input.events.length, slowFrames: input.frames.length, timing }
} finally {
if (profilingStarted) {
await cdp.send('Profiler.stop').catch(() => {})
}
if (inputStarted) {
await page.evaluate(() => window.__orcaLiveInputLag?.stop()).catch(() => {})
}
if (timingStarted) {
await stopRendererTimingProbe(page).catch(() => {})
await page
.evaluate(() => {
delete window.__orcaIdleCpuTimingProbe
})
.catch(() => {})
}
await cdp.send('Profiler.disable').catch(() => {})
await cdp.detach().catch(() => {})
}
}