@bivy/bivy 0.17.2 → 0.17.3-staging.10

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
@@ -238,7 +288,7 @@ export function createRunTerminals(deps) {
                 workspace,
                 command: spec.command,
                 args: spec.args,
-                env: credentialEnv,
+                env: { ...credentialEnv, ...spec.env },
                 cols: spec.cols,
                 rows: spec.rows,
                 clientId: spec.clientId,
@@ -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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bivy/bivy",
-  "version": "0.17.2",
+  "version": "0.17.3-staging.10",
   "type": "module",
   "license": "AGPL-3.0-only",
   "description": "Run coding agents on machines you own. Open-source, self-hostable agent workspace.",
@@ -39,6 +39,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.30.0",
+    "@novnc/novnc": "1.7.0",
     "brace-expansion": "5.0.12",
     "express": "^5.2.1",
     "express-rate-limit": "^8.7.0",