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.

7.2 KB
Raw Blame
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join } from 'node:path'

// The tree below a Cursor home is the wrong thing to watch: one macOS box had 6,849 folders under
// ~/.cursor/projects for 10 transcripts, and a recursive watcher of that size stalls the daemon's
// event loop (libuv rebuilds its single FSEvents stream on every add/remove). The discovery must
// never reach for a directory watcher again, whichever library it would be.
vi.mock('chokidar', () => ({
  default: { watch: () => { throw new Error('cursor discovery must not watch the projects tree') } },
}))

const SESSION_A = 'aaaaaaaa-1111-4222-8333-444444444444'
const SESSION_B = 'bbbbbbbb-1111-4222-8333-444444444444'
// Fast enough that a test waiting on a sweep finishes in milliseconds, slow enough that a sweep
// never overlaps the one before it on a loaded CI box.
const POLL_MS = 20

let cursorHome = ''

function writeTranscript(project: string, sessionId: string): string {
  const dir = join(cursorHome, 'projects', project, 'agent-transcripts', sessionId)
  mkdirSync(dir, { recursive: true })
  const path = join(dir, `${sessionId}.jsonl`)
  writeFileSync(path, '{"role":"user"}\n')
  return path
}

// `validTranscriptPath` checks candidates against the process-wide `env.CURSOR_HOME`, which the config
// module resolves once at import time — so the module graph is reset and re-imported per test with
// the throwaway home already in the environment (the same shape registry.spec.ts uses).
async function loadDiscovery() {
  vi.resetModules()
  process.env.CURSOR_HOME = cursorHome
  return import('./discovery.js')
}

async function settle(): Promise<void> {
  await new Promise((resolve) => setTimeout(resolve, POLL_MS * 4))
}

describe('CursorTranscriptDiscovery', () => {
  beforeEach(() => {
    cursorHome = mkdtempSync(join(tmpdir(), 'cursor-discovery-'))
    mkdirSync(join(cursorHome, 'projects'), { recursive: true })
  })

  afterEach(() => {
    delete process.env.CURSOR_HOME
    rmSync(cursorHome, { recursive: true, force: true })
  }, 30_000)

  it('reports a transcript that already exists without polling', async () => {
    const { CursorTranscriptDiscovery } = await loadDiscovery()
    const expected = writeTranscript('proj-1', SESSION_A)
    const onFound = vi.fn()
    const discovery = new CursorTranscriptDiscovery(cursorHome, onFound, POLL_MS)
    await discovery.start()

    await discovery.add(SESSION_A)

    expect(onFound).toHaveBeenCalledTimes(1)
    expect(onFound).toHaveBeenCalledWith(SESSION_A, expected)
    expect(discovery.isPolling).toBe(false)
    await discovery.stop()
  })

  it('polls only while a session is pending and reports the transcript once it appears', async () => {
    const { CursorTranscriptDiscovery } = await loadDiscovery()
    const onFound = vi.fn()
    const discovery = new CursorTranscriptDiscovery(cursorHome, onFound, POLL_MS)
    await discovery.start()

    await discovery.add(SESSION_A)
    expect(onFound).not.toHaveBeenCalled()
    expect(discovery.isPolling).toBe(true)

    const expected = writeTranscript('proj-late', SESSION_A)
    await vi.waitFor(() => expect(onFound).toHaveBeenCalledWith(SESSION_A, expected))

    // Found once, then the poll shuts itself off — nothing is left to look for.
    await settle()
    expect(onFound).toHaveBeenCalledTimes(1)
    expect(discovery.isPolling).toBe(false)
    await discovery.stop()
  })

  it('finds transcripts added before start() once polling begins', async () => {
    const { CursorTranscriptDiscovery } = await loadDiscovery()
    const onFound = vi.fn()
    const discovery = new CursorTranscriptDiscovery(cursorHome, onFound, POLL_MS)

    await discovery.add(SESSION_A)
    expect(discovery.isPolling).toBe(false)
    const expected = writeTranscript('proj-1', SESSION_A)

    await discovery.start()
    await vi.waitFor(() => expect(onFound).toHaveBeenCalledWith(SESSION_A, expected))
    await discovery.stop()
  })

  it('stops looking for a session that was removed', async () => {
    const { CursorTranscriptDiscovery } = await loadDiscovery()
    const onFound = vi.fn()
    const discovery = new CursorTranscriptDiscovery(cursorHome, onFound, POLL_MS)
    await discovery.start()
    await discovery.add(SESSION_A)
    await discovery.add(SESSION_B)

    discovery.remove(SESSION_A)
    writeTranscript('proj-1', SESSION_A)
    const expectedB = writeTranscript('proj-2', SESSION_B)

    await vi.waitFor(() => expect(onFound).toHaveBeenCalledWith(SESSION_B, expectedB))
    await settle()
    expect(onFound).toHaveBeenCalledTimes(1)
    expect(discovery.isPolling).toBe(false)
    await discovery.stop()
  })

  it('reports nothing after stop()', async () => {
    const { CursorTranscriptDiscovery } = await loadDiscovery()
    const onFound = vi.fn()
    const discovery = new CursorTranscriptDiscovery(cursorHome, onFound, POLL_MS)
    await discovery.start()
    await discovery.add(SESSION_A)

    await discovery.stop()
    expect(discovery.isPolling).toBe(false)
    writeTranscript('proj-1', SESSION_A)

    await settle()
    expect(onFound).not.toHaveBeenCalled()
  })

  it('drops what an add() in flight finds once stop() has run', async () => {
    const { CursorTranscriptDiscovery } = await loadDiscovery()
    writeTranscript('proj-1', SESSION_A)
    const onFound = vi.fn()
    const discovery = new CursorTranscriptDiscovery(cursorHome, onFound, POLL_MS)
    await discovery.start()

    const adding = discovery.add(SESSION_A) // its lookup is now awaiting the disk
    await discovery.stop()
    await adding

    expect(onFound).not.toHaveBeenCalled()
    expect(discovery.isPolling).toBe(false)
  })

  it('ignores session ids that cannot name a transcript', async () => {
    const { CursorTranscriptDiscovery } = await loadDiscovery()
    const onFound = vi.fn()
    const discovery = new CursorTranscriptDiscovery(cursorHome, onFound, POLL_MS)
    await discovery.start()

    await discovery.add('../../etc/passwd')
    await discovery.add('short')

    expect(discovery.isPolling).toBe(false)
    expect(onFound).not.toHaveBeenCalled()
    await discovery.stop()
  })

  it('never watches the projects tree, however large it is', async () => {
    const { CursorTranscriptDiscovery } = await loadDiscovery()
    // A thousand unrelated project folders — the shape of a Cursor home on a machine that has opened
    // many repos. The old recursive watcher registered every one of these with the OS.
    for (let i = 0; i < 1000; i++) mkdirSync(join(cursorHome, 'projects', `proj-${i}`, 'deep', 'er'), { recursive: true })
    const onFound = vi.fn()
    const discovery = new CursorTranscriptDiscovery(cursorHome, onFound, POLL_MS)

    const started = Date.now()
    await discovery.start()
    await discovery.add(SESSION_A)
    const expected = writeTranscript('proj-999', SESSION_A)
    await vi.waitFor(() => expect(onFound).toHaveBeenCalledWith(SESSION_A, expected))
    await discovery.stop()

    expect(Date.now() - started).toBeLessThan(2000)
  // Creating 3,000 fixture directories can exceed Vitest's default under concurrent builds. The
  // measured discovery deadline above stays two seconds and excludes only fixture construction.
  }, 30_000)
})