Skip to content

The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.

22.0 KB
Raw Blame
import { readInlineScreen } from '../testing/inlineScreen.js'
import { inlineSubmission } from '../testing/inlineSubmission.js'
import { CodexNormalizer } from '../engines/codex/normalizer.js'
import { lineToEvents, newTurnState, type LiveEvent } from '../lib/normalize.js'
import { randomUUID } from 'node:crypto'
import { afterEach, describe, expect, it, vi } from 'vitest'
import { AutonomousDeviceInput, isDeviceInputBoundary, type DeviceInputDeps } from './deviceInput.js'
import { SessionInputController } from '../lib/sessionInput.js'
import { AutonomousDeviceService } from '../lib/autonomous-device/service.js'
import type { RegisteredSession } from '../lib/registry.js'
import type { TerminalActionResult } from '../lib/terminalTypes.js'

function makeDevice(overrides: Partial<DeviceInputDeps>): AutonomousDeviceInput {
  return new AutonomousDeviceInput({
    getSession: () => ({ agentId: 'agent', engine: 'claude' }) as RegisteredSession,
    validateRuntime: async () => true, inject: async () => true, sendKey: async () => true,
    capture: async () => '› ', submission: inlineSubmission, acquireControl: () => () => {}, legacySubmit: vi.fn(), legacyCancel: () => false,
    onDelivery: vi.fn(), onInputStatus: vi.fn(), ...overrides,
  })
}

function fixture(engine: 'claude' | 'codex' | 'commandcode' = 'codex') {
  let available = true
  const session = { agentId: 'agent', engine, cliVersion: '0.106.0' } as RegisteredSession
  const inject = vi.fn(async (_target: string, _text: string): Promise<TerminalActionResult> => ({ state: 'succeeded', dispatch: 'executed' }))
  const capture = vi.fn(async (): Promise<string | null> => '› \nWorking…')
  const sendKey = vi.fn(async (_id: string, _key: string) => true)
  const events: Record<string, unknown>[] = []
  const service = new AutonomousDeviceService({
    machineId: 'machine', agents: () => available ? [{ agentId: 'agent', engine, name: 'Agent', state: 'working' }] : [],
    submit: (id, text, delivery) => controller.submit(id, text, delivery), cancelDelivery: id => controller.cancelDelivery(id),
    stop: async () => true, answer: async () => true, recent: () => [], emit: frame => events.push(frame),
  })
  const legacy: SessionInputController = new SessionInputController({ readScreen: readInlineScreen, submission: inlineSubmission,
    getSession: () => available ? session : undefined, validateRuntime: async () => available,
    inject: (id, text) => controller.legacyWrite(id, () => inject(id, text)),
    sendKey: (id, key) => controller.legacyWrite(id, () => sendKey(id, key)), capture, onError: vi.fn(),
    onDelivery: event => service.delivery(event),
  })
  const controller: AutonomousDeviceInput = new AutonomousDeviceInput({
    acquireControl: id => legacy.acquireControl(id, { forAnswer: true }),
    legacySubmit: (id, text, delivery) => legacy.submit(id, text, delivery),
    legacyCancel: id => legacy.cancelDelivery(id),
    onForget: id => service.agentGone(id),
    getSession: () => available ? session : undefined, validateRuntime: async () => available,
    inject, capture, sendKey, submission: inlineSubmission, onDelivery: event => service.delivery(event),
    onInputStatus: event => service.inputStatus(event),
  })
  const send = (key: string, text = key, focusRevision?: string) => service.request('device', {
    type: 'turn.send', requestId: randomUUID(), machineId: 'machine', agentId: 'agent', idempotencyKey: key, text,
    ...(focusRevision ? { focusRevision } : {}),
  })
  const start = (text: string) => { legacy.onTurnStarted('agent', text); controller.onTurnStarted('agent', text); service.turnStarted('agent') }
  const end = () => { service.turnEnded('agent'); legacy.onTurnEnded('agent'); controller.onTurnEnded('agent') }
  return { controller, legacy, service, inject, capture, sendKey, send, start, end, events,
    gone: () => { available = false; controller.forget('agent') }, receipt: (key: string) => service.receipt('device', key)! }
}

