starred/orca
1
0
Fork 0
mirror of https://github.com/stablyai/orca.git synced 2026-09-22 16:02:32 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
cff202c16a79bbcd3d24cb7ab62abf2898449a23
orca/src/shared/setup-agent-sequencing.test.ts
T
OrcaWinandOrca Worker cff202c16a fix(windows): drop EDR-flagged -ExecutionPolicy Bypass from encoded PowerShell (#17880) 
* fix(windows): drop EDR-flagged -ExecutionPolicy Bypass from encoded PowerShell

MDE flags `-ExecutionPolicy Bypass` paired with base64 `-EncodedCommand` as a
behavioural signal. Measured on Windows 11: neither `-Command` nor
`-EncodedCommand` is execution-policy gated (both run under an explicit
`-ExecutionPolicy Restricted` and `AllSigned`; only `-File` fails), so the
switch was a pure no-op on every one of these command lines.

Removes the switch from all four sites that spelled it, and de-encodes the one
site whose payload never passes through a re-parsing shell:

- ssh-remote-powershell: one chokepoint for ~40 remote-Windows call sites.
  Base64 kept — the remote sshd DefaultShell re-parses this string.
- setup-agent-sequencing / windows-cmd-runner-delayed-launch: base64 kept —
  these strings are typed into a terminal pane.
- windows-interactive-login-spawn: base64 kept — `cmd.exe /c start` re-parses,
  and the cmd-safe-token guard rejects the `&` and `"` in the raw relay script.
- windows-mobile-firewall local runner: `-EncodedCommand` -> `-Command`, since
  execFile reaches CreateProcess with no shell in between.

The setup startup gate keeps execution-policy relief in-payload (process scope),
because it evals a user-authored startup command that may invoke a `.ps1`, and a
`.ps1` IS gated. Caught by the real-process suite; mirrors the agent-hooks
launcher's trade.

The elevated firewall child deliberately stays encoded: `Start-Process
-ArgumentList` joins its array into one ShellExecuteEx string without quoting
and PowerShell re-splits on whitespace, measured to collapse `C:\My  App\...`
to `C:\My App\...` — a firewall rule for the wrong program.

* test(ssh): enforce the no-script-file invariant remote payloads rely on

Dropping `-ExecutionPolicy Bypass` from `powerShellCommand` is a no-op only
while no remote payload loads a PowerShell script file — execution policy has
never gated anything else. That invariant held by inspection and was guarded by
nothing, so a future payload that dot-sourced, used `-File`, or imported a
`.psm1` would break only on a remote host with a Restricted/AllSigned
LocalMachine policy and no GPO: a failure on someone else's machine.

States the invariant at the wrapper, and adds a ratchet that scans every module
importing it for `.ps1`/`.psm1`, `Import-Module`, `-File`, and dot-sourcing.
The scan discovers importers itself (13 today) so new ones are covered, and
asserts it found some, so an emptied list cannot pass vacuously.

Mutation-checked: injecting each construct into a real importer fails the
matching case and names the file. The first dot-source pattern passed a
`;`-prefixed sample but missed `powerShellCommand(". '$x'")` — the likelier
shape — so the pattern now accepts a string-literal start and the self-test
samples carry their surrounding quotes.

* test(ssh): close two blind spots in the remote-payload ratchet

Both found by independent mutation testing of the ratchet itself, and both let
a real violation pass while the guard reported green.

`-File` was matched case-sensitively, so `-file $scriptVar` slipped through —
PowerShell switches are case-insensitive, and with a variable path the `.ps1`
pattern does not cover for it, so that shape escaped both nets. The naive fix
is wrong: bare /-File\b/i matches `--credential-file`, `--log-file` and
`--body-file`, which occur in three of these importers. Anchoring to a token
boundary catches the lowercase, odd-spacing and argv-element forms with zero
offenders across all 14.

Comment stripping paired a `/*` appearing inside a string (a glob such as
'src/*.ts') with any later comment close and deleted everything between, hiding
violations in the gap. Anchoring the block strip to line start, as the `//`
strip already was, fixes it — verified by injecting an `Import-Module` after a
glob string: the unanchored form misses it, the anchored form catches it.

Extends the same case-insensitivity to `.ps1`/`.psm1` and `Import-Module`,
which had the identical flaw (`import-module`, `DEPLOY.PS1` are legitimate
spellings); measured to add no false positive.

Each construct now carries the fixtures it must catch AND the near-misses it
must not, so a future tightening cannot quietly trade one for the other — the
negative fixtures are what would have caught the naive `-File` fix. Non-vacuity
bound tightened to >10 against 14 importers.

* docs(ssh): state what the remote-payload ratchet cannot see

The scan matches source text, so a script file reached only through a variable
(`& $scriptPath`) never appears in source and no pattern can catch it. The
ratchet narrows the hole; the invariant note on `powerShellCommand` covers the
remainder.

Recorded because a guard that reads as complete coverage when it is not is
worse than one that states its edge: the next author trusts it further than it
deserves, and should learn this limit from the test rather than an incident.

* test(ssh): scan remote payloads with the shared source walk

The ratchet had its own tree walk and comment stripper. The walk skipped
neither node_modules/dist/.git nor dot-directories and excluded tests by
`.test.ts` alone, so its importer count -- the guard's own goalpost -- could
be wrong about what it scanned. The stripper was anchored to line start to
dodge a `/*` inside a glob string, which silently skipped trailing comments;
`stripComments` tracks quote state and handles both.

Importer set re-derived against the shared walk: 15, floor unchanged at 10.

* fix(setup): report a failed execution-policy relief instead of swallowing it

The in-payload Set-ExecutionPolicy carried -ErrorAction SilentlyContinue and
an empty catch, so any failure vanished. A Windows PowerShell 5.1 install with
duplicate extended type data fails every cmdlet in Microsoft.PowerShell.Security
-- autoload, not policy -- and the user then saw only their own .ps1 being
refused, with no trace that the relief had been attempted or why.

-ErrorAction Stop is what routes a non-terminating failure into the catch at
all; the catch reports the FullyQualifiedErrorId to stderr and deliberately
does not rethrow, so a broken policy cmdlet cannot take down the startup this
gate exists to run. Success path is unchanged and stays stderr-clean.

Verified by execution on a clean child environment: success -> policy=Bypass,
stderr empty; shadowed failing cmdlet -> diagnostic on stderr and the gate
still continues; the old empty catch -> silent.

---------

Co-authored-by: Orca Worker <orca-worker@localhost>
2026-09-05 21:12:40 -07:00

668 lines
25 KiB
TypeScript
Raw Blame History

import { spawn } from 'node:child_process'
import { chmodSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
import { join } from 'node:path'
import { tmpdir } from 'node:os'
import { afterEach, describe, expect, it, vi } from 'vitest'
import { getDefaultRepoHookSettings } from './constants'
import {
createSequencedSetupAgentCommands,
createSetupAgentSequenceNonce,
SETUP_COMPLETE_MESSAGE,
getSetupAgentSequenceShellForTests,
resolveSetupAgentSequenceLaunchCommand,
SETUP_AGENT_SEQUENCE_STARTUP_COMMAND_ENV,
SETUP_AGENT_SEQUENCE_STARTUP_SCRIPT_ENV
} from './setup-agent-sequencing'
import {
DEFAULT_SETUP_AGENT_STARTUP_POLICY,
shouldWaitForSetupBeforeAgentStartup
} from './setup-agent-startup-policy'
const TEMP_DIRS: string[] = []
const WINDOWS_PROCESS_TEST_TIMEOUT_MS = 30_000
afterEach(() => {
for (const dir of TEMP_DIRS.splice(0)) {
rmSync(dir, { recursive: true, force: true })
}
})
describe('createSequencedSetupAgentCommands', () => {
it('defaults agent startup to immediate unless the wait policy is explicit', () => {
expect(DEFAULT_SETUP_AGENT_STARTUP_POLICY).toBe('start-immediately')
expect(getDefaultRepoHookSettings().setupAgentStartupPolicy).toBe('start-immediately')
expect(shouldWaitForSetupBeforeAgentStartup(undefined)).toBe(false)
expect(shouldWaitForSetupBeforeAgentStartup('start-immediately')).toBe(false)
expect(shouldWaitForSetupBeforeAgentStartup('wait-for-setup')).toBe(true)
})
it('uses the original sequenced startup command as the launch hint when present', () => {
expect(
resolveSetupAgentSequenceLaunchCommand(
{ [SETUP_AGENT_SEQUENCE_STARTUP_COMMAND_ENV]: 'omp --resume' },
'powershell wait-wrapper'
)
).toBe('omp --resume')
expect(
resolveSetupAgentSequenceLaunchCommand(
{ [SETUP_AGENT_SEQUENCE_STARTUP_COMMAND_ENV]: ' ' },
'powershell wait-wrapper'
)
).toBe('powershell wait-wrapper')
})
it('wraps POSIX setup and startup commands with a matching nonce marker', () => {
const result = createSequencedSetupAgentCommands({
runnerScriptPath: '/repo/.git/orca/setup-runner.sh',
startupCommand: "codex 'fix bug'",
platform: 'posix',
nonce: 'nonce-123',
waitTimeoutSeconds: 9
})
expect(result.setupCommand).toMatch(/^bash -lc /)
expect(result.setupCommand).toContain('bash /repo/.git/orca/setup-runner.sh')
expect(result.setupCommand).toContain('printf')
expect(result.setupCommand).toContain('nonce-123 "$status"')
expect(result.setupCommand).toContain(
'mv -f /repo/.git/orca/setup-runner.sh.nonce-123.done.tmp'
)
const startupScript = result.startupEnv?.[SETUP_AGENT_SEQUENCE_STARTUP_SCRIPT_ENV]
expect(result.startupCommand).toBe(
`bash -lc 'eval "$${SETUP_AGENT_SEQUENCE_STARTUP_SCRIPT_ENV}"'`
)
expect(startupScript).toContain('deadline=$((SECONDS + 9))')
expect(startupScript).not.toContain('date +%s')
expect(startupScript).toContain('Waiting for setup to finish before starting agent...')
expect(startupScript).toContain('[ "$seen" = nonce-123 ]')
expect(startupScript).toContain(
'rm -f /repo/.git/orca/setup-runner.sh.nonce-123.done /repo/.git/orca/setup-runner.sh.nonce-123.done.tmp'
)
expect(startupScript).toContain('exec codex')
expect(startupScript).toContain('fix bug')
expect(result.startupEnv).toEqual(
expect.objectContaining({
[SETUP_AGENT_SEQUENCE_STARTUP_COMMAND_ENV]: "codex 'fix bug'",
[SETUP_AGENT_SEQUENCE_STARTUP_SCRIPT_ENV]: startupScript
})
)
})
it('announces success so the pane stops showing the waiting line', () => {
const commands = createSequencedSetupAgentCommands({
runnerScriptPath: '/repo/.git/orca/setup-runner.sh',
startupCommand: 'codex',
platform: 'posix',
nonce: 'nonce-1'
})
const script = commands.startupEnv?.ORCA_SEQUENCED_STARTUP_SCRIPT ?? ''
// Why ordering: `eval`/`exec` never returns, so a later message never renders.
expect(script.indexOf(SETUP_COMPLETE_MESSAGE)).toBeGreaterThan(-1)
expect(script.indexOf(SETUP_COMPLETE_MESSAGE)).toBeLessThan(
script.indexOf('eval "$ORCA_SEQUENCED_STARTUP_COMMAND"')
)
})
it('announces success on the native Windows gate too', () => {
const commands = createSequencedSetupAgentCommands({
runnerScriptPath: 'C:\\repo\\.git\\orca\\setup-runner.cmd',
platform: 'windows',
startupCommand: 'codex',
nonce: 'nonce-2'
})
const decoded = Buffer.from(
commands.startupCommand.split('-EncodedCommand ')[1] ?? '',
'base64'
).toString('utf16le')
expect(decoded).toContain(SETUP_COMPLETE_MESSAGE)
expect(decoded.indexOf(SETUP_COMPLETE_MESSAGE)).toBeLessThan(
decoded.indexOf('Invoke-Expression $startup')
)
})
it('leaves the failure and timeout messages as the only other outcomes', () => {
const script =
createSequencedSetupAgentCommands({
runnerScriptPath: '/repo/.git/orca/setup-runner.sh',
startupCommand: 'codex',
platform: 'posix',
nonce: 'nonce-3'
}).startupEnv?.ORCA_SEQUENCED_STARTUP_SCRIPT ?? ''
// Silence on success is what made a healthy worktree look stuck.
expect(script).toContain(SETUP_COMPLETE_MESSAGE)
expect(script).toContain('Setup failed; skipping agent startup.')
expect(script).toContain('Timed out waiting for setup before starting agent.')
})
it('keeps the POSIX terminal submission below the canonical input floor', () => {
const result = createSequencedSetupAgentCommands({
runnerScriptPath: `/repo/${'nested-worktree/'.repeat(100)}setup-runner.sh`,
startupCommand: 'codex',
platform: 'posix',
nonce: 'long-path'
})
expect(result.startupCommand.length).toBeLessThan(256)
expect(result.startupCommand).not.toContain('nested-worktree')
expect(result.startupEnv?.[SETUP_AGENT_SEQUENCE_STARTUP_SCRIPT_ENV]).toContain(
'nested-worktree'
)
})
it('uses launch-specific marker paths for overlapping setup gates', () => {
const first = createSequencedSetupAgentCommands({
runnerScriptPath: '/repo/.git/orca/setup-runner.sh',
startupCommand: 'claude',
platform: 'posix',
nonce: 'first-launch'
})
const second = createSequencedSetupAgentCommands({
runnerScriptPath: '/repo/.git/orca/setup-runner.sh',
startupCommand: 'codex',
platform: 'posix',
nonce: 'second-launch'
})
expect(first.setupCommand).toContain('/repo/.git/orca/setup-runner.sh.first-launch.done')
expect(first.startupEnv?.[SETUP_AGENT_SEQUENCE_STARTUP_SCRIPT_ENV]).toContain(
'/repo/.git/orca/setup-runner.sh.first-launch.done'
)
expect(second.setupCommand).toContain('/repo/.git/orca/setup-runner.sh.second-launch.done')
expect(second.startupEnv?.[SETUP_AGENT_SEQUENCE_STARTUP_SCRIPT_ENV]).toContain(
'/repo/.git/orca/setup-runner.sh.second-launch.done'
)
expect(first.setupCommand).not.toContain('/repo/.git/orca/setup-runner.sh.second-launch.done')
expect(second.setupCommand).not.toContain('/repo/.git/orca/setup-runner.sh.first-launch.done')
})
it('keeps simple POSIX startup commands eligible for exec when quoted text has separators', () => {
const result = createSequencedSetupAgentCommands({
runnerScriptPath: '/repo/.git/orca/setup-runner.sh',
startupCommand: "codex 'fix this; then test'",
platform: 'posix',
nonce: 'nonce-quoted',
waitTimeoutSeconds: 9
})
const startupScript = result.startupEnv?.[SETUP_AGENT_SEQUENCE_STARTUP_SCRIPT_ENV]
expect(startupScript).toContain("exec codex 'fix this; then test'")
expect(startupScript).not.toContain('eval codex')
})
it('preserves POSIX inline environment assignment startup commands', () => {
const result = createSequencedSetupAgentCommands({
runnerScriptPath: '/repo/.git/orca/setup-runner.sh',
startupCommand: 'FOO=bar claude',
platform: 'posix',
nonce: 'nonce-env',
waitTimeoutSeconds: 9
})
const startupScript = result.startupEnv?.[SETUP_AGENT_SEQUENCE_STARTUP_SCRIPT_ENV]
expect(startupScript).toContain('FOO=bar claude')
expect(startupScript).toContain('exit "$?"')
expect(startupScript).not.toContain('exec FOO=bar claude')
})
it('uses the converted Linux marker path for WSL UNC runners on Windows', () => {
const result = createSequencedSetupAgentCommands({
runnerScriptPath:
'\\\\wsl.localhost\\Ubuntu\\home\\jin\\repo\\.git\\worktrees\\feature\\orca\\setup-runner.sh',
startupCommand: 'claude',
platform: 'windows',
nonce: 'nonce-wsl'
})
expect(getSetupAgentSequenceShellForTests(resultPathWsl(), 'windows')).toBe('posix')
expect(result.setupCommand).toContain(
'bash /home/jin/repo/.git/worktrees/feature/orca/setup-runner.sh'
)
expect(result.setupCommand).toContain(
'/home/jin/repo/.git/worktrees/feature/orca/setup-runner.sh.nonce-wsl.done'
)
expect(result.setupCommand).not.toContain('wsl.localhost')
})
it('keeps remote POSIX runners in bash even from a Windows client', () => {
const result = createSequencedSetupAgentCommands({
runnerScriptPath: '/remote/repo/.git/worktrees/feature/orca/setup-runner.sh',
startupCommand: 'claude',
platform: 'windows',
nonce: 'nonce-remote'
})
expect(result.setupCommand).toContain(
'bash /remote/repo/.git/worktrees/feature/orca/setup-runner.sh'
)
expect(result.startupEnv?.[SETUP_AGENT_SEQUENCE_STARTUP_SCRIPT_ENV]).toContain(
'[ "$seen" = nonce-remote ]'
)
})
it('preserves WSL shell metadata when sequencing native Windows runners', () => {
const result = createSequencedSetupAgentCommands({
runnerScriptPath: 'C:\\repo\\.git\\orca\\setup-runner.sh',
startupCommand: 'claude',
platform: 'windows',
shell: { family: 'posix', executable: 'wsl.exe' },
nonce: 'nonce-wsl-shell'
})
expect(result.setupCommand).toContain('bash /mnt/c/repo/.git/orca/setup-runner.sh')
expect(result.setupCommand).toContain(
'/mnt/c/repo/.git/orca/setup-runner.sh.nonce-wsl-shell.done'
)
expect(result.startupEnv?.[SETUP_AGENT_SEQUENCE_STARTUP_SCRIPT_ENV]).toContain(
'/mnt/c/repo/.git/orca/setup-runner.sh.nonce-wsl-shell.done'
)
})
it('wraps native Windows runners in a cmd-pinned setup and startup gate', () => {
const result = createSequencedSetupAgentCommands({
runnerScriptPath: 'C:\\repo\\.git\\orca\\setup-runner.cmd',
startupCommand: "codex --model gpt-5 'fix !PATH! & test'",
platform: 'windows',
nonce: 'nonce-win',
waitTimeoutSeconds: 3
})
const setupPowerShell = decodePowerShellScript(result.setupCommand)
const startupPowerShell = decodePowerShellScript(result.startupCommand)
expect(result.setupCommand).toContain(
'powershell.exe -NoProfile -NonInteractive -EncodedCommand'
)
expect(setupPowerShell).toContain("$runner = 'C:\\repo\\.git\\orca\\setup-runner.cmd'")
expect(setupPowerShell).toContain('$nonce + ":" + $setupStatus')
expect(result.startupCommand.match(/powershell\.exe/g)).toHaveLength(1)
expect(result.startupCommand).toContain(
'powershell.exe -NoProfile -NonInteractive -EncodedCommand'
)
expect(startupPowerShell).toContain('AddSeconds(3)')
expect(startupPowerShell).toContain('Missing setup marker path.')
expect(startupPowerShell).toContain('Timed out waiting for setup before starting agent.')
expect(startupPowerShell).toContain('Setup failed; skipping agent startup.')
expect(startupPowerShell).toContain(
'Remove-Item -LiteralPath $marker, $tmp -Force -ErrorAction SilentlyContinue'
)
expect(result.startupCommand).not.toContain('%ERRORLEVEL%')
expect(startupPowerShell).toContain('Invoke-Expression')
expect(result.startupCommand).not.toContain('fix !PATH! & test')
expect(result.startupEnv).toEqual({
[SETUP_AGENT_SEQUENCE_STARTUP_COMMAND_ENV]: "codex --model gpt-5 'fix !PATH! & test'"
})
// Why: `-EncodedCommand` is not execution-policy gated — only `-File` is — so the switch
// was a no-op, and base64 beside `-ExecutionPolicy Bypass` is a heavily EDR-flagged shape.
// The base64 itself must stay: these strings are typed into a terminal pane.
expect(result.setupCommand).not.toMatch(/-ExecutionPolicy/i)
expect(result.startupCommand).not.toMatch(/-ExecutionPolicy/i)
// Why: dropping the switch alone would break a user startup command that invokes a
// `.ps1` — a `.ps1` IS policy gated even though `-EncodedCommand` is not. The relief
// moves into the payload, where it is not part of the flagged command-line shape.
expect(startupPowerShell).toContain(
'Set-ExecutionPolicy -Scope Process -ExecutionPolicy Bypass -Force -ErrorAction Stop'
)
// Why `-ErrorAction Stop` and a reporting catch: autoload can fail for reasons that are
// not about policy at all (a 5.1 install with duplicate extended type data fails every
// cmdlet in Microsoft.PowerShell.Security), and the old SilentlyContinue plus `catch {}`
// hid that -- the user saw only their own script being refused. The catch must report and
// must NOT rethrow, or a broken policy cmdlet would take the whole startup with it.
expect(startupPowerShell).not.toContain('catch {}')
expect(startupPowerShell).toMatch(/catch \{ \[Console\]::Error\.WriteLine\(/)
expect(startupPowerShell).toContain('$_.FullyQualifiedErrorId')
expect(startupPowerShell).not.toMatch(/catch \{[^}]*throw/)
// Why: the autoloaded module's progress record would otherwise corrupt this gate's stderr.
expect(startupPowerShell).toContain("$ProgressPreference = 'SilentlyContinue'")
expect(startupPowerShell).toContain('$ProgressPreference = $orcaProgress')
// The setup gate only ever launches a .cmd/.bat runner, so it needs no relief.
expect(setupPowerShell).not.toMatch(/Set-ExecutionPolicy/i)
})
it('launches a batch runner through the cmd launcher inside a Git Bash gate', () => {
// Regression (#6896): a Git Bash terminal with a batch setup script still gets a .cmd
// runner, and the gate must not hand that runner to bash. The gate itself stays POSIX
// because the Git Bash pane types it and quoted the startup command for bash.
const result = createSequencedSetupAgentCommands({
runnerScriptPath: 'C:\\repo\\.git\\orca\\setup-runner.cmd',
startupCommand: "claude 'fix the user'\\''s login'",
platform: 'windows',
shell: { family: 'posix' },
nonce: 'nonce-gitbash-cmd'
})
expect(result.setupCommand).toContain(
'powershell.exe -NoProfile -NonInteractive -EncodedCommand'
)
expect(result.setupCommand).not.toMatch(/bash\s+\S*setup-runner/)
expect(decodePowerShellScript(result.setupCommand)).toContain(
"$runner = 'C:\\repo\\.git\\orca\\setup-runner.cmd'"
)
// Why: PowerShell's `Invoke-Expression` cannot parse the POSIX `'\''` escaping a Git Bash
// pane produces, so the gate that evaluates the startup command must be bash.
expect(result.setupCommand).toMatch(/^bash -lc /)
expect(result.startupCommand).toMatch(/^bash -lc /)
expect(result.startupCommand).not.toContain('Invoke-Expression')
expect(result.startupEnv?.[SETUP_AGENT_SEQUENCE_STARTUP_SCRIPT_ENV]).toContain(
'eval "$ORCA_SEQUENCED_STARTUP_COMMAND"'
)
// Why: bash writes and reads the marker here, so it needs the /c/... form of the path.
expect(result.setupCommand).toContain(
'/c/repo/.git/orca/setup-runner.cmd.nonce-gitbash-cmd.done'
)
expect(result.startupEnv?.[SETUP_AGENT_SEQUENCE_STARTUP_SCRIPT_ENV]).toContain(
'/c/repo/.git/orca/setup-runner.cmd.nonce-gitbash-cmd.done'
)
})
it.skipIf(process.platform !== 'win32')(
'executes the native Windows setup-to-agent sequence through cmd.exe',
async () => {
const tempDir = join(makeTempDir(), 'path with spaces')
mkdirSync(tempDir)
const runnerScriptPath = join(tempDir, 'setup runner.cmd')
const startupScriptPath = join(tempDir, 'agent-startup.cmd')
const logPath = join(tempDir, 'sequence.log')
writeFileSync(
runnerScriptPath,
['@echo off', `>> "${logPath}" echo setup-done`, 'exit /b 0'].join('\r\n'),
'utf8'
)
writeFileSync(
startupScriptPath,
['@echo off', `>> "${logPath}" echo agent-start`, 'exit /b 0'].join('\r\n'),
'utf8'
)
const commands = createSequencedSetupAgentCommands({
runnerScriptPath,
startupCommand: `cmd.exe /d /c "${startupScriptPath}"`,
platform: 'windows',
nonce: 'windows-sequence',
waitTimeoutSeconds: 2
})
const setupExit = await waitForExit(
spawnWindowsCommand(tempDir, 'run-setup.cmd', commands.setupCommand)
)
expect(setupExit.code).toBe(0)
expect(readIfExists(`${runnerScriptPath}.windows-sequence.done`)).toBe(
'windows-sequence:0\r\n'
)
const startupExit = await waitForExit(
spawnWindowsCommand(
tempDir,
'run-startup.cmd',
commands.startupCommand,
commands.startupEnv
)
)
expect(startupExit.code).toBe(0)
expect(startupExit.stderr).toContain('Waiting for setup to finish before starting agent...')
expect(readFileSync(logPath, 'utf8')).toBe('setup-done\r\nagent-start\r\n')
},
WINDOWS_PROCESS_TEST_TIMEOUT_MS
)
it.skipIf(process.platform === 'win32')(
'ignores stale markers until the matching setup run finishes, even when startup launches first',
async () => {
const tempDir = makeTempDir()
const runnerScriptPath = join(tempDir, 'setup-runner.sh')
const startupScriptPath = join(tempDir, 'startup.sh')
const logPath = join(tempDir, 'sequence.log')
const markerPath = `${runnerScriptPath}.fresh-sequence.done`
writeExecutable(
runnerScriptPath,
[
'#!/bin/sh',
`printf 'setup-start\\n' >> ${quoteSh(logPath)}`,
'sleep 1',
`printf 'setup-done\\n' >> ${quoteSh(logPath)}`
].join('\n')
)
writeExecutable(
startupScriptPath,
['#!/bin/sh', `printf 'agent-start\\n' >> ${quoteSh(logPath)}`].join('\n')
)
writeFileSync(markerPath, 'stale:0\n', 'utf8')
const commands = createSequencedSetupAgentCommands({
runnerScriptPath,
startupCommand: `bash ${quoteSh(startupScriptPath)}`,
platform: 'posix',
nonce: 'fresh-sequence',
waitTimeoutSeconds: 5
})
const startupExitPromise = waitForExit(
spawn('bash', ['-lc', commands.startupCommand], {
stdio: 'pipe',
env: { ...process.env, ...commands.startupEnv }
})
)
await sleep(250)
expect(readIfExists(logPath)).toBe('')
expect(readFileSync(markerPath, 'utf8')).toBe('stale:0\n')
const setupExit = await waitForExit(
spawn('bash', ['-lc', commands.setupCommand], { stdio: 'pipe' })
)
expect(setupExit.code).toBe(0)
const startupExit = await startupExitPromise
expect(startupExit.code).toBe(0)
expect(readFileSync(logPath, 'utf8')).toBe('setup-start\nsetup-done\nagent-start\n')
expect(readIfExists(markerPath)).toBe('')
expect(readIfExists(`${markerPath}.tmp`)).toBe('')
}
)
it.skipIf(process.platform === 'win32')(
'runs compound POSIX startup cleanup commands after setup succeeds',
async () => {
const tempDir = makeTempDir()
const runnerScriptPath = join(tempDir, 'setup-runner.sh')
const logPath = join(tempDir, 'sequence.log')
writeExecutable(
runnerScriptPath,
['#!/bin/sh', `printf 'setup-done\\n' >> ${quoteSh(logPath)}`].join('\n')
)
const commands = createSequencedSetupAgentCommands({
runnerScriptPath,
startupCommand: `printf 'agent-start\\n' >> ${quoteSh(logPath)}; printf 'cleanup\\n' >> ${quoteSh(logPath)}`,
platform: 'posix',
nonce: 'compound-sequence',
waitTimeoutSeconds: 5
})
const setupExitPromise = waitForExit(
spawn('bash', ['-lc', commands.setupCommand], { stdio: 'pipe' })
)
const startupExit = await waitForExit(
spawn('bash', ['-lc', commands.startupCommand], {
stdio: 'pipe',
env: { ...process.env, ...commands.startupEnv }
})
)
const setupExit = await setupExitPromise
expect(setupExit.code).toBe(0)
expect(startupExit.code).toBe(0)
expect(readFileSync(logPath, 'utf8')).toBe('setup-done\nagent-start\ncleanup\n')
const startupScript = commands.startupEnv?.[SETUP_AGENT_SEQUENCE_STARTUP_SCRIPT_ENV]
expect(startupScript).toContain('eval')
expect(startupScript).not.toContain('exec printf')
}
)
it.skipIf(process.platform === 'win32')(
'prefers the env-provided startup command after setup succeeds',
async () => {
const tempDir = makeTempDir()
const runnerScriptPath = join(tempDir, 'setup-runner.sh')
const startupScriptPath = join(tempDir, 'startup.sh')
const logPath = join(tempDir, 'sequence.log')
writeExecutable(
runnerScriptPath,
['#!/bin/sh', `printf 'setup-done\\n' >> ${quoteSh(logPath)}`].join('\n')
)
writeExecutable(
startupScriptPath,
[
'#!/bin/sh',
'if [ "$FOO" = "bar" ]; then',
` printf 'env-start\\n' >> ${quoteSh(logPath)}`,
'fi'
].join('\n')
)
const commands = createSequencedSetupAgentCommands({
runnerScriptPath,
startupCommand: `printf 'inline-start\\n' >> ${quoteSh(logPath)}`,
platform: 'posix',
nonce: 'env-sequence',
waitTimeoutSeconds: 5
})
const setupExitPromise = waitForExit(
spawn('bash', ['-lc', commands.setupCommand], { stdio: 'pipe' })
)
const startupExit = await waitForExit(
spawn('bash', ['-lc', commands.startupCommand], {
stdio: 'pipe',
env: {
...process.env,
...commands.startupEnv,
[SETUP_AGENT_SEQUENCE_STARTUP_COMMAND_ENV]: `FOO=bar bash ${quoteSh(startupScriptPath)}; printf 'env-cleanup\\n' >> ${quoteSh(logPath)}`
}
})
)
const setupExit = await setupExitPromise
expect(setupExit.code).toBe(0)
expect(startupExit.code).toBe(0)
expect(readFileSync(logPath, 'utf8')).toBe('setup-done\nenv-start\nenv-cleanup\n')
}
)
it.skipIf(process.platform === 'win32')(
'times out instead of hanging forever when setup never writes a matching marker',
async () => {
const tempDir = makeTempDir()
const runnerScriptPath = join(tempDir, 'setup-runner.sh')
writeExecutable(runnerScriptPath, '#!/bin/sh\nexit 0\n')
const commands = createSequencedSetupAgentCommands({
runnerScriptPath,
startupCommand: 'printf ready',
platform: 'posix',
nonce: 'timeout-sequence',
waitTimeoutSeconds: 1
})
const startupExit = await waitForExit(
spawn('bash', ['-lc', commands.startupCommand], {
stdio: 'pipe',
env: { ...process.env, ...commands.startupEnv }
})
)
expect(startupExit.code).toBe(124)
expect(startupExit.stderr).toContain('Timed out waiting for setup before starting agent.')
}
)
})
describe('createSetupAgentSequenceNonce', () => {
it('prefers crypto.randomUUID when available', () => {
const originalCrypto = globalThis.crypto
vi.stubGlobal('crypto', { randomUUID: () => 'uuid-1' })
expect(createSetupAgentSequenceNonce()).toBe('uuid-1')
vi.stubGlobal('crypto', originalCrypto)
})
})
function resultPathWsl(): string {
return '\\\\wsl.localhost\\Ubuntu\\home\\jin\\repo\\.git\\worktrees\\feature\\orca\\setup-runner.sh'
}
function makeTempDir(): string {
const dir = mkdtempSync(join(tmpdir(), 'orca-setup-sequencing-'))
TEMP_DIRS.push(dir)
return dir
}
function writeExecutable(path: string, contents: string): void {
writeFileSync(path, contents, 'utf8')
chmodSync(path, 0o755)
}
function quoteSh(value: string): string {
return `'${value.replace(/'/g, `'\\''`)}'`
}
function readIfExists(path: string): string {
try {
return readFileSync(path, 'utf8')
} catch {
return ''
}
}
function sleep(ms: number): Promise<void> {
return new Promise((resolve) => {
setTimeout(resolve, ms)
})
}
function spawnWindowsCommand(
dir: string,
filename: string,
command: string,
env: Record<string, string> = {}
): ReturnType<typeof spawn> {
const scriptPath = join(dir, filename)
// Why: /s strips the quotes Node adds for batch paths containing spaces;
// argv spawning still exercises cmd.exe's native parser without that loss.
writeFileSync(scriptPath, `@echo off\r\n${command}\r\nexit /b %ERRORLEVEL%\r\n`, 'utf8')
return spawn('cmd.exe', ['/d', '/c', scriptPath], {
stdio: 'pipe',
env: { ...process.env, ...env }
})
}
function decodePowerShellScript(command: string): string {
const encoded = command.match(/-EncodedCommand\s+([A-Za-z0-9+/=]+)/)?.[1]
if (!encoded) {
throw new Error('Missing PowerShell encoded command')
}
return Buffer.from(encoded, 'base64').toString('utf16le')
}
function waitForExit(
child: ReturnType<typeof spawn>
): Promise<{ code: number | null; stderr: string }> {
return new Promise((resolve, reject) => {
let stderr = ''
child.stderr?.on('data', (chunk: Buffer | string) => {
stderr += chunk.toString()
})
child.once('error', reject)
child.once('close', (code) => {
resolve({ code, stderr })
})
})
}
Reference in New Issue View Git Blame Copy Permalink