@idl3/claude-control 1.1.0 → 1.4.3

package/lib/tmux.js

@@ -184,6 +184,9 @@ const FORMAT = [
   '#{pane_active}',
   '#{pane_id}',
   '#{@cc_shell}',
+  '#{@cc_agent}',
+  '#{@cc_transport}',
+  '#{@cc_endpoint}',
 ].join(SEP);
 
 /**
@@ -229,7 +232,23 @@ export async function listPanes() {
     const parts = trimmed.split(SEP);
     if (parts.length < 9) continue;
 
-    const [sessionName, rawIndex, windowName, rawActive, rawPid, cwd, cmd, windowId, rawPane, rawPaneActive, paneId, ccShell] = parts;
+    const [
+      sessionName,
+      rawIndex,
+      windowName,
+      rawActive,
+      rawPid,
+      cwd,
+      cmd,
+      windowId,
+      rawPane,
+      rawPaneActive,
+      paneId,
+      ccShell,
+      ccAgent,
+      ccTransport,
+      ccEndpoint,
+    ] = parts;
     const windowIndex = Number(rawIndex);
     const panePid = Number(rawPid);
     const paneIndex = Number(rawPane) || 0;
@@ -248,6 +267,9 @@ export async function listPanes() {
       paneIndex,
       paneId: paneId ?? null, // stable tmux %N — joins to $TMUX_PANE from the hook
       ccShell: ccShell === '1', // sister shell pane created for the composer >_
+      ccAgent: ccAgent || null,
+      ccTransport: ccTransport || null,
+      ccEndpoint: ccEndpoint || null,
     });
   }
 
@@ -379,7 +401,7 @@ export async function createWindow({ cwd, name } = {}, { _run, _listPanes } = {}
 
   // A server exists — create the window in the first existing session and read
   // back its "session:window" target via the -P/-F print format.
-  const targetSession = windows[0].sessionName;
+  const targetSession = `${windows[0].sessionName}:`;
   const args = [
     'new-window',
     '-t', targetSession,
@@ -482,20 +504,49 @@ export async function renameWindow(target, name) {
 // Send text (literal, with Enter)
 // ---------------------------------------------------------------------------
 
+/** Monotonic suffix so concurrent sends never collide on a tmux buffer name. */
+let _pasteBufferSeq = 0;
+
 /**
- * Send literal text to a tmux pane and then press Enter.
- * Uses `-l` so tmux does not interpret key names.
+ * Send text to a tmux pane as an atomic bracketed paste, then press Enter.
+ *
+ * Why not `send-keys -l text` + `send-keys Enter`: against a TUI (Claude/Codex,
+ * Ink-based) those two execs race — the Enter can land before the app has
+ * ingested the literal bytes, so the message sits unsent in the input box.
+ * Instead we stage the text in a tmux paste buffer and `paste-buffer -p`
+ * (bracketed paste), which the TUI ingests as one atomic unit, wait a short
+ * settle, THEN send a real Enter to submit. Bracketed paste also stops embedded
+ * newlines from prematurely submitting.
+ *
+ * Falls back to the old literal `send-keys` path if the buffer route errors, so
+ * behaviour never regresses below today's baseline.
  *
  * @param {string} target  e.g. "0:3"
  * @param {string} text
+ * @param {{ _run?: Function, _delay?: Function }} [_injected]  Test-only seam.
  * @returns {Promise<void>}
  */