afterEach(() => vi.useRealTimers())

describe('in-flight input through the Autonomous Device contract', () => {
  it.each(['harness-use', 'Harness-only voice'])('%s delivers B before A ends, preserving retry and focus guards', async caller => {
    vi.useFakeTimers()
    const f = fixture()
    f.service.appFocus('machine', 'agent', 'desktop')
    const revision = caller === 'Harness-only voice' ? f.service.focusSnapshot().focusRevision : undefined
    await f.send('A', 'Create a house', revision)
    await vi.advanceTimersByTimeAsync(0)
    f.start('Create a house')
    await f.send('B', 'Make the roof red', revision)
    await vi.advanceTimersByTimeAsync(0)
    expect(f.inject.mock.calls.map(call => call[1])).toEqual(['Create a house', 'Make the roof red'])
    expect(f.receipt('A').state).toBe('started')
    expect(f.receipt('B')).toMatchObject({ state: 'delivered', input: { mode: 'steering', phase: 'accepted' } })
    // Lost RPC acknowledgment + reconnect: same key returns its own reservation.
    const before = f.receipt('B').deliveryId
    const cursor = f.service.resume().cursor
    const replay: unknown[] = []
    f.service.replay({ serverInstanceId: f.service.serverInstanceId, cursor: 0 }, event => replay.push(event))
    expect(replay.length).toBe(cursor)
    expect(await f.send('B', 'Make the roof red', revision)).toMatchObject({ status: 'duplicate', receipt: { deliveryId: before } })
    expect(f.inject).toHaveBeenCalledTimes(2)
    f.end()
    // A session end without engine result evidence cannot complete a native input.
    expect(f.receipt('A').state).toBe('unknown')
    expect(f.receipt('B').state).toBe('delivered')
    f.start('Make the roof red')
    f.end()
    expect(f.receipt('B').state).toBe('unknown')
    expect(f.receipt('B').turnId).not.toBe(f.receipt('A').turnId)
    f.controller.forget('agent')
  })

  it('serializes rapid Device A/B/C writes, while the agent stays busy', async () => {
    vi.useFakeTimers()
    const f = fixture()
    const finish: Array<() => void> = []
    f.inject.mockImplementation(() => new Promise(resolve => finish.push(() => resolve({ state: 'succeeded', dispatch: 'executed' }))))
    f.start('existing task')
    await f.send('A')
    await f.send('B')
    await f.send('C')
    expect(f.inject.mock.calls.map(call => call[1])).toEqual(['A'])
    expect(f.legacy.acquireControl('agent', { forAnswer: true })).toBeNull()
    finish[0]()
    await vi.advanceTimersByTimeAsync(0)
    expect(f.inject.mock.calls.map(call => call[1])).toEqual(['A', 'B'])
    finish[1]()
    await vi.advanceTimersByTimeAsync(0)
    expect(f.inject.mock.calls.map(call => call[1])).toEqual(['A', 'B', 'C'])
    finish[2]()
    await vi.advanceTimersByTimeAsync(0)
    expect(f.sendKey).not.toHaveBeenCalled()
    f.controller.forget('agent')
  })

  it('keeps native-queue receipts independent across the old turn ending', async () => {
    vi.useFakeTimers()
    const f = fixture('claude')
    f.start('existing task')
    await f.send('B')
    await f.send('C')
    await vi.advanceTimersByTimeAsync(0)
    expect(f.inject.mock.calls.map(call => call[1])).toEqual(['B', 'C'])
    expect(f.receipt('B').input).toEqual({ mode: 'native_queue', phase: 'accepted' })
    f.end()
    expect(f.receipt('B').state).toBe('delivered')
    expect(f.receipt('C').state).toBe('delivered')
    f.start('B'); f.end()
    expect(f.receipt('B').state).toBe('unknown')
    expect(f.receipt('C').state).toBe('delivered')
    f.start('C'); f.end()
    expect(f.receipt('C').state).toBe('unknown')
    f.controller.forget('agent')
  })

  it('does not assign one session done or summary to overlapping steered inputs', async () => {
    vi.useFakeTimers()
    const f = fixture()
    await f.send('A'); await vi.advanceTimersByTimeAsync(0); f.start('A')
    await f.send('B'); await vi.advanceTimersByTimeAsync(0); f.start('B')
    f.end()
    f.service.commander({ type: 'commander_event', agentId: 'agent', payload: { kind: 'summary', text: 'A answer' } })
    expect(f.receipt('A')).toMatchObject({ state: 'unknown', error: { code: 'RESULT_EVIDENCE_MISSING' } })
    expect(f.receipt('B')).toMatchObject({ state: 'unknown', error: { code: 'RESULT_EVIDENCE_MISSING' } })
    expect(f.events.findLast(event => event.kind === 'turn.done')).toMatchObject({ payload: {} })
    expect(await f.send('B')).toMatchObject({ status: 'duplicate' })
    expect(f.inject).toHaveBeenCalledTimes(2)
    f.controller.forget('agent')
  })

  it('does not attribute an untracked running task completion to a steered message', async () => {
    vi.useFakeTimers()
    const f = fixture()
    f.start('local task')
    await f.send('B'); await vi.advanceTimersByTimeAsync(0); f.start('B'); f.end()
    expect(f.receipt('B').state).toBe('unknown')
    f.controller.forget('agent')
  })

  it('never retries a timed-out native write or appends to an unconfirmed composer', async () => {
    vi.useFakeTimers()
    const f = fixture()
    f.inject.mockResolvedValue({ state: 'unknown', dispatch: 'possibly_executed', reason: 'ack lost' })
    f.capture.mockResolvedValue('› A')
    await f.send('A'); await f.send('B')
    await vi.advanceTimersByTimeAsync(30_000)
    expect(f.receipt('A').state).toBe('unknown')
    expect(f.receipt('B').state).toBe('queued')
    expect(f.inject).toHaveBeenCalledTimes(1)
    expect(f.sendKey).not.toHaveBeenCalled()
    expect(await f.send('A')).toMatchObject({ status: 'duplicate' })
    // A later transcript match is evidence; a timer was never permission to resend.
    f.start('A')
    await vi.advanceTimersByTimeAsync(0)
    expect(f.inject.mock.calls.map(call => call[1])).toEqual(['A', 'B'])
    f.controller.forget('agent')
  })

  it('does not treat an unreadable or dialog-only screen as an empty composer', async () => {
    vi.useFakeTimers()
    const f = fixture()
    f.capture.mockResolvedValue('Allow this tool?')
    await f.send('A'); await f.send('B'); await vi.advanceTimersByTimeAsync(30_000)
    expect(f.inject).toHaveBeenCalledTimes(1)
    expect(f.receipt('A').input?.phase).toBe('unconfirmed')
    f.controller.forget('agent')
  })

  it('queues unsupported engines in the daemon, with an explicit disposition', async () => {
    vi.useFakeTimers()
    const f = fixture('commandcode')
    f.start('existing task')
    await f.send('B')
    expect(f.inject).not.toHaveBeenCalled()
    expect(f.receipt('B').input).toEqual({ mode: 'daemon_queue', phase: 'waiting_for_turn' })
    f.end(); await vi.advanceTimersByTimeAsync(0)
    expect(f.inject.mock.calls.map(call => call[1])).toEqual(['B'])
    f.controller.forget('agent')
  })

  it('holds new prompts for a user action but lets the explicit answer acquire control', async () => {
    vi.useFakeTimers()
    const f = fixture()
    f.start('existing task')
    f.controller.setUserAction('agent', true)
    await f.send('B')
    expect(f.receipt('B').input).toEqual({ mode: 'daemon_queue', phase: 'waiting_for_user' })
    const release = f.legacy.acquireControl('agent', { forAnswer: true })
    expect(release).not.toBeNull()
    f.controller.setUserAction('agent', false)
    expect(f.inject).not.toHaveBeenCalled()
    release!(); await vi.advanceTimersByTimeAsync(1500)
    expect(f.inject.mock.calls.map(call => call[1])).toEqual(['B'])
    f.controller.forget('agent')
  })

  it('marks pasted work unknown and unsent work rejected when the session disappears', async () => {
    vi.useFakeTimers()
    const f = fixture()
    let finish!: () => void
    f.inject.mockImplementation(() => new Promise(resolve => { finish = () => resolve({ state: 'succeeded', dispatch: 'executed' }) }))
    await f.send('A'); await f.send('B')
    f.gone(); finish(); await vi.advanceTimersByTimeAsync(0)
    expect(f.receipt('A')).toMatchObject({ state: 'unknown', error: { code: 'AGENT_GONE' } })
    expect(f.receipt('B')).toMatchObject({ state: 'rejected', error: { code: 'agent_gone' } })
    expect(f.inject).toHaveBeenCalledTimes(1)
  })
})

