@bivy/bivy 0.17.3-staging.9 → 0.18.0

package/dist/apps/review.js

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (c) 2026 Petter André Sjulstad
+import { inflateSync } from "node:zlib";
+/** What each review-card mode lets through. `present`: the agent's
+ * `bivy app present` makes a card. `minChange`: at the end of a run whose
+ * preview changed, the share of pixels that must differ from the page before
+ * the run; undefined = never on its own. A new mode is a new row. */
+export const REVIEW_MODES = {
+    // ~8×8 CSS px at 2× on a phone-sized page: a moved button or changed
+    // label, not a blinking caret (~0.01%).
+    ready: { present: true, minChange: 0.0002 },
+    every: { present: true, minChange: 0 },
+    off: { present: false },
+};
+/** Whether a moment gets a review card. Show me ("asked") is the user's own
+ * request, so it always does. Without a baseline, a run can't prove a visible
+ * change, so it gets no card: a backend-only run must never produce one. */
+export function shouldReview(input) {
+    if (input.trigger === "asked")
+        return true;
+    if (input.muted)
+        return false;
+    const rule = REVIEW_MODES[input.mode];
+    if (input.trigger === "present")
+        return rule.present;
+    return input.revisionChanged && rule.minChange !== undefined && input.change !== undefined && input.change > rule.minChange;
+}
+/** What the "session finished" notification carries about a review: IDs only.
+ * The device fetches the screenshot over the encrypted session channel. */
+export function reviewHint(review) {
+    return {
+        review: { appId: review.appId, viewId: review.viewId, reviewId: review.id },
+        body: review.trigger === "notes"
+            ? `${review.notes === 1 ? "A reviewer note is" : `${review.notes ?? "Reviewer"} notes are`} waiting on ${review.name} — tap to read ${review.notes === 1 ? "it" : "them"}.`
+            : `${review.name} ${review.trigger === "present" ? "is ready to review" : "changed"} — tap to see it.`,
+    };
+}
+/** Decodes the 8-bit, non-interlaced RGB(A) PNGs Chrome and rfb.ts write. */
+export function decodePng(png) {
+    if (png.readUInt32BE(0) !== 0x89504e47)
+        throw new Error("Not a PNG.");
+    let offset = 8, width = 0, height = 0, channels = 0;
+    const data = [];
+    while (offset < png.length) {
+        const length = png.readUInt32BE(offset);
+        const type = png.toString("latin1", offset + 4, offset + 8);
+        const chunk = png.subarray(offset + 8, offset + 8 + length);
+        if (type === "IHDR") {
+            width = chunk.readUInt32BE(0);
+            height = chunk.readUInt32BE(4);
+            const [depth, color, , , interlace] = chunk.subarray(8, 13);
+            channels = color === 6 ? 4 : color === 2 ? 3 : 0;
+            if (depth !== 8 || !channels || interlace)
+                throw new Error("Unsupported PNG.");
+        }
+        else if (type === "IDAT")
+            data.push(chunk);
+        else if (type === "IEND")
+            break;
+        offset += 12 + length;
+    }
+    const raw = inflateSync(Buffer.concat(data));
+    const stride = width * channels;
+    const pixels = Buffer.alloc(stride * height);
+    for (let y = 0; y < height; y++) {
+        const filter = raw[y * (stride + 1)];
+        const line = raw.subarray(y * (stride + 1) + 1, (y + 1) * (stride + 1));
+        const out = y * stride;
+        for (let x = 0; x < stride; x++) {
+            const a = x >= channels ? pixels[out + x - channels] : 0;
+            const b = y ? pixels[out - stride + x] : 0;
+            const c = y && x >= channels ? pixels[out - stride + x - channels] : 0;
+            let value = line[x];
+            if (filter === 1)
+                value += a;
+            else if (filter === 2)
+                value += b;
+            else if (filter === 3)
+                value += (a + b) >> 1;
+            else if (filter === 4) {
+                const p = a + b - c, pa = Math.abs(p - a), pb = Math.abs(p - b), pc = Math.abs(p - c);
+                value += pa <= pb && pa <= pc ? a : pb <= pc ? b : c;
+            }
+            pixels[out + x] = value & 0xff;
+        }
+    }
+    return { width, height, channels, pixels };
+}
+/** Share of pixels that visibly differ (0–1). Different sizes count as a
+ * full change: the page grew or shrank. */
+export function visualChange(before, after) {
+    if (before.equals(after))
+        return 0;
+    const a = decodePng(before), b = decodePng(after);
+    if (a.width !== b.width || a.height !== b.height)
+        return 1;
+    let changed = 0;
+    for (let i = 0, p = 0; p < a.width * a.height; p++, i += a.channels) {
+        const j = p * b.channels;
+        const delta = Math.abs(a.pixels[i] - b.pixels[j]) + Math.abs(a.pixels[i + 1] - b.pixels[j + 1]) + Math.abs(a.pixels[i + 2] - b.pixels[j + 2]);
+        // Re-renders of the same page are pixel-identical; this only skips
+        // sub-pixel antialiasing shifts, not a light grey on white.
+        if (delta > 12)
+            changed++;
+    }
+    return changed / (a.width * a.height);
+}
+/** PNG dimensions, from the header. */
+export function pngSize(png) {
+    return { width: png.readUInt32BE(16), height: png.readUInt32BE(20) };
+}

