agent-relay-orchestrator 0.32.2 → 0.32.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.32.2",
+  "version": "0.32.4",
   "description": "Agent Relay orchestrator — manages agent lifecycle across hosts",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "agent-relay-sdk": "0.2.19"
+    "agent-relay-sdk": "0.2.20"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/git.ts

@@ -0,0 +1,30 @@
+// Low-level git primitives shared by the workspace probe/merge/cleanup helpers.
+// Extracted from workspace-probe.ts so that giant keeps shrinking (epic #291) and the
+// `git -C` invocation lives in one place.
+
+interface GitResult {
+  ok: boolean;
+  stdout: string;
+  stderr: string;
+}
+
+/** Run `git -C cwd <args>` and capture trimmed stdout/stderr; never throws. */
+export function git(args: string[], cwd: string): GitResult {
+  const proc = Bun.spawnSync(["git", "-C", cwd, ...args], {
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  return {
+    ok: proc.exitCode === 0,
+    stdout: proc.stdout.toString().trim(),
+    stderr: proc.stderr.toString().trim(),
+  };
+}
+
+/** Like {@link git} but throws on a non-zero exit, returning stdout on success. */
+export function requireGit(args: string[], cwd: string): string {
+  const result = git(args, cwd);
+  if (!result.ok) throw new Error(result.stderr || `git ${args.join(" ")} failed`);
+  return result.stdout;
+}

package/src/workspace-probe.ts

@@ -5,6 +5,7 @@ import { basename, dirname, isAbsolute, join, relative, resolve } from "node:pat
 import type { WorkspaceDepsProvision, WorkspaceDepsRefreshDir, WorkspaceDepsRefreshResult, WorkspaceDiff, WorkspaceDiffFile, WorkspaceGitState, WorkspaceMergePreview, WorkspaceMergeResult, WorkspaceMetadata, WorkspaceMode, WorkspaceProbe, WorkspaceProbeWorktree, WorkspaceStatus, WorkspaceSymlinkProvision } from "agent-relay-sdk";
 import { errMessage } from "agent-relay-sdk";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
+import { git, requireGit } from "./git";
 
 const MAX_DIFF_PATCH_BYTES = 200_000;
 
@@ -25,31 +26,6 @@ interface WorkspaceResolution {
   workspace: WorkspaceMetadata;
 }
 
-interface GitResult {
-  ok: boolean;
-  stdout: string;
-  stderr: string;
-}
-
-function git(args: string[], cwd: string): GitResult {
-  const proc = Bun.spawnSync(["git", "-C", cwd, ...args], {
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  return {
-    ok: proc.exitCode === 0,
-    stdout: proc.stdout.toString().trim(),
-    stderr: proc.stderr.toString().trim(),
-  };
-}
-
-function requireGit(args: string[], cwd: string): string {
-  const result = git(args, cwd);
-  if (!result.ok) throw new Error(result.stderr || `git ${args.join(" ")} failed`);
-  return result.stdout;
-}
-
 function shortBranch(ref: string | undefined): string | undefined {
   if (!ref || ref === "HEAD") return undefined;
   return ref.startsWith("refs/heads/") ? ref.slice("refs/heads/".length) : ref;
@@ -472,12 +448,34 @@ export function pruneWorktrees(input: { repoRoot?: string }): { repoRoot: string
   return { repoRoot: repo, pruned: true, output: result.stdout.trim() || undefined };
 }
 
+// Repo that actually owns `worktreePath`'s git admin. A CHAINED workspace's recorded
+// repoRoot points at the PARENT worktree (maybe deleted), not the real checkout (#278/#307);
+// every linked worktree shares the main `.git` (--git-common-dir), so derive the owner from
+// the worktree itself, falling back to `fallback` only when it can't be interrogated.
+function owningRepoRoot(worktreePath: string, fallback: string): string {
+  const res = git(["rev-parse", "--git-common-dir"], worktreePath);
+  if (!res.ok || !res.stdout) return fallback;
+  let commonDir = res.stdout;
+  if (!isAbsolute(commonDir)) commonDir = resolve(worktreePath, commonDir);
+  const root = basename(commonDir) === ".git" ? dirname(commonDir) : commonDir; // .git's parent = repo
+  return existsSync(root) ? root : fallback;
+}
+
 export function cleanupWorkspace(workspace: { repoRoot?: string; worktreePath?: string; id?: string; branch?: string; deleteBranch?: boolean; workspacesRoot?: string }): { workspaceId?: string; removed: boolean; worktreePath?: string; branchDeleted?: boolean; containerRemoved?: boolean } {
   if (!workspace.worktreePath) throw new Error("worktreePath required");
   const path = resolve(workspace.worktreePath);
-  const repo = workspace.repoRoot ? resolve(workspace.repoRoot) : path;
+  const recordedRepo = workspace.repoRoot ? resolve(workspace.repoRoot) : path;
+  // Remove via the REAL owning repo, not the recorded (chained/deleted) repoRoot which
+  // would silently no-op and leak the dir while the relay marks it `cleaned` (#307).
+  const repo = owningRepoRoot(path, recordedRepo);
   const result = git(["worktree", "remove", "--force", path], repo);
-  if (!result.ok) throw new Error(result.stderr || `failed to remove workspace ${path}`);
+  // Trust the filesystem, not git's exit code (a remove against the wrong repo "succeeds"
+  // touching nothing). If the dir survives, surface failure so the relay leaves the row
+  // un-cleaned instead of recording a phantom removal (#307).
+  if (existsSync(path)) {
+    git(["worktree", "prune"], repo);
+    throw new Error(result.stderr || `worktree ${path} still present after \`git worktree remove\` (repo ${repo})`);
+  }
   // Once the worktree is gone the agent/... branch is litter — delete it so
   // branches don't accumulate. Best-effort: don't fail cleanup if it can't
   // (e.g. branch already gone, or checked out elsewhere).
@@ -736,9 +734,9 @@ function ghAvailable(): boolean {
  * Returns undefined when there's no PR, no branch, or gh fails —
  * we never invent a merge.
  */
-function prMergedState(cwd: string, branch: string | undefined): { state: "merged" | "open"; url?: string } | undefined {
+function prMergedState(cwd: string, branch: string | undefined): { state: "merged" | "open"; url?: string; sha?: string } | undefined {
   if (!branch) return undefined;
-  const proc = Bun.spawnSync(["gh", "pr", "view", branch, "--json", "state,url"], {
+  const proc = Bun.spawnSync(["gh", "pr", "view", branch, "--json", "state,url,mergeCommit"], {
     cwd,
     stdin: "ignore",
     stdout: "pipe",
@@ -746,9 +744,10 @@ function prMergedState(cwd: string, branch: string | undefined): { state: "merge
   });
   if (proc.exitCode !== 0) return undefined; // no PR for the branch, or gh unavailable/unauthed
   try {
-    const data = JSON.parse(proc.stdout.toString()) as { state?: string; url?: string };
+    const data = JSON.parse(proc.stdout.toString()) as { state?: string; url?: string; mergeCommit?: { oid?: string } | null };
     if (!data.state) return undefined;
-    return { state: data.state === "MERGED" ? "merged" : "open", url: data.url };
+    const sha = data.mergeCommit?.oid;
+    return { state: data.state === "MERGED" ? "merged" : "open", url: data.url, ...(sha ? { sha } : {}) };
   } catch {
     return undefined;
   }
@@ -783,6 +782,20 @@ function worktreeForBranch(repoRoot: string, branch: string): { path: string; di
   return { path: match.path, dirty: status.ok ? status.stdout.length > 0 : true };
 }
 
+// Populate a preview's PR fields from `gh` ground truth; returns whether the PR is merged
+// (#168/#304). One home for the PR-landing rule so the worktree- and repoRoot-based previews
+// can't drift. On a merge it stamps the merge SHA so the relay can finalize a parked pr land.
+function applyPrMergeState(base: WorkspaceMergePreview, cwd: string, branch: string | undefined): boolean {
+  const pr = prMergedState(cwd, branch);
+  if (!pr) return false;
+  base.prState = pr.state;
+  if (pr.url) base.prUrl = pr.url;
+  if (pr.state !== "merged") return false;
+  base.prMerged = true;
+  if (pr.sha) base.prMergeSha = pr.sha;
+  return true;
+}
+
 export function previewBranchMerge(input: {
   repoRoot?: string;
   branch?: string;
@@ -815,16 +828,8 @@ export function previewBranchMerge(input: {
   base.dirtyCount = 0;
 
   let effectiveAhead = gitState.landed ? 0 : (gitState.unmergedAhead ?? gitState.ahead ?? 0);
-  if (effectiveAhead > 0 && input.checkPr && strategy === "pr") {
-    const pr = prMergedState(repoRoot, input.branch);
-    if (pr) {
-      base.prState = pr.state;
-      if (pr.url) base.prUrl = pr.url;
-      if (pr.state === "merged") {
-        base.prMerged = true;
-        effectiveAhead = 0;
-      }
-    }
+  if (input.checkPr && strategy === "pr") {
+    if (applyPrMergeState(base, repoRoot, input.branch)) effectiveAhead = 0;
   }
   if (effectiveAhead === 0) {
     const reason = base.prMerged
@@ -862,19 +867,11 @@ export function previewWorkspaceMerge(input: { worktreePath?: string; baseRef?:
   base.dirtyCount = gitState.dirtyCount;
   if ((gitState.dirtyCount ?? 0) > 0) return { ...base, reason: "worktree has uncommitted changes" };
   let effectiveAhead = gitState.landed ? 0 : (gitState.unmergedAhead ?? gitState.ahead ?? 0);
-  // Local git still thinks there's unmerged work, but a squash-merged PR whose
-  // base has moved on is invisible to it. When the caller opts in (checkPr) and
-  // the strategy targets a PR, ask gh for the truth — a MERGED PR means landed.
-  if (effectiveAhead > 0 && input.checkPr && strategy === "pr" && input.worktreePath) {
-    const pr = prMergedState(resolve(input.worktreePath), gitState.branch);
-    if (pr) {
-      base.prState = pr.state;
-      if (pr.url) base.prUrl = pr.url;
-      if (pr.state === "merged") {
-        base.prMerged = true;
-        effectiveAhead = 0;
-      }
-    }
+  // Ask gh in BOTH cases local git can't see a PR landing: a squash-merge (looks ahead)
+  // and a regular merge-commit (branch becomes an ancestor → ahead=0 no-op). A merged PR
+  // means landed; its SHA lets the relay finalize a parked pr land instead of stalling (#304).
+  if (input.checkPr && strategy === "pr" && input.worktreePath) {
+    if (applyPrMergeState(base, resolve(input.worktreePath), gitState.branch)) effectiveAhead = 0;
   }
   if (effectiveAhead === 0) {
     const reason = base.prMerged