Skip to content

armgit / orca

Public Imported from GitHub
0

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.

9.5 KB
Raw Blame
import assert from 'node:assert/strict'
import { EventEmitter } from 'node:events'
import {
  cpSync,
  existsSync,
  mkdirSync,
  mkdtempSync,
  readFileSync,
  readdirSync,
  realpathSync,
  rmSync,
  symlinkSync,
  writeFileSync
} from 'node:fs'
import { createRequire } from 'node:module'
import { tmpdir } from 'node:os'
import { join, resolve } from 'node:path'
import { setImmediate } from 'node:timers/promises'
import { pathToFileURL } from 'node:url'
import test from 'node:test'
import { runProcess } from '@orca/process-host'
import { runRelayTests } from './run-relay-tests.mjs'

const success = { code: 0, signal: null, timedOut: false }
const databaseUrl = 'postgres://relay_test:[email protected]:5432/orca_relay_test'
const require = createRequire(import.meta.url)
const cloud = resolve(import.meta.dirname, '../..')

function temporary(t) {
  const directory = realpathSync(mkdtempSync(join(tmpdir(), 'orca-relay-runner-contract-')))
  t.after(() => rmSync(directory, { recursive: true, force: true }))
  return directory
}

function start(t, options = {}) {
  const scratchParent = temporary(t)
  const calls = []
  const reports = []
  const events = new EventEmitter()
  const env = { ORCA_RELAY_TEST_POSTGRES_URL: databaseUrl, PRESERVED: 'yes', ...options.env }
  const pending = runRelayTests({
    cwd: join(scratchParent, 'relay'),
    cli: join(scratchParent, 'vitest.mjs'),
    parallelism: 4,
    ...options,
    env,
    events,
    scratchParent,
    report: (message) => reports.push(message),
    run: (spec) => {
      const deferred = Promise.withResolvers()
      calls.push({ spec, ...deferred })
      return deferred.promise
    }
  })
  return { pending, calls, reports, events, scratchParent, env }
}

function finish(call, result = success, closed = true) {
  if (closed) {
    call.spec.onChildTerminated()
  }
  call.resolve(result)
}

function assertClean(harness) {
  assert.deepEqual(readdirSync(harness.scratchParent), [])
  assert.equal(harness.events.listenerCount('SIGINT'), 0)
  assert.equal(harness.events.listenerCount('SIGTERM'), 0)
}

test('overlaps both projects within the worker budget and isolates their scratch and caches', async (t) => {
  const h = start(t)
  assert.equal(h.calls.length, 2)
  const [regular, postgres] = h.calls.map((call) => call.spec)
  assert.deepEqual(regular.args.slice(1), ['run', '--project=relay', '--maxWorkers=2'])
  assert.deepEqual(postgres.args.slice(1), ['run', '--project=relay-postgres', '--maxWorkers=1'])
  assert.notEqual(regular.env.TMPDIR, postgres.env.TMPDIR)
  assert.notEqual(regular.env.ORCA_RELAY_TEST_CACHE_DIR, postgres.env.ORCA_RELAY_TEST_CACHE_DIR)
  for (const spec of [regular, postgres]) {
    assert.equal(spec.env.TMP, spec.env.TMPDIR)
    assert.equal(spec.env.TEMP, spec.env.TMPDIR)
    assert.equal(spec.env.ORCA_RELAY_TEST_CACHE_DIR, join(spec.env.TMPDIR, 'cache'))
    assert.equal(spec.env.ORCA_RELAY_TEST_POSTGRES_URL, databaseUrl)
    assert.equal(spec.env.PRESERVED, 'yes')
    assert.equal(spec.env.ORCA_BACKGROUND_LAUNCH, '1')
    assert.ok(existsSync(spec.env.TMPDIR))
    assert.equal(spec.timeoutMs, null)
    assert.equal(typeof spec.terminationBarrier.force, 'function')
  }
  assert.equal(regular.signal, postgres.signal)
  let settled = false
  h.pending.then(() => {
    settled = true
  })
  finish(h.calls[0], { ...success, code: 7 })
  await setImmediate()
  assert.equal(settled, false)
  assert.equal(postgres.signal.aborted, false)
  assert.ok(existsSync(postgres.env.TMPDIR))
  finish(h.calls[1])
  assert.equal(await h.pending, 7)
  assertClean(h)
})

for (const [name, options] of [
  ['selectors', { args: ['src/assignment.test.ts', '-t', 'requested behavior'] }],
  [
    'alternate PostgreSQL',
    { env: { ORCA_IDLE_REHOME_POSTGRES_URL: 'postgres://localhost:55440/relay' } }
  ],
  ['application database', { env: { DATABASE_URL: databaseUrl } }],
  ['one CPU', { parallelism: 1 }],
  ['two CPUs', { parallelism: 2 }]
]) {
  test(`retains the original single run for ${name}`, async (t) => {
    const h = start(t, options)
    assert.equal(h.calls.length, 1)
    const { spec } = h.calls[0]
    assert.deepEqual(spec.args.slice(1), ['run', ...(options.args ?? [])])
    for (const [key, value] of Object.entries(h.env)) {
      assert.equal(spec.env[key], value)
    }
    finish(h.calls[0])
    assert.equal(await h.pending, 0)
    assertClean(h)
  })
}

for (const [name, result] of [
  ['null exit code', { ...success, code: null }],
  ['termination signal', { ...success, signal: 'SIGTERM' }],
  ['timeout', { ...success, timedOut: true }]
]) {
  test(`fails a ${name} even when other result fields indicate success`, async (t) => {
    const h = start(t)
    finish(h.calls[0], result)
    finish(h.calls[1])
    assert.equal(await h.pending, 1)
    assertClean(h)
  })
}

