agent-relay-orchestrator 0.11.3 → 0.11.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.11.3",
+  "version": "0.11.5",
   "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.2"
+    "agent-relay-sdk": "0.2.4"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/control.ts

@@ -2,7 +2,7 @@ import type { OrchestratorConfig } from "./config";
 import type { ManagedAgentReport, RelayClient, RelayCommand } from "./relay";
 import { handleSelfUpgrade } from "./self-upgrade";
 import { spawnAgent, stopSession, type SpawnOptions } from "./spawn";
-import { cleanupWorkspace, mergeWorkspace, reconcileWorkspace } from "./workspace-probe";
+import { cleanupWorkspace, mergeWorkspace, pruneWorktrees, reconcileWorkspace } from "./workspace-probe";
 
 interface ControlHandler {
   handleCommand(command: RelayCommand): Promise<boolean>;
@@ -103,6 +103,11 @@ export function createControlHandler(
           prBody: typeof command.params.prBody === "string" ? command.params.prBody : undefined,
         });
         await relay.updateCommand(command.id, "succeeded", result as unknown as Record<string, unknown>);
+      } else if (command.type === "workspace.prune") {
+        const result = pruneWorktrees({
+          repoRoot: typeof command.params.repoRoot === "string" ? command.params.repoRoot : undefined,
+        });
+        await relay.updateCommand(command.id, "succeeded", result);
       } else if (command.type === "orchestrator.upgrade") {
         // Install + restart ourselves. Intentionally NOT marked "succeeded": the
         // relay settles it by reconciling the version we report after we restart,
@@ -163,10 +168,10 @@ export function spawnOptionsFromControl(ctrl: Record<string, any>, config: Orche
     profile: typeof ctrl.profile === "string" ? ctrl.profile : undefined,
     workspaceMode: workspaceMode(ctrl.workspaceMode),
     agentProfile: isRecord(ctrl.agentProfile) ? ctrl.agentProfile : undefined,
-    label: ctrl.label,
+    label: typeof ctrl.label === "string" ? ctrl.label : undefined,
     agentId: typeof ctrl.agentId === "string" ? ctrl.agentId : undefined,
-    approvalMode: ctrl.approvalMode || "guarded",
-    prompt: ctrl.prompt,
+    approvalMode: typeof ctrl.approvalMode === "string" ? ctrl.approvalMode : "guarded",
+    prompt: typeof ctrl.prompt === "string" ? ctrl.prompt : undefined,
     systemPromptAppend: typeof ctrl.systemPromptAppend === "string" ? ctrl.systemPromptAppend : undefined,
     tags: stringArray(ctrl.tags),
     capabilities: stringArray(ctrl.capabilities),
@@ -183,6 +188,7 @@ export function spawnOptionsFromRestartSource(restartSource: Record<string, any>
   return {
     provider: restartSource.provider === "codex" ? "codex" : "claude",
     cwd: typeof restartSource.cwd === "string" ? restartSource.cwd : config.baseDir,
+    rig: typeof restartSource.rig === "string" ? restartSource.rig : undefined,
     model: modelFromControl(restartSource),
     effort: typeof restartSource.effort === "string" ? restartSource.effort : undefined,
     profile: typeof restartSource.profile === "string" ? restartSource.profile : undefined,

package/src/index.ts

@@ -17,12 +17,19 @@ if (args[0] === "init") {
   process.exit(0);
 }
 
+if (args[0] === "--version" || args[0] === "-v") {
+  const { VERSION } = await import("./version");
+  console.log(VERSION);
+  process.exit(0);
+}
+
 if (args[0] === "--help" || args[0] === "-h") {
   console.log(`agent-relay-orchestrator — manage agent lifecycle across hosts
 
 Usage:
-  agent-relay-orchestrator          Start the orchestrator daemon
-  agent-relay-orchestrator init     Create default config file
+  agent-relay-orchestrator              Start the orchestrator daemon
+  agent-relay-orchestrator init         Create default config file
+  agent-relay-orchestrator --version    Print version and exit
 
 Environment:
   AGENT_RELAY_URL                   Relay server URL (default: http://localhost:4850)

package/src/self-upgrade.ts

@@ -1,8 +1,7 @@
-import { existsSync } from "node:fs";
 import { join } from "node:path";
 import type { OrchestratorConfig } from "./config";
 import type { RelayClient, RelayCommand } from "./relay";
-import { detectSelfSupervision } from "./self-supervision";
+import { detectSelfSupervision, type SelfSupervision } from "./self-supervision";
 
 const VALID_PROVIDERS = new Set(["auto", "all", "codex", "claude", "orchestrator"]);
 const SEMVER_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
@@ -36,7 +35,6 @@ export interface SelfUpgradePlan {
   providers: string[];
   unit: string;
   runtimePrefix?: string;
-  binary: string;
   installCmd: string[];
   restartCmd: string[];
   /** restart runs decoupled from this process's cgroup (transient unit) */
@@ -63,16 +61,7 @@ export function planSelfUpgrade(
     throw new Error("orchestrator is not under systemd or launchd; remote self-upgrade requires a managed service");
   }
   const unit = supervision.selfUnit;
-  const binary = resolveBinary(supervision.runtimePrefix);
-
-  const installCmd = [
-    binary, "upgrade",
-    "--version", targetVersion,
-    "--providers", providers.join(","),
-    "--no-restart",
-    "--yes",
-  ];
-  if (supervision.runtimePrefix) installCmd.push("--runtime-prefix", supervision.runtimePrefix);
+  const installCmd = buildInstallCommand(targetVersion, providers, supervision, runner);
 
   let restartDetached: boolean;
   let restartCmd: string[];
@@ -93,7 +82,7 @@ export function planSelfUpgrade(
       : ["setsid", "systemctl", "--user", "restart", unit];
   }
 
-  return { targetVersion, providers, unit, runtimePrefix: supervision.runtimePrefix, binary, installCmd, restartCmd, restartDetached };
+  return { targetVersion, providers, unit, runtimePrefix: supervision.runtimePrefix, installCmd, restartCmd, restartDetached };
 }
 
 /**
@@ -145,10 +134,56 @@ function normalizeProviders(value: unknown): string[] {
   return [...new Set(providers)];
 }
 
-function resolveBinary(runtimePrefix?: string): string {
-  if (runtimePrefix) {
-    const local = join(runtimePrefix, "node_modules", ".bin", "agent-relay");
-    if (existsSync(local)) return local;
+function buildInstallCommand(
+  targetVersion: string,
+  providers: string[],
+  supervision: SelfSupervision,
+  runner: SelfUpgradeRunner,
+): string[] {
+  if (supervision.runtimePrefix) {
+    if (!runner.commandExists("npm")) {
+      throw new Error("npm is required for runtime-prefix self-upgrade");
+    }
+    return [
+      "npm",
+      "install",
+      "--prefix",
+      supervision.runtimePrefix,
+      ...packagesForProviders(targetVersion, providers),
+    ];
+  }
+
+  if (runner.commandExists("agent-relay")) {
+    return [
+      "agent-relay", "upgrade",
+      "--version", targetVersion,
+      "--providers", providers.join(","),
+      "--no-restart",
+      "--yes",
+    ];
+  }
+
+  throw new Error("agent-relay CLI is not available and no runtime prefix was detected; self-upgrade cannot install packages");
+}
+
+function packagesForProviders(targetVersion: string, providers: string[]): string[] {
+  const selected = new Set(providers);
+  const packages = new Set<string>();
+  const includeAll = selected.has("all");
+  const includeAuto = selected.has("auto");
+
+  if (includeAll || includeAuto || selected.has("orchestrator")) {
+    packages.add("agent-relay-orchestrator");
   }
-  return "agent-relay";
+  if (includeAll || selected.has("codex")) {
+    packages.add("agent-relay-runner");
+    packages.add("agent-relay-codex");
+  }
+  if (includeAll || selected.has("claude")) {
+    packages.add("agent-relay-runner");
+    packages.add("agent-relay-plugin");
+  }
+
+  if (packages.size === 0) packages.add("agent-relay-orchestrator");
+  return [...packages].map((pkg) => `${pkg}@${targetVersion}`);
 }

package/src/version.ts

@@ -21,6 +21,7 @@ export const CONTRACTS = {
 export const RUNTIME_CAPABILITIES = {
   directoryBrowse: true,
   relayCommandBus: true,
+  selfUpgrade: true,
   authenticatedLogProxy: true,
   artifactProxy: true,
   managedAgentReports: true,

package/src/workspace-probe.ts

@@ -1,8 +1,8 @@
-import { existsSync, mkdirSync, statSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readdirSync, statSync, symlinkSync, type Dirent } from "node:fs";
 import { createHash } from "node:crypto";
 import { homedir } from "node:os";
 import { basename, join, resolve } from "node:path";
-import type { WorkspaceDiff, WorkspaceDiffFile, WorkspaceGitState, WorkspaceMergePreview, WorkspaceMergeResult, WorkspaceMetadata, WorkspaceMode, WorkspaceProbe, WorkspaceProbeWorktree, WorkspaceStatus } from "agent-relay-sdk";
+import type { WorkspaceDepsProvision, WorkspaceDiff, WorkspaceDiffFile, WorkspaceGitState, WorkspaceMergePreview, WorkspaceMergeResult, WorkspaceMetadata, WorkspaceMode, WorkspaceProbe, WorkspaceProbeWorktree, WorkspaceStatus } from "agent-relay-sdk";
 
 const MAX_DIFF_PATCH_BYTES = 200_000;
 
@@ -129,6 +129,11 @@ export async function resolveSpawnWorkspace(input: WorkspaceResolutionInput): Pr
   mkdirSync(join(worktreePath, ".."), { recursive: true });
   requireGit(["worktree", "add", "-b", branch, worktreePath, baseSha], repoRoot);
 
+  // A fresh worktree has no node_modules (git worktrees don't share
+  // gitignored/untracked files). Provision deps before handing cwd to the
+  // runner so the agent can typecheck/test/build without manual setup (#159).
+  const deps = provisionWorkspaceDeps(repoRoot, worktreePath);
+
   return {
     cwd: worktreePath,
     workspace: {
@@ -142,11 +147,147 @@ export async function resolveSpawnWorkspace(input: WorkspaceResolutionInput): Pr
       baseRef: probe.branch,
       baseSha,
       status: "active",
+      deps,
       probe,
     },
   };
 }
 
+const NODE_MODULES_SCAN_DEPTH = 2;
+
+const LOCKFILES: Array<{ file: string; pm: string; install: string[] }> = [
+  { file: "bun.lockb", pm: "bun", install: ["bun", "install"] },
+  { file: "bun.lock", pm: "bun", install: ["bun", "install"] },
+  { file: "pnpm-lock.yaml", pm: "pnpm", install: ["pnpm", "install"] },
+  { file: "package-lock.json", pm: "npm", install: ["npm", "install"] },
+  { file: "yarn.lock", pm: "yarn", install: ["yarn", "install"] },
+];
+
+function pathExists(p: string): boolean {
+  try {
+    lstatSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Depth-limited walk collecting relative dirs (from root) matching `match`.
+ * Never descends into node_modules or dot-dirs (no point, and avoids walking
+ * into sibling worktrees under .agent-relay/).
+ */
+function scanProjectDirs(root: string, depth: number, match: (dir: string) => boolean): string[] {
+  const found: string[] = [];
+  const walk = (dir: string, rel: string, remaining: number): void => {
+    if (match(dir)) found.push(rel);
+    if (remaining <= 0) return;
+    let entries: Dirent[];
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      if (entry.name === "node_modules" || entry.name.startsWith(".")) continue;
+      walk(join(dir, entry.name), rel ? join(rel, entry.name) : entry.name, remaining - 1);
+    }
+  };
+  walk(root, "", depth);
+  return found;
+}
+
+function detectPackageManager(dir: string): { pm: string; install: string[] } | undefined {
+  for (const lock of LOCKFILES) {
+    if (existsSync(join(dir, lock.file))) return { pm: lock.pm, install: lock.install };
+  }
+  return undefined;
+}
+
+/** Symlink the source checkout's node_modules dirs into the worktree. Fast and
+ * exact (matches the deps the source actually runs with). Best-effort per dir. */
+function symlinkNodeModules(repoRoot: string, worktreePath: string): string[] {
+  const dirs = scanProjectDirs(repoRoot, NODE_MODULES_SCAN_DEPTH, (dir) => existsSync(join(dir, "node_modules")));
+  const linked: string[] = [];
+  for (const rel of dirs) {
+    const source = join(repoRoot, rel, "node_modules");
+    const targetParent = join(worktreePath, rel);
+    const target = join(targetParent, "node_modules");
+    if (pathExists(target)) continue;
+    try {
+      mkdirSync(targetParent, { recursive: true });
+      symlinkSync(source, target, "dir");
+      linked.push(rel || ".");
+    } catch {
+      // best-effort: a single failed link shouldn't block the spawn
+    }
+  }
+  return linked;
+}
+
+/** Run a package install in each dir that owns a lockfile. Root install covers
+ * the package manager's workspace members; standalone sub-projects with their
+ * own lockfile (e.g. dashboard) get a separate install. */
+function installNodeModules(worktreePath: string): { installed: string[]; packageManager?: string; error?: string } {
+  const dirs = scanProjectDirs(worktreePath, NODE_MODULES_SCAN_DEPTH, (dir) => detectPackageManager(dir) !== undefined);
+  const installed: string[] = [];
+  let packageManager: string | undefined;
+  let error: string | undefined;
+  for (const rel of dirs) {
+    const dir = join(worktreePath, rel);
+    const pm = detectPackageManager(dir);
+    if (!pm) continue;
+    packageManager = pm.pm;
+    const proc = Bun.spawnSync(pm.install, { cwd: dir, stdin: "ignore", stdout: "ignore", stderr: "pipe", env: process.env });
+    if (proc.exitCode === 0) {
+      installed.push(rel || ".");
+    } else {
+      const detail = `${rel || "."}: ${proc.stderr.toString().trim().slice(0, 200)}`;
+      error = error ? `${error}; ${detail}` : detail;
+    }
+  }
+  return { installed, packageManager, error };
+}
+
+/**
+ * Provision node_modules into a freshly created isolated worktree (#159).
+ * Default: symlink the source checkout's node_modules (instant, matches what
+ * the source runs with). Falls back to a fresh install when the source has no
+ * node_modules to borrow. Set AGENT_RELAY_WORKSPACE_DEPS=install to always
+ * install (full isolation, no shared cache), or =none to skip entirely.
+ * Never throws — provisioning failure must not block the spawn.
+ */
+export function provisionWorkspaceDeps(repoRoot: string, worktreePath: string): WorkspaceDepsProvision {
+  const requested = (process.env.AGENT_RELAY_WORKSPACE_DEPS || "symlink").toLowerCase();
+  if (requested === "none") return { mode: "none" };
+
+  try {
+    if (requested !== "install") {
+      const linked = symlinkNodeModules(repoRoot, worktreePath);
+      if (linked.length > 0) return { mode: "symlink", linked };
+      // Source has no installed deps to borrow — install fresh instead.
+    }
+    const result = installNodeModules(worktreePath);
+    if (result.installed.length === 0 && !result.error) return { mode: "none" };
+    return {
+      mode: "install",
+      installed: result.installed,
+      ...(result.packageManager ? { packageManager: result.packageManager } : {}),
+      ...(result.error ? { error: result.error } : {}),
+    };
+  } catch (error) {
+    return { mode: "none", error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export function pruneWorktrees(input: { repoRoot?: string }): { repoRoot: string; pruned: boolean; output?: string; error?: string } {
+  const repo = resolve(input.repoRoot ?? ".");
+  const result = git(["worktree", "prune"], repo);
+  if (!result.ok) return { repoRoot: repo, pruned: false, error: result.stderr || "git worktree prune failed" };
+  return { repoRoot: repo, pruned: true, output: result.stdout.trim() || undefined };
+}
+
 export function cleanupWorkspace(workspace: { repoRoot?: string; worktreePath?: string; id?: string; branch?: string; deleteBranch?: boolean }): { workspaceId?: string; removed: boolean; worktreePath?: string; branchDeleted?: boolean } {
   if (!workspace.worktreePath) throw new Error("worktreePath required");
   const path = resolve(workspace.worktreePath);
@@ -201,11 +342,39 @@ export function workspaceGitState(input: { worktreePath?: string; baseRef?: stri
       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;
+        }
+      }
+      if (state.unmergedAhead === 0) state.landed = true;
+    }
   }
 
   return state;
 }
 
+/** Remote-tracking branch a local base tracks (e.g. `main` -> `origin/main`),
+ * or undefined when base has no upstream or is a bare sha. Squash PRs land on
+ * the remote, so the upstream is the truthful "has this merged?" reference. */
+function upstreamRef(worktreePath: string, base: string): string | undefined {
+  const res = git(["rev-parse", "--abbrev-ref", `${base}@{upstream}`], worktreePath);
+  return res.ok && res.stdout ? res.stdout : undefined;
+}
+
 function resolveBaseRef(worktreePath: string, baseRef?: string, baseSha?: string): string | undefined {
   for (const candidate of [baseRef, baseSha]) {
     if (candidate && git(["rev-parse", "--verify", "--quiet", `${candidate}^{commit}`], worktreePath).ok) {
@@ -232,7 +401,10 @@ export function reconcileWorkspace(workspace: { id?: string; repoRoot?: string;
   if (gitState.missing) {
     return { workspaceId: workspace.id, removed: false, status: "cleaned", gitState };
   }
-  const empty = gitState.error === undefined && gitState.dirtyCount === 0 && gitState.ahead === 0;
+  // Empty = nothing left to preserve: clean tree and either no commits ahead or
+  // the work already landed in base via squash/cherry-pick (`landed`). Landing
+  // detection can only under-report, so this never deletes unmerged work.
+  const empty = gitState.error === undefined && gitState.dirtyCount === 0 && ((gitState.ahead ?? 0) === 0 || gitState.landed === true);
   if (empty) {
     cleanupWorkspace({ id: workspace.id, repoRoot: workspace.repoRoot, worktreePath: workspace.worktreePath, branch: workspace.branch });
     return { workspaceId: workspace.id, removed: true, status: "cleaned", gitState };
@@ -366,10 +538,15 @@ export function previewWorkspaceMerge(input: { worktreePath?: string; baseRef?:
   if (gitState.missing) return { ...base, missing: true, reason: "worktree no longer exists" };
   if (gitState.error) return { ...base, error: gitState.error };
   base.ahead = gitState.ahead;
+  base.unmergedAhead = gitState.unmergedAhead;
+  base.landed = gitState.landed;
   base.behind = gitState.behind;
   base.dirtyCount = gitState.dirtyCount;
   if ((gitState.dirtyCount ?? 0) > 0) return { ...base, reason: "worktree has uncommitted changes" };
-  if ((gitState.ahead ?? 0) === 0) return { ...base, reason: "no commits to merge" };
+  const effectiveAhead = gitState.landed ? 0 : (gitState.unmergedAhead ?? gitState.ahead ?? 0);
+  if (effectiveAhead === 0) {
+    return { ...base, reason: gitState.landed ? "already merged into base (squash/cherry-pick)" : "no commits to merge" };
+  }
   if (gitState.baseRef && input.worktreePath) {
     const conflict = predictConflict(resolve(input.worktreePath), gitState.baseRef);
     base.conflict = conflict;