agent-relay-orchestrator 0.26.0 → 0.27.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.26.0",
+  "version": "0.27.1",
   "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.15"
+    "agent-relay-sdk": "0.2.16"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/api.ts

@@ -9,7 +9,7 @@ import type { RelayClient } from "./relay";
 import { captureSession, captureSessionMirror, captureTerminal, createTerminalGuest, listSessions, sendTerminalInput, resizeTerminal, stopTerminalGuest, validateTerminalInputData, validateTerminalResize } from "./spawn";
 import { acquireTerminalStream, type TerminalStreamHandle, type TerminalStreamSubscriber } from "./terminal-stream";
 import { VERSION, runtimeMetadata } from "./version";
-import { previewWorkspaceMerge, probeWorkspace, workspaceDiff, workspaceGitState } from "./workspace-probe";
+import { previewBranchMerge, previewWorkspaceMerge, probeWorkspace, workspaceDiff, workspaceGitState } from "./workspace-probe";
 
 interface DirectoryEntry {
   name: string;
@@ -517,6 +517,26 @@ export function startApiServer(config: OrchestratorConfig, probeCache: ProviderP
         }
       }
 
+      if (req.method === "GET" && url.pathname === "/api/workspace/branch-merge-preview") {
+        if (!authorized(req, config)) return error("unauthorized", 401);
+        try {
+          const { target } = resolveInsideBase(url.searchParams.get("repoRoot") || undefined, config.baseDir);
+          const strategy = url.searchParams.get("strategy");
+          const preview = previewBranchMerge({
+            repoRoot: target,
+            branch: url.searchParams.get("branch") || undefined,
+            baseRef: url.searchParams.get("baseRef") || undefined,
+            baseSha: url.searchParams.get("baseSha") || undefined,
+            strategy: strategy === "pr" || strategy === "rebase-ff" || strategy === "auto" ? strategy : undefined,
+            checkPr: url.searchParams.get("checkPr") === "1",
+          });
+          if (preview === null) return error("branch not found", 404);
+          return json(preview);
+        } catch (e) {
+          return error((e as Error).message);
+        }
+      }
+
       if (req.method === "GET" && url.pathname === "/api/providers") {
         return (async () => {
           const snapshot = await probeCache.getSnapshot(url.searchParams.get("refresh") === "1");

package/src/workspace-probe.ts

@@ -515,38 +515,38 @@ export function workspaceGitState(input: { worktreePath?: string; baseRef?: stri
     }
   }
 
-  // Resolve a base to diff against: prefer the named branch (gives real behind
-  // counts), fall back to the fork SHA (behind is then always 0, ahead is the
-  // agent's new commits — still the signal we care about for cleanup).
-  const base = resolveBaseRef(path, input.baseRef, input.baseSha);
-  if (base) {
-    state.baseRef = base;
-    const counts = git(["rev-list", "--left-right", "--count", `${base}...HEAD`], path);
-    if (counts.ok && counts.stdout) {
-      const [behind, ahead] = counts.stdout.split(/\s+/).map((n) => Number(n));
-      if (Number.isFinite(behind)) state.behind = behind;
-      if (Number.isFinite(ahead)) state.ahead = ahead;
-    }
-    if ((state.ahead ?? 0) > 0) {
-      // A squash or cherry-pick merge re-creates the work as a NEW commit on
-      // base, so the branch tip is never an ancestor and raw `ahead` stays
-      // positive even though the content has already landed. Discount that:
-      // compare against the base branch's upstream when it has one (squash PRs
-      // land on the remote), treat an identical tree as fully landed (covers a
-      // multi-commit squash), else count only commits whose patch isn't already
-      // present in base (git cherry '+'). Staleness of the compare ref can only
-      // under-count landings, never invent one — so `landed` is safe to act on.
-      const cherryBase = upstreamRef(path, base) ?? base;
-      if (git(["diff", "--quiet", cherryBase, "HEAD"], path).ok) {
-        state.unmergedAhead = 0;
-      } else {
-        const cherry = git(["cherry", cherryBase, "HEAD"], path);
-        if (cherry.ok) {
-          state.unmergedAhead = cherry.stdout ? cherry.stdout.split("\n").filter((line) => line.startsWith("+")).length : 0;
-        }
+  return populateMergeState(path, "HEAD", state, input.baseRef, input.baseSha);
+}
+
+function populateMergeState(cwd: string, targetRef: string, state: WorkspaceGitState, baseRef?: string, baseSha?: string): WorkspaceGitState {
+  const base = resolveBaseRef(cwd, baseRef, baseSha);
+  if (!base) return state;
+  state.baseRef = base;
+  const counts = git(["rev-list", "--left-right", "--count", `${base}...${targetRef}`], cwd);
+  if (counts.ok && counts.stdout) {
+    const [behind, ahead] = counts.stdout.split(/\s+/).map((n) => Number(n));
+    if (Number.isFinite(behind)) state.behind = behind;
+    if (Number.isFinite(ahead)) state.ahead = ahead;
+  }
+  if ((state.ahead ?? 0) > 0) {
+    // A squash or cherry-pick merge re-creates the work as a NEW commit on
+    // base, so the branch tip is never an ancestor and raw `ahead` stays
+    // positive even though the content has already landed. Discount that:
+    // compare against the base branch's upstream when it has one (squash PRs
+    // land on the remote), treat an identical tree as fully landed (covers a
+    // multi-commit squash), else count only commits whose patch isn't already
+    // present in base (git cherry '+'). Staleness of the compare ref can only
+    // under-count landings, never invent one — so `landed` is safe to act on.
+    const cherryBase = upstreamRef(cwd, base) ?? base;
+    if (git(["diff", "--quiet", cherryBase, targetRef], cwd).ok) {
+      state.unmergedAhead = 0;
+    } else {
+      const cherry = git(["cherry", cherryBase, targetRef], cwd);
+      if (cherry.ok) {
+        state.unmergedAhead = cherry.stdout ? cherry.stdout.split("\n").filter((line) => line.startsWith("+")).length : 0;
       }
-      if (state.unmergedAhead === 0) state.landed = true;
     }
+    if (state.unmergedAhead === 0) state.landed = true;
   }
 
   return state;
@@ -569,6 +569,14 @@ function resolveBaseRef(worktreePath: string, baseRef?: string, baseSha?: string
   return undefined;
 }
 
+function resolveBranchRef(repoRoot: string, branch?: string): string | undefined {
+  if (!branch) return undefined;
+  for (const candidate of [branch, `refs/heads/${branch}`]) {
+    if (git(["rev-parse", "--verify", "--quiet", `${candidate}^{commit}`], repoRoot).ok) return candidate;
+  }
+  return undefined;
+}
+
 /**
  * Exit-time decision for an orphaned worktree (owner agent disappeared). Probe
  * the worktree and either remove it (genuinely empty — clean tree, no commits
@@ -688,19 +696,18 @@ function ghAvailable(): boolean {
 }
 
 /**
- * Ground-truth merge state for the branch checked out at `worktreePath`, via gh.
+ * Ground-truth merge state for `branch`, via gh.
  * This is the only reliable signal once a PR is squash-merged AND base has moved
  * on: the squash re-creates the work as one new commit (patch ids no longer
  * match, so `git cherry` can't see it) and the trees diverge (so tree-equality
  * can't either), leaving local git convinced the branch is still unmerged.
- * Returns undefined when there's no PR, no detached/unknown branch, or gh fails —
+ * Returns undefined when there's no PR, no branch, or gh fails —
  * we never invent a merge.
  */
-function prMergedState(worktreePath: string): { state: "merged" | "open"; url?: string } | undefined {
-  const branch = git(["rev-parse", "--abbrev-ref", "HEAD"], worktreePath);
-  if (!branch.ok || !branch.stdout || branch.stdout === "HEAD") return undefined;
-  const proc = Bun.spawnSync(["gh", "pr", "view", branch.stdout, "--json", "state,url"], {
-    cwd: worktreePath,
+function prMergedState(cwd: string, branch: string | undefined): { state: "merged" | "open"; url?: string } | undefined {
+  if (!branch) return undefined;
+  const proc = Bun.spawnSync(["gh", "pr", "view", branch, "--json", "state,url"], {
+    cwd,
     stdin: "ignore",
     stdout: "pipe",
     stderr: "pipe",
@@ -744,6 +751,60 @@ function worktreeForBranch(repoRoot: string, branch: string): { path: string; di
   return { path: match.path, dirty: status.ok ? status.stdout.length > 0 : true };
 }
 
+export function previewBranchMerge(input: {
+  repoRoot?: string;
+  branch?: string;
+  baseRef?: string;
+  baseSha?: string;
+  strategy?: "pr" | "rebase-ff" | "auto";
+  checkPr?: boolean;
+}): WorkspaceMergePreview | null {
+  if (!input.repoRoot) return { strategy: "rebase-ff", error: "repoRoot required" };
+  if (!input.branch) return { strategy: "rebase-ff", error: "branch required" };
+  const repoRoot = resolve(input.repoRoot);
+  if (!existsSync(repoRoot)) return { strategy: "rebase-ff", error: `repoRoot does not exist: ${repoRoot}` };
+
+  const remote = hasOriginRemote(repoRoot);
+  const gh = ghAvailable();
+  const baseBranch = baseBranchName(repoRoot, input.baseRef);
+  const strategy: "pr" | "rebase-ff" = input.strategy === "pr" || input.strategy === "rebase-ff"
+    ? input.strategy
+    : remote && gh && baseBranch ? "pr" : "rebase-ff";
+  const branchRef = resolveBranchRef(repoRoot, input.branch);
+  if (!branchRef) return null;
+
+  const gitState = populateMergeState(repoRoot, branchRef, { dirty: false, dirtyCount: 0, branch: input.branch }, input.baseRef, input.baseSha);
+  const base: WorkspaceMergePreview = { strategy, hasRemote: remote, ghAvailable: gh, baseRef: baseBranch ?? gitState.baseRef };
+  if (!gitState.baseRef) return { ...base, error: "base ref unavailable" };
+  base.ahead = gitState.ahead;
+  base.unmergedAhead = gitState.unmergedAhead;
+  base.landed = gitState.landed;
+  base.behind = gitState.behind;
+  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 (effectiveAhead === 0) {
+    const reason = base.prMerged
+      ? "PR merged on remote"
+      : gitState.landed
+        ? "already merged into base (squash/cherry-pick)"
+        : "no commits to merge";
+    return { ...base, reason, noop: true };
+  }
+  return base;
+}
+
 /**
  * Read-only pre-flight for integrating a workspace's work. Reports the strategy
  * `auto` would pick plus whether the merge is clean, would conflict, or is a
@@ -773,7 +834,7 @@ export function previewWorkspaceMerge(input: { worktreePath?: string; baseRef?:
   // 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));
+    const pr = prMergedState(resolve(input.worktreePath), gitState.branch);
     if (pr) {
       base.prState = pr.state;
       if (pr.url) base.prUrl = pr.url;