agent-yes 1.230.0 → 1.231.0-beta.561.1

package/dist/{SUPPORTED_CLIS-Bzr_YYLu.js → SUPPORTED_CLIS-BjVtNw1b.js}

@@ -1,8 +1,8 @@
-import { t as CLIS_CONFIG } from "./ts-Cl1DluDM.js";
+import { t as CLIS_CONFIG } from "./ts-B8eWE6oN.js";
 
 //#region ts/SUPPORTED_CLIS.ts
 const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { SUPPORTED_CLIS as t };
-//# sourceMappingURL=SUPPORTED_CLIS-Bzr_YYLu.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-BjVtNw1b.js.map

package/dist/{SUPPORTED_CLIS-NP2basqU.js → SUPPORTED_CLIS-DxzlLYfn.js}

@@ -1,11 +1,11 @@
-import "./ts-Cl1DluDM.js";
+import "./ts-B8eWE6oN.js";
 import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-qZA8b3cE.js";
+import "./versionChecker-DteYJH7s.js";
 import "./todoAutomation-x6guaQXc.js";
 import "./JsonlStore-CWOA3aDH.js";
 import "./globalPidIndex-Ca4sTr1b.js";
 import "./pidStore-Hjba3K6Q.js";
 import "./messageLog-zVGWLX7w.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-Bzr_YYLu.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-BjVtNw1b.js";
 
 export { SUPPORTED_CLIS };

package/dist/{agent-yes.config-0G11aPWe.js → agent-yes.config-BhjzWavn.js}

@@ -1,5 +1,5 @@
 import { n as logger } from "./logger-CDIsZ-Pp.js";
-import { n as normalizeAgentYesConfig, t as loadSharedCliDefaults } from "./configShared-YKfS6NMe.js";
+import { n as normalizeAgentYesConfig, t as loadSharedCliDefaults } from "./configShared-BXz2vi4Q.js";
 import os from "node:os";
 import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
