@bivy/bivy 0.17.3-staging.11 → 0.17.3-staging.12

package/dist/apps/styles.css

@@ -3201,3 +3201,8 @@ select.picker-search { appearance: auto; }
   .automation-history-view .autom-section-head { align-items: flex-start; gap: var(--space-3); }
   .automation-history-view .autom-section-head > strong { min-width: 0; line-height: var(--lh-lg); }
 }
+
+/* Device handoff (HandoffBanner): sits above the composer like the composer
+   itself, with one line of the other device's draft. */
+.handoff-banner { border-radius: var(--radius-md); }
+.handoff-preview { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }

package/dist/attach.js

@@ -1,5 +1,6 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 // Copyright (c) 2026 Petter André Sjulstad
+import { hostname } from "node:os";
 import { StringDecoder } from "node:string_decoder";
 import { WebSocket } from "ws";
 /**
@@ -50,6 +51,9 @@ const TTY_MODE_RESET = "\x1b[?1049l" + // leave the alternate screen
     "\x1b[?1l\x1b>" + // cursor keys + keypad back to normal mode
     "\x1b[?25h" + // cursor visible
     "\x1b[0m"; // reset colors/attributes
+/** How this terminal names itself to the node, so other devices can say where a
+ *  session was last driven ("Terminal on my-laptop"). */
+const DEVICE = { id: `terminal:${hostname()}`, label: `Terminal on ${hostname()}` };
 function parseArgs(argv) {
     let url = process.env.BIVY_URL || `http://localhost:${process.env.PORT || "4317"}`;
     let token = process.env.BIVY_DEVICE_TOKEN || undefined;
@@ -276,7 +280,7 @@ function openDetached(args, spec, cols, rows) {
             catch { }
             resolve(code);
         };
-        socket.on("open", () => socket.send(JSON.stringify({ kind: "terminal.open.run", agent: spec.agent, label: spec.label, name: spec.name, model: spec.model, command: spec.command, args: spec.args ?? [], workspace: spec.workspace, sessionId: spec.sessionId, cols, rows })));
+        socket.on("open", () => socket.send(JSON.stringify({ kind: "terminal.open.run", agent: spec.agent, label: spec.label, name: spec.name, model: spec.model, command: spec.command, args: spec.args ?? [], workspace: spec.workspace, sessionId: spec.sessionId, cols, rows, device: DEVICE })));
         socket.on("error", (err) => {
             process.stderr.write(c.red(`Connection error: ${err instanceof Error ? err.message : String(err)}\n`));
             finish(1);
@@ -312,7 +316,7 @@ async function main() {
             process.exit(await openDetached(args, spec, cols, rows));
         }
         process.stdout.write(c.dim(`Starting ${c.cyan(spec.name || spec.label || spec.agent || spec.command)} — Ctrl-\\ Ctrl-\\ to detach\r\n`));
-        const code = await bridge(args, (ws) => ws.send(JSON.stringify({ kind: "terminal.open.run", agent: spec.agent, label: spec.label, name: spec.name, model: spec.model, command: spec.command, args: spec.args ?? [], workspace: spec.workspace, sessionId: spec.sessionId, cols, rows })));
+        const code = await bridge(args, (ws) => ws.send(JSON.stringify({ kind: "terminal.open.run", agent: spec.agent, label: spec.label, name: spec.name, model: spec.model, command: spec.command, args: spec.args ?? [], workspace: spec.workspace, sessionId: spec.sessionId, cols, rows, device: DEVICE })));
         process.exit(code);
     }
     // attach
@@ -326,7 +330,7 @@ async function main() {
 async function attachById(args, termId) {
     const { cols, rows } = termSize();
     process.stdout.write(c.dim(`Attaching to ${c.cyan(termId)} — Ctrl-\\ Ctrl-\\ to detach\r\n`));
-    const code = await bridge({ ...args, termId }, (ws) => ws.send(JSON.stringify({ kind: "terminal.attach", termId, cols, rows })));
+    const code = await bridge({ ...args, termId }, (ws) => ws.send(JSON.stringify({ kind: "terminal.attach", termId, cols, rows, device: DEVICE })));
     process.exit(code);
 }
 main().catch((error) => {

package/dist/controllers/presence-commands.js

@@ -0,0 +1,19 @@
+import { deviceFrom } from "../session/presence.js";
+/** Device handoff presence, shared by relay and HTTP: read a session's driver
+ * and carried-over draft, and publish this device's unsent draft. */
+export function createPresenceCommands(book, publish) {
+    return {
+        "session.presence.get"(input, ctx) {
+            const requestId = typeof input.requestId === "string" ? input.requestId : undefined;
+            ctx.reply({ type: "session.presence.get.ok", requestId, presence: book.get(String(input.sessionId)) });
+        },
+        "session.presence.draft"(input, ctx) {
+            const requestId = typeof input.requestId === "string" ? input.requestId : undefined;
+            const device = deviceFrom(input.device);
+            if (!device)
+                return ctx.reply({ type: "session.presence.draft.error", httpStatus: 400, requestId, error: "Missing device" });
+            publish(book.draft(String(input.sessionId), device, String(input.text ?? "")));
+            ctx.reply({ type: "session.presence.draft.ok", requestId });
+        },
+    };
+}

package/dist/protocol/client-command-routes.js

@@ -7,6 +7,7 @@ export const CLIENT_COMMAND_ROUTES = [
     { method: "post", path: "/api/auth/credentials/native-preview", kind: "credentials.native.preview" },
     { method: "post", path: "/api/auth/credentials/native-import", kind: "credentials.native.import" },
     { method: "post", path: "/api/session/pause", kind: "session.pause" },
+    ...["get", "draft"].map((action) => ({ method: "post", path: `/api/session/presence/${action}`, kind: `session.presence.${action}` })),
     { method: "post", path: "/api/session/resume", kind: "session.resume" },
     { method: "post", path: "/api/session/question/answer", kind: "session.question.answer" },
 ];

package/dist/protocol/client-command-schemas.js

@@ -28,6 +28,8 @@ export const CLIENT_COMMAND_SCHEMAS = {
     }),
     "attachment.fetch": Type.Object({ ...request, hash: Type.String() }),
     "session.pause": Type.Object(session),
+    "session.presence.get": Type.Object({ ...request, ...session }),
+    "session.presence.draft": Type.Object({ ...request, ...session, device: Type.Object({ id: Type.String({ maxLength: 100 }), label: Type.Optional(Type.String({ maxLength: 200 })) }), text: Type.String({ maxLength: 20_000 }) }),
     "session.resume": Type.Object(session),
     "session.question.answer": Type.Object({ ...optionalSession, requestId: Type.String(), answers: Type.Optional(Type.Record(Type.String(), Type.String())) }),
     "session.replay": Type.Object({ ...session, afterSeq: Type.Optional(Type.Number()) }),

package/dist/server.js

@@ -114,6 +114,8 @@ import { listInstalledPlugins } from "./plugins/store.js";
 import { createCapabilitiesController } from "./controllers/capabilities.js";
 import { createAccessDeviceController, createLinkedDeviceController } from "./controllers/devices.js";
 import { createSessionControlCommands } from "./controllers/session-control.js";
+import { createPresenceCommands } from "./controllers/presence-commands.js";
+import { PresenceBook, deviceFrom } from "./session/presence.js";
 import { createForkCommands } from "./controllers/fork-commands.js";
 import { createGithubCommands } from "./controllers/github-commands.js";
 import { createCredentialCommands } from "./controllers/credential-commands.js";
@@ -1676,6 +1678,19 @@ const sessionEvents = new SessionEventCoalescer({
 function broadcastTuiState(sessionId, active) {
     broadcast({ type: "terminal.tui", sessionId, active });
 }
+// Device handoff (src/session/presence.ts): which device last drove each
+// session and the draft it left, so the next device can pick up from there.
+const presenceBook = new PresenceBook();
+function publishPresence(presence) {
+    broadcast({ type: "session.presence", presence });
+}
+function notePresence(sessionId, device, via) {
+    if (!sessionId || !device)
+        return;
+    const changed = presenceBook.drove(sessionId, device, via);
+    if (changed)
+        publishPresence(changed);
+}
 // Terminals opened by relay clients (phone/web over the relay). Output is emitted
 // via the relay tagged with termId; clients filter by it. (Per-client unicast
 // is a known future hardening step.)
@@ -2000,6 +2015,7 @@ const RELAY_COMMANDS = {
         const meta = attachmentStore.readMeta(hash);
         ctx.reply({ type: "attachment.data", requestId, hash, mimeType: meta?.mimeType ?? "application/octet-stream", name: meta?.name, data: bytes.toString("base64") });
     },
+    ...createPresenceCommands(presenceBook, publishPresence),
     ...createSessionControlCommands({
         resolve: (sessionId) => resolveSession(sessionId),
         pause: pauseSession,
@@ -2910,6 +2926,7 @@ const RELAY_COMMANDS = {
             broadcast({ type: "session.error", sessionId: record.id, error: record.tuiRefreshing ? "This session is returning from the terminal. Try again in a moment." : "This session is open in the terminal (TUI). Close the TUI to chat here." });
             return;
         }
+        notePresence(record.id, deviceFrom(msg.device), "chat");
         touchSession(record);
         // Now that the session (and its workdir) exists, write file attachments to
         // disk and fold their path notes into the prompt the agent actually sees.
@@ -3052,6 +3069,8 @@ async function handleRelayMessage(msg) {
         // Fallthrough for kinds not in RELAY_COMMANDS: terminal.* frames go to the
         // PTY manager; anything else is an unknown client message.
         if (typeof msg.kind === "string" && msg.kind.startsWith("terminal.")) {
+            if (msg.kind === "terminal.attach")
+                notePresence(terminals.meta(String(msg.termId ?? ""))?.sessionId, deviceFrom(msg.device), "terminal");
             // The relay is a single tunnel with no per-remote-client identity at this
             // layer, so every relay-tunneled client shares one size slot. That still
             // keeps them distinct from each local socket, so a PTY shared between a
@@ -11132,6 +11151,7 @@ app.post("/api/session/prompt", async (req, res, next) => {
         if (record.tuiTermId || record.tuiRefreshing) {
             return res.status(409).json({ error: record.tuiRefreshing ? "This session is returning from the terminal. Try again in a moment." : "This session is open in the terminal (TUI). Close the TUI to chat here." });
         }
+        notePresence(record.id, deviceFrom(req.body?.device), "chat");
         const session = record.session;
         const { note: fileNote, refs: fileRefs } = materializeAttachments(record, files);
         const promptText = [text, imageNotes.join("\n"), fileNote].filter(Boolean).join("\n\n") ||
@@ -11466,6 +11486,7 @@ wss.on("connection", (socket, req) => {
     // Stable id for this socket, keying its per-terminal size so several clients
     // sharing a PTY size it to their min (see TerminalManager.setClientSize).
     const clientTerminalId = `sock-${randomUUID()}`;
+    let socketDevice;
     socket.send(JSON.stringify({ type: "hello", activeSessionId: active?.id, activeSession: active ? { id: active.id, isStreaming: sessionBusy(active), sessionState: sessionState(active), lastActivity: active.lastActivity, workingStartedAt: active.workingStartedAt } : null }));
     // Authoritative version status on every connect: `latest` set means this node
     // is behind (banner shows); absent means up to date (banner + any "Updating…"
@@ -11490,6 +11511,12 @@ wss.on("connection", (socket, req) => {
             return;
         }
         if (typeof msg?.kind === "string" && msg.kind.startsWith("terminal.")) {
+            // A terminal client (`bivy run`/`bivy resume`) names its device once; typing
+            // into a session's terminal then makes it that session's driver.
+            socketDevice = deviceFrom(msg.device) ?? socketDevice;
+            if (msg.kind === "terminal.input" || msg.kind === "terminal.attach") {
+                notePresence(terminals.meta(String(msg.termId ?? ""))?.sessionId, socketDevice, "terminal");
+            }
             runTerms.handleTerminalMessage(msg, (event) => {
                 if (socket.readyState === WebSocket.OPEN)
                     socket.send(JSON.stringify(event));

package/dist/session/presence.js

@@ -0,0 +1,82 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+//
+// Which device is driving a session, and the draft it left behind. This is a
+// soft lease, not a lock. Nothing is ever refused because another device drove
+// last; it only lets the next device say "you were on your Mac a minute ago" and
+// carry the unsent draft over. Devices name themselves (the room key already
+// trusts every linked device, so this is presentation, not authentication).
+// In-memory: a handoff is minutes-scale, and a node restart is a fine reset.
+/** Longest device label kept; they're shown in a one-line strip. */
+const LABEL_MAX = 60;
+/** Longest draft carried between devices. */
+const DRAFT_MAX = 20_000;
+/** A driver that keeps typing re-announces at most this often. */
+const REANNOUNCE_MS = 30_000;
+/** Presence older than this is forgotten. */
+const TTL_MS = 6 * 60 * 60 * 1000;
+/** A device reference from untrusted client input, or undefined. */
+export function deviceFrom(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const { id, label } = value;
+    if (typeof id !== "string" || !id.trim() || id.length > 100)
+        return undefined;
+    const name = typeof label === "string" && label.trim() ? label.trim().slice(0, LABEL_MAX) : "Another device";
+    return { id: id.trim(), label: name };
+}
+export class PresenceBook {
+    now;
+    sessions = new Map();
+    constructor(now = Date.now) {
+        this.now = now;
+    }
+    get(sessionId) {
+        this.expire();
+        return this.sessions.get(sessionId) ?? { sessionId };
+    }
+    /** A device sent input to the session. Returns the presence to broadcast when
+     *  the driver changed (or is due a re-announce), else undefined. A chat send
+     *  also consumes that device's draft, since the draft has now been sent. */
+    drove(sessionId, device, via) {
+        const at = this.now();
+        const entry = this.entry(sessionId);
+        const previous = entry.driver;
+        entry.driver = { ...device, via, at };
+        const sentDraft = via === "chat" && entry.draft?.device.id === device.id;
+        if (sentDraft)
+            entry.draft = undefined;
+        const changed = !previous || previous.id !== device.id || previous.via !== via || at - previous.at >= REANNOUNCE_MS;
+        return changed || sentDraft ? { ...entry } : undefined;
+    }
+    /** A device's unsent draft for the session (empty text clears it). */
+    draft(sessionId, device, text) {
+        const entry = this.entry(sessionId);
+        const trimmed = text.slice(0, DRAFT_MAX);
+        if (trimmed.trim())
+            entry.draft = { device, text: trimmed, at: this.now() };
+        else if (entry.draft?.device.id === device.id)
+            entry.draft = undefined;
+        return { ...entry };
+    }
+    entry(sessionId) {
+        this.expire();
+        let entry = this.sessions.get(sessionId);
+        if (!entry) {
+            entry = { sessionId };
+            this.sessions.set(sessionId, entry);
+        }
+        return entry;
+    }
+    expire() {
+        const cutoff = this.now() - TTL_MS;
+        for (const [id, entry] of this.sessions) {
+            if (entry.driver && entry.driver.at < cutoff)
+                entry.driver = undefined;
+            if (entry.draft && entry.draft.at < cutoff)
+                entry.draft = undefined;
+            if (!entry.driver && !entry.draft)
+                this.sessions.delete(id);
+        }
+    }
+}

package/package.json

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