agent-yes 1.231.0 → 1.232.0

package/ts/channels/store.ts

@@ -0,0 +1,170 @@
+// The channel CRDT — pure, isomorphic (Node + browser), storage-agnostic.
+//
+// A channel is a grow-only set of immutable ops (op.ts) keyed by `id`. Because
+// ids are content-independent-but-unique and the set only grows, MERGE is a
+// union and always converges: any two replicas that have exchanged the same ops
+// hold the same set regardless of arrival order (commutative, associative,
+// idempotent). Display order is the total order over `hlc`.
+//
+// Amendments (edit/delete/reaction) are folded per target message as
+// last-writer-wins by HLC, so the rendered thread is likewise a pure function of
+// the op set — every replica renders identically.
+//
+// This module never touches disk or network; backends (store.node.ts,
+// store.browser.ts) provide the ops, and peer.ts moves them between replicas.
+
+import { compareHlc, parseHlc } from "./hlc.ts";
+import type { Op, Role } from "./op.ts";
+
+/** Order ops by HLC (then id, for a fully deterministic tie-break). */
+export function sortOps(ops: Op[]): Op[] {
+  return [...ops].sort(
+    (a, b) => compareHlc(a.hlc, b.hlc) || (a.id < b.id ? -1 : a.id > b.id ? 1 : 0),
+  );
+}
+
+/**
+ * Union `incoming` into `existing`, deduping by id. Returns the merged set
+ * (sorted) and the ops that were actually new — the backend appends `added`, and
+ * peer.ts rebroadcasts them. Idempotent: merging the same ops twice adds nothing.
+ */
+export function mergeOps(existing: Op[], incoming: Op[]): { merged: Op[]; added: Op[] } {
+  const byId = new Map<string, Op>();
+  for (const op of existing) byId.set(op.id, op);
+  const added: Op[] = [];
+  for (const op of incoming) {
+    if (byId.has(op.id)) continue;
+    byId.set(op.id, op);
+    added.push(op);
+  }
+  return { merged: sortOps([...byId.values()]), added };
+}
+
+/** The greatest HLC in the set (used to seed the next local send), or null if empty. */
+export function maxHlc(ops: Op[]): string | null {
+  let max: string | null = null;
+  for (const op of ops) if (max === null || compareHlc(op.hlc, max) > 0) max = op.hlc;
+  return max;
+}
+
+// --- rendered thread --------------------------------------------------------
+
+export interface Reaction {
+  /** The emoji/label. */
+  emoji: string;
+  /** Distinct author ids that reacted with it. */
+  by: string[];
+}
+
+/** A message as shown in the UI: a base `msg` op with amendments folded in. */
+export interface Message {
+  id: string;
+  author: string;
+  name: string;
+  role: Role;
+  /** Base op HLC — the thread sort key. */
+  hlc: string;
+  /** Current text (after the latest edit); empty when deleted. */
+  text: string;
+  /** True if a delete op is the latest amendment. */
+  deleted: boolean;
+  /** HLC of the latest edit/delete applied, if any. */
+  amendedHlc?: string;
+  reactions: Reaction[];
+  ms: number;
+}
+
+/**
+ * Fold an op set into the ordered list of messages. Pure function of the ops:
+ * for each `msg` op, its `edit`/`delete` amendments are applied in HLC order
+ * (last wins — an edit after a delete revives it, a delete after an edit hides
+ * it), and `reaction` ops are grouped by emoji into distinct authors.
+ */
+export function renderThread(ops: Op[]): Message[] {
+  const sorted = sortOps(ops);
+  const messages = new Map<string, Message>();
+
+  for (const op of sorted) {
+    if (op.kind !== "msg") continue;
+    messages.set(op.id, {
+      id: op.id,
+      author: op.author,
+      name: op.name,
+      role: op.role,
+      hlc: op.hlc,
+      text: op.body ?? "",
+      deleted: false,
+      reactions: [],
+      ms: parseHlc(op.hlc).ms,
+    });
+  }
+
+  // reactions grouped as emoji -> ordered distinct authors, per target message
+  const reactions = new Map<string, Map<string, string[]>>();
+
+  for (const op of sorted) {
+    if (!op.ref) continue;
+    const target = messages.get(op.ref);
+    if (!target) continue; // amendment for an op we don't (yet) have — ignore
+    if (op.kind === "edit") {
+      // amendments always sort after the base (author is causal); LWW by HLC
+      if (compareHlc(op.hlc, target.amendedHlc ?? target.hlc) > 0) {
+        target.text = op.body ?? "";
+        target.deleted = false;
+        target.amendedHlc = op.hlc;
+      }
+    } else if (op.kind === "delete") {
+      if (compareHlc(op.hlc, target.amendedHlc ?? target.hlc) > 0) {
+        target.text = "";
+        target.deleted = true;
+        target.amendedHlc = op.hlc;
+      }
+    } else if (op.kind === "reaction" && op.body) {
+      let group = reactions.get(op.ref);
+      if (!group) reactions.set(op.ref, (group = new Map()));
+      const authors = group.get(op.body) ?? [];
+      if (!authors.includes(op.author)) authors.push(op.author);
+      group.set(op.body, authors);
+    }
+  }
+
+  for (const [msgId, group] of reactions) {
+    const target = messages.get(msgId);
+    if (!target) continue;
+    target.reactions = [...group.entries()].map(([emoji, by]) => ({ emoji, by }));
+  }
+
+  return [...messages.values()].sort((a, b) => compareHlc(a.hlc, b.hlc));
+}
+
+// --- anti-entropy sync ------------------------------------------------------
+//
+// On each new peer connection the two sides exchange a compact per-author
+// summary of what they hold, then each sends the ops the other lacks. This is
+// why an intermittent / partial mesh still converges: a peer that was offline
+// receives the suffix it missed on reconnect.
+
+/** Per-author greatest HLC held — the compact "have" summary sent to a peer. */
+export function haveVector(ops: Op[]): Record<string, string> {
+  const have: Record<string, string> = {};
+  for (const op of ops) {
+    const cur = have[op.author];
+    if (cur === undefined || compareHlc(op.hlc, cur) > 0) have[op.author] = op.hlc;
+  }
+  return have;
+}
+
+/**
+ * The ops in `local` that a peer with summary `remoteHave` is missing: any op
+ * from an author the peer hasn't heard from, or newer than the peer's max for
+ * that author. Relies on an author's ops forming a contiguous HLC suffix on each
+ * replica (sync always transfers whole suffixes), which holds under this protocol.
+ */
+export function opsMissing(local: Op[], remoteHave: Record<string, string>): Op[] {
+  return sortOps(
+    local.filter((op) => {
+      const peerMax = remoteHave[op.author];
+      return peerMax === undefined || compareHlc(op.hlc, peerMax) > 0;
+    }),
+  );
+}

