@bivy/bivy 0.20.0 → 0.20.1-staging.10

package/dist/access.js

@@ -0,0 +1,72 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+//
+// How this machine can be reached, as one table: the setups (this machine only,
+// Tailscale, Bivy hosted, your own server), what each gives you, and which are
+// active here. `bivy access`, `bivy status`, setup and the app all render this
+// report, so they always agree. Setups stack: each only adds to the ones before.
+export const ACCESS_FEATURES = [
+    { id: "devices", label: "Your phone and other devices" },
+    { id: "machines", label: "All your machines in one app" },
+    { id: "push", label: "Push notifications" },
+    { id: "sharing", label: "Shareable app previews" },
+];
+export const ACCESS_SETUPS = [
+    { id: "local", label: "This machine only", summary: "The terminal and a browser on this machine.", gives: { devices: 0, machines: 0, push: 0, sharing: 0 } },
+    { id: "tailscale", label: "Tailscale", summary: "Your devices reach your machines over your tailnet. No account, nothing in between.", command: "bivy access tailscale", gives: { devices: 1, machines: 1, push: 0, sharing: 0 } },
+    { id: "hosted", label: "Bivy hosted", summary: "Sign in once. Sessions stay end-to-end encrypted.", command: "bivy access hosted", gives: { devices: 2, machines: 2, push: 2, sharing: 2 } },
+    { id: "server", label: "Your own server", summary: "Like hosted, on a server you control.", command: "bivy access server <url>", gives: { devices: 2, machines: 2, push: 2, sharing: 2 } },
+];
+/** "a, b and c" (or "a and b"). */
+function and(items) {
+    return items.length < 2 ? items[0] ?? "" : `${items.slice(0, -1).join(", ")} and ${items.at(-1)}`;
+}
+const origin = (url) => {
+    try {
+        return url ? new URL(url).origin : "";
+    }
+    catch {
+        return "";
+    }
+};
+/** Which setups are active, from what the node has on disk. */
+export function activeSetups(inputs) {
+    const active = ["local"];
+    if (inputs.tailscaleHostname)
+        active.push("tailscale");
+    const relay = inputs.relay;
+    if (relay?.room && relay.roomToken)
+        active.push("server");
+    else if (relay?.controlPlaneUrl)
+        active.push(origin(relay.controlPlaneUrl) === origin(inputs.hostedControlPlane) ? "hosted" : "server");
+    return active;
+}
+export function accessReport(inputs) {
+    const active = activeSetups(inputs);
+    const reach = {};
+    for (const { id } of ACCESS_FEATURES) {
+        reach[id] = Math.max(...ACCESS_SETUPS.filter((s) => active.includes(s.id)).map((s) => s.gives[id]));
+    }
+    // Hosted and your own server are alternatives: once one is on, neither is a next step.
+    const linked = active.includes("hosted") || active.includes("server");
+    const next = ACCESS_SETUPS
+        .filter((s) => !active.includes(s.id) && !(linked && (s.id === "hosted" || s.id === "server")))
+        .map((s) => {
+        const adds = ACCESS_FEATURES.filter((f) => s.gives[f.id] > reach[f.id]);
+        // What you already have on your tailnet only widens: say "from anywhere" once for those.
+        const widened = adds.filter((f) => reach[f.id] === 1).map((f) => f.label.toLowerCase());
+        const fresh = adds.filter((f) => reach[f.id] === 0).map((f) => f.label.toLowerCase());
+        const phrases = [...(widened.length ? [`${and(widened)} from anywhere`] : []), ...fresh];
+        return { id: s.id, adds: adds.map((f) => f.id), addsText: and(phrases) };
+    })
+        .filter((s) => s.adds.length > 0);
+    return {
+        features: ACCESS_FEATURES,
+        setups: ACCESS_SETUPS.map((s) => ({ ...s, active: active.includes(s.id) })),
+        active,
+        reach,
+        next,
+        ...(inputs.tailscaleHostname ? { tailscaleUrl: `https://${inputs.tailscaleHostname}` } : {}),
+        ...(inputs.relay?.controlPlaneUrl ? { controlPlaneUrl: inputs.relay.controlPlaneUrl } : {}),
+    };
+}

package/dist/agent-instructions.js