describe('native input write evidence', () => {
  it('waits for a detected permission dialog to close before touching the composer', async () => {
    vi.useFakeTimers()
    let blocked = true
    const inject = vi.fn(async (_target: string, _text: string) => true)
    const statuses: unknown[] = []
    const controller = makeDevice({
      getSession: () => ({ agentId: 'agent', engine: 'claude' }) as RegisteredSession,
      validateRuntime: async () => true, isAwaitingUser: async () => blocked,
      inject, sendKey: async () => true, onInputStatus: event => statuses.push(event),
    })
    controller.onTurnStarted('agent', 'existing task')
    controller.submit('agent', 'B', 'B')
    await vi.advanceTimersByTimeAsync(0)
    expect(inject).not.toHaveBeenCalled()
    expect(statuses).toContainEqual({ sessionId: 'agent', deliveryId: 'B', mode: 'daemon_queue', phase: 'waiting_for_user' })
    blocked = false
    await vi.advanceTimersByTimeAsync(1500)
    expect(inject).toHaveBeenCalledExactlyOnceWith('agent', 'B')
    controller.forget('agent')
  })

  it('does not downgrade a transcript-confirmed start when the write acknowledgment is lost', async () => {
    vi.useFakeTimers()
    const f = fixture()
    let fail!: () => void
    f.inject.mockImplementation(() => new Promise((_resolve, reject) => { fail = () => reject(new Error('ack lost')) }))
    await f.send('A'); await vi.advanceTimersByTimeAsync(0)
    f.start('A'); fail(); await vi.advanceTimersByTimeAsync(0)
    expect(f.receipt('A').state).toBe('started')
    expect(f.receipt('A').input?.phase).toBe('accepted')
    expect(await f.send('A')).toMatchObject({ status: 'duplicate' })
    expect(f.inject).toHaveBeenCalledTimes(1)
    f.end()
    // A session end without engine result evidence cannot complete a native input.
    expect(f.receipt('A').state).toBe('unknown')
    f.controller.forget('agent')
  })

  it('marks an observed running delivery unknown when its session disappears', async () => {
    vi.useFakeTimers()
    const f = fixture()
    await f.send('A'); await vi.advanceTimersByTimeAsync(0); f.start('A')
    f.gone()
    expect(f.receipt('A')).toMatchObject({ state: 'unknown', error: { code: 'AGENT_GONE' } })
    f.end()
    // A session end without engine result evidence cannot complete a native input.
    expect(f.receipt('A').state).toBe('unknown')
  })

  it('holds the next writer across an evidence-backed Enter retry and never repeats a lost key acknowledgment', async () => {
    vi.useFakeTimers()
    const f = fixture()
    f.capture.mockResolvedValue('› A')
    let resolveKey!: (value: boolean) => void
    f.sendKey.mockImplementation(() => new Promise(resolve => { resolveKey = resolve }))
    await f.send('A'); await f.send('B')
    await vi.advanceTimersByTimeAsync(1500)
    expect(f.sendKey).toHaveBeenCalledExactlyOnceWith('agent', 'Enter')
    expect(f.inject).toHaveBeenCalledTimes(1)
    resolveKey(false) // no proof whether the key took effect
    await vi.advanceTimersByTimeAsync(30_000)
    expect(f.sendKey).toHaveBeenCalledTimes(1)
    expect(f.inject).toHaveBeenCalledTimes(1)
    expect(f.receipt('A').state).toBe('unknown')
    expect(f.receipt('B').state).toBe('queued')
    f.controller.forget('agent')
  })
})

