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

package/dist/apps/styles.css

@@ -300,6 +300,7 @@ input, textarea, select { font-family: inherit; font-size: 16px; }
 }
 .side-pane-tabs { min-width: 0; overflow-x: auto; }
 .side-pane-tab { display: inline-flex; align-items: center; gap: var(--space-1); }
+.side-pane-tabs .side-pane-tab { padding-inline: var(--space-2); }
 .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); }
@@ -330,6 +331,46 @@ input, textarea, select { font-family: inherit; font-size: 16px; }
 .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)); }
+
+/* ---- Files: read-only browser over the session's workspace ---- */
+.files-browser, .files-viewer { display: flex; flex-direction: column; gap: var(--space-2); min-width: 0; }
+.files-toolbar { display: flex; align-items: center; justify-content: space-between; gap: var(--space-2); padding-bottom: var(--space-2); border-bottom: 1px solid var(--line); }
+.files-toolbar-meta { font-size: var(--text-xs); color: var(--muted); }
+.files-tree { display: flex; flex-direction: column; }
+.files-row {
+  display: flex; align-items: center; gap: var(--space-1); width: 100%; min-height: 32px;
+  padding: var(--space-1) var(--space-2) var(--space-1) var(--space-1);
+  background: transparent; border: 0; border-radius: var(--radius-sm); color: var(--ink);
+  font: inherit; font-size: var(--text-sm); text-align: left; cursor: pointer;
+}
+.files-row:hover:not(:disabled) { background: var(--surface-2); }
+.files-row:disabled { cursor: default; color: var(--muted); }
+.files-row[data-status="deleted"] .files-name { text-decoration: line-through; }
+.files-row-note { cursor: default; color: var(--muted); font-size: var(--text-xs); gap: var(--space-2); }
+.files-row-note:hover { background: transparent; }
+.files-row-error { color: var(--danger); }
+@media (pointer: coarse) { .files-row { min-height: 40px; } }
+.files-name { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-family: var(--font-mono); font-size: var(--text-xs); }
+.files-meta { flex: none; font-size: var(--text-xs); color: var(--muted); }
+.files-changed { color: var(--accent); }
+.files-mark { flex: none; width: 1.25em; text-align: center; font-family: var(--font-mono); font-weight: var(--weight-bold); }
+.files-mark[data-status="added"] { color: var(--add); }
+.files-mark[data-status="modified"] { color: var(--accent); }
+.files-mark[data-status="deleted"] { color: var(--del); }
+.files-viewer-head { display: flex; align-items: center; gap: var(--space-1); }
+.files-viewer-path { flex: 1; min-width: 0; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-family: var(--font-mono); font-size: var(--text-xs); font-weight: var(--weight-semibold); }
+.files-viewer-meta { display: flex; flex-wrap: wrap; align-items: center; gap: var(--space-1) var(--space-3); font-size: var(--text-xs); color: var(--muted); }
+.files-code {
+  display: flex; min-width: 0; overflow: auto; max-height: none;
+  border: 1px solid var(--line); border-radius: var(--radius-sm); background: var(--surface-2);
+  font-family: var(--font-mono); font-size: var(--text-xs); line-height: var(--lh-xs);
+}
+.files-code pre { margin: 0; padding: var(--space-2) 0; background: none; border: 0; font: inherit; white-space: pre; }
+.files-code .files-gutter { flex: none; position: sticky; left: 0; padding-inline: var(--space-2); text-align: right; color: var(--muted); background: var(--surface-2); border-right: 1px solid var(--line); user-select: none; }
+.files-code .files-source { flex: 1; padding-inline: var(--space-3); }
+.files-source code { display: block; background: none; padding: 0; color: var(--ink); }
+.files-image { display: flex; justify-content: center; padding: var(--space-3); border: 1px solid var(--line); border-radius: var(--radius-sm); background: var(--surface-2); }
+.files-image img { max-width: 100%; height: auto; }
 .topbar-actions .side-pane-toggle[aria-pressed="true"] { color: var(--accent); background: var(--accent-soft); }
 
 /* ---- Header session actions (dot-menu: rename / open PR / delete) ---- */