@@ -39,9 +39,14 @@ export const BIVY_AGENT_NOTE = [
         "can check your work; `bivy app present` tells the user a visible change is ready to look at. " +
         "`bivy app --help` has the details.",
     "- Proposing tasks the user could hand you (next steps, ideas, options): post each with " +
-        '`bivy suggest "<complete instruction>" [--title "short label"]` instead of only listing them. The user can ' +
-        "start each in one tap, in this session or in a parallel one that works in its own copy of the project, so " +
-        "write it to stand on its own, with paths relative to the project root.",
+        '`bivy suggest "<complete instruction>" [--title "short label"] [--run here|subagents|new]` instead of only ' +
+        "listing them. The user can start each in one tap, in this session, through your sub-agents, or in a parallel " +
+        "one that works in its own copy of the project, so write it to stand on its own, with paths relative to the " +
+        "project root. `--run` is the one you recommend: here when it builds on this conversation, subagents for " +
+        "independent tasks you can split and supervise (only if you have sub-agents), new for bigger work worth its " +
+        "own session.",
+    '- If this session\'s title (taken from the first message) doesn\'t say what the work is, or the work changes ' +
+        'direction: `bivy title "<short title>"`.',
     "- When you finish long work, get blocked, or need the user to look at something: " +
         '`bivy notify "<message>"` (a chat card, plus a push to their phone when they are away). To ask and wait for ' +
         'an answer: `bivy ask "<question>" [--option A --option B]` prints their answer (or use your own ask-the-user tool).',

package/dist/apps/listeners.js

@@ -19,11 +19,39 @@ export async function scanListeners(workspace, platform = process.platform) {
     }
     const found = platform === "linux" ? await scanProc(root) : platform === "darwin" ? await scanLsof(root) : [];
     const byPort = new Map();
-    for (const offer of found)
+    for (const { cwd: _cwd, ...offer } of found)
         if (offer.pid !== process.pid && offer.port >= 1024 && !byPort.has(offer.port))
             byPort.set(offer.port, offer);
     return [...byPort.values()].sort((a, b) => a.port - b.port);
 }
+/** Servers running anywhere under `root` (the owner's home), each with the
+ * project it runs in: what a first session can open before it has a folder.
+ * Processes running in `root` itself or in Bivy's own data folders aren't apps. */
+export async function scanMachineListeners(root, bivyDirs = [path.join(root, ".bivy")], platform = process.platform) {
+    let top;
+    try {
+        top = await fs.realpath(root);
+    }
+    catch {
+        return [];
+    }
+    const found = platform === "linux" ? await scanProc(top) : platform === "darwin" ? await scanLsof(top) : [];
+    const byPort = new Map();
+    for (const { cwd, ...offer } of found) {
+        if (offer.pid === process.pid || offer.port < 1024 || byPort.has(offer.port) || cwd === top || bivyDirs.includes(cwd))
+            continue;
+        byPort.set(offer.port, { ...offer, project: await projectOf(cwd, top) });
+    }
+    return [...byPort.values()].sort((a, b) => a.port - b.port);
+}
+/** The nearest folder at or above `dir` (below `top`) with a .git, else `dir`. */
+async function projectOf(dir, top) {
+    for (let at = dir; inside(top, at) && at !== top; at = path.dirname(at)) {
+        if (await fs.stat(path.join(at, ".git")).then(() => true, () => false))
+            return at;
+    }
+    return dir;
+}
 const inside = (root, dir) => dir === root || dir.startsWith(root + path.sep);
 /** `local_address` in /proc/net/tcp{,6}: hex address in little-endian 32-bit words. */
 export function listenPort(line) {
@@ -73,7 +101,7 @@ async function scanProc(root) {
             return;
         const argv = (await fs.readFile(`/proc/${pid}/cmdline`, "utf8").catch(() => "")).split("\0").filter(Boolean);
         for (const port of ports)
-            offers.push({ port, pid: Number(pid), command: commandLabel(argv) });
+            offers.push({ port, pid: Number(pid), command: commandLabel(argv), cwd });
     }));
     return offers;
 }
@@ -103,7 +131,7 @@ async function scanLsof(root) {
         for (const name of values) {
             const match = /^(\*|127\.[\d.]+|\[::1\]|\[::\]|localhost):(\d+)$/.exec(name);
             if (match)
-                offers.push({ port: Number(match[2]), pid, command: commandLabel(args.split(/\s+/)) });
+                offers.push({ port: Number(match[2]), pid, command: commandLabel(args.split(/\s+/)), cwd });
         }
     }
     return offers;

package/dist/apps/service.js

