agent-relay-orchestrator 0.11.4 → 0.11.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay-orchestrator",
-  "version": "0.11.4",
+  "version": "0.11.6",
   "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.3"
+    "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,

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;