@bivy/bivy 0.6.0-staging.83 → 0.6.0-staging.84

package/dist/repo-workspace.js

@@ -164,6 +164,25 @@ export async function resolveBranchBaseRef(repoDir, branch) {
         throw new Error(`Branch "${branch}" was not found on the remote.`);
     }
 }
+/**
+ * Base ref for ADOPTING a source branch onto a fresh clone on another node (a
+ * cross-node fork). Prefers the pushed `origin/<branch>` so the source's
+ * committed work travels; falls back to the repo's default branch when the
+ * source branch was never pushed (best-effort — any uncommitted work still
+ * arrives via the fork's dirty patch). Fetches first so `origin/<branch>` is
+ * current. Contrast with `resolveBranchBaseRef`, which is user-facing and throws
+ * on a missing branch; a fork must degrade rather than fail.
+ */
+export async function resolveAdoptBaseRef(repoDir, branch) {
+    await fetchOrigin(repoDir);
+    try {
+        await exec("git", ["-C", repoDir, "rev-parse", "--verify", "--quiet", `origin/${branch}`], { cwd: repoDir });
+        return `origin/${branch}`;
+    }
+    catch {
+        return resolveDefaultBaseRef(repoDir);
+    }
+}
 /**
  * Whether an existing Bivy-owned checkout at `dest` can be reused as-is, i.e. it
  * has a `.git` entry AND `git rev-parse` accepts it as a real repository. A

package/dist/server.js

@@ -60,7 +60,7 @@ import { checkDiskAdmission } from "./harness/disk-admission.js";
 import { sandboxTier, setConfiguredSandboxTier, normalizeSandboxTier } from "./harness/sandbox.js";
 import { setConfiguredAutoAttachToolImages } from "./harness/tool-image-attachments.js";
 import { injectMcpProxyForSession, injectBivyToolsForSession } from "./harness/mcp-inject.js";
-import { parseRepo, inferGitHubRepoFromWorkspace, isSharedCloneRoot, resolveGitHubToken, cloneOrUpdateRepo, resolveDefaultBaseRef, resolveBranchBaseRef, fetchOrigin } from "./repo-workspace.js";
+import { parseRepo, inferGitHubRepoFromWorkspace, isSharedCloneRoot, resolveGitHubToken, cloneOrUpdateRepo, resolveDefaultBaseRef, resolveBranchBaseRef, resolveAdoptBaseRef, fetchOrigin } from "./repo-workspace.js";
 import { configureGitAuth, writeGitCredentialEndpoint } from "./git-auth.js";
 import { GitHubTaskPoller, resolveGitHubTaskConfig, buildTaskPrompt, buildResumePrompt, buildInteractiveResumePrompt, DEFAULT_ISSUE_INSTRUCTIONS, parseBivyDirectives, commitAll, pushBranch, mergeBaseIntoBranch, completeMerge, abortMerge, findOpenPullRequestForBranch, findPullRequestsForBranch, findMergedPullRequestForBranch, issueBranchName, getPullRequest, commentIssue, listOpenLabelledIssues, selectActionableIssues, getIssue, getIssueCommentBody, addLabel, removeLabel, announcePickup, } from "./github-tasks.js";
 import { buildLinearTaskPrompt, getLinearIssue, linearBranchName } from "./linear-tasks.js";
@@ -3560,6 +3560,7 @@ const RELAY_COMMANDS = {
                 source: rec.source,
                 title: rec.session.getName(),
                 model: rec.session.getCurrentModel()?.name,
+                sandbox: rec.sandbox,
             };
             let dirtyPatch;
             if (rec.worktree) {
@@ -3568,6 +3569,14 @@ const RELAY_COMMANDS = {
                 }
                 catch { /* best effort — omit dirty state */ }
             }
+            // 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
+            // for a genuine cross-node fork — a same-node cross-agent fork adopts the
+            // LOCAL branch and needs no push. Best-effort: a no-token/offline node just
+            // falls back to the default base downstream.
+            if (msg.crossNode === true)
+                await pushForkSourceBranch(rec);
             // Refresh the account model-auth vault so the destination node can pull
             // this session's model credentials during import (fork credential-move,
             // docs/session-fork-plan.md). Best-effort: local-only nodes just skip it.
@@ -3648,6 +3657,7 @@ const RELAY_COMMANDS = {
                 source: rec.source,
                 title: rec.session.getName(),
                 model: rec.session.getCurrentModel()?.name,
+                sandbox: rec.sandbox,
             };
             // Carry uncommitted work: capture from the SOURCE worktree; standUpFork
             // re-applies it into the fork's fresh worktree. Local git ops only.
@@ -5859,6 +5869,48 @@ async function applyRequestedModel(record, model) {
         broadcast({ type: "session.error", sessionId: record.id, error: error instanceof Error ? error.message : "Selected model is not available on this node." });
     }
 }
