hop2 0.11.76 → 0.11.77

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

@@ -142,6 +142,11 @@ export type RoomSummary = {
 // 6MB still exceeds every reader: the deep-history replay asks 1.5MB, the
 // serialized attach reads the grid, and `hop restore` persists 64KB tails.
 // Override with HAY_SNAPSHOT_BUFFER_BYTES for deeper rings at GC's expense.
+// DEC private modes worth restoring on adopt: cursor keys, mouse (any
+// flavour and encoding), focus events, alternate screen, bracketed paste,
+// cursor visibility.
+const TRACKED_DEC_MODES = new Set(["1", "25", "47", "1000", "1002", "1003", "1004", "1005", "1006", "1015", "1047", "1049", "2004"]);
+
 const MAX_BUFFER_SIZE = (() => {
   const env = Number(process.env.HAY_SNAPSHOT_BUFFER_BYTES);
   return Number.isFinite(env) && env > 0 ? env : 6_000_000;
@@ -321,6 +326,13 @@ export class Room extends EventEmitter {
   private mouseReporting = false;
   private mouseSgr = false;
   private cursorHidden = false;
+  // The DEC private modes an app set (alternate screen, mouse, focus,
+  // bracketed paste…), exactly. An app sets them once at startup; a host
+  // restart rebuilds the room from a bounded replay that no longer holds
+  // that moment, so the room forgot Codex was full-screen and the wheel
+  // scrolled the page instead of the app (2026-10-12). The host saves
+  // modePrefix() and puts it back in front of the replay on adopt.
+  private decModes = new Map<string, boolean>();
   private controlSequenceTail = "";
   private oscBuffer = "";
   private cleanupTimer: NodeJS.Timeout | null = null;
@@ -678,10 +690,13 @@ export class Room extends EventEmitter {
 
     let nextMouseReporting = hasNewRis ? false : this.mouseReporting;
     let nextMouseSgr = hasNewRis ? false : this.mouseSgr;
+    const modesBefore = this.modePrefix();
+    if (hasNewRis) this.decModes.clear();
     while ((match = regex.exec(stateInput)) !== null) {
       const params = match[1].split(";").filter(Boolean);
       const mode = match[2];
       for (const param of params) {
+        if (TRACKED_DEC_MODES.has(param)) this.decModes.set(param, mode === "h");
         if (param === "25") {
           nextCursorHidden = mode === "l";
         } else if (param === "47" || param === "1047" || param === "1049") {
@@ -738,6 +753,9 @@ export class Room extends EventEmitter {
       stateChanged = true;
     }
 
+    const modesAfter = this.modePrefix();
+    if (modesAfter !== modesBefore) this.emit("modes", modesAfter);
+
     if (stateChanged) {
       this.emit("pty_state", {
         roomId: this.id,
@@ -1204,6 +1222,22 @@ export class Room extends EventEmitter {
   // omit cells until the app happens to repaint (for example, on scroll).
   // Begin tracking at TUI entry; dependency loading is shared and normally
   // finishes first, but the callback covers a TUI that starts immediately.
+  /**
+   * The escape sequences that put a fresh terminal into this app's current
+   * modes: the alternate screen first (so the rest apply to it), then each
+   * mode that is on, and a hidden cursor. "" for a plain shell.
+   */
+  modePrefix(): string {
+    let alt = "", rest = "";
+    for (const [mode, on] of this.decModes) {
+      if (mode === "25") { if (!on) rest += "\x1b[?25l"; continue; }
+      if (!on) continue;
+      if (mode === "1049" || mode === "1047" || mode === "47") alt = `\x1b[?${mode}h`;
+      else rest += `\x1b[?${mode}h`;
+    }
+    return alt + rest;
+  }
+
   private startTuiGrid() {
     if (!SERIALIZED_ATTACH_ENABLED || this.grid || this.gridStartPending || this.gridUnavailable || this.ended) return;
     if (!this.alternateScreen && !this.mouseReporting) return;
@@ -1244,7 +1278,11 @@ export class Room extends EventEmitter {
             const nl = tail.indexOf("\n");
             if (nl !== -1 && nl < 8192) tail = tail.slice(nl + 1);
           }
-          this.grid.write(tail);
+          // The tail rarely reaches back to where the app set its modes
+          // (an adopted room's saved prefix sits at the very front of the
+          // ring): put the room's current modes first, or the grid serializes
+          // a full-screen app as a plain shell. The tail's own changes win.
+          this.grid.write(this.modePrefix() + tail);
         }
       }
     }

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

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+import { RoomManager } from "../src/rooms";
+import type { PtyFactory } from "../src/pty";
+
+class FakePty {
+  private handlers: Array<(data: string) => void> = [];
+  onData(handler: (data: string) => void) { this.handlers.push(handler); }
+  onExit() {}
+  emit(data: string) { for (const h of this.handlers) h(data); }
+  write() {}
+  resize() {}
+  kill() {}
+}
+
+describe("terminal modes a room remembers", () => {
+  it("a room reports the DEC modes its app set, alternate screen first", () => {
+    const pty = new FakePty();
+    const manager = new RoomManager((() => pty) as unknown as PtyFactory);
+    const room = manager.getRoom("codex", { cols: 80, rows: 24 }, "/tmp");
+    const seen: string[] = [];
+    room.on("modes", (p: string) => seen.push(p));
+    pty.emit("\x1b[?2004h\x1b[?1004h\x1b[?1049h\x1b[?1003h\x1b[?1006h\x1b[?25l hello");
+    expect(room.modePrefix()).toBe("\x1b[?1049h\x1b[?2004h\x1b[?1004h\x1b[?1003h\x1b[?1006h\x1b[?25l");
+    expect(seen.at(-1)).toBe(room.modePrefix());
+    pty.emit("\x1b[?1003l\x1b[?1049l");
+    expect(room.modePrefix()).toBe("\x1b[?2004h\x1b[?1004h\x1b[?1006h\x1b[?25l");
+    pty.emit("\x1bc");
+    expect(room.modePrefix()).toBe("");
+  });
+});

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

@@ -49,6 +49,7 @@ import {
 } from "./utils/paneTree";
 import { ViewsPanel, hasUnseenViews, loadViewsSeen } from "./components/ViewsPanel";
 import type { ViewsSummary } from "./utils/switcherModel";
+import { isAppCtrlEnter, isFullscreenChord } from "./utils/fullscreenChord";
 
 const createRoomId = () => `room-${Math.random().toString(36).slice(2, 7)}`;
 
@@ -2329,13 +2330,21 @@ const App = () => {
     terminal.attachCustomKeyEventHandler((event) => {
       // ⌘⏎ leaves full screen for the wall — the mirror of ⌘⏎ on a wall
       // tile entering it. One chord toggles the mode from either side.
-      if (event.key === 'Enter' && (event.metaKey || event.ctrlKey) && !event.altKey && !event.shiftKey) {
+      // On a Mac only ⌘⏎ — Ctrl⏎ goes to the app (see fullscreenChord.ts).
+      if (isFullscreenChord(event)) {
         if (event.type === 'keydown') {
           event.preventDefault();
           setSwitcherOpen(true);
         }
         return false;
       }
+      if (isAppCtrlEnter(event) && (remoteKbdEnhancedRef.current || foregroundIsClaude())) {
+        if (event.type === 'keydown') {
+          event.preventDefault();
+          handleUserInput('\x1b[13;5u');
+        }
+        return false;
+      }
       // Long-press SPACE = voice input — shared controller; see voiceHold.ts.
       {
         const verdict = voiceHoldRef.current?.handleKey(event);

package/hay/apps/web/src/components/SessionSwitcher.tsx

@@ -37,6 +37,7 @@ import {
   type SwitcherSortMode,
   insertAfter, describeAccount, type AgentHome, type AgentHomes } from "../utils/switcherModel";
 import { scanKeyboardProtocol } from "../utils/keyboardProtocol";
+import { isAppCtrlEnter, isFullscreenChord } from "../utils/fullscreenChord";
 import { DigestCard } from "./DigestCard";
 import { hasUnseenViews, loadViewsSeen } from "./ViewsPanel";
 
@@ -693,10 +694,15 @@ const LiveTile = ({ wsBase, room, userName, theme, live, deliberate, claudeApp,
         if (ev.type === "keydown") sendInputRef.current?.("\x1b[13;2u");
         return false;
       }
-      if ((ev.metaKey || ev.ctrlKey) && !ev.altKey && !ev.shiftKey && ev.key === "Enter") {
+      // On a Mac only ⌘⏎ — Ctrl⏎ goes to the app (see fullscreenChord.ts).
+      if (isFullscreenChord(ev)) {
         if (ev.type === "keydown") onFullscreenRef.current();
         return false;
       }
+      if (isAppCtrlEnter(ev) && (kbdEnhancedRef.current || looksLikeClaude())) {
+        if (ev.type === "keydown") sendInputRef.current?.("\x1b[13;5u");
+        return false;
+      }
       if ((ev.metaKey || ev.ctrlKey) && !ev.altKey && !ev.shiftKey && ev.key === ".") {
         if (ev.type === "keydown") onUnfocusRef.current();
         return false;

package/hay/apps/web/src/utils/fullscreenChord.ts

@@ -0,0 +1,18 @@
+// The full-screen ⇄ wall chord inside a terminal. On a Mac it is ⌘⏎ only:
+// Ctrl⏎ belongs to the app (Claude Code binds it), and hop taking it meant
+// the keystroke never arrived. Elsewhere there is no ⌘, so Ctrl⏎ stays.
+export const IS_MAC = typeof navigator !== "undefined"
+  && /Mac|iPhone|iPad|iPod/.test(navigator.platform || navigator.userAgent || "");
+
+type Chord = { key: string; metaKey: boolean; ctrlKey: boolean; altKey: boolean; shiftKey: boolean };
+
+export function isFullscreenChord(ev: Chord, mac = IS_MAC): boolean {
+  if (ev.key !== "Enter" || ev.altKey || ev.shiftKey) return false;
+  return mac ? ev.metaKey && !ev.ctrlKey : ev.metaKey || ev.ctrlKey;
+}
+
+/** Ctrl⏎ passed to the app: CSI-u (13;5u), since xterm.js would send a bare \r. */
+export function isAppCtrlEnter(ev: Chord, mac = IS_MAC): boolean {
+  return ev.key === "Enter" && ev.ctrlKey && !ev.metaKey && !ev.altKey && !ev.shiftKey
+    && !isFullscreenChord(ev, mac);
+}

package/hay/apps/web/test/fullscreenChord.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from "vitest";
+import { isAppCtrlEnter, isFullscreenChord } from "../src/utils/fullscreenChord";
+
+const key = (mods: Partial<{ metaKey: boolean; ctrlKey: boolean; altKey: boolean; shiftKey: boolean }>, k = "Enter") =>
+  ({ key: k, metaKey: false, ctrlKey: false, altKey: false, shiftKey: false, ...mods });
+
+describe("full-screen chord", () => {
+  it("on a Mac only ⌘⏎ toggles; Ctrl⏎ is the app's", () => {
+    expect(isFullscreenChord(key({ metaKey: true }), true)).toBe(true);
+    expect(isFullscreenChord(key({ ctrlKey: true }), true)).toBe(false);
+    expect(isAppCtrlEnter(key({ ctrlKey: true }), true)).toBe(true);
+  });
+  it("without ⌘ (Windows/Linux) Ctrl⏎ still toggles", () => {
+    expect(isFullscreenChord(key({ ctrlKey: true }), false)).toBe(true);
+    expect(isAppCtrlEnter(key({ ctrlKey: true }), false)).toBe(false);
+  });
+  it("other chords are untouched", () => {
+    expect(isFullscreenChord(key({ metaKey: true, shiftKey: true }), true)).toBe(false);
+    expect(isFullscreenChord(key({}), true)).toBe(false);
+    expect(isAppCtrlEnter(key({ ctrlKey: true }, "a"), true)).toBe(false);
+  });
+});

package/hop

@@ -802,7 +802,18 @@ async function withLifecycleLock(op, fn, { waitMs = 120_000, onWait } = {}) {
 }
 // Marker so the authenticator setup QR is only shown on first run (UX only; no auth logic).
 const AUTH_QR_SHOWN_FILE = path.join(HOME_DIR, '.auth_qr_shown');
-const HAY_HOST_READY_TIMEOUT_MS = parsePositiveIntEnv('HOP_HAY_HOST_READY_TIMEOUT_MS', 5000);
+// A keeper-backed host re-adopts every running terminal (replaying each
+// screen) BEFORE it opens its port. With 30 rooms that took ~8 s, then ~41 s
+// once one replay timed out (2026-10-12), so first a 5 s and then a 25 s
+// limit killed each new host mid-adoption and spawned the next — a restart
+// loop that left hop with no host, and took the daemon down with it ("Fatal:
+// Hay host did not open its port in time") while a `hop restore` was in
+// flight, which the CLI reported as "socket hang up". This is now a ceiling,
+// not the expected wait: the spawner keeps waiting while the host process is
+// alive (see waitForHayHostPort), gives up early only once it has died, and
+// refreshes the spawn lock as it waits so a rival spawner never mistakes a
+// long adoption for a stale lock.
+const HAY_HOST_READY_TIMEOUT_MS = parsePositiveIntEnv('HOP_HAY_HOST_READY_TIMEOUT_MS', 180000);
 const HAY_HOST_DISCOVERY_CACHE_MS = parsePositiveIntEnv('HOP_HAY_HOST_DISCOVERY_CACHE_MS', 10000);
 const HAY_HOST_HOME_HASH = crypto.createHash('sha256').update(path.resolve(HOME_DIR)).digest('hex').slice(0, 24);
 const HAY_HOST_HOME_FLAG = `--hop-home-hash=${HAY_HOST_HOME_HASH}`;
@@ -9706,6 +9717,27 @@ async function stopExternalHayHostProcess(hostState, timeoutMs = 1500) {
     return !isProcessAlive(pid);
 }
 
+// Wait for a freshly spawned host to open its port. Adopting a big fleet from
+// the pty-keeper can take a minute or more, so the wait is bounded by the
+// host's LIFE first and the ceiling second: a host that dies returns at once
+// instead of burning the whole ceiling, and one still working keeps the spawn
+// lock's mtime fresh so a concurrent spawner (30 s staleness rule) never calls
+// the lock stale and starts a rival host mid-adoption.
+async function waitForHayHostPort(started, ceilingMs) {
+    const deadline = Date.now() + ceilingMs;
+    let lastLockTouch = 0;
+    while (Date.now() < deadline) {
+        if (await waitForPort(started.port, '127.0.0.1', 1000, 120)) return true;
+        if (!isProcessAlive(started.pid)) return false;
+        if (Date.now() - lastLockTouch > 5000) {
+            lastLockTouch = Date.now();
+            const now = new Date();
+            try { fs.utimesSync(HAY_HOST_SPAWN_LOCK, now, now); } catch (e) { /* lock gone — nothing to refresh */ }
+        }
+    }
+    return false;
+}
+
 function markExternalHayHostResponsive(host) {
     const recovered = hayHostProbeFailures.recordSuccess(Number(host?.pid));
     if (recovered) {
@@ -9832,6 +9864,9 @@ async function ensureExternalHayHostReadyOnce() {
                 if (spawned && isProcessAlive(spawned.pid) && await probeExternalHayHostFromHost(spawned, 1500)) {
                     return markExternalHayHostResponsive(spawned);
                 }
+                // The winner releases the lock on success and failure alike;
+                // once it is gone there is nothing left to wait for.
+                if (!fs.existsSync(HAY_HOST_SPAWN_LOCK)) break;
             }
             // Winner never delivered — fall through and spawn ourselves.
         }
@@ -9917,10 +9952,13 @@ async function ensureExternalHayHostReadyOnce() {
         throw new Error(`Hay host failed to start; see ${hayHostLogFile}`);
     }
 
-    const ready = await waitForPort(started.port, '127.0.0.1', HAY_HOST_READY_TIMEOUT_MS, 120);
+    const ready = await waitForHayHostPort(started, HAY_HOST_READY_TIMEOUT_MS);
     if (!ready) {
+        const died = !isProcessAlive(started.pid);
         await stopExternalHayHostProcess(started);
-        throw new Error(`Hay host did not open its port in time; see ${hayHostLogFile}`);
+        throw new Error(died
+            ? `Hay host (pid ${started.pid}) exited before opening its port; see ${hayHostLogFile}`
+            : `Hay host did not open its port within ${Math.round(HAY_HOST_READY_TIMEOUT_MS / 1000)}s (still adopting its terminals? HOP_HAY_HOST_READY_TIMEOUT_MS raises the ceiling); see ${hayHostLogFile}`);
     }
     const healthy = await probeExternalHayHostFromHost(started, 1500);
     if (!healthy) {
@@ -17559,7 +17597,13 @@ async function main() {
         try {
             res = await callLocalApi(state, '/api/sessions/restore', 'POST', { dryRun, includeAgents, only: only.length ? only : undefined });
         } catch (e) {
-            log(`Restore request failed: ${e.message}`, RED);
+            // "socket hang up" here means the daemon closed the connection
+            // without answering: it was restarted, or died (e.g. its host
+            // never came up), while the restore was in flight. Nothing about
+            // the restore itself failed, so say what to do next.
+            const gone = !isServerRunning();
+            log(`Restore request failed: ${e.message}${gone ? ' — the daemon went away mid-request' : ''}.`, RED);
+            log(`  ${DIM}Check ${CYAN}hop logs${RESET}${DIM} (look for "Fatal:" or "Cleaning up"), then run ${CYAN}hop restore${RESET}${DIM} again — it only recreates sessions that are not running.${RESET}`, RESET);
             process.exit(1);
         }
         if (!res || res.status < 200 || res.status >= 300) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hop2",
-  "version": "0.11.76",
+  "version": "0.11.77",
   "description": "🐰 Hop into your terminal from anywhere. Secure remote shell access with 2FA via Cloudflare Tunnel. Next-gen rewrite with native terminal sharing.",
   "main": "hop",
   "bin": {

package/scripts/hay-host.js

@@ -91,10 +91,19 @@ function loadViewerColors(hay) {
         if (typeof hay.setDefaultViewerColors === 'function') hay.setDefaultViewerColors(saved.bg, saved.fg);
     } catch (e) { /* none yet: the dark default */ }
 }
+// Compared against what is on disk, not setDefaultViewerColors' "changed":
+// room.setClientColors already updates the defaults before this runs, so
+// that always said "unchanged" and the file was never written — every host
+// restart went back to the dark default (Codex's charcoal composer).
+let savedViewerColors = null;
 function rememberViewerColors(hay, bg, fg) {
     if (typeof hay.setDefaultViewerColors !== 'function') return;
-    if (!hay.setDefaultViewerColors(bg, fg)) return;
-    try { fs.writeFileSync(VIEWER_COLORS_FILE, JSON.stringify(hay.getDefaultViewerColors())); } catch (e) { /* best effort */ }
+    hay.setDefaultViewerColors(bg, fg);
+    const json = JSON.stringify(hay.getDefaultViewerColors());
+    if (savedViewerColors === null) { try { savedViewerColors = fs.readFileSync(VIEWER_COLORS_FILE, 'utf8'); } catch (e) { savedViewerColors = ''; } }
+    if (json === savedViewerColors) return;
+    try { fs.writeFileSync(VIEWER_COLORS_FILE, json); savedViewerColors = json; } catch (e) { /* best effort */ }
+}
 const CLAUDE_SESSIONS_DIR = path.join(HOP_HOME, 'claude-sessions');
 
 // Scrub Claude Code SESSION markers from our environment before any PTY is
@@ -153,9 +162,29 @@ const watchedRooms = new WeakSet();
 // restore <name>`): their records must survive the close, exactly as they
 // survive a host shutdown. Consumed once, on the next session_end.
 const preserveRecordsOnClose = new Set();
+// Each room's terminal modes (Room.modePrefix), saved as they change so a
+// re-adopted room starts in them: an app turns alternate screen and mouse
+// reporting on once, at startup, which a bounded replay no longer holds.
+const ROOM_MODES_DIR = path.join(HOP_HOME, 'room-modes');
+const roomModesFile = (id) => path.join(ROOM_MODES_DIR, `${id}.modes`);
+function loadRoomModes(id) {
+    if (!/^[A-Za-z0-9_.-]+$/.test(String(id || ''))) return '';
+    try { return fs.readFileSync(roomModesFile(id), 'utf8'); } catch (e) { return ''; }
+}
+function saveRoomModes(id, prefix) {
+    try {
+        if (!prefix) { fs.unlinkSync(roomModesFile(id)); return; }
+        fs.mkdirSync(ROOM_MODES_DIR, { recursive: true });
+        fs.writeFileSync(roomModesFile(id), prefix);
+    } catch (e) { /* best effort */ }
+}
 function watchRoomEnd(room) {
     if (!room || typeof room.on !== 'function' || watchedRooms.has(room)) return room;
     watchedRooms.add(room);
+    if (/^[A-Za-z0-9_.-]+$/.test(String(room.id || ''))) {
+        room.on('modes', (prefix) => saveRoomModes(String(room.id), String(prefix || '')));
+        if (typeof room.modePrefix === 'function') saveRoomModes(String(room.id), room.modePrefix());
+    }
     room.on('session_end', () => {
         if (shuttingDown) return;
         const id = String(room.id || '');
@@ -168,6 +197,7 @@ function watchRoomEnd(room) {
         // request to forget its conversation; that is an explicit delete's
         // job, daemon-side.
         try { fs.unlinkSync(path.join(BUFFER_DIR, `${id}.raw`)); } catch (e) { /* best effort */ }
+        try { fs.unlinkSync(roomModesFile(id)); } catch (e) { /* best effort */ }
     });
     return room;
 }