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
import { mkdir, mkdtemp, rename, rm, symlink, writeFile } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import path from 'node:path'
import { afterEach, beforeEach, describe, expect, it } from 'vitest'
import { resolveGitCommonDirectory } from './git-common-directory'
import {
annotateWorktreeLocksFromAdmin,
findLinkedWorktreeGitDirectory,
isBranchReservedByWorktreeOperation
} from './git-worktree-admin'
import type { GitWorktreeInfo } from './worktree/types'
import { isWorktreeCreatePreparation } from './worktree/create-preparation'
let root = ''
let repo = ''
let common = ''
let linked = ''
let admin = ''
const preparationReason = 'orca-create-preparation:v1:12345:lease'
function rows(): GitWorktreeInfo[] {
return [
{ path: repo, branch: 'refs/heads/main', head: 'abc', isBare: false, isMainWorktree: true },
{ path: linked, branch: '', head: 'abc', isBare: false, isMainWorktree: false }
]
}
beforeEach(async () => {
root = await mkdtemp(path.join(tmpdir(), 'orca-admin-safety-'))
repo = path.join(root, 'repo')
common = path.join(repo, '.git')
linked = path.join(root, '.orca-preparing', 'checkout')
admin = path.join(common, 'worktrees', 'checkout')
await mkdir(admin, { recursive: true })
await mkdir(linked, { recursive: true })
await writeFile(path.join(common, 'HEAD'), 'ref: refs/heads/main\n')
await writeFile(path.join(admin, 'gitdir'), `${path.join(linked, '.git')}\n`)
await writeFile(path.join(admin, 'commondir'), '../..\n')
await writeFile(path.join(linked, '.git'), `gitdir: ${admin}\r\n`)
})
afterEach(async () => {
await rm(root, { recursive: true, force: true })
})
describe('owning-host worktree administrative reads', () => {
it('finds one exact linked registration after its checkout disappears', async () => {
await rm(linked, { recursive: true })
await expect(findLinkedWorktreeGitDirectory(repo, linked)).resolves.toBe(admin)
await expect(findLinkedWorktreeGitDirectory(repo, `${linked}-other`)).resolves.toBeNull()
await expect(findLinkedWorktreeGitDirectory(repo, repo)).resolves.toBeNull()
await writeFile(
path.join(admin, 'gitdir'),
`${path.relative(admin, path.join(linked, '.git'))}\n`
)
await expect(findLinkedWorktreeGitDirectory(repo, linked)).resolves.toBe(admin)
})
it('rejects duplicate registrations instead of choosing an owner marker', async () => {
const duplicate = path.join(common, 'worktrees', 'duplicate')
await mkdir(duplicate)
await writeFile(path.join(duplicate, 'gitdir'), `${path.join(linked, '.git')}\n`)
await expect(findLinkedWorktreeGitDirectory(repo, linked)).rejects.toThrow(
'Cannot verify linked worktree administration'
)
})
it('rejects a backlink to a file other than the checkout gitfile', async () => {
await writeFile(path.join(admin, 'gitdir'), `${path.join(linked, 'other')}\n`)
await expect(findLinkedWorktreeGitDirectory(repo, linked)).rejects.toThrow(
'Cannot verify linked worktree administration'
)
})
it.runIf(process.platform !== 'win32')(
'rejects administrative directories redirected outside the common directory',
async () => {
const outside = path.join(root, 'outside-administration')
const worktrees = path.join(common, 'worktrees')
await rename(worktrees, outside)
await symlink(outside, worktrees)
await expect(findLinkedWorktreeGitDirectory(repo, linked)).rejects.toThrow(
'Cannot verify linked worktree administration'
)
}
)
it.runIf(process.platform !== 'win32')('rejects symlinked backlink files', async () => {
const outside = path.join(root, 'outside-backlink')
await writeFile(outside, `${path.join(linked, '.git')}\n`)
await rm(path.join(admin, 'gitdir'))
await symlink(outside, path.join(admin, 'gitdir'))
await expect(findLinkedWorktreeGitDirectory(repo, linked)).rejects.toThrow(
'Cannot verify linked worktree administration'
)
})
it.runIf(process.platform !== 'win32')(
'rejects symlink administrative entries instead of overlooking duplicates',
async () => {
await symlink(admin, path.join(common, 'worktrees', 'duplicate-link'))
await expect(findLinkedWorktreeGitDirectory(repo, linked)).rejects.toThrow(
'Cannot verify linked worktree administration'
)
}
)
it('resolves normal, linked, separate-git-dir and bare layouts without subprocesses', async () => {
await expect(resolveGitCommonDirectory(repo)).resolves.toBe(common)
await expect(resolveGitCommonDirectory(linked)).resolves.toBe(common)
await expect(resolveGitCommonDirectory(common)).resolves.toBe(common)
const separate = path.join(root, 'separate')
await mkdir(separate)
await writeFile(path.join(separate, '.git'), 'gitdir: ../repo/.git\r\n')
await expect(resolveGitCommonDirectory(separate)).resolves.toBe(common)
})
it('recovers exact preparation reasons even when the checkout directory is missing', async () => {
await writeFile(path.join(admin, 'locked'), `${preparationReason}\n`)
await rm(linked, { recursive: true })
const annotated = await annotateWorktreeLocksFromAdmin(repo, rows())
expect(annotated[1]).toMatchObject({ locked: true, lockReason: preparationReason })
expect(isWorktreeCreatePreparation(annotated[1])).toBe(true)
})
it('keeps empty and foreign locks without claiming preparations by path shape', async () => {
await writeFile(path.join(admin, 'locked'), '')
const empty = await annotateWorktreeLocksFromAdmin(repo, rows())
expect(empty[1].locked).toBe(true)
expect(isWorktreeCreatePreparation(empty[1])).toBe(false)
await writeFile(path.join(admin, 'locked'), 'user session\n')
const foreign = await annotateWorktreeLocksFromAdmin(repo, rows())
expect(foreign[1]).toMatchObject({ locked: true, lockReason: 'user session' })
expect(isWorktreeCreatePreparation(foreign[1])).toBe(false)
})
it('does not treat an unreadable marker as an unlocked authoritative registration', async () => {
await mkdir(path.join(admin, 'locked'))
await expect(annotateWorktreeLocksFromAdmin(repo, rows())).rejects.toThrow()
})
it('does not cache a replaced lock reason or another repository’s metadata', async () => {
await writeFile(path.join(admin, 'locked'), `${preparationReason}\n`)
expect((await annotateWorktreeLocksFromAdmin(repo, rows()))[1].lockReason).toBe(
preparationReason
)
await writeFile(path.join(admin, 'locked'), 'replacement\n')
expect((await annotateWorktreeLocksFromAdmin(repo, rows()))[1].lockReason).toBe('replacement')
const other = path.join(root, 'other')
await mkdir(path.join(other, '.git'), { recursive: true })
await writeFile(path.join(other, '.git', 'HEAD'), 'ref: refs/heads/main\n')
const otherRows = rows().map((row) => (row.isMainWorktree ? { ...row, path: other } : row))
expect((await annotateWorktreeLocksFromAdmin(other, otherRows))[1].locked).toBeUndefined()
})
it.each(['rebase-merge/head-name', 'rebase-apply/head-name', 'BISECT_START'])(
'checks detached main worktrees as well as linked ones: %s',
async (marker) => {
const file = path.join(common, ...marker.split('/'))
await mkdir(path.dirname(file), { recursive: true })
await writeFile(file, 'refs/heads/feature\n')
const detachedMain = rows().map((row) => (row.isMainWorktree ? { ...row, branch: '' } : row))
await expect(
isBranchReservedByWorktreeOperation(repo, 'feature', detachedMain)
).resolves.toBe(true)
await expect(isBranchReservedByWorktreeOperation(repo, 'other', detachedMain)).resolves.toBe(
false
)
}
)
it('fails closed when a detached registration cannot be associated with admin metadata', async () => {
await rm(path.join(admin, 'gitdir'))
await expect(isBranchReservedByWorktreeOperation(repo, 'feature', rows())).rejects.toThrow(
'Cannot verify worktree branch usage'
)
})
it.each([40, 64])(
'protects auxiliary rebase refs with %i-character OIDs on attached worktrees',
async (length) => {
await mkdir(path.join(admin, 'rebase-merge'))
const before = 'a'.repeat(length)
const after = '0'.repeat(length)
await writeFile(
path.join(admin, 'rebase-merge', 'update-refs'),
`refs/heads/other\r\n${before}\r\n${after}\r\nrefs/heads/feature\r\n${before}\r\n${after}\r\n`
)
const attached = rows().map((row) => ({ ...row, branch: 'refs/heads/main' }))
await expect(isBranchReservedByWorktreeOperation(repo, 'feature', attached)).resolves.toBe(
true
)
await expect(isBranchReservedByWorktreeOperation(repo, 'unreserved', attached)).resolves.toBe(
false
)
}
)
it('checks update-refs in the main worktree and compares only ref-name fields', async () => {
await mkdir(path.join(common, 'rebase-merge'))
await writeFile(
path.join(common, 'rebase-merge', 'update-refs'),
`refs/heads/feature\n${'a'.repeat(40)}\n${'0'.repeat(40)}\n`
)
await expect(isBranchReservedByWorktreeOperation(repo, 'feature', rows())).resolves.toBe(true)
await expect(isBranchReservedByWorktreeOperation(repo, 'a'.repeat(40), rows())).resolves.toBe(
false
)
})
it.each([
`refs/heads/feature\n${'a'.repeat(40)}\n`,
`refs/heads/feature\n${'a'.repeat(40)}\n${'g'.repeat(40)}\n`,
`refs/heads/feature\n${'a'.repeat(40)}\n${'0'.repeat(64)}\n`,
`refs/heads/feature\n${'a'.repeat(40)}\n${'0'.repeat(40)}\ninvalid\n`
])('fails closed on malformed update-refs records: %s', async (contents) => {
await mkdir(path.join(admin, 'rebase-merge'))
await writeFile(path.join(admin, 'rebase-merge', 'update-refs'), contents)
await expect(isBranchReservedByWorktreeOperation(repo, 'feature', rows())).rejects.toThrow(
'Cannot verify rebase update-refs branch usage'
)
})
it('fails closed when update-refs cannot be read', async () => {
await mkdir(path.join(admin, 'rebase-merge', 'update-refs'), { recursive: true })
await expect(isBranchReservedByWorktreeOperation(repo, 'feature', rows())).rejects.toThrow()
})
it('propagates cancellation during administrative reads', async () => {
const signal = AbortSignal.abort(new Error('cancelled'))
await expect(annotateWorktreeLocksFromAdmin(repo, rows(), { signal })).rejects.toThrow(
'cancelled'
)
await expect(
isBranchReservedByWorktreeOperation(repo, 'feature', rows(), { signal })
).rejects.toThrow('cancelled')
await expect(findLinkedWorktreeGitDirectory(repo, linked, { signal })).rejects.toThrow(
'cancelled'
)
})
})