-export async function sendText(target, text) {
+export async function sendText(target, text, { _run, _delay } = {}) {
   assertTarget(target);
-  // Step 1: literal text (no key interpretation)
-  await runTmux(['send-keys', '-t', target, '-l', text]);
-  // Step 2: press Enter
-  await runTmux(['send-keys', '-t', target, 'Enter']);
+  const runner = _run ?? runTmux;
+  const delay = _delay ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const SETTLE_MS = 90; // give the TUI time to commit the paste before Enter
+
+  const bufName = `cc-paste-${process.pid}-${_pasteBufferSeq++}`;
+  try {
+    // Stage the text in a named buffer (data passed as argv — no shell, no stdin).
+    await runner(['set-buffer', '-b', bufName, text]);
+    // Bracketed paste into the pane (-p), deleting the buffer after (-d).
+    await runner(['paste-buffer', '-d', '-p', '-b', bufName, '-t', target]);
+    // Let the paste land in the editable buffer before submitting.
+    await delay(SETTLE_MS);
+    await runner(['send-keys', '-t', target, 'Enter']);
+  } catch {
+    // Fallback to the legacy literal path (also clean up a possibly-orphaned buffer).
+    await runner(['delete-buffer', '-b', bufName]).catch(() => {});
+    await runner(['send-keys', '-t', target, '-l', text]);
+    await runner(['send-keys', '-t', target, 'Enter']);
+  }
 }
 
 /**
@@ -571,7 +622,7 @@ export async function sendRawKeysSequenced(target, keys, delayMs = 160) {
  * @param {{ _run?: Function }} [_injected]  Test-only seam; omit in production.
  * @returns {Promise<string>}
  */
-export async function capturePane(target, lines = 40, escapes = false, join = false, { _run } = {}) {
+export async function capturePane(target, lines = 40, escapes = false, join = false, { _run, visibleOnly = false } = {}) {
   assertTarget(target);
   const runner = _run ?? runTmux;
   const args = ['capture-pane', '-t', target, '-p'];
@@ -582,7 +633,13 @@ export async function capturePane(target, lines = 40, escapes = false, join = fa
   // `-J` rejoins soft-wrapped lines into logical lines so that a URL split
   // across narrow pane columns is reconstructed before the client linkifies it.
   if (join) args.push('-J');
-  args.push('-S', `-${lines}`); // start N lines above the visible area
+  // visibleOnly: capture ONLY the on-screen pane (no `-S`), never scrollback.
+  // Prompt/question detection MUST use this — a `-S -N` window pulls in an
+  // already-answered picker that scrolled into history (frozen WITH its ❯ cursor
+  // + "esc to cancel" footer), which re-fires the prompt after it was answered
+  // and lets stray numbered prose in history look like a live menu. The active
+  // picker always renders on the visible screen, so visible-only is sufficient.
+  if (!visibleOnly) args.push('-S', `-${lines}`); // start N lines above the visible area
   const { stdout } = await runner(args);
   return stdout;
 }

package/lib/transcribe.js

@@ -197,6 +197,6 @@ export async function transcribe(inputPath, { lang, _resolvers, _run } = {}) {
     ]);
     return cleanTranscript(stdout);
   } finally {
-    fs.promises.unlink(wav).catch(() => {});
+    await fs.promises.unlink(wav).catch(() => {});
   }
 }

package/lib/tui.js

