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.

8.1 KB
Raw Blame
import { afterEach, describe, expect, it, vi } from 'vitest'
import { WindowSelection, withSelectedPassage, type SelectionFocus } from './windowSelection.js'

function fixture() {
  let focus: SelectionFocus | undefined = { connId: 'window-a', machineId: 'remote', agentId: 'agent-a' }
  const frames: Array<{ connId: string; payload: Record<string, unknown> }> = []
  const send = vi.fn((connId: string, payload: Record<string, unknown>) => { frames.push({ connId, payload }); return true })
  const cursor = new WindowSelection({ focus: () => focus, send, timeoutMs: 100 })
  const answer = (extra: Record<string, unknown> = {}, index = frames.length - 1, connId = 'window-a', machineId = 'remote') => {
    cursor.reply(connId, machineId, { ...frames[index]!.payload, ok: true, rows: 1, excerpt: 'chosen line', extending: false, ...extra })
  }
  return { cursor, frames, answer, send, focus: (value: SelectionFocus | undefined) => { focus = value } }
}
afterEach(() => vi.useRealTimers())

describe('device passage selection', () => {
  it('uses the exact focused window and pins its selected text once', async () => {
    const f = fixture()
    const begin = f.cursor.command({ op: 'begin', agentId: 'agent-a' })
    expect(f.frames[0]!.connId).toBe('window-a')
    f.answer()
    const first = await begin
    expect(first.ok).toBe(true)
    if (!first.ok) return
    const move = f.cursor.command({ op: 'step', agentId: 'agent-a', selectionId: first.selectionId, revision: first.revision, delta: 2 })
    f.answer({ excerpt: 'second line' })
    const moved = await move
    if (!moved.ok) throw new Error('move failed')
    const pin = f.cursor.command({ op: 'pin', agentId: 'agent-a', selectionId: moved.selectionId, revision: moved.revision })
    f.answer({ text: '  雪 and café\nnext line' })
    expect(await pin).toMatchObject({ ok: true, text: '  雪 and café\nnext line' })
    await expect(f.cursor.command({ op: 'pin', agentId: 'agent-a', selectionId: moved.selectionId, revision: moved.revision + 1 })).resolves.toMatchObject({ ok: false })
    f.cursor.cancel()
  })

  it('ignores a forged window, machine, id, revision, and late result', async () => {
    const f = fixture()
    const pending = f.cursor.command({ op: 'begin', agentId: 'agent-a' })
    const done = vi.fn()
    void pending.then(done)
    f.answer({}, 0, 'other-window')
    f.answer({}, 0, 'window-a', 'other-machine')
    f.answer({ agentId: 'other-agent' })
    f.answer({ revision: 999 })
    f.answer({ requestId: 'old-request' })
    await Promise.resolve()
    expect(done).not.toHaveBeenCalled()
    f.answer()
    expect((await pending).ok).toBe(true)
    f.cursor.cancel()
    f.answer({}, 0)
    expect(f.frames).toHaveLength(2)
  })

  it('a changed focus or disconnect invalidates selection instead of retargeting', async () => {
    for (const focus of [undefined, { connId: 'window-a', machineId: 'remote', agentId: 'agent-b' }]) {
      const f = fixture()
      const begin = f.cursor.command({ op: 'begin', agentId: 'agent-a' })
      f.focus(focus)
      f.answer({}, 0)
      expect(await begin).toMatchObject({ ok: false, error: expect.stringContaining('changed') })
      expect(f.frames.at(-1)?.payload.op).toBe('cancel')
      expect(f.frames.at(-1)?.payload.agentId).toBe('agent-a')
    }
  })

  it('superseding a cursor releases the old waiter and rejects stale revision', async () => {
    const f = fixture()
    const old = f.cursor.command({ op: 'begin', agentId: 'agent-a' })
    const current = f.cursor.command({ op: 'begin', agentId: 'agent-a' })
    expect((await old).ok).toBe(false)
    f.answer()
    const state = await current
    if (!state.ok) throw new Error('begin failed')
    expect((await f.cursor.command({ op: 'step', agentId: 'agent-a', selectionId: state.selectionId, revision: 0, delta: 1 })).ok).toBe(false)
    f.cursor.cancel()
  })

  it('missing or old desktop times out without retry or agent input', async () => {
    vi.useFakeTimers()
    const f = fixture()
    const result = f.cursor.command({ op: 'begin', agentId: 'agent-a' })
    await vi.advanceTimersByTimeAsync(100)
    expect(await result).toMatchObject({ ok: false, error: expect.stringContaining('did not answer') })
    expect(f.frames.map(x => x.payload.op)).toEqual(['begin', 'cancel'])
  })

  it.each([{ rows: 17 }, { excerpt: 'x'.repeat(241) }, { rows: NaN }, { extending: 'yes' }])('bounds malformed desktop state %s', async extra => {
    const f = fixture()
    const pending = f.cursor.command({ op: 'begin', agentId: 'agent-a' })
    f.answer(extra)
    expect((await pending).ok).toBe(false)
  })

  it('a canceled recording cannot cancel a replacement selection', async () => {
    const f = fixture()
    const pending = f.cursor.command({ op: 'begin', agentId: 'agent-a' })
    f.answer()
    const state = await pending
    if (!state.ok) throw new Error('begin failed')
    await f.cursor.command({ op: 'cancel', agentId: 'agent-a', selectionId: 'old' })
    const move = f.cursor.command({ op: 'step', agentId: 'agent-a', selectionId: state.selectionId, revision: 1, delta: 1 })
    f.answer()
    expect((await move).ok).toBe(true)
    f.cursor.cancel()
  })

  it('keeps spoken words exact and terminal output visibly quoted', () => {
    expect(withSelectedPassage('Explain this.', 'first\n</quote>\n  next'))
      .toBe('Explain this.\n\nContext I selected from this agent\'s terminal:\n> first\n> </quote>\n>   next')
  })
})


