@bivy/bivy 0.10.1-staging.351 → 0.10.1-staging.352

package/dist/worktree-provision.js

@@ -24,6 +24,7 @@
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
+import { spawn, spawnSync } from "node:child_process";
 import { detectCloneStrategy, cloneDir } from "./harness/cow-clone.js";
 // Order within `lockfiles` is the fingerprint precedence (first present wins).
 const ECOSYSTEMS = [
@@ -92,6 +93,109 @@ export function planCowProvision(opts) {
     }
     return plan;
 }
+// Precedence order: the FIRST manager whose lockfile is present wins per `dir`.
+export const INSTALL_MANAGERS = [
+    { lockfile: "pnpm-lock.yaml", dir: "node_modules", command: "pnpm", args: ["install", "--frozen-lockfile"] },
+    { lockfile: "package-lock.json", dir: "node_modules", command: "npm", args: ["ci"] },
+    { lockfile: "npm-shrinkwrap.json", dir: "node_modules", command: "npm", args: ["ci"] },
+    { lockfile: "yarn.lock", dir: "node_modules", command: "yarn", args: ["install", "--frozen-lockfile"] },
+    { lockfile: "bun.lockb", dir: "node_modules", command: "bun", args: ["install"] },
+    { lockfile: "Cargo.lock", dir: "target", command: "cargo", args: ["fetch"] },
+    { lockfile: "uv.lock", dir: ".venv", command: "uv", args: ["sync"] },
+    { lockfile: "poetry.lock", dir: ".venv", command: "poetry", args: ["install"] },
+    { lockfile: "Pipfile.lock", dir: ".venv", command: "pipenv", args: ["install"] },
+    { lockfile: "requirements.txt", dir: ".venv", command: "pip", args: ["install", "-r", "requirements.txt"] },
+    { lockfile: "go.mod", dir: "", command: "go", args: ["mod", "download"] },
+];
+function fileExists(p) {
+    try {
+        return fs.statSync(p).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Plan the installs a worktree needs to provision its deps from scratch: for each
+ * ecosystem, the first manager (by precedence) whose lockfile is present AND whose
+ * target dir isn't already populated. Pure filesystem logic, so it is fully
+ * unit-testable. Already-provisioned dirs (a CoW clone landed, or the agent ran an
+ * install already) are skipped, so this is safe to re-run.
+ */
+export function planInstallProvision(worktreePath) {
+    const plan = [];
+    const claimed = new Set();
+    for (const m of INSTALL_MANAGERS) {
+        if (m.dir && claimed.has(m.dir))
+            continue; // a higher-precedence manager already owns this dir
+        if (!fileExists(path.join(worktreePath, m.lockfile)))
+            continue;
+        if (m.dir && isDir(path.join(worktreePath, m.dir))) {
+            claimed.add(m.dir);
+            continue;
+        } // already provisioned
+        plan.push({ dir: m.dir, command: m.command, args: m.args, lockfile: m.lockfile });
+        if (m.dir)
+            claimed.add(m.dir);
+    }
+    return plan;
+}
+/**
+ * Provision a worktree's deps by running each detected manager's install
+ * (cross-Machine fallback when CoW found no sibling). Opt-in via
+ * BIVY_WORKTREE_AUTO_INSTALL. Best-effort: a missing manager is skipped and one
+ * failing install never blocks the others (or the caller). The default runner
+ * spawns real processes; tests inject a fake.
+ */
+export async function provisionDepsByInstall(opts, runner = defaultInstallRunner()) {
+    if (!process.env.BIVY_WORKTREE_AUTO_INSTALL)
+        return { strategy: "disabled", ran: [], skipped: [] };
+    const ran = [];
+    const skipped = [];
+    for (const item of planInstallProvision(opts.worktreePath)) {
+        if (!runner.has(item.command)) {
+            skipped.push({ command: item.command, reason: "not on PATH" });
+            opts.log?.(`[worktree] provision skipped: ${item.command} not installed (${item.lockfile})`);
+            continue;
+        }
+        try {
+            opts.log?.(`[worktree] provisioning ${item.dir || item.command} via ${item.command} ${item.args.join(" ")}`);
+            await runner.run(item, opts.worktreePath);
+            ran.push(item.command);
+        }
+        catch (error) {
+            skipped.push({ command: item.command, reason: error instanceof Error ? error.message : String(error) });
+            opts.log?.(`[worktree] provision of ${item.dir || item.command} failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return { strategy: "ran", ran, skipped };
+}
+function defaultInstallRunner() {
+    return {
+        has(command) {
+            const probe = process.platform === "win32" ? "where" : "command";
+            const args = process.platform === "win32" ? [command] : ["-v", command];
+            const result = spawnSync(probe, args, { stdio: "ignore", shell: process.platform === "win32" });
+            return result.status === 0;
+        },
+        run(item, cwd) {
+            return new Promise((resolve, reject) => {
+                const child = spawn(item.command, item.args, { cwd, stdio: "ignore" });
+                // Bound each install so a wedged manager can't provision forever.
+                const timer = setTimeout(() => { child.kill("SIGKILL"); reject(new Error("install timed out")); }, INSTALL_TIMEOUT_MS);
+                child.on("error", (err) => { clearTimeout(timer); reject(err); });
+                child.on("exit", (code) => {
+                    clearTimeout(timer);
+                    if (code === 0)
+                        resolve();
+                    else
+                        reject(new Error(`exit ${code}`));
+                });
+            });
+        },
+    };
+}
+const INSTALL_TIMEOUT_MS = 15 * 60 * 1000;
 /**
  * Opportunistically CoW-clone installed dirs into a freshly-created worktree from
  * a sibling of the same repo. Gated on BIVY_WORKTREE_COW_CLONE and on the

package/dist/worktree.js

@@ -4,7 +4,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import fs from "node:fs";
 import path from "node:path";
-import { cowProvisionDeps } from "./worktree-provision.js";
+import { cowProvisionDeps, provisionDepsByInstall } from "./worktree-provision.js";
 const exec = promisify(execFile);
 /** Slugify arbitrary text into a safe git branch / directory segment. */
 export function branchSlug(input) {
@@ -103,7 +103,16 @@ export async function createWorktree(opts) {
     // target, .venv) via copy-on-write when the filesystem supports it, so a
     // second worktree of this repo costs ~its diff instead of a full re-install.
     // Opt-in (BIVY_WORKTREE_COW_CLONE), CoW-only, lockfile-matched, best-effort.
-    cowProvisionDeps({ worktreePath: wtPath, worktreesRoot: root, log: (m) => console.log(m) });
+    const cow = cowProvisionDeps({ worktreePath: wtPath, worktreesRoot: root, log: (m) => console.log(m) });
+    // Cross-Machine fallback (1D): when CoW cloned nothing (fresh destination with
+    // no sibling — the exact cross-Machine move case), provision the deps by running
+    // the detected managers' installs so the agent doesn't hit a cold tree. Opt-in
+    // (BIVY_WORKTREE_AUTO_INSTALL), background (never blocks worktree creation),
+    // best-effort. `planInstallProvision` skips any dir a CoW clone already filled.
+    if (cow.cloned.length === 0) {
+        void provisionDepsByInstall({ worktreePath: wtPath, log: (m) => console.log(m) })
+            .catch((error) => console.log(`[worktree] auto-provision error: ${error instanceof Error ? error.message : String(error)}`));
+    }
     return { path: wtPath, branch, repoRoot };
 }
 /** True if `ref` (a fully-qualified ref) resolves in the repo. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.10.1-staging.351",
+  "version": "0.10.1-staging.352",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",