hop2 0.11.84 → 0.11.85

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

@@ -362,8 +362,8 @@ const PHONE_ICONS: Record<string, string> = {
   moon: "M20 14.5A8 8 0 0 1 9.5 4 8 8 0 1 0 20 14.5z",
   gear: "M12 9a3 3 0 1 0 0 6 3 3 0 0 0 0-6zM12 2v3M12 19v3M2 12h3M19 12h3M4.9 4.9l2.1 2.1M17 17l2.1 2.1M4.9 19.1L7 17M17 7l2.1-2.1"
 };
-const PhoneIcon = ({ name }: { name: string }) => (
-  <svg width="20" height="20" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.7" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
+const PhoneIcon = ({ name, size = 20 }: { name: string; size?: number }) => (
+  <svg width={size} height={size} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="1.7" strokeLinecap="round" strokeLinejoin="round" aria-hidden="true">
     <path d={PHONE_ICONS[name] || ""} />
   </svg>
 );
@@ -3703,14 +3703,14 @@ export const SessionSwitcher = ({
           {onOpenDesktop && (
             <button type="button" className="switcher-action views-entry" aria-label="Remote desktop"
                     title="This machine's screen, through hop" onClick={() => onOpenDesktop()}>
-              <span aria-hidden="true">🖥</span>
+              <span className="switcher-action-icon"><PhoneIcon name="display" size={15} /></span>
               Desktop
             </button>
           )}
           {onOpenCheckbacks && scheduledTotal > 0 && (
             <button type="button" className="switcher-action views-entry" aria-label="Scheduled on every session"
                     title="Every check-back hop will type, across your sessions" onClick={() => onOpenCheckbacks("*")}>
-              <span aria-hidden="true">⏰</span>
+              <span className="switcher-action-icon"><PhoneIcon name="clock" size={15} /></span>
               Scheduled
               <span className="views-entry-count">{scheduledTotal}</span>
             </button>

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

@@ -481,9 +481,10 @@ export const ViewsPanel = ({ session, item, sessions = [], dock = false, onClose
         onMouseLeave={() => setArmedDelete((a) => (a === item.path ? null : a))}
       >
         {isImage(item.name)
-          // The file is its own thumbnail — one lazy request, and a list of
-          // plots becomes scannable at a glance.
-          ? <img className="views-thumb" src={item.path} loading="lazy" alt="" />
+          // A small server-made thumbnail (the daemon falls back to the file
+          // itself): a list of plots scannable at a glance, without pulling
+          // every full image through the tunnel to draw it.
+          ? <img className="views-thumb" src={item.path.replace(/\/inline$/, "/thumb")} loading="lazy" decoding="async" alt="" />
           : <span className="views-kind" aria-hidden="true">{kindOf(item.name, item.kind)}</span>}
         <span className="views-row-text">
           <span className="views-title">{item.title || item.name}</span>

package/hay/apps/web/src/styles.css

@@ -5824,3 +5824,5 @@ body.pane-dragging { user-select: none; }
   color: var(--accent);
   cursor: pointer;
 }
+/* Line icons in the wall's header buttons sit on the text like its glyphs. */
+.switcher-action-icon { display: inline-flex; align-items: center; opacity: 0.85; }

package/hop

@@ -2746,6 +2746,60 @@ function saveHopConfig(config) {
     writePrivateFile(HOP_CONFIG_FILE, JSON.stringify(config, null, 2));
 }
 
+// --- View thumbnails ---
+// Small JPEGs for the Views list, made once per file version with macOS's
+// sips (ImageMagick elsewhere, when installed) and kept under the hop home.
+// A few at a time: a list opening asks for a screenful at once. No tool, or
+// a failure → null, and the caller serves the file itself as before.
+const VIEW_THUMB_DIR = path.join(HOME_DIR, 'cache', 'view-thumbs');
+const VIEW_THUMB_PX = 160;
+const VIEW_THUMB_EXTS = new Set(['.png', '.jpg', '.jpeg', '.gif', '.webp', '.heic', '.tif', '.tiff', '.bmp']);
+const viewThumbQueue = [];
+const viewThumbWaiting = new Map();
+let viewThumbRunning = 0;
+let viewThumbTool;
+function findViewThumbTool() {
+    if (viewThumbTool !== undefined) return viewThumbTool;
+    const has = (bin) => { try { execFileSync('which', [bin], { stdio: 'ignore' }); return true; } catch (e) { return false; } };
+    viewThumbTool = process.platform === 'darwin' && has('sips') ? 'sips' : has('magick') ? 'magick' : has('convert') ? 'convert' : null;
+    return viewThumbTool;
+}
+function viewThumbnail(file, done) {
+    const ext = path.extname(file).toLowerCase();
+    const tool = VIEW_THUMB_EXTS.has(ext) ? findViewThumbTool() : null;
+    if (!tool) { done(null); return; }
+    let st;
+    try { st = fs.statSync(file); } catch (e) { done(null); return; }
+    const key = crypto.createHash('sha1').update(`${file}\0${st.size}\0${st.mtimeMs}`).digest('hex');
+    const out = path.join(VIEW_THUMB_DIR, key + '.jpg');
+    if (fs.existsSync(out)) { done(out); return; }
+    if (viewThumbWaiting.has(out)) { viewThumbWaiting.get(out).push(done); return; }
+    viewThumbWaiting.set(out, [done]);
+    viewThumbQueue.push({ file, out, tool });
+    pumpViewThumbs();
+}
+function pumpViewThumbs() {
+    while (viewThumbRunning < 3 && viewThumbQueue.length) {
+        const { file, out, tool } = viewThumbQueue.shift();
+        viewThumbRunning++;
+        try { fs.mkdirSync(VIEW_THUMB_DIR, { recursive: true }); } catch (e) { /* the write below fails */ }
+        const tmp = `${out}.${process.pid}.tmp.jpg`;
+        const args = tool === 'sips'
+            ? ['-Z', String(VIEW_THUMB_PX), '-s', 'format', 'jpeg', '-s', 'formatOptions', '70', file, '--out', tmp]
+            : (tool === 'magick' ? ['convert'] : []).concat([`${file}[0]`, '-thumbnail', `${VIEW_THUMB_PX}x${VIEW_THUMB_PX}>`, '-quality', '70', tmp]);
+        execFile(tool === 'magick' ? 'magick' : tool, args, { timeout: 15000 }, (err) => {
+            viewThumbRunning--;
+            let result = null;
+            if (!err) { try { fs.renameSync(tmp, out); result = out; } catch (e) { /* none */ } }
+            try { fs.unlinkSync(tmp); } catch (e) { /* renamed or never made */ }
+            const waiters = viewThumbWaiting.get(out) || [];
+            viewThumbWaiting.delete(out);
+            for (const w of waiters) { try { w(result); } catch (e) { /* the response went away */ } }
+            pumpViewThumbs();
+        });
+    }
+}
+
 // --- Remote desktop ---
 // hop carries a VNC server that is already on the machine (macOS Screen
 // Sharing, or x11vnc/wayvnc on Linux) through its own authenticated link:
@@ -7731,6 +7785,11 @@ async function restoreSavedSessionsUnlocked({ dryRun = false, includeAgents = fa
     if (refiled.length) log(`${dryRun ? 'Would re-file' : 'Re-filed'} ${refiled.length} session(s) into their folders from the identity snapshot.`, DIM);
     const snapshot = await listAllSessionEntriesRuntimeFirst();
     const live = new Set(snapshot.entries.filter((e) => e.live).map((e) => e.internalName));
+    // The host cuts room ids to 32 characters, so a record filed under a
+    // longer name (forks named after their source did this) belongs to the
+    // room with the cut name; while that runs, the record is not a dead
+    // session to bring back.
+    const isLive = (name) => live.has(name) || (name.length > 32 && live.has(name.slice(0, 32)));
     // Targeted redo (`hop restore <name>...`): the named sessions are planned
     // even when live - a failed restore leaves a LIVE room (bare shell,
     // parked dialog), which is exactly what a fleet restore skips, so the
@@ -7787,14 +7846,14 @@ async function restoreSavedSessionsUnlocked({ dryRun = false, includeAgents = fa
         // angler-codex-claude-codex, 2026-10-12). Let the old ones go first.
         if (closedAny) await new Promise((r) => setTimeout(r, 2000));
     }
-    const candidates = snapshot.entries.filter((e) => e && e.type === 'terminal' && !live.has(e.internalName));
+    const candidates = snapshot.entries.filter((e) => e && e.type === 'terminal' && !isLive(e.internalName));
     // Primary source: the SessionStart-hook records. Add any recorded session that
     // isn't already live or covered by the store, so restore works even though the
     // workspace store is empty. restorePlanForSession() reads each record and turns
     // it into `claude --resume <sessionId>`.
     const known = new Set(candidates.map((e) => e.internalName));
     for (const rec of listClaudeSessionRecords()) {
-        if (live.has(rec.internalName) || known.has(rec.internalName)) continue;
+        if (isLive(rec.internalName) || known.has(rec.internalName)) continue;
         known.add(rec.internalName);
         candidates.push({
             internalName: rec.internalName,
@@ -7812,7 +7871,7 @@ async function restoreSavedSessionsUnlocked({ dryRun = false, includeAgents = fa
     // record, so after a HARD crash (no graceful-shutdown buffers) the meta's cwd
     // is its only trace — reopen a fresh shell there.
     for (const meta of listClaudeSessionMetas()) {
-        if (live.has(meta.internalName) || known.has(meta.internalName)) continue;
+        if (isLive(meta.internalName) || known.has(meta.internalName)) continue;
         if (!meta.cwd || typeof meta.cwd !== 'string') continue;
         known.add(meta.internalName);
         candidates.push({
@@ -12616,7 +12675,7 @@ happens until someone clicks it.
         // file name. The legacy /assets/view/<s>/<f> form redirects here, so
         // an edge-cached response is at worst a redirect, never the bytes.
         const viewMatch = (req.method === 'GET' || req.method === 'HEAD')
-            && parsedUrl.pathname.match(/^\/view\/([^/]+)\/([^/]+?)(\/inline|\/download)?$/);
+            && parsedUrl.pathname.match(/^\/view\/([^/]+)\/([^/]+?)(\/inline|\/download|\/thumb)?$/);
         if (viewMatch) {
             // /download: the stored file itself, as an attachment — the
             // markdown an agent wrote rather than the page it renders into,
@@ -12632,6 +12691,23 @@ happens until someone clicks it.
                 return;
             }
             const viewExt = path.extname(target).toLowerCase();
+            // /thumb: a small JPEG for the Views list. The list used to load
+            // every image whole as its own thumbnail — 39 MB through the
+            // tunnel to draw one screen of rows, with the view you picked
+            // queued behind it.
+            if (viewMatch[3] === '/thumb') {
+                viewThumbnail(target, (thumb) => {
+                    if (!thumb) {
+                        res.writeHead(302, { Location: `/view/${viewMatch[1]}/${viewMatch[2]}/inline` });
+                        res.end();
+                        return;
+                    }
+                    res.writeHead(200, { 'Content-Type': 'image/jpeg', 'Content-Length': fs.statSync(thumb).size, 'Cache-Control': 'private, max-age=86400' });
+                    if (req.method === 'HEAD') { res.end(); return; }
+                    fs.createReadStream(thumb).pipe(res);
+                });
+                return;
+            }
             // ?download=1 — the FILE, not the page: the bytes the agent
             // published, under their real name, as an attachment. Rendered
             // kinds (md/csv/json) come back raw here, not as the HTML the
@@ -13317,7 +13393,12 @@ happens until someone clicks it.
                         forkName = forkBase + suffix + n;
                         n += 1;
                     }
-                    const forkInternal = toInternalSessionName(forkName);
+                    // An opaque id like any new session's, not the name: the
+                    // host cuts room ids to 32 characters, so a long name ran
+                    // as a shorter room than its records were filed under,
+                    // and a later `hop restore` took the record for a dead
+                    // session and listed it as restored.
+                    const forkInternal = mintSessionInternalName();
 
                     let command;
                     let kind = 'shell';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hop2",
-  "version": "0.11.84",
+  "version": "0.11.85",
   "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/codex-notify-hook.js

@@ -22,7 +22,7 @@
 const fs = require("node:fs");
 const os = require("node:os");
 const path = require("node:path");
-const { spawn } = require("node:child_process");
+const { spawn, execFileSync } = require("node:child_process");
 
 function turnsDir() {
   const home = process.env.HOP_HOME || path.join(os.homedir(), ".hop2");
@@ -63,6 +63,32 @@ function resolveHopSession(dir, rootId, envSession) {
   return owners.length === 1 ? owners[0] : envSession;
 }
 
+// Codex's shared app-server daemon runs the notify of every thread it
+// serves with ITS OWN environment — the session that happened to start it.
+// One started inside one session filed another session's turns as its own,
+// so that record named the other conversation and `hop recover` there
+// brought the wrong one back. Under the daemon
+// HOP_SESSION says nothing about the thread. Codex runs this hook through
+// whatever notify chain is configured (Computer Use wraps it), so walk up
+// to the first codex process and look at how it runs.
+function underSharedCodexDaemon() {
+  let pid = process.ppid;
+  for (let i = 0; i < 8 && pid > 1; i++) {
+    let row = "";
+    let args = "";
+    try {
+      row = execFileSync("ps", ["-o", "ppid=,comm=", "-p", String(pid)], { encoding: "utf8", timeout: 2000 }).trim();
+      args = execFileSync("ps", ["-o", "args=", "-p", String(pid)], { encoding: "utf8", timeout: 2000 }).trim();
+    } catch { return false; }
+    const m = /^(\d+)\s+(.*)$/.exec(row);
+    if (!m) return false;
+    // The executable itself, not any command line that mentions it.
+    if (path.basename(m[2]) === "codex") return /\sapp-server(\s|$)/.test(args);
+    pid = Number(m[1]);
+  }
+  return false;
+}
+
 // A sub-agent's rollout names its parent in its first line (session_meta →
 // parent_thread_id). Walk up to the root, reading only that line of each
 // file — a long thread's rollout runs to hundreds of MB. Any failure leaves
@@ -114,7 +140,10 @@ function bumpTurn(payload) {
              : (payload && typeof payload.thread_id === "string") ? payload.thread_id
              : (payload && typeof payload.session_id === "string") ? payload.session_id : null;
   let rootId = rootThreadId(rawThread);
-  const hopSession = resolveHopSession(dir, rootId, envSession);
+  // Under the shared daemon the environment is another session's: the
+  // turn goes only to a record that already names this thread, else nowhere.
+  const hopSession = underSharedCodexDaemon() ? resolveHopSession(dir, rootId, null) : resolveHopSession(dir, rootId, envSession);
+  if (!hopSession) return;
   const file = path.join(dir, `${hopSession}.turn`);
   let count = 0;
   let prev = null;

package/tests/codex-notify-hook.unit.test.cjs

@@ -61,3 +61,40 @@ test('other event types count nothing', () => {
   run(home, 'alpha', { type: 'something-else', 'thread-id': 'thread-A' });
   assert.equal(turn(home, 'alpha'), null);
 });
+
+// Codex's shared app-server daemon runs every thread's notify with the
+// environment of whichever session started it. A parent whose command line
+// says app-server stands in for it here.
+// The daemon is an executable named codex running `app-server`: a copy of
+// node under that name, running the hook, stands in for it.
+const runAsDaemon = (home, session, json) => {
+  const bin = path.join(home, 'bin'); fs.mkdirSync(bin, { recursive: true });
+  const codex = path.join(bin, 'codex');
+  if (!fs.existsSync(codex)) fs.symlinkSync(process.execPath, codex);
+  const script = path.join(bin, 'daemon.js');
+  fs.writeFileSync(script, 'require("child_process").execFileSync(process.execPath, process.argv.slice(3), { stdio: "inherit" })');
+  return require('node:child_process').spawnSync(codex, [script, 'app-server', HOOK, json], {
+    env: { ...process.env, HOP_HOME: home, HOP_SESSION: session, CODEX_HOME: path.join(home, 'codex') }
+  });
+};
+
+test("under Codex's shared daemon a turn is not filed against the daemon's session", () => {
+  const home = freshHome();
+  saveRollout(home, 'thread-starter'); saveRollout(home, 'thread-other');
+  fs.writeFileSync(path.join(home, 'claude-sessions', 'starter.turn'), JSON.stringify({ sessionId: 'thread-starter', count: 4, at: '2026-10-14T00:00:00.000Z', agent: 'codex' }));
+  fs.writeFileSync(path.join(home, 'claude-sessions', 'other.turn'), JSON.stringify({ sessionId: 'thread-other', count: 7, at: '2026-10-14T00:00:00.000Z', agent: 'codex' }));
+  // Another session's thread finishes a turn inside the daemon the starter session started.
+  const daemon = runAsDaemon(home, 'starter', JSON.stringify({ type: 'agent-turn-complete', 'thread-id': 'thread-other', 'turn-id': 't1' }));
+  assert.equal(daemon.status, 0, String(daemon.stderr));
+  assert.equal(turn(home, 'starter').sessionId, 'thread-starter', "the starter's record keeps its own thread");
+  assert.equal(turn(home, 'starter').count, 4, 'and is not counted');
+  assert.equal(turn(home, 'other').count, 8, 'the turn goes to the record that names the thread');
+});
+
+test('under the shared daemon a thread no record names is filed nowhere', () => {
+  const home = freshHome();
+  saveRollout(home, 'thread-new');
+  const daemon = runAsDaemon(home, 'starter', JSON.stringify({ type: 'agent-turn-complete', 'thread-id': 'thread-new', 'turn-id': 't1' }));
+  assert.equal(daemon.status, 0, String(daemon.stderr));
+  assert.equal(turn(home, 'starter'), null, 'no record is invented for the daemon session');
+});

package/tests/terminal-api.integration.test.cjs

@@ -1055,7 +1055,7 @@ test('a session whose display name has spaces can be renamed and forked', async
     internalName: internal
   });
   assert.equal(fork.status, 200, JSON.stringify(fork.data));
-  assert.match(fork.data.internalName, /^[A-Za-z0-9_-]+$/);
+  assert.match(fork.data.internalName, /^s_[0-9a-f]{10}$/, 'a fork gets an opaque id, not its (possibly long) name');
 
   const rename = await requestJson(state.port, state.sessionSecret, 'POST', '/api/sessions/rename', {
     oldName: 'Find grant opportunities', newName: 'grant-search', internalName: internal
@@ -1069,6 +1069,37 @@ test('a session whose display name has spaces can be renamed and forked', async
 });
 
 
+// The host cuts room ids to 32 characters. A record filed under a longer
+// name belongs to the room with the cut name, and while that room runs,
+// restore must not plan the record as a dead session.
+test('restore does not take a long-named record for dead while its cut room runs', async () => {
+  const dir = path.join(hopHome, 'claude-sessions');
+  await fs.mkdir(dir, { recursive: true });
+  const cut = 'longnamerecordcheck-abcdefghijkl'; // 32 characters
+  const long = cut + '-continued';
+  assert.equal(cut.length, 32);
+  await fs.writeFile(path.join(dir, `${cut}.meta`), JSON.stringify({ internalName: cut, cwd: tempDir }), { mode: 0o600 });
+  const up = await requestJson(state.port, state.sessionSecret, 'POST', '/api/sessions/restore', { only: [cut] });
+  assert.equal(up.status, 200, JSON.stringify(up.data));
+  let running = false;
+  for (let i = 0; i < 40 && !running; i++) {
+    const list = await requestJson(state.port, state.sessionSecret, 'GET', '/api/sessions');
+    running = !!list.data.sessions.find((x) => x.internalName === cut && x.live !== false);
+    if (!running) await delay(150);
+  }
+  assert.ok(running, 'the 32-character room is up');
+
+  await fs.writeFile(path.join(dir, `${long}.meta`), JSON.stringify({ internalName: long, displayName: long, cwd: tempDir }), { mode: 0o600 });
+  const plan = await requestJson(state.port, state.sessionSecret, 'POST', '/api/sessions/restore', { dryRun: true });
+  assert.equal(plan.status, 200, JSON.stringify(plan.data));
+  const names = (plan.data.restored || []).map((x) => x.name);
+  assert.ok(!names.includes(long), `planned the live session again: ${names.join(', ')}`);
+
+  await requestJson(state.port, state.sessionSecret, 'POST', '/api/sessions/delete', { name: cut, internalName: cut });
+  await fs.rm(path.join(dir, `${long}.meta`), { force: true });
+});
+
+
 // A session continued from the Codex app has no turn record until its first
 // turn finishes in hop — and until then Continue-in-Claude refused it as a
 // plain shell. Its record names the app thread, and that thread's rollout
@@ -1526,3 +1557,45 @@ test('the desktop pipe is off by default and, once on, carries bytes both ways',
     vnc.close();
   }
 });
+
+test('a view image has a small thumbnail; other kinds fall back to the file', async () => {
+  const dir = path.join(hopHome, 'views', 'thumbprobe');
+  await fs.mkdir(dir, { recursive: true });
+  // A 400x300 PNG, written by hand: one solid-colour row repeated.
+  const zlib = require('node:zlib');
+  const w = 400, h = 300;
+  const crc = (buf) => { let c = ~0; for (const b of buf) { c ^= b; for (let k = 0; k < 8; k++) c = (c >>> 1) ^ (0xedb88320 & -(c & 1)); } return ~c >>> 0; };
+  const chunk = (type, data) => { const len = Buffer.alloc(4); len.writeUInt32BE(data.length); const td = Buffer.concat([Buffer.from(type), data]); const c = Buffer.alloc(4); c.writeUInt32BE(crc(td)); return Buffer.concat([len, td, c]); };
+  const ihdr = Buffer.alloc(13); ihdr.writeUInt32BE(w, 0); ihdr.writeUInt32BE(h, 4); ihdr[8] = 8; ihdr[9] = 2;
+  const row = Buffer.concat([Buffer.from([0]), Buffer.alloc(w * 3, 0x80)]);
+  const png = Buffer.concat([Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]), chunk('IHDR', ihdr),
+    chunk('IDAT', zlib.deflateSync(Buffer.concat(Array(h).fill(row)))), chunk('IEND', Buffer.alloc(0))]);
+  await fs.writeFile(path.join(dir, 'plot.png'), png);
+  await fs.writeFile(path.join(dir, 'notes.pdf'), Buffer.alloc(64, 1));
+  const get = (reqPath) => new Promise((resolve, reject) => {
+    const req = http.request({ hostname: '127.0.0.1', port: state.port, path: reqPath, method: 'GET',
+      headers: { Authorization: `Bearer ${state.sessionSecret}` } }, (res) => {
+      const parts = []; res.on('data', (d) => parts.push(d));
+      res.on('end', () => resolve({ status: res.statusCode, headers: res.headers, body: Buffer.concat(parts) }));
+    });
+    req.on('error', reject); req.end();
+  });
+  try {
+    const thumb = await get('/view/thumbprobe/plot.png/thumb');
+    if (thumb.status === 200) {
+      assert.equal(thumb.headers['content-type'], 'image/jpeg');
+      assert.ok(thumb.body.length < png.length, 'smaller than the image itself');
+      const again = await get('/view/thumbprobe/plot.png/thumb');
+      assert.deepEqual(again.body, thumb.body, 'served from the cache the second time');
+    } else {
+      // No image tool on this machine: the file itself, as before.
+      assert.equal(thumb.status, 302);
+      assert.equal(thumb.headers.location, '/view/thumbprobe/plot.png/inline');
+    }
+    const pdf = await get('/view/thumbprobe/notes.pdf/thumb');
+    assert.equal(pdf.status, 302);
+    assert.equal((await get('/view/thumbprobe/missing.png/thumb')).status, 404);
+  } finally {
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+});