@bivy/bivy 0.20.6-staging.1 → 0.20.6-staging.3

package/bin/bivy.mjs

@@ -2691,7 +2691,14 @@ blocked, or need the user to look at something. --json prints
   const body = await res.json().catch(() => ({}));
   if (!res.ok) return fail(sessionHttpError("Notify", res.status, body));
   if (json) { console.log(JSON.stringify(body)); return; }
-  const pushed = { sent: "and pushed to the user's devices", user_watching: "(no push: the user has the app open; add --urgent to push anyway)", rate_limited: "(no push: this session pushed less than a minute ago)", unavailable: "(no push: this machine isn't signed in to a Bivy account)" }[body.push] ?? "";
+  const noPush = { user_watching: "the user has the app open; add --urgent to push anyway", rate_limited: "this session pushed less than a minute ago", unavailable: "this machine isn't signed in to a Bivy account" }[body.push];
+  // A terminal run (`bivy run`) has no chat to hold a card: the push is the notice.
+  if (body.posted === false) {
+    if (body.push === "sent") console.log(c.green("Pushed to the user's devices."));
+    else console.log(c.yellow(`Not delivered: a terminal run has no chat to post in, and no push was sent (${noPush ?? body.push}).`));
+    return;
+  }
+  const pushed = body.push === "sent" ? "and pushed to the user's devices" : noPush ? `(no push: ${noPush})` : "";
   console.log(c.green(`Posted in the chat ${pushed}.`.replace(" .", ".")));
 }
 

package/dist/apps/styles.css

@@ -284,6 +284,54 @@ input, textarea, select { font-family: inherit; font-size: 16px; }
 .focus-view-btn[aria-pressed="true"] { color: var(--accent); background: var(--accent-soft); }
 .focus-view-label { font-size: var(--text-xs); font-weight: var(--weight-semibold); }
 
+/* ---- Side pane (wide screens): the session's changes, apps and artifacts
+   beside the chat instead of in a sheet over it. Same bodies as the sheets
+   (components/Panel.tsx), docked; below the breakpoint in App.tsx the pane
+   is never rendered and the sheets are used. */
+.app.has-pane { grid-template-columns: minmax(300px, 22vw) minmax(0, 1fr) clamp(380px, 32vw, 600px); }
+.side-pane {
+  display: flex; flex-direction: column; min-width: 0; min-height: 0; height: var(--app-h, 100dvh);
+  border-left: 1px solid var(--line); background: var(--surface);
+}
+.side-pane-head {
+  flex: none; display: flex; align-items: center; justify-content: space-between; gap: var(--space-2);
+  min-height: var(--topbar-h, 57px); padding: var(--space-2) var(--space-2) var(--space-2) var(--space-3);
+  border-bottom: 1px solid var(--line);
+}
+.side-pane-tabs { min-width: 0; overflow-x: auto; }
+.side-pane-tab { display: inline-flex; align-items: center; gap: var(--space-1); }
+.seg-count { color: var(--muted); font-variant-numeric: tabular-nums; font-weight: var(--weight-normal); }
+.side-pane-close { flex: none; color: var(--muted); }
+.side-pane-close:hover { color: var(--ink); }
+.side-pane-body { flex: 1; min-height: 0; display: flex; flex-direction: column; }
+/* A docked Panel: the sheet's title row becomes a quiet toolbar, its content
+   the pane's own scroller. */
+.pane-panel { flex: 1; min-height: 0; display: flex; flex-direction: column; }
+.pane-panel-head {
+  flex: none; display: flex; align-items: center; gap: var(--space-2);
+  min-height: 44px; padding: var(--space-1) var(--space-2) var(--space-1) var(--space-3);
+  border-bottom: 1px solid var(--line);
+}
+.pane-panel-title {
+  flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap;
+  font-size: var(--text-sm); font-weight: var(--weight-semibold);
+}
+.pane-panel-content { flex: 1; min-height: 0; overflow-y: auto; overflow-x: hidden; padding: var(--space-3); overscroll-behavior: contain; }
+.pane-panel[data-size="full"] .pane-panel-content { padding: 0; overflow: hidden; }
+.pane-panel[data-size="full"] .preview-peek { border-radius: 0; }
+/* The pane's tab already says Terminal: keep the head to the pane toolbar's
+   height, with the live status and the actions that matter beside a chat. */
+.side-pane .term-head { min-height: 44px; padding: var(--space-1) var(--space-2) var(--space-1) var(--space-3); gap: var(--space-2); }
+.side-pane .term-title-label, .side-pane .term-zoom { display: none; }
+.side-pane .term-title { flex: none; }
+.side-pane .term-status { margin-left: 0; }
+/* Narrow screens: Changes in the session view switch covers the column's
+   view, full height. Everything else in the column stays mounted, hidden. */
+.main.changes-section > :not(.topbar):not(.banner):not(.main-changes) { display: none; }
+.main-changes { flex: 1; min-height: 0; display: flex; flex-direction: column; background: var(--surface); }
+.main-changes .pane-panel-content { padding-bottom: max(var(--space-3), env(safe-area-inset-bottom)); }
+.topbar-actions .side-pane-toggle[aria-pressed="true"] { color: var(--accent); background: var(--accent-soft); }
+
 /* ---- Header session actions (dot-menu: rename / open PR / delete) ---- */
 .session-actions-wrap { position: relative; flex: none; }
 .session-actions-btn { border: 0; background: transparent; color: var(--ink); font-size: 20px; line-height: 1; padding: 4px 8px; border-radius: var(--radius-sm); }
