agent-yes 1.206.0 → 1.208.0

package/ts/serveLock.spec.ts

@@ -140,7 +140,8 @@ describe("acquireWebrtcHostLock — held-lock lifecycle", () => {
   });
 
   const ownerFile = () => path.join(home, "webrtc-host.lock", "owner.json");
-  const readOwnerFile = async () => JSON.parse(await readFile(ownerFile(), "utf-8")) as ServeLockOwner;
+  const readOwnerFile = async () =>
+    JSON.parse(await readFile(ownerFile(), "utf-8")) as ServeLockOwner;
 
   it("heartbeats refresh beat_at while held", async () => {
     const got = await acquireWebrtcHostLock({ graceMs: 0, beatMs: 40 });
@@ -190,19 +191,19 @@ describe("acquireWebrtcHostLock — held-lock lifecycle", () => {
   it.skipIf(process.platform === "win32")(
     "escalates to SIGKILL when the owner ignores SIGTERM",
     async () => {
-    const { spawn } = await import("node:child_process");
-    const stubborn = spawn("/bin/sh", ["-c", "trap '' TERM; sleep 30"], { stdio: "ignore" });
-    const pid = stubborn.pid!;
-    await new Promise((r) => setTimeout(r, 100)); // let the trap install
-    const { mkdir: mkd, writeFile: wf } = await import("fs/promises");
-    await mkd(path.join(home, "webrtc-host.lock"), { recursive: true });
-    await wf(ownerFile(), JSON.stringify({ pid, started_at: Date.now(), beat_at: Date.now() }));
-
-    const got = await acquireWebrtcHostLock({ takeover: true, graceMs: 0, takeoverWaitMs: 200 });
-    expect(got.ok).toBe(true);
-    if (got.ok) releases.push(got.release);
-    await new Promise((r) => setTimeout(r, 100));
-    expect(stubborn.signalCode).toBe("SIGKILL");
+      const { spawn } = await import("node:child_process");
+      const stubborn = spawn("/bin/sh", ["-c", "trap '' TERM; sleep 30"], { stdio: "ignore" });
+      const pid = stubborn.pid!;
+      await new Promise((r) => setTimeout(r, 100)); // let the trap install
+      const { mkdir: mkd, writeFile: wf } = await import("fs/promises");
+      await mkd(path.join(home, "webrtc-host.lock"), { recursive: true });
+      await wf(ownerFile(), JSON.stringify({ pid, started_at: Date.now(), beat_at: Date.now() }));
+
+      const got = await acquireWebrtcHostLock({ takeover: true, graceMs: 0, takeoverWaitMs: 200 });
+      expect(got.ok).toBe(true);
+      if (got.ok) releases.push(got.release);
+      await new Promise((r) => setTimeout(r, 100));
+      expect(stubborn.signalCode).toBe("SIGKILL");
     },
   );
 

package/ts/sizeNego.spec.ts

@@ -0,0 +1,56 @@
+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/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-CQ6e94ln.js

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