@bivy/bivy 0.17.3-staging.9 → 0.18.0

package/dist/session/run-terminal.js

@@ -98,6 +98,44 @@ export function createRunTerminals(deps) {
         }
         return false;
     }
+    // One conversation, one writer. A run pinned to a session that is also open as
+    // a chat owns it while the PTY lives: the chat locks (and says so on every
+    // device), and when the PTY ends the chat reloads what the terminal wrote.
+    function bindRun(record, termId) {
+        record.tuiTermId = termId;
+        void deps.sessionTerminalsRecord(record.id, { termId }).catch(() => { });
+        deps.broadcastTuiState(record.id, true);
+    }
+    function releaseRun(record, termId) {
+        if (record.tuiTermId !== termId)
+            return;
+        record.tuiTermId = undefined;
+        void deps.sessionTerminalsForget(record.id).catch(() => { });
+        record.tuiRefreshing = true;
+        deps.broadcastTuiState(record.id, false);
+        void deps.refreshRecordAfterTui(record);
+    }
+    function adoptLiveRun(record) {
+        if (record.tuiTermId)
+            return;
+        for (const id of runTerminals) {
+            const pinned = terminals.meta(id)?.sessionId;
+            if (pinned && (pinned === record.id || pinned === record.sessionFile)) {
+                bindRun(record, id);
+                return;
+            }
+        }
+    }
+    /** Stop a run because its session is continuing as a chat. Tells every viewer
+     *  where the session went first, so a terminal attached elsewhere (a laptop's
+     *  `bivy run`) can offer to take it back instead of just printing "ended". */
+    function handRunToChat(termId, sessionId) {
+        deps.broadcast({ type: "terminal.closed", termId, reason: "chat", sessionId });
+        terminals.close(termId);
+        runTerminals.delete(termId);
+        runViewers.delete(termId);
+        deps.broadcast({ type: "terminal.closed", termId });
+    }
     async function runTerminalList() {
         const runs = terminals.list((meta) => meta.kind === "run").filter((t) => runTerminals.has(t.id));
         let saved = [];
@@ -218,6 +256,18 @@ export function createRunTerminals(deps) {
             emit({ type: "terminal.error", error: `Too many run terminals open (${runTerminals.size}/${deps.maxRunTerminals}). Close one (e.g. 'bivy kill') or raise BIVY_MAX_RUN_TERMINALS.` });
             return undefined;
         }
+        const owner = spec.sessionId && !spec.mux ? deps.findOpenSession(spec.sessionId) : undefined;
+        if (owner?.tuiTermId && runTerminals.has(owner.tuiTermId)) {
+            // Already open in a terminal: join it rather than start a second writer.
+            if (spec.clientId && (spec.cols !== undefined || spec.rows !== undefined))
+                terminals.setClientSize(owner.tuiTermId, spec.clientId, spec.cols || 80, spec.rows || 24);
+            emit({ type: "terminal.attached", termId: owner.tuiTermId, data: terminals.snapshot(owner.tuiTermId) ?? "" });
+            return owner.tuiTermId;
+        }
+        if (owner && deps.sessionBusy(owner)) {
+            emit({ type: "terminal.error", sessionId: owner.id, error: "This session is mid-turn in chat. Stop or finish the turn, then open it in the terminal." });
+            return undefined;
+        }
         const active = deps.getActiveSession();
         const workspace = spec.workspace || active?.session?.cwd || active?.worktree?.path || active?.workspace || deps.defaultWorkspace;
         // Agent-owned integrations keep their native login untouched. Only an
@@ -260,6 +310,17 @@ export function createRunTerminals(deps) {
                     clearRunIdleNotify(id);
                     deps.broadcast({ type: "terminal.exit", termId: id, code });
                     deps.broadcast({ type: "terminal.closed", termId: id });
+                    // A run that owned an open chat hands the conversation back to it; the
+                    // chat keeps its own record, so none of the run bookkeeping below applies.
+                    const bound = spec.sessionId ? deps.findOpenSession(spec.sessionId) : undefined;
+                    if (bound?.tuiTermId === id) {
+                        releaseRun(bound, id);
+                        try {
+                            deps.sessionListChanged();
+                        }
+                        catch { /* best-effort */ }
+                        return;
+                    }
                     if (!spec.mux) {
                         // The durable record of this run, in order of fidelity: the agent's
                         // own session (pinned at launch), the session discovered in the
@@ -315,7 +376,9 @@ export function createRunTerminals(deps) {
                 },
             });
             runTerminals.add(id);
-            if (spec.sessionId && spec.agent && !spec.mux) {
+            if (owner)
+                bindRun(owner, id);
+            if (spec.sessionId && spec.agent && !spec.mux && !owner) {
                 const runtimeId = TAKEOVER_RUNTIME_BY_AGENT[spec.agent] ?? spec.agent;
                 try {
                     deps.upsertSessionMetadata({ id: spec.sessionId, runtimeId, agentName: spec.agent, workspace, name: name || undefined, source: "cli", status: "working" });
@@ -366,6 +429,13 @@ export function createRunTerminals(deps) {
                 : undefined;
         if (!entry)
             return { ok: false, status: 404, error: "No matching live run-terminal." };
+        // The chat already exists (the terminal was opened from it, or joined it):
+        // stopping the PTY is the whole handoff — its exit reloads the chat.
+        const owner = entry.meta.sessionId ? deps.findOpenSession(entry.meta.sessionId) : undefined;
+        if (owner?.tuiTermId === entry.id) {
+            handRunToChat(entry.id, owner.id);
+            return { ok: true, sessionId: owner.id, runtimeId: owner.runtimeId ?? "" };
+        }
         const agent = entry.meta.agent ?? "";
         const runtimeId = TAKEOVER_RUNTIME_BY_AGENT[agent];
         if (!runtimeId)
@@ -385,10 +455,7 @@ export function createRunTerminals(deps) {
         // second agent process until the next prompt. If preparation fails, the
         // terminal remains live and the user loses nothing.
         const record = await deps.createSession(workspace, pinned, { runtimeId, makeActive: true, source: "takeover" });
-        terminals.close(entry.id);
-        runTerminals.delete(entry.id);
-        runViewers.delete(entry.id);
-        deps.broadcast({ type: "terminal.closed", termId: entry.id });
+        handRunToChat(entry.id, record.id);
         const resumeCommand = RESUME_CLI_BY_AGENT[agent]?.(pinned);
         return { ok: true, sessionId: record.id, runtimeId, resumeCommand };
     }
@@ -473,84 +540,61 @@ export function createRunTerminals(deps) {
                 return true;
             }
             case "terminal.open.tui": {
+                // "Open in terminal" for a chat session: its runtime's own interactive
+                // TUI, resuming the same conversation, as a daemon-owned run pinned to the
+                // session — so it outlives the device that opened it, every device can
+                // watch it, and the chat stays locked until it ends (single writer).
                 void (async () => {
-                    const record = deps.resolveSession(msg.sessionId);
+                    const record = typeof msg.sessionId === "string" && msg.sessionId ? deps.findOpenSession(msg.sessionId) : undefined;
                     if (!record) {
                         emit({ type: "terminal.error", error: "Session not found for TUI." });
                         return;
                     }
-                    if (record.tuiTermId) {
-                        const snapshot = terminals.snapshot(record.tuiTermId);
-                        if (snapshot != null) {
-                            owned.add(record.tuiTermId);
-                            if (typeof msg.cols !== "undefined" || typeof msg.rows !== "undefined")
-                                terminals.setClientSize(record.tuiTermId, clientId, Number(msg.cols) || 80, Number(msg.rows) || 24);
-                            emit({ type: "terminal.attached", termId: record.tuiTermId, data: snapshot });
-                            return;
-                        }
-                    }
-                    if (deps.sessionBusy(record)) {
+                    const cols = Number(msg.cols) || undefined;
+                    const rows = Number(msg.rows) || undefined;
+                    const live = record.tuiTermId && runTerminals.has(record.tuiTermId) ? record.tuiTermId : undefined;
+                    if (!live && deps.sessionBusy(record)) {
                         emit({ type: "terminal.error", sessionId: record.id, error: "Finish or stop the current turn before opening the TUI." });
                         return;
                     }
-                    let spec;
-                    try {
-                        spec = record.session.interactiveTuiCommand ? await record.session.interactiveTuiCommand() : null;
-                    }
-                    catch (error) {
-                        emit({ type: "terminal.error", sessionId: record.id, error: error instanceof Error ? error.message : String(error) });
-                        return;
-                    }
-                    if (!spec) {
-                        emit({ type: "terminal.error", sessionId: record.id, error: "This runtime has no interactive TUI available on this node." });
-                        return;
-                    }
-                    const workspace = record.session.cwd || record.worktree?.path || record.workspace;
-                    try {
-                        const id = terminals.open({
-                            workspace,
-                            command: spec.command,
-                            args: spec.args,
-                            env: spec.env,
-                            cols: Number(msg.cols) || undefined,
-                            rows: Number(msg.rows) || undefined,
-                            clientId,
-                            onData: (data) => emit({ type: "terminal.output", termId: id, data }),
-                            onExit: (code) => {
-                                owned.delete(id);
-                                if (record.tuiTermId === id) {
-                                    record.tuiTermId = undefined;
-                                    void deps.sessionTerminalsForget(record.id).catch(() => { });
-                                    record.tuiRefreshing = true;
-                                    deps.broadcastTuiState(record.id, false);
-                                    void deps.refreshRecordAfterTui(record);
-                                }
-                                emit({ type: "terminal.exit", termId: id, code });
-                            },
-                        });
-                        owned.add(id);
-                        record.tuiTermId = id;
-                        void deps.sessionTerminalsRecord(record.id, { termId: id }).catch(() => { });
-                        emit({ type: "terminal.opened", termId: id, workspace, sessionId: record.id, mode: "tui" });
-                        deps.broadcastTuiState(record.id, true);
-                    }
-                    catch (error) {
-                        emit({ type: "terminal.error", sessionId: record.id, error: error instanceof Error ? error.message : String(error) });
+                    let spec = null;
+                    if (!live) {
+                        try {
+                            spec = record.session.interactiveTuiCommand ? await record.session.interactiveTuiCommand() : null;
+                        }
+                        catch (error) {
+                            emit({ type: "terminal.error", sessionId: record.id, error: error instanceof Error ? error.message : String(error) });
+                            return;
+                        }
+                        if (!spec) {
+                            emit({ type: "terminal.error", sessionId: record.id, error: "This runtime has no interactive TUI available on this node." });
+                            return;
+                        }
                     }
+                    const id = await openRunTerminal({
+                        command: spec?.command ?? "",
+                        args: spec?.args ?? [],
+                        env: spec?.env,
+                        name: record.session.getName() || undefined,
+                        workspace: record.session.cwd || record.worktree?.path || record.workspace,
+                        sessionId: record.id,
+                        cols,
+                        rows,
+                        clientId,
+                    }, emit);
+                    if (id)
+                        viewRun?.(id);
                 })();
                 return true;
             }
             case "terminal.close.tui": {
-                const record = deps.resolveSession(msg.sessionId);
+                // "Use chat": hand the session's terminal back to its chat.
+                const record = typeof msg.sessionId === "string" && msg.sessionId ? deps.findOpenSession(msg.sessionId) : undefined;
                 const termId = record?.tuiTermId;
-                if (termId) {
-                    terminals.close(termId);
-                    owned.delete(termId);
-                    clearBellNotify(termId);
-                }
-                else if (record) {
+                if (record && termId && runTerminals.has(termId))
+                    handRunToChat(termId, record.id);
+                else if (record)
                     deps.broadcastTuiState(record.id, false);
-                }
                 return true;
             }
             case "terminal.attach": {
@@ -607,5 +651,5 @@ export function createRunTerminals(deps) {
                 return false;
         }
     }
-    return { runTerminalList, openRunTerminal, takeoverRunTerminal, handleTerminalMessage, addRunViewer, dropRunViewer, hasRunTerminal, hasLiveRunForSession };
+    return { runTerminalList, openRunTerminal, takeoverRunTerminal, handleTerminalMessage, addRunViewer, dropRunViewer, hasRunTerminal, hasLiveRunForSession, adoptLiveRun };
 }

package/dist/session/session-new-dedupe.js

@@ -38,5 +38,5 @@ export function createSessionNewDedupe(options = {}) {
         });
         return p;
     }
-    return { run, size: () => inflight.size };
+    return { run, has: (requestId) => Boolean(requestId && inflight.has(requestId)), size: () => inflight.size };
 }

package/dist/terminal.js

@@ -37,6 +37,14 @@ export function loadPty() {
 // and the relay closed the socket with "Rate limit exceeded" the moment a
 // phone/app attached to a live `bivy run` terminal.
 const OUTPUT_FLUSH_MS = 16;
+/**
+ * Closing sends a hangup (node-pty's kill, what closing a terminal window
+ * sends). A shell hung up while it's still starting can miss it and live on,
+ * holding the PTY: a leaked shell on the machine, and a handle that keeps Node
+ * from exiting. Until it exits, these follow (Unix; ms after close): the hangup
+ * again, then a kill of its whole process group.
+ */
+const CLOSE_FOLLOW_UPS = [[250, "SIGHUP"], [1000, "SIGKILL"]];
 /**
  * How much recent output to retain per terminal for scrollback replay on
  * reconnect. A phone that backgrounds the PWA (or drops its network) reattaches
@@ -385,6 +393,21 @@ export class TerminalManager {
         catch {
             // already gone
         }
+        if (process.platform === "win32")
+            return;
+        let exited = false;
+        void entry.exitPromise.then(() => { exited = true; });
+        for (const [delay, signal] of CLOSE_FOLLOW_UPS) {
+            setTimeout(() => {
+                if (exited)
+                    return;
+                // The PTY's child leads its own process group: a kill takes its jobs too.
+                try {
+                    process.kill(signal === "SIGKILL" ? -entry.proc.pid : entry.proc.pid, signal);
+                }
+                catch { /* already gone */ }
+            }, delay).unref();
+        }
     }
     has(id) {
         return this.terminals.has(id);

package/dist/worktree.js

@@ -4,6 +4,7 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import fs from "node:fs";
 import path from "node:path";
+import { gitNonInteractiveEnv } from "./git-auth.js";
 import { cowProvisionDeps, provisionDepsByInstall } from "./worktree-provision.js";
 const exec = promisify(execFile);
 /** Slugify arbitrary text into a safe git branch / directory segment. */
@@ -86,7 +87,7 @@ export async function createWorktree(opts) {
     const localExists = await refExists(repoRoot, `refs/heads/${branch}`);
     const remoteExists = !localExists && await refExists(repoRoot, `refs/remotes/origin/${branch}`);
     if (localExists) {
-        await exec("git", ["-C", repoRoot, "worktree", "add", wtPath, branch]);
+        await worktreeAdd(repoRoot, [wtPath, branch]);
     }
     else {
         if (remoteExists)
@@ -98,10 +99,10 @@ export async function createWorktree(opts) {
             // Empty repo (e.g. a freshly created GitHub repo with no commits): HEAD is
             // unborn, so it can't seed a worktree. Start the branch as an orphan —
             // the session's first commit becomes the repo's root commit.
-            await exec("git", ["-C", repoRoot, "worktree", "add", "--orphan", "-b", branch, wtPath]);
+            await worktreeAdd(repoRoot, ["--orphan", "-b", branch, wtPath]);
         }
         else {
-            await exec("git", ["-C", repoRoot, "worktree", "add", "-b", branch, wtPath, base]);
+            await worktreeAdd(repoRoot, ["-b", branch, wtPath, base]);
         }
     }
     // Opportunistically reuse a sibling worktree's installed deps (node_modules,
@@ -120,6 +121,42 @@ export async function createWorktree(opts) {
     }
     return { path: wtPath, branch, repoRoot };
 }
+/**
+ * `git worktree add`, non-interactively. Managed repos are partial clones
+ * (`--filter=blob:none`), so the checkout lazily fetches blobs from origin and
+ * needs credentials. The daemon has no TTY: without GIT_TERMINAL_PROMPT=0 a
+ * credential miss falls through to git's terminal prompt, which fails with the
+ * cryptic "could not read Username …: Device not configured" (macOS ENXIO).
+ */
+async function worktreeAdd(repoRoot, args) {
+    try {
+        await exec("git", ["-C", repoRoot, "worktree", "add", ...args], { env: gitNonInteractiveEnv() });
+    }
+    catch (error) {
+        const stderr = String(error.stderr ?? "");
+        const friendly = describeWorktreeAddError(stderr);
+        if (friendly)
+            throw new Error(friendly, { cause: error });
+        throw error;
+    }
+}
+/**
+ * Turn a `git worktree add` failure caused by the lazy blob fetch into a message
+ * a person can act on, with git's output kept below as details. Returns
+ * undefined for any other failure (the raw error is already specific).
+ */
+export function describeWorktreeAddError(stderr) {
+    const detail = stderr.trim();
+    const auth = /could not read (Username|Password)|terminal prompts disabled|Authentication failed|Invalid username or (password|token)|Permission to .* denied/i.test(detail);
+    const promisor = /from promisor remote/i.test(detail);
+    if (auth) {
+        return `Couldn't create the session's worktree: git had to download repository files from GitHub, but no GitHub credentials were available on this machine. Reconnect GitHub for this machine in Bivy, then start the session again.\n\n${detail}`;
+    }
+    if (promisor) {
+        return `Couldn't create the session's worktree: git had to download repository files from the remote and the download failed. Check this machine's network connection, then start the session again.\n\n${detail}`;
+    }
+    return undefined;
+}
 /** True if `ref` (a fully-qualified ref) resolves in the repo. */
 async function refExists(repoRoot, ref) {
     try {

package/package.json

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