@idl3/claude-control 1.1.0 → 1.4.3

package/lib/pane-registry.js

@@ -12,6 +12,20 @@ import os from 'node:os';
 
 const PANES_DIR = path.join(os.homedir(), '.claude-control', 'panes');
 
+/**
+ * Reset GC state. Exported FOR TESTS ONLY; current GC is transcript-existence
+ * based and has no mutable state, so this is intentionally a no-op.
+ */
+export function _resetGcStateForTest() {
+  // no-op
+}
+
+/** %5 → "5"; tolerate any tmux pane-id form, keep it filename-safe. */
+function paneFile(tmuxPane, dir = PANES_DIR) {
+  const safe = String(tmuxPane || '').replace(/[^A-Za-z0-9_-]/g, '');
+  return safe ? path.join(dir, `${safe}.json`) : null;
+}
+
 /**
  * @typedef {Object} PaneRecord
  * @property {string}      paneId          tmux %N (matches a pane's paneId)
@@ -55,31 +69,65 @@ export async function readPaneRegistry(dir = PANES_DIR) {
 }
 
 /**
- * Remove registry files for panes that no longer exist (best-effort GC, e.g.
- * when SessionEnd didn't fire on a crash). `livePaneIds` is the set of tmux %N
- * currently present.
+ * Persist an exact pane→transcript binding for transports that discover the
+ * rollout path programmatically instead of via Claude's hook.
  *
- * @param {Set<string>} livePaneIds
+ * @param {{paneId:string, sessionId?:string|null, transcriptPath:string, cwd?:string|null}} rec
+ * @param {string} [dir] Override the registry dir (tests).
  * @returns {Promise<void>}
  */
