mirror of
https://github.com/stablyai/orca.git
synced 2026-09-23 08:02:31 +00:00
OrcaWinandOrcaWin
ed7849eb7b
* fix(worktrees): stop silently switching existing Windows setup scripts to Git Bash #6967 derived the Windows setup-runner shell from `terminalWindowsShell`. On upgrade, any Windows user whose terminal preference resolved to Git Bash had their existing `orca.yaml` setup script (and issue command) handed to bash instead of cmd.exe. Scripts authored against the cmd runner — `copy`, `xcopy`, `set VAR=value`, `if errorlevel 1`, `%VAR%`, backslash paths — broke with no migration and no warning, and the failure looked like Orca broke the project. The conflation is also wrong in the steady state: a terminal preference is per-user, so two people on the same repo got different interpreters for the same orca.yaml and no project could write a setup script that worked for all of its Windows contributors. The interpreter is now a property of the script, declared the standard way: a leading `#!` line. Native Windows keeps the historical `.cmd` runner unless the script declares a POSIX shell, so no existing script changes behavior. `resolveSetupRunnerShell` keeps its role as the feasibility gate — a bash runner still requires the terminal to resolve to Git Bash, since the launch command is typed into that shell and uses MSYS `/c/...` paths. `buildWindowsRunnerScript` now drops a leading `#!` line rather than `call`ing it, so a declared-bash script that falls back to cmd (Git Bash missing) fails on a real setup line instead of aborting on errorlevel at line one. WSL worktrees, POSIX platforms, and SSH hosts are untouched. * fix(worktrees): keep the cmd setup runner launchable from a Git Bash pane Adversarial review of this PR found that pinning the runner format per script reopened issue #6896 one layer down. - `WorktreeSetupLaunch.shell` had been redefined to mean "the format the runner file was written in". `resolveSetupRunnerCommand` consumes it as "the shell that types the launch command", so a Git Bash terminal with a batch setup script produced `cmd.exe /c "C:\...\setup-runner.cmd"` typed into a bash pane, where MSYS rewrites the `/c` switch into a drive path: cmd opens interactively and setup never runs. `shell` is the terminal's family again; the runner file's .cmd/.sh extension carries the format, and a batch runner launched from a POSIX pane reuses the existing PowerShell ProcessStartInfo launcher. - The cmd runner dropped a leading `#!` line and ran the rest as batch, so a bash script reaching cmd (PowerShell/cmd terminal, or any SSH-to-Windows host) got its interpreter-agnostic prefix executed before failing mid-way. It now prints why and exits 1 without running anything. - A `#!` line's option flags were discarded: `#!/usr/bin/env -S bash -euo pipefail` lost pipefail because the runner is launched as `bash <path>`. The generated posix runner now replays declared flags via `set` and drops the duplicate interpreter line. - Docs cover the per-user setup command in repository hook settings, which goes through the same `#!` rule, and describe what the `#!` line does and does not select. Tests: composed launch command for a POSIX pane + cmd runner (hooks, shared runner command, setup sequencing gate, observed-setup signal), the cmd runner's shebang refusal, and shebang flag replay. Each fails with the source reverted. * fix(worktrees): replay only real `set` flags and keep the gate in the pane's shell Two round-2 review findings: - `#!/bin/bash -l` replayed `set -l`, which exits 2 and aborted the runner under its own `set -e` before a single setup line ran (all platforms). Only the flags `set` documents are replayed now; a bare `-o` with no option name is dropped instead of dumping the shell-option table. - The wait-for-setup gate picked its language from the runner file, so a batch runner launched from a Git Bash pane got the PowerShell gate while the agent startup command was already POSIX-quoted — `Invoke-Expression` cannot parse `'\''`. The gate now follows the pane; the runner still launches through the ProcessStartInfo launcher, never through bash. --------- Co-authored-by: OrcaWin <293788423+OrcaWin@users.noreply.github.com>
100 lines
4.5 KiB
TypeScript
100 lines
4.5 KiB
TypeScript
import { describe, it, expect } from 'vitest'
|
|
import {
|
|
isShebangLine,
|
|
parseSetupScriptShebang,
|
|
scriptDeclaresPosixShell,
|
|
stripLeadingShebangLine
|
|
} from './setup-script-shebang'
|
|
|
|
describe('scriptDeclaresPosixShell', () => {
|
|
it('accepts the common env and absolute-path forms', () => {
|
|
expect(scriptDeclaresPosixShell('#!/usr/bin/env bash\npnpm install')).toBe(true)
|
|
expect(scriptDeclaresPosixShell('#!/bin/sh -e\npnpm install')).toBe(true)
|
|
expect(scriptDeclaresPosixShell('#!/usr/bin/env -S bash -euo pipefail\npnpm install')).toBe(
|
|
true
|
|
)
|
|
expect(scriptDeclaresPosixShell('#!/bin/zsh')).toBe(true)
|
|
})
|
|
|
|
it('rejects scripts with no interpreter line', () => {
|
|
// Regression: batch-syntax setup scripts must stay on the cmd runner.
|
|
expect(scriptDeclaresPosixShell('copy .env.example .env\nxcopy /E assets dist')).toBe(false)
|
|
expect(scriptDeclaresPosixShell('')).toBe(false)
|
|
expect(scriptDeclaresPosixShell('pnpm install\n#!/usr/bin/env bash')).toBe(false)
|
|
expect(scriptDeclaresPosixShell('# !/usr/bin/env bash\npnpm install')).toBe(false)
|
|
})
|
|
|
|
it('rejects interpreters that are not POSIX shells', () => {
|
|
expect(scriptDeclaresPosixShell('#!/usr/bin/env node\nconsole.log(1)')).toBe(false)
|
|
expect(scriptDeclaresPosixShell('#!/usr/bin/env python3\nprint(1)')).toBe(false)
|
|
})
|
|
|
|
it('tolerates CRLF and Windows-style interpreter paths', () => {
|
|
expect(scriptDeclaresPosixShell('#!/usr/bin/env bash\r\npnpm install')).toBe(true)
|
|
expect(scriptDeclaresPosixShell('#!C:\\tools\\git\\bin\\bash.exe\r\npnpm install')).toBe(true)
|
|
})
|
|
})
|
|
|
|
describe('parseSetupScriptShebang', () => {
|
|
it('keeps the interpreter flags a script declares', () => {
|
|
// Regression: the runner is launched as `bash <path>`, so flags survive only if they are
|
|
// parsed out here and replayed with `set` — otherwise `pipefail` is silently lost.
|
|
expect(parseSetupScriptShebang('#!/usr/bin/env -S bash -euo pipefail\nmake')).toEqual({
|
|
interpreter: 'bash',
|
|
shellOptions: ['-euo', 'pipefail']
|
|
})
|
|
expect(parseSetupScriptShebang('#!/bin/bash -e -x\nmake')).toEqual({
|
|
interpreter: 'bash',
|
|
shellOptions: ['-e', '-x']
|
|
})
|
|
expect(parseSetupScriptShebang('#!/bin/sh\nmake')).toEqual({
|
|
interpreter: 'sh',
|
|
shellOptions: []
|
|
})
|
|
})
|
|
|
|
it('ignores interpreter arguments that `set` cannot apply', () => {
|
|
// Regression: `set` rejects invocation-only flags with exit 2, and the runner's `set -e`
|
|
// turns that into an aborted setup before its first line runs.
|
|
expect(parseSetupScriptShebang('#!/bin/bash --norc\nmake')?.shellOptions).toEqual([])
|
|
expect(parseSetupScriptShebang('#!/bin/bash -l\nmake')?.shellOptions).toEqual([])
|
|
expect(parseSetupScriptShebang('#!/bin/bash -s\nmake')?.shellOptions).toEqual([])
|
|
expect(parseSetupScriptShebang('#!/bin/bash -i\nmake')?.shellOptions).toEqual([])
|
|
// Why: `-r` is accepted by `set` on some shells but silently restricts the rest of setup.
|
|
expect(parseSetupScriptShebang('#!/bin/bash -r\nmake')?.shellOptions).toEqual([])
|
|
expect(parseSetupScriptShebang('#!/bin/bash -ex -l\nmake')?.shellOptions).toEqual(['-ex'])
|
|
// Why: a bare `-o` would print the whole shell-option table into the setup terminal.
|
|
expect(parseSetupScriptShebang('#!/bin/bash -o\nmake')?.shellOptions).toEqual([])
|
|
expect(parseSetupScriptShebang('#!/bin/bash -euo\nmake')?.shellOptions).toEqual([])
|
|
expect(parseSetupScriptShebang('#!/bin/bash +o posix\nmake')?.shellOptions).toEqual([
|
|
'+o',
|
|
'posix'
|
|
])
|
|
})
|
|
|
|
it('returns null without an interpreter line', () => {
|
|
expect(parseSetupScriptShebang('pnpm install')).toBeNull()
|
|
expect(parseSetupScriptShebang('#!/usr/bin/env')).toBeNull()
|
|
})
|
|
})
|
|
|
|
describe('stripLeadingShebangLine', () => {
|
|
it('removes only a leading interpreter line', () => {
|
|
expect(stripLeadingShebangLine('#!/usr/bin/env bash\npnpm install\n')).toBe('pnpm install\n')
|
|
expect(stripLeadingShebangLine('#!/usr/bin/env bash\r\npnpm install')).toBe('pnpm install')
|
|
expect(stripLeadingShebangLine('pnpm install\n#!/usr/bin/env bash')).toBe(
|
|
'pnpm install\n#!/usr/bin/env bash'
|
|
)
|
|
expect(stripLeadingShebangLine('#!/usr/bin/env bash')).toBe('')
|
|
})
|
|
})
|
|
|
|
describe('isShebangLine', () => {
|
|
it('detects interpreter lines regardless of leading whitespace', () => {
|
|
expect(isShebangLine('#!/usr/bin/env bash')).toBe(true)
|
|
expect(isShebangLine(' #!/bin/sh')).toBe(true)
|
|
expect(isShebangLine('#comment')).toBe(false)
|
|
expect(isShebangLine('pnpm install')).toBe(false)
|
|
})
|
|
})
|