test('fails and retains scratch when a child never reports closure', async (t) => {
  const h = start(t)
  finish(h.calls[0], success, false)
  finish(h.calls[1])
  assert.equal(await h.pending, 1)
  assert.ok(existsSync(h.calls[0].spec.env.TMPDIR))
  assert.match(String(h.reports[0]), /closure is unverifiable; retained/)
  assert.equal(h.events.listenerCount('SIGINT'), 0)
  assert.equal(h.events.listenerCount('SIGTERM'), 0)
})

for (const [signal, exitCode, laterSignal] of [
  ['SIGINT', 130, 'SIGTERM'],
  ['SIGTERM', 143, 'SIGINT']
]) {
  test(`${signal} cancels every child and retains scratch despite root close callbacks`, async (t) => {
    const h = start(t)
    h.events.emit(signal)
    h.events.emit(laterSignal)
    for (const call of h.calls) {
      assert.equal(call.spec.signal.aborted, true)
      finish(call)
    }
    assert.equal(await h.pending, exitCode)
    for (const call of h.calls) {
      assert.ok(existsSync(call.spec.env.TMPDIR))
    }
    assert.match(String(h.reports[0]), /closure is unverifiable; retained/)
    assert.equal(h.events.listenerCount('SIGINT'), 0)
    assert.equal(h.events.listenerCount('SIGTERM'), 0)
  })
}

for (const verified of [1, 2]) {
  test(`requires verification of both cancelled trees (${verified} verified)`, async (t) => {
    const h = start(t)
    h.events.emit('SIGINT')
    for (const call of h.calls.slice(0, verified)) {
      // An unspawned handle proves absence without signalling a real process.
      assert.equal(await call.spec.terminationBarrier.force({ kill: () => true }), true)
    }
    for (const call of h.calls) {
      finish(call)
    }
    assert.equal(await h.pending, 130)
    if (verified === 2) {
      assertClean(h)
    } else {
      assert.ok(existsSync(h.calls[0].spec.env.TMPDIR))
    }
  })
}

test('reports a spawn failure and waits for its cancelled peer before returning', async (t) => {
  const h = start(t)
  const failure = new Error('fixture spawn failed')
  h.calls[0].reject(failure)
  let settled = false
  h.pending.then(() => {
    settled = true
  })
  await setImmediate()
  assert.equal(h.calls[1].spec.signal.aborted, true)
  assert.equal(settled, false)
  finish(h.calls[1])
  assert.equal(await h.pending, 1)
  assert.equal(h.reports[0], failure)
  assert.ok(existsSync(h.calls[1].spec.env.TMPDIR))
})

test('launches with only the Cloud dependency link and no root install or compiled host package', async (t) => {
  const root = temporary(t)
  const standalone = join(root, 'cloud')
  const manifest = JSON.parse(readFileSync(join(cloud, 'package.json'), 'utf8'))
  const dependency = manifest.devDependencies['@orca/process-host']
  assert.equal(dependency, 'link:../src/packages/process-host')
  const packageDir = resolve(standalone, dependency.slice('link:'.length))
  mkdirSync(packageDir, { recursive: true })
  for (const file of ['package.json', 'src']) {
    cpSync(join(cloud, '..', 'src', 'packages', 'process-host', file), join(packageDir, file), {
      recursive: true
    })
  }
  const scripts = join(standalone, 'dev', 'scripts')
  mkdirSync(scripts, { recursive: true })
  cpSync(join(cloud, 'dev', 'scripts', 'run-relay-tests.mjs'), join(scripts, 'run-relay-tests.mjs'))
  writeFileSync(join(standalone, 'package.json'), JSON.stringify(manifest))
  mkdirSync(join(standalone, 'apps', 'relay'), { recursive: true })
  mkdirSync(join(standalone, 'node_modules', '@orca'), { recursive: true })
  symlinkSync(
    packageDir,
    join(standalone, 'node_modules', '@orca', 'process-host'),
    process.platform === 'win32' ? 'junction' : 'dir'
  )
  const fakeVitest = join(standalone, 'node_modules', 'vitest')
  mkdirSync(fakeVitest)
  writeFileSync(join(fakeVitest, 'package.json'), '{"name":"vitest","version":"0.0.0"}')
  writeFileSync(
    join(fakeVitest, 'vitest.mjs'),
    'console.log(JSON.stringify({args:process.argv.slice(2), background:process.env.ORCA_BACKGROUND_LAUNCH, database:process.env.ORCA_RELAY_TEST_POSTGRES_URL}))'
  )
  assert.equal(existsSync(join(root, 'node_modules')), false)
  assert.equal(existsSync(join(packageDir, 'dist')), false)
  const result = await runProcess({
    program: process.execPath,
    args: [
      '--import',
      pathToFileURL(require.resolve('tsx')).href,
      '--conditions=orca-source',
      join(scripts, 'run-relay-tests.mjs'),
      'src/requested.test.ts'
    ],
    cwd: standalone,
    timeoutMs: 15_000,
    terminationBarrier: true,
    env: {
      ...process.env,
      NODE_PATH: '',
      NODE_OPTIONS: '',
      ORCA_BACKGROUND_LAUNCH: '1',
      ORCA_RELAY_TEST_POSTGRES_URL: databaseUrl
    }
  })
  assert.equal(result.code, 0, result.stderr)
  assert.deepEqual(JSON.parse(result.stdout), {
    args: ['run', 'src/requested.test.ts'],
    background: '1',
    database: databaseUrl
  })
  assert.equal(existsSync(join(packageDir, 'dist')), false)
})