agent-yes 1.204.0 → 1.206.0

package/ts/serveLock.ts

@@ -0,0 +1,172 @@
+import { mkdir, readFile, rm, writeFile, rename } from "fs/promises";
+import path from "path";
+import { agentYesHome } from "./agentYesHome.ts";
+import { isTransientLockMkdirError } from "./notifyStore.ts";
+
+/**
+ * Singleton lock for the WebRTC host role: one `ay serve` host per
+ * ~/.agent-yes. Two hosts sharing the persisted room (~/.agent-yes/.share-room)
+ * fight over every viewer connection — the exact outage seen live: an orphaned
+ * `ay serve --webrtc` from a previous manager era plus a manual run left the
+ * managed daemon crash-looping (12 watchdog restarts) and the share link
+ * unloadable. The lock makes the loser fail FAST with a pointer to the owner
+ * instead of silently contending.
+ *
+ * mkdir-based (atomic on every platform), owner JSON alongside, heartbeat
+ * refresh while held. A stale owner — dead pid, or a heartbeat older than
+ * SERVE_LOCK_STALE_MS (a SIGKILLed host can't clean up) — is stolen, so a
+ * crashed host never wedges the next start.
+ */
+
+export const SERVE_LOCK_STALE_MS = 20_000;
+export const SERVE_LOCK_BEAT_MS = 5_000;
+// Riding out a manager roll-forward: stop-old/start-new overlap briefly, so a
+// new host retries for a grace window before declaring the lock busy.
+export const SERVE_LOCK_GRACE_MS = 12_000;
+
+export type ServeLockOwner = { pid: number; started_at: number; beat_at: number };
+
+export type ServeLockResult =
+  | { ok: true; release: () => Promise<void> }
+  | { ok: false; owner: ServeLockOwner | null };
+
+function lockDir(): string {
+  return path.join(agentYesHome(), "webrtc-host.lock");
+}
+function ownerPath(): string {
+  return path.join(lockDir(), "owner.json");
+}
+
+function pidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    // EPERM = alive but not ours; only ESRCH means gone.
+    return (e as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+async function readOwner(): Promise<ServeLockOwner | null> {
+  try {
+    const o = JSON.parse(await readFile(ownerPath(), "utf-8")) as ServeLockOwner;
+    return typeof o?.pid === "number" ? o : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Pure staleness decision, exported for tests. */
+export function isOwnerStale(
+  owner: ServeLockOwner | null,
+  now: number,
+  alive: (pid: number) => boolean,
+  staleMs = SERVE_LOCK_STALE_MS,
+): boolean {
+  if (!owner) return true; // torn/absent owner: mkdir won but write died
+  if (!alive(owner.pid)) return true;
+  return now - owner.beat_at > staleMs;
+}
+
+// Atomic owner stamp (temp + rename) so a concurrent reader never parses a
+// torn file as "no owner" while we in fact hold the lock.
+async function stampOwner(startedAt: number): Promise<boolean> {
+  const tmp = `${ownerPath()}.${process.pid}.tmp`;
+  try {
+    await writeFile(
+      tmp,
+      JSON.stringify({ pid: process.pid, started_at: startedAt, beat_at: Date.now() }),
+    );
+    await rename(tmp, ownerPath());
+    return true;
+  } catch {
+    await rm(tmp, { force: true }).catch(() => {});
+    return false;
+  }
+}
+
+/**
+ * Acquire the host lock, retrying for up to `graceMs`. Returns fast on a live
+ * owner once the grace expires (never blocks a daemon boot forever). With
+ * `takeover`, a live owner is SIGTERM'd (then SIGKILL'd) and the lock stolen.
+ */
+export async function acquireWebrtcHostLock(opts?: {
+  takeover?: boolean;
+  graceMs?: number;
+  staleMs?: number;
+  /** Heartbeat cadence override — tests only. */
+  beatMs?: number;
+  /** SIGTERM→SIGKILL escalation wait for --takeover — tests only. */
+  takeoverWaitMs?: number;
+}): Promise<ServeLockResult> {
+  const graceMs = opts?.graceMs ?? SERVE_LOCK_GRACE_MS;
+  const staleMs = opts?.staleMs ?? SERVE_LOCK_STALE_MS;
+  const beatMs = opts?.beatMs ?? SERVE_LOCK_BEAT_MS;
+  const startedAt = Date.now();
+  const deadline = startedAt + graceMs;
+  let tookOver = false;
+  for (;;) {
+    try {
+      await mkdir(lockDir(), { recursive: false });
+      if (!(await stampOwner(startedAt))) {
+        await rm(lockDir(), { recursive: true, force: true }).catch(() => {});
+        return { ok: false, owner: null };
+      }
+      // Heartbeat while held; stops itself if a thief replaced our owner file.
+      const beat = setInterval(() => {
+        void (async () => {
+          const o = await readOwner();
+          if (o?.pid !== process.pid) {
+            clearInterval(beat);
+            return;
+          }
+          await stampOwner(startedAt);
+        })();
+      }, beatMs);
+      if (typeof beat.unref === "function") beat.unref();
+      return {
+        ok: true,
+        release: async () => {
+          clearInterval(beat);
+          if ((await readOwner())?.pid === process.pid)
+            await rm(lockDir(), { recursive: true, force: true }).catch(() => {});
+        },
+      };
+    } catch (e) {
+      const code = (e as NodeJS.ErrnoException).code;
+      if (!isTransientLockMkdirError(code)) throw e;
+      if (code !== "EEXIST") {
+        // win32 mkdir-vs-rm race: dir mid-delete, just retry.
+        await new Promise((r) => setTimeout(r, 25));
+        continue;
+      }
+      const owner = await readOwner();
+      if (isOwnerStale(owner, Date.now(), pidAlive, staleMs)) {
+        await rm(lockDir(), { recursive: true, force: true }).catch(() => {});
+        continue; // re-prove via mkdir — two stealers can't both win
+      }
+      if (opts?.takeover && owner && !tookOver) {
+        tookOver = true; // one shot: never kill a second, newer owner
+        try {
+          process.kill(owner.pid, "SIGTERM");
+        } catch {
+          /* already gone */
+        }
+        // Give it a moment to shut down cleanly (it releases the lock), then
+        // escalate; the loop's stale check mops up whatever remains.
+        await new Promise((r) => setTimeout(r, opts?.takeoverWaitMs ?? 2_000));
+        if (pidAlive(owner.pid)) {
+          try {
+            process.kill(owner.pid, "SIGKILL");
+          } catch {
+            /* gone */
+          }
+        }
+        await rm(lockDir(), { recursive: true, force: true }).catch(() => {});
+        continue;
+      }
+      if (Date.now() >= deadline) return { ok: false, owner };
+      await new Promise((r) => setTimeout(r, 250));
+    }
+  }
+}

package/ts/share.ts

@@ -66,10 +66,28 @@ const MAX_PEER_JOIN_QUEUE = 50;
 const IDLE_RESTART_UPTIME_MS = 25 * 60_000;
 const HARD_RESTART_UPTIME_MS = 45 * 60_000;
 const IDLE_RESTART_CHECK_MS = 60_000;
+const PERF_SLOW_MS = Number(process.env.AGENT_YES_WEBRTC_PERF_SLOW_MS) || 750;
+const PERF_BUFFERED_BYTES = Number(process.env.AGENT_YES_WEBRTC_PERF_BUFFERED_BYTES) || 1_000_000;
+const PERF_VERBOSE = process.env.AGENT_YES_WEBRTC_PERF === "1";
 
 type IceServer = { urls: string | string[]; username?: string; credential?: string };
 const STUN: IceServer[] = [{ urls: "stun:stun.l.google.com:19302" }];
 
+function perfLog(event: string, data: Record<string, unknown>, force = false) {
+  if (!force && !PERF_VERBOSE) return;
+  process.stderr.write(`[share:perf] ${JSON.stringify({ t: Date.now(), event, ...data })}\n`);
+}
+
+function maybeSlow(event: string, startedAt: number, data: Record<string, unknown> = {}) {
+  const ms = Math.round(performance.now() - startedAt);
+  perfLog(event, { ms, ...data }, ms >= PERF_SLOW_MS);
+}
+
+function dcBufferedAmount(dc: any): number {
+  const n = Number(dc?.bufferedAmount ?? 0);
+  return Number.isFinite(n) ? n : 0;
+}
+
 // Short-lived Cloudflare TURN credentials, minted from a long-term TURN key, so
 // browsers can RELAY when a direct P2P path is impossible (symmetric NAT /
 // CGNAT — the main cause of "rooms offline"). Set CF_TURN_KEY_ID +
@@ -428,6 +446,7 @@ export async function startShare(
     if (closed) return; // a reconnect timer queued before close() must not revive it
     const ws = new WebSocket(`${wsScheme}://${host}/${room}`, [SUB]);
     currentWs = ws;
+    const signalStartedAt = performance.now();
     let ready = false;
     let lastRecv = Date.now();
     let hb: ReturnType<typeof setInterval> | undefined;
@@ -443,6 +462,7 @@ export async function startShare(
       }
     };
     ws.onopen = () => {
+      maybeSlow("signal.open", signalStartedAt, { room, host });
       ws.send(JSON.stringify({ type: "hello", role: "host", v: 2, token: authToken }));
       ready = true;
       lastRecv = Date.now();
@@ -480,6 +500,12 @@ export async function startShare(
       const m = JSON.parse(ev.data as string);
       if (m.type === "pong") return; // heartbeat ack — liveness already recorded
       if (m.type === "peer-join") {
+        perfLog("peer.join", {
+          room,
+          peer: String(m.peer),
+          queue: peerJoinQueue.length,
+          peers: peers.size,
+        });
         // Serialized in drainPeerJoins() to avoid a storm. Skip dupes (already
         // queued or already an active peer) and cap the queue so a pathological
         // burst can't grow it unboundedly — dropped joins retry via the browser.
@@ -554,6 +580,7 @@ export async function startShare(
   };
 
   async function startPeer(ws: WebSocket, peerId: string) {
+    const startedAt = performance.now();
     const iceServers = await getIceServers();
     const pc = new RTCPeerConnection({ iceServers });
     let resolveKeys!: () => void;
@@ -584,6 +611,11 @@ export async function startShare(
     dc.binaryType = "arraybuffer";
     dc.onopen = async () => {
       try {
+        maybeSlow("peer.dc_open", startedAt, {
+          room,
+          peer: peerId,
+          buffered: dcBufferedAmount(dc),
+        });
         await peer.keysReady; // keys derived in the answer handler
         // Open the mandatory bidirectional key-confirmation handshake. Nothing
         // the peer sends is acted on until BOTH directions confirm (see onFrame).
@@ -624,6 +656,7 @@ export async function startShare(
     ws.send(
       JSON.stringify({ type: "offer", to: peerId, sdp: pc.localDescription.sdp, iceServers }),
     );
+    maybeSlow("peer.offer", startedAt, { room, peer: peerId, iceServers: iceServers.length });
   }
 
   function closePeer(peerId: string) {
@@ -642,8 +675,10 @@ export async function startShare(
   // Seal an envelope and send it, serialized per peer so the wire order matches
   // the nonce-counter order (so the receiver's monotonic check never trips).
   function enqueueSeal(peerId: string, dc: any, peer: Peer, flags: number, obj: object) {
+    const queuedAt = performance.now();
     peer.sendChain = peer.sendChain.then(async () => {
       if (dc.readyState !== "open" || !peer.keyH2C || !peer.th) return;
+      const queuedMs = Math.round(performance.now() - queuedAt);
       let frame: ArrayBuffer;
       try {
         frame = await e2eSeal(peer.keyH2C, peer.send, flags, peer.th, packEnvelope(obj));
@@ -653,6 +688,19 @@ export async function startShare(
       }
       try {
         dc.send(frame);
+        const buffered = dcBufferedAmount(dc);
+        perfLog(
+          "send",
+          {
+            room,
+            peer: peerId,
+            kind: (obj as any)?.t,
+            queuedMs,
+            buffered,
+            bytes: frame.byteLength,
+          },
+          queuedMs >= PERF_SLOW_MS || buffered >= PERF_BUFFERED_BYTES,
+        );
       } catch {
         /* peer vanished mid-send; dropping the frame is correct */
       }
@@ -703,6 +751,8 @@ export async function startShare(
     }
     if (req.t !== "req") return;
     const { id, method, path: p, body } = req;
+    const startedAt = performance.now();
+    perfLog("req.start", { room, peer: peerId, id, method, path: p });
     const ac = new AbortController();
     peer.aborts.set(id, ac);
     try {
@@ -718,6 +768,14 @@ export async function startShare(
           signal: ac.signal,
         }),
       );
+      maybeSlow("req.head", startedAt, {
+        room,
+        peer: peerId,
+        id,
+        method,
+        path: p,
+        status: res.status,
+      });
       enqueueSeal(peerId, dc, peer, 0, {
         t: "res",
         id,
@@ -727,9 +785,11 @@ export async function startShare(
       const reader = res.body!.getReader();
       const dec = new TextDecoder();
       let seq = 0;
+      let bytes = 0;
       for (;;) {
         const { done, value } = await reader.read();
         if (done) break;
+        bytes += value.byteLength;
         const text = dec.decode(value, { stream: true });
         // Slice on UTF-16 boundaries: JSON round-trips lone surrogates as \uXXXX,
         // so the receiver reassembles the exact text by concatenating in seq order.
@@ -742,13 +802,32 @@ export async function startShare(
           });
       }
       enqueueSeal(peerId, dc, peer, 0, { t: "end", id, seq });
+      maybeSlow("req.end", startedAt, {
+        room,
+        peer: peerId,
+        id,
+        method,
+        path: p,
+        status: res.status,
+        chunks: seq,
+        bytes,
+      });
     } catch (e) {
-      if ((e as Error).name !== "AbortError")
+      if ((e as Error).name !== "AbortError") {
+        maybeSlow("req.error", startedAt, {
+          room,
+          peer: peerId,
+          id,
+          method,
+          path: p,
+          error: String((e as Error).message ?? e),
+        });
         enqueueSeal(peerId, dc, peer, 0, {
           t: "end",
           id,
           error: String((e as Error).message ?? e),
         });
+      }
     } finally {
       peer.aborts.delete(id);
     }

package/ts/statusText.spec.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import { parseStatusText } from "./statusText.ts";
+
+describe("parseStatusText", () => {
+  it("returns the latest Claude spinner/status line", () => {
+    expect(
+      parseStatusText([
+        "older output",
+        "✶ Verifying calendar meetings with real data… (6m 30s · ↓ 19.5k tokens)",
+      ]),
+    ).toBe("✶ Verifying calendar meetings with real data… (6m 30s · ↓ 19.5k tokens)");
+  });
+
+  it("ignores non-status terminal prose", () => {
+    expect(parseStatusText(["hello", "Done", ""])).toBe(null);
+  });
+});

package/ts/statusText.ts

@@ -0,0 +1,19 @@
+/**
+ * Extract a short "what is the agent doing right now?" line from the rendered
+ * terminal screen. Claude Code paints this as a spinner/status line, e.g.
+ * "✶ Verifying calendar meetings with real data… (6m 30s · ↓ 19.5k tokens)".
+ */
+
+const SPINNER_PREFIX = /^[\u2800-\u28ff✶✻✢✳✽✦✧✩✷✸✹✺✼·•●◐◓◒◑]\s+/u;
+const CONTROL = /[\x00-\x1f\x7f-\x9f]/g;
+
+export function parseStatusText(lines: string[]): string | null {
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i]?.replace(CONTROL, "").trim();
+    if (!line || line.length < 3) continue;
+    if (!SPINNER_PREFIX.test(line)) continue;
+    if (/^(?:[•·]\s*)?(?:esc|ctrl|enter|return|shift|tab)\b/i.test(line)) continue;
+    return line.slice(0, 220).trim();
+  }
+  return null;
+}

package/dist/SUPPORTED_CLIS-BUxPt2CD.js

@@ -1,9 +0,0 @@
-import "./ts-D9LzuGpU.js";
-import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-C8ScoMqV.js";
-import "./pidStore-BIvsBQ8X.js";
-import "./globalPidIndex-CoNr7tS8.js";
-import "./messageLog-CxrKJj77.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DqsPHFU9.js";
-
-export { SUPPORTED_CLIS };