agent-yes 1.193.0 → 1.195.0

package/lab/ui/index.html

@@ -392,6 +392,60 @@
         padding-bottom: 10px;
         margin-bottom: 4px;
       }
+      /* P2P preview overlay — full-window iframe of the exposed app. */
+      .preview-overlay {
+        position: fixed;
+        inset: 0;
+        z-index: 70;
+        display: flex;
+        flex-direction: column;
+        background: var(--bg);
+      }
+      .preview-overlay[hidden] {
+        display: none;
+      }
+      .preview-bar {
+        display: flex;
+        align-items: center;
+        gap: 10px;
+        padding: 6px 10px;
+        border-bottom: 1px solid var(--line);
+        background: var(--panel, var(--bg));
+        flex: 0 0 auto;
+      }
+      .preview-bar .preview-badge {
+        font-size: 11px;
+        font-weight: 600;
+        color: #3fb950;
+        border: 1px solid #3fb95055;
+        border-radius: 6px;
+        padding: 2px 7px;
+        white-space: nowrap;
+      }
+      .preview-bar .preview-title {
+        flex: 1;
+        min-width: 0;
+        overflow: hidden;
+        text-overflow: ellipsis;
+        white-space: nowrap;
+        opacity: 0.8;
+        font-size: 13px;
+      }
+      .preview-bar button {
+        border: 1px solid var(--line);
+        background: transparent;
+        color: var(--fg);
+        border-radius: 6px;
+        padding: 3px 9px;
+        cursor: pointer;
+        font-size: 13px;
+      }
+      .preview-frame {
+        flex: 1 1 auto;
+        border: 0;
+        width: 100%;
+        background: #fff;
+      }
       /* Share modal — QR + link for a single-agent view-only share. */
       .modal-backdrop {
         position: fixed;
@@ -1079,6 +1133,50 @@
           background-color: color-mix(in srgb, var(--peer) 24%, transparent);
         }
       }
