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.

10.9 KB
Raw Blame
import {
  existsSync,
  mkdirSync,
  mkdtempSync,
  readFileSync,
  realpathSync,
  renameSync,
  rmSync,
  writeFileSync
} from 'node:fs'
import { createServer, type Socket } from 'node:net'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
import { setAppEnvironment } from '../../shared/app-environment'
import { readAgentHookSettingsFromProfileState } from '../../main/persistence/profile-state/profile-state-offline-settings'
import { acquireProfileStateMaintenance } from '../../main/persistence/profile-state/profile-state-access'
import { PROFILE_STATE_RECOVERY_RESULT_PREFIX } from '../../shared/profile-state-recovery-command'
import type * as ProcessHost from '@orca/process-host'
import { main } from '../index'

const { runChild } = vi.hoisted(() => ({ runChild: vi.fn() }))
vi.mock('@orca/process-host', async (original) => ({
  ...(await original<typeof ProcessHost>()),
  runProcess: runChild
}))

// Exercise the existing hook installer on one isolated target; do not discover installed agents.
vi.mock('../../main/agent-hooks/managed-agent-hook-controls', async () => {
  const { claudeHookService } = await import('../../main/claude/hook-service.js')
  return {
    applyAgentStatusHooksEnabled: vi.fn(async (enabled: boolean) => [
      enabled ? claudeHookService.install({ claudeVersion: '2.1.0' }) : claudeHookService.remove()
    ]),
    getManagedAgentHookStatuses: () => [claudeHookService.getStatus()]
  }
})

const priorExit = process.exitCode
const sockets = new Set<Socket>()
let root: string
let profile: string
let endpoint: string
let server: ReturnType<typeof createServer> | undefined

beforeEach(() => {
  root = mkdtempSync(join(tmpdir(), 'orca-offline-command-'))
  profile = join(root, 'profiles', 'fixture')
  endpoint = join(root, 'runtime.sock')
  mkdirSync(profile, { recursive: true })
  writeFileSync(
    join(root, 'orca-profile-index.json'),
    JSON.stringify({ activeProfileId: 'fixture', profiles: [{ id: 'fixture' }] })
  )
  writeFileSync(
    join(profile, 'orca-data.json'),
    JSON.stringify({ settings: { agentStatusHooksEnabled: false }, retained: { value: 7 } })
  )
  for (const key of [
    'ORCA_PAIRING_CODE',
    'ORCA_REMOTE_PAIRING',
    'ORCA_ENVIRONMENT',
    'ELECTRON_RUN_AS_NODE',
    'ORCA_APP_EXECUTABLE',
    'WSL_DISTRO_NAME'
  ]) {
    vi.stubEnv(key, undefined)
  }
  for (const key of [
    'HOME',
    'USERPROFILE',
    'XDG_CONFIG_HOME',
    'XDG_DATA_HOME',
    'XDG_CACHE_HOME',
    'CODEX_HOME',
    'CLAUDE_CONFIG_DIR'
  ]) {
    vi.stubEnv(key, join(root, key))
  }
  vi.stubEnv('ORCA_USER_DATA_PATH', root)
  setAppEnvironment({
    getPath: () => root,
    getAppPath: () => root,
    getVersion: () => 'test',
    isPackaged: () => false,
    onWillQuit: () => {},
    exit: () => {},
    getAppMetrics: () => []
  })
  runChild.mockReset()
  process.exitCode = 0
  vi.spyOn(console, 'log').mockImplementation(() => {})
  vi.spyOn(console, 'error').mockImplementation(() => {})
})
afterEach(async () => {
  for (const socket of sockets) {
    socket.destroy()
  }
  sockets.clear()
  if (server) {
    const listening = server
    await new Promise<void>((resolve) => listening.close(() => resolve()))
  }
  server = undefined
  vi.restoreAllMocks()
  vi.unstubAllEnvs()
  process.exitCode = priorExit
  rmSync(root, { recursive: true, force: true })
})

function metadata(shape = 'complete', pid = 2147483647) {
  writeFileSync(
    join(root, 'orca-runtime.json'),
    JSON.stringify({
      runtimeId: 'runtime-before',
      pid,
      authToken: shape === 'incomplete' ? null : 'fixture-token',
      startedAt: 1,
      ...(shape === 'singular'
        ? { transport: { kind: 'unix', endpoint } }
        : { transports: [{ kind: 'unix', endpoint }] })
    })
  )
}
function settings() {
  return readAgentHookSettingsFromProfileState({
    dataFile: join(profile, 'orca-data.json'),
    databaseFile: join(profile, 'profile-state.db'),
    profileId: 'fixture'
  })
}
function output() {
  return JSON.parse(String(vi.mocked(console.log).mock.calls.at(-1)?.[0]))
}
async function refusedEndpoint() {
  const listener = createServer()
  await new Promise<void>((resolve) => listener.listen(endpoint, resolve))
  renameSync(endpoint, `${endpoint}.stale`)
  await new Promise<void>((resolve) => listener.close(() => resolve()))
  renameSync(`${endpoint}.stale`, endpoint)
}

