@bivy/bivy 0.17.2-staging.4 → 0.17.2-staging.6

package/dist/command-launch.js

@@ -1,12 +1,57 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 // Copyright (c) 2026 Petter André Sjulstad
+import { spawn } from "node:child_process";
+import os from "node:os";
+import { loadPty } from "./terminal.js";
+const signalNames = new Map(Object.entries(os.constants.signals).map(([name, num]) => [num, name]));
 /**
  * Keep terminal semantics opt-in for short-lived commands. Native interactive
- * commands must set requiresTty; ordinary commands stay on direct pipes and do
- * not pay for a Python PTY relay.
+ * commands must set requiresTty and run under node-pty (the same dependency the
+ * interactive terminals use); ordinary commands stay on direct pipes.
  */
-export function commandLaunch(command, args, requiresTty, pythonCommand, ptyRunnerScript) {
-    return requiresTty
-        ? { command: pythonCommand, args: [ptyRunnerScript, command, ...args], usesPty: true }
-        : { command, args: [...args], usesPty: false };
+export function launchCommand(spec, requiresTty, handlers) {
+    return requiresTty ? launchPty(spec, handlers) : launchPipes(spec, handlers);
+}
+function launchPipes({ command, args, cwd, env }, handlers) {
+    const child = spawn(command, args, { cwd, env });
+    child.stdout.on("data", (data) => handlers.onOutput("stdout", String(data)));
+    child.stderr.on("data", (data) => handlers.onOutput("stderr", String(data)));
+    child.on("error", handlers.onError);
+    child.on("exit", handlers.onExit);
+    return {
+        usesPty: false,
+        write: (text) => child.stdin.write(text),
+        interrupt: () => child.kill("SIGINT"),
+    };
+}
+function launchPty({ command, args, cwd, env }, handlers) {
+    let proc;
+    try {
+        proc = loadPty().spawn(command, args, { name: env.TERM ?? "xterm-256color", cols: 120, rows: 40, cwd, env });
+    }
+    catch (error) {
+        // Match child_process: a launch failure is reported asynchronously, not thrown.
+        queueMicrotask(() => handlers.onError(error instanceof Error ? error : new Error(String(error))));
+        return { usesPty: true, write: () => { }, interrupt: () => { } };
+    }
+    // A PTY merges stdout and stderr into one stream.
+    proc.onData((text) => handlers.onOutput("stdout", text));
+    proc.onExit(({ exitCode, signal }) => handlers.onExit(signal ? null : exitCode, signal ? signalNames.get(signal) ?? null : null));
+    return {
+        usesPty: true,
+        write: (text) => proc.write(text),
+        interrupt: () => {
+            // node-pty makes the child a session (and process-group) leader, so a
+            // negative pid reaches anything it forked too.
+            try {
+                process.kill(-proc.pid, "SIGINT");
+            }
+            catch {
+                try {
+                    proc.kill("SIGINT");
+                }
+                catch { /* already exited */ }
+            }
+        },
+    };
 }

package/dist/runtime/process.js

@@ -16,8 +16,8 @@ import { withExactCapabilitySurface } from "./types.js";
  * worker processes) die with it instead of being orphaned. Relies on the child
  * having been spawned `detached` (making it its own process-group leader, POSIX
  * only — see the spawn() call in ProcessSession.prompt); `process.kill(-pid,
- * signal)` then targets the whole group, mirroring `pty-runner.py`'s
- * `os.killpg`. Falls back to killing just the direct child on Windows (no
+ * signal)` then targets the whole group, as the PTY command launcher does
+ * (src/command-launch.ts). Falls back to killing just the direct child on Windows (no
  * negative-pid group kill there) or if the group is already gone.
  */
 function killProcessGroup(child, signal) {

package/dist/server.js

@@ -91,7 +91,7 @@ import { hostedCustodyNode } from "./hosted-custody.js";
 import { PolicyEngine } from "./policy/policy-engine.js";
 import { SessionAllowRules } from "./policy/session-allow.js";
 import { TerminalManager } from "./terminal.js";
-import { commandLaunch } from "./command-launch.js";
+import { launchCommand } from "./command-launch.js";
 import { listMultiplexerSessions } from "./multiplexer.js";
 import { createWorktree, removeWorktree, gitRepoRoot } from "./worktree.js";
 import { HarnessManager } from "./harness/manager.js";
@@ -344,10 +344,6 @@ const worktreeCleanupSweepMs = Math.max(60 * 60 * 1000, Math.min(worktreeRetenti
 // Native Pi commands run the operator-installed agent. Bivy does not substitute
 // a private TUI; BIVY_PI_COMMAND is an explicit path override for managed nodes.
 const piCommand = process.env.BIVY_PI_COMMAND?.trim() || "pi";
-const ptyRunnerScript = process.env.BIVY_PTY_RUNNER ?? (fs.existsSync(path.join(assetRoot, "src", "pty-runner.py"))
-    ? path.join(assetRoot, "src", "pty-runner.py")
-    : path.join(assetRoot, "dist", "pty-runner.py"));
-const pythonCommand = process.env.PYTHON ?? "python3";
 // Per-process secret gating the loopback bootstrap endpoint. Published to a
 // 0600 file (and stdout) so only the launching user can read it.
 const bootstrapSecret = randomBytes(32).toString("base64url");
@@ -1744,8 +1740,10 @@ function referencedAttachmentHashes() {
     const ids = new Set(metadata.listSessions().map((session) => session.id));
     for (const record of new Set(openSessions.values()))
         ids.add(record.id);
+    // `scan`, not `entries`: this visits every session ever created, and must not pin
+    // each one's full log in the event-log cache.
     for (const id of ids) {
-        for (const entry of eventLog.entries(id)) {
+        for (const entry of eventLog.scan(id, ["attachment", "outbound-attachment", "inline-image"])) {
             if (entry.bivyKind === "attachment")
                 for (const ref of entry.refs)
                     hashes.add(ref.hash);
@@ -5617,26 +5615,19 @@ function runNativeCommand(command) {
         NO_COLOR: "1",
     };
     // Native commands (login/model/config/etc.) need a TTY for prompts and the
-    // terminal UI. Everything else uses ordinary pipes: this avoids an extra
-    // Python process and PTY relay for non-interactive commands while preserving
-    // the old behavior for commands that genuinely require terminal semantics.
-    const launch = commandLaunch(command.spawn.command, command.spawn.args, command.spawn.requiresTty, pythonCommand, ptyRunnerScript);
-    const child = spawn(launch.command, launch.args, { cwd: repoRoot, env });
-    commandProcesses.set(runId, child);
-    child.stdout.on("data", (data) => {
-        broadcast({ type: "command.output", runId, command: command.name, stream: "stdout", text: stripAnsi(String(data)) });
-    });
-    child.stderr.on("data", (data) => {
-        broadcast({ type: "command.output", runId, command: command.name, stream: "stderr", text: stripAnsi(String(data)) });
-    });
-    child.on("error", (error) => {
-        commandProcesses.delete(runId);
-        broadcast({ type: "command.error", runId, command: command.name, error: String(error?.stack ?? error) });
-    });
-    child.on("exit", (code, signal) => {
-        commandProcesses.delete(runId);
-        broadcast({ type: "command.exited", runId, command: command.name, code, signal });
+    // terminal UI, so they run under a PTY; everything else uses ordinary pipes.
+    const handle = launchCommand({ command: command.spawn.command, args: command.spawn.args, cwd: repoRoot, env }, command.spawn.requiresTty, {
+        onOutput: (stream, text) => broadcast({ type: "command.output", runId, command: command.name, stream, text: stripAnsi(text) }),
+        onError: (error) => {
+            commandProcesses.delete(runId);
+            broadcast({ type: "command.error", runId, command: command.name, error: String(error?.stack ?? error) });
+        },
+        onExit: (code, signal) => {
+            commandProcesses.delete(runId);
+            broadcast({ type: "command.exited", runId, command: command.name, code, signal });
+        },
     });
+    commandProcesses.set(runId, handle);
     return { ok: true, runId };
 }
 const guardianInterceptorImpl = async ({ sessionId, toolName, input, signal }) => {
@@ -11085,14 +11076,14 @@ app.post("/api/commands/:runId/input", (req, res) => {
     const child = commandProcesses.get(req.params.runId);
     if (!child)
         return res.status(404).json({ error: "No active command process" });
-    child.stdin.write(`${String(req.body?.text ?? "")}\n`);
+    child.write(`${String(req.body?.text ?? "")}\n`);
     res.json({ ok: true });
 });
 app.post("/api/commands/:runId/terminate", (req, res) => {
     const child = commandProcesses.get(req.params.runId);
     if (!child)
         return res.status(404).json({ error: "No active command process" });
-    child.kill("SIGINT");
+    child.interrupt();
     res.json({ ok: true });
 });
 // On-demand "update GitHub status" for one session: force `refreshPullRequests`

package/dist/session/event-log.js

@@ -397,12 +397,12 @@ export function baseReplay(entries) {
     }
     return base;
 }
-function parseLogDetailed(body) {
+function parseLogDetailed(body, keep = () => true) {
     const records = [];
     let malformedLines = 0;
     for (const line of body.split("\n")) {
         const trimmed = line.trim();
-        if (!trimmed)
+        if (!trimmed || !keep(trimmed))
             continue;
         try {
             const value = JSON.parse(trimmed);
@@ -429,6 +429,10 @@ export function parseLog(body) {
  * `throttleMs` per session (a burst of same-id deltas within a window collapses to
  * one appended line). Durability at boundaries is explicit `flush()` (turn-end,
  * close, delete, shutdown), mirroring `SidecarStore`.
+ *
+ * The in-memory copy of flushed records is an LRU capped at `maxCachedBytes`
+ * (measured as log-file size): an evicted session simply re-reads its file on next
+ * use, so memory tracks the sessions in use, not the node's whole history.
  */
 export class EventLog {
     dir;
@@ -436,7 +440,10 @@ export class EventLog {
     redact;
     throttleMs;
     onIssue;
+    maxCachedBytes;
     disk = new Map();
+    diskBytes = new Map();
+    cachedBytes = 0;
     pending = new Map();
     timers = new Map();
     lastFlush = new Map();
@@ -446,12 +453,13 @@ export class EventLog {
     // on first use of a session after a restart.
     baseKeys = new Map();
     lastIssue;
-    constructor(dir, pathFor, redact = (t) => t, throttleMs = 500, onIssue = (issue) => console.error(`[event-log] ${issue.operation} failed for ${issue.sessionId}: ${issue.message}`)) {
+    constructor(dir, pathFor, redact = (t) => t, throttleMs = 500, onIssue = (issue) => console.error(`[event-log] ${issue.operation} failed for ${issue.sessionId}: ${issue.message}`), maxCachedBytes = 64 * 1024 * 1024) {
         this.dir = dir;
         this.pathFor = pathFor;
         this.redact = redact;
         this.throttleMs = throttleMs;
         this.onIssue = onIssue;
+        this.maxCachedBytes = maxCachedBytes;
     }
     report(id, operation, error) {
         const issue = {
@@ -493,23 +501,64 @@ export class EventLog {
         }
         return { files, bytes };
     }
-    load(id) {
-        const cached = this.disk.get(id);
-        if (cached)
-            return cached;
-        let data = [];
+    /** Read + parse a session's log file (lines passing `keep`), reporting problems. */
+    readLog(id, keep) {
         try {
-            const parsed = parseLogDetailed(fs.readFileSync(this.pathFor(id), "utf8"));
-            data = parsed.records;
+            const body = fs.readFileSync(this.pathFor(id), "utf8");
+            const parsed = parseLogDetailed(body, keep);
             if (parsed.malformedLines > 0)
                 this.report(id, "parse", new Error(`${parsed.malformedLines} malformed record(s); valid history was recovered`));
+            return { records: parsed.records, bytes: body.length };
         }
         catch (error) {
             if (error?.code !== "ENOENT")
                 this.report(id, "read", error);
+            return { records: [], bytes: 0 };
+        }
+    }
+    load(id) {
+        const cached = this.disk.get(id);
+        if (cached) {
+            // Re-insert to mark most-recently-used (Map iterates in insertion order).
+            this.disk.delete(id);
+            this.disk.set(id, cached);
+            return cached;
         }
-        this.disk.set(id, data);
-        return data;
+        const { records, bytes } = this.readLog(id);
+        this.cache(id, records, bytes);
+        return records;
+    }
+    /** Store a session's flushed records, then evict least-recently-used others past the cap. */
+    cache(id, records, bytes) {
+        this.uncache(id);
+        this.disk.set(id, records);
+        this.diskBytes.set(id, bytes);
+        this.cachedBytes += bytes;
+        for (const oldest of this.disk.keys()) {
+            if (this.cachedBytes <= this.maxCachedBytes || oldest === id)
+                break;
+            this.uncache(oldest);
+        }
+    }
+    uncache(id) {
+        this.cachedBytes -= this.diskBytes.get(id) ?? 0;
+        this.diskBytes.delete(id);
+        this.disk.delete(id);
+    }
+    /**
+     * The session's records of the given kinds, read WITHOUT caching the log. For
+     * whole-store sweeps (attachment GC) that visit every session, where `load` would
+     * pin every log in memory. Uses the cached copy when there is one, and always
+     * includes pending records so unflushed writes are never missed. Off the cache only
+     * candidate lines are parsed: those naming a wanted kind, plus torn lines (not
+     * ending in `}`) so a truncated write is still reported and callers can fail closed.
+     */
+    scan(id, kinds) {
+        const wanted = new Set(kinds);
+        const markers = kinds.map((kind) => `"bivyKind":${JSON.stringify(kind)}`);
+        const flushed = this.disk.get(id) ?? this.readLog(id, (line) => !line.endsWith("}") || markers.some((m) => line.includes(m))).records;
+        const pending = this.pending.get(id)?.values() ?? [];
+        return [...flushed, ...pending].filter((record) => wanted.has(record.bivyKind));
     }
     /** Allocate a unique synthetic coalescing key (for id-less records). */
     syntheticKey(id) {
@@ -681,9 +730,16 @@ export class EventLog {
         const lines = [...batch.values()];
         try {
             fs.mkdirSync(this.dir, { recursive: true });
-            fs.appendFileSync(this.pathFor(id), this.redact(lines.map((e) => JSON.stringify(e)).join("\n") + "\n"));
-            const disk = this.load(id);
-            disk.push(...lines);
+            const body = this.redact(lines.map((e) => JSON.stringify(e)).join("\n") + "\n");
+            fs.appendFileSync(this.pathFor(id), body);
+            // Extend the cached copy only if it is still cached: an evicted session re-reads
+            // the file (which now holds these lines) on next use, so loading here would
+            // double-count them.
+            const cached = this.disk.get(id);
+            if (cached) {
+                cached.push(...lines);
+                this.cache(id, cached, (this.diskBytes.get(id) ?? 0) + body.length);
+            }
             batch.clear();
             this.lastFlush.set(id, Date.now());
         }
@@ -708,10 +764,10 @@ export class EventLog {
         }
         this.pending.delete(id);
         this.baseKeys.delete(id);
-        this.disk.set(id, copy);
+        const body = copy.length ? copy.map((e) => JSON.stringify(e)).join("\n") + "\n" : "";
+        this.cache(id, copy, body.length);
         try {
             fs.mkdirSync(this.dir, { recursive: true });
-            const body = copy.length ? copy.map((e) => JSON.stringify(e)).join("\n") + "\n" : "";
             fs.writeFileSync(this.pathFor(id), this.redact(body));
             this.lastFlush.set(id, Date.now());
         }
@@ -726,7 +782,7 @@ export class EventLog {
             clearTimeout(timer);
             this.timers.delete(id);
         }
-        this.disk.delete(id);
+        this.uncache(id);
         this.pending.delete(id);
         this.lastFlush.delete(id);
         this.counters.delete(id);

package/dist/terminal.js

@@ -6,7 +6,7 @@ import { createRequire } from "node:module";
 import path from "node:path";
 import { depCacheEnv } from "./harness/dep-cache.js";
 let ptyModule;
-function loadPty() {
+export function loadPty() {
     if (ptyModule)
         return ptyModule;
     if (ptyModule === null) {

package/package.json

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

package/dist/pty-runner.py

@@ -1,95 +0,0 @@
-#!/usr/bin/env python3
-"""Run a command under a pseudo-terminal while relaying stdio over pipes."""
-
-import os
-import pty
-import select
-import signal
-import subprocess
-import sys
-
-
-def main() -> int:
-    if len(sys.argv) < 2:
-        print("usage: pty-runner.py command [args...]", file=sys.stderr)
-        return 2
-
-    master_fd, slave_fd = pty.openpty()
-    env = os.environ.copy()
-    env.setdefault("TERM", "xterm-256color")
-
-    proc = subprocess.Popen(
-        sys.argv[1:],
-        stdin=slave_fd,
-        stdout=slave_fd,
-        stderr=slave_fd,
-        env=env,
-        close_fds=True,
-        start_new_session=True,
-    )
-    os.close(slave_fd)
-
-    def forward_signal(signum, _frame):
-        try:
-            os.killpg(proc.pid, signum)
-        except ProcessLookupError:
-            pass
-
-    signal.signal(signal.SIGINT, forward_signal)
-    signal.signal(signal.SIGTERM, forward_signal)
-
-    stdin_fd = sys.stdin.fileno()
-    stdout_fd = sys.stdout.fileno()
-    stdin_open = True
-
-    while True:
-        read_fds = [master_fd]
-        if stdin_open:
-            read_fds.append(stdin_fd)
-
-        readable, _, _ = select.select(read_fds, [], [], 0.1)
-
-        if master_fd in readable:
-            try:
-                data = os.read(master_fd, 8192)
-            except OSError:
-                data = b""
-            if not data:
-                break
-            os.write(stdout_fd, data)
-
-        if stdin_open and stdin_fd in readable:
-            data = os.read(stdin_fd, 8192)
-            if not data:
-                stdin_open = False
-            else:
-                try:
-                    os.write(master_fd, data)
-                except OSError:
-                    break
-
-        if proc.poll() is not None:
-            # Drain any final PTY output.
-            while True:
-                readable, _, _ = select.select([master_fd], [], [], 0)
-                if not readable:
-                    break
-                try:
-                    data = os.read(master_fd, 8192)
-                except OSError:
-                    break
-                if not data:
-                    break
-                os.write(stdout_fd, data)
-            break
-
-    try:
-        os.close(master_fd)
-    except OSError:
-        pass
-
-    return proc.wait()
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())