chrome-relay 0.4.0 → 0.5.1

package/dist/cli.js

@@ -5,7 +5,7 @@ import { Command } from "commander";
 import { writeFileSync } from "fs";
 
 // src/index.ts
-var CHROME_RELAY_VERSION = true ? "0.4.0" : "0.0.0-dev";
+var CHROME_RELAY_VERSION = true ? "0.5.1" : "0.0.0-dev";
 
 // src/install/install.ts
 import os from "os";
@@ -130,7 +130,14 @@ async function runDoctor() {
 }
 
 // src/client/call.ts
-async function callTool(name, args) {
+var noticePrinted = false;
+function emitNoticeOnce(notice) {
+  if (noticePrinted) return;
+  noticePrinted = true;
+  process.stderr.write(`[chrome-relay] ${notice}
+`);
+}
+async function callToolWithMeta(name, args) {
   const response = await fetch(`http://127.0.0.1:${DEFAULT_HTTP_PORT}/call`, {
     method: "POST",
     headers: {
@@ -143,12 +150,53 @@ async function callTool(name, args) {
   });
   const payload = await response.json().catch(() => null);
   if (!response.ok) {
+    if (payload?.notice) emitNoticeOnce(payload.notice);
     throw new Error(payload?.error || `Bridge request failed with ${response.status}`);
   }
   if (!payload?.ok) {
+    if (payload?.notice) emitNoticeOnce(payload.notice);
     throw new Error(payload?.error || "Bridge call failed.");
   }
-  return payload.data;
+  if (payload.notice) emitNoticeOnce(payload.notice);
+  return { data: payload.data, notice: payload.notice };
+}
+async function callTool(name, args) {
+  const { data } = await callToolWithMeta(name, args);
+  return data;
+}
+
+// src/release-notes.ts
+var RELEASE_NOTES = {
+  "0.5.1": [
+    "Tool results now carry a `notice` field when the CLI is older than the connected extension \u2014 agents (or humans) get a structured nudge to run `chrome-relay update`.",
+    "New subcommand: `chrome-relay update` \u2014 installs the latest CLI via your package manager and prints what changed.",
+    "New subcommand: `chrome-relay release-notes --since <version>` \u2014 query the same change log without updating."
+  ],
+  "0.5.0": [
+    "New tool: `chrome_hover` \u2014 `Input.dispatchMouseEvent mouseMoved` at a selector or x,y. Fires :hover, :focus-within, tooltips, dropdown openers without clicking.",
+    "New tool: `chrome_screencast` \u2014 paint-driven CDP recording. Catches CSS transitions, fade-ins, and animation mid-states that screenshot polling misses. Requires the tab to be active.",
+    "`chrome-relay screencast {start,stop}` CLI with default-on SHA-256 dedupe (--no-dedupe to keep raw frames) and --gif/--mp4 ffmpeg post-step.",
+    "JPEG default quality bumped 60 \u2192 80 for max precision. See docs/recording.md."
+  ],
+  "0.4.0": [
+    "BREAKING: `chrome_group` repurposed for Chrome's native tab-groups (the colored, collapsible folders). Old isolation-window semantics moved to `chrome_workspace`.",
+    "New CLI: `chrome-relay workspace {create,list,close}` for parallel agent isolation (named background windows).",
+    "New CLI: `chrome-relay group {create,list,close,add,remove}` for visual tab-grouping inside a single window."
+  ]
+};
+function compareSemver(a, b) {
+  const pa = a.split(".").map((n) => Number(n) || 0);
+  const pb = b.split(".").map((n) => Number(n) || 0);
+  for (let i = 0; i < 3; i++) {
+    const ai = pa[i] ?? 0;
+    const bi = pb[i] ?? 0;
+    if (ai > bi) return 1;
+    if (ai < bi) return -1;
+  }
+  return 0;
+}
+function listReleaseNotesSince(since) {
+  return Object.keys(RELEASE_NOTES).filter((v) => compareSemver(v, since) > 0).sort((a, b) => compareSemver(a, b)).map((version) => ({ version, bullets: RELEASE_NOTES[version] }));
 }
 
 // src/program.ts
@@ -181,6 +229,43 @@ Notes:
     const ok = await runDoctor();
     process.exit(ok ? 0 : 1);
   });
+  program.command("update").description("Update chrome-relay CLI to the latest version and print what changed (agent-readable JSON).").option("--dry-run", "skip the install; just show what changed since the current version").action(async (opts) => {
+    const fromVersion = CHROME_RELAY_VERSION;
+    const { spawnSync } = await import("child_process");
+    if (!opts.dryRun) {
+      const argv0 = process.argv[1] ?? "";
+      const pm = /[\\/](pnpm|\.pnpm)[\\/]/.test(argv0) ? "pnpm" : /[\\/]bun[\\/]/.test(argv0) ? "bun" : "npm";
+      const cmd = pm === "pnpm" ? ["pnpm", ["add", "-g", "chrome-relay@latest"]] : pm === "bun" ? ["bun", ["add", "-g", "chrome-relay@latest"]] : ["npm", ["install", "-g", "chrome-relay@latest"]];
+      process.stderr.write(`[chrome-relay] updating from ${fromVersion} via ${pm}...
+`);
+      const install = spawnSync(cmd[0], cmd[1], { stdio: "inherit" });
+      if (install.status !== 0) {
+        process.stderr.write(`[chrome-relay] install failed (${pm} exited ${install.status}). Try manually: ${pm} ${cmd[1].join(" ")}
+`);
+        process.exit(1);
+      }
+      const which = spawnSync("which", ["chrome-relay"]);
+      const newBin = which.stdout?.toString().trim();
+      if (which.status === 0 && newBin && newBin !== argv0) {
+        spawnSync(newBin, ["release-notes", "--since", fromVersion], { stdio: "inherit" });
+        return;
+      }
+    }
+    const changes = listReleaseNotesSince(fromVersion);
+    process.stdout.write(JSON.stringify({
+      updatedFrom: fromVersion,
+      updatedTo: CHROME_RELAY_VERSION,
+      changes
+    }, null, 2) + "\n");
+  });
+  program.command("release-notes").description("Print release notes since a version (no install). JSON output for agents.").option("--since <version>", "show release notes for versions newer than this", "0.0.0").action((opts) => {
+    const changes = listReleaseNotesSince(opts.since);
+    process.stdout.write(JSON.stringify({
+      currentVersion: CHROME_RELAY_VERSION,
+      since: opts.since,
+      changes
+    }, null, 2) + "\n");
+  });
   async function run(name, args) {
     try {
       const result = await callTool(name, args);
@@ -644,6 +729,171 @@ Notes:
     if (typeof opts.limit === "number") args.limit = opts.limit;
     await run("chrome_console", args);
   });
+  tabOpt(
+    program.command("hover [selector]").description("Move the pointer over an element or coordinates. Fires :hover styles.").option("--x <px>", "explicit x coordinate (CSS pixels)", (v) => Number(v)).option("--y <px>", "explicit y coordinate (CSS pixels)", (v) => Number(v)).addHelpText(
+      "after",
+      `
+
+Examples:
+  chrome-relay hover --tab 123 'button[title="Install runner"]'
+  chrome-relay hover --tab 123 --x 1327 --y 771
+
+Use before screencast to capture hover-driven micro-states (button glow,
+tooltip appearance, etc.) that a bare click would skip past too quickly.
+`
+    )
+  ).action(async (selector, opts) => {
+    const args = {};
+    Object.assign(args, baseArgs(opts));
+    if (selector) args.selector = selector;
+    if (typeof opts.x === "number" && typeof opts.y === "number") {
+      args.x = opts.x;
+      args.y = opts.y;
+    }
+    await run("chrome_hover", args);
+  });
+  const screencast = program.command("screencast").description("Record a tab via CDP (paint-driven). Requires an active tab.").addHelpText(
+    "after",
+    `
+
+Examples:
+  chrome-relay screencast start --tab 123 --quality 80 --max-width 900
+  # ... drive the interaction (hover, click, etc.) ...
+  chrome-relay screencast stop --tab 123 --out /tmp/recording
+
+  # The --out path becomes a directory of frame_NNNN.jpg files. If ffmpeg
+  # is on PATH and --gif is also passed, an animated GIF is written next to
+  # the frames at /tmp/recording.gif.
+
+Notes:
+  Frames buffer in the extension service worker. A 10-second capture at
+  default settings (jpeg q=60, ~15fps, full viewport) lands ~2-3 MB.
+  Pass --max-width to downscale and lighten the buffer.
+  Each frame is base64 JPEG; the CLI decodes them when --out is given.
+`
+  );
+  tabOpt(
+    screencast.command("start").description("Begin screencast capture on a tab.").option("--format <fmt>", "jpeg | png (default jpeg)").option("--quality <n>", "jpeg quality 0-100 (default 80)", (v) => Number(v)).option("--max-width <px>", "downscale; aspect preserved", (v) => Number(v)).option("--max-height <px>", "downscale; aspect preserved", (v) => Number(v)).option("--every-nth <n>", "throttle: keep 1 in N frames (default 1)", (v) => Number(v))
+  ).action(async (opts) => {
+    const args = { action: "start" };
+    Object.assign(args, baseArgs(opts));
+    if (opts.format) args.format = opts.format;
+    if (typeof opts.quality === "number") args.quality = opts.quality;
+    if (typeof opts.maxWidth === "number") args.maxWidth = opts.maxWidth;
+    if (typeof opts.maxHeight === "number") args.maxHeight = opts.maxHeight;
+    if (typeof opts.everyNth === "number") args.everyNthFrame = opts.everyNth;
+    await run("chrome_screencast", args);
+  });
+  tabOpt(
+    screencast.command("stop").description("Stop the screencast and emit frames (or write to disk).").option("-o, --out <dir>", "write frames as JPEGs into this directory (created if missing)").option("--gif", "after writing frames, ffmpeg them into <dir>.gif").option("--mp4", "after writing frames, ffmpeg them into <dir>.mp4").option("--fps <n>", "assumed framerate when invoking ffmpeg (default 15)", (v) => Number(v)).option("--no-dedupe", "keep raw frames; default collapses consecutive identical frames via SHA-256")
+  ).action(async (opts) => {
+    const args = { action: "stop" };
+    Object.assign(args, baseArgs(opts));
+    try {
+      const result = await callTool("chrome_screencast", args);
+      if (!opts.out) {
+        const { frames, ...summary } = result;
+        process.stdout.write(JSON.stringify({ ...summary, framesOmitted: frames.length, hint: "pass --out <dir> to save" }, null, 2) + "\n");
+        return;
+      }
+      const { mkdirSync, writeFileSync: writeFileSync2, renameSync, unlinkSync } = await import("fs");
+      const path2 = await import("path");
+      const { createHash } = await import("crypto");
+      mkdirSync(opts.out, { recursive: true });
+      result.frames.forEach((f, i) => {
+        const name = `frame_${String(i + 1).padStart(4, "0")}.jpg`;
+        writeFileSync2(path2.join(opts.out, name), Buffer.from(f.data, "base64"));
+      });
+      process.stdout.write(`Wrote ${result.frames.length} frames to ${opts.out}
+`);
+      const dedupeOn = opts.dedupe !== false;
+      if (dedupeOn && result.frames.length > 1) {
+        const hashes = result.frames.map(
+          (f) => createHash("sha256").update(Buffer.from(f.data, "base64")).digest("hex")
+        );
+        const kept = [];
+        let prev = "";
+        hashes.forEach((h, i) => {
+          if (h !== prev) kept.push(i);
+          prev = h;
+        });
+        const dropped = result.frames.length - kept.length;
+        if (dropped > 0) {
+          for (let i = 0; i < result.frames.length; i++) {
+            const src = path2.join(opts.out, `frame_${String(i + 1).padStart(4, "0")}.jpg`);
+            try {
+              unlinkSync(src);
+            } catch {
+            }
+          }
+          kept.forEach((srcIdx, newIdx) => {
+            const tmp = path2.join(opts.out, `tmp_${String(newIdx + 1).padStart(4, "0")}.jpg`);
+            writeFileSync2(tmp, Buffer.from(result.frames[srcIdx].data, "base64"));
+          });
+          kept.forEach((_, newIdx) => {
+            const tmp = path2.join(opts.out, `tmp_${String(newIdx + 1).padStart(4, "0")}.jpg`);
+            const final = path2.join(opts.out, `frame_${String(newIdx + 1).padStart(4, "0")}.jpg`);
+            renameSync(tmp, final);
+          });
+          process.stdout.write(`Deduped: dropped ${dropped} identical frames, ${kept.length} remain.
+`);
+        } else {
+          process.stdout.write(`Deduped: no consecutive duplicates found.
+`);
+        }
+      }
+      if (opts.gif || opts.mp4) {
+        const fps = typeof opts.fps === "number" ? opts.fps : 15;
+        const { spawnSync } = await import("child_process");
+        const which = spawnSync("which", ["ffmpeg"]);
+        if (which.status !== 0) {
+          process.stderr.write("[chrome-relay] ffmpeg not on PATH \u2014 skipping --gif/--mp4.\n");
+          return;
+        }
+        if (opts.gif) {
+          const gifOut = `${opts.out.replace(/\/$/, "")}.gif`;
+          const r = spawnSync("ffmpeg", [
+            "-y",
+            "-framerate",
+            String(fps),
+            "-i",
+            path2.join(opts.out, "frame_%04d.jpg"),
+            "-vf",
+            `fps=${fps},split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse`,
+            "-loop",
+            "0",
+            gifOut
+          ], { stdio: "inherit" });
+          if (r.status === 0) process.stdout.write(`Wrote ${gifOut}
+`);
+        }
+        if (opts.mp4) {
+          const mp4Out = `${opts.out.replace(/\/$/, "")}.mp4`;
+          const r = spawnSync("ffmpeg", [
+            "-y",
+            "-framerate",
+            String(fps),
+            "-i",
+            path2.join(opts.out, "frame_%04d.jpg"),
+            "-c:v",
+            "libx264",
+            "-pix_fmt",
+            "yuv420p",
+            "-crf",
+            "20",
+            mp4Out
+          ], { stdio: "inherit" });
+          if (r.status === 0) process.stdout.write(`Wrote ${mp4Out}
+`);
+        }
+      }
+    } catch (error) {
+      process.stderr.write(
+        (error instanceof Error ? error.message : String(error)) + "\n"
+      );
+      process.exit(1);
+    }
+  });
   return program;
 }
 

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-var CHROME_RELAY_VERSION = true ? "0.4.0" : "0.0.0-dev";
+var CHROME_RELAY_VERSION = true ? "0.5.1" : "0.0.0-dev";
 export {
   CHROME_RELAY_VERSION
 };