+      /* An inter-agent message just travelled between two rows (`ay send`/`key`/
+         `select`, from /api/edges `sends`). Both ends pulse so the exchange reads
+         as a pair: green at the SENDER, amber at the RECIPIENT — the same hues the
+         /r/ forest uses for its send wire. Distinct from .stdinflash (which fires
+         for ANY stdin, including a human typing) so agent→agent traffic stands out. */
+      .row.sendflash {
+        animation: sendpulse 0.7s ease-in-out infinite;
+      }
+      .row.recvflash {
+        animation: recvpulse 0.7s ease-in-out infinite;
+      }
+      @keyframes sendpulse {
+        0%,
+        100% {
+          background-color: transparent;
+        }
+        50% {
+          background-color: color-mix(in srgb, var(--green) 22%, transparent);
+        }
+      }
+      @keyframes recvpulse {
+        0%,
+        100% {
+          background-color: transparent;
+        }
+        50% {
+          background-color: color-mix(in srgb, var(--amber) 22%, transparent);
+        }
+      }
+      /* The wire itself: an SVG laid over the (scrolling) list, drawn from the row
+         rects. Inside .list so it scrolls with the rows; pointer-events off so it
+         never eats a click meant for a row. */
+      .list {
+        position: relative;
+      }
+      .wire-overlay {
+        position: absolute;
+        left: 0;
+        top: 0;
+        width: 100%;
+        pointer-events: none;
+        overflow: visible;
+        z-index: 3;
+      }
       /* Per-row chip: how many peers are watching THIS agent (yellow, mono). */
       .peerchip {
         font-family: var(--mono);
@@ -1960,6 +2058,19 @@
       </div>
     </div>
 
+    <!-- P2P preview: the exposed app rendered in-console over the machine's
+         WebRTC tunnel (Service Worker proxies /w/p/<src>/<port>/*, no relay). -->
+    <div class="preview-overlay" id="previewOverlay" hidden>
+      <div class="preview-bar">
+        <span class="preview-badge" title="served over a direct P2P WebRTC tunnel — traffic does not go through agent-yes.com">⚡ P2P · no relay</span>
+        <span class="preview-title" id="previewTitle"></span>
+        <button id="previewReload" type="button" title="reload">↻</button>
+        <button id="previewPop" type="button" title="open in a new tab">↗</button>
+        <button id="previewClose" type="button" title="close">✕</button>
+      </div>
+      <iframe class="preview-frame" id="previewFrame" title="preview"></iframe>
+    </div>
+
     <!-- Cmd/Ctrl+K omnibox: search agents by title (instant) then output (tail),
          or spawn a new agent in the highlighted agent's cwd with the typed prompt. -->
     <div class="omni" id="omni" style="display: none">
@@ -2034,6 +2145,16 @@
       const stdinSeen = new Map();
       const flashUntil = new Map();
       const STDIN_FLASH_MS = 1200;
+      // Inter-agent message traffic (from /api/edges `sends`). A send is an EVENT,
+      // not a standing relation: both ends pulse and the wire between them fades
+      // out over SEND_FADE_MS. `sendSeen` dedupes by (by,target,at) so re-polling
+      // the same still-in-window edge doesn't re-arm the flash forever.
+      const sendFlashUntil = new Map(); // sender key   → until (ms)
+      const recvFlashUntil = new Map(); // receiver key → until (ms)
+      const sendSeen = new Set();
+      let sendWires = []; // [{by, target, at, kind}] — live wires, keys are <src>#<pid>
+      const SEND_FLASH_MS = 2000;
+      const SEND_FADE_MS = 20000; // wire fully faded this long after delivery
       let es = null; // live-tail subscription closer
       let term = null; // xterm.js Terminal rendering the raw PTY stream
       let fit = null;
@@ -2176,6 +2297,15 @@
             started_at: a.startedAt,
           }));
         return {
+          // Marker + raw tunnel access for the P2P preview: only a codehost
+          // (`ch`) source can proxy a local port over its WebRTC DataChannel via
+          // the daemon's `preview` plugin (/__codehost/port/<PORT>/*), so the
+          // viewer's preview traffic stays peer-to-peer, off the edge relay.
+          ch: true,
+          peerId,
+          previewFetch(port, method, path, init) {
+            return chRoom.room.fetch(peerId, method, "/__codehost/port/" + port + path, init || {});
+          },
           async fetchJSON(path) {
             let res;
             try {
@@ -2432,6 +2562,43 @@
       const sources = new Map(); // id -> { id, room, host, kind, tx, client, live, devices, serverCount }
       const srcFor = (e) => (e && sources.get(e._src)) || sources.get(LOCAL) || null;
       const txFor = (e) => srcFor(e)?.tx || localTx;
+
+      // Preview bridge: the Service Worker (which can't own the RTCPeerConnection)
+      // forwards each /w/p/<src>/<port>/* request here; we run it over that
+      // source's codehost tunnel (previewFetch → the daemon's `preview` plugin →
+      // 127.0.0.1:<port>) and stream the response back through the message port.
+      // This keeps the viewer's preview traffic peer-to-peer, off the edge relay.
+      if ("serviceWorker" in navigator) {
+        navigator.serviceWorker.addEventListener("message", (event) => {
+          const msg = event.data;
+          if (!msg || msg.type !== "ay-preview-fetch") return;
+          const port = event.ports[0];
+          const tx = sources.get(msg.src)?.tx;
+          if (!tx || !tx.ch || !tx.previewFetch) {
+            port.postMessage({ type: "error", message: "no P2P preview for this machine" });
+            return;
+          }
+          const init = { headers: msg.headers };
+          if (msg.body) init.body = new Uint8Array(msg.body);
+          tx.previewFetch(msg.port, msg.method, msg.path, init)
+            .then(async (res) => {
+              const headers = {};
+              res.headers.forEach((v, k) => (headers[k] = v));
+              port.postMessage({ type: "head", status: res.status, statusText: res.statusText, headers });
+              if (res.body) {
+                const reader = res.body.getReader();
+                for (;;) {
+                  const { done, value } = await reader.read();
+                  if (done) break;
+                  const buf = value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+                  port.postMessage({ type: "body", chunk: buf }, [buf]);
+                }
+              }
+              port.postMessage({ type: "end" });
+            })
+            .catch((err) => port.postMessage({ type: "error", message: String(err) }));
+        });
+      }
       // Every machine belonging to a room (for an ay-share room, the room itself).
       const roomSources = (name) => [...sources.values()].filter((s) => (s.room || s.id) === name);
       const roomLive = (name) =>
@@ -3057,6 +3224,131 @@
         }
       }, 200);
 
+      // ── inter-agent message traffic: row pulses + the wire between them ───────
+
+      /** Remaining life of a send, 1 at delivery → 0 once fully faded. */
+      function sendAlpha(at) {
+        return Math.max(0, Math.min(1, 1 - (Date.now() - at) / SEND_FADE_MS));
+      }
+
+      // Poll every source's /api/edges and arm a pulse for each NEW send. Edge pids
+      // are mapped to the `<src>#<pid>` row keys the list already uses, so a wire
+      // never crosses sources (a daemon only ever sees its own agents). An older
+      // daemon has no `sends` field — the console then simply shows no traffic.
+      async function pollEdges() {
+        const srcs = [...sources.values()].filter((s) => s.tx && s.live);
+        const results = await Promise.allSettled(
+          srcs.map(async (s) => {
+            const body = await s.tx.fetchJSON("/api/edges");
+            return (body?.sends ?? []).map((e) => ({
+              by: `${s.id}#${e.by}`,
+              target: `${s.id}#${e.target}`,
+              at: e.at,
+              kind: e.kind,
+            }));
+          }),
+        );
+        const edges = results.flatMap((p) => (p.status === "fulfilled" ? p.value : []));
+        const now = Date.now();
+        for (const e of edges) {
+          const id = `${e.by}${e.target}${e.at}`;
+          if (sendSeen.has(id)) continue; // already pulsed for this exact send
+          sendSeen.add(id);
+          // Don't flash a send that's already older than its own flash window (e.g.
+          // the first poll after opening the console, which sees the whole minute).
+          if (now - e.at > SEND_FLASH_MS) continue;
+          sendFlashUntil.set(e.by, now + SEND_FLASH_MS);
+          recvFlashUntil.set(e.target, now + SEND_FLASH_MS);
+        }
+        // Keep only wires still worth drawing; bound sendSeen to the live set so it
+        // can't grow without limit over a long session.
+        sendWires = edges.filter((e) => sendAlpha(e.at) > 0);
+        if (sendSeen.size > 500) {
+          const live = new Set(sendWires.map((e) => `${e.by}${e.target}${e.at}`));
+          for (const id of [...sendSeen]) if (!live.has(id)) sendSeen.delete(id);
+        }
+        renderSendWires();
+      }
+      setInterval(() => void pollEdges(), 1500);
+
+      // Drive the send/recv row pulses on the stable list DOM (same trick as the
+      // stdin flash above), and keep the wire fading. No-op when nothing's in
+      // flight, so an idle console costs nothing.
+      setInterval(() => {
+        const now = Date.now();
+        for (const [k, until] of [...sendFlashUntil.entries()])
+          if (until <= now) sendFlashUntil.delete(k);
+        for (const [k, until] of [...recvFlashUntil.entries()])
+          if (until <= now) recvFlashUntil.delete(k);
+        const listEl = $("list");
+        if (listEl && (sendFlashUntil.size || recvFlashUntil.size)) {
+          for (const el of listEl.querySelectorAll(".row[data-key]")) {
+            const key = el.getAttribute("data-key");
+            el.classList.toggle("sendflash", (sendFlashUntil.get(key) || 0) > now);
+            el.classList.toggle("recvflash", (recvFlashUntil.get(key) || 0) > now);
+          }
+        }
+        if (sendWires.length) {
+          sendWires = sendWires.filter((e) => sendAlpha(e.at) > 0);
+          renderSendWires(); // redraw so the wire's opacity decays smoothly
+        }
+      }, 200);
+
+      /**
+       * Draw the live send wires over the list: an S-curve in the left gutter from
+       * the sender row's centre to the recipient's, opacity decaying with age.
+       *
+       * The SVG lives INSIDE #list (which scrolls), sized to scrollHeight, so the
+       * wires scroll with their rows instead of needing a scroll listener. An
+       * endpoint that isn't in the DOM right now — folded under a collapsed parent,
+       * or filtered out by the search box — simply drops its wire.
+       */
+      function renderSendWires() {
+        const listEl = $("list");
+        if (!listEl) return;
+        let svg = listEl.querySelector(".wire-overlay");
+        if (!sendWires.length) {
+          if (svg) svg.remove();
+          return;
+        }
+        if (!svg) {
+          svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+          svg.setAttribute("class", "wire-overlay");
+          listEl.appendChild(svg);
+        }
+        const base = listEl.getBoundingClientRect();
+        // Row centres in the list's own scrolled coordinate space.
+        const yOf = (key) => {
+          const el = listEl.querySelector(`.row[data-key="${CSS.escape(key)}"]`);
+          if (!el) return null;
+          const r = el.getBoundingClientRect();
+          return r.top - base.top + listEl.scrollTop + r.height / 2;
+        };
+        svg.setAttribute("height", String(listEl.scrollHeight));
+        svg.style.height = listEl.scrollHeight + "px";
+        const paths = [];
+        for (const e of sendWires) {
+          const y1 = yOf(e.by);
+          const y2 = yOf(e.target);
+          if (y1 == null || y2 == null || y1 === y2) continue;
+          const a = sendAlpha(e.at);
+          const color = e.kind ? "245, 158, 11" : "63, 185, 80"; // amber = key/select, green = msg
+          // Bulge left-to-right with the gap so a long hop is legible, capped so it
+          // stays inside the gutter.
+          const bulge = Math.min(34, 8 + Math.abs(y2 - y1) * 0.18);
+          const x = 8;
+          paths.push(
+            `<path d="M ${x},${y1} C ${x + bulge},${y1} ${x + bulge},${y2} ${x},${y2}" ` +
+              `fill="none" stroke="rgba(${color}, ${(0.2 + 0.8 * a).toFixed(3)})" ` +
+              `stroke-width="${(1 + 1.6 * a).toFixed(2)}" stroke-dasharray="3 3" />` +
+              // arrowhead at the recipient end — which way the message travelled
+              `<circle cx="${x}" cy="${y2}" r="${(2 + 1.5 * a).toFixed(2)}" ` +
+              `fill="rgba(${color}, ${(0.3 + 0.7 * a).toFixed(3)})" />`,
+          );
+        }
+        svg.innerHTML = paths.join("");
+      }
+
       // Peer-selection overlay. The coordinate math (parseSel / selSegments /
       // hashHue) lives in console-logic.js (unit-tested); here we just measure the
       // DOM and place the boxes. Drawn in OUR buffer rows, clipped to the viewport.
@@ -3397,6 +3689,23 @@
           btn.textContent = orig;
         }, 1200);
       }
