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.
TypeScript adeagent-ideai-agentsautomationbotclaude-codecodexghosttygrok-bothermes-agentmobile-appmuseopenclawopencodeorchestrationpiruntimeterminalworktreesyc-backed
// Run node config/scripts/archive-hook-removal-repro.mjs after build:cli/build:electron-vite.
// Drive built CLI/headless runtime against real worktrees: failed/unverifiable archive hooks must preserve registration and file contents.
import { spawn, spawnSync } from 'node:child_process'
import { mkdtempSync, writeFileSync, readFileSync, existsSync, rmSync, mkdirSync } from 'node:fs'
import { tmpdir } from 'node:os'
import { join, dirname, resolve } from 'node:path'
import { randomBytes } from 'node:crypto'
const projectDir = resolve(import.meta.dirname, '../..')
const serveEntry = join(projectDir, 'out', 'main', 'index.js')
const cliEntry = join(projectDir, 'out', 'cli', 'index.js')
const PORT = 6900 + Math.floor(Math.random() * 400)
const READY_TIMEOUT_MS = 180_000
const control = mkdtempSync(join(tmpdir(), 'agh-control-'))
const modeFile = join(control, 'mode')
const ranFile = join(control, 'ran')
const setMode = (m) => writeFileSync(modeFile, m)
const hookRuns = () => (existsSync(ranFile) ? readFileSync(ranFile, 'utf8').trim().split('\n') : [])
let failures = 0
const out = (s) => process.stdout.write(`${s}\n`)
const banner = (s) => out(`\n${'='.repeat(78)}\n${s}\n${'='.repeat(78)}`)
function check(label, ok, detail = '') {
out(` ${ok ? 'PASS' : 'FAIL'} ${label}${detail ? ` -- ${detail}` : ''}`)
if (!ok) {
failures++
}
}
let pairingCode = null
function cli(args, { json = true } = {}) {
return spawnSync(
process.execPath,
[cliEntry, ...args, '--pairing-code', pairingCode, ...(json ? ['--json'] : [])],
{ encoding: 'utf8', shell: false }
)
}
function ok(args) {
const r = cli(args)
const parsed = parseJsonLine(r)
if (!parsed) {
throw new Error(`orca ${args.join(' ')} produced no JSON:\n${r.stdout}\n${r.stderr}`)
}
if (parsed.ok === false) {
throw new Error(`orca ${args.join(' ')} failed: ${parsed.error?.code} ${parsed.error?.message}`)
}
return parsed.result
}
/** The CLI pretty-prints one JSON document to stdout. */
function parseJsonLine(r) {
const text = (r.stdout ?? '').trim()
const start = text.indexOf('{')
if (start === -1) {
return null
}
try {
return JSON.parse(text.slice(start))
} catch {
return null
}
}
function git(cwd, ...args) {
const r = spawnSync('git', args, { cwd, encoding: 'utf8' })
if (r.status !== 0) {
throw new Error(`git ${args.join(' ')}: ${r.stderr || r.stdout}`)
}
return r.stdout
}
const ARCHIVE_HOOK = `echo "[archive-hook] running in $PWD"
echo "$PWD" >> ${JSON.stringify(ranFile).slice(1, -1)}
mode=$(cat ${JSON.stringify(modeFile).slice(1, -1)})
case "$mode" in
ok) echo "[archive-hook] archived OK"; exit 0 ;;
fail) echo "[archive-hook] backup target unreachable" >&2; exit 23 ;;
signal) echo "[archive-hook] losing the execution host now"; kill -KILL $$ ;;
esac
echo "unknown mode $mode" >&2; exit 99
`
/** A throwaway git repo with one commit; optionally an orca.yaml archive hook. */
function seedGitRepo(label, withHook, githubSlug) {
const dir = mkdtempSync(join(tmpdir(), `agh-repo-${label}-`))
writeFileSync(join(dir, 'README.md'), `# ${label}\n`)
if (withHook) {
writeFileSync(
join(dir, 'orca.yaml'),
`scripts:\n archive: |\n${ARCHIVE_HOOK.split('\n')
.map((l) => ` ${l}`)
.join('\n')}\n`
)
}
git(dir, 'init', '-b', 'main')
git(dir, 'config', 'user.email', '[email protected]')
git(dir, 'config', 'user.name', 'Archive Gate Verify')
if (githubSlug) {
git(dir, 'remote', 'add', 'origin', `https://github.com/agh-owner/${githubSlug}.git`)
}
git(dir, 'add', '-A')
git(dir, 'commit', '-m', 'seed')
return dir
}
function waitForReady(child) {
return new Promise((res, rej) => {
let buffered = ''
let serverErr = ''
const timer = setTimeout(
() => rej(new Error(`no ready payload in ${READY_TIMEOUT_MS}ms\n${serverErr}`)),
READY_TIMEOUT_MS
)
child.stderr.setEncoding('utf8')
child.stderr.on('data', (c) => {
serverErr += c
})
child.stdout.setEncoding('utf8')
child.stdout.on('data', (chunk) => {
buffered += chunk
for (const line of buffered.split('\n')) {
if (!line.startsWith('{')) {
continue
}
try {
const p = JSON.parse(line)
if (p.type === 'orca_server_ready') {
clearTimeout(timer)
res(p)
return
}
} catch {
/* partial */
}
}
})
child.on('exit', (code) => {
clearTimeout(timer)
rej(new Error(`server exited ${code} before ready:\n${serverErr}`))
})
})
}
/** Filesystem + git truth about a worktree, read directly rather than through Orca. */
function evidence(repoPath, wtPath) {
const ls = spawnSync('ls', ['-la', wtPath], { encoding: 'utf8' })
const list = spawnSync('git', ['worktree', 'list'], { cwd: repoPath, encoding: 'utf8' })
return {
dirExists: existsSync(wtPath),
fileExists: existsSync(join(wtPath, 'PRECIOUS.txt')),
fileBody: existsSync(join(wtPath, 'PRECIOUS.txt'))
? readFileSync(join(wtPath, 'PRECIOUS.txt'), 'utf8').trim()
: null,
registered: (list.stdout ?? '').includes(wtPath),
ls: (ls.stdout ?? '').trim(),
worktreeList: (list.stdout ?? '').trim()
}
}
function showEvidence(e) {
out(' --- ls -la <worktree> ---')
out(
e.ls
.split('\n')
.map((l) => ` ${l}`)
.join('\n')
)
out(' --- git worktree list (in the repo) ---')
out(
e.worktreeList
.split('\n')
.map((l) => ` ${l}`)
.join('\n')
)
}
async function main() {
const userDataDir = mkdtempSync(join(tmpdir(), 'agh-userdata-'))
out(`booting headless runtime on port ${PORT}, userData ${userDataDir}`)
const child = spawn(
'npx',
[
'electron',
serveEntry,
'--serve',
'--serve-port',
String(PORT),
'--serve-json',
`--user-data-dir=${userDataDir}`
],
{
cwd: projectDir,
stdio: ['ignore', 'pipe', 'pipe'],
env: { ...process.env, ORCA_BACKGROUND_LAUNCH: '1' }
}
)
const created = []
try {
const ready = await waitForReady(child)
pairingCode = new URL(ready.pairing.url).searchParams.get('code')
out(`ready: ${ready.advertisedEndpoint}`)
const hookRepoPath = seedGitRepo('hooked', true)
const folderProjectSlug = `agh-folder-proof-${randomBytes(3).toString('hex')}`
const bareRepoPath = seedGitRepo('nohook', false, folderProjectSlug)
const hookRepo = ok(['repo', 'add', '--path', hookRepoPath]).repo
const bareRepo = ok(['repo', 'add', '--path', bareRepoPath]).repo
out(`repo with archive hook: ${hookRepoPath} (${hookRepo.id})`)
out(`repo without archive hook: ${bareRepoPath} (${bareRepo.id})`)
const makeWorktree = (repo, repoPath, name) => {
const wt = ok([
'worktree',
'create',
'--repo',
`id:${repo.id}`,
'--name',
name,
'--setup',
'skip'
]).worktree
created.push(wt)
const unarchivedBody = `unarchived work for ${name}`
writeFileSync(join(wt.path, 'PRECIOUS.txt'), `${unarchivedBody}\n`)
return { ...wt, repoPath, unarchivedBody }
}
banner('SCENARIO 1 — archive hook exits 23: removal MUST be refused, nothing deleted')
setMode('fail')
const wt1 = makeWorktree(hookRepo, hookRepoPath, `gate-fail-${randomBytes(3).toString('hex')}`)
out(`worktree: ${wt1.path}`)
const before = evidence(wt1.repoPath, wt1.path)
out('\n$ orca worktree rm --worktree <id> --run-hooks (human output)')
const human = cli(['worktree', 'rm', '--worktree', wt1.id, '--run-hooks'], { json: false })
out(` exit code: ${human.status}`)
out(' --- stdout ---')
out(
(human.stdout ?? '')
.trimEnd()
.split('\n')
.map((l) => ` ${l}`)
.join('\n')
)
out(' --- stderr ---')
out(
(human.stderr ?? '')
.trimEnd()
.split('\n')
.map((l) => ` ${l}`)
.join('\n')
)
out(
'\n$ orca worktree rm --worktree <id> --force --run-hooks --json (--force must NOT waive)'
)
const forced = cli(['worktree', 'rm', '--worktree', wt1.id, '--force', '--run-hooks'])
const forcedJson = parseJsonLine(forced)
out(` exit code: ${forced.status}`)
out(` ${JSON.stringify(forcedJson)}`)
const after1 = evidence(wt1.repoPath, wt1.path)
showEvidence(after1)
check('CLI exits non-zero', human.status !== 0, `got ${human.status}`)
check(
'human stderr names the archive hook',
/Archive hook failed for worktree/.test(human.stderr ?? '')
)
check('--force also refused (non-zero)', forced.status !== 0, `got ${forced.status}`)
check(
'typed error code',
forcedJson?.error?.code === 'worktree_archive_hook_failed',
JSON.stringify(forcedJson?.error?.code)
)
check(
"error data outcome is 'exited'",
forcedJson?.error?.data?.outcome === 'exited',
JSON.stringify(forcedJson?.error?.data)
)
check('error data carries exitCode 23', forcedJson?.error?.data?.exitCode === 23)
check('checkout directory still exists', after1.dirExists)
// Check contents too: an empty surviving stub would not prove archive protection.
check(
'unarchived file PRECIOUS.txt survives with its contents',
after1.fileExists && after1.fileBody === wt1.unarchivedBody,
`exists=${after1.fileExists} body=${JSON.stringify(after1.fileBody)}`
)
check('git worktree registration survives', after1.registered)
check(
'nothing changed vs. before the attempt',
before.dirExists === after1.dirExists && before.registered === after1.registered
)
const shown = ok(['worktree', 'show', '--worktree', wt1.id]).worktree
check('Orca still resolves the worktree', shown?.id === wt1.id)
check(
'the hook really ran (twice: plain + --force)',
hookRuns().length >= 2,
`runs=${hookRuns().length}`
)
// Dirty checkout reports archive failure first, proving gate precedes dirty preflight.
check(
'archive gate precedes the dirty preflight (dirty checkout, archive error reported)',
/Archive hook failed/.test(human.stderr ?? '') &&
!/\?\? PRECIOUS\.txt/.test(human.stderr ?? '')
)
banner('SCENARIO 2 — --allow-failed-archive-hook: removal proceeds, waiver recorded')
// --force waives only dirty preflight; scenario 1 proves archive gate still requires its own waiver.
const waived = cli([
'worktree',
'rm',
'--worktree',
wt1.id,
'--force',
'--run-hooks',
'--allow-failed-archive-hook'
])
const waivedJson = parseJsonLine(waived)
out(` exit code: ${waived.status}`)
out(` ${JSON.stringify(waivedJson)}`)
const after2 = evidence(wt1.repoPath, wt1.path)
out(` checkout still on disk: ${after2.dirExists}`)
out(
` --- git worktree list ---\n${after2.worktreeList
.split('\n')
.map((l) => ` ${l}`)
.join('\n')}`
)
check('override exits zero', waived.status === 0, `got ${waived.status}`)
check('removal reported', waivedJson?.result?.removed === true)
check('checkout is GONE', !after2.dirExists)
check('git registration is gone', !after2.registered)
check(
'archiveHookOverride recorded',
waivedJson?.result?.archiveHookOverride?.overridden === true,
JSON.stringify(waivedJson?.result?.archiveHookOverride)
)
check(
'override records exit 23 / exited',
waivedJson?.result?.archiveHookOverride?.exitCode === 23 &&
waivedJson?.result?.archiveHookOverride?.outcome === 'exited'
)
banner('SCENARIO 3 — archive hook exits 0: removal proceeds')
setMode('ok')
const wt3 = makeWorktree(hookRepo, hookRepoPath, `gate-ok-${randomBytes(3).toString('hex')}`)
out(`worktree: ${wt3.path}`)
const okRm = cli(['worktree', 'rm', '--worktree', wt3.id, '--force', '--run-hooks'])
const okJson = parseJsonLine(okRm)
out(` exit code: ${okRm.status}`)
out(` ${JSON.stringify(okJson)}`)
const after3 = evidence(wt3.repoPath, wt3.path)
check('exits zero', okRm.status === 0)
check('checkout deleted', !after3.dirExists)
check('git registration gone', !after3.registered)
check(
'no archiveHookOverride on a clean run',
okJson?.result?.archiveHookOverride === undefined
)
banner('SCENARIO 4 — no archive hook configured: removal proceeds unchanged')
const wt4 = makeWorktree(
bareRepo,
bareRepoPath,
`gate-nohook-${randomBytes(3).toString('hex')}`
)
out(`worktree: ${wt4.path}`)
const runsBefore = hookRuns().length
const noHook = cli(['worktree', 'rm', '--worktree', wt4.id, '--force', '--run-hooks'])
const noHookJson = parseJsonLine(noHook)
out(` exit code: ${noHook.status}`)
out(` ${JSON.stringify(noHookJson)}`)
const after4 = evidence(wt4.repoPath, wt4.path)
check('exits zero', noHook.status === 0)
check('checkout deleted', !after4.dirExists)
check('no hook was run', hookRuns().length === runsBefore)
banner('SCENARIO 5 — hook never reports an exit (killed): must BLOCK as `unverifiable`')
setMode('signal')
const wt5 = makeWorktree(hookRepo, hookRepoPath, `gate-unver-${randomBytes(3).toString('hex')}`)
out(`worktree: ${wt5.path}`)
const unver = cli(['worktree', 'rm', '--worktree', wt5.id, '--run-hooks'])
const unverJson = parseJsonLine(unver)
out(` exit code: ${unver.status}`)
out(` ${JSON.stringify(unverJson)}`)
const after5 = evidence(wt5.repoPath, wt5.path)
showEvidence(after5)
check('blocked (non-zero)', unver.status !== 0, `got ${unver.status}`)
check('typed error code', unverJson?.error?.code === 'worktree_archive_hook_failed')
check(
"outcome is 'unverifiable', NOT 'exited'",
unverJson?.error?.data?.outcome === 'unverifiable',
JSON.stringify(unverJson?.error?.data)
)
check(
'exit code is WITHHELD (never read as a pass)',
unverJson?.error?.data?.exitCode === undefined
)
check('checkout survives', after5.dirExists && after5.fileExists)
check('git registration survives', after5.registered)
setMode('ok')
cli(['worktree', 'rm', '--worktree', wt5.id, '--force'])
banner('SCENARIO 6 — folder workspace removal (the boundary that runs no hook) is unchanged')
const folderDir = mkdtempSync(join(tmpdir(), 'agh-folder-'))
mkdirSync(join(folderDir, 'src'))
writeFileSync(join(folderDir, 'src', 'app.txt'), 'folder workspace content\n')
// Folder imports use existing project identity; anchor to the hookless repo’s GitHub project.
const folderProjectId = `github:agh-owner/${folderProjectSlug}`
ok([
'project',
'setup-existing-folder',
'--project',
folderProjectId,
'--host',
'local',
'--path',
folderDir,
'--kind',
'folder'
])
const folderRepo = (ok(['repo', 'list']).repos ?? []).find((r) => r.path === folderDir) ?? null
out(`folder repo: ${folderDir} (${folderRepo?.id}) kind=${folderRepo?.kind}`)
check('registered repo kind is folder', folderRepo?.kind === 'folder', String(folderRepo?.kind))
// Folder project root remains undeletable; test removal on its child workspace.
const folderRoot = ok(['worktree', 'show', '--worktree', `path:${folderDir}`]).worktree
const rootRm = cli(['worktree', 'rm', '--worktree', folderRoot.id, '--force', '--run-hooks'])
out(
` root refusal (unchanged): exit ${rootRm.status} ${parseJsonLine(rootRm)?.error?.code} -- ${parseJsonLine(rootRm)?.error?.message}`
)
check(
'folder project root still refuses for its own reason, not the archive gate',
rootRm.status !== 0 && parseJsonLine(rootRm)?.error?.code !== 'worktree_archive_hook_failed'
)
const folderChild = ok([
'worktree',
'create',
'--repo',
`id:${folderRepo.id}`,
'--name',
'agh-folder-child',
'--setup',
'skip'
]).worktree
out(`folder workspace: ${folderChild.id}`)
const runsBeforeFolder = hookRuns().length
out(`\n$ orca worktree rm --worktree <folder workspace> --force --run-hooks`)
const folderRm = cli(['worktree', 'rm', '--worktree', folderChild.id, '--force', '--run-hooks'])
const folderJson = parseJsonLine(folderRm)
out(` exit code: ${folderRm.status}`)
out(` ${JSON.stringify(folderJson)}`)
const stillThere = cli(['worktree', 'show', '--worktree', folderChild.id])
check(
'folder workspace removal exits zero',
folderRm.status === 0,
`${folderRm.status} ${folderRm.stderr}`
)
check('folder removal ran no archive hook', hookRuns().length === runsBeforeFolder)
check(
'folder contents left on disk (forget, not delete)',
existsSync(join(folderDir, 'src', 'app.txt'))
)
check(
'folder workspace is deregistered',
stillThere.status !== 0 && parseJsonLine(stillThere)?.error?.code === 'selector_not_found'
)
rmSync(folderDir, { recursive: true, force: true })
banner(failures === 0 ? 'ALL CHECKS PASSED' : `${failures} CHECK(S) FAILED`)
} catch (error) {
out(`\nHARNESS ERROR: ${error instanceof Error ? error.stack : String(error)}`)
failures++
} finally {
for (const wt of created) {
if (existsSync(wt.path)) {
cli(['worktree', 'rm', '--worktree', wt.id, '--force'])
rmSync(dirname(wt.path), { recursive: true, force: true })
}
}
if (child.exitCode === null && child.signalCode === null) {
child.kill('SIGTERM')
await Promise.race([
new Promise((r) => child.on('exit', r)),
new Promise((r) => setTimeout(r, 15_000))
])
child.kill('SIGKILL')
}
rmSync(userDataDir, { recursive: true, force: true })
}
process.exitCode = failures === 0 ? 0 : 1
}
setMode('ok')
main()