npm - agent-yes - Versions diffs - 1.195.0 → 1.196.1 - Mend

agent-yes 1.195.0 → 1.196.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

package/dist/SUPPORTED_CLIS-CFTeu8hj.js +8 -0
package/dist/{SUPPORTED_CLIS-Bdj9qDRm.js → SUPPORTED_CLIS-DOwI2CmP.js} +2 -2
package/dist/{agentShare-M2jaTMlH.js → agentShare-bCHRyHSj.js} +2 -2
package/dist/cli.js +4 -4
package/dist/index.js +2 -2
package/dist/{notifyDaemon-D5HwUMxH.js → notifyDaemon-lPJrVB96.js} +2 -2
package/dist/{rustBinary-B4pfibDJ.js → rustBinary-BYJrF4jm.js} +2 -2
package/dist/{schedule-1oS-Yxxa.js → schedule-BVTk2aWT.js} +4 -4
package/dist/{serve-Ce708ALB.js → serve-sTUSkXkr.js} +21 -16
package/dist/{setup-fTLT9Bf2.js → setup-B03A9bDx.js} +2 -2
package/dist/{subcommands-CV5gqRKq.js → subcommands-CRW8on1l.js} +1 -1
package/dist/{subcommands-CqB9zo8_.js → subcommands-RnI0AkSK.js} +6 -6
package/dist/{ts-DDsICrj-.js → ts-CHkgLvsJ.js} +2 -2
package/dist/{versionChecker-B8qEzYDu.js → versionChecker-BGywS-RN.js} +2 -2
package/lab/ui/index.html +96 -0
package/lab/ui/room-client.js +544 -388
package/lab/ui/sw.js +71 -19
package/package.json +1 -1
package/ts/serve.spec.ts +29 -1
package/ts/serve.ts +24 -3
package/dist/SUPPORTED_CLIS-Daig8XHX.js +0 -8

package/lab/ui/sw.js CHANGED Viewed

@@ -21,7 +21,7 @@ async function pickClient() {
   return all.find((c) => !new URL(c.url).pathname.startsWith(BASE + "p/")) || all[0] || null;
 }
-async function proxyPreview(request, src, port, rest) {
+async function proxyPreview(request, src, port, rest, allowInject) {
   const client = await pickClient();
   if (!client) return new Response("open the agent-yes console to preview", { status: 502 });
   const headers = {};
@@ -35,23 +35,40 @@ async function proxyPreview(request, src, port, rest) {
     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 }));
+      if (msg.type !== "head") {
+        if (msg.type === "error" && !resolved) {
+          resolved = true;
+          resolve(new Response("preview tunnel error: " + msg.message, { status: 502 }));
+        }
+        return;
       }
+      resolved = true;
+      const headers = new Headers(msg.headers);
+      const ct = headers.get("content-type") || "";
+      // HTML document navigations (the /p/ path itself, not app subresources):
+      // buffer, strip CSP, and inject a window.WebSocket shim so the app's own
+      // sockets (Vite HMR) also ride the P2P tunnel. Everything else streams.
+      if (allowInject && ct.includes("text/html")) {
+        const chunks = [];
+        mc.port1.onmessage = (e2) => {
+          const m2 = e2.data;
+          if (m2.type === "body") chunks.push(new Uint8Array(m2.chunk));
+          else if (m2.type === "end") resolve(injectBootstrap(chunks, msg, headers, src, Number(port)));
+          else if (m2.type === "error") resolve(new Response("preview error: " + m2.message, { status: 502 }));
+        };
+        return;
+      }
+      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));
+          };
+        },
+      });
+      resolve(new Response(stream, { status: msg.status, statusText: msg.statusText, headers }));
     };
     client.postMessage(
       { type: "ay-preview-fetch", src, port: Number(port), method: request.method, path: rest, headers, body },
@@ -60,6 +77,37 @@ async function proxyPreview(request, src, port, rest) {
   });
 }
+// Concatenate the buffered HTML chunks, strip CSP, and inject a bootstrap
+// <script> that replaces window.WebSocket with the parent console's tunneled
+// shim — so a dev server's own sockets (Vite HMR) ride the P2P tunnel too. Runs
+// first (right after <head>) so the override is in place before app scripts.
+function injectBootstrap(chunks, msg, headers, src, port) {
+  let total = 0;
+  for (const c of chunks) total += c.byteLength;
+  const all = new Uint8Array(total);
+  let off = 0;
+  for (const c of chunks) {
+    all.set(c, off);
+    off += c.byteLength;
+  }
+  const raw = new TextDecoder().decode(all);
+  const boot =
+    "<script>(function(){try{var mk=window.parent&&window.parent.__ayMakeWS;" +
+    "if(mk)window.WebSocket=mk(" +
+    JSON.stringify(src) +
+    "," +
+    JSON.stringify(port) +
+    ");}catch(e){}})();</" +
+    "script>";
+  const html = /<head[^>]*>/i.test(raw)
+    ? raw.replace(/<head[^>]*>/i, (m) => m + boot)
+    : boot + raw;
+  headers.delete("content-security-policy");
+  headers.delete("content-security-policy-report-only");
+  headers.delete("content-length");
+  return new Response(html, { status: msg.status, statusText: msg.statusText, headers });
+}
 const SHELL = [
   "./",
   "./index.html",
@@ -98,7 +146,9 @@ self.addEventListener("fetch", (e) => {
   const own = PREVIEW.exec(url.pathname);
   if (own) {
     const rest = (own[3] || "/") + url.search;
-    e.respondWith(proxyPreview(req, decodeURIComponent(own[1]), own[2], rest));
+    // Navigations to the /p/ root/route may be an HTML doc → allow WS-shim
+    // injection; app subresources (below) never inject.
+    e.respondWith(proxyPreview(req, decodeURIComponent(own[1]), own[2], rest, true));
     return;
   }
   e.respondWith(maybePreviewFromClient(e, req, url));
@@ -112,7 +162,9 @@ async function maybePreviewFromClient(e, req, url) {
     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);
+      // Subresources (Vite's /@vite/client, module chunks, etc.) never get the
+      // WS shim injected — only the top-level /p/ navigation does.
+      return proxyPreview(req, decodeURIComponent(cm[1]), cm[2], url.pathname + url.search, false);
     }
   }
   return shellFetch(req, url);

package/package.json CHANGED Viewed

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

package/ts/serve.spec.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import { readFile } from "fs/promises";
 import { describe, expect, it } from "vitest";
-import { isNoNodeExecError, oxmgrVersionHasWindowsFix } from "./serve.ts";
+import { installerArgv, isNoNodeExecError, oxmgrVersionHasWindowsFix } from "./serve.ts";
 // Guards the Windows daemon-manager selection: on Windows we only PREFER oxmgr
 // when the installed build carries the daemon-socket-inheritance fix. Stock
@@ -90,3 +90,31 @@ describe("manager spawns pass a live env snapshot", () => {
     }
   });
 });
