@bivy/bivy 0.17.2-staging.5 → 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");
@@ -5619,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 }) => {
@@ -11087,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/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.5",
+  "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())