it('lets the next message through once a write could not be checked after its paste', async () => {
  // The check before pressing Enter again could not see the agent (gone, or a probe that failed): the
  // first message is unknown, and the one behind it used to wait until a turn began or ended.
  vi.useFakeTimers()
  const answers = [true, false]
  const inject = vi.fn(async (_target: string, _text: string): Promise<TerminalActionResult> => ({ state: 'succeeded', dispatch: 'executed' }))
  const onDelivery = vi.fn()
  const device = makeDevice({
    getSession: () => ({ agentId: 'agent', engine: 'codex', cliVersion: '0.106.0' }) as RegisteredSession,
    validateRuntime: async () => answers.length ? answers.shift()! : true,
    inject, capture: async () => '› A', onDelivery,
  })
  device.submit('agent', 'A', 'delivery-A')
  device.submit('agent', 'B', 'delivery-B')
  await vi.advanceTimersByTimeAsync(5_000)
  expect(onDelivery).toHaveBeenCalledWith(expect.objectContaining({ deliveryId: 'delivery-A', state: 'unknown', reason: 'runtime_gone_post_paste' }))
  expect(inject).toHaveBeenLastCalledWith('agent', 'B')
  device.forget('agent')
})

it('preserves A/B order if a dialog appears during the first preflight check', async () => {
  vi.useFakeTimers()
  let release!: (blocked: boolean) => void
  const probe = vi.fn<() => Promise<boolean>>().mockImplementationOnce(() => new Promise(resolve => { release = resolve })).mockResolvedValue(false)
  const inject = vi.fn(async (_target: string, _text: string) => true)
  const controller = makeDevice({
    getSession: () => ({ agentId: 'agent', engine: 'claude' }) as RegisteredSession,
    validateRuntime: async () => true, isAwaitingUser: probe, inject, sendKey: async () => true,
  })
  controller.submit('agent', 'A', 'A')
  await vi.advanceTimersByTimeAsync(0)
  controller.submit('agent', 'B', 'B')
  release(true)
  await vi.advanceTimersByTimeAsync(1500)
  expect(inject.mock.calls.map(call => call[1])).toEqual(['A', 'B'])
  controller.forget('agent')
})


