@bivy/bivy 0.17.2 → 0.17.3-staging.10

package/dist/apps/service.js

@@ -1,23 +1,137 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { scanListeners } from "./listeners.js";
+import { takeShots } from "./screenshot.js";
+const NO_DISPLAYS = { unavailable: () => "Desktop app views aren't available on this machine.", ensure: () => Promise.reject(new Error("Desktop app views aren't available on this machine.")), stop: () => { } };
+/** How long a screenshot waits for a desktop app's first window. */
+const WINDOW_WAIT_MS = 15_000;
 /** Composes view providers; registry never spawns processes and the gateway
  * never knows about terminals. New providers can extend open/remove here. */
+/** A managed server that keeps exiting is left down after this many restarts
+ * in RESTART_WINDOW; opening the view again tries afresh. */
+const MAX_RESTARTS = 5;
+/** Compare keeps this many shots per view, taken after servers settle. */
+const COMPARE_KEEP = 4;
+const COMPARE_SETTLE_MS = 1_500;
+const RESTART_WINDOW = 10 * 60_000;
 export class AppService {
     registry;
     gateway;
     terminals;
     terminalStarts = new Map();
-    constructor(registry, gateway, terminals) {
+    servers = new Map();
+    scan;
+    serverWatchMs;
+    screenshots;
+    displays;
+    shooting = Promise.resolve();
+    constructor(registry, gateway, terminals, options = {}) {
         this.registry = registry;
         this.gateway = gateway;
         this.terminals = terminals;
+        this.scan = options.scan ?? scanListeners;
+        this.serverWatchMs = options.serverWatchMs ?? 5_000;
+        this.screenshots = { enabled: options.screenshots?.enabled ?? (() => false), take: options.screenshots?.take ?? takeShots };
+        this.displays = options.displays ?? NO_DISPLAYS;
     }
-    list(sessionId) { return { apps: this.registry.list(sessionId), previewAvailable: Boolean(this.gateway) && this.gateway?.available !== false }; }
-    publish(sessionId, workspace, manifest) { return this.registry.publish(sessionId, workspace, manifest); }
-    async open(sessionId, appId, viewId, returnTo) {
+    list(sessionId) {
+        const available = Boolean(this.gateway) && this.gateway?.available !== false;
+        const apps = this.registry.list(sessionId);
+        for (const app of apps)
+            for (const view of app.views) {
+                if (view.kind !== "web")
+                    continue;
+                if (available)
+                    view.address = this.gateway?.address?.(view.id);
+                const entry = this.registry.getView(view.id);
+                if (entry?.notes?.length)
+                    view.notes = structuredClone(entry.notes);
+                if (entry?.stats)
+                    view.stats = structuredClone(entry.stats);
+            }
+        return { apps, previewAvailable: available };
+    }
+    publish(sessionId, workspace, manifest) {
+        // Tell the agent now, not on first open, when this machine can't show it.
+        const unavailable = manifest?.views?.some?.((view) => view?.kind === "display") && this.displays.unavailable();
+        if (unavailable)
+            throw new Error(unavailable);
+        return this.registry.publish(sessionId, workspace, manifest);
+    }
+    /** An agent turn changed files in this session's workspace. With agent
+     * screenshots on, Compare gets an "after" shot once servers have rebuilt. */
+    turnChanged(sessionId) {
+        const bumped = this.registry.touch(sessionId);
+        // Desktop apps that asked for it are restarted, so they run the new code.
+        for (const id of bumped) {
+            const entry = this.registry.getView(id);
+            const server = this.servers.get(id);
+            if (entry?.target.kind !== "display" || !server?.termId)
+                continue;
+            this.terminals.close(server.termId);
+            server.termId = undefined;
+            void this.ensureServer(entry).catch(() => { });
+        }
+        if (bumped.length && this.screenshots.enabled())
+            setTimeout(() => void this.capture(bumped), COMPARE_SETTLE_MS).unref?.();
+        return bumped;
+    }
+    /** One phone-width shot per view of the page last viewed, kept for Compare. */
+    async capture(viewIds) {
+        for (const id of viewIds) {
+            const entry = this.registry.getView(id);
+            if (!entry || entry.view.kind !== "web")
+                continue;
+            await this.windowShown(entry).catch(() => { });
+            const outDir = path.join(os.tmpdir(), "bivy-shots", "compare", id);
+            const run = this.shooting.catch(() => { }).then(() => this.screenshots.take([entry], { widths: [390], themes: ["light"], path: entry.lastPath ?? "/" }, outDir));
+            this.shooting = run;
+            try {
+                const [shot] = await run;
+                if (!shot)
+                    continue;
+                const png = fs.readFileSync(shot.file);
+                fs.rmSync(outDir, { recursive: true, force: true });
+                entry.shots = [...(entry.shots ?? []), { revision: entry.revision, at: Date.now(), png }].slice(-COMPARE_KEEP);
+            }
+            catch { /* a failed shot just leaves Compare without this turn */ }
+        }
+    }
+    /** Servers running in the workspace that this session doesn't preview yet. */
+    async offers(sessionId, workspace) {
+        const claimed = this.registry.claimedPorts(sessionId);
+        return { offers: (await this.scan(workspace)).filter((offer) => !claimed.has(offer.port)) };
+    }
+    /** Publish a detected server. Re-scanned so a client can't adopt an arbitrary port. */
+    async adopt(sessionId, workspace, port) {
+        const offer = (await this.offers(sessionId, workspace)).offers.find((item) => item.port === port);
+        if (!offer)
+            throw new Error(`Nothing in this session's workspace is listening on port ${port} any more.`);
+        return this.registry.publish(sessionId, workspace, { version: 1, name: `${offer.command} · :${port}`.slice(0, 100), views: [{ kind: "web", name: `Port ${port}`, source: { kind: "service", port } }] });
+    }
+    /** `direct` opens the app origin itself (no shell): a signed-in device
+     * returning to a view's stable address. */
+    /** `scale`: the opening device's pixel density, used if this starts a display. */
+    async open(sessionId, appId, viewId, returnTo, direct = false, scale) {
         const entry = this.registry.requireView(sessionId, appId, viewId);
+        if (entry.target.kind === "display" && !entry.display)
+            entry.displayScale = scale === 2 ? 2 : 1;
         if (entry.view.kind === "web") {
             if (!this.gateway)
                 throw new Error("Bivy's preview service is unavailable on this connection.");
-            return { kind: "web", url: this.gateway.open(viewId, returnTo) };
+            if (direct && !this.gateway.openDirect)
+                throw new Error("This machine can't open previews directly.");
+            const url = direct ? this.gateway.openDirect(viewId) : this.gateway.open(viewId, returnTo);
+            // Don't wait for a managed server to boot: the preview shows it starting
+            // and reloads itself once it answers.
+            if (this.servers.get(viewId))
+                this.servers.get(viewId).restarts = [];
+            void this.ensureServer(entry).catch(() => { });
+            // Compare needs a "before": take a baseline the first time it's opened.
+            if (!entry.shots?.length && this.screenshots.enabled())
+                setTimeout(() => void this.capture([viewId]), COMPARE_SETTLE_MS).unref?.();
+            return { kind: "web", url };
         }
         if (entry.target.kind !== "terminal")
             throw new Error("Unsupported app view provider.");
@@ -48,6 +162,125 @@ export class AppService {
             throw error;
         }
     }
+    /** Screenshots of a session's web views (one app, or all), for agents to
+     * check their own UI. One browser at a time node-wide; PNGs in a temp dir. */
+    async shot(sessionId, appId, input) {
+        if (!this.screenshots.enabled())
+            throw new Error("Agent screenshots are off on this machine. Turn on “Let agents screenshot their app previews” in Bivy → Settings → this machine, or run: bivy config set sessions.appScreenshots true");
+        const widths = input.widths ?? [390, 1280];
+        const themes = input.themes ?? ["light"];
+        const page = input.path ?? "/";
+        if (!Array.isArray(widths) || !widths.length || widths.length > 4 || widths.some((w) => !Number.isInteger(w) || w < 240 || w > 2560))
+            throw new Error("Widths must be 1–4 whole numbers between 240 and 2560.");
+        if (!Array.isArray(themes) || !themes.length || themes.some((t) => t !== "light" && t !== "dark"))
+            throw new Error("Themes must be light and/or dark.");
+        if (typeof page !== "string" || !page.startsWith("/") || page.startsWith("//") || page.length > 2048)
+            throw new Error("Path must start with /.");
+        const apps = appId ? [this.registry.require(sessionId, appId)] : this.registry.list(sessionId);
+        const views = apps.flatMap((app) => app.views).filter((view) => view.kind === "web").map((view) => this.registry.getView(view.id)).filter(Boolean);
+        if (!views.length)
+            throw new Error("This session has no web views to screenshot. Publish one with bivy app publish, or preview a detected server.");
+        await Promise.all(views.map((entry) => this.windowShown(entry)));
+        const outDir = path.join(os.tmpdir(), "bivy-shots", sessionId.replace(/[^A-Za-z0-9_-]/g, "_"), String(Date.now()));
+        const run = this.shooting.catch(() => { }).then(() => this.screenshots.take(views, { widths, themes: [...new Set(themes)], path: page }, outDir));
+        this.shooting = run;
+        return { shots: await run };
+    }
+    /** The managed server's output, as an attachable terminal (starts it if needed). */
+    async logs(sessionId, appId, viewId) {
+        const entry = this.registry.requireView(sessionId, appId, viewId);
+        const termId = await this.ensureServer(entry);
+        if (!termId)
+            throw new Error("Only views with a start command have server logs.");
+        return { kind: "terminal", termId };
+    }
+    /** A desktop app's display is up and showing a window (or gave up waiting),
+     * so a screenshot shows the app rather than an empty screen. */
+    async windowShown(entry) {
+        if (entry.target.kind !== "display")
+            return;
+        await this.ensureServer(entry);
+        const display = await this.displays.ensure(entry.view.id, entry.app.name, entry.displayScale);
+        for (const until = Date.now() + WINDOW_WAIT_MS; !display.wm.count && Date.now() < until;)
+            await new Promise((r) => setTimeout(r, 100));
+        await new Promise((r) => setTimeout(r, 800)); // first paint
+    }
+    /** The program Bivy runs for a view: a service's start command, or a desktop
+     * app on its display (started first). */
+    program(entry) {
+        const target = entry.target;
+        if (target.kind === "service" && target.start)
+            return { ...target.start, name: `${entry.app.name} · ${entry.view.name} server` };
+        if (target.kind !== "display")
+            throw new Error("This view has no program.");
+        return this.displays.ensure(entry.view.id, entry.app.name, entry.displayScale).then((display) => {
+            entry.display = display.socket;
+            return { command: target.command, args: target.args, workspace: target.workspace, env: display.env, name: `${entry.app.name} · ${entry.view.name}` };
+        });
+    }
+    /** Services start synchronously; a desktop app waits for its display. */
+    startProgram(entry) {
+        const program = this.program(entry);
+        return program instanceof Promise ? program.then((spec) => this.terminals.start(spec)) : this.terminals.start(program);
+    }
+    ensureServer(entry) {
+        if (!(entry.target.kind === "service" && entry.target.start) && entry.target.kind !== "display")
+            return Promise.resolve(undefined);
+        const id = entry.view.id;
+        let state = this.servers.get(id);
+        if (!state) {
+            state = { restarts: [] };
+            this.servers.set(id, state);
+        }
+        const server = state;
+        if (server.termId && this.terminals.has(server.termId))
+            return Promise.resolve(server.termId);
+        server.pending ??= this.startProgram(entry)
+            .then((termId) => {
+            if (!this.registry.getView(id)) {
+                this.terminals.close(termId);
+                throw new Error("App was removed while starting.");
+            }
+            server.termId = termId;
+            return termId;
+        })
+            .finally(() => { server.pending = undefined; });
+        // Watch for exits and restart, backing off a crash loop.
+        server.timer ??= setInterval(() => {
+            const current = this.registry.getView(id);
+            if (!current) {
+                this.stopServer(id);
+                return;
+            }
+            if (server.pending || !server.termId || this.terminals.has(server.termId))
+                return;
+            const now = Date.now();
+            server.restarts = server.restarts.filter((at) => now - at < RESTART_WINDOW);
+            if (server.restarts.length >= MAX_RESTARTS)
+                return;
+            server.restarts.push(now);
+            server.termId = undefined;
+            void this.ensureServer(current).catch(() => { });
+        }, this.serverWatchMs);
+        server.timer.unref?.();
+        return server.pending;
+    }
+    stopServer(id) {
+        this.displays.stop(id);
+        const entry = this.registry.getView(id);
+        if (entry) {
+            entry.display = undefined;
+            entry.displayScale = undefined;
+        }
+        const server = this.servers.get(id);
+        if (!server)
+            return;
+        clearInterval(server.timer);
+        if (server.termId)
+            this.terminals.close(server.termId);
+        void server.pending?.then((termId) => this.terminals.close(termId)).catch(() => { });
+        this.servers.delete(id);
+    }
     share(sessionId, appId, viewId) {
         if (this.registry.requireView(sessionId, appId, viewId).view.kind !== "web")
             throw new Error("Only web views have preview links.");
@@ -55,6 +288,10 @@ export class AppService {
             throw new Error("Bivy's preview service is unavailable on this connection.");
         return this.gateway.share(viewId);
     }
+    clearNotes(sessionId, appId, viewId) {
+        delete this.registry.requireView(sessionId, appId, viewId).notes;
+        return { ok: true };
+    }
     /** Ends every link, browser session and open connection for one view; the app stays. */
     revoke(sessionId, appId, viewId) {
         this.registry.requireView(sessionId, appId, viewId);
@@ -66,6 +303,7 @@ export class AppService {
         this.registry.remove(sessionId, appId);
         for (const view of app.views) {
             this.gateway?.revoke(view.id);
+            this.stopServer(view.id);
             const pending = this.terminalStarts.get(view.id);
             this.terminalStarts.delete(view.id);
             if (pending)

package/dist/apps/styles.css

@@ -551,6 +551,8 @@ input, textarea, select { font-family: inherit; font-size: 16px; }
 .hljs-addition { color: var(--syntax-addition); }
 .msg.system { align-self: center; color: var(--muted); font-size: 13px; font-style: italic; display: flex; flex-direction: column; align-items: center; gap: 8px; text-align: center; }
 .msg.system .system-text { display: block; }
+.entry-actions { display: flex; flex-wrap: wrap; gap: var(--space-2); font-style: normal; }
+.msg.system .entry-actions { justify-content: center; }
 .msg.thinking { align-self: flex-start; color: var(--muted); font-size: 13px; border-left: 2px solid var(--line-strong); padding-left: 10px; }
 .msg.error {
   align-self: stretch; display: flex; gap: 8px; align-items: flex-start;
@@ -2957,6 +2959,9 @@ select.picker-search { appearance: auto; }
 .app-views-heading > .btn, .app-view-actions .btn { min-block-size: var(--space-7); flex-shrink: 0; }
 .app-view-actions { display: flex; flex-wrap: wrap; justify-content: flex-end; gap: var(--space-2); margin-inline-start: auto; }
 .app-view-notice { display: flex; flex-direction: column; gap: var(--space-2); flex-basis: 100%; min-width: 0; }
+.app-view-notes { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: var(--space-1); font-size: var(--text-sm); overflow-wrap: anywhere; }
+/* Peek: an app preview framed in a drawer over the chat (PreviewPeek.tsx). */
+.preview-peek { display: block; inline-size: 100%; block-size: 100%; border: 0; border-radius: var(--radius-md); background: var(--bg); }
 .app-terminal-status { padding: var(--space-2) var(--space-4); margin: 0; color: var(--muted); font-size: var(--text-sm); }
 .app-view-command { overflow-wrap: anywhere; white-space: pre-wrap; font-size: var(--text-xs); color: var(--muted); }
 .app-view-row .artifact-main { flex-basis: 60%; }

package/dist/apps/x11.js

@@ -0,0 +1,273 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+import net from "node:net";
+import fs from "node:fs";
+import { randomBytes } from "node:crypto";
+/** An X authority file with one MIT-MAGIC-COOKIE-1 for any display number, so
+ * only processes Bivy hands the file to can connect. */
+export function writeXauthority(file, cookie = randomBytes(16)) {
+    const field = (data) => { const len = Buffer.alloc(2); len.writeUInt16BE(data.length); return Buffer.concat([len, data]); };
+    const family = Buffer.from([0xff, 0xff]); // FamilyWild
+    fs.writeFileSync(file, Buffer.concat([family, field(Buffer.alloc(0)), field(Buffer.alloc(0)), field(Buffer.from("MIT-MAGIC-COOKIE-1")), field(cookie)]), { mode: 0o600 });
+    return cookie;
+}
+const pad = (n) => (4 - (n % 4)) % 4;
+// Core protocol numbers used below (X11 protocol, little-endian client).
+const OP = { ChangeWindowAttributes: 2, MapWindow: 8, ConfigureWindow: 12, GetGeometry: 14, ChangeProperty: 18, GetProperty: 20, SendEvent: 25, SetInputFocus: 42, QueryExtension: 98 };
+/** RandR minor opcodes. */
+const RR = { QueryVersion: 0, SetScreenSize: 7 };
+const EV = { DestroyNotify: 17, UnmapNotify: 18, MapRequest: 20, ConfigureNotify: 22, ConfigureRequest: 23 };
+const MASK = { StructureNotify: 1 << 17, SubstructureNotify: 1 << 19, SubstructureRedirect: 1 << 20 };
+const CFG = { x: 1, y: 2, width: 4, height: 8, border: 16 };
+const ATOM = { STRING: 31, RESOURCE_MANAGER: 23, WM_NORMAL_HINTS: 40, WM_SIZE_HINTS: 41, WINDOW: 33, WM_TRANSIENT_FOR: 68 };
+/** WM_SIZE_HINTS flag: the program set a minimum size. */
+const P_MIN_SIZE = 1 << 4;
+/** A window manager with one rule, sized for previews: every top-level window
+ * fills the screen, dialogs are centered at their own size, and everything is
+ * refit when the viewer resizes the display. A window that can't shrink to the
+ * viewer's size grows the screen instead, and the viewer scales it down, so
+ * nothing is cut off. Pure protocol, no dependencies. */
+export class FitWindowManager {
+    socket;
+    buffer = Buffer.alloc(0);
+    seq = 0;
+    root = 0;
+    width = 0;
+    height = 0;
+    ready = false;
+    /** Pending replies by sequence number: the raw reply, or undefined on error. */
+    replies = new Map();
+    /** Mapped windows we manage; `size` is what the app asked for (dialogs keep
+     * it), `min` the smallest it can draw. */
+    windows = new Map();
+    /** The size the viewer asked for, and the size we last set ourselves. */
+    viewer = [0, 0];
+    own;
+    randr = 0;
+    /** Resolves once the WM owns the root window; rejects if another WM does. */
+    /** `dpi` is published as Xft.dpi, which Chromium/Electron and others scale by. */
+    start(socketPath, cookie, dpi = 96) {
+        return new Promise((resolve, reject) => {
+            const socket = net.connect(socketPath);
+            this.socket = socket;
+            socket.on("error", (error) => { if (!this.ready)
+                reject(error); });
+            socket.on("close", () => { if (!this.ready)
+                reject(new Error("The display closed the window manager's connection.")); });
+            const name = Buffer.from("MIT-MAGIC-COOKIE-1");
+            const setup = Buffer.alloc(12);
+            setup.write("l", 0);
+            setup.writeUInt16LE(11, 2);
+            setup.writeUInt16LE(0, 4);
+            setup.writeUInt16LE(name.length, 6);
+            setup.writeUInt16LE(cookie.length, 8);
+            socket.write(Buffer.concat([setup, name, Buffer.alloc(pad(name.length)), cookie, Buffer.alloc(pad(cookie.length))]));
+            socket.on("data", (chunk) => {
+                this.buffer = Buffer.concat([this.buffer, chunk]);
+                try {
+                    if (!this.ready) {
+                        if (this.buffer.length < 8)
+                            return;
+                        const total = 8 + this.buffer.readUInt16LE(6) * 4;
+                        if (this.buffer.length < total)
+                            return;
+                        const reply = this.buffer.subarray(0, total);
+                        this.buffer = this.buffer.subarray(total);
+                        if (reply[0] !== 1) {
+                            reject(new Error(`The display refused the window manager: ${reply.subarray(8, 8 + reply[1]).toString()}`));
+                            socket.destroy();
+                            return;
+                        }
+                        this.parseSetup(reply);
+                        this.ready = true;
+                        this.viewer = [this.width, this.height];
+                        const resources = Buffer.from(`Xft.dpi:\t${dpi}\n`);
+                        this.request(OP.ChangeProperty, 0, Buffer.concat([u32(this.root, ATOM.RESOURCE_MANAGER, ATOM.STRING, 8, resources.length), resources, Buffer.alloc(pad(resources.length))]));
+                        const name = Buffer.from("RANDR");
+                        this.query(OP.QueryExtension, Buffer.concat([u16pair(name.length, 0), name, Buffer.alloc(pad(name.length))]), (reply) => {
+                            if (!reply?.[8])
+                                return;
+                            this.randr = reply[9];
+                            this.request(this.randr, RR.QueryVersion, u32(1, 5));
+                        });
+                        // Redirecting the root's substructure is what makes us the WM.
+                        const seq = this.request(OP.ChangeWindowAttributes, 0, u32(this.root, 0x800, MASK.SubstructureRedirect | MASK.SubstructureNotify | MASK.StructureNotify));
+                        this.replies.set(seq, () => reject(new Error("Another window manager already runs on this display.")));
+                        // A no-reply request can't be confirmed directly; a reply to the next
+                        // request arrives in order, so it means the first one passed.
+                        this.query(OP.GetGeometry, u32(this.root), () => { this.replies.delete(seq); resolve(); });
+                    }
+                    this.drain();
+                }
+                catch {
+                    socket.destroy();
+                }
+            });
+        });
+    }
+    stop() { this.socket?.destroy(); this.socket = undefined; }
+    get size() { return [this.width, this.height]; }
+    /** Top-level windows currently shown. */
+    get count() { return this.windows.size; }
+    parseSetup(reply) {
+        const vendorLength = reply.readUInt16LE(24);
+        const formats = reply[29];
+        const screen = 40 + vendorLength + pad(vendorLength) + formats * 8;
+        this.root = reply.readUInt32LE(screen);
+        this.width = reply.readUInt16LE(screen + 20);
+        this.height = reply.readUInt16LE(screen + 22);
+    }
+    request(opcode, data, body) {
+        const header = Buffer.alloc(4);
+        header[0] = opcode;
+        header[1] = data;
+        header.writeUInt16LE(1 + body.length / 4, 2);
+        this.socket?.write(Buffer.concat([header, body]));
+        this.seq = (this.seq + 1) & 0xffff;
+        return this.seq;
+    }
+    query(opcode, body, done) {
+        this.replies.set(this.request(opcode, 0, body), done);
+    }
+    drain() {
+        while (this.buffer.length >= 32) {
+            const kind = this.buffer[0];
+            const length = kind === 1 ? 32 + this.buffer.readUInt32LE(4) * 4 : 32;
+            if (this.buffer.length < length)
+                return;
+            const packet = this.buffer.subarray(0, length);
+            this.buffer = this.buffer.subarray(length);
+            const seq = packet.readUInt16LE(2);
+            if (kind === 0 || kind === 1) {
+                const done = this.replies.get(seq);
+                this.replies.delete(seq);
+                done?.(kind === 1 ? packet : undefined);
+                continue;
+            }
+            this.event(kind & 0x7f, packet);
+        }
+    }
+    event(code, e) {
+        if (code === EV.MapRequest) {
+            const window = e.readUInt32LE(8);
+            // The size it was created (or last configured) with, and whether it's a
+            // dialog: dialogs name their parent and keep their size, centered.
+            let size = [0, 0], min = [0, 0];
+            this.query(OP.GetGeometry, u32(window), (reply) => { if (reply)
+                size = [reply.readUInt16LE(16), reply.readUInt16LE(18)]; });
+            this.query(OP.GetProperty, u32(window, ATOM.WM_NORMAL_HINTS, ATOM.WM_SIZE_HINTS, 0, 18), (reply) => {
+                if (reply && reply.readUInt32LE(16) >= 7 && reply.readUInt32LE(32) & P_MIN_SIZE)
+                    min = [reply.readInt32LE(32 + 20), reply.readInt32LE(32 + 24)];
+            });
+            this.query(OP.GetProperty, u32(window, ATOM.WM_TRANSIENT_FOR, ATOM.WINDOW, 0, 1), (reply) => {
+                if (!reply)
+                    return; // gone already
+                const dialog = reply.readUInt32LE(16) > 0 && reply.readUInt32LE(32) > 0;
+                this.windows.set(window, { dialog, size, min: min.map((v) => Math.max(0, Math.min(v, 8192))) });
+                if (!this.resize())
+                    this.fit(window);
+                this.request(OP.MapWindow, 0, u32(window));
+                this.request(OP.SetInputFocus, 2, u32(window, 0));
+            });
+        }
+        else if (code === EV.ConfigureRequest) {
+            const window = e.readUInt32LE(8);
+            const size = [e.readUInt16LE(20), e.readUInt16LE(22)];
+            const managed = this.windows.get(window);
+            if (managed) {
+                managed.size = size;
+                this.fit(window);
+                return;
+            }
+            // Not shown yet: honour it; the map request decides the final geometry.
+            this.configure(window, e.readInt16LE(16), e.readInt16LE(18), size[0], size[1]);
+        }
+        else if (code === EV.DestroyNotify || code === EV.UnmapNotify) {
+            const window = e.readUInt32LE(8);
+            if (e.readUInt32LE(4) === this.root && this.windows.delete(window))
+                this.resize();
+        }
+        else if (code === EV.ConfigureNotify && e.readUInt32LE(8) === this.root) {
+            // The display changed size: refit everything to the new screen. If the
+            // viewer did it (not us), remember what it asked for.
+            this.width = e.readUInt16LE(20);
+            this.height = e.readUInt16LE(22);
+            if (!this.own || this.own[0] !== this.width || this.own[1] !== this.height) {
+                this.viewer = [this.width, this.height];
+                this.own = undefined;
+            }
+            if (this.resize())
+                return;
+            for (const window of this.windows.keys())
+                this.fit(window);
+        }
+    }
+    /** Grow the screen past the viewer's size when a window can't shrink that
+     * far; back to the viewer's size when it can. True if a resize was sent (the
+     * refit follows when the display reports its new size). */
+    resize() {
+        if (!this.randr)
+            return false;
+        let [w, h] = this.viewer;
+        for (const { dialog, min } of this.windows.values())
+            if (!dialog) {
+                w = Math.max(w, min[0]);
+                h = Math.max(h, min[1]);
+            }
+        if (w === this.width && h === this.height)
+            return false;
+        this.own = [w, h];
+        const body = Buffer.alloc(16);
+        body.writeUInt32LE(this.root, 0);
+        body.writeUInt16LE(w, 4);
+        body.writeUInt16LE(h, 6);
+        body.writeUInt32LE(Math.round(w * 25.4 / 96), 8);
+        body.writeUInt32LE(Math.round(h * 25.4 / 96), 12);
+        const seq = this.request(this.randr, RR.SetScreenSize, body);
+        // Refused (e.g. too large): stop resizing and fit to the screen we have.
+        // A later reply means it was accepted, so drop the error handler.
+        this.replies.set(seq, () => { this.randr = 0; this.own = undefined; for (const window of this.windows.keys())
+            this.fit(window); });
+        this.query(OP.GetGeometry, u32(this.root), () => this.replies.delete(seq));
+        return true;
+    }
+    fit(window) {
+        const managed = this.windows.get(window);
+        if (!managed)
+            return;
+        if (!managed.dialog) {
+            this.configure(window, 0, 0, this.width, this.height);
+            return;
+        }
+        const w = Math.min(Math.max(managed.size[0], 1), this.width), h = Math.min(Math.max(managed.size[1], 1), this.height);
+        this.configure(window, Math.floor((this.width - w) / 2), Math.floor((this.height - h) / 2), w, h);
+    }
+    configure(window, x, y, width, height) {
+        const body = Buffer.alloc(28);
+        body.writeUInt32LE(window, 0);
+        body.writeUInt16LE(CFG.x | CFG.y | CFG.width | CFG.height | CFG.border, 4);
+        body.writeInt32LE(x, 8);
+        body.writeInt32LE(y, 12);
+        body.writeUInt32LE(Math.max(1, width), 16);
+        body.writeUInt32LE(Math.max(1, height), 20);
+        body.writeUInt32LE(0, 24);
+        this.request(OP.ConfigureWindow, 0, body);
+        // ICCCM: tell the client its geometry even when nothing changed, or
+        // toolkits that asked for another size wait for an answer and never paint.
+        const event = Buffer.alloc(32);
+        event[0] = EV.ConfigureNotify;
+        event.writeUInt32LE(window, 4);
+        event.writeUInt32LE(window, 8);
+        event.writeInt16LE(x, 16);
+        event.writeInt16LE(y, 18);
+        event.writeUInt16LE(Math.max(1, width), 20);
+        event.writeUInt16LE(Math.max(1, height), 22);
+        this.request(OP.SendEvent, 0, Buffer.concat([u32(window, MASK.StructureNotify), event]));
+    }
+}
+function u16pair(a, b) { const out = Buffer.alloc(4); out.writeUInt16LE(a, 0); out.writeUInt16LE(b, 2); return out; }
+function u32(...values) {
+    const out = Buffer.alloc(values.length * 4);
+    values.forEach((value, i) => out.writeUInt32LE(value >>> 0, i * 4));
+    return out;
+}

package/dist/attach.js

@@ -102,6 +102,9 @@ function bridge(args, open) {
         let bound = false;
         let detachArmed = 0;
         let settled = false;
+        // Set while the session this terminal showed is continuing as a chat in the
+        // app: the next key decides whether to take it back here or leave.
+        let handedToChat;
         const inputDecoder = new StringDecoder("utf8");
         const stdin = process.stdin;
         const wasRaw = stdin.isTTY ? stdin.isRaw : false;
@@ -144,6 +147,21 @@ function bridge(args, open) {
                 socket.send(JSON.stringify(payload));
         };
         const onInput = (data) => {
+            if (handedToChat) {
+                const sessionId = handedToChat;
+                handedToChat = undefined;
+                if (data[0] !== 0x0d && data[0] !== 0x0a) {
+                    finish(0);
+                    return;
+                }
+                // Reopen the chat's own TUI, resuming the same conversation; the node
+                // locks the chat again and every device sees the handoff.
+                process.stdout.write(c.dim("Taking it back…\r\n"));
+                modesReset = false;
+                const { cols, rows } = termSize();
+                send({ kind: "terminal.open.tui", sessionId, cols, rows });
+                return;
+            }
             // Ctrl-\ (0x1c) twice in a row detaches, leaving the daemon session alive.
             if (data.length === 1 && data[0] === 0x1c) {
                 const now = Date.now();
@@ -212,6 +230,17 @@ function bridge(args, open) {
                 if (typeof msg.data === "string")
                     process.stdout.write(msg.data);
             }
+            else if (type === "terminal.closed" && msg.reason === "chat" && msg.termId === termId) {
+                resetModes();
+                termId = undefined;
+                process.stdout.write(c.dim("\r\n[continued as chat in the Bivy app]\r\n"));
+                if (typeof msg.sessionId !== "string" || !msg.sessionId) {
+                    finish(0);
+                    return;
+                }
+                handedToChat = msg.sessionId;
+                process.stdout.write(`Press ${c.bold("Enter")} to take it back here, or any other key to leave.\r\n`);
+            }
             else if ((type === "terminal.exit" || type === "terminal.closed") && msg.termId === termId) {
                 const code = typeof msg.code === "number" ? msg.code : 0;
                 resetModes();
@@ -220,7 +249,7 @@ function bridge(args, open) {
             }
             else if (type === "terminal.error") {
                 process.stderr.write(c.red(`\r\n${String(msg.error || "Terminal error")}\r\n`));
-                if (!bound)
+                if (!bound || !termId)
                     finish(1);
             }
         });

package/dist/config-cli.js

@@ -108,6 +108,7 @@ const ENV_FOR_KEY = {
     "defaults.sandbox": "BIVY_SANDBOX",
     "defaults.approval": "BIVY_APPROVAL_MODE",
     "sessions.autoAttachToolImages": "BIVY_AUTO_ATTACH_TOOL_IMAGES",
+    "sessions.appScreenshots": "BIVY_APP_SCREENSHOTS",
     "automation.checks": "BIVY_AUTOMATION_CHECKS",
     "automation.checkTimeoutMinutes": "BIVY_AUTOMATION_CHECK_TIMEOUT_MS",
 };
@@ -122,6 +123,7 @@ const BUILTIN_VALUES = {
     "sessions.worktreeSync": false,
     "sessions.resume": "auto",
     "sessions.autoAttachToolImages": false,
+    "sessions.appScreenshots": false,
     "automation.checks": ["test", "lint", "typecheck"],
     "automation.checkTimeoutMinutes": 10,
 };