npm - agent-yes - Versions diffs - 1.194.0 → 1.196.0 - Mend

agent-yes 1.194.0 → 1.196.0

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 (24) hide show

package/dist/SUPPORTED_CLIS-Ca2ffDRy.js +8 -0
package/dist/{SUPPORTED_CLIS--WH2XfM2.js → SUPPORTED_CLIS-CxLCQtAU.js} +2 -2
package/dist/{agentShare-BEXN8bNT.js → agentShare-Bi95Xy0S.js} +2 -2
package/dist/cli.js +4 -4
package/dist/index.js +2 -2
package/dist/{notifyDaemon-Deisyrbn.js → notifyDaemon-BdOeFIVl.js} +2 -2
package/dist/{rustBinary-cTIMKGQp.js → rustBinary-D_ifX2Vd.js} +2 -2
package/dist/{schedule-MQZjDaY6.js → schedule-rvMgc0tA.js} +4 -4
package/dist/{serve-hA23xPpg.js → serve-D0-LoTfw.js} +43 -13
package/dist/{setup-C6grPf1R.js → setup-BC1VjTOf.js} +2 -2
package/dist/subcommands-Cz8xpc5X.js +9 -0
package/dist/{subcommands-Ba0V9EEH.js → subcommands-s74ViJcI.js} +305 -12
package/dist/{ts-6JcbtJh1.js → ts-CP17kUI1.js} +2 -2
package/dist/{versionChecker-DDNKcQRx.js → versionChecker-DTssk7cU.js} +2 -2
package/lab/ui/index.html +292 -2
package/lab/ui/room-client.js +544 -388
package/lab/ui/sw.js +71 -19
package/package.json +1 -1
package/ts/messageLog.spec.ts +145 -0
package/ts/messageLog.ts +147 -0
package/ts/serve.ts +55 -8
package/ts/subcommands.ts +270 -5
package/dist/SUPPORTED_CLIS-NfXUfiWY.js +0 -8
package/dist/subcommands-LP1Z8g-h.js +0 -9

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.194.0",
+  "version": "1.196.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",

package/ts/messageLog.spec.ts ADDED Viewed