@@ -29,10 +29,14 @@ const MODEL_RE = /\b(Opus|Sonnet|Haiku)\s+[\d.]+(?:\s*\([^)]*\))?/i;
 const THINKING_RE = /esc to interrupt/i;
 const WORKING_TIMER_RE = /…\s*\(\s*\d+\s*[smh]\b/;
 const THINKING_SCAN_LINES = 8;
+// Auto/manual compaction renders a distinct working line ("Compacting
+// conversation…"). It can run for many seconds with no other output, so without
+// a dedicated signal the UI looks hung. Treated as a busy sub-state of thinking.
+const COMPACTING_RE = /compacting\b/i;
 
 /**
  * @param {string} capture  raw `tmux capture-pane -p` output (ANSI ok)
- * @returns {{ ctxPct: number|null, model: string|null, thinking: boolean }}
+ * @returns {{ ctxPct: number|null, model: string|null, thinking: boolean, compacting: boolean }}
  */
 export function parseTuiStatus(capture) {
   const text = String(capture || '').replace(ANSI_RE, '');
@@ -53,9 +57,12 @@ export function parseTuiStatus(capture) {
   // area) do not produce a false positive after generation ends.
   const lines = text.split('\n');
   const tail = lines.slice(-THINKING_SCAN_LINES).join('\n');
-  const thinking = THINKING_RE.test(tail) || WORKING_TIMER_RE.test(tail);
+  const compacting = COMPACTING_RE.test(tail);
+  // Compaction IS a busy state — fold it into thinking so the rail still reads
+  // "working" even if the compaction line omits "esc to interrupt".
+  const thinking = compacting || THINKING_RE.test(tail) || WORKING_TIMER_RE.test(tail);
 
-  return { ctxPct, model, thinking };
+  return { ctxPct, model, thinking, compacting };
 }
 
 /**

package/lib/version.js

@@ -38,27 +38,63 @@ async function git(args) {
 
 let cache = { info: null, checkedAt: 0 };
 
+async function checkoutIdentity() {
+  const identity = {
+    root: ROOT,
+    branch: null,
+    commit: null,
+    dirty: null,
+  };
+  try {
+    const branch = await git(['rev-parse', '--abbrev-ref', 'HEAD']);
+    identity.branch = branch && branch !== 'HEAD' ? branch : null;
+  } catch {
+    // not a git checkout
+  }
+  try {
+    identity.commit = await git(['rev-parse', '--short', 'HEAD']);
+  } catch {
+    // not a git checkout
+  }
+  try {
+    identity.dirty = (await git(['status', '--porcelain'])).length > 0;
+  } catch {
+    // not a git checkout
+  }
+  return identity;
+}
+
 /**
- * { current, latest, behind, updateAvailable }.
+ * { current, root, branch, commit, dirty, latest, behind, updateAvailable }.
  * - behind: commits on origin/<branch> not in HEAD.
  * - latest: version field of origin's package.json (may equal current if the
  *   upstream bumped commits without bumping the version).
  */
 export async function getVersionInfo({ force = false, now = Date.now() } = {}) {
   const current = currentVersion();
+  const identity = await checkoutIdentity();
   if (!force && cache.info && now - cache.checkedAt < REFRESH_MS) {
-    return { current, ...cache.info };
+    return { current, ...identity, ...cache.info };
   }
 
   let behind = 0;
   let latest = null;
+  // "dev mode" — running from a working codebase, not a clean install. A normal
+  // user's checkout is pristine and only ever BEHIND origin; a developer's has
+  // local edits (dirty tree) or unpushed commits (ahead). In dev mode we never
+  // nag about updates. An explicit CLAUDE_CONTROL_DEV=1 forces it.
+  let dev = process.env.CLAUDE_CONTROL_DEV === '1';
   try {
-    const branch = await git(['rev-parse', '--abbrev-ref', 'HEAD']);
-    await git(['fetch', '--quiet', 'origin', branch]);
-    behind = parseInt(await git(['rev-list', '--count', `HEAD..origin/${branch}`]), 10) || 0;
+    if (!identity.branch) throw new Error('detached HEAD');
+    await git(['fetch', '--quiet', 'origin', identity.branch]);
+    behind = parseInt(await git(['rev-list', '--count', `HEAD..origin/${identity.branch}`]), 10) || 0;
+    if (!dev) {
+      const ahead = parseInt(await git(['rev-list', '--count', `origin/${identity.branch}..HEAD`]), 10) || 0;
+      dev = !!identity.dirty || ahead > 0;
+    }
     if (behind > 0) {
       try {
-        latest = JSON.parse(await git(['show', `origin/${branch}:package.json`])).version || null;
+        latest = JSON.parse(await git(['show', `origin/${identity.branch}:package.json`])).version || null;
       } catch {
         latest = null;
       }
@@ -67,7 +103,7 @@ export async function getVersionInfo({ force = false, now = Date.now() } = {}) {
     // not a git checkout / no origin / offline — treat as up to date.
   }
 
-  const info = { latest, behind, updateAvailable: behind > 0 };
+  const info = { latest, behind, dev, updateAvailable: behind > 0 && !dev };
   cache = { info, checkedAt: now };
-  return { current, ...info };
+  return { current, ...identity, ...info };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@idl3/claude-control",
-  "version": "1.1.0",
+  "version": "1.4.3",
   "type": "module",
   "description": "Local web UI to watch and drive your Claude Code sessions running in tmux — live transcripts, reply, answer AskUserQuestion, attach files, from a browser or phone.",
   "keywords": [