@@ -226,4 +226,4 @@ async function getDefaultConfig() {
 
 //#endregion
 export { agent_yes_config_default as default };
-//# sourceMappingURL=agent-yes.config-0G11aPWe.js.map
+//# sourceMappingURL=agent-yes.config-BhjzWavn.js.map

package/dist/{agentShare-BgzKKAFp.js → agentShare-D0eaibsl.js}

@@ -1,12 +1,12 @@
 import "./logger-CDIsZ-Pp.js";
 import "./globalPidIndex-Ca4sTr1b.js";
 import "./messageLog-zVGWLX7w.js";
-import "./configShared-YKfS6NMe.js";
-import { N as resolveOne } from "./subcommands-BPFUbAqp.js";
-import "./e2e-DB7BDdEA.js";
-import "./webrtcLink-CjckgIZe.js";
-import "./remotes-ZqD0FHl_.js";
-import { r as startShare } from "./share-CrvxZO7o.js";
+import "./e2e-CYlKpfxa.js";
+import "./configShared-BXz2vi4Q.js";
+import { N as resolveOne } from "./subcommands--OoWVuAI.js";
+import "./webrtcLink-CEYNs0pt.js";
+import "./remotes-BM3Zm8Wh.js";
+import { a as startShare } from "./share-D4K0JnHg.js";
 
 //#region ts/agentShare.ts
 const MAX_SHARES = 8;
@@ -229,4 +229,4 @@ function transformEvent(rawEvent, agentId, forwarded) {
 
 //#endregion
 export { createScopedShare, listShares, revokeAllShares, revokeShare };
-//# sourceMappingURL=agentShare-BgzKKAFp.js.map
+//# sourceMappingURL=agentShare-D0eaibsl.js.map

package/dist/{callback-CPEbx_V0.js → callback-15YcBPKg.js}

@@ -1,6 +1,6 @@
 import { t as agentYesHome } from "./agentYesHome-CtHb5b71.js";
-import { N as resolveOne } from "./subcommands-BPFUbAqp.js";
-import { a as mintCapability, o as parseExpires } from "./callbackCore-BlNdDILy.js";
+import { N as resolveOne } from "./subcommands--OoWVuAI.js";
+import { a as mintCapability, o as parseExpires } from "./callbackCore-Me97qn68.js";
 import { randomBytes } from "node:crypto";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
@@ -72,7 +72,7 @@ async function resolveBase(flag) {
 	if (flag) return flag;
 	if (process.env.AGENT_YES_CALLBACK_BASE) return process.env.AGENT_YES_CALLBACK_BASE;
 	try {
-		const { resolveLocalServeUrl } = await import("./serve-TPasyukD.js");
+		const { resolveLocalServeUrl } = await import("./serve-GhS1eaFx.js");
 		const url = await resolveLocalServeUrl();
 		if (url) return url;
 	} catch {}
@@ -170,7 +170,7 @@ async function cmdCallback(rest) {
 		createdAt: Date.now()
 	};
 	saveStore(all);
-	const { buildSnippet } = await import("./callbackCore-B3DNe_SP.js");
+	const { buildSnippet } = await import("./callbackCore-CcbVa8r2.js");
 	w(`callback ${id} → ${record.cli} #${record.pid} @ ${record.cwd}`);
 	w(`expires:  ${new Date(exp).toISOString()}  (${expiresSpec})`);
 	w(`endpoint: ${base.replace(/\/+$/, "")}/cb/${cap}`);
@@ -187,4 +187,4 @@ async function cmdCallback(rest) {
 
 //#endregion
 export { loadOrCreateCallbackSecret as i, isCallbackRevoked as n, loadCallbackSecretReadOnly as r, cmdCallback as t };
-//# sourceMappingURL=callback-CPEbx_V0.js.map
+//# sourceMappingURL=callback-15YcBPKg.js.map

package/dist/callback-BaJEHrei.js

@@ -0,0 +1,12 @@
+import "./logger-CDIsZ-Pp.js";
+import "./globalPidIndex-Ca4sTr1b.js";
+import "./messageLog-zVGWLX7w.js";
+import "./e2e-CYlKpfxa.js";
+import "./configShared-BXz2vi4Q.js";
+import "./subcommands--OoWVuAI.js";
+import "./webrtcLink-CEYNs0pt.js";
+import "./remotes-BM3Zm8Wh.js";
+import "./callbackCore-Me97qn68.js";
+import { i as loadOrCreateCallbackSecret, n as isCallbackRevoked, r as loadCallbackSecretReadOnly, t as cmdCallback } from "./callback-15YcBPKg.js";
+
+export { cmdCallback };

package/dist/{callbackCore-B3DNe_SP.js → callbackCore-CcbVa8r2.js}

@@ -1,3 +1,3 @@
-import { a as mintCapability, i as frameVisitorMessage, n as MAX_EXPIRES_MS, o as parseExpires, r as buildSnippet, s as verifyCapability, t as MAX_CALLBACK_MSG_BYTES } from "./callbackCore-BlNdDILy.js";
+import { a as mintCapability, i as frameVisitorMessage, n as MAX_EXPIRES_MS, o as parseExpires, r as buildSnippet, s as verifyCapability, t as MAX_CALLBACK_MSG_BYTES } from "./callbackCore-Me97qn68.js";
 
 export { buildSnippet };

package/dist/{callbackCore-BlNdDILy.js → callbackCore-Me97qn68.js}

@@ -140,4 +140,4 @@ function buildSnippet(opts) {
 
 //#endregion
 export { mintCapability as a, frameVisitorMessage as i, MAX_EXPIRES_MS as n, parseExpires as o, buildSnippet as r, verifyCapability as s, MAX_CALLBACK_MSG_BYTES as t };
-//# sourceMappingURL=callbackCore-BlNdDILy.js.map
+//# sourceMappingURL=callbackCore-Me97qn68.js.map

package/dist/channels-Boi4aNiY.js

@@ -0,0 +1,540 @@
+import "./e2e-CYlKpfxa.js";
+import { a as formatChannelWebLink, c as secretFromTopic, i as formatChannelLink, n as deriveChannelId, o as isChannelLink, r as deriveRoom, s as parseChannelLink } from "./channels-Bu4DZzHk.js";
+import { a as renderThread, c as makeOp, f as hlcSend, n as maxHlc, o as sortOps, r as mergeOps, s as isValidOp } from "./store-Ba3SsoOx.js";
+import { appendFile, chmod, mkdir, readFile, rm, writeFile } from "fs/promises";
+import os from "os";
+import path from "path";
+import { randomBytes } from "crypto";
+
+//#region ts/channels/store.node.ts
+/** Rewrite (dedup + sort) once the file grows past this many raw lines. */
+const COMPACT_AT_LINES = 4e3;
+/** Path to a channel's jsonl replica under a project cwd. */
+function channelFilePath(cwd, channelId) {
+	return path.join(cwd, ".agent-yes", `ch-${channelId}.jsonl`);
+}
+/** Read + parse a channel's ops, deduped and HLC-sorted. Missing file → []. */
+async function readOps(cwd, channelId) {
+	let raw;
+	try {
+		raw = await readFile(channelFilePath(cwd, channelId), "utf-8");
+	} catch {
+		return [];
+	}
+	const byId = /* @__PURE__ */ new Map();
+	for (const line of raw.split("\n")) {
+		const t = line.trim();
+		if (!t) continue;
+		try {
+			const op = JSON.parse(t);
+			if (isValidOp(op) && !byId.has(op.id)) byId.set(op.id, op);
+		} catch {}
+	}
+	return sortOps([...byId.values()]);
+}
+/**
+* Append `incoming` to a channel, deduping against what's already stored.
+* Returns the ops that were genuinely new (so the daemon can rebroadcast just
+* those). Opportunistically compacts when the file accumulates duplicate lines
+* or grows large, keeping it bounded despite append-only writes.
+*/
+async function appendOps(cwd, channelId, incoming) {
+	const valid = incoming.filter(isValidOp);
+	if (valid.length === 0) return [];
+	const file = channelFilePath(cwd, channelId);
+	await mkdir(path.dirname(file), { recursive: true });
+	const existing = await readOps(cwd, channelId);
+	const { added } = mergeOps(existing, valid);
+	if (added.length === 0) return [];
+	await appendFile(file, added.map((op) => JSON.stringify(op)).join("\n") + "\n");
+	if (existing.length + valid.length > COMPACT_AT_LINES) await writeFile(file, sortOps([...existing, ...added]).map((op) => JSON.stringify(op)).join("\n") + "\n");
+	return added;
+}
+
+//#endregion
+//#region ts/channels.ts
+/**
+* `ay ch` — channels: local-first, end-to-end threads where AI agents and humans
+* talk on a topic. No server ever stores a message; every participant keeps a
+* full replica as an append-only CRDT log, cwd-scoped like the rest of
+* agent-yes's per-project state:
+*
+*   ay ch mk <topic> [--sighost H] [--name N] [--role agent|human] [--salt HEX]
+*   ay ch join <link> [--as <topic>] [--name N] [--role R]
+*   ay ch ls [--json]
+*   ay ch rm <topic>
+*   ay ch send <topic> <text…> [--name N] [--role R]
+*   ay ch read <topic> [-n N] [--json]
+*   ay ch head <topic> [-n N]
+*   ay ch tail <topic> [-n N] [-f]
+*   ay ch sync <topic> [--quiet]   — hold the WebRTC mesh (live send/receive)
+*   ay ch pipe <topic>             — sync + bridge stdin→send, inbound→stdout
+*
+* The read/write verbs are pure-local (they only touch the jsonl replica). Live
+* delivery is a separate `sync` peer that holds the WebRTC mesh, appends inbound
+* ops, and broadcasts newly-appeared local ops — so send/tail COMPOSE with a
+* running sync through the shared replica file, no IPC/daemon. The browser side
+* (Phase 3) joins the same mesh with its own peer, so agent↔human chat is truly
+* peer-to-peer with no central bridge.
+*
+* The channels core (ts/channels/) is isomorphic and reused verbatim by the
+* browser lib; this file is the Node CLI shell over it, mirroring ts/ws.ts.
+*/
+const REG_SCHEMA = "ay-ch/v1";
+/** An agent (AGENT_YES_PID set) defaults to role "agent"; a human shell to "human". */
+function defaultRole() {
+	return process.env.AGENT_YES_PID ? "agent" : "human";
+}
+/** Default display name: $AY_CH_NAME, else the OS username, else "anon". */
+function defaultName() {
+	if (process.env.AY_CH_NAME) return process.env.AY_CH_NAME;
+	try {
+		return os.userInfo().username || "anon";
+	} catch {
+		return "anon";
+	}
+}
+function validRole(v) {
+	if (v === "agent" || v === "human") return v;
+	throw new Error(`--role must be "agent" or "human"`);
+}
+function registryPath(cwd) {
+	return path.join(cwd, ".agent-yes", "channels.json");
+}
+async function readRegistry(cwd) {
+	try {
+		const reg = JSON.parse(await readFile(registryPath(cwd), "utf-8"));
+		if (reg && typeof reg === "object" && reg.channels) return reg;
+	} catch {}
+	return {
+		schema: REG_SCHEMA,
+		channels: {}
+	};
+}
+async function writeRegistry(cwd, reg) {
+	const file = registryPath(cwd);
+	await mkdir(path.dirname(file), { recursive: true });
+	await writeFile(file, JSON.stringify(reg, null, 2) + "\n");
+	await chmod(file, 384).catch(() => {});
+}
+/**
+* Resolve a `<topic|link>` operand. A registered topic yields its full entry; a
+* bare invite link yields just its channelId (read-only — sending needs an
+* identity, i.e. `ay ch join` first). Anything else is an error.
+*/
+async function resolveChannel(reg, arg) {
+	const entry = reg.channels[arg];
+	if (entry) return {
+		channelId: entry.channelId,
+		entry
+	};
+	if (isChannelLink(arg)) {
+		const link = parseChannelLink(arg);
+		if (link) return {
+			channelId: await deriveChannelId(link.s),
+			entry: null
+		};
+	}
+	throw new Error(`no channel "${arg}" — see 'ay ch ls', or 'ay ch join <link>'`);
+}
+/** One rendered thread line: `HH:MM:SS  name(a): text  👍2`. Pure, for tests. */
+function formatMessage(m) {
+	return `${new Date(m.ms).toISOString().slice(11, 19)}  ${`${m.name}(${m.role[0]})`}: ${m.deleted ? "(deleted)" : m.text}${m.reactions.length ? "  " + m.reactions.map((r) => `${r.emoji}${r.by.length > 1 ? r.by.length : ""}`).join(" ") : ""}`;
+}
+function parseFlags(args, known) {
+	const flags = {};
+	const positional = [];
+	for (let i = 0; i < args.length; i++) {
+		const a = args[i];
+		if (!a.startsWith("-") || a === "-") {
+			positional.push(a);
+			continue;
+		}
+		const isShortN = a === "-n";
+		const eq = a.indexOf("=");
+		const name = isShortN ? "limit" : eq === -1 ? a.replace(/^--?/, "") : a.slice(a.startsWith("--") ? 2 : 1, eq);
+		const kind = known[name];
+		if (!kind) throw new Error(`unknown flag ${a}`);
+		if (kind === "bool") {
+			if (eq !== -1) throw new Error(`--${name} takes no value`);
+			flags[name] = true;
+		} else {
+			const v = eq !== -1 ? a.slice(eq + 1) : args[++i];
+			if (v === void 0) throw new Error(`${a} requires a value`);
+			flags[name] = v;
+		}
+	}
+	return {
+		flags,
+		positional
+	};
+}
+function limitOf(flags) {
+	if (flags.limit === void 0) return void 0;
+	const n = Number(flags.limit);
+	if (!Number.isInteger(n) || n < 0) throw new Error(`-n/--limit must be a non-negative integer`);
+	return n;
+}
+async function cmdChMk(cwd, args) {
+	const { flags, positional } = parseFlags(args, {
+		sighost: "value",
+		name: "value",
+		role: "value",
+		salt: "value",
+		topic: "value"
+	});
+	const topic = positional[0];
+	if (!topic || positional.length > 1) 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.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 entry = {
+		topic,
+		channelId,
+		room,
+		sighost: (typeof flags.sighost === "string" ? flags.sighost : void 0) ?? "s.agent-yes.com",
+		s,
+		author: randomBytes(8).toString("hex"),
+		name: typeof flags.name === "string" ? flags.name : defaultName(),
+		role: flags.role ? validRole(flags.role) : defaultRole(),
+		createdAt: Date.now()
+	};
+	reg.channels[topic] = entry;
+	await writeRegistry(cwd, reg);
+	const link = formatChannelLink({
+		sighost: entry.sighost,
+		room,
+		s
+	});
+	process.stdout.write(`created channel "${topic}"  (${entry.name}, ${entry.role})\n  invite (CLI):     ${link}\n  invite (browser): ${formatChannelWebLink({
+		sighost: entry.sighost,
+		room,
+		s
+	})}\n\n  share the invite; others join with:  ay ch join '${link}'\n`);
+	return 0;
+}
+async function cmdChJoin(cwd, args) {
+	const { flags, positional } = parseFlags(args, {
+		as: "value",
+		name: "value",
+		role: "value"
+	});
+	const linkStr = positional[0];
+	if (!linkStr || positional.length > 1) throw new Error("usage: ay ch join <link> [--as <topic>] [--name N] [--role R]");
+	const link = parseChannelLink(linkStr);
+	if (!link) throw new Error(`not a channel invite link: ${linkStr}`);
+	const channelId = await deriveChannelId(link.s);
+	const topic = typeof flags.as === "string" ? flags.as : `ch-${link.room.slice(0, 10)}`;
+	const reg = await readRegistry(cwd);
+	const existing = reg.channels[topic];
+	if (existing && existing.channelId !== channelId) throw new Error(`topic "${topic}" is already bound to a different channel — pick another --as`);
+	const entry = existing ?? {
+		topic,
+		channelId,
+		room: link.room,
+		sighost: link.sighost,
+		s: link.s,
+		author: randomBytes(8).toString("hex"),
+		name: typeof flags.name === "string" ? flags.name : defaultName(),
+		role: flags.role ? validRole(flags.role) : defaultRole(),
+		createdAt: Date.now()
+	};
+	if (typeof flags.name === "string") entry.name = flags.name;
+	if (flags.role) entry.role = validRole(flags.role);
+	reg.channels[topic] = entry;
+	await writeRegistry(cwd, reg);
+	process.stdout.write(`joined channel "${topic}"  (${entry.name}, ${entry.role})\n`);
+	return 0;
+}
+async function cmdChLs(cwd, args) {
+	const { flags, positional } = parseFlags(args, { json: "bool" });
+	if (positional.length) throw new Error("ay ch ls takes no positional args");
+	const reg = await readRegistry(cwd);
+	const topics = Object.keys(reg.channels).sort();
+	const rows = await Promise.all(topics.map(async (topic) => {
+		const e = reg.channels[topic];
+		const msgs = renderThread(await readOps(cwd, e.channelId));
+		const last = msgs.length ? msgs[msgs.length - 1] : null;
+		return {
+			topic,
+			channelId: e.channelId,
+			name: e.name,
+			role: e.role,
+			messages: msgs.length,
+			lastMs: last ? last.ms : null
+		};
+	}));
+	if (flags.json) {
+		process.stdout.write(JSON.stringify({
+			schema: REG_SCHEMA,
+			channels: rows
+		}, null, 2) + "\n");
+		return 0;
+	}
+	if (rows.length === 0) {
+		process.stderr.write(`no channels in ${cwd} — 'ay ch mk <topic>' or 'ay ch join <link>'\n`);
+		return 0;
+	}
+	const w = Math.max(5, ...rows.map((r) => r.topic.length));
+	process.stdout.write(`${"TOPIC".padEnd(w)}  ${"MSGS".padStart(5)}  LAST\n`);
+	for (const r of rows) {
+		const last = r.lastMs ? new Date(r.lastMs).toISOString().slice(0, 19).replace("T", " ") : "-";
+		process.stdout.write(`${r.topic.padEnd(w)}  ${String(r.messages).padStart(5)}  ${last}\n`);
+	}
+	return 0;
+}
+async function cmdChRm(cwd, args) {
+	const { positional } = parseFlags(args, {});
+	const topic = positional[0];
+	if (!topic || positional.length > 1) throw new Error("usage: ay ch rm <topic>");
+	const reg = await readRegistry(cwd);
+	const entry = reg.channels[topic];
+	if (!entry) throw new Error(`no channel "${topic}"`);
+	delete reg.channels[topic];
+	await writeRegistry(cwd, reg);
+	await rm(channelFilePath(cwd, entry.channelId), { force: true });
+	process.stdout.write(`removed channel "${topic}" (local replica deleted; peers unaffected)\n`);
+	return 0;
+}
+async function cmdChSend(cwd, args) {
+	const { flags, positional } = parseFlags(args, {
+		name: "value",
+		role: "value"
+	});
+	const topic = positional[0];
+	const text = positional.slice(1).join(" ");
+	if (!topic || !text) throw new Error("usage: ay ch send <topic> <text…>");
+	const { channelId, entry } = await resolveChannel(await readRegistry(cwd), topic);
+	if (!entry) throw new Error(`join "${topic}" before sending: ay ch join <link>`);
+	const hlc = hlcSend(maxHlc(await readOps(cwd, channelId)), Date.now(), entry.author);
+	await appendOps(cwd, channelId, [makeOp({
+		author: entry.author,
+		name: typeof flags.name === "string" ? flags.name : entry.name,
+		role: flags.role ? validRole(flags.role) : entry.role,
+		hlc,
+		kind: "msg",
+		body: text
+	})]);
+	return 0;
+}
+async function readAndRender(cwd, channelId) {
+	return renderThread(await readOps(cwd, channelId));
+}
+async function cmdChRead(cwd, args, mode) {
+	const { flags, positional } = parseFlags(args, {
+		limit: "value",
+		json: "bool",
+		follow: "bool",
+		f: "bool"
+	});
+	const topic = positional[0];
+	if (!topic || positional.length > 1) throw new Error(`usage: ay ch ${mode} <topic> [-n N]`);
+	const { channelId } = await resolveChannel(await readRegistry(cwd), topic);
+	const n = limitOf(flags);
+	let msgs = await readAndRender(cwd, channelId);
+	if (mode === "head") msgs = msgs.slice(0, n ?? 10);
+	else if (mode === "tail") msgs = msgs.slice(-(n ?? 96));
+	else if (n !== void 0) msgs = msgs.slice(-n);
+	if (flags.json) process.stdout.write(JSON.stringify(msgs, null, 2) + "\n");
+	else for (const m of msgs) process.stdout.write(formatMessage(m) + "\n");
+	if (mode === "tail" && (flags.follow || flags.f)) await followChannel(cwd, channelId, new Set(msgs.map((m) => m.id)));
+	return 0;
+}
+/**
+* Follow a channel, printing messages as they appear. Phase 1 polls the local
+* replica (fs.watch is unreliable in long-lived daemons — see the fswatch-dies
+* note), so it surfaces same-cwd appends; Phase 2's daemon feeds it live peer
+* traffic. Runs until SIGINT.
+*/
+function followChannel(cwd, channelId, seen) {
+	return new Promise((resolve) => {
+		const timer = setInterval(async () => {
+			const msgs = await readAndRender(cwd, channelId);
+			for (const m of msgs) {
+				if (seen.has(m.id)) continue;
+				seen.add(m.id);
+				process.stdout.write(formatMessage(m) + "\n");
+			}
+		}, 500);
+		const stop = () => {
+			clearInterval(timer);
+			resolve();
+		};
+		process.once("SIGINT", stop);
+		process.once("SIGTERM", stop);
+	});
+}
+/** Store adapter the mesh peer drives (persist + dedup, returns new ops). */
+function nodeStore(cwd, channelId) {
+	return {
+		all: () => readOps(cwd, channelId),
+		append: (ops) => appendOps(cwd, channelId, ops)
+	};
+}
+/** One inbound op as a line (only messages are surfaced live). */
+function printOp(op) {
+	if (op.kind !== "msg") return;
+	const t = new Date(Number(op.hlc.split(".")[0])).toISOString().slice(11, 19);
+	process.stdout.write(`${t}  ${op.name}(${op.role[0]}): ${op.body ?? ""}\n`);
+}
+/**
+* Hold the WebRTC mesh for a channel: append inbound ops to the local replica and
+* broadcast newly-appeared LOCAL ops (e.g. from a separate `ay ch send`) to peers.
+* All coordination is through the jsonl file — no IPC — so `send`/`tail` compose
+* with a running `sync` unchanged. Resolves when stopped (SIGINT/SIGTERM) or when
+* `extraStdin` (pipe mode) drives it. Returns the started peer + a stop fn.
+*/
+async function runMesh(cwd, entry, opts) {
+	const { ChannelPeer } = await import("./peer-BM805vTt.js");
+	const { importRTC, getIceServers } = await import("./share-CDER9qNq.js");
+	const rtc = await importRTC();
+	const seen = new Set((await readOps(cwd, entry.channelId)).map((o) => o.id));
+	const peer = new ChannelPeer({
+		room: entry.room,
+		sighost: entry.sighost,
+		s: entry.s,
+		rtc,
+		iceServers: getIceServers,
+		store: nodeStore(cwd, entry.channelId),
+		onOp: (op) => {
+			seen.add(op.id);
+			opts.onInbound?.(op);
+			if (!opts.quiet) printOp(op);
+		},
+		onPeers: (n) => process.stderr.write(`[ch] peers: ${n}\n`)
+	});
+	await peer.start();
+	const poll = setInterval(() => {
+		(async () => {
+			for (const op of await readOps(cwd, entry.channelId)) {
+				if (seen.has(op.id)) continue;
+				seen.add(op.id);
+				await peer.publish(op);
+			}
+		})();
+	}, 500);
+	let resolveDone;
+	const done = new Promise((r) => resolveDone = r);
+	const stop = () => {
+		clearInterval(poll);
+		peer.close();
+		resolveDone();
+	};
+	process.once("SIGINT", stop);
+	process.once("SIGTERM", stop);
+	return {
+		stop,
+		done,
+		peer
+	};
+}
+async function cmdChSync(cwd, args) {
+	const { flags, positional } = parseFlags(args, { quiet: "bool" });
+	const topic = positional[0];
+	if (!topic || positional.length > 1) throw new Error("usage: ay ch sync <topic> [--quiet]");
+	const { entry } = await resolveChannel(await readRegistry(cwd), topic);
+	if (!entry) throw new Error(`join "${topic}" before syncing: ay ch join <link>`);
+	process.stderr.write(`syncing "${topic}" over the mesh — Ctrl-C to stop\n`);
+	const { done } = await runMesh(cwd, entry, { quiet: !!flags.quiet });
+	await done;
+	return 0;
+}
+async function cmdChPipe(cwd, args) {
+	const { positional } = parseFlags(args, {});
+	const topic = positional[0];
+	if (!topic || positional.length > 1) throw new Error("usage: ay ch pipe <topic>");
+	const { entry } = await resolveChannel(await readRegistry(cwd), topic);
+	if (!entry) throw new Error(`join "${topic}" before piping: ay ch join <link>`);
+	const { done } = await runMesh(cwd, entry, {});
+	const rl = (await import("readline")).createInterface({ input: process.stdin });
+	rl.on("line", (line) => {
+		const text = line.trimEnd();
+		if (!text) return;
+		(async () => {
+			const hlc = hlcSend(maxHlc(await readOps(cwd, entry.channelId)), Date.now(), entry.author);
+			await appendOps(cwd, entry.channelId, [makeOp({
+				author: entry.author,
+				name: entry.name,
+				role: entry.role,
+				hlc,
+				kind: "msg",
+				body: text
+			})]);
+		})();
+	});
+	await done;
+	rl.close();
+	return 0;
+}
+async function cmdChEmbed(cwd, args) {
+	const { flags, positional } = parseFlags(args, { host: "value" });
+	const topic = positional[0];
+	if (!topic || positional.length > 1) throw new Error("usage: ay ch embed <topic> [--host <console-host>]");
+	const { entry } = await resolveChannel(await readRegistry(cwd), topic);
+	if (!entry) throw new Error(`join "${topic}" before embedding: ay ch join <link>`);
+	const consoleHost = typeof flags.host === "string" ? flags.host : "agent-yes.com";
+	const link = formatChannelLink({
+		sighost: entry.sighost,
+		room: entry.room,
+		s: entry.s
+	});
+	process.stdout.write(`<!-- ay channel: ${topic} — anyone who can read this snippet can join -->\n<script type="module">\n  import AyChannel from "https://${consoleHost}/w/channels.js";\n  new AyChannel(${JSON.stringify(link)}).mount();\n<\/script>\n`);
+	return 0;
+}
+/** The page bookmarklet: derive a channel from the page URL and mount the widget. */
+function buildBookmarklet(host, sighost) {
+	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, args) {
+	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() {
+	process.stdout.write("ay ch - local-first E2E channels for AI ↔ humans (per-cwd, no server storage)\n\n  ay ch mk <topic> [--name N] [--role R]   create a channel, print an invite link\n  ay ch join <link> [--as <topic>]         join a channel from an invite link\n  ay ch ls [--json]                        list channels in this project (+message counts)\n  ay ch rm <topic>                         delete the local replica (peers unaffected)\n  ay ch send <topic> <text…>               post a message\n  ay ch read <topic> [-n N] [--json]       print the thread (last N)\n  ay ch head <topic> [-n N]                first N messages\n  ay ch tail <topic> [-n N] [-f]           last N (96), -f to follow\n  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            'ay ch send/tail' compose with it through the shared replica file — no daemon\n");
+	return 0;
+}
+/** `ay ch <sub> …` dispatcher (called from runSubcommand). */
+async function cmdCh(args) {
+	const cwd = process.cwd();
+	const sub = args[0];
+	const rest = args.slice(1);
+	switch (sub) {
+		case "mk":
+		case "new":
+		case "create": return cmdChMk(cwd, rest);
+		case "join": return cmdChJoin(cwd, rest);
+		case "ls":
+		case "list": return cmdChLs(cwd, rest);
+		case "rm":
+		case "remove": return cmdChRm(cwd, rest);
+		case "send": return cmdChSend(cwd, rest);
+		case "read": return cmdChRead(cwd, rest, "read");
+		case "head": return cmdChRead(cwd, rest, "head");
+		case "tail": return cmdChRead(cwd, rest, "tail");
+		case "sync": return cmdChSync(cwd, rest);
+		case "pipe": return cmdChPipe(cwd, rest);
+		case "embed": return cmdChEmbed(cwd, rest);
+		case "bookmarklet": return cmdChBookmarklet(cwd, rest);
+		case void 0:
+		case "help":
+		case "--help":
+		case "-h": return chHelp();
+		default:
+			process.stderr.write(`ay ch: unknown subcommand "${sub}"\n\n`);
+			chHelp();
+			return 1;
+	}
+}
+
+//#endregion
+export { cmdCh };
+//# sourceMappingURL=channels-Boi4aNiY.js.map