@@ -0,0 +1,145 @@
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { mkdtemp, readFile, rm } from "fs/promises";
+import { tmpdir } from "os";
+import path from "path";
+import {
+  mailboxPath,
+  partyMatches,
+  readMailbox,
+  recordInbox,
+  recordMessage,
+  recordOutbox,
+  type MessageRecord,
+} from "./messageLog.ts";
+function makeRecord(over: Partial<MessageRecord> = {}): MessageRecord {
+  return {
+    at: 1_000,
+    nonce: "abcd",
+    from: { pid: 11, cli: "claude", cwd: "/from", agent_id: "agent-A" },
+    to: { pid: 22, cli: "codex", cwd: "/to", agent_id: "agent-B" },
+    body: "hello",
+    confirmed: true,
+    wrapped: true,
+    ...over,
+  };
+}
+describe("messageLog", () => {
+  let dir: string;
+  let prevCwd: string;
+  beforeEach(async () => {
+    dir = await mkdtemp(path.join(tmpdir(), "msglog-"));
+    prevCwd = process.cwd();
+  });
+  afterEach(async () => {
+    process.chdir(prevCwd);
+    await rm(dir, { recursive: true, force: true });
+  });
+  it("mailboxPath colocates under <cwd>/.agent-yes", () => {
+    expect(mailboxPath("/x", "inbox")).toBe(path.join("/x", ".agent-yes", "inbox.jsonl"));
+    expect(mailboxPath("/x", "outbox")).toBe(path.join("/x", ".agent-yes", "outbox.jsonl"));
+  });
+  it("records to sender outbox and recipient inbox", async () => {
+    const from = path.join(dir, "sender");
+    const to = path.join(dir, "recipient");
+    const rec = makeRecord({
+      from: { pid: 11, cli: "claude", cwd: from, agent_id: "A" },
+      to: { pid: 22, cli: "codex", cwd: to, agent_id: "B" },
+    });
+    await recordMessage(rec);
+    const outbox = await readMailbox(from, "outbox");
+    const inbox = await readMailbox(to, "inbox");
+    expect(outbox).toHaveLength(1);
+    expect(inbox).toHaveLength(1);
+    expect(outbox[0]!.body).toBe("hello");
+    expect(inbox[0]!.to.agent_id).toBe("B");
+    // The sender's inbox and recipient's outbox stay empty.
+    expect(await readMailbox(from, "inbox")).toHaveLength(0);
+    expect(await readMailbox(to, "outbox")).toHaveLength(0);
+  });
+  it("writes a human sender's outbox under process.cwd()", async () => {
+    process.chdir(dir);
+    const to = path.join(dir, "recipient");
+    await recordMessage(makeRecord({ from: null, to: { pid: 22, cli: "codex", cwd: to } }));
+    const outbox = await readMailbox(dir, "outbox");
+    expect(outbox).toHaveLength(1);
+    expect(outbox[0]!.from).toBeNull();
+  });
+  it("readMailbox skips corrupt lines and returns empty for a missing file", async () => {
+    expect(await readMailbox(dir, "inbox")).toEqual([]);
+    const from = path.join(dir, "s");
+    await recordMessage(makeRecord({ from: { pid: 1, cli: "c", cwd: from } }));
+    // Corrupt the file with a partial line; the good record still parses.
+    const p = mailboxPath(from, "outbox");
+    const raw = await readFile(p, "utf-8");
+    const { appendFile } = await import("fs/promises");
+    await appendFile(p, "{ not json\n");
+    expect(raw.trim().split("\n")).toHaveLength(1);
+    expect(await readMailbox(from, "outbox")).toHaveLength(1);
+  });
+  it("recordOutbox writes only the sender's outbox (remote peer's cwd untouched)", async () => {
+    const from = path.join(dir, "local");
+    const to = path.join(dir, "remote");
+    await recordOutbox(
+      makeRecord({
+        from: { pid: 1, cli: "claude", cwd: from, agent_id: "A" },
+        to: { pid: 2, cli: "codex", cwd: to, agent_id: "B" },
+        remote: "http://host:8080",
+        wrapped: false,
+      }),
+    );
+    expect(await readMailbox(from, "outbox")).toHaveLength(1);
+    // The remote peer's cwd is on another host — nothing is written there.
+    expect(await readMailbox(to, "inbox")).toHaveLength(0);
+    expect((await readMailbox(from, "outbox"))[0]!.remote).toBe("http://host:8080");
+  });
+  it("recordInbox writes only the recipient's inbox (remote sender's cwd untouched)", async () => {
+    const from = path.join(dir, "remote-sender");
+    const to = path.join(dir, "local-recipient");
+    await recordInbox(
+      makeRecord({
+        from: { pid: 1, cli: "claude", cwd: from, agent_id: "A" },
+        to: { pid: 2, cli: "codex", cwd: to, agent_id: "B" },
+        remote: "wire",
+        wrapped: false,
+      }),
+    );
+    expect(await readMailbox(to, "inbox")).toHaveLength(1);
+    expect(await readMailbox(from, "outbox")).toHaveLength(0);
+  });
+  it("preserves the kind tag for key/select events", async () => {
+    const from = path.join(dir, "kfrom");
+    const to = path.join(dir, "kto");
+    await recordMessage(
+      makeRecord({
+        from: { pid: 1, cli: "bash", cwd: from, agent_id: "A" },
+        to: { pid: 2, cli: "bash", cwd: to, agent_id: "B" },
+        kind: "key",
+        body: "down down enter",
+        wrapped: false,
+      }),
+    );
+    const rec = (await readMailbox(to, "inbox"))[0]!;
+    expect(rec.kind).toBe("key");
+    expect(rec.body).toBe("down down enter");
+  });
+  it("partyMatches prefers agent_id, falls back to pid", () => {
+    const party = { pid: 5, cli: "c", cwd: "/x", agent_id: "stable" };
+    expect(partyMatches(party, "stable", 999)).toBe(true); // agent_id wins across pid churn
+    expect(partyMatches(party, "other", 5)).toBe(true); // pid fallback
+    expect(partyMatches(party, "other", 6)).toBe(false);
+    expect(partyMatches(null, "stable", 5)).toBe(false);
+  });
+});

package/ts/messageLog.ts ADDED Viewed

