agent-yes 1.193.0 → 1.195.0

package/ts/messageLog.spec.ts

@@ -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

@@ -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

@@ -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 });
       }
@@ -2887,6 +2934,11 @@ export async function cmdServe(rest: string[]): Promise<number> {
       return serveUiFile("e2e.js", "text/javascript; charset=utf-8");
     if (req.method === "GET" && p === "/qrcode.js")
       return serveUiFile("qrcode.js", "text/javascript; charset=utf-8");
+    // The PWA / preview Service Worker. Without it, --http never registers a SW
+    // (so the in-console P2P preview can't proxy). Served at the console root so
+    // its scope covers /p/<src>/<port>/*.
+    if (req.method === "GET" && p === "/sw.js")
+      return serveUiFile("sw.js", "text/javascript; charset=utf-8");
     if (req.method === "GET" && p === "/manifest.webmanifest")
       return serveUiFile("manifest.webmanifest", "application/manifest+json");
     if (req.method === "GET" && p === "/icon.svg")