+      // In-console P2P preview: an iframe served from /w/p/<src>/<port>/, which
+      // the Service Worker proxies over the machine's WebRTC tunnel (no relay).
+      function openPreview(src, port) {
+        // Scope-relative so it works at both /w/ (agent-yes.com) and / (ay serve).
+        const url = new URL("p/" + encodeURIComponent(src) + "/" + port + "/", location.href).pathname;
+        const frame = $("previewFrame");
+        if (!frame) return window.open(url, "_blank");
+        $("previewTitle").textContent = "localhost:" + port;
+        frame.src = url;
+        $("previewOverlay").hidden = false;
+      }
+      function closePreview() {
+        const ov = $("previewOverlay");
+        if (ov) ov.hidden = true;
+        const frame = $("previewFrame");
+        if (frame) frame.src = "about:blank"; // tear down the app + its tunnel
+      }
       async function doExpose() {
         const tx = exposePendingTx || localTx;
         const port = exposePendingPort;
@@ -3435,7 +3744,7 @@
               return;
             }
             if (Array.isArray(arr))
-              for (const ex of arr) rows.push({ ...ex, _srcName: s.name || s.id, _tx: tx });
+              for (const ex of arr) rows.push({ ...ex, _srcName: s.name || s.id, _src: s.id, _tx: tx });
           }),
         );
         list.textContent = "";