@@ -0,0 +1,147 @@
+/**
+ * Durable inter-agent message log.
+ *
+ * Every `ay send` that carries a real body is recorded twice — from the two
+ * ends' points of view — as append-only JSONL colocated with each agent's
+ * project dir (the same `<cwd>/.agent-yes/` convention the session logs use):
+ *
+ *   - the SENDER's   `<from.cwd>/.agent-yes/outbox.jsonl`
+ *   - the RECIPIENT's `<to.cwd>/.agent-yes/inbox.jsonl`
+ *
+ * A single cwd may host several agents, so records carry the stable `agent_id`
+ * (falling back to `pid`) of each end; `ay msgs` filters a mailbox down to one
+ * agent by that key. Reading needs no lock (last line wins isn't relevant — a
+ * message log keeps every entry); writing is best-effort and never blocks or
+ * fails a send.
+ */
+import { appendFile, mkdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+import { logger } from "./logger.ts";
+/** One end of a message: enough to attribute and to route a reply. */
+export interface MailParty {
+  pid: number;
+  cli: string;
+  cwd: string;
+  agent_id?: string | null;
+}
+/** A single delivered inter-agent message, stored verbatim in both mailboxes. */
+export interface MessageRecord {
+  /** Epoch ms the send was recorded. */
+  at: number;
+  /** The per-send nonce from the `[ay-msg …]` wrapper, when the body was wrapped. */
+  nonce?: string;
+  /** Sender; `null` when an interactive human shell sent it (no agent context). */
+  from: MailParty | null;
+  /** Recipient agent. */
+  to: MailParty;
+  /** What kind of stdin write this was. Omitted for a normal `ay send` text
+   * message; "key" for raw keystrokes (`ay key`), "select" for a menu pick
+   * (`ay select`). For key/select the `body` holds the key names / choice. */
+  kind?: "key" | "select";
+  /** The message body (without the `[ay-msg …]` wrapper), or — for a key/select
+   * record — the keystroke names / chosen option. */
+  body: string;
+  /** Trailing control code name (e.g. "enter", "ctrl-c") when not a plain submit. */
+  code?: string;
+  /** Whether `ay send` confirmed the CLI acted on it. */
+  confirmed?: boolean;
+  /** Whether the body was wrapped in an `[ay-msg …]` attribution block. */
+  wrapped: boolean;
+  /** The remote url/alias when this message crossed the wire (`ay send <remote>:<kw>`);
+   * absent for a same-host send. The two ends record their own mailbox on their
+   * own machine, so this marks that the peer's cwd is on another host. */
+  remote?: string;
+}
+/** Keep at most this many lines per mailbox; older entries are compacted away. */
+const MAILBOX_MAX_LINES = 2000;
+export type Mailbox = "inbox" | "outbox";
+/** Path to a cwd's mailbox file (`<cwd>/.agent-yes/{inbox,outbox}.jsonl`). */
+export function mailboxPath(cwd: string, box: Mailbox): string {
+  return path.join(cwd, ".agent-yes", `${box}.jsonl`);
+}
+/** Whether a mail party is the agent identified by (agentId, pid). Prefers the
+ * stable agent_id (survives restart); falls back to pid for legacy records. */
+export function partyMatches(
+  party: MailParty | null,
+  agentId: string | null | undefined,
+  pid: number | null | undefined,
+): boolean {
+  if (!party) return false;
+  if (agentId && party.agent_id && party.agent_id === agentId) return true;
+  if (typeof pid === "number" && party.pid === pid) return true;
+  return false;
+}
+async function appendCapped(filePath: string, record: MessageRecord): Promise<void> {
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await appendFile(filePath, JSON.stringify(record) + "\n");
+  // Opportunistic compaction: keep the file bounded despite append-only writes.
+  const raw = await readFile(filePath, "utf-8").catch(() => "");
+  const lines = raw.split("\n").filter((l) => l.trim());
+  if (lines.length > MAILBOX_MAX_LINES) {
+    const kept = lines.slice(lines.length - MAILBOX_MAX_LINES).join("\n");
+    await writeFile(filePath, kept + "\n");
+  }
+}
+/**
+ * Record the SENDER's view in its outbox. Best-effort — a filesystem error is
+ * logged and swallowed so persistence never breaks a send. The outbox lives
+ * under `from.cwd`; a human sender (from === null) writes under `process.cwd()`.
+ */
+export async function recordOutbox(record: MessageRecord): Promise<void> {
+  const outCwd = record.from?.cwd ?? process.cwd();
+  try {
+    await appendCapped(mailboxPath(outCwd, "outbox"), record);
+  } catch (err) {
+    logger.debug(`[messageLog] outbox append failed: ${err}`);
+  }
+}
+/** Record the RECIPIENT's view in its inbox (under `to.cwd`). Best-effort. */
+export async function recordInbox(record: MessageRecord): Promise<void> {
+  try {
+    await appendCapped(mailboxPath(record.to.cwd, "inbox"), record);
+  } catch (err) {
+    logger.debug(`[messageLog] inbox append failed: ${err}`);
+  }
+}
+/**
+ * Record a same-host message in both mailboxes — the sender's outbox and the
+ * recipient's inbox both live on this machine. For a message that crossed the
+ * wire, each end calls `recordOutbox`/`recordInbox` on its own host instead.
+ */
+export async function recordMessage(record: MessageRecord): Promise<void> {
+  await recordOutbox(record);
+  await recordInbox(record);
+}
+/** Read and parse a cwd's mailbox, oldest first. Missing/corrupt lines skipped. */
+export async function readMailbox(cwd: string, box: Mailbox): Promise<MessageRecord[]> {
+  let raw: string;
+  try {
+    raw = await readFile(mailboxPath(cwd, box), "utf-8");
+  } catch {
+    return [];
+  }
+  const out: MessageRecord[] = [];
+  for (const line of raw.split("\n")) {
+    const t = line.trim();
+    if (!t) continue;
+    try {
+      const rec = JSON.parse(t) as MessageRecord;
+      if (rec && typeof rec.at === "number" && rec.to) out.push(rec);
+    } catch {
+      /* skip corrupt/partial line */
+    }
+  }
+  return out;
+}

package/ts/serve.ts CHANGED Viewed

@@ -16,6 +16,7 @@ import {
   listRecords,
   readNotes,
   readPtysize,
+  recentMessageEdges,
   recentReadEdges,
   renderLogTailLines,
   renderRawLog,
@@ -26,6 +27,7 @@ import {
 } from "./subcommands.ts";
 import { TYPING_BADGE } from "./badges.ts";
 import { ensureNodeRuntime, liveEnv } from "./nodeRuntime.ts";
+import { type MailParty, recordInbox } from "./messageLog.ts";
 import { updateGlobalPidStatus } from "./globalPidIndex.ts";
 import { spawnRejectionReason } from "./spawnGate.ts";
 import { findSpawnHiddenLauncher } from "./rustBinary.ts";
@@ -1723,12 +1725,16 @@ export async function cmdServe(rest: string[]): Promise<number> {
       });
     }
