hop2 0.11.11 → 0.11.13

package/hay/apps/server/test/rooms.test.ts

@@ -243,50 +243,85 @@ describe("Room", () => {
     expect(ptyInstance!.resizes.at(-1)).toEqual({ cols: 90, rows: 20 });
   });
 
-  it('claim:"attach" takes the size unless a peer typed seconds ago', () => {
-    vi.useFakeTimers();
-    try {
-      let ptyInstance: FakePty | null = null;
-      const factory: PtyFactory = () => {
-        ptyInstance = new FakePty() as unknown as FakePty;
-        return ptyInstance as any;
-      };
-      const manager = new RoomManager(factory);
-      const room = manager.getRoom("attach-claim", { cols: 80, rows: 24 }, "/tmp");
-      const cli = new FakeSocket();
-      room.attachClient({ id: "cli", name: "Local", colorIndex: 0, cols: 80, rows: 24 }, cli);
-
-      // The desktop CLI is actively typing right now.
-      cli.emitMessage({ type: "input", data: "ls" });
-
-      // A phone opens the session 2s later and attach-claims its fitted size:
-      // an actively-typing peer keeps the size — the claim loses.
-      vi.advanceTimersByTime(2_000);
-      const phone = new FakeSocket();
-      room.attachClient({ id: "ph", name: "Phone", colorIndex: 1, cols: 46, rows: 28 }, phone);
-      const before = ptyInstance!.resizes.length;
-      phone.emitMessage({ type: "resize", cols: 46, rows: 28, claim: "attach" });
-      expect(ptyInstance!.resizes.length).toBe(before);
-
-      // 10s after the CLI's last keystroke (well inside the 60s a plain
-      // resize would need), the attach claim wins: opening a session is
-      // intent, and nobody is typing anymore.
-      vi.advanceTimersByTime(10_000);
-      phone.emitMessage({ type: "resize", cols: 46, rows: 28, claim: "attach" });
-      expect(ptyInstance!.resizes.at(-1)).toEqual({ cols: 46, rows: 28 });
-
-      // A plain (unclaimed) resize from another fresh viewer still cannot
-      // yank the size at 10s idle — the 60s election guards those.
-      const viewer = new FakeSocket();
-      room.attachClient({ id: "v", name: "Viewer", colorIndex: 2, cols: 200, rows: 50 }, viewer);
-      phone.emitMessage({ type: "input", data: "x" });
-      vi.advanceTimersByTime(10_000);
-      const beforeViewer = ptyInstance!.resizes.length;
-      viewer.emitMessage({ type: "resize", cols: 200, rows: 50 });
-      expect(ptyInstance!.resizes.length).toBe(beforeViewer);
-    } finally {
-      vi.useRealTimers();
-    }
+  it("lets a monitor size only an unattended session", () => {
+    let ptyInstance: FakePty | null = null;
+    const factory: PtyFactory = () => {
+      ptyInstance = new FakePty() as unknown as FakePty;
+      return ptyInstance as any;
+    };
+
+    const manager = new RoomManager(factory);
+    const room = manager.getRoom("monitor-resize", { cols: 80, rows: 24 }, "/tmp");
+    const desktop = new FakeSocket();
+    const monitor = new FakeSocket();
+    room.attachClient(
+      { id: "desktop", name: "Desktop", colorIndex: 0, cols: 80, rows: 24, nudge: false },
+      desktop
+    );
+    room.attachClient(
+      { id: "wall", name: "Wall", source: "monitor", colorIndex: 1, cols: 80, rows: 40, nudge: false },
+      monitor
+    );
+
+    const before = ptyInstance!.resizes.length;
+    monitor.emitMessage({ type: "resize", cols: 80, rows: 40, claim: "attach", user: true });
+    expect(ptyInstance!.resizes.length).toBe(before);
+    expect(findMessages(monitor, "active_size").at(-1)).toMatchObject({ cols: 80, rows: 24 });
+
+    desktop.close();
+    monitor.emitMessage({ type: "resize", cols: 80, rows: 40, claim: "attach", user: true });
+    expect(ptyInstance!.resizes.at(-1)).toEqual({ cols: 80, rows: 40 });
+  });
+
+  it("the last user action — open or keystroke — owns the size", () => {
+    let ptyInstance: FakePty | null = null;
+    const factory: PtyFactory = () => {
+      ptyInstance = new FakePty() as unknown as FakePty;
+      return ptyInstance as any;
+    };
+    const manager = new RoomManager(factory);
+    const room = manager.getRoom("attach-claim", { cols: 80, rows: 24 }, "/tmp");
+    const cli = new FakeSocket();
+    room.attachClient({ id: "cli", name: "Local", colorIndex: 0, cols: 80, rows: 24 }, cli);
+
+    // The desktop CLI is actively typing right now.
+    cli.emitMessage({ type: "input", data: "ls" });
+
+    // A phone opens the session and attach-claims its fitted size: opening
+    // is the latest user action, so the claim wins outright — even over
+    // someone who typed a moment ago. Strict recency, no idle windows.
+    const phone = new FakeSocket();
+    room.attachClient({ id: "ph", name: "Phone", colorIndex: 1, cols: 46, rows: 28 }, phone);
+    phone.emitMessage({ type: "resize", cols: 46, rows: 28, claim: "attach" });
+    expect(ptyInstance!.resizes.at(-1)).toEqual({ cols: 46, rows: 28 });
+
+    // The CLI's next keystroke is now the latest user action: ownership
+    // transfers back and the PTY snaps to the CLI's declared fit
+    // immediately — before any resize message from it.
+    cli.emitMessage({ type: "input", data: "x" });
+    expect(ptyInstance!.resizes.at(-1)).toEqual({ cols: 80, rows: 24 });
+
+    // A plain (unclaimed) resize from a fresh viewer is a declaration, not
+    // a user action — it cannot move an owned size, and the viewer is
+    // snapped back to the shared grid.
+    const viewer = new FakeSocket();
+    room.attachClient({ id: "v", name: "Viewer", colorIndex: 2, cols: 200, rows: 50 }, viewer);
+    const beforeViewer = ptyInstance!.resizes.length;
+    viewer.emitMessage({ type: "resize", cols: 200, rows: 50 });
+    expect(ptyInstance!.resizes.length).toBe(beforeViewer);
+    expect(findMessages(viewer, "active_size").at(-1)).toMatchObject({ cols: 80, rows: 24, clientId: "cli" });
+
+    // But that declaration is remembered: the viewer's first keystroke makes
+    // it the owner and the PTY takes its declared 200×50 in the same beat.
+    viewer.emitMessage({ type: "input", data: "y" });
+    expect(ptyInstance!.resizes.at(-1)).toEqual({ cols: 200, rows: 50 });
+
+    // Wheel reports are reading, not typing: a pure SGR mouse payload from
+    // the phone transfers nothing.
+    const beforeWheel = ptyInstance!.resizes.length;
+    phone.emitMessage({ type: "input", data: "\x1b[<64;40;12M\x1b[<65;40;12M" });
+    phone.emitMessage({ type: "resize", cols: 46, rows: 28 });
+    expect(ptyInstance!.resizes.length).toBe(beforeWheel);
   });
 
   it("bounds the join-time snapshot replay to a tail cut at a line boundary", () => {
@@ -408,41 +443,31 @@ describe("Room", () => {
     expect(last?.clientId).toBe("typer");
   });
 
-  it("lets a resize claim the size once every other client is input-idle", () => {
-    vi.useFakeTimers();
-    try {
-      vi.setSystemTime(1_000_000);
-      let ptyInstance: FakePty | null = null;
-      const factory: PtyFactory = () => {
-        ptyInstance = new FakePty() as unknown as FakePty;
-        return ptyInstance as any;
-      };
-      const manager = new RoomManager(factory);
-      const room = manager.getRoom("claim", { cols: 120, rows: 30 }, "/tmp");
-      const typer = new FakeSocket();
-      const viewer = new FakeSocket();
-      room.attachClient({ id: "typer", name: "Alex", colorIndex: 0, cols: 120, rows: 30 }, typer);
-      room.attachClient({ id: "viewer", name: "Blake", colorIndex: 1, cols: 60, rows: 20 }, viewer);
-
-      typer.emitMessage({ type: "input", data: "ls\r" });
-      typer.emitMessage({ type: "resize", cols: 120, rows: 30 });
-
-      // Recently-typed elsewhere: the viewer's autofit is refused (and snapped back).
-      viewer.emitMessage({ type: "resize", cols: 60, rows: 20 });
-      expect((ptyInstance as unknown as FakePty).resizes.at(-1)).toEqual({ cols: 120, rows: 30 });
-
-      // Everyone else idle past the claim window: the same autofit now wins.
-      vi.setSystemTime(1_000_000 + 61_000);
-      viewer.emitMessage({ type: "resize", cols: 60, rows: 20 });
-      expect((ptyInstance as unknown as FakePty).resizes.at(-1)).toEqual({ cols: 60, rows: 20 });
-
-      // The previous holder is told the size moved.
-      const sizes = findMessages(typer, "active_size");
-      expect(sizes.at(-1)?.cols).toBe(60);
-      expect(sizes.at(-1)?.clientId).toBe("viewer");
-    } finally {
-      vi.useRealTimers();
-    }
+  it("frees the size when the owner detaches — no idle window needed", () => {
+    let ptyInstance: FakePty | null = null;
+    const factory: PtyFactory = () => {
+      ptyInstance = new FakePty() as unknown as FakePty;
+      return ptyInstance as any;
+    };
+    const manager = new RoomManager(factory);
+    const room = manager.getRoom("claim", { cols: 120, rows: 30 }, "/tmp");
+    const typer = new FakeSocket();
+    const viewer = new FakeSocket();
+    room.attachClient({ id: "typer", name: "Alex", colorIndex: 0, cols: 120, rows: 30 }, typer);
+    room.attachClient({ id: "viewer", name: "Blake", colorIndex: 1, cols: 60, rows: 20 }, viewer);
+
+    typer.emitMessage({ type: "input", data: "ls\r" });
+    typer.emitMessage({ type: "resize", cols: 120, rows: 30 });
+
+    // The owner is elsewhere: the viewer's autofit is refused (and snapped back).
+    viewer.emitMessage({ type: "resize", cols: 60, rows: 20 });
+    expect((ptyInstance as unknown as FakePty).resizes.at(-1)).toEqual({ cols: 120, rows: 30 });
+
+    // The owner leaves: the size is up for grabs, and the viewer's next
+    // plain refit takes it — no keystroke, no claim, no waiting.
+    typer.close();
+    viewer.emitMessage({ type: "resize", cols: 60, rows: 20 });
+    expect((ptyInstance as unknown as FakePty).resizes.at(-1)).toEqual({ cols: 60, rows: 20 });
   });
 
   it("counts attention bells but not OSC-terminator BELs", () => {
@@ -813,6 +838,31 @@ describe("Room", () => {
       }
     });
 
+    it("preserves consecutive shrink and grow transitions in the screen grid", async () => {
+      const { room, pty } = await setup("ordered-grid-resize-burst", { cols: 20, rows: 5 });
+      const owner = new FakeSocket();
+      room.attachClient(
+        { id: "owner", name: "Owner", colorIndex: 0, cols: 20, rows: 5, replayBytes: 0, nudge: false },
+        owner
+      );
+      const rows = Array.from({ length: 5 }, (_, i) => `\x1b[${i + 1};1HROW-${i + 1}`).join("");
+      pty().emit("\x1b[?1049h\x1b[2J" + rows);
+
+      // Even with no output between them, shrink then grow is not equivalent
+      // to only the final size: xterm discards the rows clipped by the shrink.
+      owner.emitMessage({ type: "resize", cols: 20, rows: 2, user: true });
+      owner.emitMessage({ type: "resize", cols: 20, rows: 5, user: true });
+      const late = new FakeSocket();
+      room.attachClient(
+        { id: "late", name: "Late", colorIndex: 1, cols: 20, rows: 5, replayBytes: 65536 },
+        late
+      );
+      const snapshot = await waitForSnapshot(late);
+      expect(String(snapshot.data)).not.toContain("ROW-1");
+      expect(String(snapshot.data)).toContain("ROW-4");
+      expect(String(snapshot.data)).toContain("ROW-5");
+    });
+
     it("flags a serialized snapshot as capped when deeper raw history exists", async () => {
       const { room, pty } = await setup("capped");
       const big = "\x1b[20;1H" + "y".repeat(4096);
@@ -954,3 +1004,57 @@ describe("Room", () => {
     });
   });
 });
+
+describe("device-key eviction", () => {
+  // The room actively closes the predecessor's socket; a plain FakeSocket
+  // close is indistinguishable from a client-side close, so count them.
+  class TrackingSocket extends FakeSocket {
+    serverCloses = 0;
+    close() {
+      this.serverCloses += 1;
+      super.close();
+    }
+  }
+
+  const makeRoom = (name: string) => {
+    const manager = new RoomManager(() => new FakePty() as any);
+    return manager.getRoom(name, { cols: 80, rows: 24 }, "/tmp");
+  };
+
+  it("a same-key attach replaces the predecessor instead of joining it", () => {
+    const room = makeRoom("evict");
+    const ghost = new TrackingSocket();
+    const fresh = new FakeSocket();
+    room.attachClient({ id: "a", name: "iPhone", colorIndex: 0, cols: 80, rows: 24, deviceKey: "dev1.tab1" }, ghost);
+    room.attachClient({ id: "b", name: "iPhone", colorIndex: 1, cols: 80, rows: 24, deviceKey: "dev1.tab1" }, fresh);
+
+    expect(ghost.serverCloses).toBe(1);
+    const presence = findMessages(fresh, "presence").at(-1) as any;
+    expect(presence.clients.map((c: { id: string }) => c.id)).toEqual(["b"]);
+  });
+
+  it("different tabs from the same device coexist", () => {
+    const room = makeRoom("tabs");
+    const tabA = new TrackingSocket();
+    const tabB = new FakeSocket();
+    room.attachClient({ id: "a", name: "iPhone", colorIndex: 0, cols: 80, rows: 24, deviceKey: "dev1.tab1" }, tabA);
+    room.attachClient({ id: "b", name: "iPhone", colorIndex: 1, cols: 80, rows: 24, deviceKey: "dev1.tab2" }, tabB);
+
+    expect(tabA.serverCloses).toBe(0);
+    const presence = findMessages(tabB, "presence").at(-1) as any;
+    expect(presence.clients.map((c: { id: string }) => c.id).sort()).toEqual(["a", "b"]);
+  });
+
+  it("keyless clients (CLI, older bundles) are never evicted", () => {
+    const room = makeRoom("legacy");
+    const legacy = new TrackingSocket();
+    const keyed = new FakeSocket();
+    room.attachClient({ id: "a", name: "cli", colorIndex: 0, cols: 80, rows: 24 }, legacy);
+    room.attachClient({ id: "b", name: "iPhone", colorIndex: 1, cols: 80, rows: 24, deviceKey: "dev1.tab1" }, keyed);
+    room.attachClient({ id: "c", name: "iPhone", colorIndex: 2, cols: 80, rows: 24, deviceKey: "dev1.tab1" }, new FakeSocket());
+
+    expect(legacy.serverCloses).toBe(0);
+    const presence = findMessages(legacy, "presence").at(-1) as any;
+    expect(presence.clients.map((c: { id: string }) => c.id).sort()).toEqual(["a", "c"]);
+  });
+});

package/hay/apps/web/scripts/run-e2e.mjs

@@ -113,6 +113,46 @@ const runE2E = async () => {
     const switchedBuffer = await page1.evaluate(() => window.__hay?.getBufferText() || "");
     assert.ok(!switchedBuffer.includes("shared"), `old room output survived session switch: ${JSON.stringify(switchedBuffer)}`);
 
+    // A wall/watch tile may fit an unattended room, but it must not replace
+    // the PTY geometry underneath an attached desktop. Claude's alternate
+    // screen has no local scrollback, so foreign rows can otherwise be clipped.
+    const monitorClaim = await page1.evaluate(async (roomName) => {
+      const peer = new WebSocket(
+        `ws://${location.host}/ws?room=${encodeURIComponent(roomName)}&name=Wall&source=monitor&replay=0&cols=240&rows=70`
+      );
+      const nextActiveSize = () => new Promise((resolve) => {
+        const handler = (event) => {
+          const message = JSON.parse(String(event.data));
+          if (message.type !== "active_size") return;
+          peer.removeEventListener("message", handler);
+          resolve(message);
+        };
+        peer.addEventListener("message", handler);
+      });
+      const initialSize = nextActiveSize();
+      await new Promise((resolve, reject) => {
+        peer.onopen = resolve;
+        peer.onerror = reject;
+      });
+      const before = await initialSize;
+      const claimedSize = nextActiveSize();
+      peer.send(JSON.stringify({
+        type: "resize",
+        cols: 240,
+        rows: 70,
+        claim: "attach",
+        user: true
+      }));
+      const after = await claimedSize;
+      peer.close();
+      return { before, after };
+    }, freshRoom);
+    assert.deepEqual(
+      { cols: monitorClaim.after.cols, rows: monitorClaim.after.rows },
+      { cols: monitorClaim.before.cols, rows: monitorClaim.before.rows },
+      `monitor replaced an attached desktop's PTY size: ${JSON.stringify(monitorClaim)}`
+    );
+
     // A resize can collapse scrollback to y=base=0 without xterm emitting an
     // onScroll event. App follow-mode must reconcile that state before the
     // next real room output grows below a viewport parked at 0.