it.each(['codex', 'claude'] as const)('%s Device filter rejects an inferred completion without changing normalizer output', async engine => {
  vi.useFakeTimers()
  const f = fixture(engine)
  const codex = new CodexNormalizer('live')
  const claude = newTurnState()
  const normalizeUser = (text: string) => engine === 'codex'
    ? codex.ingest(JSON.stringify({ type: 'event_msg', payload: { type: 'user_message', message: text } }))
    : lineToEvents(JSON.stringify({ type: 'user', message: { role: 'user', content: [{ type: 'text', text }] } }), claude)
  const observe = (events: LiveEvent[]) => {
    for (const [index, event] of events.entries()) {
      if (isDeviceInputBoundary(inlineSubmission.policy(engine), events, index)) continue
      if (event.type === 'turn_started') f.start(event.payload.userMessage)
      if (event.type === 'turn_ended') f.end()
    }
  }
  await f.send('A'); await vi.advanceTimersByTimeAsync(0); observe(normalizeUser('A'))
  if (engine === 'claude') claude.pendingTools.add('running-tool')
  await f.send('B'); await vi.advanceTimersByTimeAsync(0)
  const inputEvents = normalizeUser('B')
  expect(inputEvents.map(event => event.type)).toEqual(['turn_ended', 'turn_started'])
  if (engine === 'claude') expect(claude.pendingTools.has('running-tool')).toBe(false) // unchanged shared normalizer
  observe(inputEvents)
  expect(f.receipt('A').state).toBe('started')
  expect(f.receipt('B').state).toBe('started')
  const endEvents = engine === 'codex'
    ? codex.ingest(JSON.stringify({ type: 'event_msg', payload: { type: 'task_complete' } }))
    : (() => {
      claude.pendingTools.delete('running-tool')
      return lineToEvents(JSON.stringify({ type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: 'done' }], stop_reason: 'end_turn' } }), claude)
    })()
  expect(endEvents.some(event => event.type === 'turn_ended')).toBe(true)
  observe(endEvents)
  expect(f.receipt('A').state).toBe('unknown')
  expect(f.receipt('B').state).toBe('unknown')
  f.controller.forget('agent')
})

