handmux 0.17.0 → 0.17.3

package/public/index.html

@@ -48,7 +48,7 @@
       @keyframes bootDot { 0%,100% { opacity: .22; transform: translateY(0); } 40% { opacity: 1; transform: translateY(-3px); } }
       @media (prefers-reduced-motion: reduce) { .boot-glow, .boot-dots i { animation: none; opacity: .8; } }
     </style>
-    <script type="module" crossorigin src="/assets/index-C8uRJNnP.js"></script>
+    <script type="module" crossorigin src="/assets/index-Ddagv-Lc.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-BT03K2MQ.css" media="print" onload="this.media='all'"><noscript><link rel="stylesheet" crossorigin href="/assets/index-BT03K2MQ.css"></noscript>
   </head>
   <body>

package/src/agents/claude.js

@@ -10,7 +10,64 @@
 //   sessions       cwd → session resolution + the `resume` command, for orphan takeover
 import path from 'node:path';
 import os from 'node:os';
-import { resolveEncodedDirSession, isSessionUuid } from './scanUtils.js';
+import { promises as fsp } from 'node:fs';
+import { resolveEncodedDirSession, isSessionUuid, normTty } from './scanUtils.js';
+
+// The NATIVE installer names the real binary by version (~/.local/share/claude/versions/2.1.196 —
+// ~/.local/bin/claude is only a symlink to it), and tmux #{pane_current_command} follows that basename
+// ("2_1_196", dots sanitized to underscores) instead of "claude". ps can't tie it: ps `comm` shows the
+// process's self-set title ("claude"), which does NOT match tmux's report (verified live on a native-
+// install machine). Matching any semver-shaped name would misidentify any version-named binary, so we
+// corroborate with the process's REAL executable path (`lsof -d txt` on macOS, /proc/<pid>/exe on
+// Linux): a pid on the pane's tty whose exe BASENAME equals tmux's version comm, and whose path carries
+// "claude" — every official install layout carries it (Caskroom/claude-code@latest, .local/share/
+// claude/versions, node_modules/@anthropic-ai/claude-code, …), version- and layout-proof, while a
+// foreign version-named binary's path doesn't. Only then is the pane's cmd normalized to 'claude', so
+// every downstream match (identity + liveness) stays exact-name. Verdicts are cached per (tty, cmd) in
+// an injected Map — a cache miss costs one ps + one lsof per candidate pane, once per version per pane.
+const VERSION_COMM_RE = /^\d+[._]\d+[._]\d+$/;
+const CLAUDE_PATH_RE = /claude/;
+
+// The real executable path of a pid: first txt entry from lsof (resolves symlinks → the actual binary),
+// falling back to /proc on Linux where lsof output may be restricted. '' when unknowable.
+async function exePath(run, pid) {
+  const out = await run('lsof', ['-a', '-p', String(pid), '-d', 'txt', '-Fn']);
+  for (const line of String(out).split('\n')) if (line[0] === 'n') return line.slice(1).trim();
+  try { return await fsp.readlink(`/proc/${pid}/exe`); } catch { return ''; }
+}
+
+export async function resolveVersionedComms(panes, run, verdicts = new Map()) {
+  const candidates = panes.filter((p) => p && p.tty && VERSION_COMM_RE.test(p.cmd || ''));
+  if (!candidates.length) return panes;
+  const key = (p) => `${normTty(p.tty)}|${p.cmd}`;
+  for (const p of candidates) if (verdicts.get(key(p)) === true) p.cmd = 'claude';
+  const pending = candidates.filter((p) => p.cmd !== 'claude' && !verdicts.has(key(p)));
+  if (!pending.length) return panes;
+
+  const out = await run('ps', ['-Ao', 'tty=,pid=,comm=']);
+  const procs = []; // [{ tty, pid, comm }]
+  for (const line of String(out).split('\n')) {
+    const m = line.match(/^\s*(\S+)\s+(\d+)\s+(.*)$/);
+    if (!m) continue;
+    const tty = normTty(m[1]);
+    if (tty) procs.push({ tty, pid: m[2], comm: m[3].trim() });
+  }
+  for (const p of pending) {
+    let ok = false;
+    // Tie by tty + exe BASENAME (== tmux's version comm; ps comm is the self-set title and can't be
+    // trusted to match), then require the real path to carry "claude" — a random semver-named binary
+    // elsewhere is NOT Claude.
+    const want = p.cmd.replace(/_/g, '.');
+    for (const r of procs.filter((r) => r.tty === normTty(p.tty))) {
+      const exe = await exePath(run, r.pid);
+      const base = exe.split('/').pop() || '';
+      if ((base === p.cmd || base === want) && CLAUDE_PATH_RE.test(exe)) { ok = true; break; }
+    }
+    verdicts.set(key(p), ok);
+    if (ok) p.cmd = 'claude';
+  }
+  return panes;
+}
 
 // Build the 需要你 one-liner for a PermissionRequest, from the tool it's gating on (PermissionRequest
 // carries tool_name + tool_input, unlike the later permission_prompt Notification which only has an
