@holdgrenade/cli 1.0.48 → 1.0.49

package/dist/cli.js

@@ -3242,7 +3242,7 @@ var require_stream = __commonJS({
       };
       duplex._final = function(callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open5() {
+          ws.once("open", function open6() {
             duplex._final(callback);
           });
           return;
@@ -3263,7 +3263,7 @@ var require_stream = __commonJS({
       };
       duplex._write = function(chunk, encoding, callback) {
         if (ws.readyState === ws.CONNECTING) {
-          ws.once("open", function open5() {
+          ws.once("open", function open6() {
             duplex._write(chunk, encoding, callback);
           });
           return;
@@ -7025,7 +7025,7 @@ function isKnownAgent(kind) {
 
 // src/cli.ts
 import { existsSync as existsSync23, mkdirSync as mkdirSync16, readFileSync as readFileSync17, writeFileSync as writeFileSync18 } from "node:fs";
-import { dirname as dirname16 } from "node:path";
+import { dirname as dirname17 } from "node:path";
 
 // node_modules/commander/lib/error.js
 var CommanderError = class extends Error {
@@ -30900,6 +30900,78 @@ var VoiceTokenFrame = external_exports.object({
   once: external_exports.literal(true).optional()
 });
 
+// ../grenade-protocol/dist/canvas.js
+var CANVAS_FOLDER = ".grenade/canvas";
+var CANVAS_BOARDS_MAX = 500;
+var CANVAS_BOARD_MAX_BYTES = 2 * 1024 * 1024;
+var CANVAS_BOARD_FRAME_MAX_BYTES = 3e6;
+var CANVAS_SUBSCRIPTIONS_MAX = 8;
+var CANVAS_DEFAULT_WIDTH = 1280;
+var CANVAS_DEFAULT_HEIGHT = 800;
+var CANVAS_SIZE_MAX = 8e3;
+var CanvasCwd = external_exports.string().min(1).max(1024).refine((p) => p === "~" || p.startsWith("~/") || p.startsWith("/"), "absolute or starting with ~");
+var CanvasFileName = external_exports.string().min(1).max(255).refine((f) => !/[/\\\0]/.test(f) && !f.startsWith(".") && /\.html?$/i.test(f), "a board's file name in the canvas folder");
+var RequestId = external_exports.string().min(1).max(64);
+var CanvasBoard = external_exports.object({
+  /** Its file name, "R3A · Cards.html". */
+  file: CanvasFileName,
+  /** What it is, from its name: "Cards". The file's name without its extension when the name has nothing after the revision. */
+  name: external_exports.string().min(1).max(255),
+  /** The revision its name starts with: 3 for "R3A · Cards.html". Absent for a name without one. */
+  revision: external_exports.number().int().min(0).max(9999).optional(),
+  /** The letters after the revision, as written: "A" for "R3A · Cards.html". Absent when there are none. */
+  letter: external_exports.string().regex(/^[A-Za-z]{1,3}$/).optional(),
+  /** The size it asks for (`<meta name="board" content="1280x800">`), else 1280 × 800. */
+  width: external_exports.number().int().min(1).max(CANVAS_SIZE_MAX),
+  height: external_exports.number().int().min(1).max(CANVAS_SIZE_MAX),
+  /** When it was last saved. */
+  modified: external_exports.string().datetime(),
+  /** Its size on disk. */
+  bytes: external_exports.number().int().min(0)
+});
+var CanvasRequestFrame = external_exports.object({ type: external_exports.literal("canvas"), id: RequestId, cwd: CanvasCwd });
+var CanvasSubscribeFrame = external_exports.object({ type: external_exports.literal("canvas.subscribe"), id: RequestId, cwd: CanvasCwd });
+var CanvasUnsubscribeFrame = external_exports.object({ type: external_exports.literal("canvas.unsubscribe"), cwd: CanvasCwd });
+var CanvasBoardRequestFrame = external_exports.object({ type: external_exports.literal("canvas.board"), id: RequestId, cwd: CanvasCwd, file: CanvasFileName });
+var CanvasFrame = external_exports.object({
+  type: external_exports.literal("canvas"),
+  /** The request's; absent on a frame sent because the canvas changed. */
+  id: RequestId.optional(),
+  /** As the client sent it. */
+  cwd: external_exports.string().min(1),
+  /** The canvas folder, absolute: `<cwd>/.grenade/canvas`. */
+  folder: external_exports.string().min(1),
+  boards: external_exports.array(CanvasBoard).max(CANVAS_BOARDS_MAX),
+  /** The folder is not there (yet): no session has drawn on this canvas. `boards` is empty. */
+  missing: external_exports.literal(true).optional(),
+  truncated: external_exports.literal(true).optional()
+});
+var CanvasBoardFrame = external_exports.object({
+  type: external_exports.literal("canvas.board"),
+  id: RequestId,
+  cwd: external_exports.string().min(1),
+  file: CanvasFileName,
+  /** The whole file, at most `CANVAS_BOARD_MAX_BYTES` bytes on disk. */
+  html: external_exports.string().max(CANVAS_BOARD_MAX_BYTES),
+  modified: external_exports.string().datetime(),
+  bytes: external_exports.number().int().min(0).max(CANVAS_BOARD_MAX_BYTES)
+});
+function boardNameOf(file2) {
+  const stem = file2.replace(/\.html?$/i, "") || file2;
+  const match = /^[Rr](\d{1,4})([A-Za-z]{0,3})(?![A-Za-z0-9])/.exec(stem);
+  if (!match)
+    return { name: stem };
+  const rest = stem.slice(match[0].length).replace(/^[\s·•\-–—_:|.]+/u, "").trim();
+  return { name: rest || stem, revision: Number(match[1]), ...match[2] ? { letter: match[2] } : {} };
+}
+function boardSizeOf(html) {
+  const meta3 = /<meta[^>]*name=["']board["'][^>]*>/i.exec(html);
+  const content = meta3 && /content=["']\s*(\d{2,5})\s*[x×]\s*(\d{2,5})\s*["']/.exec(meta3[0]);
+  if (!content)
+    return { width: CANVAS_DEFAULT_WIDTH, height: CANVAS_DEFAULT_HEIGHT };
+  return { width: Math.min(Number(content[1]), CANVAS_SIZE_MAX), height: Math.min(Number(content[2]), CANVAS_SIZE_MAX) };
+}
+
 // ../grenade-protocol/dist/relay.js
 var RELAY_PROTOCOL_VERSION = 1;
 var RELAY_DAEMON_PATH = "/v1/daemon";
@@ -31142,6 +31214,8 @@ var DaemonInfo = external_exports.object({
   groupNames: external_exports.literal(1).optional(),
   /** 1 when the daemon keeps voice providers' keys and answers `voice`, `voice.key` and `voice.token` (PROTOCOL.md "Voice providers"). Absent from older daemons. */
   voice: external_exports.literal(1).optional(),
+  /** 1 when the daemon serves a group's design canvas: `canvas`, `canvas.subscribe`, `canvas.board` (PROTOCOL.md "Canvas"). Absent from older daemons. */
+  canvas: external_exports.literal(1).optional(),
   /** Retired: 1 when the daemon sends `activity` for Codex sessions too. Still sent for apps that read it; new clients read `agents`. */
   codexActivity: external_exports.literal(1).optional(),
   /** Every agent the daemon can start and what it does with each (PROTOCOL.md "Agents"). Absent from older daemons. */
@@ -31282,6 +31356,10 @@ var ClientFrame = external_exports.discriminatedUnion("type", [
   VoiceRequestFrame,
   VoiceKeyFrame,
   VoiceTokenRequestFrame,
+  CanvasRequestFrame,
+  CanvasSubscribeFrame,
+  CanvasUnsubscribeFrame,
+  CanvasBoardRequestFrame,
   PingFrame
 ]);
 var ErrorCode = external_exports.enum([
@@ -31307,7 +31385,7 @@ var ErrorFrame = external_exports.object({
   code: ErrorCode,
   message: external_exports.string(),
   ref: external_exports.string().optional(),
-  /** The `id` of the frame this error answers, when it had one (an `input`). */
+  /** The `id` of the frame this error answers, when it had one (an `input`, a `voice.token`, a `canvas` request). */
   id: external_exports.string().min(1).max(64).optional()
 });
 var SessionsFrame = external_exports.object({ type: external_exports.literal("sessions"), sessions: external_exports.array(Session) });
@@ -31378,6 +31456,8 @@ var DaemonFrame = external_exports.discriminatedUnion("type", [
   FoldersFrame,
   VoiceFrame,
   VoiceTokenFrame,
+  CanvasFrame,
+  CanvasBoardFrame,
   PongFrame
 ]);
 var PairRequest = external_exports.object({ code: external_exports.string().regex(/^\d{6}$/), client: ClientInfo });
@@ -34478,12 +34558,12 @@ function terminalFromEnv() {
   const env = process.env["GRENADE_TERMINAL"];
   return env !== void 0 && isTerminalKind(env) ? env : void 0;
 }
-function relayoutSteps(ordered, open5) {
+function relayoutSteps(ordered, open6) {
   const [head, ...rest] = ordered;
   if (head === void 0) return [];
-  const keepHead = open5.has(head);
+  const keepHead = open6.has(head);
   const steps = [];
-  for (const id of keepHead ? rest : ordered) if (open5.has(id)) steps.push({ kind: "close", id });
+  for (const id of keepHead ? rest : ordered) if (open6.has(id)) steps.push({ kind: "close", id });
   if (!keepHead) steps.push({ kind: "tab", id: head });
   rest.forEach((id, i) => steps.push({ kind: "split", id, nextTo: ordered[i] }));
   return steps;
@@ -34637,9 +34717,9 @@ var TerminalMirror = class {
   /** The nearest live member before `s` in group order that has a pane in `a`, else the last one that has. */
   openMemberOf(s, a) {
     if (s.group === void 0) return void 0;
-    const open5 = otherMembers(s.group, this.registry.list(), s.id).filter((m) => this.openIn.get(m.id) === a);
-    const before = open5.filter((m) => byGroupOrder(m, s) < 0);
-    return (before.at(-1) ?? open5.at(-1))?.id;
+    const open6 = otherMembers(s.group, this.registry.list(), s.id).filter((m) => this.openIn.get(m.id) === a);
+    const before = open6.filter((m) => byGroupOrder(m, s) < 0);
+    return (before.at(-1) ?? open6.at(-1))?.id;
   }
   closeTab(id) {
     const a = this.openIn.get(id);
@@ -34738,7 +34818,7 @@ function underService(env = process.env, pid = process.pid) {
 }
 
 // src/daemon/server.ts
-import { dirname as dirname15, join as join17 } from "node:path";
+import { dirname as dirname16, join as join18 } from "node:path";
 import { createServer as createServer2 } from "node:http";
 import { networkInterfaces } from "node:os";
 
@@ -36729,13 +36809,13 @@ function switchModelDialog(below) {
 }
 function paragraphs(rows) {
   const out = [];
-  let open5 = false;
+  let open6 = false;
   for (const row of rows.map((r) => r.trim())) {
-    if (!row) open5 = false;
-    else if (open5) out[out.length - 1] += ` ${row}`;
+    if (!row) open6 = false;
+    else if (open6) out[out.length - 1] += ` ${row}`;
     else {
       out.push(row);
-      open5 = true;
+      open6 = true;
     }
   }
   return out.map((p) => /[.!?:]$/.test(p) ? p : `${p}.`).join(" ");
@@ -36772,25 +36852,25 @@ async function switchClaudeModel(term, model, effort, timing = DEFAULT_TIMING) {
     throw new ModelSwitchError("Claude Code's prompt is not empty. Send or clear what is typed there, then choose again.");
   }
   await term.key("enter");
-  let open5 = await look2(modelPickerIn);
-  if (!open5) throw new ModelSwitchError("Claude Code did not open its model picker.");
-  if (!open5.sessionOnly) await giveUp("This Claude Code cannot switch one session only. Update Claude Code, then choose again.");
-  for (let moves = 0; selectedModel(open5) !== model; moves++) {
+  let open6 = await look2(modelPickerIn);
+  if (!open6) throw new ModelSwitchError("Claude Code did not open its model picker.");
+  if (!open6.sessionOnly) await giveUp("This Claude Code cannot switch one session only. Update Claude Code, then choose again.");
+  for (let moves = 0; selectedModel(open6) !== model; moves++) {
     if (moves >= MOST_MOVES) await giveUp(`Claude Code's picker has no ${model}.`);
-    const down = rowsDownTo(open5, model);
+    const down = rowsDownTo(open6, model);
     await term.key(down !== null && down > 0 ? "down" : "up");
     await timing.wait(LOOK_EVERY_MS);
-    open5 = await picker() ?? await giveUp("Claude Code closed its model picker.");
+    open6 = await picker() ?? await giveUp("Claude Code closed its model picker.");
   }
   if (effort !== void 0) {
-    for (let steps = 0; open5.effort !== effort; steps++) {
+    for (let steps = 0; open6.effort !== effort; steps++) {
       if (steps >= MOST_EFFORT_STEPS) await giveUp(`${model} has no ${effort} effort in Claude Code.`);
       await term.type(RIGHT);
       await timing.wait(LOOK_EVERY_MS);
-      open5 = await picker() ?? await giveUp("Claude Code closed its model picker.");
+      open6 = await picker() ?? await giveUp("Claude Code closed its model picker.");
     }
   }
-  const chosenEffort = open5.effort ?? void 0;
+  const chosenEffort = open6.effort ?? void 0;
   await term.type("s");
   const closed = await look2((lines) => modelPickerIn(lines) ? null : lines);
   if (!closed) await giveUp("Claude Code did not take the choice.");
@@ -38603,6 +38683,271 @@ function switchTimingProblem(session) {
   return null;
 }
 
+// src/canvas/canvasService.ts
+import { homedir as homedir9 } from "node:os";
+
+// src/canvas/canvasAccess.ts
+import { posix } from "node:path";
+function normalizeCwd(cwd, home) {
+  const expanded = expandHome(cwd, home);
+  if (!expanded.startsWith("/")) return null;
+  return posix.resolve(expanded);
+}
+function sharedFolder(paths2) {
+  if (paths2.length === 0) return null;
+  let shared = paths2[0].split("/").filter(Boolean);
+  for (const path2 of paths2.slice(1)) {
+    const parts = path2.split("/").filter(Boolean);
+    let i = 0;
+    while (i < shared.length && i < parts.length && shared[i] === parts[i]) i++;
+    shared = shared.slice(0, i);
+  }
+  return shared.length === 0 ? null : `/${shared.join("/")}`;
+}
+function canvasCwds(sessions, home) {
+  const allowed = /* @__PURE__ */ new Set();
+  const groups = /* @__PURE__ */ new Map();
+  for (const s of sessions) {
+    const cwd = normalizeCwd(s.cwd, home);
+    if (!cwd) continue;
+    allowed.add(cwd);
+    const key = s.group ?? s.id;
+    groups.set(key, [...groups.get(key) ?? [], cwd]);
+  }
+  for (const cwds of groups.values()) {
+    const shared = cwds.length > 1 ? sharedFolder(cwds) : null;
+    if (shared) allowed.add(shared);
+  }
+  return allowed;
+}
+function allowedCanvasCwd(cwd, sessions, home) {
+  const normalized = normalizeCwd(cwd, home);
+  return normalized && canvasCwds(sessions, home).has(normalized) ? normalized : null;
+}
+function canvasFolderOf(cwd) {
+  return posix.join(cwd, CANVAS_FOLDER);
+}
+
+// src/canvas/canvasFolder.ts
+import { constants as constants3 } from "node:fs";
+import { lstat, open as open5, readdir as readdir5 } from "node:fs/promises";
+import { dirname as dirname12, join as join16 } from "node:path";
+
+// src/canvas/boardListing.ts
+var finderOrder2 = new Intl.Collator("en", { numeric: true, sensitivity: "base" });
+function isBoardFile(name) {
+  return CanvasFileName.safeParse(name).success;
+}
+function boardsFrom(files, max = CANVAS_BOARDS_MAX) {
+  const sorted = files.filter((f) => isBoardFile(f.file)).sort((a, b) => finderOrder2.compare(a.file, b.file));
+  const boards = sorted.slice(0, max).map((f) => ({
+    file: f.file,
+    ...boardNameOf(f.file),
+    ...boardSizeOf(f.head),
+    modified: new Date(f.mtimeMs).toISOString(),
+    bytes: f.bytes
+  }));
+  return { boards, truncated: sorted.length > max };
+}
+function listingKey(listing) {
+  if (listing.missing) return "missing";
+  return listing.boards.map((b) => `${b.file}
+${b.modified}
+${b.bytes}`).join("\n\n");
+}
+function megabytes(bytes) {
+  return (bytes / (1024 * 1024)).toFixed(1);
+}
+function boardTooLarge(file2, fileBytes, frameBytes, computer = "Mac") {
+  if (fileBytes <= CANVAS_BOARD_MAX_BYTES && frameBytes <= CANVAS_BOARD_FRAME_MAX_BYTES) return null;
+  const name = file2.replace(/\.html?$/i, "");
+  return `"${name}" is too large to show here (${megabytes(Math.max(fileBytes, frameBytes))} MB; at most ${megabytes(CANVAS_BOARD_MAX_BYTES).replace(/\.0$/, "")} MB). Open it on the ${computer}.`;
+}
+
+// src/canvas/canvasFolder.ts
+var HEAD_BYTES = 8192;
+var CanvasError = class extends Error {
+};
+async function realFolder(path2) {
+  const st = await lstat(path2).catch((e) => {
+    if (e.code === "ENOENT" || e.code === "ENOTDIR") return null;
+    throw e;
+  });
+  if (!st) return false;
+  if (st.isSymbolicLink() || !st.isDirectory()) throw new CanvasError(`${path2} is not a folder of its own, so it is not served as a canvas.`);
+  return true;
+}
+async function canvasThere(folder) {
+  return await realFolder(dirname12(folder)) && await realFolder(folder);
+}
+async function openBoard(path2) {
+  const handle = await open5(path2, constants3.O_RDONLY | constants3.O_NOFOLLOW | constants3.O_NONBLOCK).catch(() => null);
+  if (!handle) return null;
+  const st = await handle.stat();
+  if (!st.isFile()) {
+    await handle.close();
+    return null;
+  }
+  return {
+    size: st.size,
+    mtimeMs: st.mtimeMs,
+    async read(max) {
+      const buffer = Buffer.alloc(Math.min(max, st.size));
+      const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+      return buffer.subarray(0, bytesRead);
+    },
+    close: () => handle.close()
+  };
+}
+async function listCanvas(folder, heads = /* @__PURE__ */ new Map()) {
+  if (!await canvasThere(folder)) return { boards: [], missing: true };
+  const entries = await readdir5(folder, { withFileTypes: true });
+  const files = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    if (!e.isFile() || !isBoardFile(e.name)) continue;
+    const st = await lstat(join16(folder, e.name)).catch(() => null);
+    if (!st?.isFile()) continue;
+    const key = `${e.name}
+${st.mtimeMs}
+${st.size}`;
+    seen.add(key);
+    let head = heads.get(key);
+    if (head === void 0) {
+      const board = await openBoard(join16(folder, e.name));
+      if (!board) continue;
+      try {
+        head = (await board.read(HEAD_BYTES)).toString("utf8");
+      } finally {
+        await board.close();
+      }
+      heads.set(key, head);
+    }
+    files.push({ file: e.name, mtimeMs: st.mtimeMs, bytes: st.size, head });
+  }
+  for (const key of heads.keys()) if (!seen.has(key)) heads.delete(key);
+  const { boards, truncated } = boardsFrom(files);
+  return { boards, ...truncated ? { truncated: true } : {} };
+}
+async function readBoard(folder, file2, computer = "Mac") {
+  const notHere = new CanvasError(`"${file2}" is not on this canvas.`);
+  if (!isBoardFile(file2) || !await canvasThere(folder)) throw notHere;
+  const board = await openBoard(join16(folder, file2));
+  if (!board) throw notHere;
+  try {
+    const tooLarge = boardTooLarge(file2, board.size, 0, computer);
+    if (tooLarge) throw new CanvasError(tooLarge);
+    const data = await board.read(CANVAS_BOARD_MAX_BYTES);
+    return { html: data.toString("utf8"), modified: new Date(board.mtimeMs).toISOString(), bytes: data.length };
+  } finally {
+    await board.close();
+  }
+}
+
+// src/canvas/canvasWatcher.ts
+var CANVAS_POLL_MS = 400;
+var realEvery = (fn, ms) => {
+  const timer = setInterval(fn, ms);
+  timer.unref?.();
+  return () => clearInterval(timer);
+};
+var CanvasWatcher = class {
+  constructor(every = realEvery, list = listCanvas, onError = () => {
+  }) {
+    this.every = every;
+    this.list = list;
+    this.onError = onError;
+  }
+  every;
+  list;
+  onError;
+  folders = /* @__PURE__ */ new Map();
+  /** Starts telling `onChange` of every change to `folder` after `current`, the listing the subscriber has. Returns how to stop. */
+  watch(folder, current, onChange) {
+    let watched = this.folders.get(folder);
+    if (!watched) {
+      const created = { subscribers: /* @__PURE__ */ new Set(), heads: /* @__PURE__ */ new Map(), busy: false, stop: () => {
+      } };
+      created.stop = this.every(() => void this.look(folder, created), CANVAS_POLL_MS);
+      this.folders.set(folder, created);
+      watched = created;
+    }
+    const subscriber = { lastKey: listingKey(current), onChange };
+    watched.subscribers.add(subscriber);
+    const w = watched;
+    return () => {
+      w.subscribers.delete(subscriber);
+      if (w.subscribers.size === 0 && this.folders.get(folder) === w) {
+        w.stop();
+        this.folders.delete(folder);
+      }
+    };
+  }
+  /** How many folders are being polled. */
+  get size() {
+    return this.folders.size;
+  }
+  /** Looks at one folder now; a look still running makes this one a no-op. */
+  async look(folder, watched = this.folders.get(folder)) {
+    if (!watched || watched.busy) return;
+    watched.busy = true;
+    try {
+      const listing = await this.list(folder, watched.heads);
+      const key = listingKey(listing);
+      for (const s of watched.subscribers) {
+        if (s.lastKey === key) continue;
+        s.lastKey = key;
+        s.onChange(listing);
+      }
+    } catch (e) {
+      this.onError(folder, e);
+    } finally {
+      watched.busy = false;
+    }
+  }
+  /** Stops every poll (the daemon is stopping). */
+  stopAll() {
+    for (const w of this.folders.values()) w.stop();
+    this.folders.clear();
+  }
+};
+
+// src/canvas/canvasService.ts
+var CanvasService = class {
+  constructor(sessions, watcher = new CanvasWatcher(), home = homedir9(), computer = computerWord()) {
+    this.sessions = sessions;
+    this.watcher = watcher;
+    this.home = home;
+    this.computer = computer;
+  }
+  sessions;
+  watcher;
+  home;
+  computer;
+  /** The canvas folder of `cwd`, or `CanvasError` when no session works there. */
+  folderOf(cwd) {
+    const allowed = allowedCanvasCwd(cwd, this.sessions(), this.home);
+    if (!allowed) throw new CanvasError(`No session on this ${this.computer} works in ${cwd}, so it has no canvas to show.`);
+    return canvasFolderOf(allowed);
+  }
+  async list(cwd) {
+    const folder = this.folderOf(cwd);
+    return { folder, ...await listCanvas(folder) };
+  }
+  async board(cwd, file2) {
+    return readBoard(this.folderOf(cwd), file2, this.computer);
+  }
+  /** The canvas now, and `onChange` with each change after it until `stop`. */
+  async watch(cwd, onChange) {
+    const reply2 = await this.list(cwd);
+    const stop2 = this.watcher.watch(reply2.folder, reply2, (listing) => onChange({ folder: reply2.folder, ...listing }));
+    return { reply: reply2, stop: stop2 };
+  }
+  stop() {
+    this.watcher.stopAll();
+  }
+};
+
 // src/daemon/wsHandler.ts
 var HELLO_TIMEOUT_MS = 5e3;
 var NO_PUSH = { type: "push.state", registered: false, delivery: "off", events: [] };
@@ -38629,6 +38974,8 @@ var Connection = class {
   /** Live terminals this client has open, by session. */
   terms = /* @__PURE__ */ new Map();
   stopWatchingPush;
+  /** Canvases this client watches, by `cwd` as it sent it (PROTOCOL.md "Canvas", "Watching"). */
+  canvasWatches = /* @__PURE__ */ new Map();
   helloTimer;
   onUpdated = (s) => this.send({ type: "session.updated", session: s });
   onRemoved = (id) => {
@@ -38676,7 +39023,7 @@ var Connection = class {
     try {
       await this.dispatch(frame);
     } catch (e) {
-      const id = frame.type === "input" ? frame.id : void 0;
+      const id = frame.type === "input" || frame.type === "canvas" || frame.type === "canvas.subscribe" || frame.type === "canvas.board" ? frame.id : void 0;
       if (e instanceof UnknownSessionError) return this.fail("unknown_session", e.message, frame.type, false, id);
       if (e instanceof SessionExistsError) return this.fail("tmux_failed", e.message, frame.type, false, id);
       if (e instanceof BadCwdError || e instanceof UnknownGroupError) return this.fail("bad_frame", e.message, frame.type, false, id);
@@ -38699,6 +39046,8 @@ var Connection = class {
     for (const id of this.subscriptions) this.d.registry.unsubscribe(id);
     this.subscriptions.clear();
     for (const id of [...this.terms.keys()]) this.closeTerm(id);
+    for (const stop2 of this.canvasWatches.values()) stop2();
+    this.canvasWatches.clear();
     if (this.authed) {
       this.d.registry.off("updated", this.onUpdated);
       this.d.registry.off("removed", this.onRemoved);
@@ -38751,7 +39100,7 @@ var Connection = class {
     }
     this.d.prompts?.on("opened", this.onPrompt);
     this.d.prompts?.on("closed", this.onPrompt);
-    for (const open5 of this.d.prompts?.list() ?? []) this.send(open5);
+    for (const open6 of this.d.prompts?.list() ?? []) this.send(open6);
     this.d.activity?.on("activity", this.onActivity);
   }
   async dispatch(frame) {
@@ -38875,6 +39224,11 @@ ${frame.id}`, () => r.sendText(frame.sessionId, frame.text, frame.submit));
           throw e;
         }
       }
+      case "canvas":
+      case "canvas.subscribe":
+      case "canvas.unsubscribe":
+      case "canvas.board":
+        return this.handleCanvas(frame);
       case "session.group": {
         const before = r.get(frame.sessionId);
         const after = r.setGroup(frame.sessionId, frame.group, frame.index);
@@ -38930,6 +39284,40 @@ ${frame.id}`, () => r.sendText(frame.sessionId, frame.text, frame.submit));
       }
     }
   }
+  /** The canvas frames (PROTOCOL.md "Canvas"): a refused folder, a missing or too large board is `bad_frame` with the request's `id`. */
+  async handleCanvas(frame) {
+    if (frame.type === "canvas.unsubscribe") {
+      this.canvasWatches.get(frame.cwd)?.();
+      this.canvasWatches.delete(frame.cwd);
+      return;
+    }
+    const canvas = this.d.canvas;
+    if (!canvas) return this.fail("bad_frame", "this daemon serves no canvas", frame.type, false, frame.id);
+    const { cwd, id } = frame;
+    const framed = (reply2, withId) => ({ type: "canvas", ...withId ? { id } : {}, cwd, ...reply2 });
+    try {
+      if (frame.type === "canvas") return this.send(framed(await canvas.list(cwd), true));
+      if (frame.type === "canvas.subscribe") {
+        const again = this.canvasWatches.get(cwd);
+        if (!again && this.canvasWatches.size >= CANVAS_SUBSCRIPTIONS_MAX) {
+          return this.fail("bad_frame", `A connection watches at most ${CANVAS_SUBSCRIPTIONS_MAX} canvases; unsubscribe from one first.`, frame.type, false, id);
+        }
+        const { reply: reply3, stop: stop2 } = await canvas.watch(cwd, (changed) => this.send(framed(changed, false)));
+        if (!this.authed) return stop2();
+        again?.();
+        this.canvasWatches.set(cwd, stop2);
+        return this.send(framed(reply3, true));
+      }
+      const board = await canvas.board(cwd, frame.file);
+      const reply2 = { type: "canvas.board", id, cwd, file: frame.file, ...board };
+      const tooLarge = boardTooLarge(frame.file, board.bytes, Buffer.byteLength(JSON.stringify(reply2)), computerWord());
+      if (tooLarge) return this.fail("bad_frame", tooLarge, frame.type, false, id);
+      return this.send(reply2);
+    } catch (e) {
+      if (e instanceof CanvasError) return this.fail("bad_frame", e.message, frame.type, false, id);
+      throw e;
+    }
+  }
   openTerm(sessionId, cols, rows) {
     if (!this.d.openTerm) return this.fail("bad_frame", "this daemon streams no terminal", "term.open");
     this.requireSession(sessionId);
@@ -39016,7 +39404,7 @@ var PairingWatch = class {
 // src/attachments/attachmentStore.ts
 import { mkdir, writeFile } from "node:fs/promises";
 import { existsSync as existsSync19 } from "node:fs";
-import { join as join16 } from "node:path";
+import { join as join17 } from "node:path";
 
 // src/attachments/attachmentName.ts
 var EXTENSION_FOR_MIME = {
@@ -39050,7 +39438,7 @@ function stamp(d) {
 function createAttachmentStore(dir, now = () => /* @__PURE__ */ new Date()) {
   return {
     async save(sessionId, name, mime, data) {
-      const folder = join16(dir, sessionId);
+      const folder = join17(dir, sessionId);
       await mkdir(folder, { recursive: true });
       const path2 = unusedPath(folder, attachmentFileName(name, mime, now()));
       await writeFile(path2, data, { flag: "wx" });
@@ -39062,8 +39450,8 @@ function unusedPath(folder, fileName) {
   const dot = fileName.lastIndexOf(".");
   const stem = dot > 0 ? fileName.slice(0, dot) : fileName;
   const ext = dot > 0 ? fileName.slice(dot) : "";
-  let candidate = join16(folder, fileName);
-  for (let n = 2; existsSync19(candidate); n++) candidate = join16(folder, `${stem}-${n}${ext}`);
+  let candidate = join17(folder, fileName);
+  for (let n = 2; existsSync19(candidate); n++) candidate = join17(folder, `${stem}-${n}${ext}`);
   return candidate;
 }
 
@@ -39078,14 +39466,14 @@ function accessHash(token) {
 
 // src/relay/e2eKey.ts
 import { existsSync as existsSync20, mkdirSync as mkdirSync13, readFileSync as readFileSync14, writeFileSync as writeFileSync15 } from "node:fs";
-import { dirname as dirname12 } from "node:path";
+import { dirname as dirname13 } from "node:path";
 function loadOrCreateE2EKey(path2) {
   if (existsSync20(path2)) {
     const raw = Buffer.from(readFileSync14(path2, "utf8").trim(), "base64");
     if (raw.length === 32) return x25519FromRaw(raw);
   }
   const pair2 = generateX25519();
-  mkdirSync13(dirname12(path2), { recursive: true });
+  mkdirSync13(dirname13(path2), { recursive: true });
   writeFileSync15(path2, privateRaw(pair2.privateKey).toString("base64") + "\n", { mode: 384 });
   return pair2;
 }
@@ -39334,7 +39722,7 @@ var RelayLink = class {
 
 // src/push/boardDevices.ts
 import { existsSync as existsSync21, mkdirSync as mkdirSync14, readFileSync as readFileSync15, writeFileSync as writeFileSync16 } from "node:fs";
-import { dirname as dirname13 } from "node:path";
+import { dirname as dirname14 } from "node:path";
 var BoardDevices = class {
   constructor(path2) {
     this.path = path2;
@@ -39377,7 +39765,7 @@ var BoardDevices = class {
   }
   save() {
     if (!this.path) return;
-    mkdirSync14(dirname13(this.path), { recursive: true });
+    mkdirSync14(dirname14(this.path), { recursive: true });
     writeFileSync16(this.path, JSON.stringify(this.list(), null, 2) + "\n", { mode: 384 });
   }
 };
@@ -39630,7 +40018,7 @@ var BoardPusher = class {
 
 // src/push/pushDevices.ts
 import { existsSync as existsSync22, mkdirSync as mkdirSync15, readFileSync as readFileSync16, writeFileSync as writeFileSync17 } from "node:fs";
-import { dirname as dirname14 } from "node:path";
+import { dirname as dirname15 } from "node:path";
 var PushDevices = class {
   constructor(path2) {
     this.path = path2;
@@ -39673,7 +40061,7 @@ var PushDevices = class {
   }
   save() {
     if (!this.path) return;
-    mkdirSync15(dirname14(this.path), { recursive: true });
+    mkdirSync15(dirname15(this.path), { recursive: true });
     writeFileSync17(this.path, JSON.stringify(this.list(), null, 2) + "\n", { mode: 384 });
   }
 };
@@ -40291,7 +40679,7 @@ async function startDaemon(opts = {}) {
   const controlPort2 = opts.controlPort ?? CONTROL_PORT;
   const log = opts.log ?? createLogger({ file: paths.log, level: process.env["GRENADE_LOG"] ?? "info" });
   const e2eKey = loadOrCreateE2EKey(opts.e2eKeyPath ?? paths.e2eKey);
-  const info = { id: loadDaemonId(), name: opts.name ?? defaultName(), version: VERSION, os: daemonOs(), key: e2eKey.publicKey.toString("base64"), e2e: 1, inputSent: 1, conversations: 1, conversationDelete: 1, term: 1, folders: 1, board: 1, groupNames: 1, voice: 1, codexActivity: 1, agents: [...AGENTS] };
+  const info = { id: loadDaemonId(), name: opts.name ?? defaultName(), version: VERSION, os: daemonOs(), key: e2eKey.publicKey.toString("base64"), e2e: 1, inputSent: 1, conversations: 1, conversationDelete: 1, term: 1, folders: 1, board: 1, groupNames: 1, voice: 1, canvas: 1, codexActivity: 1, agents: [...AGENTS] };
   const allowPlainLan = opts.allowPlainLan === true;
   const tmux = opts.tmux ?? createTmux({ agentFlags: { claude: claudeHookFlags(port), codex: codexHookFlags(port) }, serverScope: underSystemd() });
   const tokens = new TokenStore(opts.tokensPath === null ? void 0 : opts.tokensPath ?? paths.tokens);
@@ -40304,7 +40692,7 @@ async function startDaemon(opts = {}) {
   });
   const summarizer = startSummarizer(registry2, log, opts.summaries ?? process.env["GRENADE_SUMMARIES"] !== "off");
   await registry2.adopt();
-  const groupsPath = opts.sessionsPath === null ? void 0 : opts.sessionsPath ? join17(dirname15(opts.sessionsPath), "groups.json") : paths.groups;
+  const groupsPath = opts.sessionsPath === null ? void 0 : opts.sessionsPath ? join18(dirname16(opts.sessionsPath), "groups.json") : paths.groups;
   const groupOrder = new GroupOrderStore(registry2, log, groupsPath);
   const poller = startPoller({ tmux, registry: registry2, log });
   const pinnedTerminal = opts.terminal ?? terminalFromEnv();
@@ -40376,7 +40764,7 @@ async function startDaemon(opts = {}) {
   for (const { id, path: path2 } of registry2.transcripts()) {
     readActivity(id, path2).catch((e) => log.debug("Could not read the activity from a saved transcript", { session: id, path: path2, error: e }));
   }
-  const marksPath = opts.sessionsPath === null ? void 0 : opts.sessionsPath ? join17(dirname15(opts.sessionsPath), "conversations.json") : paths.conversations;
+  const marksPath = opts.sessionsPath === null ? void 0 : opts.sessionsPath ? join18(dirname16(opts.sessionsPath), "conversations.json") : paths.conversations;
   const marks = new ConversationMarks(log, marksPath);
   const held = () => heldConversations(registry2.transcripts(), (id) => (registry2.get(id)?.status ?? "gone") !== "gone");
   const conversationIndex = new AllConversations([
@@ -40390,6 +40778,7 @@ async function startDaemon(opts = {}) {
     log,
     ...opts.voiceFetch ? { fetch: opts.voiceFetch } : {}
   });
+  const canvas = new CanvasService(() => registry2.list(), new CanvasWatcher(void 0, void 0, (folder, error62) => log.debug("Could not look at a canvas", { folder, error: error62 instanceof Error ? error62.message : String(error62) })));
   const models = {
     async switch(session, model, effort) {
       if (switchingModel.has(session.id)) throw new ModelSwitchError("A model switch is already under way in this session.");
@@ -40531,7 +40920,7 @@ async function startDaemon(opts = {}) {
   prompts.on("answered", (id) => registry2.applyHook(id, "working", void 0, true));
   const screenPrompts = new ScreenPrompts(registry2, prompts, log, (id) => switchingModel.has(id));
   watchScreenBackground(registry2);
-  const backgroundWatch = new ClaudeBackgroundWatch(registry2, join17(opts.claudeDir ?? paths.claudeDir, "sessions"), log);
+  const backgroundWatch = new ClaudeBackgroundWatch(registry2, join18(opts.claudeDir ?? paths.claudeDir, "sessions"), log);
   backgroundWatch.start();
   registry2.on("removed", (id) => {
     prompts.closeSession(id);
@@ -40590,12 +40979,13 @@ async function startDaemon(opts = {}) {
     groups: groupOrder,
     models,
     voice,
+    canvas,
     conversations,
-    openTerm(open5) {
+    openTerm(open6) {
       const stream = new TermStream({
-        ...open5,
-        resize: (cols, rows, by) => registry2.resize(open5.sessionId, cols, rows, by),
-        release: (by) => registry2.releaseSize(open5.sessionId, by),
+        ...open6,
+        resize: (cols, rows, by) => registry2.resize(open6.sessionId, cols, rows, by),
+        release: (by) => registry2.releaseSize(open6.sessionId, by),
         log
       });
       stream.start();
@@ -40727,6 +41117,7 @@ async function startDaemon(opts = {}) {
       mirror.stop();
       poller.stop();
       relayLink?.stop();
+      canvas.stop();
       push2.stop();
       prompts.closeAll();
       summarizer?.stop();
@@ -40923,7 +41314,7 @@ program2.command("install-hooks").description("also let a claude typed by hand i
   if (o.print) return console.log(JSON.stringify(settings, null, 2));
   if (o.remove) removeOldCodexHooks();
   if (!changed) return console.log(`nothing to do: ${paths.claudeSettings} already up to date`);
-  mkdirSync16(dirname16(paths.claudeSettings), { recursive: true });
+  mkdirSync16(dirname17(paths.claudeSettings), { recursive: true });
   writeFileSync18(paths.claudeSettings, JSON.stringify(settings, null, 2) + "\n");
   console.log(`${o.remove ? "removed Grenade hooks from" : "installed Grenade hooks in"} ${paths.claudeSettings}`);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holdgrenade/cli",
-  "version": "1.0.48",
+  "version": "1.0.49",
   "description": "Watch and drive AI coding agents (Claude Code, Codex, a shell) in your computer's terminals from your phone.",
   "type": "module",
   "bin": {