-    // GET /api/edges — recent inter-agent relationship edges for the /rgui wire
-    // view. Currently the read/tail edges (agent `by` read agent `target` within
-    // the last minute, from ~/.agent-yes/reads.jsonl). Directional, ephemeral.
+    // GET /api/edges — recent inter-agent relationship edges for the /rgui + /w
+    // wire view. Two directional, ephemeral edge sets:
+    //   reads — agent `by` read/tailed agent `target` (from ~/.agent-yes/reads.jsonl)
+    //   sends — agent `by` sent `target` a message/key/select (from the per-cwd
+    //           outbox logs); carries the send `kind` so the UI can style it.
+    // Both are last-minute windows the client fades out by `at`.
     if (req.method === "GET" && p === "/api/edges") {
       try {
-        return Response.json({ reads: await recentReadEdges() });
+        const [reads, sends] = await Promise.all([recentReadEdges(), recentMessageEdges()]);
+        return Response.json({ reads, sends });
       } catch (e) {
         return new Response((e as Error).message, { status: 500 });
       }
@@ -2199,15 +2205,20 @@ export async function cmdServe(rest: string[]): Promise<number> {
       }
     }
-    // POST /api/send  body: {keyword, msg, code?}
+    // POST /api/send  body: {keyword, msg, code?, from?}
     if (req.method === "POST" && p === "/api/send") {
-      let body: { keyword: string; msg: string; code?: string };
+      let body: {
+        keyword: string;
+        msg: string;
+        code?: string;
+        from?: MailParty | null;
+      };
       try {
         body = (await req.json()) as typeof body;
       } catch {
         return new Response("invalid JSON body", { status: 400 });
       }
-      const { keyword, msg = "", code = "enter" } = body;
+      const { keyword, msg = "", code = "enter", from = null } = body;
       if (!keyword || typeof keyword !== "string") {
         return new Response("missing keyword", { status: 400 });
       }
@@ -2228,7 +2239,43 @@ export async function cmdServe(rest: string[]): Promise<number> {
         // over this same wire) is protocol noise, not input — stamp anyDaemonWriteAt
         // but not the "meaningful" time, so a resize/redraw can't trip the flash.
         await noteStdinWrite(record.pid, record.fifo_file, !isTerminalReply(msg));
-        return Response.json({ ok: true, pid: record.pid });
+        // Record the recipient's inbox on THIS host (the sender records its own
+        // outbox on its host). The sender crossed the wire, so `from.cwd` names a
+        // path on another machine — mark it remote so the peer's cwd isn't misread
+        // as local. Only real message bodies are logged. Best-effort.
+        if (msg) {
+          const senderParty: MailParty | null =
+            from && typeof from === "object" && typeof from.pid === "number"
+              ? {
+                  pid: from.pid,
+                  cli: String(from.cli ?? "?"),
+                  cwd: String(from.cwd ?? ""),
+                  agent_id: from.agent_id ?? undefined,
+                }
+              : null;
+          await recordInbox({
+            at: Date.now(),
+            from: senderParty,
+            to: {
+              pid: record.pid,
+              cli: record.cli,
+              cwd: record.cwd,
+              agent_id: record.agent_id,
+            },
+            body: msg,
+            code: code.toLowerCase() === "enter" ? undefined : code.toLowerCase(),
+            confirmed: true,
+            wrapped: false,
+            remote: senderParty ? "wire" : undefined,
+          });
+        }
+        return Response.json({
+          ok: true,
+          pid: record.pid,
+          cli: record.cli,
+          cwd: record.cwd,
+          agentId: record.agent_id ?? undefined,
+        });
       } catch (e) {
         return new Response((e as Error).message, { status: 404 });
       }