describe.skipIf(process.platform === 'win32')(
  'offline CLI admission through dispatch and persistence',
  () => {
    it.each(['complete', 'singular', 'incomplete', 'refused'])(
      'recovers JSON and toggles hooks both ways with %s stopped metadata',
      async (shape) => {
        metadata(shape)
        if (shape === 'refused') {
          await refusedEndpoint()
        }
        await main(['profile', 'state', 'rollback', '--current-json', '--json'], root)
        expect(process.exitCode).toBe(0)
        expect(output()).toMatchObject({ ok: true, result: { storage: 'json' } })
        expect(JSON.parse(readFileSync(join(profile, 'orca-data.json'), 'utf8'))).toMatchObject({
          retained: { value: 7 }
        })
        for (const enabled of [true, false]) {
          await main(['agent', 'hooks', enabled ? 'on' : 'off', '--json'], root)
          expect(process.exitCode).toBe(0)
          expect(output()).toMatchObject({
            ok: true,
            result: {
              enabled,
              appliedBy: 'offline',
              statuses: [expect.objectContaining({ agent: 'claude', managedHooksPresent: enabled })]
            }
          })
          expect(settings().agentStatusHooksEnabled).toBe(enabled)
          const config = JSON.parse(
            readFileSync(join(root, 'HOME', '.claude', 'settings.json'), 'utf8')
          )
          expect(JSON.stringify(config.hooks ?? {}).includes('orca')).toBe(enabled)
        }
      }
    )

    it.each(['packaged', 'dev', 'older-override'])(
      'retains the %s helper selection and never replays an uncertain child result',
      async (kind) => {
        metadata()
        const executable = kind === 'older-override' ? join(root, 'older-Orca') : process.execPath
        if (kind === 'older-override') {
          vi.stubEnv('ORCA_APP_EXECUTABLE', executable)
        } else {
          vi.stubEnv('ELECTRON_RUN_AS_NODE', '1')
        }
        vi.stubEnv('ORCA_APP_EXECUTABLE_NEEDS_APP_ROOT', kind === 'dev' ? '1' : undefined)
        const result = {
          profileId: 'fixture',
          dataFile: join(profile, 'orca-data.json'),
          databaseFile: join(profile, 'profile-state.db'),
          exportPaths: [],
          backups: [],
          revision: null,
          quarantineDirectory: profile,
          removedDatabaseFiles: [],
          storage: 'json',
          restoredPath: join(profile, 'orca-data.json')
        }
        runChild.mockImplementationOnce(async () => {
          // Parent observation precedes the existing child, with no new parent lease.
          acquireProfileStateMaintenance(root).release()
          return {
            code: 0,
            signal: null,
            timedOut: false,
            stdout: PROFILE_STATE_RECOVERY_RESULT_PREFIX + JSON.stringify({ ok: true, result }),
            stderr: ''
          }
        })
        await main(['profile', 'state', 'rollback', '--current-json', '--json'], root)
        expect(process.exitCode).toBe(0)
        expect(runChild).toHaveBeenCalledOnce()
        expect(runChild.mock.calls[0][0]).toMatchObject({
          program: executable,
          timeoutMs: null,
          env: { ORCA_BACKGROUND_LAUNCH: '1', ORCA_USER_DATA_PATH: realpathSync(root) }
        })
        expect(runChild.mock.calls[0][0].args).toContain('--serve')
        expect(JSON.parse(runChild.mock.calls[0][0].args.at(-1))).toMatchObject({
          selector: { kind: 'current-json' }
        })
        runChild.mockClear().mockResolvedValue({
          code: 1,
          signal: null,
          timedOut: false,
          stdout: 'partial',
          stderr: 'uncertain result'
        })
        await main(['profile', 'state', 'rollback', '--current-json', '--json'], root)
        expect(process.exitCode).toBe(1)
        expect(runChild).toHaveBeenCalledOnce()
        expect(existsSync(join(profile, 'profile-state.db'))).toBe(false)
      }
    )

    it('refuses a visible PID without creating a database or changing profile and hook files', async () => {
      metadata('complete', process.pid)
      const before = readFileSync(join(profile, 'orca-data.json'))
      for (const args of [
        ['profile', 'state', 'rollback', '--current-json'],
        ['agent', 'hooks', 'on'],
        ['agent', 'hooks', 'off']
      ]) {
        process.exitCode = 0
        await main([...args, '--json'], root)
        expect(process.exitCode).toBe(1)
        expect(output()).toMatchObject({ ok: false, error: { code: 'runtime_error' } })
        expect(readFileSync(join(profile, 'orca-data.json'))).toEqual(before)
        expect(existsSync(join(profile, 'profile-state.db'))).toBe(false)
        expect(existsSync(join(root, 'HOME', '.claude'))).toBe(false)
      }
    })

    it.each(['close', 'server-error'])(
      'never replays a failed online settings update offline (%s)',
      async (failure) => {
        metadata()
        const methods: string[] = []
        const listener = createServer((socket) => {
          sockets.add(socket)
          socket.once('close', () => sockets.delete(socket))
          socket.once('data', (data) => {
            const request = JSON.parse(String(data))
            methods.push(request.method)
            if (request.method === 'settings.update' && failure === 'close') {
              socket.end()
              return
            }
            socket.end(
              `${JSON.stringify({
                id: request.id,
                ...(request.method === 'status.get'
                  ? {
                      ok: true,
                      result: {
                        runtimeId: 'runtime-before',
                        graphStatus: 'ready',
                        authoritativeWindowId: null
                      }
                    }
                  : {
                      ok: false,
                      error: { code: 'runtime_unavailable', message: 'update rejected' }
                    }),
                _meta: { runtimeId: 'runtime-before' }
              })}\n`
            )
          })
        })
        server = listener
        await new Promise<void>((resolve) => listener.listen(endpoint, resolve))
        const before = readFileSync(join(profile, 'orca-data.json'))
        await main(['agent', 'hooks', 'on', '--json'], root)
        expect(process.exitCode).toBe(1)
        expect(methods).toEqual(['status.get', 'settings.update'])
        expect(readFileSync(join(profile, 'orca-data.json'))).toEqual(before)
        expect(existsSync(join(profile, 'profile-state.db'))).toBe(false)
        expect(existsSync(join(root, 'HOME', '.claude'))).toBe(false)
      }
    )
  }
)