package/dist/apps/rfb.js

@@ -5,18 +5,21 @@ import { deflateSync } from "node:zlib";
 /** Reads exact byte counts from a stream. */
 class Reader {
     buffer = Buffer.alloc(0);
+    /** Chunks not yet joined onto `buffer`: joined once enough have arrived, so a large frame isn't copied per chunk. */
+    chunks = [];
+    queued = 0;
     waiting;
     failure;
     reject;
     constructor(socket) {
-        socket.on("data", (chunk) => { this.buffer = Buffer.concat([this.buffer, chunk]); this.pump(); });
+        socket.on("data", (chunk) => { this.chunks.push(chunk); this.queued += chunk.length; this.pump(); });
         const fail = (error) => { this.failure = error; this.reject?.(error); };
         socket.on("error", fail);
         socket.on("close", () => fail(new Error("The display closed the connection.")));
     }
     read(n) {
         return new Promise((resolve, reject) => {
-            if (this.failure && this.buffer.length < n) {
+            if (this.failure && this.buffer.length + this.queued < n) {
                 reject(this.failure);
                 return;
             }
@@ -26,8 +29,13 @@ class Reader {
         });
     }
     pump() {
-        if (!this.waiting || this.buffer.length < this.waiting.n)
+        if (!this.waiting || this.buffer.length + this.queued < this.waiting.n)
             return;
+        if (this.buffer.length < this.waiting.n) {
+            this.buffer = Buffer.concat([this.buffer, ...this.chunks]);
+            this.chunks = [];
+            this.queued = 0;
+        }
         const { n, resolve } = this.waiting;
         this.waiting = undefined;
         const out = this.buffer.subarray(0, n);
@@ -35,27 +43,68 @@ class Reader {
         resolve(out);
     }
 }
-/** One full frame from a VNC server (security type None), as packed RGB. Joins
- * as a shared client, so open viewers stay connected. */
+/** Joins a VNC server (security type None) as a shared client, so open viewers
+ * stay connected: the connection and the display's size. */
+async function join(socket) {
+    const reader = new Reader(socket);
+    const version = (await reader.read(12)).toString("latin1");
+    if (!/^RFB 003\.\d{3}\n$/.test(version))
+        throw new Error("Not a VNC display.");
+    socket.write("RFB 003.008\n");
+    const types = await reader.read((await reader.read(1))[0]);
+    if (!types.includes(1))
+        throw new Error("The display requires a password.");
+    socket.write(Buffer.from([1]));
+    if ((await reader.read(4)).readUInt32BE(0) !== 0)
+        throw new Error("The display refused the connection.");
+    socket.write(Buffer.from([1]));
+    const init = await reader.read(24);
+    await reader.read(init.readUInt32BE(20)); // desktop name
+    return { reader, width: init.readUInt16BE(0), height: init.readUInt16BE(2) };
+}
+/** Sends input to a display the way a viewer would, so it works for any VNC
+ * display. Returns the display's size; points outside it are refused. */
+export async function sendInput(socketPath, events, timeoutMs = 10_000) {
+    const socket = net.connect(socketPath);
+    const timer = setTimeout(() => socket.destroy(new Error("The display didn't answer in time.")), timeoutMs);
+    try {
+        const { width, height } = await join(socket);
+        for (const event of events)
+            if ("pointer" in event && (event.pointer.x >= width || event.pointer.y >= height)) {
+                throw new Error(`${event.pointer.x},${event.pointer.y} is outside the app, which is ${width}×${height} pixels (the size of its screenshot).`);
+            }
+        for (const event of events) {
+            if ("wait" in event) {
+                await new Promise((r) => setTimeout(r, event.wait));
+                continue;
+            }
+            const message = Buffer.alloc(8);
+            if ("pointer" in event) {
+                message[0] = 5;
+                message[1] = event.pointer.buttons;
+                message.writeUInt16BE(event.pointer.x, 2);
+                message.writeUInt16BE(event.pointer.y, 4);
+            }
+            else {
+                message[0] = 4;
+                message[1] = event.key.down ? 1 : 0;
+                message.writeUInt32BE(event.key.keysym >>> 0, 4);
+            }
+            await new Promise((resolve, reject) => socket.write("pointer" in event ? message.subarray(0, 6) : message, (error) => error ? reject(error) : resolve()));
+        }
+        return { width, height };
+    }
+    finally {
+        clearTimeout(timer);
+        socket.end();
+    }
+}
+/** One full frame from a VNC server, as packed RGB. */
 export async function captureFrame(socketPath, timeoutMs = 10_000) {
     const socket = net.connect(socketPath);
     const timer = setTimeout(() => socket.destroy(new Error("The display didn't answer in time.")), timeoutMs);
     try {
-        const reader = new Reader(socket);
-        const version = (await reader.read(12)).toString("latin1");
-        if (!/^RFB 003\.\d{3}\n$/.test(version))
-            throw new Error("Not a VNC display.");
-        socket.write("RFB 003.008\n");
-        const types = await reader.read((await reader.read(1))[0]);
-        if (!types.includes(1))
-            throw new Error("The display requires a password.");
-        socket.write(Buffer.from([1]));
-        if ((await reader.read(4)).readUInt32BE(0) !== 0)
-            throw new Error("The display refused the connection.");
-        socket.write(Buffer.from([1]));
-        const init = await reader.read(24);
-        const width = init.readUInt16BE(0), height = init.readUInt16BE(2);
-        await reader.read(init.readUInt32BE(20)); // desktop name
+        const { reader, width, height } = await join(socket);
         // 32 bpp true colour, little-endian, red at bit 16: bytes arrive B, G, R, X.
         const format = Buffer.from([0, 0, 0, 0, 32, 24, 0, 1, 0, 255, 0, 255, 0, 255, 16, 8, 0, 0, 0, 0]);
         const encodings = Buffer.from([2, 0, 0, 1, 0, 0, 0, 0]); // Raw only

package/dist/apps/screenshot.js

@@ -160,16 +160,22 @@ export async function takeShots(views, request, outDir, chrome = findChrome()) {
             for (const width of request.widths)
                 for (const theme of request.themes) {
                     const mobile = width < 600;
-                    await cdp.send("Emulation.setDeviceMetricsOverride", { width, height: mobile ? 844 : 800, deviceScaleFactor: mobile ? 2 : 1, mobile }, sessionId);
+                    await cdp.send("Emulation.setDeviceMetricsOverride", { width, height: request.height ?? (mobile ? 844 : 800), deviceScaleFactor: request.scale ?? (mobile ? 2 : 1), mobile }, sessionId);
                     await cdp.send("Emulation.setEmulatedMedia", { features: [{ name: "prefers-color-scheme", value: theme }] }, sessionId);
                     const loaded = cdp.once("Page.loadEventFired", sessionId, 15_000);
                     await cdp.send("Page.navigate", { url: origin + request.path }, sessionId);
                     await loaded;
                     await new Promise((r) => setTimeout(r, 400)); // let fonts and first effects settle
+                    let scroll;
+                    if (request.scroll) {
+                        const { result } = await cdp.send("Runtime.evaluate", { expression: `scrollTo(${Number(request.scroll.x) || 0}, ${Number(request.scroll.y) || 0}); [scrollX, scrollY]`, returnByValue: true }, sessionId);
+                        scroll = { x: Number(result?.value?.[0]) || 0, y: Number(result?.value?.[1]) || 0 };
+                        await new Promise((r) => setTimeout(r, 150));
+                    }
                     const { data } = await cdp.send("Page.captureScreenshot", { format: "png" }, sessionId);
                     const file = path.join(outDir, `${entry.view.id.slice(0, 8)}-${width}-${theme}.png`);
                     fs.writeFileSync(file, Buffer.from(data, "base64"));
-                    shots.push({ viewId: entry.view.id, view: entry.view.name, width, theme, file });
+                    shots.push({ viewId: entry.view.id, view: entry.view.name, width, theme, file, ...(scroll ? { scroll } : {}) });
                 }
         }
         return shots;