@@ -3470,8 +3779,19 @@
         meta.appendChild(host);
         row.appendChild(meta);
 
+        // Preview here: render the app P2P over this machine's WebRTC tunnel
+        // (no edge relay), in an in-console iframe. Only offered for a codehost
+        // (ch) source, which has the `preview` plugin.
+        if (ex._tx && ex._tx.ch) {
+          const preview = document.createElement("button");
+          preview.className = "primary";
+          preview.textContent = "Preview";
+          preview.title = "view in-console over a direct P2P tunnel (no relay)";
+          preview.onclick = () => openPreview(ex._src, ex.port);
+          row.appendChild(preview);
+        }
+
         const openBtn = document.createElement("button");
-        openBtn.className = "primary";
         openBtn.textContent = "Open";
         // Re-mint a fresh claim so the owner (or a guest) gets a usable link.
         openBtn.onclick = async () => {
@@ -3574,6 +3894,15 @@
         $("exposeModal")?.addEventListener("click", (e) => {
           if (e.target === $("exposeModal")) closeExposeModal();
         });
+        $("previewClose")?.addEventListener("click", closePreview);
+        $("previewReload")?.addEventListener("click", () => {
+          const f = $("previewFrame");
+          if (f) f.src = f.src;
+        });
+        $("previewPop")?.addEventListener("click", () => {
+          const f = $("previewFrame");
+          if (f && f.src && f.src !== "about:blank") window.open(f.src, "_blank");
+        });
       })();
       (function shareModalBoot() {
         $("shareClose")?.addEventListener("click", closeShareModal);
@@ -4236,9 +4565,19 @@
       // redundant — and it's the only row your own terminal's protocol replies
       // could ever nudge, so this also keeps a resize from blinking your own row.
       function rowFlags(e) {
+        const now = Date.now();
         const peers = focusByKey.get(e._key) || 0;
-        const flash = e._key !== sel && (flashUntil.get(e._key) || 0) > Date.now();
-        return (peers ? " peerfocus" : "") + (flash ? " stdinflash" : "");
+        const flash = e._key !== sel && (flashUntil.get(e._key) || 0) > now;
+        // Re-emit the message pulses too: renderList replaces rows wholesale, so a
+        // class the fast loop toggled on would be lost on the next render otherwise.
+        const sent = (sendFlashUntil.get(e._key) || 0) > now;
+        const recv = (recvFlashUntil.get(e._key) || 0) > now;
+        return (
+          (peers ? " peerfocus" : "") +
+          (flash ? " stdinflash" : "") +
+          (sent ? " sendflash" : "") +
+          (recv ? " recvflash" : "")
+        );
       }
       // A yellow chip showing how many peers are watching this agent ("" if none).
       function peerChipHtml(e) {
@@ -4303,6 +4642,7 @@
         <span class="age">${age(e)}</span></div>`;
               })
               .join("") || `<div class="empty">no match</div>`;
+          renderSendWires(); // rows were replaced — re-draw the overlay (see below)
           return;
         }
         $("list").innerHTML =
@@ -4341,6 +4681,10 @@
       </div>`;
             })
             .join("") || `<div class="empty">no match</div>`;
+        // The innerHTML above replaced every row — and with them the wire overlay
+        // (a child of #list). Re-draw it against the fresh rects, or an in-flight
+        // wire would vanish on the next list render.
+        renderSendWires();
       }
 
       // Restore the last filter so a refresh (incl. the auto-reload on a new