+// Guards the oxmgr bootstrap: bun blocks untrusted postinstalls, and oxmgr's
+// native binary only arrives via its postinstall — without --trust the install
+// "succeeds" but leaves a launcher that dies with "oxmgr binary is missing"
+// (the real reason bootstrap used to fall back to pm2 on fresh boxes).
+describe("installerArgv", () => {
+  it("trusts oxmgr's postinstall under bun", () => {
+    expect(installerArgv("oxmgr", "/x/bun", null)).toEqual([
+      "/x/bun",
+      "add",
+      "-g",
+      "--trust",
+      "oxmgr",
+    ]);
+  });
+  it("keeps pm2 untrusted under bun (pure JS, no required scripts)", () => {
+    expect(installerArgv("pm2", "/x/bun", "/x/npm")).toEqual(["/x/bun", "add", "-g", "pm2"]);
+  });
+  it("falls back to npm without a trust flag (npm runs scripts by default)", () => {
+    expect(installerArgv("oxmgr", null, "/x/npm")).toEqual(["/x/npm", "install", "-g", "oxmgr"]);
+  });
+  it("returns null with neither installer", () => {
+    expect(installerArgv("pm2", null, null)).toBeNull();
+  });
+});

package/ts/serve.ts CHANGED Viewed

@@ -471,16 +471,37 @@ async function resolveActiveManager(): Promise<DaemonManager | null> {
   return firstRunnable ?? resolveDaemonManager();
 }
+// The install command for one PM package. oxmgr gets `--trust` under bun: its
+// native binary arrives via the package's postinstall (scripts/install.js
+// downloads the platform build), and bun BLOCKS lifecycle scripts of untrusted
+// packages by default — which leaves a JS launcher that dies with "oxmgr binary
+// is missing" and was the real reason bootstrap kept falling back to pm2 on
+// fresh boxes. Re-adding with --trust also heals such a blocked install. pm2 is
+// pure JS with no required scripts, so it stays untrusted. npm runs lifecycle
+// scripts by default — no flag needed.
+export function installerArgv(
+  pkg: "oxmgr" | "pm2",
+  bun: string | null,
+  npm: string | null,
+): string[] | null {
+  if (bun) return [bun, "add", "-g", ...(pkg === "oxmgr" ? ["--trust"] : []), pkg];
+  if (npm) return [npm, "install", "-g", pkg];
+  return null;
+}
 // Install one PM package globally via the SAME JS package manager that installed
 // `ay` (bun preferred, npm fallback — no Rust toolchain required, so a fresh
 // Linux box with only bun from setup.sh works), then confirm the resulting
 // binary actually execs. Returns a runnable manager, or null if the install
 // failed or the binary can't run here (caller then tries the next candidate).
 async function installAndVerify(pkg: "oxmgr" | "pm2"): Promise<DaemonManager | null> {
-  const bun = Bun.which("bun");
-  const npm = Bun.which("npm");
-  const installer = bun ? [bun, "add", "-g", pkg] : npm ? [npm, "install", "-g", pkg] : null;
+  const installer = installerArgv(pkg, Bun.which("bun"), Bun.which("npm"));
   if (!installer) return null;
+  // The node→bun shim must exist BEFORE the install, not just before the probe:
+  // oxmgr's postinstall itself runs `node scripts/install.js` to fetch the
+  // native binary, so on a bun-only box a missing shim silently skips the
+  // download even when the script is trusted.
+  await ensureNodeRuntime();
   process.stderr.write(`ay serve install: installing ${pkg}…\n`);
   const code =
     (await Bun.spawn(installer, {

package/dist/SUPPORTED_CLIS-Daig8XHX.js DELETED Viewed

@@ -1,8 +0,0 @@
-import "./ts-DDsICrj-.js";
-import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-B8qEzYDu.js";
-import "./pidStore-BIvsBQ8X.js";
-import "./globalPidIndex-CoNr7tS8.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Bdj9qDRm.js";
-export { SUPPORTED_CLIS };