package/dist/controllers/file-commands.js

@@ -0,0 +1,208 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+//
+// Read-only file browser over a session's workspace (its worktree, or the
+// directory it runs in): list one directory, read one file. Lets a person look
+// at what the agent is working on before anything is committed or pushed. Every
+// path is confined to the workspace — `..`, absolute paths and symlinks that
+// resolve outside it are refused — and nothing here ever writes.
+import { execFile } from "node:child_process";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+const exec = promisify(execFile);
+/** Text past this is cut (and says so); a viewer, not an editor. */
+export const MAX_TEXT_BYTES = 1024 * 1024;
+export const MAX_IMAGE_BYTES = 8 * 1024 * 1024;
+/** A directory this big is cut so one listing can't flood the link. */
+export const MAX_DIR_ENTRIES = 2000;
+/** Never listed: git's own store says nothing about the work. */
+const HIDDEN = new Set([".git"]);
+const IMAGE_TYPES = {
+    ".png": "image/png", ".jpg": "image/jpeg", ".jpeg": "image/jpeg", ".gif": "image/gif",
+    ".webp": "image/webp", ".avif": "image/avif", ".bmp": "image/bmp", ".ico": "image/x-icon",
+};
+export class WorkspacePathError extends Error {
+}
+/** Normalise a client path to workspace-relative `a/b`, or throw if it climbs out. */
+export function relativeWorkspacePath(input) {
+    const raw = (input ?? "").replace(/\\/g, "/").trim();
+    if (raw.startsWith("/") || /^[a-zA-Z]:/.test(raw))
+        throw new WorkspacePathError("Paths are relative to the workspace.");
+    const parts = [];
+    for (const part of raw.split("/")) {
+        if (!part || part === ".")
+            continue;
+        if (part === "..")
+            throw new WorkspacePathError("That path is outside the workspace.");
+        parts.push(part);
+    }
+    if (parts.some((part) => HIDDEN.has(part)))
+        throw new WorkspacePathError("That path is not browsable.");
+    return parts.join("/");
+}
+/** Resolve `rel` inside `root`, following symlinks, refusing anything that lands outside. */
+async function confined(root, rel) {
+    const realRoot = await fs.realpath(root);
+    const abs = path.join(realRoot, rel);
+    const real = await fs.realpath(abs).catch((error) => {
+        if (error.code === "ENOENT")
+            throw new WorkspacePathError("That file no longer exists.");
+        throw error;
+    });
+    if (real !== realRoot && !real.startsWith(realRoot + path.sep))
+        throw new WorkspacePathError("That path is outside the workspace.");
+    return { abs, real, realRoot };
+}
+/** Uncommitted files by workspace-relative path; null when not a git checkout. */
+export async function gitStatus(root) {
+    try {
+        const opts = { cwd: root, maxBuffer: 32 * 1024 * 1024, timeout: 10_000 };
+        // Porcelain paths are repo-relative; the workspace may be a subdirectory.
+        const [{ stdout: prefix }, { stdout }] = await Promise.all([
+            exec("git", ["rev-parse", "--show-prefix"], opts),
+            exec("git", ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", "."], opts),
+        ]);
+        return parseGitStatus(stdout, prefix.trim());
+    }
+    catch {
+        return null;
+    }
+}
+/** `git status --porcelain=v1 -z` → path → status. A rename shows as its new path, added. */
+export function parseGitStatus(stdout, prefix = "") {
+    const out = new Map();
+    const records = stdout.split("\0");
+    for (let i = 0; i < records.length; i++) {
+        const record = records[i];
+        if (record.length < 4)
+            continue;
+        const code = record.slice(0, 2);
+        const file = record.slice(3);
+        // Renames and copies carry the source path as the next record.
+        if (code.includes("R") || code.includes("C"))
+            i++;
+        if (code === "!!" || !file.startsWith(prefix))
+            continue;
+        out.set(file.slice(prefix.length), code === "??" || code.includes("A") || code.includes("R") || code.includes("C") ? "added" : code.includes("D") ? "deleted" : "modified");
+    }
+    return out;
+}
+export async function listWorkspaceDir(root, input) {
+    const rel = relativeWorkspacePath(input);
+    const { real } = await confined(root, rel);
+    const stat = await fs.stat(real);
+    if (!stat.isDirectory())
+        throw new WorkspacePathError("That path is not a folder.");
+    const [dirents, status] = await Promise.all([fs.readdir(real, { withFileTypes: true }), gitStatus(root)]);
+    const prefix = rel ? `${rel}/` : "";
+    const entries = [];
+    for (const dirent of dirents) {
+        if (HIDDEN.has(dirent.name))
+            continue;
+        const entryPath = prefix + dirent.name;
+        let isDir = dirent.isDirectory();
+        let size;
+        let mtime;
+        try {
+            const s = await fs.stat(path.join(real, dirent.name));
+            isDir = s.isDirectory();
+            size = isDir ? undefined : s.size;
+            mtime = s.mtimeMs;
+        }
+        catch { /* a dangling symlink: list it, reading it says why */ }
+        entries.push({
+            name: dirent.name,
+            path: entryPath,
+            type: isDir ? "dir" : "file",
+            ...(size !== undefined ? { size } : {}),
+            ...(mtime !== undefined ? { mtime: Math.round(mtime) } : {}),
+            ...(dirent.isSymbolicLink() ? { symlink: true } : {}),
+        });
+    }
+    // Deleted files are gone from disk but are part of what changed: show them here.
+    const present = new Set(entries.map((entry) => entry.name));
+    for (const [file, state] of status ?? []) {
+        if (state !== "deleted" || !file.startsWith(prefix))
+            continue;
+        const name = file.slice(prefix.length);
+        if (!name.includes("/") && !present.has(name))
+            entries.push({ name, path: file, type: "file", status: "deleted" });
+    }
+    for (const entry of entries) {
+        if (!status)
+            break;
+        if (entry.type === "file") {
+            const state = status.get(entry.path);
+            if (state)
+                entry.status = state;
+        }
+        else {
+            let changed = 0;
+            for (const file of status.keys())
+                if (file.startsWith(`${entry.path}/`))
+                    changed++;
+            if (changed)
+                entry.changed = changed;
+        }
+    }
+    entries.sort((a, b) => (a.type === b.type ? a.name.localeCompare(b.name) : a.type === "dir" ? -1 : 1));
+    return { path: rel, entries: entries.slice(0, MAX_DIR_ENTRIES), git: status !== null };
+}
+function looksBinary(bytes) {
+    const head = bytes.subarray(0, 8000);
+    return head.includes(0);
+}
+export async function readWorkspaceFile(root, input) {
+    const rel = relativeWorkspacePath(input);
+    if (!rel)
+        throw new WorkspacePathError("Choose a file.");
+    const { real } = await confined(root, rel);
+    const stat = await fs.stat(real);
+    if (!stat.isFile())
+        throw new WorkspacePathError("That path is not a file.");
+    const status = (await gitStatus(root))?.get(rel);
+    const base = { path: rel, size: stat.size, mtime: Math.round(stat.mtimeMs), ...(status ? { status } : {}) };
+    const mimeType = IMAGE_TYPES[path.extname(rel).toLowerCase()];
+    if (mimeType) {
+        if (stat.size > MAX_IMAGE_BYTES)
+            return { ...base, kind: "too-large" };
+        return { ...base, kind: "image", mimeType, data: (await fs.readFile(real)).toString("base64") };
+    }
+    const handle = await fs.open(real, "r");
+    try {
+        const length = Math.min(stat.size, MAX_TEXT_BYTES);
+        const bytes = Buffer.alloc(length);
+        await handle.read(bytes, 0, length, 0);
+        if (looksBinary(bytes))
+            return { ...base, kind: "binary" };
+        return { ...base, kind: "text", content: bytes.toString("utf8"), truncated: stat.size > MAX_TEXT_BYTES };
+    }
+    finally {
+        await handle.close();
+    }
+}
+/** `workspaceFor`: the directory a session works in, if this machine has it. */
+export function createFileCommands(workspaceFor) {
+    const operations = {
+        "files.list": (root, msg) => listWorkspaceDir(root, typeof msg.path === "string" ? msg.path : undefined),
+        "files.read": async (root, msg) => ({ file: await readWorkspaceFile(root, String(msg.path ?? "")) }),
+    };
+    return Object.fromEntries(Object.entries(operations).map(([kind, run]) => [kind, async (msg, ctx) => {
+            try {
+                const root = workspaceFor(String(msg.sessionId ?? ""));
+                if (!root)
+                    throw new WorkspacePathError("This session's workspace isn't on this machine.");
+                ctx.reply({ type: `${kind}.ok`, requestId: msg.requestId, ...await run(root, msg) });
+            }
+            catch (error) {
+                // Raw filesystem errors carry host paths; say what happened without them.
+                const code = error?.code;
+                const message = error instanceof WorkspacePathError ? error.message
+                    : code === "ENOENT" ? "That file no longer exists."
+                        : code === "EACCES" || code === "EPERM" ? "Permission denied."
+                            : "Could not read that path.";
+                ctx.reply({ type: `${kind}.error`, requestId: msg.requestId, httpStatus: 400, error: message });
+            }
+        }]));
+}

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

@@ -5,6 +5,7 @@
 export const CLIENT_COMMAND_ROUTES = [
     ...["list", "publish", "offers", "adopt", "open", "logs", "requests", "request", "runRequest", "data", "serverLog", "shot", "input", "menu", "present", "scenarios", "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" },
+    ...["list", "read"].map((action) => ({ method: "post", path: `/api/files/${action}`, kind: `files.${action}` })),
     { 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" },

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

@@ -13,6 +13,8 @@ export const CLIENT_COMMAND_SCHEMAS = {
     ping: Type.Object(request),
     "apps.list": Type.Object({ ...request, ...optionalSession }),
     "artifacts.list": Type.Object(request),
+    "files.list": Type.Object({ ...request, ...session, path: Type.Optional(Type.String({ maxLength: 4096 })) }),
+    "files.read": Type.Object({ ...request, ...session, path: Type.String({ minLength: 1, maxLength: 4096 }) }),
     "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 }) })) }),

package/dist/server.js

@@ -41,6 +41,7 @@ import { AGENT_PROFILES } from "./agents/profiles.js";
 import { pngSize, reviewHint } from "./apps/review.js";
 import { createDisplayHost } from "./apps/display.js";
 import { createAppCommands } from "./controllers/app-commands.js";
+import { createFileCommands } from "./controllers/file-commands.js";
 import { bindClientCommandRoutes } from "./http/client-command-routes.js";
 import { collectDiscoveredSessions, planNativeAdoption } from "./runtime/native-session-discovery.js";
 import { aggregateModelCatalog, catalogReplyEvent, mergeProviderCatalog } from "./runtime/model-catalog.js";
@@ -2385,6 +2386,15 @@ 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") });
     },
+    // Read-only browsing of a session's workspace: an open session's worktree,
+    // else the one metadata remembers, else a live terminal run's directory.
+    ...createFileCommands((id) => {
+        const record = resolveSession(id);
+        if (record)
+            return harnessDirFor(record);
+        const meta = metadata.getSession(id);
+        return meta?.worktree || meta?.workspace || runTerms.liveRun(id)?.workspace;
+    }),
     ...createArtifactCommands({
         sessionIds: () => new Set([...metadata.listSessions().map((session) => session.id), ...[...openSessions.values()].map((record) => record.id)]),
         scan: (id) => eventLog.scan(id, ["outbound-attachment"]),

package/package.json

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