@@ -103,7 +160,9 @@ export const claude = {
   label: 'Claude Code',
   procName: 'claude',
   // Which tmux #{pane_current_command} values mean "this agent is still the pane's foreground app" (inbox
-  // liveness). Claude sets its process title to "claude", so an exact single-name match is right.
+  // liveness). Claude sets its process title to "claude", so an exact single-name match is right — for
+  // native-install machines (whose comm is the VERSION string) resolveVersionedComms below normalizes the
+  // cmd back to 'claude' at ingest, keeping every match here exact-name.
   procNames: ['claude'],
   // The `claude` CLI sets its process title to "claude" (verified via ps): match the program token at the
   // start of argv — bare "claude", "claude --continue", or an absolute path ending in /claude. Anchored so

package/src/agents/index.js

@@ -16,5 +16,7 @@ const BY_ID = new Map(AGENTS.map((a) => [a.id, a]));
 export function getAgent(id) { return BY_ID.get(id) || claude; }
 
 // The driver whose foreground process this tmux #{pane_current_command} is, or null. Used by the inbox to
-// decide a recorded pane is still running its agent (vs. the agent having exited to a shell).
+// decide a recorded pane is still running its agent (vs. the agent having exited to a shell). Matches the
+// canonical procName only — never the ambiguous extras in procNames (e.g. Codex's 'node'); native-install
+// Claude binaries (comm = version string) are normalized to 'claude' at ingest (resolveVersionedComms).
 export function agentForProc(cmd) { return AGENTS.find((a) => a.procName === cmd) || null; }

package/src/claudeEvents.js

@@ -2,6 +2,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { getAgent, agentForProc } from './agents/index.js';
+import { resolveVersionedComms } from './agents/claude.js';
+import { defaultRun } from './agents/scanUtils.js';
 import { claude } from './agents/claude.js';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
@@ -134,12 +136,16 @@ function readStateFile(file) {
 }
 
 // Per-process event reader. Deps injected for testability:
-//   commands.listLivePanes() → [{ id, cmd, session, window, windowName }]  (one tmux call: liveness+location)
+//   commands.listLivePanes() → [{ id, cmd, tty, session, window, windowName }]  (one tmux call)
+//   run(cmd, args) → stdout   (only used by the version-named-comm corroboration; default defaultRun)
 //   push.sendToSession(session, payload, {ttl, urgency, topic})
 //   file: the hook-maintained JSON state file (DEFAULT_STATE_FILE).
 // The hook is the sole writer; the server reads the file fresh on every getStates and on every file
 // change (the watcher, for push). No persisted state of our own — the file IS the persistence.
-export function createClaudeEvents({ commands, push, file = DEFAULT_STATE_FILE, now = () => Date.now(), statMtime = defaultStatMtime, readTail = defaultReadTail } = {}) {
+export function createClaudeEvents({ commands, push, file = DEFAULT_STATE_FILE, now = () => Date.now(), statMtime = defaultStatMtime, readTail = defaultReadTail, run = defaultRun } = {}) {
+  // Cache for resolveVersionedComms verdicts ((tty|cmd) → bool) — one corroboration per version per pane,
+  // not one per poll. Per instance: prod shares one server-wide map; tests get isolation for free.
+  const commVerdicts = new Map();
   const lastPushed = {}; // pane → 'needs' | 'done' | null  (in-process push-transition dedup, by display view)
   // The dedup above is in-process ONLY: a restart (e.g. ./deploy.sh) wipes it while the hook's state
   // file on disk keeps every pane's latest 需要你/已完成. Without priming, the first read after boot
@@ -181,7 +187,13 @@ export function createClaudeEvents({ commands, push, file = DEFAULT_STATE_FILE,
     const allow = allowedSessions == null ? null : new Set(allowedSessions);
     const recorded = readStateFile(file);
     let live = null;
-    try { live = new Map((await commands.listLivePanes()).map((p) => [p.id, p])); } catch { /* tmux down */ }
+    try {
+      const panes = await commands.listLivePanes();
+      // Native-install Claude binaries report a version string as pane_current_command — corroborate via
+      // ps and normalize to 'claude' BEFORE any identity/liveness match (see agents/claude.js).
+      await resolveVersionedComms(panes, run, commVerdicts);
+      live = new Map(panes.map((p) => [p.id, p]));
+    } catch { /* tmux down */ }
 
     const out = {};
     for (const [pane, rec] of Object.entries(recorded)) {

package/src/tmux/commands.js

@@ -78,10 +78,10 @@ export async function listPaneIds(target) {
 // per-pane display-message. The hook only records the pane id; location comes from here, always fresh.
 export async function listLivePanes() {
   return lines(await runTmux(['list-panes', '-a', '-F',
-    '#{pane_id}\t#{pane_current_command}\t#{session_name}\t#{window_id}\t#{window_name}']))
+    '#{pane_id}\t#{pane_current_command}\t#{pane_tty}\t#{session_name}\t#{window_id}\t#{window_name}']))
     .map((l) => {
-      const [id, cmd, session, window, windowName] = l.split('\t');
-      return { id, cmd, session, window, windowName };
+      const [id, cmd, tty, session, window, windowName] = l.split('\t');
+      return { id, cmd, tty, session, window, windowName };
     });
 }