@bivy/bivy 0.16.8-staging.1 → 0.16.8-staging.3

package/dist/controllers/fork-commands.js

@@ -8,7 +8,7 @@
 // server injects its own session lookup, runtime access, event emit, and the fork
 // helpers as composition deps, so this stays free of daemon state and unit-testable.
 import { buildForkBundle } from "../session/fork.js";
-import { captureDirtyPatch, captureWorkspaceDirtyPatch } from "../session/fork-dirty.js";
+import { captureDirtyPatch, captureWorkspaceDirtyPatch, captureWorkspaceSnapshot } from "../session/fork-dirty.js";
 export function createForkCommands(deps) {
     return {
         async "session.fork.retire-source"(msg) {
@@ -48,9 +48,15 @@ export function createForkCommands(deps) {
                 // A git workspace must be captured successfully, including sessions that
                 // were started in an unmanaged checkout rather than a Bivy worktree.
                 // Treating a git/read failure as "clean" could retire the only WIP copy.
+                const sourceCwd = rec.session.cwd || rec.workspace;
                 const dirtyPatch = rec.worktree
                     ? captureDirtyPatch(rec.worktree.path)
-                    : captureWorkspaceDirtyPatch(rec.session.cwd || rec.workspace);
+                    : captureWorkspaceDirtyPatch(sourceCwd);
+                // Plain workspaces have no remote clone source, so carry their files in
+                // the E2E bundle instead of silently substituting the destination cwd.
+                const workspaceSnapshot = !forkRecord.repoSlug && (msg.crossNode === true || dirtyPatch === undefined)
+                    ? captureWorkspaceSnapshot(sourceCwd, { maxBytes: deps.forkWorkspaceMaxBytes() })
+                    : undefined;
                 // Publish the source branch so a cross-node fork's COMMITTED work travels
                 // via origin (the destination adopts `origin/<branch>`; see
                 // resolveAdoptBaseRef). Uncommitted work rides the dirtyPatch above. Only
@@ -66,7 +72,7 @@ export function createForkCommands(deps) {
                 // When the client has already picked a target agent, pass it so the
                 // bundle omits the native payload for a cross-runtime fork (it could
                 // never be replayed there — see buildForkBundle). Unset => keep it.
-                const bundle = buildForkBundle({ runtime: deps.getRuntime(rec.runtimeId), sessionFile: rec.sessionFile, record: forkRecord, dirtyPatch, targetRuntimeId: deps.agentFrom(msg), liveMessages: rec.session.getMessages(), state: deps.forkInFlightState(rec) });
+                const bundle = buildForkBundle({ runtime: deps.getRuntime(rec.runtimeId), sessionFile: rec.sessionFile, record: forkRecord, dirtyPatch, workspaceSnapshot, targetRuntimeId: deps.agentFrom(msg), liveMessages: rec.session.getMessages(), state: deps.forkInFlightState(rec) });
                 deps.sendEvent({ type: "session.fork.bundle", requestId, bundle });
             }
             catch (error) {
@@ -136,11 +142,15 @@ export function createForkCommands(deps) {
                 // re-applies it into the fork's fresh worktree. Local git ops only.
                 // Include unmanaged git workspaces too. standUpFork will cut an isolated
                 // worktree for them, so their uncommitted state must ride with it.
+                const sourceCwd = rec.session.cwd || rec.workspace;
                 const dirtyPatch = rec.worktree
                     ? captureDirtyPatch(rec.worktree.path)
-                    : captureWorkspaceDirtyPatch(rec.session.cwd || rec.workspace);
+                    : captureWorkspaceDirtyPatch(sourceCwd);
+                const workspaceSnapshot = dirtyPatch === undefined
+                    ? captureWorkspaceSnapshot(sourceCwd, { maxBytes: deps.forkWorkspaceMaxBytes() })
+                    : undefined;
                 // Same runtime → the bundle carries the native payload → full fidelity.
-                const bundle = buildForkBundle({ runtime, sessionFile: rec.sessionFile, record: forkRecord, dirtyPatch, targetRuntimeId: rec.runtimeId, liveMessages: rec.session.getMessages(), state: deps.forkInFlightState(rec) });
+                const bundle = buildForkBundle({ runtime, sessionFile: rec.sessionFile, record: forkRecord, dirtyPatch, workspaceSnapshot, targetRuntimeId: rec.runtimeId, liveMessages: rec.session.getMessages(), state: deps.forkInFlightState(rec) });
                 // Cut a fresh fork branch (the source still holds its own); skip prereq
                 // detection (same node + same runtime ⇒ agent and repo are present).
                 const outcome = await deps.standUpFork({

package/dist/node-config.js

@@ -74,7 +74,7 @@ export function validateNodeConfig(value) {
     const node = section(root, "node", ["workspace", "port", "maxConcurrentAutomations", "capabilities"], errors);
     const defaults = section(root, "defaults", ["agent", "model", "sandbox", "approval"], errors);
     const safety = section(root, "safety", ["maxSandbox", "approvalFloor"], errors);
-    const sessions = section(root, "sessions", ["sync", "worktreeSync", "standbyNodeId", "resume", "autoAttachToolImages", "wedgedTurnMinutes"], errors);
+    const sessions = section(root, "sessions", ["sync", "worktreeSync", "standbyNodeId", "resume", "autoAttachToolImages", "forkWorkspaceMaxBytes", "wedgedTurnMinutes"], errors);
     const github = section(root, "github", ["issuePrompt"], errors);
     const automation = section(root, "automation", ["checks", "checkTimeoutMinutes"], errors);
     const agentsRaw = section(root, "agents", Object.keys(record(root.agents) ?? {}), errors);
@@ -133,6 +133,7 @@ export function validateNodeConfig(value) {
     if (resume !== undefined && resume !== "auto" && resume !== "manual")
         errors.push("sessions.resume must be auto or manual");
     const autoAttachToolImages = optionalBoolean(sessions.autoAttachToolImages, "sessions.autoAttachToolImages", errors);
+    const forkWorkspaceMaxBytes = optionalInteger(sessions.forkWorkspaceMaxBytes, "sessions.forkWorkspaceMaxBytes", errors, 1_048_576, 1_073_741_824);
     // Upper bound is the wall-clock turn cap (60 min): a wedged window at/above it
     // would never fire before the cap. 0 disables the band.
     const wedgedTurnMinutes = optionalInteger(sessions.wedgedTurnMinutes, "sessions.wedgedTurnMinutes", errors, 0, 60);
@@ -215,7 +216,7 @@ export function validateNodeConfig(value) {
         ...(Object.keys(node).length ? { node: { workspace, port, maxConcurrentAutomations, capabilities } } : {}),
         ...(Object.keys(defaults).length ? { defaults: { agent, model, sandbox, approval } } : {}),
         ...(Object.keys(safety).length ? { safety: { maxSandbox, approvalFloor } } : {}),
-        ...(Object.keys(sessions).length ? { sessions: { sync, worktreeSync, standbyNodeId, resume, autoAttachToolImages, wedgedTurnMinutes } } : {}),
+        ...(Object.keys(sessions).length ? { sessions: { sync, worktreeSync, standbyNodeId, resume, autoAttachToolImages, forkWorkspaceMaxBytes, wedgedTurnMinutes } } : {}),
         ...(Object.keys(github).length ? { github: { issuePrompt } } : {}),
         ...(Object.keys(automation).length ? { automation: { checks, checkTimeoutMinutes } } : {}),
         ...(Object.keys(agents).length ? { agents } : {}),
@@ -271,6 +272,7 @@ export function configToLegacySettings(config) {
         ...(config.sessions?.standbyNodeId ? { syncStandbyNodeId: config.sessions.standbyNodeId } : {}),
         ...(config.sessions?.resume ? { sessionResumeMode: config.sessions.resume } : {}),
         ...(config.sessions?.autoAttachToolImages !== undefined ? { autoAttachToolImages: config.sessions.autoAttachToolImages } : {}),
+        ...(config.sessions?.forkWorkspaceMaxBytes !== undefined ? { forkWorkspaceMaxBytes: config.sessions.forkWorkspaceMaxBytes } : {}),
     };
 }
 export function mergeLegacyIntoNodeConfig(cli, settings) {
@@ -333,6 +335,7 @@ export function mergeLegacyIntoNodeConfig(cli, settings) {
             standbyNodeId: typeof settings.syncStandbyNodeId === "string" ? settings.syncStandbyNodeId : undefined,
             resume: settings.sessionResumeMode === "manual" ? "manual" : "auto",
             autoAttachToolImages: settings.autoAttachToolImages === true,
+            forkWorkspaceMaxBytes: Number.isInteger(settings.forkWorkspaceMaxBytes) ? Number(settings.forkWorkspaceMaxBytes) : undefined,
         },
         github: { issuePrompt: typeof settings.githubIssuePrompt === "string" ? settings.githubIssuePrompt : undefined },
         automation: {
@@ -358,7 +361,7 @@ export function setConfigValue(config, dotted, value) {
         "node.workspace", "node.port", "node.maxConcurrentAutomations", "node.capabilities",
         "defaults.agent", "defaults.model", "defaults.sandbox", "defaults.approval",
         "safety.maxSandbox", "safety.approvalFloor",
-        "sessions.sync", "sessions.worktreeSync", "sessions.standbyNodeId", "sessions.resume", "sessions.autoAttachToolImages", "sessions.wedgedTurnMinutes",
+        "sessions.sync", "sessions.worktreeSync", "sessions.standbyNodeId", "sessions.resume", "sessions.autoAttachToolImages", "sessions.forkWorkspaceMaxBytes", "sessions.wedgedTurnMinutes",
         "github.issuePrompt", "automation.checks", "automation.checkTimeoutMinutes",
     ]);
     if (!allowed.has(dotted) && !/^agents\.[a-z][a-z0-9-]{1,47}$/.test(dotted) && !/^environment\.[A-Z][A-Z0-9_]+$/.test(dotted))

package/dist/server.js

@@ -1345,6 +1345,7 @@ function writeSettings(settings) {
         ...("syncStandbyNodeId" in settings ? { standbyNodeId: typeof settings.syncStandbyNodeId === "string" ? settings.syncStandbyNodeId || undefined : undefined } : {}),
         ...(settings.sessionResumeMode === "auto" || settings.sessionResumeMode === "manual" ? { resume: settings.sessionResumeMode } : {}),
         ...(typeof settings.autoAttachToolImages === "boolean" ? { autoAttachToolImages: settings.autoAttachToolImages } : {}),
+        ...(Number.isInteger(settings.forkWorkspaceMaxBytes) ? { forkWorkspaceMaxBytes: Number(settings.forkWorkspaceMaxBytes) } : {}),
     };
     next.github = {
         ...next.github,
@@ -1463,6 +1464,7 @@ function nodeSettingsSnapshot() {
         })(),
         sessionResumeMode: nodeSessionResumeMode(),
         autoAttachToolImages: readSettings().autoAttachToolImages === true,
+        forkWorkspaceMaxBytes: Number.isInteger(readSettings().forkWorkspaceMaxBytes) ? Number(readSettings().forkWorkspaceMaxBytes) : 50 * 1024 * 1024,
     };
 }
 async function applyNodeSettings(patch) {
@@ -1962,6 +1964,7 @@ const RELAY_COMMANDS = {
         modelFrom,
         pushModelAuthToControlPlane,
         pushForkSourceBranch: (rec) => branchPublish.pushForkSourceBranch(rec),
+        forkWorkspaceMaxBytes: () => nodeSettingsSnapshot().forkWorkspaceMaxBytes,
         standUpFork: (opts) => forkStandUp.standUpFork(opts),
         retireSource: (input) => forkRetire.retireSource(input),
     }),

package/dist/session/fork-dirty.js

@@ -14,12 +14,27 @@ import path from "node:path";
  * the marker as success would lose work-in-progress.
  */
 const DEFAULT_MAX_BYTES = 5 * 1024 * 1024; // 5 MiB of patch text
+const DEFAULT_WORKSPACE_MAX_BYTES = 50 * 1024 * 1024; // 50 MiB of files
+function workspaceMaxBytes(configured) {
+    return configured !== undefined ? configured : DEFAULT_WORKSPACE_MAX_BYTES;
+}
 /** Find the containing git checkout without throwing for ordinary non-git
  * workspaces. A discovered checkout is captured fail-closed by the caller. */
 export function captureWorkspaceDirtyPatch(cwd, opts = {}) {
     const probe = spawnSync("git", ["-C", cwd, "rev-parse", "--show-toplevel"], { encoding: "utf8", timeout: 10_000 });
-    if (probe.status !== 0)
-        return undefined;
+    if (probe.error)
+        throw probe.error;
+    if (probe.signal === "SIGTERM")
+        throw new Error("Timed out while inspecting the session workspace for uncommitted changes.");
+    if (probe.status !== 0) {
+        // A plain directory is a supported workspace. Do not, however, turn a
+        // broken/permission-denied git invocation into an apparent clean tree: for
+        // a MOVE that could discard the only copy of the user's edits.
+        const detail = String(probe.stderr || "").toLowerCase();
+        if (/not a git repository|outside a git work tree/.test(detail))
+            return undefined;
+        throw new Error(`Could not inspect the session workspace with git${probe.stderr ? `: ${String(probe.stderr).trim()}` : ""}`);
+    }
     const root = String(probe.stdout || "").trim();
     return root ? captureDirtyPatch(root, opts) : undefined;
 }
@@ -58,6 +73,60 @@ export function captureDirtyPatch(repoDir, opts = {}) {
     }
     return { patch, untracked };
 }
+/** Capture a non-git workspace for a fork. Symlinks are recorded, never followed,
+ * and .git is excluded as it is a repository boundary rather than workspace data. */
+export function captureWorkspaceSnapshot(root, opts = {}) {
+    const maxBytes = workspaceMaxBytes(opts.maxBytes);
+    const entries = [];
+    let byteLength = 0;
+    const walk = (dir, prefix) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (!prefix && (entry.name === ".git" || entry.name === ".bivy"))
+                continue;
+            const rel = prefix ? path.join(prefix, entry.name) : entry.name;
+            const abs = path.join(dir, entry.name);
+            const stat = fs.lstatSync(abs);
+            if (stat.isDirectory()) {
+                walk(abs, rel);
+                continue;
+            }
+            if (stat.isSymbolicLink()) {
+                const target = fs.readlinkSync(abs);
+                byteLength += Buffer.byteLength(target);
+                entries.push({ path: rel, kind: "symlink", target });
+            }
+            else if (stat.isFile()) {
+                byteLength += stat.size;
+                entries.push({ path: rel, kind: "file", data: fs.readFileSync(abs).toString("base64"), mode: stat.mode & 0o777 });
+            }
+        }
+    };
+    walk(path.resolve(root), "");
+    if (byteLength > maxBytes)
+        return { entries: [], byteLength, maxBytes, oversized: true };
+    return { entries, byteLength, maxBytes };
+}
+/** Materialise a captured workspace into a fresh destination directory. */
+export function applyWorkspaceSnapshot(root, snapshot) {
+    if (!snapshot)
+        return;
+    if (snapshot.oversized)
+        throw new Error(`The workspace snapshot is ${snapshot.byteLength} bytes, above the ${snapshot.maxBytes}-byte transfer limit.`);
+    const destination = path.resolve(root);
+    for (const entry of snapshot.entries) {
+        const target = path.resolve(destination, entry.path);
+        if (target !== destination && !target.startsWith(`${destination}${path.sep}`))
+            throw new Error("Workspace snapshot contains an invalid path.");
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        if (entry.kind === "symlink")
+            fs.symlinkSync(entry.target ?? "", target);
+        else {
+            fs.writeFileSync(target, Buffer.from(entry.data ?? "", "base64"));
+            if (entry.mode !== undefined)
+                fs.chmodSync(target, entry.mode);
+        }
+    }
+}
 /**
  * Re-apply a captured patch onto a fresh checkout at `repoDir`. An oversized
  * marker produces a warning as a final defence; normal fork stand-up rejects it

package/dist/session/fork-standup.js

@@ -16,9 +16,12 @@
 // Generic over the record type R (server passes SessionRecord) so the outcome it
 // returns is the caller's own record type, not a narrowed copy.
 import { randomBytes } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
 import { normalizeSandboxTier } from "../harness/sandbox.js";
 import { parseRepo } from "../repo-workspace.js";
 import { evaluateForkPrereqs, blockingForkPrereqs, missingForkPrereqs } from "../session/fork-prereqs.js";
+import { applyWorkspaceSnapshot } from "./fork-dirty.js";
 /**
  * A one-line, user-facing disclosure of the source's in-flight state, or
  * undefined when there is nothing to disclose. Pure so it is unit-testable.
@@ -57,6 +60,13 @@ export function createForkStandUp(deps) {
                 missing: [],
             };
         }
+        if (bundle.workspaceSnapshot?.oversized) {
+            return {
+                ok: false,
+                error: `The source workspace is too large to transfer safely (${bundle.workspaceSnapshot.byteLength} bytes; limit ${bundle.workspaceSnapshot.maxBytes}). Reduce it and retry.`,
+                missing: [],
+            };
+        }
         // Carry the source's sandbox tier so a sandboxed session forks into a
         // sandboxed one, rather than defaulting to this node's tier (fork.ts).
         const forkSandbox = normalizeSandboxTier(bundle.record.sandbox);
@@ -159,12 +169,26 @@ export function createForkStandUp(deps) {
             worktree = wt;
         }
         else {
+            // Non-repo-backed source. Materialise the complete workspace into an
+            // isolated directory on the destination; this also prevents same-node
+            // plain-directory forks from running two agents in one cwd.
+            if (bundle.workspaceSnapshot) {
+                const root = path.resolve(deps.defaultWorkspace);
+                fs.mkdirSync(root, { recursive: true });
+                const isolated = fs.mkdtempSync(path.join(root, ".bivy-fork-"));
+                applyWorkspaceSnapshot(isolated, bundle.workspaceSnapshot);
+                workspace = isolated;
+                cwd = isolated;
+            }
             // Non-repo-backed source. The fork would otherwise reuse the PARENT's cwd,
             // putting two sessions in one working tree — so when that cwd is itself a git
             // checkout (a local repo without a GitHub origin), cut the fork its own
             // worktree on a fresh branch. Best-effort: a non-git workspace has no tree to
             // isolate, so the fork keeps the fallback cwd (no git collisions possible).
-            const forkRepoRoot = await deps.gitRepoRoot(cwd);
+            // A snapshot is authoritative for a machine-local source. Do not inspect
+            // the destination fallback cwd and accidentally turn it into a worktree
+            // fork of an unrelated repository.
+            const forkRepoRoot = bundle.workspaceSnapshot ? undefined : await deps.gitRepoRoot(cwd);
             if (forkRepoRoot) {
                 const forkBranch = `bivy/fork-${randomBytes(6).toString("hex")}`;
                 const wt = await deps.withRepoLock(forkRepoRoot, () => deps.createWorktree({ repoDir: forkRepoRoot, id: forkBranch, branch: forkBranch }));

package/dist/session/fork.js

@@ -33,7 +33,14 @@ export function buildForkBundle(opts) {
     // Only worth capturing when the target is the same runtime (or not yet known).
     const nativeCouldReplay = !opts.targetRuntimeId || opts.targetRuntimeId === runtime.id;
     let native;
-    if (sessionFile && nativeCouldReplay && runtime.capabilities.forkTransport && runtime.exportForFork) {
+    // A native export reads the runtime's persisted store, which may lag the
+    // live session while a turn is streaming. Never prefer that stale snapshot
+    // for an in-flight fork: the normalized live transcript below is the only
+    // representation that includes the current turn. This is especially
+    // important for same-runtime forks, where a successful native import would
+    // otherwise prevent the portable fallback from being used.
+    const nativeSafe = !opts.state?.working;
+    if (sessionFile && nativeSafe && nativeCouldReplay && runtime.capabilities.forkTransport && runtime.exportForFork) {
         try {
             native = runtime.exportForFork(sessionFile);
         }
@@ -42,7 +49,7 @@ export function buildForkBundle(opts) {
             // transcript below still supports replay or a seeded continuation.
         }
     }
-    return { record, normalized, ...(native ? { native } : {}), ...(opts.dirtyPatch ? { dirtyPatch: opts.dirtyPatch } : {}), ...(opts.state ? { state: opts.state } : {}) };
+    return { record, normalized, ...(native ? { native } : {}), ...(opts.dirtyPatch ? { dirtyPatch: opts.dirtyPatch } : {}), ...(opts.workspaceSnapshot ? { workspaceSnapshot: opts.workspaceSnapshot } : {}), ...(opts.state ? { state: opts.state } : {}) };
 }
 /**
  * Decide the best fidelity a fork of `bundle` into `targetRuntime` can achieve:

package/package.json

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