agent-yes 1.205.0 → 1.207.0

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/sizeNego.spec.ts

@@ -0,0 +1,61 @@
+import { describe, expect, it } from "vitest";
+import {
+  NEGO_FLOOR_COLS,
+  NEGO_FLOOR_ROWS,
+  negotiateSize,
+  sanitizeCap,
+} from "./sizeNego.ts";
+
+describe("sanitizeCap", () => {
+  it("accepts a normal viewer capacity", () => {
+    expect(sanitizeCap({ cols: 80, rows: 24 })).toEqual({ cols: 80, rows: 24 });
+  });
+  it("floors fractional values", () => {
+    expect(sanitizeCap({ cols: 80.9, rows: 24.7 })).toEqual({ cols: 80, rows: 24 });
+  });
+  it("rejects null / non-object / missing fields", () => {
+    expect(sanitizeCap(null)).toBeNull();
+    expect(sanitizeCap(undefined)).toBeNull();
+    expect(sanitizeCap("80x24")).toBeNull();
+    expect(sanitizeCap({})).toBeNull();
+    expect(sanitizeCap({ cols: 80 })).toBeNull();
+  });
+  it("rejects out-of-range junk (mid-layout 0x0, absurd sizes)", () => {
+    expect(sanitizeCap({ cols: 0, rows: 0 })).toBeNull();
+    expect(sanitizeCap({ cols: 10, rows: 24 })).toBeNull(); // below min cols
+    expect(sanitizeCap({ cols: 80, rows: 2 })).toBeNull(); // below min rows
+    expect(sanitizeCap({ cols: 9999, rows: 24 })).toBeNull();
+    expect(sanitizeCap({ cols: 80, rows: 9999 })).toBeNull();
+    expect(sanitizeCap({ cols: NaN, rows: 24 })).toBeNull();
+  });
+});
+
+describe("negotiateSize", () => {
+  it("returns null with no caps (withdraw → tty size rules)", () => {
+    expect(negotiateSize([])).toBeNull();
+  });
+  it("single viewer: adopts its capacity", () => {
+    expect(negotiateSize([{ cols: 133, rows: 40 }])).toEqual({ cols: 133, rows: 40 });
+  });
+  it("phone + desktop: elementwise min (the tmux rule)", () => {
+    // phone is narrow but tall, desktop is wide but short → min of each axis
+    const phone = { cols: 51, rows: 60 };
+    const desktop = { cols: 200, rows: 50 };
+    expect(negotiateSize([phone, desktop])).toEqual({ cols: 51, rows: 50 });
+  });
+  it("clamps to the floor so a tiny viewer can't wedge the agent", () => {
+    expect(negotiateSize([{ cols: 20, rows: 5 }])).toEqual({
+      cols: NEGO_FLOOR_COLS,
+      rows: NEGO_FLOOR_ROWS,
+    });
+  });
+  it("three viewers: min wins per axis", () => {
+    expect(
+      negotiateSize([
+        { cols: 100, rows: 30 },
+        { cols: 80, rows: 50 },
+        { cols: 120, rows: 24 },
+      ]),
+    ).toEqual({ cols: 80, rows: 24 });
+  });
+});

package/ts/sizeNego.ts

@@ -0,0 +1,59 @@
+/**
+ * Multi-viewer PTY size negotiation — the tmux "smallest client wins" rule.
+ *
+ * Every writable web viewer reports its readable capacity (the cols×rows its
+ * pane can render at its chosen font size) via /api/presence. The host resizes
+ * the agent's PTY to the elementwise minimum across live viewers, so the
+ * narrowest screen (a phone) gets a grid it can actually read while wider
+ * viewers simply render fewer columns. When the last capacity-reporting viewer
+ * leaves, the negotiated size is withdrawn and the PTY falls back to the real
+ * terminal's size (the wrapper re-reads the tty once the winsize file is gone).
+ *
+ * Pure logic only — the serve layer owns presence bookkeeping, the winsize
+ * file, and SIGWINCH delivery.
+ */
+
+export interface SizeCap {
+  cols: number;
+  rows: number;
+}
+
+/** Reject junk caps (a viewer mid-layout can report 0×0 or absurd numbers). */
+const CAP_MIN_COLS = 20;
+const CAP_MIN_ROWS = 5;
+const CAP_MAX_COLS = 500;
+const CAP_MAX_ROWS = 200;
+
+/** Never negotiate below this — TUIs (claude, codex) break down when the grid
+ * gets absurdly narrow, so a tiny watch-sized viewer can't wedge the agent. */
+export const NEGO_FLOOR_COLS = 40;
+export const NEGO_FLOOR_ROWS = 10;
+
+/** Parse a presence-reported cap into a sane SizeCap, or null if unusable. */
+export function sanitizeCap(cap: unknown): SizeCap | null {
+  if (typeof cap !== "object" || cap === null) return null;
+  const c = Math.floor(Number((cap as SizeCap).cols) || 0);
+  const r = Math.floor(Number((cap as SizeCap).rows) || 0);
+  if (c < CAP_MIN_COLS || c > CAP_MAX_COLS) return null;
+  if (r < CAP_MIN_ROWS || r > CAP_MAX_ROWS) return null;
+  return { cols: c, rows: r };
+}
+
+/**
+ * Elementwise minimum over the live viewers' capacities, clamped to the floor.
+ * Returns null when no viewer reports a capacity — meaning "withdraw the
+ * negotiated size, let the real tty size rule again".
+ */
+export function negotiateSize(caps: ReadonlyArray<SizeCap>): SizeCap | null {
+  let cols = Infinity;
+  let rows = Infinity;
+  for (const cap of caps) {
+    if (cap.cols < cols) cols = cap.cols;
+    if (cap.rows < rows) rows = cap.rows;
+  }
+  if (!Number.isFinite(cols) || !Number.isFinite(rows)) return null;
+  return {
+    cols: Math.max(NEGO_FLOOR_COLS, cols),
+    rows: Math.max(NEGO_FLOOR_ROWS, rows),
+  };
+}

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/ts/ws.spec.ts

@@ -468,16 +468,14 @@ describe("collectWorkspaces / workspaceStatus (mocked provision)", () => {
   beforeEach(() => {
     root = realpathSync(mkdtempSync(path.join(os.tmpdir(), "ay-ws-api-")));
     prov.wsRoot = root;
-    prov.readStatus
-      .mockReset()
-      .mockResolvedValue({
-        branch: "main",
-        head: "abc123",
-        ahead: 1,
-        behind: 0,
-        dirty: true,
-        hasUpstream: true,
-      });
+    prov.readStatus.mockReset().mockResolvedValue({
+      branch: "main",
+      head: "abc123",
+      ahead: 1,
+      behind: 0,
+      dirty: true,
+      hasUpstream: true,
+    });
     homeBackup = process.env.AGENT_YES_HOME;
     process.env.AGENT_YES_HOME = path.join(root, ".ay-home");
   });

package/dist/SUPPORTED_CLIS-D3XTFfS7.js

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