@@ -927,7 +975,8 @@ button.sheet-action:last-child { border-bottom: 0; }
    would occupy and centers a compact card; the buttons are the old lock
    banner's escape hatches (open the terminal / take over in chat) at a more
    deliberate, explanatory scale. */
-.tui-locked { flex: 1; min-height: 0; display: flex; align-items: center; justify-content: center; padding: 24px 16px; overflow-y: auto; }
+.tui-locked { flex: 1; min-height: 0; display: flex; flex-direction: column; align-items: center; justify-content: safe center; gap: var(--space-4); padding: 24px 16px; overflow-y: auto; }
+.tui-locked-attention { width: min(440px, 100%); }
 .tui-locked-card { width: min(440px, 100%); display: flex; flex-direction: column; align-items: center; gap: 10px; text-align: center; }
 .tui-locked-icon { display: inline-flex; align-items: center; justify-content: center; width: 52px; height: 52px; border-radius: var(--radius-md); background: color-mix(in srgb, var(--accent) 12%, var(--surface-2)); color: var(--accent); }
 .tui-locked-title { margin: 2px 0 0; font-size: 18px; font-weight: 700; }
@@ -2610,9 +2659,12 @@ textarea.picker-search { resize: vertical; font-family: ui-monospace, monospace;
 .term-head-actions {
   display: flex; align-items: center; gap: 8px;
   flex: 1 1 auto; min-width: 0; overflow-x: auto;
-  justify-content: flex-end;
+  /* Right-aligned by an auto margin, not justify-content: flex-end, which
+     would push overflow off the left edge where it can't be scrolled to. */
+  justify-content: flex-start;
   scrollbar-width: none; -webkit-overflow-scrolling: touch;
 }
+.term-head-actions > :first-child { margin-left: auto; }
 .term-head-actions::-webkit-scrollbar { display: none; }
 .term-head-actions > * { flex: 0 0 auto; }
 .term-attach-wrap { position: relative; }

package/dist/controllers/session-control.js

@@ -17,12 +17,10 @@ export function createSessionControlCommands(ports) {
             ctx.reply({ type: "session.resume.result", ok: true });
         },
         "session.question.answer"(input, ctx) {
-            const session = ports.resolve(input.sessionId);
             const requestId = String(input.requestId ?? "");
-            if (!session || !requestId) {
+            if (!requestId || !ports.answer(input.sessionId, requestId, input)) {
                 return ctx.reply({ type: "session.question.answer.error", httpStatus: 404, error: "No matching session/question" });
             }
-            ports.answer(session, requestId, input);
             ctx.reply({ type: "session.question.answer.result", ok: true, requestId });
         },
     };

package/dist/server.js

@@ -476,7 +476,7 @@ questionManager.onRequest((request) => {
         sessionId: request.sessionId,
         attentionId: request.id,
         title: "Bivy needs your input",
-        body: `${sessionNotifyLabel(resolveSession(request.sessionId))} is asking a question — tap to answer.`,
+        body: `${sessionNotifyLabel(resolveSession(request.sessionId), runTerms.liveRun(request.sessionId)?.name)} is asking a question — tap to answer.`,
     });
 });
 questionManager.onResolved((request) => {
@@ -2330,7 +2330,7 @@ function currentAccess() {
     });
 }
 const RELAY_COMMANDS = {
-    ...createAppCommands(appService, (id) => { const record = resolveSession(id); return record ? harnessDirFor(record) : undefined; }, (app) => {
+    ...createAppCommands(appService, (id) => { const record = resolveSession(id); return record ? harnessDirFor(record) : runTerms.liveRun(id)?.workspace; }, (app) => {
         const record = resolveSession(app.sessionId);
         if (!record)
             return;
@@ -2389,7 +2389,7 @@ const RELAY_COMMANDS = {
         resolve: (sessionId) => resolveSession(sessionId),
         pause: pauseSession,
         resume: resumeSession,
-        answer: (record, requestId, input) => answerSessionQuestion(record, requestId, input),
+        answer: (sessionId, requestId, input) => answerSessionQuestion(sessionId, requestId, input),
     }),
     // Session fork/move command cluster, extracted to controllers/fork-commands.ts
     // (server.ts decomposition). Late-bound singletons (forkStandUp/forkRetire/
@@ -6405,9 +6405,13 @@ function recordMcpEvent(sessionId, event) {
  *  out, or aborted) — same tolerance as resolveApproval. The resolved broadcast
  *  is emitted from questionManager.onResolved, not here, so it fires exactly
  *  when the question actually settles (never for an already-discarded id). */
-function answerSessionQuestion(_record, requestId, msg) {
+/** A question's session may be an open chat or a live `bivy run` (`bivy ask`). */
+function answerSessionQuestion(sessionId, requestId, msg) {
+    if (!resolveSession(sessionId) && !runTerms.liveRun(typeof sessionId === "string" ? sessionId : ""))
+        return false;
     const answers = msg.answers && typeof msg.answers === "object" ? msg.answers : {};
     questionManager.resolve(requestId, msg.cancelled ? { behavior: "cancelled" } : { behavior: "completed", answers });
+    return true;
 }
 /** Agent id requested by a client command (`agent` or legacy `runtimeId`); empty = default. */
 function agentFrom(msg) {
@@ -9211,6 +9215,7 @@ const runTerms = createRunTerminals({
     sessionBusy: (record) => sessionBusy(record),
     sessionTerminalsRecord: (sessionId, val) => sessionTerminals.record(sessionId, val),
     sessionTerminalsForget: (sessionId) => sessionTerminals.forget(sessionId),
+    replayPendingInteractions: (sessionId) => replayPendingInteractions(sessionId),
     upsertSessionMetadata: (patch) => {
         const input = patch;
         // A run continuing a saved session (`bivy resume`) only moves its status;
@@ -11663,11 +11668,9 @@ app.post("/api/session/:id/attach", (req, res) => {
 // `bivy context`: what an agent in this session needs to orient itself.
 app.get("/api/session/:id/context", (req, res) => {
     const record = openSessions.get(String(req.params.id));
-    if (!record)
-        return res.status(404).json({ error: "Session not found" });
-    const { apps, previewAvailable } = appService.list(record.id);
-    res.json(buildAgentContext({
-        session: {
+    const run = record ? undefined : runTerms.liveRun(String(req.params.id));
+    const session = record
+        ? {
             id: record.id,
             name: record.session.getName() || undefined,
             agent: record.runtimeId,
@@ -11678,9 +11681,16 @@ app.get("/api/session/:id/context", (req, res) => {
             forkedFrom: record.forkedFrom,
             delegatedFrom: record.delegatedFrom?.sessionId,
             busy: sessionBusy(record),
-        },
+        }
+        // A `bivy run` terminal: the agent drives it from its own TUI, so it's live.
+        : run && { id: run.sessionId, name: run.name, agent: run.agent ?? "run", workspace: run.workspace, busy: true };
+    if (!session)
+        return res.status(404).json({ error: "Session not found" });
+    const { apps, previewAvailable } = appService.list(session.id);
+    res.json(buildAgentContext({
+        session,
         machine: { name: identity.name, platform: process.platform, arch: process.arch },
-        presence: presenceBook.get(record.id),
+        presence: presenceBook.get(session.id),
         userConnected: clients.size > 0 || (relay?.clientCount ?? 0) > 0,
         apps,
         previewAvailable,
@@ -11688,44 +11698,49 @@ app.get("/api/session/:id/context", (req, res) => {
 });
 // `bivy notify "<message>"`: a card in the chat, and a push naming the session
 // (never the text) when nobody has the app open, or when it's urgent. At most
-// one push a minute per session; later notices still post a card.
+// one push a minute per session; later notices still post a card. A `bivy run`
+// terminal has no chat to hold the card, so its notice is the push alone.
 const lastNotifyPush = new Map();
 app.post("/api/session/:id/notify", (req, res) => {
     const record = openSessions.get(String(req.params.id));
-    if (!record)
+    const run = record ? undefined : runTerms.liveRun(String(req.params.id));
+    const sessionId = record?.id ?? run?.sessionId;
+    if (!sessionId)
         return res.status(404).json({ error: "Session not found" });
     const text = typeof req.body?.text === "string" ? req.body.text.trim() : "";
     const notice = { id: `notice-${randomBytes(8).toString("hex")}`, text, ...(req.body?.urgent === true ? { urgent: true } : {}) };
     if (!isAgentNotice(notice))
         return res.status(400).json({ error: `A notice needs text (up to ${MAX_NOTICE_TEXT} characters).` });
-    eventLog.appendNotice(record.id, { afterMessageCount: record.session.getMessages().length, notice });
-    broadcast(stampSessionEvent({ type: "session.event", sessionId: record.id, event: { type: "notice", id: notice.id, notice } }));
-    const watching = clients.size > 0 || (relay?.clientCount ?? 0) > 0;
-    const push = noticePush({ urgent: notice.urgent, userWatching: watching, lastPushAt: lastNotifyPush.get(record.id), now: Date.now(), pushConfigured: Boolean(sessionAdvertiseTarget) });
+    if (record) {
+        eventLog.appendNotice(record.id, { afterMessageCount: record.session.getMessages().length, notice });
+        broadcast(stampSessionEvent({ type: "session.event", sessionId: record.id, event: { type: "notice", id: notice.id, notice } }));
+    }
+    const watching = Boolean(record) && (clients.size > 0 || (relay?.clientCount ?? 0) > 0);
+    const push = noticePush({ urgent: notice.urgent, userWatching: watching, lastPushAt: lastNotifyPush.get(sessionId), now: Date.now(), pushConfigured: Boolean(sessionAdvertiseTarget) });
     if (push === "sent") {
-        lastNotifyPush.set(record.id, Date.now());
+        lastNotifyPush.set(sessionId, Date.now());
         void sendNotificationHint({
             kind: "agent_notice",
-            sessionId: record.id,
-            targetSessionId: record.id,
-            title: sessionNotifyLabel(record),
+            sessionId,
+            targetSessionId: sessionId,
+            title: sessionNotifyLabel(record, run?.name || "A terminal session"),
             body: "Has a message for you — tap to read it.",
         });
     }
-    res.json({ ok: true, id: notice.id, push, userWatching: watching });
+    res.json({ ok: true, id: notice.id, posted: Boolean(record), push, userWatching: watching });
 });
 // `bivy ask`: the question card and "needs your input" push, for any agent.
 // Returns at once with an id; `/wait` blocks up to 240s per call (under common
 // HTTP client timeouts), so the CLI loops until the user answers.
 app.post("/api/session/:id/ask", (req, res) => {
-    const record = openSessions.get(String(req.params.id));
-    if (!record)
+    const sessionId = openSessions.get(String(req.params.id))?.id ?? runTerms.liveRun(String(req.params.id))?.sessionId;
+    if (!sessionId)
         return res.status(404).json({ error: "Session not found" });
     const questions = askQuestionsFrom(req.body?.questions);
     if (typeof questions === "string")
         return res.status(400).json({ error: questions });
     const timeoutSeconds = Number(req.body?.timeoutSeconds);
-    res.status(201).json(agentQuestions.ask(record.id, questions, Number.isFinite(timeoutSeconds) && timeoutSeconds > 0 ? timeoutSeconds * 1000 : 10 * 60 * 1000));
+    res.status(201).json(agentQuestions.ask(sessionId, questions, Number.isFinite(timeoutSeconds) && timeoutSeconds > 0 ? timeoutSeconds * 1000 : 10 * 60 * 1000));
 });
 app.get("/api/session/:id/ask/:askId", (req, res) => {
     const result = agentQuestions.get(String(req.params.id), String(req.params.askId));

package/dist/session/run-terminal.js

@@ -14,6 +14,7 @@
 // timer maps, the agent lookup tables) moves here. Credential projection follows
 // the unified agent-integration model (#433): only an integration that declares
 // bivy/mixed auth receives Bivy vault projections.
+import { randomUUID } from "node:crypto";
 import { provisionAgentRun } from "../runtime/credential-provisioning.js";
 import { ingestAgentCredentials } from "../runtime/credential-ingest.js";
 import { discoverCodexSessionForCwd } from "../runtime/codex-sessions.js";
@@ -21,6 +22,7 @@ import { discoverGrokSessionForCwd } from "../runtime/grok-sessions.js";
 import { discoverGeminiFamilySessionForCwd } from "../runtime/gemini-sessions.js";
 import { discoverOpenCodeSessionForCwd } from "../runtime/opencode-sessions.js";
 import { discoverPiSessionForCwd } from "../runtime/pi-session-discovery.js";
+import { bivySessionEnv } from "../runtime/session-env.js";
 import { listMultiplexerSessions, attachCommand } from "../multiplexer.js";
 // Agents whose pinned run-terminal session can be reopened as a governed chat.
 const TAKEOVER_RUNTIME_BY_AGENT = {
@@ -115,6 +117,13 @@ export function createRunTerminals(deps) {
         deps.broadcastTuiState(record.id, false);
         void deps.refreshRecordAfterTui(record);
     }
+    function liveRun(ref) {
+        if (!ref)
+            return undefined;
+        const run = terminals.list((m) => m.kind === "run" && !m.mux)
+            .find((t) => runTerminals.has(t.id) && (t.id === ref || t.meta.sessionId === ref));
+        return run && { termId: run.id, sessionId: run.meta.sessionId ?? run.id, workspace: run.workspace, name: run.meta.name, agent: run.meta.agent };
+    }
     function adoptLiveRun(record) {
         if (record.tuiTermId)
             return;
@@ -287,12 +296,19 @@ export function createRunTerminals(deps) {
         const name = explicitName || (spec.mux ? undefined : defaultRunName(spec.agent, commandLine, workspace));
         const notifiable = !spec.mux;
         const createdAt = Date.now();
+        // The agent inside gets the same session env a chat session's agent does, so
+        // `bivy notify`/`ask`/`app` reach this run: under its pinned session id, else
+        // under the terminal's own id (see liveRun). A mux attach joins a shell that
+        // already has its environment.
+        const termId = `term-${randomUUID()}`;
+        const sessionEnv = spec.mux ? {} : bivySessionEnv(spec.sessionId ?? termId);
         try {
             const id = terminals.open({
+                id: termId,
                 workspace,
                 command: spec.command,
                 args: spec.args,
-                env: { ...credentialEnv, ...spec.env },
+                env: { ...credentialEnv, ...sessionEnv, ...spec.env },
                 cols: spec.cols,
                 rows: spec.rows,
                 clientId: spec.clientId,
@@ -466,7 +482,15 @@ export function createRunTerminals(deps) {
     function handleTerminalMessage(msg, emit, owned, clientId, viewRun) {
         switch (msg.kind) {
             case "terminal.list":
-                void runTerminalList().then((listed) => emit({ type: "terminal.list", terminals: listed }));
+                // Every client asks on connect: also re-send what live runs are waiting
+                // on, as a chat's history request does for its own cards.
+                void runTerminalList().then((listed) => {
+                    emit({ type: "terminal.list", terminals: listed });
+                    for (const t of listed) {
+                        if (!t.mux)
+                            deps.replayPendingInteractions(t.sessionId ?? t.termId);
+                    }
+                });
                 return true;
             case "terminal.takeover": {
                 const takeoverTermId = typeof msg.termId === "string" && msg.termId ? msg.termId : undefined;
@@ -655,5 +679,5 @@ export function createRunTerminals(deps) {
                 return false;
         }
     }
-    return { runTerminalList, openRunTerminal, takeoverRunTerminal, handleTerminalMessage, addRunViewer, dropRunViewer, hasRunTerminal, hasLiveRunForSession, adoptLiveRun };
+    return { runTerminalList, openRunTerminal, takeoverRunTerminal, handleTerminalMessage, addRunViewer, dropRunViewer, hasRunTerminal, hasLiveRunForSession, adoptLiveRun, liveRun };
 }

package/dist/terminal.js

@@ -77,7 +77,7 @@ export class TerminalManager {
         return this.terminals.size;
     }
     open(options) {
-        const id = `term-${randomUUID()}`;
+        const id = options.id ?? `term-${randomUUID()}`;
         const shell = options.command || defaultShell();
         const shellArgs = options.command ? (options.args ?? []) : [];
         // Ensure a UTF-8 locale so TUIs (e.g. Claude Code) render box-drawing and

package/package.json

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