package/ts/channels.spec.ts

@@ -3,6 +3,7 @@ import os from "os";
 import path from "path";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import {
+  buildBookmarklet,
   cmdCh,
   defaultName,
   defaultRole,
@@ -145,6 +146,28 @@ describe("ay ch CLI (local-only)", () => {
     expect(linkResolved.entry).toBeNull();
   });
 
+  it("mk --topic derives the same channel for the same topic string", async () => {
+    await capture(() => cmdCh(["mk", "a", "--topic", "https://example.com/p"]));
+    await capture(() => cmdCh(["mk", "b", "--topic", "https://example.com/p"]));
+    await capture(() => cmdCh(["mk", "c", "--topic", "https://example.com/other"]));
+    const reg = await readRegistry(cwd);
+    // same topic → same underlying channel; different topic → different channel
+    expect(reg.channels.a!.channelId).toBe(reg.channels.b!.channelId);
+    expect(reg.channels.c!.channelId).not.toBe(reg.channels.a!.channelId);
+  });
+
+  it("bookmarklet prints a javascript: URL that loads the widget by page topic", async () => {
+    const out = (await capture(() => cmdCh(["bookmarklet"]))).out;
+    expect(out).toMatch(/^javascript:/);
+    expect(out).toContain("AyChannel.fromTopic");
+    expect(out).toContain("agent-yes.com/w/channels.js");
+    // custom host/sighost flow through
+    const bm = buildBookmarklet("beta.example.dev", "sig.example.dev");
+    expect(bm).toContain("beta.example.dev/w/channels.js");
+    expect(bm).toContain("sig.example.dev");
+    expect(bm).toContain("location.href"); // default topic = full page URL
+  });
+
   it("prints help for no subcommand and rejects unknown ones", async () => {
     expect((await capture(() => cmdCh([]))).out).toContain("ay ch -");
     const bad = await capture(() => cmdCh(["frobnicate"]));

package/ts/channels.ts

@@ -41,6 +41,7 @@ import {
   maxHlc,
   parseChannelLink,
   renderThread,
+  secretFromTopic,
   type Message,
   type Role,
 } from "./channels/index.ts";
@@ -196,15 +197,25 @@ async function cmdChMk(cwd: string, args: string[]): Promise<number> {
     name: "value",
     role: "value",
     salt: "value",
+    topic: "value",
   });
   const topic = positional[0];
   if (!topic || positional.length > 1)
-    throw new Error("usage: ay ch mk <topic> [--sighost H] [--name N] [--role R] [--salt HEX]");
+    throw new Error(
+      "usage: ay ch mk <name> [--topic <string>] [--sighost H] [--name N] [--role R] [--salt HEX]",
+    );
   const reg = await readRegistry(cwd);
   if (reg.channels[topic])
     throw new Error(`channel "${topic}" already exists (ay ch rm ${topic} to replace)`);
 
-  const s = typeof flags.salt === "string" ? flags.salt : randomBytes(32).toString("hex");
+  // --topic derives a deterministic secret from a public string (e.g. a page URL)
+  // so this peer lands in the SAME channel a bookmarklet on that URL joins.
+  const s =
+    typeof flags.topic === "string"
+      ? await secretFromTopic(flags.topic)
+      : typeof flags.salt === "string"
+        ? flags.salt
+        : randomBytes(32).toString("hex");
   const [channelId, room] = await Promise.all([deriveChannelId(s), deriveRoom(s)]);
   const sighost = typeof flags.sighost === "string" ? flags.sighost : undefined;
   const entry: ChannelRegEntry = {
@@ -554,6 +565,38 @@ async function cmdChEmbed(cwd: string, args: string[]): Promise<number> {
   return 0;
 }
 
+/** The page bookmarklet: derive a channel from the page URL and mount the widget. */
+export function buildBookmarklet(host: string, sighost: string): string {
+  // One line, minimal, defensive: prompt for the topic (default = full URL incl.
+  // hash), remember the name, load the widget, and alert clearly if the page CSP
+  // blocks the cross-origin import (the expected failure on hardened sites).
+  return (
+    `javascript:(async()=>{try{` +
+    `const{AyChannel}=await import('https://${host}/w/channels.js');` +
+    `const t=prompt('ay channel — topic (same topic = same room):',location.href);if(!t)return;` +
+    `let n=localStorage.getItem('ay29ch-name');if(!n){n=prompt('Your name:','guest')||'guest';localStorage.setItem('ay29ch-name',n);}` +
+    `const ch=await AyChannel.fromTopic(t,{sighost:'${sighost}',name:n});` +
+    `ch.mount(document.body,{open:true});` +
+    `}catch(e){alert('ay channel could not load — this page\\'s CSP may block it (works on your own apps, localhost, blogs, docs).\\n'+(e&&e.message||e));}})()`
+  );
+}
+
+async function cmdChBookmarklet(_cwd: string, args: string[]): Promise<number> {
+  const { flags, positional } = parseFlags(args, { host: "value", sighost: "value" });
+  if (positional.length) throw new Error("usage: ay ch bookmarklet [--host H] [--sighost H]");
+  const host = typeof flags.host === "string" ? flags.host : "agent-yes.com";
+  const sighost = typeof flags.sighost === "string" ? flags.sighost : "s.agent-yes.com";
+  process.stdout.write(buildBookmarklet(host, sighost) + "\n");
+  process.stderr.write(
+    `\n  Make a new bookmark and paste the line above as its URL. Click it on any\n` +
+      `  page to drop an ay-channel chat window joined to that page's URL (edit the\n` +
+      `  prompt to change the topic). Same topic = same room, no invite needed.\n` +
+      `  Heads-up: strict site CSP (GitHub/Google/…) blocks it; it works on your own\n` +
+      `  apps, localhost, blogs, and docs.\n`,
+  );
+  return 0;
+}
+
 function chHelp(): number {
   process.stdout.write(
     `ay ch - local-first E2E channels for AI ↔ humans (per-cwd, no server storage)\n` +
@@ -569,7 +612,10 @@ function chHelp(): number {
       `  ay ch sync <topic> [--quiet]             hold the WebRTC mesh: live send/receive (Ctrl-C to stop)\n` +
       `  ay ch pipe <topic>                       sync + bridge stdin→send and inbound→stdout\n` +
       `  ay ch embed <topic> [--host H]           print an HTML snippet embedding a floating chat widget\n` +
+      `  ay ch bookmarklet [--host H]             print a bookmarklet: any page joins a channel by its URL\n` +
       `\n` +
+      `  URL-topic: 'ay ch mk <name> --topic <string>' derives the SAME channel a\n` +
+      `             bookmarklet on that URL joins (topic = public membership)\n` +
       `  identity: --name defaults to $AY_CH_NAME/OS user; --role to agent (in an agent) or human\n` +
       `  storage:  <cwd>/.agent-yes/ch-<id>.jsonl  (a full CRDT replica; cwd-scoped)\n` +
       `  live:     run 'ay ch sync <topic>' (foreground/backgrounded) to join the mesh; then\n` +
@@ -610,6 +656,8 @@ export async function cmdCh(args: string[]): Promise<number> {
       return cmdChPipe(cwd, rest);
     case "embed":
       return cmdChEmbed(cwd, rest);
+    case "bookmarklet":
+      return cmdChBookmarklet(cwd, rest);
     case undefined:
     case "help":
     case "--help":