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 { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
const { runProcess } = vi.hoisted(() => ({ runProcess: vi.fn() }))
vi.mock('@orca/process-host', () => ({ runProcess }))
vi.mock('./darwin-terminal-names', () => ({
nameDarwinTerminalDevices: async (devices: ReadonlySet<string>) =>
new Map([...devices].filter((device) => device === '16/4').map((device) => [device, 'ttys004']))
}))
import {
setLibprocAddonForTests,
type LibprocAddon,
type LibprocProcessRow,
type LibprocQuery
} from './libproc-addon'
import { nativeReadWaitersForTests, resetNativeReadsForTests } from './libproc-native-reads'
import { runPsInProcess } from './libproc-process-table'
import { resetPsFallbackForTests } from './libproc-ps-fallback'
import { createProcessTableSnapshotReader } from './process-table-snapshot-reader'
import { parseCheapProcessTableRows, parseStrictProcessTableRows } from './process-table-snapshot'
const TTYS004 = (16 << 24) | 4
// 2026-09-03T16:02:01Z, a single-digit day so lstart pads it.
const START = Date.UTC(2026, 8, 3, 16, 2, 1) / 1000
// Pin the locale so lstart formatting doesn't depend on the runner's LANG.
const BUDGET = { timeoutMs: 1000, env: { LC_ALL: 'C' } }
function row(overrides: Partial<LibprocProcessRow>): LibprocProcessRow {
return {
pid: 1,
ppid: 0,
pgid: 1,
tpgid: 0,
tdev: -1,
status: 2,
flags: 0,
sessionLeader: false,
startSec: START,
comm: 'launchd',
command: '/sbin/launchd',
commandIncomplete: true,
...overrides
}
}
const TABLE = [
row({
pid: 4300,
ppid: 4242,
pgid: 4300,
tpgid: 4300,
tdev: TTYS004,
flags: 0x2,
comm: 'node',
command: 'node /usr/local/bin/claude --resume',
commandIncomplete: false
}),
row({
pid: 4242,
ppid: 4200,
pgid: 4242,
tpgid: 4300,
tdev: TTYS004,
flags: 0x2,
sessionLeader: true,
comm: 'zsh',
command: '-zsh',
commandIncomplete: false
}),
// A pane's root login is root-owned and sits under the terminal host.
row({
pid: 4200,
ppid: 1,
pgid: 4200,
tdev: TTYS004,
flags: 0x2,
comm: 'login',
command: '/usr/bin/login'
}),
row({
pid: 4400,
ppid: 4242,
pgid: 4400,
tpgid: 4300,
status: 4,
comm: 'vim',
command: 'vim',
commandIncomplete: false
}),
row({ pid: 4401, ppid: 4242, pgid: 4401, status: 5, comm: 'sh', command: '<defunct>' }),
row({})
]
function tableFor(
query: LibprocQuery,
table: readonly LibprocProcessRow[] = TABLE
): LibprocProcessRow[] | null {
if (query.tty !== undefined && !/^(?:\/dev\/)?ttys004$/.test(query.tty)) {
return null
}
return table
.filter((entry) => !query.pids || query.pids.includes(entry.pid))
.filter((entry) => query.tty === undefined || entry.tdev === TTYS004)
.map((entry) =>
query.command ? entry : { ...entry, command: undefined, commandIncomplete: undefined }
)
}
function installAddon(overrides: Partial<LibprocAddon> = {}): LibprocAddon {
const addon: LibprocAddon = {
readProcessTable: vi.fn(async (query: LibprocQuery) => tableFor(query)),
readProcessCwd: vi.fn(async () => null),
readProcessPath: vi.fn(async () => null),
...overrides
}
setLibprocAddonForTests(addon)
return addon
}
// Orca's euid is pinned, so neither a root runner nor Windows (no geteuid) changes whose argv is "own".
const OWN_UID = 501
const OTHER_UID = 502
const realGeteuid = process.geteuid
beforeEach(() => {
process.geteuid = () => OWN_UID
})
const PS_RESULT = {
code: 0,
signal: null,
stdout: ' 1\n',
stderr: '',
timedOut: false,
outputTruncated: false
}
afterEach(() => {
process.geteuid = realGeteuid
setLibprocAddonForTests(undefined)
resetNativeReadsForTests()
resetPsFallbackForTests()
runProcess.mockReset()
vi.useRealTimers()
})
describe('runPsInProcess', () => {
it('prints a whole-table capture the strict and cheap parsers read like ps output', async () => {
installAddon()
const utc = { env: { TZ: 'UTC0', LC_ALL: 'C' }, timeoutMs: 1000 }
const full = await runPsInProcess(
['-axo', 'pid=,ppid=,pgid=,tpgid=,stat=,tty=,lstart=,command='],
utc
)
expect(full?.code).toBe(0)
// ps sorts by terminal, then pid.
expect(parseStrictProcessTableRows(full!.stdout)).toEqual([
expect.objectContaining({ pid: 1, tty: '??', command: '/sbin/launchd' }),
expect.objectContaining({ pid: 4400, stat: 'T', tty: '??', command: 'vim' }),
expect.objectContaining({ pid: 4401, stat: 'Z', command: '<defunct>' }),
expect.objectContaining({ pid: 4200, stat: 'S', tty: 'ttys004', command: '/usr/bin/login' }),
expect.objectContaining({ pid: 4242, stat: 'Ss', tty: 'ttys004', command: '-zsh' }),
expect.objectContaining({
pid: 4300,
stat: 'S+',
tty: 'ttys004',
startTime: 'Thu Sep 3 16:02:01 2026',
command: 'node /usr/local/bin/claude --resume'
})
])
// Neither the root daemon nor the pane's root login is a pane descendant worth a setuid ps.
expect(runProcess).not.toHaveBeenCalled()
const cheap = await runPsInProcess(['-axo', 'pid=,ppid=,pgid=,tpgid=,stat=,lstart='], utc)
expect(parseCheapProcessTableRows(cheap!.stdout).at(-1)).toEqual({
pid: 4300,
ppid: 4242,
pgid: 4300,
tpgid: 4300,
stat: 'S+',
startTime: 'Thu Sep 3 16:02:01 2026'
})
})
it('selects by pid or terminal and exits 1 like ps when nothing matches', async () => {
const addon = installAddon()
expect(await runPsInProcess(['-p', '4300,4300', '-o', 'pid=,tdev='], BUDGET)).toMatchObject({
code: 0,
stdout: '4300 16/4\n'
})
expect(addon.readProcessTable).toHaveBeenLastCalledWith({ command: false, pids: [4300] })
expect(await runPsInProcess(['-p', '9999', '-o', 'stat=,lstart='], BUDGET)).toMatchObject({
code: 1,
stdout: ''
})
const tty = await runPsInProcess(['-o', 'pid=,stat=', '-t', '/dev/ttys004'], BUDGET)
expect(tty?.stdout).toBe('4200 S\n4242 Ss\n4300 S+\n')
expect(addon.readProcessTable).toHaveBeenLastCalledWith({ command: false, tty: '/dev/ttys004' })
expect(await runPsInProcess(['-o', 'pid=', '-t', 'ttys999'], BUDGET)).toMatchObject({
code: 1,
timedOut: false
})
})
it('keeps the real ps for invocations it cannot reproduce, and answers a failing addon with /bin/ps', async () => {
installAddon()
expect(await runPsInProcess(['-axo', 'pid=PROCESS_ID'], BUDGET)).toBeNull()
expect(await runPsInProcess(['-axo', 'pid=,uid='], BUDGET)).toBeNull()
expect(await runPsInProcess(['-e', '-o', 'pid='], BUDGET)).toBeNull()
expect(await runPsInProcess(['-p', '1', '-t', 'ttys004', '-o', 'pid='], BUDGET)).toBeNull()
expect(
await runPsInProcess(['-axo', 'lstart='], { env: { TZ: 'America/New_York' }, timeoutMs: 1 })
).toBeNull()
expect(
await runPsInProcess(['-axo', 'lstart='], { env: { LC_ALL: 'de_DE.UTF-8' }, timeoutMs: 1 })
).toBeNull()
installAddon({
readProcessTable: async () => {
throw new Error('sysctl failed')
}
})
runProcess.mockResolvedValue(PS_RESULT)
expect(await runPsInProcess(['-axo', 'pid='], BUDGET)).toEqual(PS_RESULT)
expect(runProcess).toHaveBeenCalledWith(
expect.objectContaining({ program: '/bin/ps', args: ['-axo', 'pid='] })
)
setLibprocAddonForTests(null)
expect(await runPsInProcess(['-axo', 'pid='], BUDGET)).toBeNull()
})
it('times out each caller of a stalled shared read like a killed ps', async () => {
vi.useFakeTimers()
const addon = installAddon({ readProcessTable: vi.fn(() => new Promise<never>(() => {})) })
const short = runPsInProcess(['-p', '4300', '-o', 'pid=,tpgid=,tty='], { timeoutMs: 125 })
const long = runPsInProcess(['-p', '4300', '-o', 'pid=,tpgid=,tty='], { timeoutMs: 1000 })
await vi.advanceTimersByTimeAsync(125)
await expect(short).resolves.toMatchObject({ code: null, timedOut: true, stdout: '' })
await vi.advanceTimersByTimeAsync(875)
await expect(long).resolves.toMatchObject({ timedOut: true })
expect(addon.readProcessTable).toHaveBeenCalledTimes(1)
})
it('asks ps once for argv only it can read, for another user’s process under a pane shell', async () => {
const sudo = row({
pid: 4500,
ppid: 4242,
pgid: 4500,
tpgid: 4300,
tdev: TTYS004,
flags: 0x2,
comm: 'node',
command: '/usr/local/bin/node'
})
installAddon({
readProcessTable: vi.fn(async (query: LibprocQuery) => tableFor(query, [...TABLE, sudo]))
})
runProcess.mockResolvedValue({
code: 0,
signal: null,
stdout: ' 4500 node /usr/local/lib/claude-code/cli.js\n',
stderr: '',
timedOut: false
})
const args = ['-o', 'pid=,ppid=,pgid=,tpgid=,stat=,command=', '-t', 'ttys004']
const options = { env: { LC_ALL: 'en_US.UTF-8' }, timeoutMs: 1000 }
for (let poll = 0; poll < 2; poll += 1) {
const result = await runPsInProcess(args, options)
expect(result?.stdout).toContain(
'4500 4242 4500 4300 S node /usr/local/lib/claude-code/cli.js'
)
expect(result?.stdout).toContain('4200 1 4200 0 S /usr/bin/login')
}
expect(runProcess).toHaveBeenCalledTimes(1)
expect(runProcess).toHaveBeenCalledWith(
expect.objectContaining({
program: '/bin/ps',
args: ['-ww', '-o', 'pid=,command=', '-p', '4500']
})
)
})
it('never joins a read submitted before the request, so stale rows never reach a caller', async () => {
type Rows = LibprocProcessRow[] | null
let finishStale: (rows: Rows) => void = () => {}
const stale = new Promise<Rows>((resolve) => {
finishStale = resolve
})
const readProcessTable = vi
.fn<(query: LibprocQuery) => Promise<Rows>>()
.mockReturnValueOnce(stale)
.mockImplementation(async (query) => tableFor(query))
installAddon({ readProcessTable })
const args = ['-axo', 'pid=,ppid=']
expect(await runPsInProcess(args, { timeoutMs: 10 })).toMatchObject({ timedOut: true })
const fresh = runPsInProcess(args, BUDGET)
finishStale([row({ pid: 9999, ppid: 4242 })])
expect((await fresh)?.stdout).not.toContain('9999')
expect(readProcessTable).toHaveBeenCalledTimes(2)
})
it('queues past the read cap without retaining timed-out waiters, then hands a stalled pool to budgeted ps', async () => {
vi.useFakeTimers()
const addon = installAddon({ readProcessTable: vi.fn(() => new Promise<never>(() => {})) })
runProcess.mockResolvedValue(PS_RESULT)
const read = (pid: number, timeoutMs = 50) =>
runPsInProcess(['-p', String(pid), '-o', 'pid='], { timeoutMs })
// Eight distinct reads fill the cap and stall; overflow callers wait on one slot notifier.
const capped = Array.from({ length: 8 }, (_, index) => read(5000 + index, 10_000))
const overflow = Array.from({ length: 300 }, (_, index) => read(6000 + index))
expect(nativeReadWaitersForTests()).toBe(300)
await vi.advanceTimersByTimeAsync(50)
expect(nativeReadWaitersForTests()).toBe(0)
// The stalled burst costs the fork budget, not one ps per caller; the rest time out like a killed ps.
await vi.advanceTimersByTimeAsync(50)
const results = await Promise.all(overflow)
expect(results.filter((result) => result?.timedOut === false)).toHaveLength(4)
expect(results.filter((result) => result?.timedOut === true)).toHaveLength(296)
expect(runProcess).toHaveBeenCalledTimes(4)
// The breaker stays open for its cool-down: callers go to ps without queueing on the pool.
await vi.advanceTimersByTimeAsync(1_000)
expect(await read(7000)).toEqual(PS_RESULT)
expect(nativeReadWaitersForTests()).toBe(0)
expect(addon.readProcessTable).toHaveBeenCalledTimes(8)
await vi.advanceTimersByTimeAsync(10_000)
expect(await Promise.all(capped)).toEqual(
Array(8).fill(expect.objectContaining({ timedOut: true }))
)
// Past the cool-down with the cap still held, callers learn it at once instead of after their timeout.
await vi.advanceTimersByTimeAsync(30_000)
let settled: unknown = 'pending'
void read(8000, 5_000).then((result) => {
settled = result
})
await vi.advanceTimersByTimeAsync(0)
expect(settled).toEqual(PS_RESULT)
})
it('recovers argv for a sudo use_pty tree on its own pty, but not for root daemons or GUI helpers', async () => {
const TTYS005 = (16 << 24) | 5
const root = { commandIncomplete: true, flags: 0x2 }
const table = [
...TABLE,
row({
...root,
pid: 4600,
ppid: 4242,
tdev: TTYS004,
comm: 'sudo',
command: '/usr/bin/sudo'
}),
row({
...root,
pid: 4601,
ppid: 4600,
tdev: TTYS005,
comm: 'sudo',
command: '/usr/bin/sudo'
}),
row({ ...root, pid: 4602, ppid: 4601, tdev: TTYS005, comm: 'zsh', command: '/bin/zsh' }),
row({ ...root, pid: 4603, ppid: 4602, tdev: TTYS005, comm: 'node', command: '/opt/node' }),
row({ pid: 300, ppid: 1, comm: 'syslogd', command: '/usr/sbin/syslogd' }),
row({
pid: 700,
ppid: 1,
comm: 'Orca',
command: '/Applications/Orca',
commandIncomplete: false
}),
row({ pid: 701, ppid: 700, comm: 'helper', command: '/usr/libexec/helper' })
]
installAddon({ readProcessTable: vi.fn(async (query: LibprocQuery) => tableFor(query, table)) })
runProcess.mockResolvedValue({ code: 0, signal: null, stdout: '', stderr: '', timedOut: false })
await runPsInProcess(['-axo', 'pid=,command='], { env: { LC_ALL: 'C' }, timeoutMs: 1000 })
const pids = runProcess.mock.calls[0]?.[0].args.at(-1).split(',').map(Number).sort()
expect(pids).toEqual([4600, 4601, 4602, 4603])
})
it('asks ps again once exec changes the program behind a cached pid and start time', async () => {
const shell = row({ pid: 4700, ppid: 4242, tdev: TTYS004, comm: 'zsh', command: '/bin/zsh' })
let current = shell
installAddon({
readProcessTable: vi.fn(async (query: LibprocQuery) => tableFor(query, [...TABLE, current]))
})
runProcess.mockImplementation(async () => ({
code: 0,
signal: null,
stdout: current === shell ? ' 4700 -zsh\n' : ' 4700 node /opt/claude/cli.js\n',
stderr: '',
timedOut: false
}))
const args = ['-p', '4700', '-o', 'command=']
const options = { env: { LC_ALL: 'C' }, timeoutMs: 1000 }
expect((await runPsInProcess(args, options))?.stdout).toBe('-zsh\n')
expect((await runPsInProcess(args, options))?.stdout).toBe('-zsh\n')
current = { ...shell, comm: 'node', command: '/opt/node' }
expect((await runPsInProcess(args, options))?.stdout).toBe('node /opt/claude/cli.js\n')
expect(runProcess).toHaveBeenCalledTimes(2)
})
it('lets concurrent tty= readers wait out one naming pass instead of running ps', async () => {
installAddon()
// 4300's read is still stalled from the timeout case above.
const args = ['-o', 'pid=,tty=', '-p', '4242']
const results = await Promise.all([1, 2, 3].map(() => runPsInProcess(args, BUDGET)))
expect(results.map((result) => result?.stdout)).toEqual(Array(3).fill('4242 ttys004\n'))
expect(runProcess).not.toHaveBeenCalled()
})
it('leaves argv of the user’s own mid-exec processes and of exiting ones to (comm), asking ps only for other users', async () => {
const foreign = { ppid: 4242, tdev: TTYS004, uid: OTHER_UID, flags: 0x2 }
const table = [
...TABLE,
// A pane looping short commands: our own child between fork and exec reads like another user's.
row({ pid: 4800, ppid: 4242, tdev: TTYS004, uid: OWN_UID, comm: 'git', command: '(git)' }),
row({ ...foreign, pid: 4801, flags: 0x2 | 0x2000, comm: 'sudo', command: '(sudo)' }),
row({ ...foreign, pid: 4802, status: 1, comm: 'sudo', command: '(sudo)' }),
row({ ...foreign, pid: 4803, comm: 'node', command: '(node)' })
]
installAddon({ readProcessTable: vi.fn(async (query: LibprocQuery) => tableFor(query, table)) })
runProcess.mockResolvedValue({
code: 0,
signal: null,
stdout: ' 4803 node /opt/claude/cli.js\n',
stderr: '',
timedOut: false
})
const result = await runPsInProcess(['-axo', 'pid=,command='], BUDGET)
expect(result?.stdout).toContain('4800 (git)\n')
expect(result?.stdout).toContain('4803 node /opt/claude/cli.js\n')
expect(runProcess).toHaveBeenCalledTimes(1)
expect(runProcess.mock.calls[0]?.[0].args.at(-1)).toBe('4803')
})
it('shares one argv ps among concurrent readers and waits out a failed recovery before asking again', async () => {
vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'performance'] })
const sudo = row({
pid: 4900,
ppid: 4242,
tdev: TTYS004,
uid: OTHER_UID,
comm: 'node',
command: '(node)'
})
installAddon({
readProcessTable: vi.fn(async (query: LibprocQuery) => tableFor(query, [...TABLE, sudo]))
})
// ps omits a process that exited, or one it cannot read either.
runProcess.mockResolvedValue({ code: 1, signal: null, stdout: '', stderr: '', timedOut: false })
const read = (): Promise<unknown> =>
runPsInProcess(['-o', 'pid=,command=', '-t', 'ttys004'], BUDGET)
const concurrent = await Promise.all(Array.from({ length: 24 }, read))
expect(concurrent).toEqual(Array(24).fill(expect.objectContaining({ timedOut: false })))
expect(runProcess).toHaveBeenCalledTimes(1)
await read()
expect(runProcess).toHaveBeenCalledTimes(1)
await vi.advanceTimersByTimeAsync(5_000)
await read()
expect(runProcess).toHaveBeenCalledTimes(2)
})
it('reuses recovered argv for at most 1.5s, so a same-comm re-exec is seen', async () => {
vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'performance'] })
const sudo = row({
pid: 5100,
ppid: 4242,
tdev: TTYS004,
uid: OTHER_UID,
comm: 'node',
command: '(node)'
})
installAddon({
readProcessTable: vi.fn(async (query: LibprocQuery) => tableFor(query, [...TABLE, sudo]))
})
// Same pid, start time and comm: node re-exec'd from Claude into an unrelated server.
let argv = 'node /opt/claude/cli.js'
runProcess.mockImplementation(async () => ({
code: 0,
signal: null,
stdout: ` 5100 ${argv}\n`,
stderr: '',
timedOut: false
}))
const args = ['-p', '5100', '-o', 'command=']
expect((await runPsInProcess(args, BUDGET))?.stdout).toBe(`node /opt/claude/cli.js\n`)
argv = 'node /srv/server.js'
expect((await runPsInProcess(args, BUDGET))?.stdout).toBe(`node /opt/claude/cli.js\n`)
await vi.advanceTimersByTimeAsync(1_500)
expect((await runPsInProcess(args, BUDGET))?.stdout).toBe('node /srv/server.js\n')
expect(runProcess).toHaveBeenCalledTimes(2)
})
it('waits out a failed recovery from when ps gave up, however long it ran', async () => {
vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'performance'] })
const sudo = row({
pid: 5200,
ppid: 4242,
tdev: TTYS004,
uid: OTHER_UID,
comm: 'su',
command: '(su)'
})
installAddon({
readProcessTable: vi.fn(async (query: LibprocQuery) => tableFor(query, [...TABLE, sudo]))
})
// A loaded host: ps takes 6s, then omits the process.
let finish: () => void = () => {}
runProcess.mockImplementation(
() =>
new Promise((resolve) => {
finish = () => resolve({ code: 1, signal: null, stdout: '', stderr: '', timedOut: false })
})
)
const read = () => runPsInProcess(['-p', '5200', '-o', 'command='], { timeoutMs: 10_000 })
const slow = read()
await vi.advanceTimersByTimeAsync(6_000)
finish()
await slow
await read()
expect(runProcess).toHaveBeenCalledTimes(1)
})
it('recovers a su pane’s argv within the recovery budget however often it is read', async () => {
vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'performance'] })
const su = row({
pid: 5300,
ppid: 4242,
tdev: TTYS004,
uid: OTHER_UID,
comm: 'su',
command: '(su)'
})
installAddon({
readProcessTable: vi.fn(async (query: LibprocQuery) => tableFor(query, [...TABLE, su]))
})
runProcess.mockResolvedValue({
code: 0,
signal: null,
stdout: ' 5300 su -l\n',
stderr: '',
timedOut: false
})
const args = ['-o', 'pid=,command=', '-t', 'ttys004']
const reads: ReturnType<typeof runPsInProcess>[] = []
for (let poll = 0; poll < 20; poll += 1) {
// readTerminalProcessRows' budget: a read may wait for the next recovery token.
reads.push(runPsInProcess(args, { ...BUDGET, timeoutMs: 3_000 }))
await vi.advanceTimersByTimeAsync(750)
}
for (const read of await Promise.all(reads)) {
expect(read?.stdout).toContain('5300 su -l\n')
}
// The recovery budget: a burst of 2, then one per 2s over the ~16s the reads span.
expect(runProcess.mock.calls.length).toBeLessThanOrEqual(10)
})
it('asks again at once after a recovery ps that timed out, which proved nothing', async () => {
const su = row({
pid: 5350,
ppid: 4242,
tdev: TTYS004,
uid: OTHER_UID,
comm: 'su',
command: '(su)'
})
installAddon({
readProcessTable: vi.fn(async (query: LibprocQuery) => tableFor(query, [...TABLE, su]))
})
runProcess
.mockResolvedValueOnce({
code: null,
signal: 'SIGTERM',
stdout: '',
stderr: '',
timedOut: true
})
.mockResolvedValue({
code: 0,
signal: null,
stdout: ' 5350 su -l\n',
stderr: '',
timedOut: false
})
const read = () => runPsInProcess(['-p', '5350', '-o', 'command='], BUDGET)
expect((await read())?.stdout).toBe('(su)\n')
expect((await read())?.stdout).toBe('su -l\n')
})
it('recovers the foreground of a terminal where no process of ours is left (exec su)', async () => {
const root = { tdev: TTYS004, uid: OTHER_UID, flags: 0x2, tpgid: 5400 }
const table = [
row({ ...root, pid: 4200, ppid: 1, pgid: 4200, comm: 'login', command: '(login)' }),
row({ ...root, pid: 5400, ppid: 4200, pgid: 5400, comm: 'sh', command: '(sh)' })
]
installAddon({ readProcessTable: vi.fn(async (query: LibprocQuery) => tableFor(query, table)) })
runProcess.mockResolvedValue({
code: 0,
signal: null,
stdout: ' 5400 -sh\n',
stderr: '',
timedOut: false
})
const result = await runPsInProcess(['-o', 'pid=,command=', '-t', 'ttys004'], BUDGET)
expect(result?.stdout).toContain('5400 -sh\n')
// The pane's root login is not in the foreground group, so it never costs a ps.
expect(runProcess.mock.calls.map(([spec]) => spec.args.at(-1))).toEqual(['5400'])
})
describe('recovered argv age in strict evidence', () => {
// Each case its own pid: the argv cache is process-wide.
let pid = 5500
const agent = () =>
row({
pid,
ppid: 4242,
tdev: TTYS004,
uid: OTHER_UID,
comm: 'node',
command: '(node)'
})
const args = ['-o', 'pid=,command=', '-t', 'ttys004']
// The production reader, stamping on the same monotonic clock the fake timers drive.
const strictReader = () =>
createProcessTableSnapshotReader({
runPs: (_fresh, inputAt) =>
runPsInProcess(args, { ...BUDGET, timeoutMs: 10_000, onArgvReadAt: inputAt }).then(
(result) => result?.stdout
),
now: () => performance.now(),
ttlMs: 0
})
const psAnswers = (argv: () => string) =>
runProcess.mockImplementation(async () => ({
code: 0,
signal: null,
stdout: ` ${pid} ${argv()}\n`,
stderr: '',
timedOut: false
}))
beforeEach(() => {
vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'performance'] })
installAddon({
readProcessTable: vi.fn(async (query: LibprocQuery) => tableFor(query, [...TABLE, agent()]))
})
})
it('ages a capture by the cached argv it reused, so a same-comm re-exec cannot read as fresh', async () => {
let argv = 'node /opt/claude/cli.js'
psAnswers(() => argv)
const reader = strictReader()
await reader.getSnapshotWithAge()
// node re-execs into a server; same pid, start time and comm.
argv = 'node /srv/server.js'
await vi.advanceTimersByTimeAsync(1_400)
const snapshot = await reader.getSnapshotWithAge()
expect(snapshot.value).toContain('claude')
expect(snapshot.capturedAgeMs).toBeGreaterThanOrEqual(1_400)
})
it('never answers a reader with a recovery begun more than 1.5s before it asked', async () => {
pid = 5600
let finishSlow: (stdout: string) => void = () => {}
runProcess
.mockImplementationOnce(
() =>
new Promise((resolve) => {
finishSlow = (stdout) =>
resolve({ code: 0, signal: null, stdout, stderr: '', timedOut: false })
})
)
.mockResolvedValue({
code: 0,
signal: null,
stdout: ' 5600 node /srv/server.js\n',
stderr: '',
timedOut: false
})
// Two captures (say the daemon's and main's), sharing one recovery that takes 6s.
void strictReader().getSnapshotWithAge()
await vi.advanceTimersByTimeAsync(5_900)
const late = strictReader().getSnapshotWithAge()
await vi.advanceTimersByTimeAsync(100)
finishSlow(' 5600 node /opt/claude/cli.js\n')
const snapshot = await late
expect(snapshot.value).toContain('/srv/server.js')
expect(runProcess).toHaveBeenCalledTimes(2)
})
})
})