it('excludes legacy writes only during Device ownership of the same pane', async () => {
  vi.useFakeTimers()
  const writes: string[] = []
  let finish!: () => void
  const controller = makeDevice({
    inject: async () => { writes.push('device'); await new Promise<void>(resolve => { finish = resolve }); return true },
  })
  await controller.legacyWrite('agent', async () => { writes.push('local-before') })
  controller.submit('agent', 'A', 'delivery-A')
  await vi.advanceTimersByTimeAsync(0)
  const local = controller.legacyWrite('agent', async () => { writes.push('local-after') })
  await controller.legacyWrite('other', async () => { writes.push('other-pane') })
  expect(writes).toEqual(['local-before', 'device', 'other-pane'])
  finish()
  await vi.advanceTimersByTimeAsync(0)
  await local
  expect(writes).toEqual(['local-before', 'device', 'other-pane', 'local-after'])
  controller.forget('agent')
})

it('says why a write the pane refused was not typed, when a dialog opened after the look for one', async () => {
  // The look before the write found the composer; the engine opened a permission prompt in between, and the
  // write refused it unwritten (core/input.ts, messageHold.ts). The refusal carries that reason, not a paste
  // that failed.
  const onDelivery = vi.fn()
  const results: TerminalActionResult[] = [
    { state: 'failed', dispatch: 'not_started', reason: 'permission_open' },
    { state: 'failed', dispatch: 'not_started', reason: 'terminal agent is unavailable' },
  ]
  const device = makeDevice({ inject: async () => results.shift()!, isAwaitingUser: async () => false, onDelivery })
  device.submit('agent', 'A', 'delivery-A')
  await vi.waitFor(() => expect(onDelivery).toHaveBeenCalledWith(expect.objectContaining({ deliveryId: 'delivery-A', state: 'rejected', reason: 'permission_open' })))
  device.submit('agent', 'B', 'delivery-B')
  await vi.waitFor(() => expect(onDelivery).toHaveBeenCalledWith(expect.objectContaining({ deliveryId: 'delivery-B', state: 'rejected', reason: 'paste_failed' })))
  device.forget('agent')
})

// "Later" on a fake clock: past every retry the device could schedule (VERIFY_MS, 1.5 s) several times over,
// at no cost in real time. It waited 2 s of real time, which with the wait before it took the case past
// vitest's 5 s in a full run under load.
it('refuses with the reason a message typed but not sent, its Enter withheld as a dialog opened, and presses no Enter later', async () => {
  vi.useFakeTimers({ toFake: ['setTimeout', 'clearTimeout', 'setInterval', 'clearInterval'] })
  const onDelivery = vi.fn(), sendKey = vi.fn(async () => true)
  const device = makeDevice({ inject: async () => ({ state: 'unknown', dispatch: 'possibly_executed', reason: 'enter_withheld:question_open' }),
    isAwaitingUser: async () => false, onDelivery, sendKey, capture: async () => '› A' })
  device.submit('agent', 'A', 'delivery-A')
  await vi.waitFor(() => expect(onDelivery).toHaveBeenCalledWith(expect.objectContaining({ deliveryId: 'delivery-A', state: 'rejected', reason: 'enter_withheld' })))
  await vi.advanceTimersByTimeAsync(10_000)
  expect(sendKey).not.toHaveBeenCalled()
  device.forget('agent')
})