hop2 0.11.11 → 0.11.13

package/hay/CHANGELOG.md

@@ -23,6 +23,7 @@
 - **Status bar / hints toggles are session-only**: `Opt+B` (status bar) and `Opt+T` (hints) no longer persist to `.hop.json`, so an in-session toggle can't silently become your permanent default. The default is taken from `.hop.json` (`showStatusBar`/`showHints`, both default `true`); toggles affect only the current session and the notice now says so. (Other toggles like mouse capture and sync-size still persist.)
 
 #### Web Client
+- **One size rule everywhere — the last user action owns the terminal size**: the server-side size election (typing-recency plus 60s/2.5s idle windows) is replaced by a single ownership rule: whoever acted last — opened the session or pressed a key — owns the PTY size, and their refits (window drag, rotation, keyboard) flow straight through. A keystroke transfers ownership and snaps the PTY to the typist's declared fit immediately. `active_size` is now interpreted by **identity** (the owner's clientId) instead of by comparing sizes. When a peer owns the size, the web terminal in Auto-fit now **follows the owner's grid** — rendered at the PTY's true geometry, scaled and letterboxed to the viewport — instead of rewrapping the buffer at its own width; typing (or the drawer's Fit button) takes the size back. Scrolling doesn't count: wheel/mouse reports never transfer ownership, so reading a session on the phone no longer steals the size from a desk. Resize sends are debounced (150ms) and the stale pre-switch resize on reconnect is gone, so a session switch reshapes the PTY once, not twice.
 - **Restyle to the hop identity**: the web client now shares the CLI bars' palette and language — accent session chip, semantic state dot, and keycap-style find control in a real status-bar footer; mono-led chrome (brand, presence names, session labels); refined light/dark themes; dot-grid join page. The hop session picker got the same treatment, including dark-mode support.
 - **Drawer polish**: quick actions split into two clusters — utility icons (keyboard / share / find) then named actions (Fit / Manage) — and the drawer FAB now defaults to the top-right (clear of the status bar, mirroring the close button) instead of bottom-left. It stays draggable.
 - **Autofit by default + fit on every session load**: the terminal fits the viewport on connect and on each session switch, on every platform. Autofit resizes the shared PTY, so other viewers follow this client; switch to Manual in the drawer to opt out.
@@ -34,7 +35,7 @@
 
 #### Web terminal
 - **Claude screens render completely on attach without a scroll**: Hop now starts its authoritative screen grid when a session enters alternate-screen or mouse-reporting TUI mode, before startup rows can fall out of a bounded replay tail. Full-screen attaches use that serialized screen, and direct snapshot paints re-arm one delayed repaint in case the browser misses the first WebGL frame.
-- **Resizing another desktop view no longer leaves a terminal unable to reach the live bottom**: Hop now reconciles xterm's follow state after every geometry change and keeps authoritative screen resizes ordered behind the output that preceded them.
+- **Resizing another desktop view no longer leaves a terminal unable to reach the live bottom**: Wall/watch tiles now resize only unattended sessions instead of overriding an open desktop's Claude grid, Hop reconciles xterm's follow state after local geometry changes, and authoritative screen resizes stay ordered behind the output that preceded them.
 
 #### Session restore
 - **`hop restore` actually restores now (Claude conversations included), from the SessionStart-hook records**: restore built its candidate list from the workspace-scoped session store, which is only populated when a workspace is active — and no workspace is ever activated in normal use, so `restore` found nothing and silently restored zero sessions. It now sources candidates directly from the durable per-session records the SessionStart hook writes (`~/.hop2/claude-sessions/<name>.json` = `{ sessionId, cwd }`), which survive a crash/reboot and carry the exact conversation id. So after a restart, `hop restore` recreates each session in its directory and resumes its Claude conversation with `claude --resume <id>` — no manual capture step. Sessions already live are skipped (idempotent), and `hop restore` now starts the daemon itself if it isn't running, so post-reboot recovery is a single command. `--dry-run` previews the plan. Records are pruned when a session is deleted, so restore never resurrects a session you intentionally closed (and if an unwanted one does come back, deleting it once keeps it gone).

package/hay/apps/server/src/index.ts

@@ -75,6 +75,7 @@ wss.on("connection", (ws, req) => {
   const url = new URL(req.url ?? "", `http://${req.headers.host ?? "localhost"}`);
   const roomId = sanitizeRoom(url.searchParams.get("room"));
   const name = sanitizeName(url.searchParams.get("name"));
+  const source = url.searchParams.get("source") || "";
   const cols = Number(url.searchParams.get("cols") ?? 80);
   const rows = Number(url.searchParams.get("rows") ?? 24);
 
@@ -91,6 +92,7 @@ wss.on("connection", (ws, req) => {
     {
       id: clientId,
       name,
+      source,
       colorIndex,
       cols,
       rows

package/hay/apps/server/src/lib.ts

@@ -119,6 +119,7 @@ export function attachTermshare(options: TermshareServerOptions) {
     const url = new URL(req.url ?? "", `http://${req.headers.host ?? "localhost"}`);
     const roomId = sanitizeRoom(url.searchParams.get("room"));
     const name = sanitizeName(url.searchParams.get("name"));
+    const source = url.searchParams.get("source") || "";
     const cols = Number(url.searchParams.get("cols") ?? 80);
     const rows = Number(url.searchParams.get("rows") ?? 24);
 
@@ -135,6 +136,7 @@ export function attachTermshare(options: TermshareServerOptions) {
       {
         id: clientId,
         name,
+        source,
         colorIndex,
         cols,
         rows

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

@@ -24,6 +24,11 @@ export type ClientInfo = {
   // switcher wall): excluded from presence and client counts, and given a
   // small snapshot so a wall of tiles doesn't pull megabytes per open.
   source?: string;
+  // Stable per-browser-tab identity (device id + tab id). A tab holds one
+  // live connection per room, so a new attach bearing the same key means the
+  // previous connection is dead even if its socket never closed — it is
+  // evicted on the spot instead of haunting presence until TCP notices.
+  deviceKey?: string;
   colorIndex: number;
   cols: number;
   rows: number;
@@ -117,25 +122,20 @@ const SERIALIZED_MAX_REQUEST = 524_288;
 // snapshot never trips).
 const SERIALIZED_CAPPED_HINT_BYTES = 262_144;
 
-// Autofit-on-attach: a resize may claim the shared size when every OTHER
-// client has been input-idle at least this long. Someone actively typing keeps
-// the size they set; a viewer opening the session after everyone went idle
-// takes it over immediately instead of waiting to type first.
-const RESIZE_CLAIM_IDLE_MS = (() => {
-  const env = Number(process.env.HAY_RESIZE_CLAIM_IDLE_MS);
-  return Number.isFinite(env) && env >= 0 ? env : 60_000;
-})();
-// A claim:"attach" resize (a fresh client's first autofit) is deliberate:
-// someone just opened the session there. It takes the shared size unless a
-// peer typed within this window — only an actively-typing peer holds it.
-// 2.5s (was 5s): an actively typing peer keeps refreshing its own window, so
-// this only decides how long a PAUSED typist blocks a deliberate new attach —
-// measured 5s made wall-tile focus feel stuck (converged at ~5s through the
-// tunnel; ~3s with this).
-const ATTACH_CLAIM_IDLE_MS = (() => {
-  const env = Number(process.env.HAY_ATTACH_CLAIM_IDLE_MS);
-  return Number.isFinite(env) && env >= 0 ? env : 2_500;
-})();
+// Size ownership: the last USER ACTION owns the PTY size — opening the
+// session (a claim:"attach" or user:true resize) or a real keystroke,
+// whichever happened last. No idle windows, no election. The owner's
+// resizes apply unconditionally (their viewport IS the session's size);
+// everyone else's are recorded as that client's declared fit and answered
+// with a corrective active_size so followers can adopt the owner's grid.
+// When a keystroke transfers ownership, the PTY immediately takes the new
+// owner's declared fit. Monitors (source=monitor: wall tiles, preview
+// sockets) never own the size; they may size an UNATTENDED session so
+// previews render true. Wheel/mouse reports are reading, not typing, and
+// transfer nothing. SGR mouse reports only — every hop client sends wheel
+// as CSI < b;x;y M/m. Anchored and exclusive: a payload containing
+// anything besides mouse reports still counts as typing.
+const PURE_MOUSE_REPORT = /^(?:\x1b\[<\d+;\d+;\d+[Mm])+$/;
 const CONTROL_SEQUENCE_TAIL = 32;
 const DEBUG_STATE = process.env.HAY_DEBUG === "1";
 
@@ -185,12 +185,12 @@ class ClientState {
   color: string;
   typing = false;
   lastActive = now();
-  // Timestamp of this client's last real keystroke input (not resize, not the
-  // typing indicator, not connect). 0 = has never typed. Drives the active PTY
-  // size election so size follows the active typer, not whoever last resized.
-  lastInputAt = 0;
   socket: SocketAdapter;
   source: string;
+  deviceKey: string;
+  // Declared fit: the size this client's viewport wants, updated by every
+  // resize message whether or not it applied. Becomes the PTY size the
+  // moment a keystroke makes this client the size owner.
   cols: number;
   rows: number;
 
@@ -198,6 +198,7 @@ class ClientState {
     this.id = info.id;
     this.name = info.name;
     this.source = info.source || "";
+    this.deviceKey = info.deviceKey || "";
     this.color = pickPresenceColor(info.colorIndex);
     this.socket = socket;
     this.cols = info.cols;
@@ -224,7 +225,9 @@ export class Room extends EventEmitter {
   private clients = new Map<string, ClientState>();
   private collabMode = true;
   private controllerId: string | null = null;
-  private activeClientId: string | null = null;
+  // The client whose last user action (open or keystroke) owns the PTY size.
+  // null = up for grabs (fresh room, or the owner detached).
+  private sizeOwnerId: string | null = null;
   private activeCols: number;
   private activeRows: number;
   // Retained raw output as a chunk ring: append is O(1) and trimming drops
@@ -365,6 +368,19 @@ export class Room extends EventEmitter {
       this.cleanupTimer = null;
     }
 
+    // Same tab, same room: the newcomer replaces its predecessor. A phone
+    // that dropped off the network never sends a close, so its old
+    // connection would otherwise sit in presence as a second "iPhone"
+    // until TCP gives up on the corpse.
+    if (info.deviceKey) {
+      for (const [id, peer] of [...this.clients]) {
+        if (peer.deviceKey === info.deviceKey && peer.source !== "monitor") {
+          try { peer.socket.close(); } catch { /* already dead */ }
+          this.removeClient(id);
+        }
+      }
+    }
+
     const client = new ClientState(info, socket);
     this.clients.set(client.id, client);
     const created = !this.hasHadClient;
@@ -385,7 +401,7 @@ export class Room extends EventEmitter {
     socket.send(
       JSON.stringify({
         type: "active_size",
-        clientId: this.activeClientId ?? client.id,
+        clientId: this.sizeOwnerId ?? client.id,
         cols: this.activeCols,
         rows: this.activeRows
       } satisfies ServerMessage)
@@ -880,7 +896,21 @@ export class Room extends EventEmitter {
       return;
     }
     client.lastActive = now();
-    client.lastInputAt = now();
+    // A real keystroke takes the size: transfer ownership and bring the PTY
+    // to the new owner's declared fit immediately, so typing from a phone
+    // reshapes the session even before its next resize message arrives.
+    // Wheel/mouse reports are reading, not typing — a phone scrolling claude
+    // must not take the size from someone typing at a desk.
+    if (
+      client.source !== "monitor" &&
+      this.sizeOwnerId !== client.id &&
+      !PURE_MOUSE_REPORT.test(data)
+    ) {
+      this.sizeOwnerId = client.id;
+      if (client.cols !== this.activeCols || client.rows !== this.activeRows) {
+        this.applySize(client, client.cols, client.rows);
+      }
+    }
     this.pty.write(data);
     this.emit("pty_input", { roomId: this.id, clientId: client.id, data, timestamp: now() });
   }
@@ -889,60 +919,76 @@ export class Room extends EventEmitter {
     if (!Number.isFinite(cols) || !Number.isFinite(rows)) return;
     if (cols < 1 || cols > 500 || rows < 1 || rows > 200) return;
 
+    // Always record the declared fit, applied or not — a later keystroke
+    // makes it the PTY size (see handleInput).
     client.cols = cols;
     client.rows = rows;
-    // The active PTY size follows whoever is actively typing — not whoever last
-    // resized. Previously a resize bumped lastActive and then checked "am I the
-    // most active?", which was trivially true for the resizer, so every resize
-    // won: a passive viewer resizing their window yanked the size from the
-    // active typer, and two differently-sized clients flapped. Elect on typing
-    // recency (lastInputAt) instead. A client that has never typed (lastInputAt
-    // 0) only wins when no one else has typed either — so the first/sole client
-    // can still size the PTY before typing.
-    const maxInputAt = Math.max(...[...this.clients.values()].map((c) => c.lastInputAt));
-    const othersMaxInputAt = Math.max(
-      0,
-      ...[...this.clients.values()].filter((c) => c.id !== client.id).map((c) => c.lastInputAt)
-    );
-    const claimIdleMs = claim === "attach" ? ATTACH_CLAIM_IDLE_MS : RESIZE_CLAIM_IDLE_MS;
-    // A user-flagged claim is a deliberate human act (clicking a wall tile,
-    // switching to the session): it wins outright. Anyone actively typing
-    // elsewhere reclaims with their next keystroke, so misfires self-heal.
-    const isActive = userClaim ||
-      client.lastInputAt >= maxInputAt || now() - othersMaxInputAt > claimIdleMs;
-    if (isActive) {
-      this.pty.resize(cols, rows);
-      this.activeCols = cols;
-      this.activeRows = rows;
-      this.grid?.resize(cols, rows);
-      this.activeClientId = client.id;
-      // Broadcast the new active size to other clients so they can adjust —
-      // and CONFIRM to the winner: a claimant otherwise learns nothing on
-      // success and can only distinguish accept from reject by timeout.
-      this.broadcastActiveSize(client);
-      client.socket.send(
-        JSON.stringify({
-          type: "active_size",
-          clientId: client.id,
-          cols,
-          rows
-        } satisfies ServerMessage)
-      );
-      this.emit("pty_resize", { roomId: this.id, clientId: client.id, cols, rows, timestamp: now() });
-    } else if (cols !== this.activeCols || rows !== this.activeRows) {
-      // The resize lost the election (a passive viewer auto-fitted itself).
-      // Snap that client back to the shared size — otherwise its local
-      // terminal re-wraps the buffer at a size the PTY isn't, and it has no
-      // way to learn the real size until the next winning resize.
-      client.socket.send(
-        JSON.stringify({
-          type: "active_size",
-          clientId: this.activeClientId ?? client.id,
-          cols: this.activeCols,
-          rows: this.activeRows
-        } satisfies ServerMessage)
+
+    // A wall/watch tile may size an unattended session so previews render
+    // true, but must never clip a live client by forcing Claude's alternate
+    // screen to the tile's grid — and never takes ownership.
+    if (client.source === "monitor") {
+      const hasInteractivePeer = [...this.clients.values()].some(
+        (peer) => peer.id !== client.id && peer.source !== "monitor"
       );
+      if (!hasInteractivePeer) {
+        this.applySize(client, cols, rows);
+      } else if (cols !== this.activeCols || rows !== this.activeRows) {
+        this.sendActiveSize(client, this.sizeOwnerId ?? client.id);
+      }
+      return;
+    }
+
+    // Opening the session here (claim:"attach") or a deliberate click
+    // (user:true) is a user action: strict recency, it takes ownership
+    // outright. Whoever was typing elsewhere takes it back with their next
+    // keystroke, so misfires self-heal.
+    if (claim === "attach" || userClaim) {
+      this.sizeOwnerId = client.id;
+      this.applySize(client, cols, rows);
+      return;
+    }
+
+    // The owner's viewport IS the session's size: its refits (rotation,
+    // keyboard show/hide, window drag) flow straight through. While nobody
+    // owns the size (fresh room, owner detached), any interactive client
+    // may size it without claiming it.
+    if (this.sizeOwnerId === client.id || this.sizeOwnerId === null) {
+      this.applySize(client, cols, rows);
+      return;
     }
+
+    // Not the owner: the declaration is recorded; snap the client back to
+    // the shared size — otherwise its local terminal re-wraps the buffer at
+    // a size the PTY isn't, and it has no way to learn the real size until
+    // the next broadcast.
+    if (cols !== this.activeCols || rows !== this.activeRows) {
+      this.sendActiveSize(client, this.sizeOwnerId);
+    }
+  }
+
+  private applySize(client: ClientState, cols: number, rows: number) {
+    this.pty.resize(cols, rows);
+    this.activeCols = cols;
+    this.activeRows = rows;
+    this.grid?.resize(cols, rows);
+    // Broadcast to the others so they can adopt — and CONFIRM to the
+    // applier: a claimant otherwise learns nothing on success and can only
+    // distinguish accept from reject by timeout.
+    this.broadcastActiveSize(client);
+    this.sendActiveSize(client, client.id);
+    this.emit("pty_resize", { roomId: this.id, clientId: client.id, cols, rows, timestamp: now() });
+  }
+
+  private sendActiveSize(client: ClientState, ownerId: string) {
+    client.socket.send(
+      JSON.stringify({
+        type: "active_size",
+        clientId: ownerId,
+        cols: this.activeCols,
+        rows: this.activeRows
+      } satisfies ServerMessage)
+    );
   }
 
   private broadcastActiveSize(client: ClientState) {
@@ -995,6 +1041,11 @@ export class Room extends EventEmitter {
   private removeClient(clientId: string) {
     const wasController = this.controllerId === clientId;
     this.clients.delete(clientId);
+    if (this.sizeOwnerId === clientId) {
+      // The owner left: the size is up for grabs, so a remaining client's
+      // next refit (not just its next keystroke) may take it.
+      this.sizeOwnerId = null;
+    }
     if (wasController && !this.collabMode) {
       this.collabMode = true;
       this.controllerId = null;

package/hay/apps/server/src/screenGrid.ts

@@ -39,6 +39,9 @@ export const GRID_SCROLLBACK = (() => {
   const env = Number(process.env.HAY_GRID_SCROLLBACK);
   return Number.isFinite(env) && env >= 0 ? Math.floor(env) : 1000;
 })();
+// Preserve ordinary shrink/grow sequences exactly while bounding an abusive
+// resize storm's retained work behind a single xterm write marker.
+const MAX_QUEUED_RESIZE_TRANSITIONS = 256;
 
 let deps: GridDeps | null = null;
 let loading: Promise<boolean> | null = null;
@@ -110,27 +113,52 @@ export const createScreenGrid = (cols: number, rows: number): ScreenGrid | null
     return null;
   }
   let disposed = false;
+  let coalescibleResizes: number[] | null = null;
   return {
     write(data: string) {
       if (disposed) return;
+      // Output is an ordering boundary: a later resize must run after it,
+      // rather than coalescing into a resize marker queued before it.
+      if (data) coalescibleResizes = null;
       try { term.write(data); } catch { /* parser hiccup — next write continues */ }
     },
     resize(nextCols: number, nextRows: number) {
       if (disposed) return;
       const cols = Math.max(2, nextCols);
       const rows = Math.max(1, nextRows);
+      if (coalescibleResizes) {
+        if (coalescibleResizes.length < MAX_QUEUED_RESIZE_TRANSITIONS * 2) {
+          coalescibleResizes.push(cols, rows);
+        } else {
+          coalescibleResizes[coalescibleResizes.length - 2] = cols;
+          coalescibleResizes[coalescibleResizes.length - 1] = rows;
+        }
+        return;
+      }
+      const scheduled = [cols, rows];
+      coalescibleResizes = scheduled;
       try {
         // xterm parses write() asynchronously. Queue the resize behind every
         // earlier byte so room order stays PTY output → SIGWINCH, while later
         // writes naturally queue behind this callback's synchronous resize.
+        // Consecutive resizes share this marker. Replay ordinary geometry
+        // changes exactly: shrink/grow transitions mutate xterm's grid even
+        // without output. Only an abusive overflow degrades to the latest size.
         term.write("", () => {
           if (disposed) return;
-          try { term.resize(cols, rows); } catch { /* keep old size */ }
+          if (coalescibleResizes === scheduled) coalescibleResizes = null;
+          for (let i = 0; i < scheduled.length; i += 2) {
+            try { term.resize(scheduled[i], scheduled[i + 1]); } catch { /* keep previous size */ }
+          }
         });
-      } catch { /* keep old size */ }
+      } catch {
+        if (coalescibleResizes === scheduled) coalescibleResizes = null;
+      }
     },
     serialize(callback: (data: string | null) => void, scrollback: number = GRID_SCROLLBACK) {
       if (disposed) { callback(null); return; }
+      // A later resize must not move ahead of this point-in-time snapshot.
+      coalescibleResizes = null;
       try {
         // An empty write's callback fires once all queued data has parsed —
         // the serialize then reflects every byte up to this attach.