package/dist/native-host.js

@@ -9,7 +9,29 @@ import Fastify from "fastify";
 // ../protocol/dist/index.js
 var DEFAULT_HTTP_PORT = 12122;
 
+// src/index.ts
+var CHROME_RELAY_VERSION = true ? "0.5.1" : "0.0.0-dev";
+
+// src/release-notes.ts
+function compareSemver(a, b) {
+  const pa = a.split(".").map((n) => Number(n) || 0);
+  const pb = b.split(".").map((n) => Number(n) || 0);
+  for (let i = 0; i < 3; i++) {
+    const ai = pa[i] ?? 0;
+    const bi = pb[i] ?? 0;
+    if (ai > bi) return 1;
+    if (ai < bi) return -1;
+  }
+  return 0;
+}
+
 // src/http/server.ts
+function buildOutdatedNotice(bridge2) {
+  const extVersion = bridge2.getExtensionVersion();
+  if (!extVersion) return void 0;
+  if (compareSemver(CHROME_RELAY_VERSION, extVersion) >= 0) return void 0;
+  return `cli-outdated: ${CHROME_RELAY_VERSION} < extension ${extVersion}; run \`chrome-relay update\``;
+}
 var RelayHttpServer = class {
   constructor(bridge2, port = DEFAULT_HTTP_PORT) {
     this.bridge = bridge2;
@@ -19,7 +41,12 @@ var RelayHttpServer = class {
   port;
   app = Fastify({ logger: false });
   async start() {
-    this.app.get("/ping", async () => ({ ok: true, port: this.port }));
+    this.app.get("/ping", async () => ({
+      ok: true,
+      port: this.port,
+      cliVersion: CHROME_RELAY_VERSION,
+      extensionVersion: this.bridge.getExtensionVersion() ?? null
+    }));
     this.app.post("/call", async (request, reply) => {
       if (request.headers.origin) {
         reply.code(403).send({ error: "Browser-origin bridge requests are not accepted." });
@@ -35,12 +62,16 @@ var RelayHttpServer = class {
           body.name,
           body.args ?? {}
         );
-        reply.send({ ok: true, data });
+        const notice = buildOutdatedNotice(this.bridge);
+        reply.send(notice ? { ok: true, data, notice } : { ok: true, data });
       } catch (error) {
-        reply.code(500).send({
+        const notice = buildOutdatedNotice(this.bridge);
+        const body2 = {
           ok: false,
           error: error instanceof Error ? error.message : String(error)
-        });
+        };
+        if (notice) body2.notice = notice;
+        reply.code(500).send(body2);
       }
     });
     await this.app.listen({ port: this.port, host: "127.0.0.1" });
@@ -60,6 +91,12 @@ var ExtensionBridge = class {
   pending = /* @__PURE__ */ new Map();
   readyWaiters = /* @__PURE__ */ new Set();
   ready = false;
+  // Extension version captured from `bridge.ready`. Read by the HTTP server
+  // to compute the cli-outdated notice on each tool call.
+  extensionVersion;
+  getExtensionVersion() {
+    return this.extensionVersion;
+  }
   handleMessage(message) {
     if (message.type === "bridge.ready") {
       this.handleReady(message);
@@ -79,8 +116,9 @@ var ExtensionBridge = class {
       pending.resolve(true);
     }
   }
-  handleReady(_message) {
+  handleReady(message) {
     this.ready = true;
+    this.extensionVersion = message.payload?.version;
     for (const notify of this.readyWaiters) {
       notify();
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chrome-relay",
-  "version": "0.4.0",
+  "version": "0.5.1",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",