mirror of
https://github.com/stablyai/orca.git
synced 2026-09-22 08:02:28 +00:00
Jinjing
7e76bb3aec
* Fix rebase race by fetching to private ref before rebasing
`git pull --rebase` is vulnerable to concurrent fetches modifying remote-tracking refs during execution. Fetch to a temporary private ref (refs/orca/rebase/*) first, then rebase from that stable ref to avoid the race condition.
* Fix rebase race by fetching to private ref with timeout
Concurrent fetches can interfere with remote-tracking refs between
fetch and rebase. Use a unique private ref and 60-second timeout to
isolate each rebase operation and prevent hangs on stalled remotes.
Extract gitPullRebaseFromBase to a dedicated module.
* fix rebase race by fetching to private ref with timeouts
Concurrent fetches can replace FETCH_HEAD and remote-tracking refs between
fetch and rebase, causing the rebase to fail. Fetch to a temporary private
ref instead, use --no-write-fetch-head when available (Git 2.29+), and
serialize FETCH_HEAD access for older versions. Add process termination
barriers to ensure proper cleanup and extend timeouts for SSH operations.
* Fix rebase race by fetching to both private and tracking refs
Concurrent fetches between source and rebase can replace remote-tracking refs,
causing rebases to use stale bases. Now fetch to both a private ref and the
remote-tracking ref simultaneously, ensuring the tracking ref stays current.
Also improves process termination for WSL guests with process-group tracking,
fixes process-tree termination timeouts on POSIX, and serializes FETCH_HEAD
operations for linked worktrees through their shared Git directory.
* Add WSL setsid --wait probe and barrier termination timeout
Probe for `setsid --wait` support and fall back to unwrapped execution for BusyBox compatibility. Add a deadline for process termination barriers to prevent hanging when tree termination cannot be verified. Update tests for cross-platform compatibility.
* Add wsl-process-group-termination to WSL invocation allowlist
* Serialize per-worktree git mutations to fix rebase race
Introduce operation locking for each worktree to prevent concurrent
mutations (like rebase) from interfering with each other. Ensures
rebasing a linked worktree doesn't affect the source worktree state.
Add SIGKILL fallback if process termination barriers cannot verify
tree termination.
* Serialize pull and fastForward operations per-worktree
- Extract generic git operation lock to reuse locking pattern
- Refactor existing locks to use the generic implementation
- Apply per-worktree serialization to pull and fastForward to prevent races
* Route WSL group termination through runWslProcess
ce743a4fd0 silenced the wsl-invocation boundary guard by appending
wsl-process-group-termination.ts to the allowlist. That fixture only
grows when the scanner learns to see a spawn it was blind to, and only
shrinks for a migration -- this was new code on this branch, so the
entry was the boundary regressing rather than the guard getting honest.
Migrate the kill instead. terminate() now calls runWslProcess with the
script form (`<shell> -c <script> -- <args>`), which keeps the group id
in $1, so the payload is unchanged. The script is plain POSIX, so it
must not pin shell: 'bash'; it calls only builtins and coreutils on the
default PATH and reads no login environment, so loginPath is 'none'.
wrapGuestArgs() is untouched: its argv is spliced into git/runner.ts's
own wsl.exe invocation, which is a long-standing allowlist entry.
The unit test now mocks runWslProcess and asserts the spec shape --
distro, loginPath, the group id in args -- so a regression back to a raw
spawn fails here as well as at the boundary guard.
* Assert cleanup is defined before accessing properties
57 lines
1.8 KiB
TypeScript
57 lines
1.8 KiB
TypeScript
// Why: a stalled remote must fail the rebase fetch, not hang the rebase; client and relay share one bound.
|
|
export const REBASE_SOURCE_FETCH_TIMEOUT_MS = 60_000
|
|
export const REBASE_FROM_BASE_OPERATION_TIMEOUT_MS = REBASE_SOURCE_FETCH_TIMEOUT_MS + 60_000
|
|
// Include the process barrier's 2s grace plus its 10s unverified-tree deadline.
|
|
export const REBASE_FROM_BASE_RPC_TIMEOUT_MS = REBASE_FROM_BASE_OPERATION_TIMEOUT_MS + 15_000
|
|
|
|
export type GitCommandRunner = (args: string[]) => Promise<{ stdout: string }>
|
|
|
|
export type GitRemoteRebaseSource = {
|
|
remoteName: string
|
|
branchName: string
|
|
displayName: string
|
|
}
|
|
|
|
function normalizeBaseRef(baseRef: string): string {
|
|
const trimmed = baseRef.trim()
|
|
if (!trimmed || trimmed.startsWith('-')) {
|
|
throw new Error('Choose a remote base branch to rebase from.')
|
|
}
|
|
if (trimmed.startsWith('refs/remotes/')) {
|
|
return trimmed.slice('refs/remotes/'.length)
|
|
}
|
|
if (trimmed.startsWith('remotes/')) {
|
|
return trimmed.slice('remotes/'.length)
|
|
}
|
|
return trimmed
|
|
}
|
|
|
|
export async function resolveGitRemoteRebaseSource(
|
|
runGit: GitCommandRunner,
|
|
baseRef: string
|
|
): Promise<GitRemoteRebaseSource> {
|
|
const normalizedBaseRef = normalizeBaseRef(baseRef)
|
|
const { stdout } = await runGit(['remote'])
|
|
const remotes = stdout
|
|
.split(/\r?\n/)
|
|
.map((line) => line.trim())
|
|
.filter(Boolean)
|
|
.sort((a, b) => b.length - a.length)
|
|
const remoteName = remotes.find(
|
|
(remote) => normalizedBaseRef !== remote && normalizedBaseRef.startsWith(`${remote}/`)
|
|
)
|
|
|
|
if (!remoteName) {
|
|
throw new Error('Choose a remote base branch to rebase from.')
|
|
}
|
|
|
|
const branchName = normalizedBaseRef.slice(remoteName.length + 1)
|
|
await runGit(['check-ref-format', '--branch', branchName])
|
|
|
|
return {
|
|
remoteName,
|
|
branchName,
|
|
displayName: `${remoteName}/${branchName}`
|
|
}
|
|
}
|