hop2 0.11.34 → 0.11.36

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

@@ -8,6 +8,40 @@ import type { PtyFactory } from "./pty";
 import { createScreenGrid, loadScreenGridDeps, screenGridsAvailable } from "./screenGrid";
 import type { ScreenGrid } from "./screenGrid";
 
+/**
+ * Darwin `lsof` probes are rate-limited process-wide, not per room.
+ *
+ * Each room polls its own cwd on its own timer, so the cost of the fallback
+ * scales with the number of live rooms — and `lsof` on macOS is not a cheap
+ * syscall but a process that stats every mount, blocking uninterruptibly when
+ * any of them is slow. At ~150 rooms the 15s timers align into bursts of ~150
+ * concurrent `lsof`s, each holding a 5s timeout; every one of them counts
+ * toward the load average. That is how this host drove the machine to a
+ * 1-minute load of 367 across 18 cores on 2026-09-01, starving its own event
+ * loop until the watchdog restarted it and killed every session inside.
+ *
+ * A small global ceiling keeps the fallback a fallback. Probes that arrive
+ * while the gate is full are DROPPED, not queued: this is a best-effort poll
+ * that repeats every 15s anyway, and a queue would just rebuild the burst.
+ */
+const MAX_CONCURRENT_CWD_PROBES = 4;
+let activeCwdProbes = 0;
+
+function runGatedCwdProbe(pid: number, onCwd: (cwdPath: string) => void) {
+  if (activeCwdProbes >= MAX_CONCURRENT_CWD_PROBES) return;
+  activeCwdProbes++;
+  execFile("lsof", ["-a", "-p", String(pid), "-d", "cwd", "-Fn"], { timeout: 5000 }, (err, stdout) => {
+    activeCwdProbes--;
+    if (err || !stdout) return;
+    for (const line of stdout.split("\n")) {
+      if (line.startsWith("n/")) {
+        onCwd(line.slice(1));
+        return;
+      }
+    }
+  });
+}
+
 export type SocketAdapter = {
   send: (data: string) => void;
   onMessage: (handler: (data: string) => void) => void;
@@ -787,6 +821,12 @@ export class Room extends EventEmitter {
         return;
       }
 
+      // The shell reports its own cwd, so the lsof fallback has nothing left to
+      // add for this room — retire its timer. Most rooms run a shell that emits
+      // OSC 7, so this is what keeps the global probe budget for the few that
+      // genuinely need it.
+      this.stopCwdPolling();
+
       if (cwdPath && cwdPath !== this.liveCwd) {
         if (DEBUG_STATE) {
           console.log(`[hay] room=${this.id} cwd=${cwdPath}`);
@@ -830,15 +870,7 @@ export class Room extends EventEmitter {
         this.foregroundProcess = fg.replace(/^-/, ""); // strip login-shell "-zsh" dash
       }
       if (process.platform === "darwin") {
-        execFile("lsof", ["-a", "-p", String(pid), "-d", "cwd", "-Fn"], { timeout: 5000 }, (err, stdout) => {
-          if (err || !stdout) return;
-          for (const line of stdout.split("\n")) {
-            if (line.startsWith("n/")) {
-              updateCwd(line.slice(1));
-              break;
-            }
-          }
-        });
+        runGatedCwdProbe(pid, updateCwd);
       } else if (process.platform === "linux") {
         readlink(`/proc/${pid}/cwd`, (err, target) => {
           if (err || !target) return;
@@ -847,9 +879,13 @@ export class Room extends EventEmitter {
       }
     };
 
-    this.cwdPollTimer = setInterval(poll, intervalMs);
+    // Jitter both the phase and the period: identical timers started together
+    // (a `hop restore` brings up dozens of rooms at once) stay in lockstep for
+    // the life of the host, turning a per-room poll into a synchronized burst.
+    const jitteredInterval = intervalMs + Math.floor(Math.random() * intervalMs);
+    this.cwdPollTimer = setInterval(poll, jitteredInterval);
     // Initial poll with a generous delay to not interfere with startup
-    setTimeout(poll, 3000);
+    setTimeout(poll, 3000 + Math.floor(Math.random() * intervalMs));
   }
 
   stopCwdPolling() {

package/hay/apps/web/src/App.tsx

@@ -10,7 +10,7 @@ import {
   type ClientMessage
 } from "hay-shared";
 import { activityLabel, sortPresence } from "./utils/presence";
-import { createOptimisticEcho } from "./utils/optimisticEcho";
+import { createOptimisticEcho, hasActiveOtherTypist } from "./utils/optimisticEcho";
 import { attachScrollFlywheel } from "./utils/scrollFlywheel";
 import { collectTerminalMatches, selectTerminalMatch } from "./utils/terminalSearch";
 import { createVoiceHold, speechRecognitionCtor } from "./utils/voiceHold";
@@ -231,6 +231,10 @@ const paneTreeHasPrimary = (n: PaneNode): boolean =>
   n.kind === "leaf" ? n.session === null : paneTreeHasPrimary(n.a) || paneTreeHasPrimary(n.b);
 
 const LATENCY_COMP = true;
+// A WebSocket handshake normally completes in well under a second. One still
+// CONNECTING after this long has hung (a stalled tunnel upgrade) and must be
+// aborted and retried — it will never resolve itself.
+const STUCK_CONNECTING_MS = 8000;
 const AUTO_FIT_ON_TYPE = true;
 
 type SessionSwitchMode = "page" | "instant";
@@ -454,6 +458,14 @@ const App = () => {
   const [sessions, setSessions] = useState<SessionInfo[]>([]);
   const [loadingSessions, setLoadingSessions] = useState(false);
   const [sessionsError, setSessionsError] = useState(false);
+  // The desktop twin of the iOS swipe filmstrip: an on-demand HUD showing the
+  // recency ring centred on the current session, target lit, that appears
+  // while you cycle (⌘J/⌘L held / two-finger swipe) and commits on release — like
+  // ⌘Tab. Frozen ring so neighbours don't reshuffle mid-cycle (same rule as
+  // the iOS swipe order). Ref mirror for the keyup/wheel listeners.
+  const [switchHud, setSwitchHud] = useState<{ ring: SessionInfo[]; index: number } | null>(null);
+  const switchHudRef = useRef<{ ring: SessionInfo[]; index: number } | null>(null);
+  switchHudRef.current = switchHud;
   // Server-owned folders (Manual mode). Kept in App because the sessions
   // fetch already carries them.
   const [folders, setFolders] = useState<Array<{ id: string; name: string }>>([]);
@@ -602,6 +614,7 @@ const App = () => {
   const viewModeRef = useRef(viewMode);
   const reconnectAttemptRef = useRef(0);
   const reconnectTimerRef = useRef<number | null>(null);
+  const connectStartedAtRef = useRef<number>(0);
   const shouldReconnectRef = useRef(true);
   const connectNonceRef = useRef(0);
   const userScrolledUpRef = useRef(false);
@@ -648,6 +661,18 @@ const App = () => {
   const pendingInputRef = useRef<Array<{ room: string; data: string; at: number }>>([]);
   // Presence re-render throttle (see the "presence" message handler).
   const presenceThrottleRef = useRef<number | null>(null);
+  // Per-peer "last observed typing" — refreshed on every presence frame that
+  // shows a peer typing. A live typist keeps advancing it (presence fires per
+  // keystroke); a ghost that dropped mid-type stops, so its flag ages out
+  // instead of pinning local echo off forever. See hasActiveOtherTypist.
+  const typingLastSeenRef = useRef<Map<string, number>>(new Map());
+  // Fresh mirrors of the echo-gating state, read at KEYSTROKE time (not from a
+  // possibly-stale render), so a silent ghost never keeps echo disabled once
+  // its typing flag has gone stale — no re-render is needed to recover.
+  const presenceRef = useRef<PresenceClient[]>([]);
+  const collabModeRef = useRef(true);
+  const controllerIdRef = useRef<string | null>(null);
+  const clientIdRef = useRef<string | null>(null);
   const presencePendingRef = useRef<PresenceClient[] | null>(null);
   const activeSessionRoomRef = useRef<string | null>(null);
   // Set each render once switchSession exists (defined later); the keyboard
@@ -1081,10 +1106,27 @@ const App = () => {
   // now (presence carries the flag), and drops the instant one starts. A
   // sub-second overlap before presence propagates is absorbed by the
   // reconciler's guards (complex-chunk passthrough, two-strike clear).
-  const othersTyping = presence.some((c) => c.id !== clientId && c.typing);
-  const optimisticActive =
-    LATENCY_COMP && status === "connected" && !othersTyping
-    && (collabMode ? true : controllerId === clientId);
+  // Keep the keystroke-time mirrors current every render.
+  presenceRef.current = presence;
+  collabModeRef.current = collabMode;
+  controllerIdRef.current = controllerId;
+  // The single source of truth for "should local echo be on", evaluated from
+  // refs so it can be recomputed at keystroke time. A peer only suppresses
+  // echo if we've seen them typing RECENTLY (ghosts age out).
+  const echoEnabledNow = () =>
+    LATENCY_COMP && statusForChromeRef.current === "connected"
+    // NOT on the alternate screen. A full-screen TUI (Claude Code's composer,
+    // vim, less) repaints on every keystroke, and that redraw IS the echo —
+    // an optimistic char painted first then overwritten by the redraw is a
+    // visible flicker ("rendered wrong, then changes"), for no latency win the
+    // app's own fast repaint doesn't already give. Optimistic echo belongs to
+    // the SHELL, where the terminal echoes char-by-char with no redraw to
+    // fight. (Reconcile's TUI guard still protects any in-flight echo when the
+    // app flips to alt-screen mid-keystroke.)
+    && !remoteAltScreenRef.current
+    && !hasActiveOtherTypist(presenceRef.current, clientIdRef.current, typingLastSeenRef.current, Date.now())
+    && (collabModeRef.current ? true : controllerIdRef.current === clientIdRef.current);
+  const optimisticActive = echoEnabledNow();
 
   useEffect(() => {
     if (optimisticPrevRef.current && !optimisticActive) {
@@ -1241,7 +1283,7 @@ const App = () => {
       }
       return;
     }
-    const echoed = optimisticEchoRef.current.onInput(sanitized, optimisticActive);
+    const echoed = optimisticEchoRef.current.onInput(sanitized, echoEnabledNow());
     if (echoed) {
       writeToTerminal(echoed);
     }
@@ -1372,7 +1414,6 @@ const App = () => {
   // clientId, so "is this size ours" is an identity check, never a size
   // comparison (comparing sizes is how a follower gets fooled into thinking
   // an adopted grid is its own).
-  const clientIdRef = useRef<string | null>(null);
   // Who owns the shared size right now, per the latest active_size.
   const activeOwnerRef = useRef<string | null>(null);
   // Non-null while a PEER owns the size in fit mode: the local terminal is
@@ -1653,6 +1694,10 @@ const App = () => {
 
     const ws = new WebSocket(url);
     wsRef.current = ws;
+    // When this socket began CONNECTING — the watchdog uses it to catch a
+    // handshake that hangs (accepted TCP, WS upgrade never completes through
+    // the tunnel): it fires no open/close/error, so nothing else can notice.
+    connectStartedAtRef.current = Date.now();
 
     ws.addEventListener("open", () => {
       if (connectionNonce !== connectNonceRef.current || activeSessionRoomRef.current !== targetRoom) {
@@ -1711,6 +1756,19 @@ const App = () => {
           // indicator) — re-rendering the whole app tree per remote key is
           // wasted main-thread time while output streams. Leading update for
           // immediacy, then at most one trailing update per 300ms window.
+          // Refresh each typing peer's "last seen" from the RAW frame (before
+          // the render throttle) so a live typist never ages out; a ghost that
+          // stopped sending does. Prune peers no longer present.
+          {
+            const now = Date.now();
+            const seen = typingLastSeenRef.current;
+            const ids = new Set<string>();
+            for (const c of message.clients) {
+              ids.add(c.id);
+              if (c.typing) seen.set(c.id, now);
+            }
+            for (const id of [...seen.keys()]) if (!ids.has(id)) seen.delete(id);
+          }
           if (presenceThrottleRef.current === null) {
             setPresence(message.clients);
             presenceThrottleRef.current = window.setTimeout(() => {
@@ -1945,6 +2003,39 @@ const App = () => {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [session, terminalReady, reconnectToken]);
 
+  // Reconnect watchdog — the guarantee that a live session never stays
+  // stranded in a non-connected state. scheduleReconnect's loop bails
+  // (correctly) in a few edge cases: a room-ref mismatch when a switch was
+  // gated behind the open wall, or a retry timer cleared by a superseding
+  // connect that then no-op'd. Individually right, together they can leave
+  // the socket dead with nothing driving a retry — the "stuck reconnecting
+  // until you refresh" symptom. This notices a session that SHOULD be up but
+  // has no live/connecting socket and no pending retry, and kicks a fresh
+  // connect through the normal effect (reconnectToken) — a refresh's recovery
+  // without the refresh. It NEVER fires while a socket is open/connecting or a
+  // retry is already scheduled, so it cannot cause a connect storm.
+  useEffect(() => {
+    if (!session || !terminalReady) return;
+    const id = window.setInterval(() => {
+      if (switcherOpenRef.current) return;          // the wall owns the socket while it's up
+      if (!shouldReconnectRef.current) return;      // session ended / leaving on purpose
+      const st = statusForChromeRef.current;
+      if (st === "connected" || st === "ended") return;
+      const ws = wsRef.current;
+      if (ws && ws.readyState === WebSocket.OPEN) return;   // healthy, leave it
+      // A socket wedged in CONNECTING past the deadline is a hung upgrade —
+      // it will never fire open/close/error on its own. Abort it so a fresh
+      // connect can run; a handshake that hasn't hung yet is still given time.
+      if (ws && ws.readyState === WebSocket.CONNECTING) {
+        if (Date.now() - connectStartedAtRef.current < STUCK_CONNECTING_MS) return;
+        try { ws.close(); } catch { /* aborting the hung upgrade */ }
+      }
+      if (reconnectTimerRef.current !== null) return; // a retry is already pending
+      setReconnectToken((value) => value + 1);      // stranded → drive a fresh connect
+    }, 2500);
+    return () => window.clearInterval(id);
+  }, [session, terminalReady]);
+
   useEffect(() => {
     if (!session || !containerRef.current || termRef.current) {
       return;
@@ -3706,19 +3797,43 @@ const App = () => {
   // Desktop keyboard layer — capture phase so shortcuts win over the focused
   // terminal. ⌘-based (Ctrl+Shift elsewhere) to stay clear of readline/TUI
   // keys, which the terminal must keep receiving untouched.
-  //   ⌘K session palette · ⌘E last session (toggles) · ⌘J/⌘⇧J cycle by name ·
+  //   ⌘K session palette · ⌘E last session (toggles) · ⌘J/⌘L cycle left/right ·
   //   ⌘, settings · ⌘+/−/0 font size · ⌘/ shortcut help · Esc closes drawer/help
   useEffect(() => {
     if (!session || !isEmbeddedInHop()) return;
-    const cycleSession = (dir: 1 | -1) => {
-      const list = [...sessionsRef.current]
+    // ── Desktop switch HUD (the swipe filmstrip's desktop twin) ────────────
+    // Recency ring, FROZEN when the HUD opens so neighbours don't reshuffle
+    // mid-cycle. Stepping only moves the lit target; the switch is DEFERRED to
+    // commit (modifier release / wheel settle) — one navigation, ⌘Tab-style,
+    // instead of the old switch-per-press.
+    const hudRing = (): SessionInfo[] =>
+      [...sessionsRef.current]
         .filter((s) => s.type !== "port")
-        .sort((a, b) => (a.displayName || a.name).localeCompare(b.displayName || b.name));
-      if (list.length < 2) return;
-      const cur = list.findIndex((s) => s.name === activeSessionRoomRef.current || s.internalName === activeSessionRoomRef.current);
-      const next = list[(cur + dir + list.length) % list.length];
-      if (next) switchSessionRef.current?.(next);
+        .sort((a, b) => (b.lastActivityAt || 0) - (a.lastActivityAt || 0));
+    const hudStep = (dir: 1 | -1) => {
+      const open = switchHudRef.current;
+      if (open) {
+        setSwitchHud({ ring: open.ring, index: Math.min(open.ring.length - 1, Math.max(0, open.index + dir)) });
+        return;
+      }
+      const ring = hudRing();
+      if (ring.length < 2) return;
+      const curKey = activeSessionRoomRef.current;
+      const cur = ring.findIndex((s) => s.name === curKey || s.internalName === curKey);
+      const start = cur < 0 ? 0 : cur;
+      setSwitchHud({ ring, index: Math.min(ring.length - 1, Math.max(0, start + dir)) });
     };
+    const hudCommit = () => {
+      const open = switchHudRef.current;
+      setSwitchHud(null);
+      if (!open) return;
+      const target = open.ring[open.index];
+      const curKey = activeSessionRoomRef.current;
+      if (target && target.name !== curKey && target.internalName !== curKey) {
+        switchSessionRef.current?.(target);
+      }
+    };
+    const hudCancel = () => setSwitchHud(null);
     // Back and forth between the two sessions you are actually working in,
     // without a trip through the palette. MRU, so pressing it twice returns
     // you — the switch itself pushes the room you left to the top of the
@@ -3745,6 +3860,12 @@ const App = () => {
         ? event.metaKey && !event.ctrlKey && !event.altKey
         : event.ctrlKey && event.shiftKey && !event.metaKey && !event.altKey;
       if (!mod) {
+        if (event.key === "Escape" && switchHudRef.current) {
+          event.preventDefault();
+          event.stopPropagation();
+          hudCancel();
+          return;
+        }
         if (event.key === "Escape" && (drawerOpenRef.current || shortcutHelpRef.current)) {
           event.preventDefault();
           event.stopPropagation();
@@ -3765,7 +3886,10 @@ const App = () => {
               : {}));
         return;
       }
-      if (key === "j") { grab(); cycleSession(shifted ? -1 : 1); return; }
+      // ⌘J / ⌘L step the switch HUD left / right (J is left of L on the
+      // keyboard), committing on ⌘ release — no Shift needed for the reverse.
+      if (key === "j") { grab(); hudStep(-1); return; }
+      if (key === "l") { grab(); hudStep(1); return; }
       if (key === ",") { grab(); setDrawerOpen((v) => !v); return; }
       if (key === "/" || (shifted && key === "?")) { grab(); setShortcutHelpOpen((v) => !v); return; }
       if (key === "e") {
@@ -3813,7 +3937,42 @@ const App = () => {
       }
     };
     window.addEventListener("keydown", onKey, true);
-    return () => window.removeEventListener("keydown", onKey, true);
+    // Release the hold modifier (⌘ on mac, Ctrl elsewhere) → land on the lit
+    // target, ⌘Tab-style. Any keyup counts: the modifier's own release AND
+    // releasing it while another key is up both leave the flag false.
+    const onKeyUp = (event: KeyboardEvent) => {
+      if (!switchHudRef.current) return;
+      if (!(isMacPlatform ? event.metaKey : event.ctrlKey)) hudCommit();
+    };
+    window.addEventListener("keyup", onKeyUp, true);
+    // Two-finger horizontal swipe = the literal parity with the phone swipe.
+    // Horizontal-dominant wheel only; ignore vertical scroll, pinch, and any
+    // scrollable panel/field; preventDefault so the browser's back/forward
+    // swipe never fires. Steps per 60pt of travel, settles into a commit.
+    let wheelAccum = 0;
+    let wheelTimer: number | null = null;
+    const onWheel = (event: WheelEvent) => {
+      if (!session) return;
+      const el = event.target as Element | null;
+      if (el?.closest(".switcher-scroll, .views-panel, .drawer, input, textarea, [contenteditable]")) return;
+      if (Math.abs(event.deltaX) <= Math.abs(event.deltaY) * 1.3) return;
+      event.preventDefault();
+      wheelAccum += event.deltaX;
+      while (Math.abs(wheelAccum) >= 60) {
+        const dir: 1 | -1 = wheelAccum > 0 ? 1 : -1;
+        wheelAccum -= dir * 60;
+        hudStep(dir);
+      }
+      if (wheelTimer) window.clearTimeout(wheelTimer);
+      wheelTimer = window.setTimeout(() => { wheelAccum = 0; hudCommit(); }, 320);
+    };
+    window.addEventListener("wheel", onWheel, { passive: false, capture: true });
+    return () => {
+      window.removeEventListener("keydown", onKey, true);
+      window.removeEventListener("keyup", onKeyUp, true);
+      window.removeEventListener("wheel", onWheel, true);
+      if (wheelTimer) window.clearTimeout(wheelTimer);
+    };
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [session]);
 
@@ -3832,6 +3991,36 @@ const App = () => {
 
   return (
     <div className="app">
+      {switchHud && (() => {
+        const curKey = session?.room ?? sessionLabel;
+        const SLOT = 152; // card 140 + gap 12; must match .switch-hud CSS
+        return (
+          <div className="switch-hud" aria-hidden="true">
+            <div className="switch-hud-window">
+              <div className="switch-hud-strip"
+                   style={{ transform: `translateX(-${switchHud.index * SLOT + 70}px)` }}>
+                {switchHud.ring.map((s, i) => {
+                  const key = s.internalName || s.name;
+                  const isTarget = i === switchHud.index;
+                  const isCurrent = key === curKey;
+                  return (
+                    <div key={key}
+                         className={"switch-hud-card"
+                                    + (isTarget ? " is-target" : "")
+                                    + (isCurrent ? " is-current" : "")}>
+                      <span className="switch-hud-name">{s.displayName || s.name}</span>
+                      {isCurrent && <span className="switch-hud-now">now</span>}
+                    </div>
+                  );
+                })}
+              </div>
+            </div>
+            <div className="switch-hud-hint">
+              {isMacPlatform ? "⌘J / ⌘L step · release ⌘ to switch" : "Ctrl+Shift+J / +L step · release to switch"} · esc cancels
+            </div>
+          </div>
+        );
+      })()}
       <header className="topbar">
         <div className="brand">
           <div>
@@ -4640,7 +4829,7 @@ const App = () => {
                 {[
                   [isMacPlatform ? "⌘K" : "Ctrl+Shift+K", "session palette (type to filter, ↑↓, ⏎)"],
                   [isMacPlatform ? "⌘E" : "Ctrl+Shift+E", "back to the last session (press again to return)"],
-                  [isMacPlatform ? "⌘J / ⌘⇧J" : "Ctrl+Shift+J / +⇧", "next / previous session (by name)"],
+                  [isMacPlatform ? "⌘J / ⌘L" : "Ctrl+Shift+J / +L", "previous / next session (left / right)"],
                   [isMacPlatform ? "⌘," : "Ctrl+Shift+,", "settings drawer"],
                   [isMacPlatform ? "⌘F" : "Ctrl+Shift+F", "find in terminal"],
                   ...(isMacPlatform ? [["⌘⇧V", "views — results agents published"]] : []),