@@ -6,7 +6,7 @@ import { PIN_CHANGE, REVIEW_MODES, regionChange, shouldReview, visualChange } fr
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { scanListeners } from "./listeners.js";
+import { scanListeners, scanMachineListeners } from "./listeners.js";
 import { takeShots } from "./screenshot.js";
 import { approximate, composite, crop, noteAnchor, readNotes, readStrokes, readElementScrolls } from "./annotate.js";
 import { captureFrame, encodePng, sendInput } from "./rfb.js";
@@ -44,6 +44,7 @@ export class AppService {
     terminalStarts = new Map();
     servers = new Map();
     scan;
+    scanMachine;
     serverWatchMs;
     screenshots;
     displays;
@@ -68,6 +69,7 @@ export class AppService {
         this.gateway = gateway;
         this.terminals = terminals;
         this.scan = options.scan ?? scanListeners;
+        this.scanMachine = options.scanMachine ?? scanMachineListeners;
         this.serverWatchMs = options.serverWatchMs ?? 5_000;
         this.screenshots = { enabled: options.screenshots?.enabled ?? (() => false), take: options.screenshots?.take ?? takeShots };
         this.displays = options.displays ?? NO_DISPLAYS;
@@ -330,6 +332,11 @@ export class AppService {
         const claimed = this.registry.claimedPorts(sessionId);
         return { offers: (await this.scan(workspace)).filter((offer) => !claimed.has(offer.port)) };
     }
+    /** Servers running anywhere under `root`, with their projects: what a first
+     *  session can start in and preview before it has a workspace of its own. */
+    async machineOffers(root) {
+        return { offers: await this.scanMachine(root) };
+    }
     /** 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);

package/dist/apps/styles.css

@@ -116,6 +116,7 @@ input, textarea, select { font-family: inherit; font-size: 16px; }
   padding: 9px var(--space-3); border: 0; border-radius: var(--radius-sm);
   background: transparent; color: var(--ink); font: inherit;
   font-size: var(--text-sm); text-align: left; cursor: pointer;
+  text-decoration: none; /* a menu item can be a link to another machine */
 }
 .menu-item:hover, .menu-item[aria-checked="true"], .menu-item.active { background: var(--surface-2); }
 .menu-item.danger { color: var(--danger); }
@@ -182,6 +183,7 @@ input, textarea, select { font-family: inherit; font-size: 16px; }
 .badge[data-variant="solid"][data-tone="accent"] { background: var(--accent); }
 .badge[data-variant="solid"][data-tone="ok"] { background: var(--ok); }
 .badge[data-variant="solid"][data-tone="danger"] { background: var(--danger); color: var(--danger-contrast); }
+.badge[data-variant="solid"][data-tone="unseen"] { background: var(--unseen); color: var(--unseen-contrast); }
 
 /* ---- Status ---- */
 .status-dot {
@@ -898,6 +900,9 @@ button.sheet-action:last-child { border-bottom: 0; }
    and let them wrap on a narrow phone instead of squashing. */
 .composer-lead { gap: var(--space-2); flex-wrap: wrap; }
 .composer-gh:empty { display: none; }
+/* The Apps pill keeps to the band's right edge, apart from the run pill. */
+.apps-pill { flex: none; margin-left: auto; }
+.apps-pill > svg { flex: none; color: var(--muted); }
 .pill-gh { flex: none; }
 
 /* TUI single-writer lock: full session-window interstitial (see
@@ -2310,7 +2315,7 @@ a.queue-item:hover { border-color: var(--line-strong); background: var(--surface
    cards, icon over label. Rendered by Segmented.tsx. */
 .segmented-cards { display: flex; gap: var(--space-2); flex-wrap: wrap; margin: 4px 0 10px; }
 .segmented-cards .selectable {
-  flex: 1; min-width: 92px; display: flex; flex-direction: column; align-items: center;
+  flex: 1; min-width: 72px; display: flex; flex-direction: column; align-items: center;
   gap: var(--space-2); padding: 16px 10px; font-size: var(--text-sm); font-weight: var(--weight-semibold);
 }
 .segmented-icon { display: inline-flex; }
@@ -3123,8 +3128,14 @@ p.setup-note .btn.link { min-height: 44px; margin-block: calc((1lh - 44px) / 2);
 .suggestion-eyebrow, .delegation-eyebrow, .notice-eyebrow { margin: 0; color: var(--muted); font-size: var(--text-xs); font-weight: var(--weight-semibold); }
 .suggestion-title { margin: 0; font-size: var(--text-base); font-weight: var(--weight-semibold); overflow-wrap: anywhere; }
 .suggestion-text { margin: 0; color: var(--muted); font-size: var(--text-sm); white-space: pre-wrap; overflow-wrap: anywhere; display: -webkit-box; -webkit-line-clamp: 4; -webkit-box-orient: vertical; overflow: hidden; }
-.suggestion-actions, .suggestion-all { display: flex; flex-wrap: wrap; gap: var(--space-2); margin-top: var(--space-2); }
+.suggestion-actions { display: flex; flex-wrap: wrap; gap: var(--space-2); margin-top: var(--space-2); }
+.suggestion-bar, .suggestion-all { display: flex; flex-direction: column; gap: var(--space-1); margin-top: var(--space-2); }
 .suggestion-all { padding-top: var(--space-2); border-top: 1px solid var(--line); }
+.suggestion-bar .suggestion-actions, .suggestion-all .suggestion-actions { margin-top: 0; }
+.suggestion-hint { margin: 0; color: var(--muted); font-size: var(--text-xs); }
+/* In a set, the title is the checkbox's label, so the whole line is the tap target. */
+.suggestion-pick { display: flex; align-items: flex-start; gap: var(--space-2); cursor: pointer; }
+.suggestion-pick input { flex: none; inline-size: 18px; block-size: 18px; margin: 2px 0 0; accent-color: var(--accent); }
 .suggestion-status { margin: var(--space-2) 0 0; display: flex; align-items: center; gap: var(--space-2); color: var(--ok); font-size: var(--text-sm); font-weight: var(--weight-medium); }
 /* Notice (NoticeCard.tsx): a message the agent sent with `bivy notify`.
    Shell and tone from .card, the urgent marker from .badge. */
@@ -3278,6 +3289,9 @@ p.setup-note .btn.link { min-height: 44px; margin-block: calc((1lh - 44px) / 2);
 .readiness .card-title { margin: 0 0 var(--space-1); }
 .readiness .card-sub { margin: 0; }
 .get-started-actions { display: flex; align-items: center; flex-wrap: wrap; gap: var(--space-2) var(--space-3); margin-top: var(--space-3); }
+.get-started-scan { display: flex; align-items: center; gap: var(--space-2); }
+.get-started-app { margin: var(--space-1) 0 0; overflow-wrap: anywhere; }
+.get-started-more { display: flex; align-items: center; flex-wrap: wrap; gap: var(--space-1) var(--space-2); margin-top: var(--space-2); }
 .readiness-checks { list-style: none; margin: 0; padding: 0; display: flex; flex-direction: column; gap: 4px; }
 /* Summarize completed checks so the next setup action stays visible. */
 .readiness-check.state-passed { display: none; }

package/dist/apps/tokens.css

@@ -215,6 +215,46 @@
 }
 }
 
+/* ---- Machine theme: the palette of the desktop the node runs on (Omarchy's
+   colors.toml), when Appearance is set to Machine. The app sets only the raw
+   --machine-* inputs (packages/web/src/theme.ts) and data-theme to the
+   palette's mode; every token below is derived here, so the mapping stays in
+   this file. Placed after the light/dark blocks so it wins at equal specificity. ---- */
+:root[data-machine-theme] {
+  --bg: var(--machine-background);
+  --surface: var(--machine-background);
+  --surface-2: color-mix(in srgb, var(--machine-foreground) 6%, var(--machine-background));
+  --surface-3: color-mix(in srgb, var(--machine-foreground) 11%, var(--machine-background));
+  --ink: var(--machine-foreground);
+  --muted: color-mix(in srgb, var(--machine-foreground) 68%, var(--machine-background));
+  --line: color-mix(in srgb, var(--machine-foreground) 14%, var(--machine-background));
+  --line-strong: color-mix(in srgb, var(--machine-foreground) 28%, var(--machine-background));
+  --accent: var(--machine-accent);
+  --accent-contrast: var(--machine-background);
+  --accent-hover: color-mix(in srgb, var(--machine-accent) 80%, var(--machine-foreground));
+  --accent-soft: color-mix(in srgb, var(--machine-accent) 20%, var(--machine-background));
+  --danger: var(--machine-red);
+  --danger-soft: color-mix(in srgb, var(--machine-red) 20%, var(--machine-background));
+  --danger-contrast: var(--machine-background);
+  --ok: var(--machine-green);
+  --merged: var(--machine-magenta);
+  --unseen: var(--machine-yellow);
+  --unseen-contrast: var(--machine-background);
+  --warn: var(--machine-yellow);
+  --warn-soft: color-mix(in srgb, var(--machine-yellow) 20%, var(--machine-background));
+  --term-selection: color-mix(in srgb, var(--machine-selection) 70%, transparent);
+  --term-selection-inactive: color-mix(in srgb, var(--machine-selection) 40%, transparent);
+  --syntax-comment: var(--machine-muted);
+  --syntax-keyword: var(--machine-magenta);
+  --syntax-string: var(--machine-green);
+  --syntax-number: var(--machine-orange);
+  --syntax-title: var(--machine-blue);
+  --syntax-type: var(--machine-yellow);
+  --syntax-name: var(--machine-cyan);
+  --syntax-deletion: var(--machine-red);
+  --syntax-addition: var(--machine-green);
+}
+
 @media (prefers-reduced-motion: reduce) {
   :root { --dur-fast: 0ms; --dur: 0ms; --dur-slow: 0ms; }
 }

package/dist/auth.js

@@ -112,6 +112,32 @@ export function isLoopbackAddress(address) {
     const addr = address.replace(/^::ffff:/, "");
     return addr === "127.0.0.1" || addr === "::1" || addr === "localhost";
 }
+// Sockets accepted by a listener that fronts remote callers through a local
+// proxy (`tailscale serve` forwards tailnet traffic from 127.0.0.1). Their peer
+// address is loopback, but the caller is not, so they never get loopback trust.
+const remoteSockets = new WeakMap();
+/** Treat every connection `server` accepts as remote, whatever its peer address. */
+export function markRemoteListener(server, options = {}) {
+    server.on("connection", (socket) => remoteSockets.set(socket, options));
+}
+/**
+ * `tailnet:<login>` when a request reached a remote listener from a device
+ * signed in to the tailnet as the machine's owner. The listener binds loopback,
+ * so another local account could forge the header; honor it only where local
+ * callers are trusted anyway (the same rule as the loopback bypass).
+ */
+function tailnetDevice(req) {
+    const options = req.socket ? remoteSockets.get(req.socket) : undefined;
+    const owner = options?.trustedLogin?.()?.toLowerCase();
+    const login = req.headers["tailscale-user-login"];
+    if (!owner || typeof login !== "string" || login.toLowerCase() !== owner)
+        return null;
+    return loopbackAllowed() ? `tailnet:${owner}` : null;
+}
+/** True when a request physically arrived over loopback from a local caller. */
+export function isLoopbackRequest(req) {
+    return !!req.socket && !remoteSockets.has(req.socket) && isLoopbackAddress(req.socket.remoteAddress);
+}
 export function extractToken(headerValue) {
     if (!headerValue)
         return null;
@@ -141,8 +167,8 @@ export function tokenFromRequest(req) {
  * `/api/auth/bootstrap`) can rely on it even when the general bypass in
  * `isAuthorized` is off. */
 export function resolveAuth(identity, req) {
-    const loopback = isLoopbackAddress(req.socket?.remoteAddress);
-    const deviceId = identity.verifyToken(tokenFromRequest(req));
+    const loopback = isLoopbackRequest(req);
+    const deviceId = identity.verifyToken(tokenFromRequest(req)) ?? tailnetDevice(req);
     return { deviceId, loopback };
 }
 export function isAuthorized(ctx) {
@@ -160,7 +186,8 @@ export function isAuthorized(ctx) {
  * web client (?local=1), a LAN device browsing the node directly, or CLI/native
  * clients (no Origin).
  * Remote phones reach the node through the relay, which the node dials
- * *outbound* — those never arrive here as inbound upgrades. So we allow only
+ * *outbound* — those never arrive here as inbound upgrades — or over Tailscale
+ * on the `*.ts.net` name, which counts as local here. So we allow only
  * local/private hostnames and reject a public Host (rebinding) or public Origin
  * (cross-site). Escape hatches: BIVY_ALLOWED_HOSTS (comma-separated extra
  * hostnames, e.g. a reverse-proxy domain) and BIVY_ALLOW_ANY_ORIGIN=1.
@@ -272,7 +299,7 @@ export function authMiddleware(identity, sessionTokens) {
                 return;
             }
             sessionTokens.used?.(sessionId, call);
-            req.auth = { deviceId: null, loopback: isLoopbackAddress(req.socket?.remoteAddress), sessionId };
+            req.auth = { deviceId: null, loopback: isLoopbackRequest(req), sessionId };
             next();
             return;
         }

package/dist/controllers/app-commands.js

@@ -1,4 +1,8 @@
-export function createAppCommands(service, workspaceFor, published = () => { }) {
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+import os from "node:os";
+/** `machineRoot`: where servers are looked for before a session exists (the owner's home). */
+export function createAppCommands(service, workspaceFor, published = () => { }, machineRoot = os.homedir) {
     const workspaceOf = (sessionId) => {
         const workspace = workspaceFor(sessionId);
         if (!workspace)
@@ -13,7 +17,8 @@ export function createAppCommands(service, workspaceFor, published = () => { })
             published(app);
             return { app };
         },
-        "apps.offers": (msg) => service.offers(String(msg.sessionId), workspaceOf(String(msg.sessionId))),
+        // Without a session: servers anywhere in the owner's home, for a first session to open.
+        "apps.offers": (msg) => typeof msg.sessionId === "string" ? service.offers(msg.sessionId, workspaceOf(msg.sessionId)) : service.machineOffers(machineRoot()),
         "apps.adopt": async (msg) => {
             const sessionId = String(msg.sessionId);
             const app = await service.adopt(sessionId, workspaceOf(sessionId), Number(msg.port));

package/dist/machine-theme.js

@@ -0,0 +1,118 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+//
+// The desktop theme of the machine a node runs on, so the app can match it.
+// Today that is Omarchy: `omarchy-theme-set` stages the active theme's
+// `colors.toml`, which this reads, resolves the way Omarchy does (legacy names
+// and ANSI fallbacks) and sends to clients as `node.theme`. Another desktop is
+// another row in THEME_SOURCES.
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export const MACHINE_COLORS = ["background", "foreground", "accent", "selection", "muted", "red", "green", "yellow", "blue", "magenta", "cyan", "orange"];
+/** Where a desktop keeps its active palette. Checked in order; the first that exists wins. */
+export const THEME_SOURCES = [
+    // Omarchy 3.2+: the staged, generated copy of the active theme.
+    { colors: ".local/state/omarchy/current/theme/colors.toml", name: ".local/state/omarchy/current/theme.name" },
+    // Earlier Omarchy: a symlink to the active theme's directory.
+    { colors: ".config/omarchy/current/theme/colors.toml", name: null },
+];
+// Omarchy's own resolution order (bin/omarchy-theme-color): each key's
+// candidates, first defined wins. Legacy short names and ANSI colorN come last.
+const FALLBACKS = {
+    background: ["background", "bg", "color0"],
+    foreground: ["foreground", "fg", "color7"],
+    accent: ["accent", "blue", "color4"],
+    selection: ["selection", "selection_background", "color8", "color0", "background", "bg"],
+    muted: ["muted", "color8", "dark_foreground", "dark_fg", "foreground", "fg", "color7"],
+    red: ["red", "color1"],
+    green: ["green", "color2"],
+    yellow: ["yellow", "color3"],
+    blue: ["blue", "color4"],
+    magenta: ["magenta", "purple", "color5"],
+    cyan: ["cyan", "color6"],
+    orange: ["orange", "yellow", "color3"],
+};
+const HEX = /^#(?:[0-9a-f]{3}|[0-9a-f]{6})$/i;
+/** `key = "value"` pairs from a flat TOML palette; comments and tables ignored. */
+export function parseFlatToml(text) {
+    const out = {};
+    for (const line of text.split("\n")) {
+        const match = /^\s*([A-Za-z0-9_-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^#\s]+))/.exec(line);
+        if (match)
+            out[match[1]] = (match[2] ?? match[3] ?? match[4] ?? "").trim();
+    }
+    return out;
+}
+function expand(hex) {
+    const h = hex.toLowerCase();
+    return h.length === 4 ? `#${h[1]}${h[1]}${h[2]}${h[2]}${h[3]}${h[3]}` : h;
+}
+function isLight(hex) {
+    const n = Number.parseInt(hex.slice(1), 16);
+    return ((n >> 16) & 255) + ((n >> 8) & 255) + (n & 255) > 382;
+}
+/** A palette the app can use, or null when the file lacks a usable background and foreground. */
+export function resolveMachineTheme(raw, name, lightModeFile = false) {
+    const colors = {};
+    for (const key of MACHINE_COLORS) {
+        const value = FALLBACKS[key].map((candidate) => raw[candidate]).find((v) => v && HEX.test(v));
+        if (value)
+            colors[key] = expand(value);
+    }
+    if (!colors.background || !colors.foreground)
+        return null;
+    // Anything still missing falls back to the ink, so the app never mixes in a stray default.
+    for (const key of MACHINE_COLORS)
+        colors[key] ??= colors.foreground;
+    const declared = raw.mode ?? raw.theme_type;
+    const mode = declared === "light" || declared === "dark" ? declared : lightModeFile || isLight(colors.background) ? "light" : "dark";
+    return { name, mode, colors };
+}
+function titleCase(slug) {
+    return slug.replace(/(^|-)([a-z])/g, (_m, sep, c) => `${sep ? " " : ""}${c.toUpperCase()}`);
+}
+/** The machine's active theme, or null when no known desktop theme is present. */
+export function readMachineTheme(home = os.homedir()) {
+    for (const source of THEME_SOURCES) {
+        const colorsPath = path.join(home, source.colors);
+        let text;
+        try {
+            text = fs.readFileSync(colorsPath, "utf8");
+        }
+        catch {
+            continue;
+        }
+        const dir = path.dirname(colorsPath);
+        let slug = "";
+        try {
+            slug = source.name ? fs.readFileSync(path.join(home, source.name), "utf8").trim() : path.basename(fs.realpathSync(dir));
+        }
+        catch {
+            /* unnamed theme */
+        }
+        return resolveMachineTheme(parseFlatToml(text), titleCase(slug || "machine"), fs.existsSync(path.join(dir, "light.mode")));
+    }
+    return null;
+}
+/**
+ * Call `onChange` whenever the machine's theme changes (a theme switch
+ * replaces the staged directory, so this polls the file's stat rather than
+ * holding an inotify watch on a directory that goes away). Returns a stop function.
+ */
+export function watchMachineTheme(onChange, home = os.homedir(), intervalMs = 1500) {
+    let last = JSON.stringify(readMachineTheme(home));
+    const check = () => {
+        const theme = readMachineTheme(home);
+        const next = JSON.stringify(theme);
+        if (next === last)
+            return;
+        last = next;
+        onChange(theme);
+    };
+    const paths = THEME_SOURCES.flatMap((source) => [source.colors, source.name]).filter((p) => !!p).map((p) => path.join(home, p));
+    for (const p of paths)
+        fs.watchFile(p, { interval: intervalMs, persistent: false }, check);
+    return () => { for (const p of paths)
+        fs.unwatchFile(p, check); };
+}

package/dist/node-update.js

@@ -2,6 +2,22 @@ import fs from "node:fs";
 import path from "node:path";
 import { gt, valid } from "semver";
 /** Match the channel recorded by install.sh and `bivy update`. */
+/**
+ * `{ manager, update }` when a system package manager owns this install (the
+ * AUR's `bivy` writes `.bivy-install.json`, as bin/install-kind.mjs reads it for
+ * the CLI), so the node must not replace its files; null otherwise.
+ */
+export function managedInstall(packageRoot) {
+    try {
+        const data = JSON.parse(fs.readFileSync(path.join(packageRoot, ".bivy-install.json"), "utf8"));
+        if (typeof data.manager === "string" && data.manager)
+            return { manager: data.manager, update: typeof data.update === "string" ? data.update : "" };
+    }
+    catch {
+        /* not managed */
+    }
+    return null;
+}
 export function updateRegistryUrl(appDir, override) {
     if (override)
         return override;

package/dist/pair-codes.js

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+//
+// One-time pairing codes for devices that reach the node directly (over
+// Tailscale). The owner mints a code on the machine (`bivy tailscale pair`),
+// the phone opens `https://<machine>.ts.net/#pair=<code>` and trades the code
+// for a device token. Codes are single-use, short-lived and held only in
+// memory, so a restart invalidates every outstanding one.
+import { createHash, randomBytes } from "node:crypto";
+export const PAIR_CODE_TTL_MS = 10 * 60 * 1000;
+const digest = (code) => createHash("sha256").update(code).digest("hex");
+export class PairCodes {
+    now;
+    // Keyed by the code's hash, so a lookup never compares secrets directly.
+    pending = new Map();
+    constructor(now = Date.now) {
+        this.now = now;
+    }
+    issue(ttlMs = PAIR_CODE_TTL_MS) {
+        this.sweep();
+        const code = randomBytes(24).toString("base64url");
+        const expiresAt = this.now() + ttlMs;
+        this.pending.set(digest(code), expiresAt);
+        return { code, expiresAt };
+    }
+    /** True once per valid, unexpired code; the code is spent either way. */
+    redeem(code) {
+        if (!code)
+            return false;
+        const key = digest(code);
+        const expiresAt = this.pending.get(key);
+        this.pending.delete(key);
+        return expiresAt !== undefined && expiresAt > this.now();
+    }
+    sweep() {
+        const now = this.now();
+        for (const [key, expiresAt] of this.pending)
+            if (expiresAt <= now)
+                this.pending.delete(key);
+    }
+}

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

@@ -5,6 +5,8 @@
 export const CLIENT_COMMAND_ROUTES = [
     ...["list", "publish", "offers", "adopt", "open", "logs", "shot", "input", "menu", "present", "showMe", "mute", "reviewMode", "annotate", "clearNotes", "agentNotes", "notes", "share", "unshare", "revoke", "remove"].map((action) => ({ method: "post", path: `/api/apps/${action}`, kind: `apps.${action}` })),
     { method: "post", path: "/api/artifacts/list", kind: "artifacts.list" },
+    { method: "post", path: "/api/access/get", kind: "access.get" },
+    { method: "post", path: "/api/tailnet/machines", kind: "tailnet.machines" },
     { 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" },

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

@@ -11,9 +11,11 @@ export const CLIENT_COMMAND_SCHEMAS = {
     ping: Type.Object(request),
     "apps.list": Type.Object({ ...request, ...optionalSession }),
     "artifacts.list": Type.Object(request),
+    "access.get": Type.Object(request),
+    "tailnet.machines": Type.Object(request),
     "session.fork.local": Type.Object({ ...request, ...session, model: Type.Optional(Type.Object({ provider: Type.Optional(Type.String({ maxLength: 200 })), id: Type.String({ maxLength: 200 }) })) }),
     "apps.publish": Type.Object({ ...request, ...session, manifest: Type.Unknown() }),
-    "apps.offers": Type.Object({ ...request, ...session }),
+    "apps.offers": Type.Object({ ...request, ...optionalSession }),
     "apps.adopt": Type.Object({ ...request, ...session, port: Type.Integer({ minimum: 1024, maximum: 65535 }) }),
     "apps.open": Type.Object({ ...request, ...session, appId: Type.String(), viewId: Type.String(), returnTo: Type.Optional(Type.String({ maxLength: 2048 })), direct: Type.Optional(Type.Boolean()), scale: Type.Optional(Type.Integer({ minimum: 1, maximum: 2 })), path: Type.Optional(Type.String({ maxLength: 2048 })) }),
     "apps.shot": Type.Object({ ...request, ...session, appId: Type.Optional(Type.String()), widths: Type.Optional(Type.Array(Type.Integer(), { maxItems: 4 })), themes: Type.Optional(Type.Array(Type.Union([Type.Literal("light"), Type.Literal("dark")]), { maxItems: 2 })), path: Type.Optional(Type.String({ maxLength: 2048 })) }),

package/dist/remote/direct.js

@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+//
+// Direct access over Tailscale: no control plane, no relay. `bivy tailscale`
+// writes `<data-dir>/tailscale.json` and points `tailscale serve` (HTTPS on the
+// machine's ts.net name, tailnet only) at a loopback port; the node opens that
+// port as its direct listener. Every connection on it is treated as remote, so
+// callers need a device token, which a phone gets by redeeming a pairing code.
+import fs from "node:fs";
+import path from "node:path";
+export const DIRECT_CONFIG_FILE = "tailscale.json";
+export function loadDirectListenerConfig(appDir) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(path.join(appDir, DIRECT_CONFIG_FILE), "utf8"));
+        const port = Number(raw.port);
+        if (!Number.isInteger(port) || port <= 0 || port > 65535)
+            return null;
+        const text = (value) => (typeof value === "string" && value ? value : undefined);
+        return { port, hostname: text(raw.hostname), owner: text(raw.owner) };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/remote/index.js

@@ -12,3 +12,5 @@
 // promote to a standalone `@bivy/remote` npm package.
 export { RelayConnector, loadRelayConfig } from "./relay-client.js";
 export { soloCredentials, buildDialUrl } from "./solo.js";
+export { loadDirectListenerConfig, DIRECT_CONFIG_FILE } from "./direct.js";
+export { discoverTailnetMachines, parseTailnetPeers } from "./tailnet.js";