handmux 0.12.2 → 0.13.0

package/public/index.html

@@ -48,8 +48,8 @@
       @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-BXd3a0v9.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-DJNPeU_h.css" media="print" onload="this.media='all'"><noscript><link rel="stylesheet" crossorigin href="/assets/index-DJNPeU_h.css"></noscript>
+    <script type="module" crossorigin src="/assets/index-Kniw-XQB.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-Bew5DIWc.css" media="print" onload="this.media='all'"><noscript><link rel="stylesheet" crossorigin href="/assets/index-Bew5DIWc.css"></noscript>
   </head>
   <body>
     <div id="boot-splash" aria-hidden="true">

package/src/agents/scanUtils.js

@@ -200,6 +200,23 @@ export function takeoverSessionName(cwdLabel, n, prefix = 'cc') {
   return `${prefix}-${base}-${n}`.slice(0, 16);
 }
 
+// Coerce a user-typed takeover name into a valid tmux session name (isValidSessionName: [A-Za-z0-9-], ≤16):
+// non-alnum runs → a single '-', trimmed of edge hyphens, capped at 16. Returns '' if nothing usable is
+// left (caller then falls back to the generated name).
+export function sanitizeSessionName(s) {
+  return String(s || '').replace(/[^A-Za-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 16).replace(/-+$/, '');
+}
+
+// First name in `<base>, base-2, base-3, …` (each capped at 16) that isn't already taken. null if none free.
+export function freeSessionName(base, taken) {
+  if (!taken.has(base)) return base;
+  for (let i = 2; i < 1000; i++) {
+    const cand = `${base}-${i}`.slice(0, 16);
+    if (!taken.has(cand)) return cand;
+  }
+  return null;
+}
+
 export const isShell = (c) => /^-?(zsh|bash|sh|fish|dash|tcsh|csh|ksh)$/.test(String(c || ''));
 
 export async function lsofCwd(run, pid) {

package/src/claudeEvents.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { getAgent } from './agents/index.js';
+import { getAgent, agentForProc } from './agents/index.js';
 import { claude } from './agents/claude.js';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
@@ -141,6 +141,24 @@ export function createClaudeEvents({ commands, push, file = DEFAULT_STATE_FILE,
       if (allow && !allow.has(loc.session)) continue;
       out[pane] = { ...loc, kind: c.kind, msg: c.msg || '', ts: rec.ts || 0, agent: agent.id };
     }
+
+    // (3) process presence — a pane whose FOREGROUND program IS a coding agent reads as "agent here" even
+    // with no active turn on record: a fresh session that hasn't prompted yet, or one right after `/clear`
+    // (whose SessionEnd dropped its roster entry above though the agent is still running). This is what the
+    // phone's per-window agent icon and the dock's default mode key off — process liveness, not the volatile
+    // activity roster. Emitted with kind:null so the inbox (inboxRows keys off VIEW[kind]) skips it and no
+    // push fires, and with NO ts so it stays inert to the done/read high-water marks (maxTs, the seen-mark
+    // effect). An active roster entry from (2) always wins (out[id] set → skip). agentForProc matches the
+    // canonical procName (never the ambiguous 'node'), so a plain node process is not mistaken for an agent.
+    if (live) {
+      for (const lp of live.values()) {
+        if (out[lp.id]) continue;
+        const a = agentForProc(lp.cmd);
+        if (!a) continue;
+        if (allow && !allow.has(lp.session)) continue;
+        out[lp.id] = { session: lp.session, window: lp.window, windowName: lp.windowName, kind: null, msg: '', agent: a.id };
+      }
+    }
     return out;
   }
 

package/src/cli/i18n/en.js

@@ -142,6 +142,15 @@ export default {
   'setup.secConnection': 'Connection',
   'setup.secName': 'Name',
   'setup.secPort': 'Port',
+  'setup.secToken': 'Token',
+  'setup.tokenAuto': 'auto · new each start',
+  'setup.tokenCustom': 'Set a custom token…',
+  'setup.tokenRandom': 'Generate a random one',
+  'setup.tokenReset': 'Reset to auto (new each start)',
+  'setup.askToken': 'Access token — it appears in the URL you open on the phone',
+  'setup.tokenGenerated': 'New token: {token}',
+  'setup.valToken': 'enter a token',
+  'setup.valTokenSpace': 'no spaces — the token goes in a URL',
   'setup.secLanguage': 'CLI language / 命令行语言',
   'setup.secPush': 'Push',
   'setup.secVoice': 'Voice',

package/src/cli/i18n/zh.js

@@ -141,6 +141,15 @@ export default {
   'setup.secConnection': '连接',
   'setup.secName': '名称',
   'setup.secPort': '端口',
+  'setup.secToken': '令牌',
+  'setup.tokenAuto': '自动 · 每次启动新生成',
+  'setup.tokenCustom': '自定义令牌…',
+  'setup.tokenRandom': '随机生成一个',
+  'setup.tokenReset': '恢复自动(每次启动新生成)',
+  'setup.askToken': '访问令牌 —— 会出现在手机打开的网址里',
+  'setup.tokenGenerated': '新令牌:{token}',
+  'setup.valToken': '请输入令牌',
+  'setup.valTokenSpace': '不能有空格 —— 令牌会放进网址',
   'setup.secLanguage': '命令行语言 / CLI language',
   'setup.secPush': '推送',
   'setup.secVoice': '语音',

package/src/cli/options.js

@@ -119,7 +119,7 @@ function resolvePublicUrl(flags, fileCfg, env, tunnel) {
 // so it's quick to thumb in on a phone. A user-supplied token (flag/config/env) is used verbatim — any
 // length, never regenerated. 8 chars over a 32-char alphabet ≈ 40 bits, fine for a single secret URL.
 const TOKEN_ALPHABET = '23456789abcdefghijkmnpqrstuvwxyz';
-function defaultGen() {
+export function defaultGen() {
   let s = '';
   for (let i = 0; i < 8; i++) s += TOKEN_ALPHABET[crypto.randomInt(TOKEN_ALPHABET.length)];
   return s;

package/src/cli/setupWizard.js

@@ -10,6 +10,7 @@ import { homedir } from 'node:os';
 import { spawnSync } from 'node:child_process';
 import webpush from 'web-push';
 import { configPath, pocketHome } from './state.js';
+import { defaultGen as genToken } from './options.js';
 import { resolveCloudflared } from './cloudflared.js';
 import { resolveTunlite, checkSshAuth } from './tunlite.js';
 import { resolveNatapp, resolveCpolar } from './tunnelClients.js';
@@ -51,10 +52,11 @@ export function findTunnelId(listJsonOut, name) {
 
 // The config keys the wizard owns: everything it can set. mergeConfig wipes these from the existing config
 // before re-applying the answers, so switching a tunnel (or clearing an optional field) cleanly drops the
-// old value instead of leaving a stale field behind. Anything NOT here (token, staticDir, previewDomain…)
-// is preserved untouched.
+// old value instead of leaving a stale field behind. Anything NOT here (staticDir, previewDomain…) is
+// preserved untouched. `token` IS owned so the Token row can pin one AND clear it back to auto — but it
+// round-trips through answersFromConfig, so a re-run that never touches the row still writes it back.
 const WIZARD_KEYS = [
-  'lang', 'name', 'port', 'tunnel',
+  'lang', 'name', 'port', 'tunnel', 'token',
   'sshHost', 'remotePort', 'sshJump', 'cfHostname', 'cfTunnelName', 'publicUrl',
   'authtoken', 'cpolarRegion',
   'vapid', 'xfyun',
@@ -68,6 +70,7 @@ export function configFromAnswers(a) {
   const cfg = { tunnel: a.tunnel, port: a.port };
   if (a.lang) cfg.lang = a.lang;
   if (a.name) cfg.name = a.name;
+  if (a.token) cfg.token = a.token;   // blank = don't pin one → the server mints a fresh token each start
   if (a.tunnel === 'ssh') {
     cfg.sshHost = a.sshHost;
     cfg.remotePort = a.remotePort;
@@ -103,6 +106,7 @@ export function answersFromConfig(cfg = {}) {
   const a = {
     lang: cfg.lang || getLocale(),
     name: cfg.name || '',
+    token: cfg.token || '',   // '' = not pinned (auto each start); seeded so an untouched re-run rewrites it
     tunnel: cfg.tunnel || 'none',
     port: Number(cfg.port) || 19999,
   };
@@ -144,6 +148,14 @@ export function validateContact(v) {
   if (!wellFormed || /\.local(?:[:/]|$)/i.test(s)) return t('setup.valContact');
   return undefined;
 }
+// Access token: it rides in the phone's URL as ?token=…, so require something and reject whitespace (a space
+// would break the link). Length/charset are otherwise up to the user — a pinned token is used verbatim.
+export function validateToken(v) {
+  const s = String(v || '').trim();
+  if (!s) return t('setup.valToken');
+  if (/\s/.test(s)) return t('setup.valTokenSpace');
+  return undefined;
+}
 
 function readExisting(file) {
   try { return JSON.parse(fs.readFileSync(file, 'utf8')); } catch { return {}; }
@@ -185,6 +197,7 @@ export async function runSetup({ home = homedir(), target = configPath(home), lo
           { value: 'connection', label: t('setup.secConnection'), hint: summarizeConnection(a) },
           { value: 'name', label: t('setup.secName'), hint: a.name || t('setup.default') },
           { value: 'port', label: t('setup.secPort'), hint: String(a.port) },
+          { value: 'token', label: t('setup.secToken'), hint: a.token ? maskSecret(a.token) : t('setup.tokenAuto') },
           { value: 'push', label: t('setup.secPush'), hint: a.vapid ? (a.vapid.subject || t('setup.on')) : t('setup.off') },
           { value: 'voice', label: t('setup.secVoice'), hint: a.xfyun ? (a.xfyun.appId || t('setup.on')) : t('setup.off') },
           // A CLI-tool preference (language of handmux's own terminal output), not an app setting — so it
@@ -212,6 +225,7 @@ export async function runSetup({ home = homedir(), target = configPath(home), lo
         if (choice === 'connection') a = await editConnection(a, { home, log });
         else if (choice === 'name') a.name = await editName(a);
         else if (choice === 'port') a.port = await editPort(a);
+        else if (choice === 'token') a.token = await editToken(a);
         else if (choice === 'language') a.lang = await editLanguage(a);
         else if (choice === 'push') a.vapid = await editPush(a);
         else if (choice === 'voice') a.xfyun = await editVoice(a);
@@ -250,6 +264,34 @@ async function editPort(a) {
   return Number(v);
 }
 
+// The access token — the one secret in the phone's URL. Unset = the server mints a fresh one each start
+// (printed + QR'd), so the link changes every restart; pinning one keeps the same URL. A mini-hub (like
+// push/voice): type your own, generate + pin a strong random one, or reset back to auto. Editing custom
+// pre-fills the current value (so you can read it off); the hub hint masks it. Esc returns to the main hub,
+// keeping the choice. Returns the token string ('' = auto).
+async function editToken(a) {
+  let token = a.token || '';
+  for (;;) {
+    let pick;
+    try {
+      pick = await ask(select({
+        message: withBack(t('setup.secToken')),
+        options: [
+          { value: 'custom', label: t('setup.tokenCustom'), hint: token ? maskSecret(token) : t('setup.tokenAuto') },
+          { value: 'random', label: t('setup.tokenRandom') },
+          { value: 'auto', label: t('setup.tokenReset'), hint: t('setup.tokenAuto') },
+        ],
+        initialValue: 'custom',
+      }));
+    } catch (e) { if (e === CANCELLED) return token; throw e; }   // back to the main hub, keeping the choice
+    try {
+      if (pick === 'custom') token = (await ask(text({ message: t('setup.askToken'), initialValue: token, validate: validateToken }))).trim();
+      else if (pick === 'random') { token = genToken(); note(t('setup.tokenGenerated', { token })); }
+      else if (pick === 'auto') token = '';
+    } catch (e) { if (e !== CANCELLED) throw e; }                 // Esc in a sub-edit → back to the mini-hub
+  }
+}
+
 const bareHost = (u) => String(u || '').replace(/^https?:\/\//, '');
 // cloudflare's two drivers are ONE family in the UI: 'cloudflare' (quick, no login) and 'cloudflare-named'
 // (your domain, needs a login) are picked as a mode INSIDE cloudflare, not as two separate tunnels.

package/src/orphans.js

@@ -21,7 +21,7 @@ import { AGENTS, getAgent } from './agents/index.js';
 import { isSessionId } from './tmux/commands.js';
 import {
   defaultRun, parseAgentProcs, parsePaneMembership, findOrphans,
-  takeoverSessionName, isShell, lsofCwd, isSessionUuid,
+  takeoverSessionName, sanitizeSessionName, freeSessionName, isShell, lsofCwd, isSessionUuid,
 } from './agents/scanUtils.js';
 
 // Back-compat re-exports: these were originally defined here and are imported by tests and callers by this
@@ -53,7 +53,7 @@ export async function takeoverOrphan(
     delay = (ms) => new Promise((r) => setTimeout(r, ms)),
     pollTries = 16, pollMs = 400,
   },
-  { pid, sessionId, target = { mode: 'new' }, kill = true } = {},
+  { pid, sessionId, target = { mode: 'new' }, kill = true, name: wantName } = {},
 ) {
   if (!Number.isInteger(pid) || pid <= 0) return { error: 'bad pid', status: 400 };
   // Both agents use UUID session ids; validate up front (takeover types the id into a shell via send-keys).
@@ -76,10 +76,18 @@ export async function takeoverOrphan(
     wid = await commands.newWindow(sid, o.cwd, agent.procName, cmd);
   } else {
     const existing = new Set((await commands.listSessions()).map((s) => s.name));
-    for (let i = 1; i < 1000 && !name; i++) {
-      const cand = takeoverSessionName(o.cwdLabel, i, agent.takeoverPrefix);
-      if (!existing.has(cand)) name = cand;
+    // Honour a user-typed name (sanitized to tmux rules, deduped with a numeric suffix); fall back to the
+    // generated `<prefix>-<dir>-<n>` when the client sent nothing.
+    const wanted = sanitizeSessionName(wantName);
+    if (wanted) {
+      name = freeSessionName(wanted, existing);
+    } else {
+      for (let i = 1; i < 1000 && !name; i++) {
+        const cand = takeoverSessionName(o.cwdLabel, i, agent.takeoverPrefix);
+        if (!existing.has(cand)) name = cand;
+      }
     }
+    if (!name) return { error: 'no free session name', status: 409 };
     sid = await commands.newSession(name, o.cwd, cmd);
     wid = (await commands.listWindows(sid))[0]?.id;
   }
@@ -121,12 +129,15 @@ export async function scanOrphans({
     const cwd = await lsofCwd(run, o.pid);
     const dir = dirOverrides[agent.sessions.dirOptKey] || agent.sessions.dir(home);
     const meta = cwd ? await agent.sessions.resolve(dir, cwd, { busyMs, now }) : {};
+    const cwdLabel = cwd ? path.basename(cwd) : '';
     results.push({
       pid: o.pid,
       agent: agent.id,
       agentLabel: agent.label,
       cwd: cwd || '',
-      cwdLabel: cwd ? path.basename(cwd) : '',
+      cwdLabel,
+      // Default name the takeover sheet prefills (the same `<prefix>-<dir>-1` the server would auto-pick).
+      suggestedName: takeoverSessionName(cwdLabel, 1, agent.takeoverPrefix),
       sessionId: meta.sessionId || null,
       state: meta.state || 'unknown',
       snippet: meta.snippet || '',