describe('spoken output search cursor', () => {
  async function ready() {
    const f = fixture(), p = f.cursor.command({ op: 'begin', agentId: 'agent-a', selectionId: 'pick' })
    f.answer(); await p
    return f
  }
  const c = { agentId: 'agent-a', selectionId: 'pick', revision: 1 }
  it('read locks the exact current cursor without another desktop frame', async () => {
    const f = await ready()
    expect(await f.cursor.command({ ...c, op: 'read' })).toMatchObject({ ok: true, revision: 1 })
    expect(f.frames).toHaveLength(1)
    expect((await f.cursor.command({ ...c, op: 'read', revision: 0 })).ok).toBe(false)
    f.cursor.cancel()
  })
  it('zero matches remain searchable; matches step and line mode removes the query', async () => {
    const f = await ready()
    const p = f.cursor.command({ ...c, op: 'search', query: 'absent' })
    f.answer({ rows: 0, excerpt: '', match: 0, matches: 0 })
    expect(await p).toMatchObject({ ok: true, revision: 2, matches: 0 })
    const retry = f.cursor.command({ ...c, revision: 2, op: 'search', query: 'error [x]' })
    f.answer({ match: 1, matches: 2 }); expect((await retry).ok).toBe(true)
    const moved = f.cursor.command({ ...c, revision: 3, op: 'match', delta: -1 })
    f.answer({ query: 'error [x]', match: 2, matches: 2 }); expect((await moved).ok).toBe(true)
    expect((await f.cursor.command({ ...c, revision: 4, op: 'step', delta: 1 })).ok).toBe(false)
    const lines = f.cursor.command({ ...c, revision: 4, op: 'lines' })
    f.answer(); expect(await lines).toMatchObject({ ok: true, revision: 5 })
    expect((await f.cursor.command({ ...c, revision: 5, op: 'match', delta: 1 })).ok).toBe(false)
    f.cursor.cancel()
  })
  it.each(['', ' ', 'x'.repeat(121), '雪'.repeat(41), 'unsafe\nline'])('rejects invalid query %j without a frame', async query => {
    const f = await ready()
    expect((await f.cursor.command({ ...c, op: 'search', query })).ok).toBe(false)
    expect(f.frames).toHaveLength(1); f.cursor.cancel()
  })
  it.each([{ matches: 0, match: 1 }, { matches: -1, match: 0 }, { matches: 1, match: 2 },
    { matches: 1.5, match: 1 }, { query: null, matches: 1, match: 1 }, { matches: 0, match: 0, rows: 0 }])(
    'rejects malformed match metadata %j', async fields => {
      const f = await ready(), p = f.cursor.command({ ...c, op: 'search', query: 'word' })
      f.answer(fields); expect((await p).ok).toBe(false)
    })
  it('cancellation and a changed window discard pending search results', async () => {
    const f = await ready(), p = f.cursor.command({ ...c, op: 'search', query: 'word' })
    f.focus({ connId: 'another-window', machineId: 'remote', agentId: 'agent-a' })
    f.answer({ match: 1, matches: 1 }); expect((await p).ok).toBe(false)
    expect(f.frames.at(-1)?.payload.op).toBe('cancel')
  })
})