agent-relay-orchestrator 0.38.0 → 0.39.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.38.0",
+  "version": "0.39.0",
   "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.23"
+    "agent-relay-sdk": "0.2.24"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/control.ts

@@ -4,6 +4,7 @@ import type { ManagedAgentReport, RelayClient, RelayCommand } from "./relay";
 import { handleSelfUpgrade } from "./self-upgrade";
 import { spawnAgent, stopSession, type SpawnOptions } from "./spawn";
 import { cleanupWorkspace, mergeWorkspace, pruneWorktrees, reconcileWorkspace, refreshWorkspaceDeps, workspacesRoot } from "./workspace-probe";
+import { armWorkspacePrAutoMerge } from "./workspace-pr";
 
 interface ControlHandler {
   handleCommand(command: RelayCommand): Promise<boolean>;
@@ -123,6 +124,17 @@ export function createControlHandler(
           autoMerge: command.params.autoMerge === "on-green" || command.params.autoMerge === "on-approval" || command.params.autoMerge === "manual" ? command.params.autoMerge : undefined,
         });
         await relay.updateCommand(command.id, "succeeded", result as unknown as Record<string, unknown>);
+      } else if (command.type === "workspace.pr-arm-auto-merge") {
+        const rawPrNumber = command.params.prNumber;
+        const result = armWorkspacePrAutoMerge({
+          id: typeof command.params.workspaceId === "string" ? command.params.workspaceId : undefined,
+          repoRoot: typeof command.params.repoRoot === "string" ? command.params.repoRoot : undefined,
+          worktreePath: typeof command.params.worktreePath === "string" ? command.params.worktreePath : undefined,
+          branch: typeof command.params.branch === "string" ? command.params.branch : undefined,
+          prNumber: typeof rawPrNumber === "number" && Number.isSafeInteger(rawPrNumber) ? rawPrNumber : undefined,
+          prUrl: typeof command.params.prUrl === "string" ? command.params.prUrl : undefined,
+        });
+        await relay.updateCommand(command.id, result.autoMergeArmed ? "succeeded" : "failed", result as unknown as Record<string, unknown>, result.error);
       } else if (command.type === "workspace.deps-refresh") {
         const result = refreshWorkspaceDeps(
           typeof command.params.repoRoot === "string" ? command.params.repoRoot : "",

package/src/spawn.ts

@@ -6,7 +6,7 @@ import type { OrchestratorConfig } from "./config";
 import type { ManagedAgentReport, ManagedSessionExitDiagnostics } from "./relay";
 import { resolveSpawnWorkspace, workspacesRoot } from "./workspace-probe";
 import type { WorkspaceMetadata, WorkspaceMode } from "agent-relay-sdk";
-import { errMessage } from "agent-relay-sdk";
+import { errMessage, extractClaudeModelUnavailableMessage } from "agent-relay-sdk";
 import { isPidAlive, parseProcStateIsZombie } from "agent-relay-sdk/process-utils";
 import { shellEscape } from "agent-relay-sdk/shell-utils";
 import { tmuxCommand, tmuxHasSession } from "agent-relay-sdk/tmux-utils";
@@ -890,6 +890,10 @@ function logFileDiagnostics(logFile: string): Pick<ManagedSessionExitDiagnostics
 }
 
 function describeSessionExit(record: SessionRecord, diagnostics: Omit<ManagedSessionExitDiagnostics, "lastError">): string {
+  if (record.provider === "claude") {
+    const modelUnavailable = extractClaudeModelUnavailableMessage((diagnostics.logTail ?? []).join("\n"));
+    if (modelUnavailable) return modelUnavailable;
+  }
   const seconds = Math.max(0, Math.round(diagnostics.runtimeMs / 1000));
   const parts = [`managed ${record.provider} session ${record.name} exited after ${seconds}s`];
   if (diagnostics.systemd?.unavailable) {
@@ -1104,7 +1108,7 @@ export function captureSessionMirror(
   // The mirror log lives in the same directory as the provider log (both written
   // by the same user on this host). Derive from the record's logFile when known so
   // it tracks any per-session log relocation.
-  const logDir = record?.logFile ? dirname(record.logFile) : LOG_DIR;
+  const logDir = record?.logFile ? dirname(record.logFile) : process.env.AGENT_RELAY_LOG_DIR || LOG_DIR;
   const mirrorPath = join(logDir, `session-mirror-${safeMirrorLogName(agentId)}.log`);
   let content: string;
   try {

package/src/workspace-pr.ts

@@ -0,0 +1,85 @@
+import { resolve } from "node:path";
+
+type PrReviewDecision = "APPROVED" | "CHANGES_REQUESTED" | "REVIEW_REQUIRED";
+
+interface PullRequestState {
+  state: "merged" | "open";
+  url?: string;
+  sha?: string;
+  number?: number;
+  reviewDecision?: PrReviewDecision;
+  statusCheckRollup?: unknown[];
+}
+
+function prReviewDecision(value: unknown): PrReviewDecision | undefined {
+  return value === "APPROVED" || value === "CHANGES_REQUESTED" || value === "REVIEW_REQUIRED" ? value : undefined;
+}
+
+export function prMergedState(cwd: string, branch: string | undefined): PullRequestState | undefined {
+  if (!branch) return undefined;
+  const proc = Bun.spawnSync(["gh", "pr", "view", branch, "--json", "state,url,mergeCommit,number,reviewDecision,statusCheckRollup"], {
+    cwd,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: process.env,
+  });
+  if (proc.exitCode !== 0) return undefined;
+  try {
+    const data = JSON.parse(proc.stdout.toString()) as {
+      state?: string;
+      url?: string;
+      mergeCommit?: { oid?: string } | null;
+      number?: number;
+      reviewDecision?: unknown;
+      statusCheckRollup?: unknown;
+    };
+    if (!data.state) return undefined;
+    const sha = data.mergeCommit?.oid;
+    const number = typeof data.number === "number" && Number.isSafeInteger(data.number) ? data.number : undefined;
+    const reviewDecision = prReviewDecision(data.reviewDecision);
+    const statusCheckRollup = Array.isArray(data.statusCheckRollup) ? data.statusCheckRollup : undefined;
+    return {
+      state: data.state === "MERGED" ? "merged" : "open",
+      url: data.url,
+      ...(sha ? { sha } : {}),
+      ...(number ? { number } : {}),
+      ...(reviewDecision ? { reviewDecision } : {}),
+      ...(statusCheckRollup ? { statusCheckRollup } : {}),
+    };
+  } catch {
+    return undefined;
+  }
+}
+
+export function armWorkspacePrAutoMerge(input: {
+  id?: string;
+  repoRoot?: string;
+  worktreePath?: string;
+  branch?: string;
+  prNumber?: number;
+  prUrl?: string;
+}): { workspaceId?: string; status: "merge_planned"; autoMergeArmed: boolean; prNumber?: number; prUrl?: string; error?: string } {
+  const cwd = input.worktreePath ? resolve(input.worktreePath) : input.repoRoot ? resolve(input.repoRoot) : undefined;
+  if (!cwd) return { workspaceId: input.id, status: "merge_planned", autoMergeArmed: false, error: "worktreePath or repoRoot required" };
+  const target = input.prNumber ? String(input.prNumber) : input.prUrl ?? input.branch;
+  if (!target) return { workspaceId: input.id, status: "merge_planned", autoMergeArmed: false, error: "prNumber, prUrl, or branch required" };
+  const proc = Bun.spawnSync(["gh", "pr", "merge", target, "--auto", "--merge"], {
+    cwd,
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "pipe",
+    env: process.env,
+  });
+  if (proc.exitCode !== 0) {
+    return {
+      workspaceId: input.id,
+      status: "merge_planned",
+      autoMergeArmed: false,
+      prNumber: input.prNumber,
+      prUrl: input.prUrl,
+      error: proc.stderr.toString().trim() || proc.stdout.toString().trim() || "gh pr merge failed",
+    };
+  }
+  return { workspaceId: input.id, status: "merge_planned", autoMergeArmed: true, prNumber: input.prNumber, prUrl: input.prUrl };
+}

package/src/workspace-probe.ts

@@ -6,6 +6,7 @@ import type { WorkspaceDepsProvision, WorkspaceDepsRefreshDir, WorkspaceDepsRefr
 import { errMessage } from "agent-relay-sdk";
 import { sanitizeFsName } from "agent-relay-sdk/fs-name";
 import { git, requireGit } from "./git";
+import { prMergedState } from "./workspace-pr";
 
 const MAX_DIFF_PATCH_BYTES = 200_000;
 
@@ -747,25 +748,6 @@ 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; sha?: string } | undefined {
-  if (!branch) return undefined;
-  const proc = Bun.spawnSync(["gh", "pr", "view", branch, "--json", "state,url,mergeCommit"], {
-    cwd,
-    stdin: "ignore",
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-  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; mergeCommit?: { oid?: string } | null };
-    if (!data.state) return undefined;
-    const sha = data.mergeCommit?.oid;
-    return { state: data.state === "MERGED" ? "merged" : "open", url: data.url, ...(sha ? { sha } : {}) };
-  } catch {
-    return undefined;
-  }
-}
-
 /**
  * Predict whether merging the branch's commits into base would conflict, using
  * git's three-way merge-tree (no working-tree changes). Exit 0 = clean, exit 1
@@ -803,6 +785,9 @@ function applyPrMergeState(base: WorkspaceMergePreview, cwd: string, branch: str
   if (!pr) return false;
   base.prState = pr.state;
   if (pr.url) base.prUrl = pr.url;
+  if (pr.number) base.prNumber = pr.number;
+  if (pr.reviewDecision) base.reviewDecision = pr.reviewDecision;
+  if (pr.statusCheckRollup) base.statusCheckRollup = pr.statusCheckRollup;
   if (pr.state !== "merged") return false;
   base.prMerged = true;
   if (pr.sha) base.prMergeSha = pr.sha;