package/lab/ui/sw.js

@@ -6,7 +6,60 @@
 // fallback when offline, which is what makes the installed app launchable with no
 // network. WebSocket signaling and cross-origin CDN scripts are not GET fetches we
 // own, so they pass straight through.
-const CACHE = "agent-yes-w-v2";
+const CACHE = "agent-yes-w-v3";
+// Preview proxy: <scope>p/<encSrc>/<port>/* renders a machine's local dev
+// server INSIDE the console's existing WebRTC tunnel (peer-to-peer, off the
+// edge relay). We can't own the RTCPeerConnection here, so we forward each
+// request to the controlling page (which does), streaming the response back.
+// Scope-relative so it works at both /w/ (agent-yes.com) and / (ay serve --http).
+const BASE = new URL("./", self.location.href).pathname; // "/w/" or "/"
+const PREVIEW = new RegExp("^" + BASE.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "p/([^/]+)/(\\d{1,5})(/.*)?$");
+
+async function pickClient() {
+  const all = await self.clients.matchAll({ type: "window", includeUncontrolled: true });
+  // Prefer a real console tab (not the preview iframe itself).
+  return all.find((c) => !new URL(c.url).pathname.startsWith(BASE + "p/")) || all[0] || null;
+}
+
+async function proxyPreview(request, src, port, rest) {
+  const client = await pickClient();
+  if (!client) return new Response("open the agent-yes console to preview", { status: 502 });
+  const headers = {};
+  request.headers.forEach((v, k) => (headers[k] = v));
+  const body =
+    request.method === "GET" || request.method === "HEAD"
+      ? undefined
+      : new Uint8Array(await request.arrayBuffer());
+  return new Promise((resolve) => {
+    const mc = new MessageChannel();
+    let resolved = false;
+    mc.port1.onmessage = (ev) => {
+      const msg = ev.data;
+      if (msg.type === "head") {
+        const stream = new ReadableStream({
+          start(controller) {
+            mc.port1.onmessage = (e2) => {
+              const m2 = e2.data;
+              if (m2.type === "body") controller.enqueue(new Uint8Array(m2.chunk));
+              else if (m2.type === "end") controller.close();
+              else if (m2.type === "error") controller.error(new Error(m2.message));
+            };
+          },
+        });
+        resolved = true;
+        resolve(new Response(stream, { status: msg.status, statusText: msg.statusText, headers: msg.headers }));
+      } else if (msg.type === "error" && !resolved) {
+        resolved = true;
+        resolve(new Response("preview tunnel error: " + msg.message, { status: 502 }));
+      }
+    };
+    client.postMessage(
+      { type: "ay-preview-fetch", src, port: Number(port), method: request.method, path: rest, headers, body },
+      [mc.port2, ...(body ? [body.buffer] : [])],
+    );
+  });
+}
+
 const SHELL = [
   "./",
   "./index.html",
@@ -35,23 +88,52 @@ self.addEventListener("activate", (e) => {
 
 self.addEventListener("fetch", (e) => {
   const req = e.request;
-  if (req.method !== "GET") return;
   const url = new URL(req.url);
-  // Only the same-origin /w/ shell; let everything else (CDN, signaling) be.
-  if (url.origin !== self.location.origin || !url.pathname.startsWith("/w/")) return;
-  e.respondWith(
-    (async () => {
-      try {
-        const res = await fetch(req);
-        if (res && res.ok) {
-          const c = await caches.open(CACHE);
-          c.put(req, res.clone());
-        }
-        return res;
-      } catch {
-        const cached = await caches.match(req);
-        return cached || (await caches.match("./index.html")) || Response.error();
-      }
-    })(),
-  );
+  if (url.origin !== self.location.origin) return; // CDN / signaling pass through
+  // Preview proxy (any method): a request is a preview request if its own path
+  // is under <base>p/<src>/<port>/ (the iframe navigation + relative URLs), OR
+  // it comes from a preview-iframe CLIENT (an app's absolute-path subresource
+  // like Vite's /@vite/client — which resolves to the origin root, not our
+  // prefix). Either way we proxy it to that machine's port over the tunnel.
+  const own = PREVIEW.exec(url.pathname);
+  if (own) {
+    const rest = (own[3] || "/") + url.search;
+    e.respondWith(proxyPreview(req, decodeURIComponent(own[1]), own[2], rest));
+    return;
+  }
+  e.respondWith(maybePreviewFromClient(e, req, url));
 });
+
+// If the request came from a preview iframe, proxy it to that iframe's port
+// (appPath = the request's own path); otherwise fall back to the shell handler.
+async function maybePreviewFromClient(e, req, url) {
+  const clientId = e.clientId || e.resultingClientId;
+  if (clientId) {
+    const client = await self.clients.get(clientId).catch(() => null);
+    const cm = client && PREVIEW.exec(new URL(client.url).pathname);
+    if (cm) {
+      return proxyPreview(req, decodeURIComponent(cm[1]), cm[2], url.pathname + url.search);
+    }
+  }
+  return shellFetch(req, url);
+}
+
+async function shellFetch(req, url) {
+  const p = url.pathname;
+  // Pass through non-GET, the API (SSE/POST — never cache), and anything off the
+  // shell. Only cache the static console shell for offline launch.
+  const isApi = p === "/api" || p.startsWith("/api/");
+  if (req.method !== "GET" || isApi || !p.startsWith(BASE)) return fetch(req);
+  // Network-first for the same-origin shell; cache is the offline fallback.
+  try {
+    const res = await fetch(req);
+    if (res && res.ok) {
+      const c = await caches.open(CACHE);
+      c.put(req, res.clone());
+    }
+    return res;
+  } catch {
+    const cached = await caches.match(req);
+    return cached || (await caches.match("./index.html")) || Response.error();
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-yes",
-  "version": "1.193.0",
+  "version": "1.195.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",