-export async function gcPaneRegistry(livePaneIds) {
+export async function writePaneRegistryRecord(rec, dir = PANES_DIR) {
+  if (!rec || typeof rec.paneId !== 'string' || typeof rec.transcriptPath !== 'string') return;
+  const file = paneFile(rec.paneId, dir);
+  if (!file) return;
+  await fsp.mkdir(dir, { recursive: true }).catch(() => {});
+  const record = {
+    paneId: rec.paneId,
+    sessionId: rec.sessionId ?? null,
+    transcriptPath: rec.transcriptPath,
+    cwd: rec.cwd ?? null,
+    ts: Date.now(),
+  };
+  await fsp.writeFile(file, JSON.stringify(record), { mode: 0o600 });
+}
+
+/**
+ * Remove registry files whose transcript files no longer exist.
+ *
+ * It deliberately does NOT use the live tmux pane set. That scan flickers
+ * (transient `list-panes` hiccups, a session momentarily not enumerated on a
+ * busy socket), and a flaky "pane absent" reading looks identical to a genuine
+ * pane close — so keying deletion off it wrongly nukes pins for panes that are
+ * very much alive (the long-lived window-1 binding kept vanishing this way).
+ *
+ * A pin for a closed pane whose transcript still lingers is harmless: there is
+ * no live pane to bind it to, and if the pane id is later reused the hook
+ * overwrites the file. It self-expires here once its transcript is removed.
+ *
+ * @param {string} [dir] Override registry dir (tests).
+ * @returns {Promise<void>}
+ */
+export async function gcPaneRegistry(dir = PANES_DIR) {
   let entries;
   try {
-    entries = await fsp.readdir(PANES_DIR);
+    entries = await fsp.readdir(dir);
   } catch {
     return;
   }
+
   await Promise.all(
     entries
       .filter((f) => f.endsWith('.json'))
       .map(async (f) => {
         try {
-          const rec = JSON.parse(await fsp.readFile(path.join(PANES_DIR, f), 'utf8'));
-          if (rec && typeof rec.paneId === 'string' && !livePaneIds.has(rec.paneId)) {
-            await fsp.rm(path.join(PANES_DIR, f), { force: true });
+          const filePath = path.join(dir, f);
+          const rec = JSON.parse(await fsp.readFile(filePath, 'utf8'));
+          if (!rec || typeof rec.transcriptPath !== 'string') return;
+          if (!fs.existsSync(rec.transcriptPath)) {
+            await fsp.rm(filePath, { force: true }); // transcript gone → stale
           }
         } catch {
-          // ignore
+          // ignore unreadable/partial files
         }
       }),
   );

package/lib/prompt.js

@@ -15,16 +15,24 @@ function stripAnsi(s) {
 }
 
 // A numbered option line, optionally preceded by the TUI cursor (❯/›).
-const OPTION_RE = /^\s*([❯›]?)\s*(\d)[.)]\s+(.+?)\s*$/;
+// `\d+` (not `\d`) so pickers with ≥10 rows parse their two-digit numbers.
+const OPTION_RE = /^\s*([❯›]?)\s*(\d+)[.)]\s+(.+?)\s*$/;
 // A checkbox marker at the START of an option label, e.g. "[ ] Label" or "[x] Label".
 // Matches the bracket content: space = unchecked; x/✓/✗ = checked.
 const CHECKBOX_RE = /^\[([✓x✗ ])\]\s*(.*)/;
-// The footer real Claude Code prompts render under the options.
-const ESC_HINT_RE = /\besc\b[^\n]*(cancel|interrupt|exit|reject|keep|quit)|ctrl\+[a-z]\b/i;
-// How many lines from the bottom to consider — the active prompt always renders
-// at the bottom of the pane, so a numbered list higher up (assistant prose) is
-// out of scope.
-const BOTTOM_REGION = 26;
+// The footer a real Claude Code SELECTION prompt renders under the options.
+// Deterministically EXCLUDES "esc to interrupt" — that is the working-state
+// footer (Claude is generating), not a prompt. A numbered list in assistant
+// prose shown while Claude works would otherwise false-positive as a prompt.
+// Real selection prompts say "esc to cancel / reject / keep".
+const ESC_HINT_RE = /\besc\b[^\n]*(cancel|reject|keep)/i;
+// How many lines from the bottom to consider. The active prompt always renders
+// at the bottom of the pane; the cursor/Esc-footer guard (not this window) is
+// what rejects assistant prose, so this can be generous. It must be large
+// enough to contain a tall AskUserQuestion (long question + 5 options each with
+// a multi-line description + footer) — otherwise the question + first options
+// scroll out and the header heuristic grabs an option-description fragment.
+const BOTTOM_REGION = 80;
 const MAX_LABEL = 80;
 
 /**
@@ -104,25 +112,56 @@ export function parsePanePrompt(capture) {
   // Require a genuine interactive-prompt signal — not just numbered prose.
   if (!hasCursor && !hasEsc) return null;
 
-  // Question = the contiguous non-empty block immediately above the options (the
-  // prompt can wrap onto several lines), joined into one string.
-  const qLines = [];
-  for (let i = firstLine - 1; i >= 0 && i >= firstLine - 4; i--) {
-    const t = lines[i].trim();
-    if (!t) break;
-    qLines.unshift(t);
+  // Question = the contiguous block above the option run. Only trust it when the
+  // run starts at key 1 — i.e. the WHOLE picker is in view. If it starts higher
+  // (1/2 scrolled off despite the large window), the lines above the first
+  // visible option are a prior option's wrapped DESCRIPTION, not the question, so
+  // we emit no header rather than a misleading fragment.
+  let question = null;
+  if (Number(options[0].key) === 1) {
+    let i = firstLine - 1;
+    while (i >= 0 && !lines[i].trim()) i--; // skip the blank separator(s)
+    const qLines = [];
+    for (; i >= 0; i--) {
+      const t = lines[i].trim();
+      if (!t) break; // stop at the blank above the question block
+      if (OPTION_RE.test(lines[i])) break; // don't bleed into a prior option
+      qLines.unshift(t);
+    }
+    question = qLines.join(' ').slice(0, 400) || null;
   }
-  const question = qLines.join(' ').slice(0, 240);
+
+  // Each option may carry a wrapped DESCRIPTION — the indented sub-text the TUI
+  // renders under the label (e.g. "Tear down the proxy/gateway…"). It lives on
+  // the contiguous non-blank lines between this option's line and the next
+  // option's line (or the footer), so capture those so the cockpit shows the
+  // same context the TUI does instead of just the bare label.
+  const descFor = (idx) => {
+    const start = options[idx].line + 1;
+    const end = idx + 1 < options.length ? options[idx + 1].line : lines.length;
+    const out = [];
+    for (let i = start; i < end; i++) {
+      const t = lines[i].trim();
+      if (!t || OPTION_RE.test(lines[i]) || ESC_HINT_RE.test(lines[i])) break;
+      out.push(t);
+    }
+    const desc = out.join(' ').slice(0, 300);
+    return desc || undefined;
+  };
 
   const hasCheckboxes = options.some((o) => o.checked !== undefined);
   return {
     question: question || 'Make a selection',
     ...(hasCheckboxes ? { multiSelect: true } : {}),
-    options: options.map((o) => ({
-      key: o.key,
-      label: o.label,
-      selected: o.cursor,
-      ...(o.checked !== undefined ? { checked: o.checked } : {}),
-    })),
+    options: options.map((o, idx) => {
+      const description = descFor(idx);
+      return {
+        key: o.key,
+        label: o.label,
+        selected: o.cursor,
+        ...(description ? { description } : {}),
+        ...(o.checked !== undefined ? { checked: o.checked } : {}),
+      };
+    }),
   };
 }