hop2 0.11.61 → 0.11.63

package/hop

@@ -5530,6 +5530,48 @@ function findCodexRolloutById(sessionId) {
     return null;
 }
 
+/**
+ * The first line of a rollout (its session_meta), read WITHOUT loading the
+ * file — a long-lived codex thread runs to hundreds of MB.
+ */
+function readCodexRolloutMeta(file) {
+    let fd = null;
+    try {
+        fd = fs.openSync(file, 'r');
+        const buf = Buffer.alloc(64 * 1024);
+        const n = fs.readSync(fd, buf, 0, buf.length, 0);
+        const text = buf.toString('utf8', 0, n);
+        const line = text.slice(0, text.indexOf('\n') >= 0 ? text.indexOf('\n') : text.length);
+        const parsed = JSON.parse(line);
+        return parsed && parsed.type === 'session_meta' ? (parsed.payload || null) : null;
+    } catch (e) {
+        return null;
+    } finally {
+        if (fd !== null) { try { fs.closeSync(fd); } catch (e) { /* ignore */ } }
+    }
+}
+
+/**
+ * The thread `codex resume` must be given for a conversation: the ROOT. The
+ * notify hook records whichever thread finished a turn, and with multi-agent
+ * codex that is often a sub-agent (its rollout's session_meta carries a
+ * parent_thread_id); resuming a sub-agent is refused ("resume the parent
+ * first"), which stranded a restored session in a bare shell. Walk up to the
+ * root, reading only each rollout's first line. Unknown ids come back as given.
+ */
+function codexRootThreadId(sessionId) {
+    let id = sessionId;
+    for (let hops = 0; hops < 8 && id; hops++) {
+        const file = findCodexRolloutById(id);
+        if (!file) return id;
+        const meta = readCodexRolloutMeta(file);
+        const parent = meta && typeof meta.parent_thread_id === 'string' ? meta.parent_thread_id : null;
+        if (!parent || parent === id) return id;
+        id = parent;
+    }
+    return id;
+}
+
 // Find a transcript for a bare session id across every claude config root,
 // returning which root (= the CLAUDE_CONFIG_DIR to resume under) holds it.
 function findClaudeTranscriptById(sessionId) {
@@ -5947,6 +5989,26 @@ function rebuildClaudeLaunch(launchCmd) {
 // that project directory.
 function restorePlanForSession(entry) {
     let rec = readClaudeSessionRecord(entry.internalName);
+    // Codex has no SessionStart record; its notify hook leaves only the
+    // .turn naming the thread. Without this, every codex session came back
+    // as a bare shell with its conversation stranded.
+    if (!rec) {
+        const turn = readTurnInfo(entry.internalName);
+        if (turn && turn.agent === 'codex') {
+            const metaCwd = readClaudeSessionMeta(entry.internalName)?.cwd;
+            const cwd = metaCwd || entry.cwd;
+            // The hook may have named a sub-agent's thread; resume the root.
+            const rootId = codexRootThreadId(turn.sessionId);
+            if (!findCodexRolloutById(rootId)) {
+                return {
+                    command: null,
+                    cwd,
+                    warning: `recorded codex conversation ${String(turn.sessionId).slice(0, 8)}… has no rollout on this host — opening a plain shell instead`
+                };
+            }
+            return { command: `codex resume '${rootId.replace(/'/g, `'\\''`)}'`, cwd, agent: 'codex' };
+        }
+    }
     // No SessionStart record, but the turn counter may still name this room's
     // conversation (the two are written independently). Recover a record from
     // it when the transcript is real — otherwise this room would drop to a
@@ -6147,6 +6209,7 @@ function recordRestoreExpectations(planned) {
     const state = readRestoreReconcile();
     for (const p of planned || []) {
         if (!p || !p.internalName || !p.command) continue; // no claude command → nothing to converge
+        if (p.agent && p.agent !== 'claude') continue; // the reconciler only knows claude
         state.sessions[p.internalName] = {
             internalName: p.internalName,
             displayName: p.displayName || p.internalName,
@@ -6500,6 +6563,7 @@ async function restoreSavedSessionsUnlocked({ dryRun = false, includeAgents = fa
         displayName: e.displayName || e.internalName,
         cwd: plan.cwd || e.cwd || process.cwd(),
         command: plan.command,
+        agent: plan.agent || (plan.command ? 'claude' : null),
         warning: plan.warning || null,
         // Plain-shell sessions (no claude/startup command) replay their last
         // screen if we persisted a buffer for them at the previous shutdown.
@@ -6544,7 +6608,11 @@ async function restoreSavedSessionsUnlocked({ dryRun = false, includeAgents = fa
         } catch (e) {
             continue;
         }
-        if (p.command && entry) {
+        if (p.command && entry && p.agent !== 'claude') {
+            // The verifier below reads claude's chrome (and may re-type the
+            // command); a codex resume is launched as argv and left alone.
+            setTimeout(() => { try { closeTerminalApiEntry(entry.id); } catch (e) { /* ignore */ } }, 600);
+        } else if (p.command && entry) {
             // Launched with the command as argv: nothing to type — just
             // confirm it actually came up.
             pending.push({ plan: p, entry, state: 'verify', attempts: 1, since: Date.now() });
@@ -11681,7 +11749,7 @@ happens until someone clicks it.
                     // names the agent and the conversation — the process name
                     // says "node" and cannot), or a plain shell.
                     const turn = readTurnInfo(source);
-                    const codexId = turn?.agent === 'codex' ? turn.sessionId : null;
+                    const codexId = turn?.agent === 'codex' ? codexRootThreadId(turn.sessionId) : null;
                     const runsCodex = !!codexId
                         || /codex/i.test(String(config.foregroundProcess || ''))
                         || /codex/i.test(String(getRuntimeSessionMetadata(source)?.foregroundProcess || ''));
@@ -16201,23 +16269,22 @@ async function main() {
         }
 
         if (stopAll) {
-            // Order matters: session deletion needs the daemon, so close sessions
-            // first, then stop the daemon, then kill the hay-host process.
+            // Stop the daemon, then SIGTERM the hay-host. Sessions are NOT
+            // deleted: /api/sessions/delete is the explicit "forget this
+            // session" path (drops its config, display name, and restore
+            // records), so calling it here made every `stop --all` wipe the
+            // restore inventory — 2026-09-26 a full restart lost all 34 live
+            // sessions and `hop restore` found nothing of them. The host's
+            // graceful shutdown persists buffers and keeps every record.
             if (state) {
                 try {
                     const sessionsRes = await fetchSessionList(state);
                     const sessions = Array.isArray(sessionsRes?.sessions) ? sessionsRes.sessions : [];
-                    for (const s of sessions) {
-                        try {
-                            await callLocalApi(state, '/api/sessions/delete', 'POST', { name: s.name || s.internalName });
-                        } catch (e) { }
+                    const liveCount = sessions.filter((s) => s && s.live !== false).length;
+                    if (liveCount > 0) {
+                        log(`Ending ${liveCount} session(s) — restore records kept (${CYAN}hop restore${RESET}${GREEN} brings them back).`, GREEN);
                     }
-                    if (sessions.length > 0) {
-                        log(`Closed ${sessions.length} session(s).`, GREEN);
-                    }
-                } catch (e) {
-                    log(`Warning: could not close sessions via daemon: ${e.message}`, YELLOW);
-                }
+                } catch (e) { /* count is informational only */ }
                 try {
                     process.kill(state.pid, 'SIGTERM');
                     log(`Hop daemon stopped.`, GREEN);
@@ -16227,7 +16294,7 @@ async function main() {
                 }
             }
             if (hayHostAlive) {
-                const stopped = await stopExternalHayHostProcess(hayHost);
+                const stopped = await stopExternalHayHostProcess(hayHost, 8000);
                 if (!stopped) {
                     log(`Failed to stop hay-host (pid ${hayHost.pid}).`, RED);
                     process.exit(1);
@@ -16483,7 +16550,7 @@ async function main() {
             // by the newest rollout in this directory.
             const turn = readTurnInfo(target);
             const rollout = turn?.agent === 'codex' ? null : resolveCodexTranscriptByCwd(cwd);
-            const rolloutId = turn?.agent === 'codex' ? turn.sessionId : (rollout ? await trajectoryExtract.codexRolloutId(rollout) : null);
+            const rolloutId = turn?.agent === 'codex' ? codexRootThreadId(turn.sessionId) : (rollout ? await trajectoryExtract.codexRolloutId(rollout) : null);
             if (rolloutId) {
                 command = `codex resume '${rolloutId.replace(/'/g, `'\\''`)}'`;
                 kind = 'codex';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hop2",
-  "version": "0.11.61",
+  "version": "0.11.63",
   "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

@@ -31,6 +31,45 @@ function turnFilePath() {
   return path.join(dir, `${process.env.HOP_SESSION}.turn`);
 }
 
+// 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
+// the id as given; hop resolves it again at restore time.
+function findRollout(id) {
+  const root = path.join(os.homedir(), ".codex", "sessions");
+  const walk = (dir, depth) => {
+    let names = [];
+    try { names = fs.readdirSync(dir, { withFileTypes: true }); } catch { return null; }
+    for (const e of names) {
+      const p = path.join(dir, e.name);
+      if (e.isDirectory() && depth < 3) { const hit = walk(p, depth + 1); if (hit) return hit; }
+      else if (e.isFile() && e.name.endsWith(".jsonl") && e.name.includes(id)) return p;
+    }
+    return null;
+  };
+  return walk(root, 0);
+}
+function rootThreadId(id) {
+  let cur = id;
+  for (let hops = 0; hops < 8 && cur; hops++) {
+    const file = findRollout(cur);
+    if (!file) return cur;
+    let parent = null;
+    try {
+      const fd = fs.openSync(file, "r");
+      const buf = Buffer.alloc(65536);
+      const n = fs.readSync(fd, buf, 0, buf.length, 0);
+      fs.closeSync(fd);
+      const text = buf.toString("utf8", 0, n);
+      const meta = JSON.parse(text.slice(0, text.indexOf("\n") >= 0 ? text.indexOf("\n") : text.length));
+      parent = meta && meta.payload && typeof meta.payload.parent_thread_id === "string" ? meta.payload.parent_thread_id : null;
+    } catch { return cur; }
+    if (!parent || parent === cur) return cur;
+    cur = parent;
+  }
+  return cur;
+}
+
 // Same crash-safe write + same {sessionId, count, at} shape the Claude hook
 // uses, so hop's finishBump() reads one number regardless of which agent wrote.
 function bumpTurn(payload) {
@@ -42,12 +81,15 @@ function bumpTurn(payload) {
     const prev = JSON.parse(fs.readFileSync(file, "utf8"));
     if (prev && Number.isInteger(prev.count) && prev.count >= 0) count = prev.count;
   } catch { /* missing/corrupt -> start at 0 */ }
+  const threadId = (payload && typeof payload["thread-id"] === "string") ? payload["thread-id"]
+             : (payload && typeof payload.thread_id === "string") ? payload.thread_id
+             : (payload && typeof payload.session_id === "string") ? payload.session_id : null;
   const rec = JSON.stringify({
     // The thread id is the conversation (and the rollout file's name); the
-    // turn id names one turn and matches nothing on disk.
-    sessionId: (payload && typeof payload["thread-id"] === "string") ? payload["thread-id"]
-             : (payload && typeof payload.thread_id === "string") ? payload.thread_id
-             : (payload && typeof payload.session_id === "string") ? payload.session_id : null,
+    // turn id names one turn and matches nothing on disk. With multi-agent
+    // codex the thread that finished may be a SUB-agent, which cannot be
+    // resumed on its own — record the root, which can.
+    sessionId: rootThreadId(threadId),
     count: count + 1,
     at: new Date().toISOString(),
     agent: "codex"