+// Serialize clone + worktree work per repo directory. Two forks (or a fork and
+// a GitHub pickup) hitting the same shared clone concurrently race on
+// `git worktree add`/`remove` and the `.bivy/worktrees` dir — the loser used to
+// see "already exists"/"already checked out" or, worse, `createWorktree`'s
+// adopt-path `rmSync` clearing a sibling's tree. A lightweight per-key async
+// mutex removes the race without a filesystem lock.
+const repoWorktreeLocks = new Map();
+async function withRepoLock(key, fn) {
+    const prev = repoWorktreeLocks.get(key) ?? Promise.resolve();
+    // Chain the map's tail on the PREVIOUS holder settling (never rejecting), so a
+    // failing fork doesn't poison the next waiter's gate. Each caller still awaits
+    // its own `run` and gets its own result/exception. Bounded by repo count.
+    const gate = prev.then(() => { }, () => { });
+    const run = gate.then(fn);
+    repoWorktreeLocks.set(key, run.then(() => { }, () => { }));
+    return run;
+}
+/**
+ * Best-effort push of a fork SOURCE's branch to origin before the bundle leaves
+ * the node, so a cross-node fork's committed work travels via origin (the
+ * destination bases its adopted worktree on `origin/<branch>` — see
+ * `resolveAdoptBaseRef`). Guarded by a token + repo backing; a failure just
+ * means the destination falls back to the default base and the dirty patch.
+ */
+async function pushForkSourceBranch(rec) {
+    const parts = repoSessionParts(rec);
+    if (!parts)
+        return;
+    const { wt, parsed } = parts;
+    try {
+        const token = await resolveTokenForRepo(parsed.owner, parsed.repo);
+        if (!token)
+            return;
+        const cfg = { token, owner: parsed.owner, repo: parsed.repo, repoDir: wt.repoRoot, label: "bivy", claimLabel: "bivy:in-progress", pollMs: 60_000 };
+        await pushBranch(cfg, wt.path, wt.branch);
+        rec.branchPushed = true;
+    }
+    catch {
+        // offline / no rights / protected branch — committed work may not reach a
+        // cross-node destination, but the fork still proceeds from the best base.
+    }
+}
 /**
  * Stand a forked session up on THIS node from a `ForkBundle`: credential-move,
  * (optional) prerequisite detection, repo/worktree reconstruction, transcript
@@ -5869,8 +5921,10 @@ async function applyRequestedModel(record, model) {
  */
 async function standUpFork(opts) {
     const { bundle, targetRuntimeId } = opts;
-    const targetRuntime = getRuntime(targetRuntimeId);
     const fallback = opts.fallback ?? { workspace: defaultWorkspace, cwd: defaultWorkspace };
+    // 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);
     // Credential-move: if the chosen model's provider isn't logged in on this node,
     // pull the account model-auth vault (a login done on another node carries over),
     // then re-check. Best-effort — a local-only node just skips it.
@@ -5882,41 +5936,64 @@ async function standUpFork(opts) {
         modelConfigured = await providerConfigured();
     }
     // Prerequisite detection. A missing AGENT is a hard blocker — stop before any
-    // clone/worktree work. Skipped for a same-node local fork.
+    // clone/worktree work. Skipped for a same-node local fork. Read the agent's
+    // availability + display name from the runtime REGISTRY (which never throws)
+    // rather than resolving the runtime up front: `getRuntime` throws for a
+    // known-but-not-installed agent, which — called eagerly — surfaced a raw
+    // "not available" string with an empty `missing[]` instead of this friendly
+    // install checklist. An unknown id (no registry entry) is treated as
+    // unavailable so it, too, degrades to the checklist rather than a getRuntime throw.
     const agentInfo = listRuntimes().find((r) => r.id === targetRuntimeId);
-    const agentAvailable = agentInfo ? agentInfo.status === "available" : true;
+    const agentAvailable = agentInfo ? agentInfo.status === "available" : false;
+    const agentDisplayName = agentInfo?.displayName ?? targetRuntimeId;
     const prereqInput = {
-        agent: { id: targetRuntimeId, displayName: targetRuntime.displayName, available: agentAvailable },
+        agent: { id: targetRuntimeId, displayName: agentDisplayName, available: agentAvailable },
         ...(modelProvider ? { model: { provider: modelProvider, configured: Boolean(modelConfigured) } } : {}),
     };
     if (opts.detectPrereqs) {
         const early = evaluateForkPrereqs(prereqInput);
         if (blockingForkPrereqs(early).length > 0) {
-            return { ok: false, error: `${targetRuntime.displayName} is not installed on the destination node.`, missing: missingForkPrereqs(early) };
+            return { ok: false, error: `${agentDisplayName} is not installed on the destination node.`, missing: missingForkPrereqs(early) };
         }
     }
+    // Safe now: the agent is available (or this is a same-node local fork whose
+    // agent is self-evidently present). The per-session sandbox tier bakes into
+    // the runtime's launch flags.
+    const targetRuntime = getRuntime(targetRuntimeId, forkSandbox);
     // Reconstruct repo + worktree when the source was repo-backed.
     let workspace = fallback.workspace;
     let cwd = fallback.cwd;
     let repoReachable;
     let worktree;
+    let dirtyWarning;
     const parsed = bundle.record.repoSlug ? parseRepo(bundle.record.repoSlug) : undefined;
     if (parsed) {
         const token = await resolveTokenForRepo(parsed.owner, parsed.repo);
         repoReachable = Boolean(token);
         const repoDir = await cloneOrUpdateRepo({ owner: parsed.owner, repo: parsed.repo, token, root: reposRoot });
         const srcBranch = bundle.record.branch;
-        let wt;
-        if (opts.worktree === "fresh") {
-            // Cut a new branch from the source branch (or the repo's default base).
-            const forkBranch = `${srcBranch ?? "fork"}-fork-${randomBytes(4).toString("hex")}`;
-            wt = await createWorktree({ repoDir, id: forkBranch, branch: forkBranch, base: srcBranch ?? await resolveDefaultBaseRef(repoDir) });
-        }
-        else {
-            // Adopt the source branch, or a fresh random worktree when it had none.
-            wt = await createWorktree({ repoDir, id: srcBranch ?? `fork-${randomBytes(6).toString("hex")}`, branch: srcBranch, base: srcBranch ? undefined : await resolveDefaultBaseRef(repoDir) });
-        }
-        applyDirtyPatch(wt.path, bundle.dirtyPatch);
+        // Serialize clone-adjacent worktree ops on this repo so concurrent forks /
+        // pickups don't race on `git worktree add` or clobber each other's trees.
+        const wt = await withRepoLock(repoDir, async () => {
+            if (opts.worktree === "fresh") {
+                // Same-node fork: cut a NEW branch from the source's LOCAL branch (which
+                // holds its latest, possibly-unpushed commits) or the repo default.
+                const forkBranch = `${srcBranch ?? "fork"}-fork-${randomBytes(4).toString("hex")}`;
+                return createWorktree({ repoDir, id: forkBranch, branch: forkBranch, base: srcBranch ?? await resolveDefaultBaseRef(repoDir) });
+            }
+            // Cross-node adopt: the source branch has no LOCAL ref here. Base the
+            // adopted branch on the pushed `origin/<branch>` so committed work travels
+            // (was: undefined → the destination's DEFAULT branch, silently dropping
+            // every commit). Give the worktree DIR a unique suffix so a same-branch
+            // adopt never reuses — or, via createWorktree's stale-dir cleanup, deletes
+            // — another live session's tree.
+            const dirId = `${srcBranch ?? "fork"}-${randomBytes(4).toString("hex")}`;
+            const base = srcBranch ? await resolveAdoptBaseRef(repoDir, srcBranch) : await resolveDefaultBaseRef(repoDir);
+            return createWorktree({ repoDir, id: dirId, branch: srcBranch, base });
+        });
+        const applied = applyDirtyPatch(wt.path, bundle.dirtyPatch);
+        if (applied.warning)
+            dirtyWarning = applied.warning;
         workspace = repoDir;
         cwd = wt.path;
         worktree = wt;
@@ -5930,8 +6007,10 @@ async function standUpFork(opts) {
         const forkRepoRoot = await gitRepoRoot(cwd);
         if (forkRepoRoot) {
             const forkBranch = `bivy/fork-${randomBytes(6).toString("hex")}`;
-            const wt = await createWorktree({ repoDir: forkRepoRoot, id: forkBranch, branch: forkBranch });
-            applyDirtyPatch(wt.path, bundle.dirtyPatch);
+            const wt = await withRepoLock(forkRepoRoot, () => createWorktree({ repoDir: forkRepoRoot, id: forkBranch, branch: forkBranch }));
+            const applied = applyDirtyPatch(wt.path, bundle.dirtyPatch);
+            if (applied.warning)
+                dirtyWarning = applied.warning;
             workspace = forkRepoRoot;
             cwd = wt.path;
             worktree = wt;
@@ -5941,8 +6020,8 @@ async function standUpFork(opts) {
     // transcript (full) or a fresh session the caller seeds with plan.seedPrompt.
     const plan = await materializeFork({ bundle, targetRuntime, ctx: { workspace, cwd }, seed: { transcriptUrl: opts.transcriptUrl } });
     const record = plan.kind === "resume"
-        ? await createSession(cwd, plan.sessionFile, { runtimeId: targetRuntimeId, source: bundle.record.source, makeActive: false })
-        : await createSession(cwd, undefined, { runtimeId: targetRuntimeId, source: bundle.record.source, makeActive: false });
+        ? await createSession(cwd, plan.sessionFile, { runtimeId: targetRuntimeId, source: bundle.record.source, sandbox: forkSandbox, makeActive: false })
+        : await createSession(cwd, undefined, { runtimeId: targetRuntimeId, source: bundle.record.source, sandbox: forkSandbox, makeActive: false });
     // Mark the new session as a fork of its source, so the run card can show
     // "Forked from …" and the lineage survives a reload (persisted below). Just
     // the parent's session id — an identifier, not content, so it's safe to
@@ -5961,6 +6040,10 @@ async function standUpFork(opts) {
     }
     if (bundle.record.title && !record.session.getName())
         record.session.setName(bundle.record.title);
+    // Surface a non-fatal note when the source's uncommitted changes didn't apply
+    // cleanly, so the fork isn't silently missing work-in-progress.
+    if (dirtyWarning)
+        broadcast({ type: "session.notice", sessionId: record.id, message: dirtyWarning });
     await applyRequestedModel(record, opts.model ?? nodeDefaultModel() ?? undefined);
     persistSessionMetadata(record);
     scheduleAdvertise();

package/dist/session/fork-dirty.js

@@ -1,4 +1,4 @@
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawnSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -53,14 +53,52 @@ export function captureDirtyPatch(repoDir, opts = {}) {
  * source pushed the branch instead (`pushedInstead`) or the working tree was
  * clean (empty patch). Uses `git apply` so both tracked hunks and untracked
  * new-file hunks (produced via `--no-index`) land correctly.
+ *
+ * NEVER throws: a fork's uncommitted changes are best-effort, and the source's
+ * base commit frequently differs from what the destination cloned (a diverged
+ * default branch, an unpushed source branch), so a strict `git apply` fails on
+ * hunk-context mismatch and previously took the whole fork down with it. Instead
+ * we fall back to `git apply --3way` (which reconstructs the hunks from the blob
+ * SHAs the patch carries and merges what it can) and, when even that fails,
+ * surface a warning and leave the tree as the clone left it — the fork still
+ * succeeds, minus the un-appliable working-tree edits.
  */
 export function applyDirtyPatch(repoDir, dirty) {
     if (!dirty || dirty.pushedInstead || !dirty.patch.trim())
-        return;
+        return { applied: false };
     const tmp = path.join(os.tmpdir(), `bivy-fork-${Date.now()}-${Math.random().toString(36).slice(2)}.patch`);
     fs.writeFileSync(tmp, dirty.patch);
     try {
-        execFileSync("git", ["-C", repoDir, "apply", "--whitespace=nowarn", tmp], { stdio: "pipe" });
+        try {
+            execFileSync("git", ["-C", repoDir, "apply", "--whitespace=nowarn", tmp], { stdio: "pipe" });
+            return { applied: true };
+        }
+        catch {
+            // Clean apply failed — the destination's base drifted from the source's.
+            // Retry with a 3-way merge, which reconstructs the pre-image from the blob
+            // SHAs the patch carries (present because the destination cloned the same
+            // repo) and merges what it can. `git apply --3way` exits non-zero BOTH for
+            // an un-appliable patch (nothing lands) AND for a conflicting one (it lands
+            // the non-conflicting hunks and writes conflict markers) — so read the exit
+            // status/stderr with spawnSync rather than treating every non-zero as a
+            // total failure that drops all the WIP.
+            const res = spawnSync("git", ["-C", repoDir, "apply", "--3way", "--whitespace=nowarn", tmp], { encoding: "utf8" });
+            if (res.status === 0)
+                return { applied: true }; // merged cleanly onto the diverged base
+            const stderr = (res.stderr || "").toString();
+            if (/with conflicts/i.test(stderr)) {
+                return {
+                    applied: true,
+                    conflicted: true,
+                    warning: "Some uncommitted changes from the source didn't apply cleanly and were merged with conflict markers — review and resolve them in the fork.",
+                };
+            }
+            const detail = stderr.split("\n").find((l) => l.trim()) || "patch did not apply";
+            return {
+                applied: false,
+                warning: `Couldn't re-apply the source's uncommitted changes (${detail}); they were left behind. Re-make them in the fork if you still need them.`,
+            };
+        }
     }
     finally {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.6.0-staging.83",
+  "version": "0.6.0-staging.84",
   "type": "module",
   "license": "FSL-1.1-ALv2",
   "description": "Run coding agents on machines you own. Source-available, self-hostable agent workspace.",