@bivy/bivy 0.6.0 → 0.7.0

package/dist/session/attachment-store.js

@@ -30,17 +30,16 @@ const HASH_RE = /^[0-9a-f]{64}$/;
 export function isValidAttachmentHash(value) {
     return typeof value === "string" && HASH_RE.test(value);
 }
-/**
- * A global, content-addressed attachment store rooted at a single directory.
- * All methods are best-effort and synchronous, matching the surrounding
- * server code (EventLog, SidecarStore) — attachment persistence must never sink
- * a turn, so a write failure surfaces as a thrown error the caller degrades to a
- * text note rather than a crash.
- */
 export class AttachmentStore {
     dir;
-    constructor(dir) {
+    maxFileBytes;
+    maxStoreBytes;
+    retentionMs;
+    constructor(dir, options = {}) {
         this.dir = dir;
+        this.maxFileBytes = options.maxFileBytes ?? 25 * 1024 * 1024;
+        this.maxStoreBytes = options.maxStoreBytes ?? 2 * 1024 * 1024 * 1024;
+        this.retentionMs = options.retentionMs ?? 30 * 24 * 60 * 60 * 1000;
     }
     /** `<dir>/ab/cd` for a hash beginning `abcd…`. */
     shardDir(hash) {
@@ -59,16 +58,23 @@ export class AttachmentStore {
      * sidecar is written only the first time so the earliest name/mime wins.
      */
     put(bytes, opts) {
+        if (bytes.length > this.maxFileBytes)
+            throw new Error(`Attachment exceeds the ${this.maxFileBytes}-byte node limit`);
         const hash = crypto.createHash("sha256").update(bytes).digest("hex");
         const ref = { hash, name: opts.name, mimeType: opts.mimeType, size: bytes.length, kind: opts.kind };
         fs.mkdirSync(this.shardDir(hash), { recursive: true });
         const blob = this.blobPath(hash);
-        if (!fs.existsSync(blob))
-            fs.writeFileSync(blob, bytes);
+        if (!fs.existsSync(blob)) {
+            const usage = this.stats();
+            if (usage.bytes + bytes.length > this.maxStoreBytes) {
+                throw new Error(`Attachment store would exceed its ${this.maxStoreBytes}-byte capacity`);
+            }
+            this.atomicWrite(blob, bytes);
+        }
         if (!fs.existsSync(this.metaPath(hash))) {
             const meta = { ...ref, createdAt: Date.now() };
             try {
-                fs.writeFileSync(this.metaPath(hash), JSON.stringify(meta));
+                this.atomicWrite(this.metaPath(hash), Buffer.from(JSON.stringify(meta)));
             }
             catch {
                 // A missing sidecar only costs us the remembered name/mime — the blob is
@@ -77,6 +83,88 @@ export class AttachmentStore {
         }
         return ref;
     }
+    atomicWrite(destination, bytes) {
+        const tmp = `${destination}.tmp-${process.pid}-${crypto.randomUUID()}`;
+        try {
+            fs.writeFileSync(tmp, bytes, { flag: "wx" });
+            fs.renameSync(tmp, destination);
+        }
+        finally {
+            try {
+                fs.unlinkSync(tmp);
+            }
+            catch { /* rename succeeded or cleanup best effort */ }
+        }
+    }
+    blobEntries() {
+        if (!fs.existsSync(this.dir))
+            return [];
+        const entries = [];
+        const walk = (dir) => {
+            for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                const full = path.join(dir, entry.name);
+                if (entry.isDirectory())
+                    walk(full);
+                else if (entry.isFile() && isValidAttachmentHash(entry.name)) {
+                    try {
+                        const stat = fs.statSync(full);
+                        entries.push({ hash: entry.name, path: full, size: stat.size, mtimeMs: stat.mtimeMs });
+                    }
+                    catch { /* raced deletion */ }
+                }
+                else if (entry.isFile() && entry.name.includes(".tmp-")) {
+                    // Repair an interrupted atomic write after a conservative grace period.
+                    try {
+                        const stat = fs.statSync(full);
+                        if (Date.now() - stat.mtimeMs > 60 * 60 * 1000)
+                            fs.unlinkSync(full);
+                    }
+                    catch { /* best effort */ }
+                }
+            }
+        };
+        walk(this.dir);
+        return entries;
+    }
+    stats() {
+        const entries = this.blobEntries();
+        return { blobs: entries.length, bytes: entries.reduce((sum, entry) => sum + entry.size, 0) };
+    }
+    /** Delete only unreferenced blobs. Retention removes old orphans first; when
+     * over the global cap, oldest remaining orphans are removed until under cap.
+     * Referenced history is never sacrificed to satisfy the soft cap. */
+    gc(referenced, now = Date.now()) {
+        const entries = this.blobEntries().sort((a, b) => a.mtimeMs - b.mtimeMs);
+        let bytes = entries.reduce((sum, entry) => sum + entry.size, 0);
+        let removedBlobs = 0;
+        let removedBytes = 0;
+        const remove = (entry) => {
+            try {
+                fs.unlinkSync(entry.path);
+                try {
+                    fs.unlinkSync(this.metaPath(entry.hash));
+                }
+                catch { /* sidecar optional */ }
+                bytes -= entry.size;
+                removedBlobs += 1;
+                removedBytes += entry.size;
+            }
+            catch { /* best-effort sweep */ }
+        };
+        for (const entry of entries) {
+            if (!referenced.has(entry.hash) && now - entry.mtimeMs >= this.retentionMs)
+                remove(entry);
+        }
+        if (bytes > this.maxStoreBytes) {
+            for (const entry of entries) {
+                if (bytes <= this.maxStoreBytes)
+                    break;
+                if (!referenced.has(entry.hash) && fs.existsSync(entry.path))
+                    remove(entry);
+            }
+        }
+        return { blobs: entries.length - removedBlobs, bytes, removedBlobs, removedBytes, overCapBytes: Math.max(0, bytes - this.maxStoreBytes) };
+    }
     /** The blob's metadata, or null if the hash is unknown/malformed. */
     readMeta(hash) {
         if (!isValidAttachmentHash(hash))

package/dist/session/event-log.js

@@ -27,6 +27,7 @@
 // The two projections are independent: base records and overlay records may be
 // interleaved in any order on disk; each replay reads only its own kind.
 import fs from "node:fs";
+import path from "node:path";
 import { normalizedIntermediateText, thinkingTextFromContent, mergeTranscript } from "./transcript-merge.js";
 /** Content-block type carried by a folded outbound attachment. MUST match
  *  `AGENT_ATTACHMENT_BLOCK` in packages/core/src/store-render.ts — the client's
@@ -219,9 +220,9 @@ export function baseReplay(entries) {
     }
     return base;
 }
-/** Parse a JSONL log body into valid records, skipping malformed/blank lines. */
-export function parseLog(body) {
-    const out = [];
+function parseLogDetailed(body) {
+    const records = [];
+    let malformedLines = 0;
     for (const line of body.split("\n")) {
         const trimmed = line.trim();
         if (!trimmed)
@@ -229,11 +230,20 @@ export function parseLog(body) {
         try {
             const value = JSON.parse(trimmed);
             if (isRecord(value))
-                out.push(value);
+                records.push(value);
+            else
+                malformedLines += 1;
+        }
+        catch {
+            malformedLines += 1;
         }
-        catch { }
     }
-    return out;
+    return { records, malformedLines };
+}
+/** Parse a JSONL log body into valid records. Callers that need corruption
+ * diagnostics use EventLog.load, which reports malformed lines via onIssue. */
+export function parseLog(body) {
+    return parseLogDetailed(body).records;
 }
 /**
  * Append-only, coalesced, throttled JSONL log store — the write+read companion to
@@ -248,6 +258,7 @@ export class EventLog {
     pathFor;
     redact;
     throttleMs;
+    onIssue;
     disk = new Map();
     pending = new Map();
     timers = new Map();
@@ -257,11 +268,53 @@ export class EventLog {
     // snapshot can be diffed (prefix-compared) into a bounded delta. Seeded from disk
     // on first use of a session after a restart.
     baseKeys = new Map();
-    constructor(dir, pathFor, redact = (t) => t, throttleMs = 500) {
+    lastIssue;
+    constructor(dir, pathFor, redact = (t) => t, throttleMs = 500, onIssue = (issue) => console.error(`[event-log] ${issue.operation} failed for ${issue.sessionId}: ${issue.message}`)) {
         this.dir = dir;
         this.pathFor = pathFor;
         this.redact = redact;
         this.throttleMs = throttleMs;
+        this.onIssue = onIssue;
+    }
+    report(id, operation, error) {
+        const issue = {
+            sessionId: id,
+            operation,
+            message: error instanceof Error ? error.message : String(error),
+            at: Date.now(),
+        };
+        this.lastIssue = issue;
+        this.onIssue(issue);
+    }
+    health() {
+        return { ok: !this.lastIssue, ...(this.lastIssue ? { lastIssue: { ...this.lastIssue } } : {}), pendingSessions: this.pending.size };
+    }
+    diskUsage() {
+        if (!fs.existsSync(this.dir))
+            return { files: 0, bytes: 0 };
+        let files = 0;
+        let bytes = 0;
+        const walk = (dir) => {
+            for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                const full = path.join(dir, entry.name);
+                if (entry.isDirectory())
+                    walk(full);
+                else if (entry.isFile()) {
+                    try {
+                        files += 1;
+                        bytes += fs.statSync(full).size;
+                    }
+                    catch { /* raced cleanup */ }
+                }
+            }
+        };
+        try {
+            walk(this.dir);
+        }
+        catch (error) {
+            this.report("*", "read", error);
+        }
+        return { files, bytes };
     }
     load(id) {
         const cached = this.disk.get(id);
@@ -269,9 +322,15 @@ export class EventLog {
             return cached;
         let data = [];
         try {
-            data = parseLog(fs.readFileSync(this.pathFor(id), "utf8"));
+            const parsed = parseLogDetailed(fs.readFileSync(this.pathFor(id), "utf8"));
+            data = parsed.records;
+            if (parsed.malformedLines > 0)
+                this.report(id, "parse", new Error(`${parsed.malformedLines} malformed record(s); valid history was recovered`));
+        }
+        catch (error) {
+            if (error?.code !== "ENOENT")
+                this.report(id, "read", error);
         }
-        catch { }
         this.disk.set(id, data);
         return data;
     }
@@ -437,7 +496,10 @@ export class EventLog {
             batch.clear();
             this.lastFlush.set(id, Date.now());
         }
-        catch { }
+        catch (error) {
+            // Do not clear the batch: a later explicit/timer flush can retry it.
+            this.report(id, "append", error);
+        }
     }
     /**
      * Overwrite a session's log with a known-complete set of records. Used by the
@@ -462,7 +524,9 @@ export class EventLog {
             fs.writeFileSync(this.pathFor(id), this.redact(body));
             this.lastFlush.set(id, Date.now());
         }
-        catch { }
+        catch (error) {
+            this.report(id, "rewrite", error);
+        }
     }
     /** Cancel any pending write and forget the session (used when it's deleted). */
     drop(id) {

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/dist/session/revert-file.js

@@ -0,0 +1,44 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+//
+// Safe per-file revert for the review surface (C3d). Restores ONE changed file
+// to its pre-turn content, so a reviewer can undo a single unwanted edit without
+// rewinding the whole turn. The pre-turn content is the diff's own `oldText`
+// (computed and sent by the node), passed back with the request; a file the turn
+// ADDED reverts to removal (content === null). Path-confined to the worktree — no
+// traversal, no absolute escape — and never writes outside it.
+import fs from "node:fs";
+import path from "node:path";
+/** Resolve `relPath` inside `worktreeDir`, rejecting anything that escapes it. */
+export function confineToWorktree(worktreeDir, relPath) {
+    const root = path.resolve(worktreeDir);
+    const abs = path.resolve(root, relPath);
+    if (abs !== root && !abs.startsWith(root + path.sep))
+        return null;
+    return abs;
+}
+/**
+ * Revert a single changed file to its pre-turn state. `content` is the file's
+ * pre-turn text (restore it), or `null` when the turn added the file (remove it).
+ * A path outside the worktree is rejected outright.
+ */
+export function revertFile(worktreeDir, relPath, content, io = {}) {
+    const abs = confineToWorktree(worktreeDir, relPath);
+    if (!abs || !relPath)
+        return { ok: false, status: "rejected", error: "path outside the worktree" };
+    const writeFile = io.writeFile ?? ((p, data) => fs.writeFileSync(p, data));
+    const rm = io.rm ?? ((p) => fs.rmSync(p, { force: true }));
+    const mkdir = io.mkdir ?? ((p) => fs.mkdirSync(p, { recursive: true }));
+    try {
+        if (content === null) {
+            rm(abs);
+            return { ok: true, status: "removed" };
+        }
+        mkdir(path.dirname(abs));
+        writeFile(abs, content);
+        return { ok: true, status: "reverted" };
+    }
+    catch (error) {
+        return { ok: false, status: "rejected", error: error instanceof Error ? error.message : String(error) };
+    }
+}

package/dist/session/turn-watchdog.js

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: FSL-1.1-ALv2
+// Copyright (c) 2026 Petter André Sjulstad
+/** One hour keeps legitimate deep coding turns viable while bounding the
+ * default failure/cost window. Automations may choose a lower timeout. */
+export const DEFAULT_TURN_TIMEOUT_MS = 60 * 60 * 1000;
+export const MAX_TURN_TIMEOUT_MS = 24 * 60 * 60 * 1000;
+/** Parse BIVY_TURN_TIMEOUT_MS. Explicit 0 is the documented trusted-workflow
+ * escape hatch; malformed/negative values fall back safely instead of silently
+ * disabling the watchdog. Very large values are capped to one day. */
+export function configuredTurnTimeoutMs(value = process.env.BIVY_TURN_TIMEOUT_MS) {
+    if (value === undefined || value.trim() === "")
+        return DEFAULT_TURN_TIMEOUT_MS;
+    const parsed = Number(value);
+    if (parsed === 0)
+        return 0;
+    if (!Number.isFinite(parsed) || parsed < 0)
+        return DEFAULT_TURN_TIMEOUT_MS;
+    return Math.min(MAX_TURN_TIMEOUT_MS, Math.max(1_000, Math.floor(parsed)));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "type": "module",
   "license": "FSL-1.1-ALv2",
   "description": "Run coding agents on machines you own. Source-available, self-hostable agent workspace.",
@@ -37,6 +37,7 @@
     "express": "^5.2.1",
     "node-pty": "^1.1.0",
     "typebox": "^1.3.6",
+    "undici": "8.9.0",
     "ws": "^8.21.1",
     "zod": "^4.0.0"
   },
@@ -44,8 +45,10 @@
     "@hono/node-server": "2.0.12",
     "@modelcontextprotocol/sdk": "1.30.0",
     "@earendil-works/pi-coding-agent": {
-      "brace-expansion": "5.0.9"
+      "brace-expansion": "5.0.9",
+      "undici": "8.9.0"
     },
-    "brace-expansion": "5.0.9"
+    "brace-expansion": "5.0.9",
+    "undici": "8.9.0"
   }
 }