handmux 0.23.0 → 0.25.0

package/src/cli/claudeHooks.js

@@ -1,206 +0,0 @@
-// Install/uninstall the Claude Code lifecycle hooks that feed the handmux inbox. This ports the idempotent
-// merge from scripts/install-hooks.sh into testable JS so the OSS CLI (and the phone, via the server) can
-// turn the inbox on — opt-in, since writing ~/.claude/settings.json edits another tool's config.
-//
-// Iron rule: only ever touch ~/.handmux/ and — after explicit opt-in — ~/.claude/. If ~/.claude is absent
-// (no Claude Code), skip and report 'no-claude'; never create it.
-import fs from 'node:fs';
-import path from 'node:path';
-import { homedir } from 'node:os';
-import { spawnSync } from 'node:child_process';
-import { writeJsonAtomic, deployHookScripts, removeHookScripts } from './hookScaffold.js';
-
-// The seven events the inbox reads. src is the arg passed to handmux-notify.sh; only PostToolUse is scoped to
-// a matcher (the two "需要你" interaction tools) — every other Read/Bash/Edit must NOT wake the hook, or
-// many concurrent Claude panes would each spawn the hook on every tool call. Keep this table in sync with
-// the hook scripts in ../../hooks.
-//   SessionStart binds the pane→session mapping the instant a session begins — critically after /clear, which
-// starts a NEW transcript file. Without it, /clear's SessionEnd(old) drops the pane and nothing rebinds it
-// until the next prompt, so the 对话 lens goes blank / falls back to the ambiguous cwd→newest-jsonl guess.
-// Fires only at session boundaries (startup/clear/resume), never per tool call, so it adds no hot-path load;
-// classified neutral (no push, no roster entry — see agents/claude.js). Base, not version-gated: SessionStart
-// is a long-standing lifecycle hook every supported Claude recognises.
-export const HOOK_EVENTS = [
-  { event: 'Stop', src: 'stop' },
-  { event: 'Notification', src: 'notify' },
-  { event: 'UserPromptSubmit', src: 'prompt' },
-  { event: 'SessionStart', src: 'start' },
-  { event: 'SessionEnd', src: 'end' },
-  { event: 'PostToolUse', src: 'resume', matcher: 'AskUserQuestion|ExitPlanMode' },
-  { event: 'PermissionRequest', src: 'permreq' },
-];
-
-// Version-gated events, only registered on a Claude Code new enough to EMIT them. Older Claude does not
-// recognise these event names — and the docs give NO guarantee it ignores unknown ones (it "likely" does,
-// but might reject the settings file) — so we NEVER write an event a version can't handle. Each carries a
-// minVersion; below it (or when the version can't be detected) the event isn't written at all → pure
-// downgrade, never an error. The pane instead self-heals via the existing idle_prompt(~60s) fallback.
-//   PreCompact  → 压缩中 shown while compaction runs (honest progress for a slow op).
-//   PostCompact → clears the 压缩中/进行中 state the instant compaction finishes.
-//   StopFailure → a turn that died on an API error (rate limit / overload / …) fires NO Stop, so without
-//                 this the pane sticks at 进行中 forever; maps to an 'error' state.
-// `pairWith` welds an invariant (learned the hard way — never light a state you can't turn off): PreCompact
-// is installed ONLY when its clearer PostCompact is also installed. minVersion is set conservatively to the
-// version we've actually verified emits these (2.1.207); lower it only after test-firing an older build.
-const COMPACT_MIN = '2.1.207';
-export const HOOK_EVENTS_EXT = [
-  { event: 'PostCompact', src: 'compact', minVersion: COMPACT_MIN },
-  { event: 'PreCompact', src: 'compacting', minVersion: COMPACT_MIN, pairWith: 'PostCompact' },
-  { event: 'StopFailure', src: 'stopfail', minVersion: COMPACT_MIN },
-];
-
-const HOOK_MARK = 'handmux-notify.sh'; // identifies our hooks among the user's own
-
-// Parse `claude --version` output ("2.1.207 (Claude Code)") → { major, minor, patch } | null.
-export function parseClaudeVersion(out) {
-  const m = /(\d+)\.(\d+)\.(\d+)/.exec(String(out || ''));
-  return m ? { major: +m[1], minor: +m[2], patch: +m[3] } : null;
-}
-
-// v >= min ("X.Y.Z"), full major.minor.patch compare. A null/undefined version is always below → fail-closed.
-export function claudeVersionAtLeast(v, minStr) {
-  if (!v) return false;
-  const [a, b, c] = String(minStr).split('.').map(Number);
-  if (v.major !== a) return v.major > a;
-  if (v.minor !== b) return v.minor > b;
-  return v.patch >= c;
-}
-
-// Detect the installed Claude Code version, or null if `claude` can't be run/parsed (→ ext hooks skipped).
-export function detectClaudeVersion(exec = spawnSync) {
-  try {
-    const r = exec('claude', ['--version'], { encoding: 'utf8', timeout: 4000 });
-    if (!r || r.status !== 0 || !r.stdout) return null;
-    return parseClaudeVersion(r.stdout);
-  } catch { return null; }
-}
-
-// Drop OUR hook from settings.hooks[event] (used to prune an ext event that no longer passes the version
-// gate — e.g. Claude was downgraded after a newer install). Mutates the passed hooks object.
-function dropOurHook(hooks, event) {
-  if (!hooks[event]) return;
-  const kept = hooks[event]
-    .map((g) => ({ ...g, hooks: (g.hooks || []).filter((h) => !(typeof h.command === 'string' && h.command.includes(HOOK_MARK))) }))
-    .filter((g) => (g.hooks || []).length > 0);
-  if (kept.length) hooks[event] = kept; else delete hooks[event];
-}
-
-// True if `settings.hooks[event]` already has one of our hooks (command references the dest script).
-function alreadyHas(hooks, event) {
-  return (hooks[event] || []).some((g) => (g.hooks || []).some(
-    (h) => typeof h.command === 'string' && h.command.includes(HOOK_MARK)));
-}
-
-// Merge one event's hook group into `hooks` (mutates), idempotently — a no-op if one of ours is already
-// registered for that event, so it's safe to call on every install/sync. Shared by mergeHooks and syncHooks.
-function addHook(hooks, e, dest) {
-  if (alreadyHas(hooks, e.event)) return;
-  const groups = hooks[e.event] = [...(hooks[e.event] || [])];
-  groups.push({ matcher: e.matcher || '', hooks: [{ type: 'command', command: `${dest} ${e.src}`, async: true, timeout: 5 }] });
-}
-
-// Pure: return a NEW settings object with our six hooks merged into settings.hooks, idempotently, leaving
-// the user's own hooks and other keys untouched. `dest` is the absolute path to the copied notify script.
-export function mergeHooks(settings, dest, claudeVersion = null) {
-  const s = { ...(settings || {}) };
-  const hooks = (s.hooks && typeof s.hooks === 'object' && !Array.isArray(s.hooks)) ? { ...s.hooks } : {};
-  for (const e of HOOK_EVENTS) addHook(hooks, e, dest);
-  // Version-gated ext events: install only when the detected Claude is new enough AND (for a paired event)
-  // its clearer is also being installed. Anything that fails the gate is actively PRUNED, so a Claude
-  // downgrade after a newer install can't leave an unrecognised event name lingering in settings.json.
-  const enabled = new Set();
-  for (const e of HOOK_EVENTS_EXT) {
-    const ok = claudeVersionAtLeast(claudeVersion, e.minVersion) && (!e.pairWith || enabled.has(e.pairWith));
-    if (ok) { enabled.add(e.event); addHook(hooks, e, dest); } else dropOurHook(hooks, e.event);
-  }
-  s.hooks = hooks;
-  return s;
-}
-
-// Pure: return a NEW settings object with all of OUR hooks removed (uninstall). An event group that ends up
-// empty is dropped; the user's own hooks and other keys are untouched.
-export function stripHooks(settings) {
-  const s = { ...(settings || {}) };
-  if (!s.hooks || typeof s.hooks !== 'object' || Array.isArray(s.hooks)) return s;
-  const hooks = {};
-  for (const [event, groups] of Object.entries(s.hooks)) {
-    const kept = (groups || [])
-      .map((g) => ({ ...g, hooks: (g.hooks || []).filter((h) => !(typeof h.command === 'string' && h.command.includes(HOOK_MARK))) }))
-      .filter((g) => (g.hooks || []).length > 0);
-    if (kept.length) hooks[event] = kept;
-  }
-  s.hooks = hooks;
-  return s;
-}
-
-// Path helpers (also used by the IO shell in the next task).
-function claudeDir(home = homedir()) { return path.join(home, '.claude'); }
-function settingsPath(home = homedir()) { return path.join(claudeDir(home), 'settings.json'); }
-
-// 'no-claude' → ~/.claude absent (don't prompt to enable). 'installed' → our hooks present. 'absent' →
-// Claude Code is here but our hooks aren't (offer to enable).
-export function hooksStatus(home = homedir()) {
-  if (!fs.existsSync(claudeDir(home))) return 'no-claude';
-  let settings = {};
-  try { settings = JSON.parse(fs.readFileSync(settingsPath(home), 'utf8')); } catch { /* missing/corrupt → {} */ }
-  const hooks = (settings && settings.hooks && typeof settings.hooks === 'object' && !Array.isArray(settings.hooks)) ? settings.hooks : {};
-  return Object.keys(hooks).some((ev) => alreadyHas(hooks, ev)) ? 'installed' : 'absent';
-}
-
-// Install (opt-in): copy the bundled hook scripts to ~/.claude/hooks/, write the env pointing at the state
-// file, and merge our six hooks into settings.json. Returns { status }. NEVER creates ~/.claude — if it's
-// absent the user doesn't run Claude Code, so we report 'no-claude' and do nothing.
-//   srcDir   = the bundled hooks dir (server/hooks)
-//   stateFile = the unified ~/.handmux/claude-state.json path the hook writes and the server reads
-export function installHooks(home = homedir(), { srcDir, stateFile, claudeVersion } = {}) {
-  if (!fs.existsSync(claudeDir(home))) return { status: 'no-claude' };
-  const hooksDir = path.join(claudeDir(home), 'hooks');
-  deployHookScripts(hooksDir, srcDir, stateFile);
-
-  const dest = path.join(hooksDir, 'handmux-notify.sh');
-  let settings = {};
-  try { settings = JSON.parse(fs.readFileSync(settingsPath(home), 'utf8')); } catch { /* missing/corrupt → {} */ }
-  // Gate the version-specific events (compact pair, StopFailure) on the installed Claude. Detect when the
-  // caller didn't inject a version; a null result (no `claude` / unparseable) is fail-closed = base 6 only.
-  const version = claudeVersion !== undefined ? claudeVersion : detectClaudeVersion();
-  writeJsonAtomic(settingsPath(home), mergeHooks(settings, dest, version));
-  return { status: 'installed' };
-}
-
-// Keep an ALREADY-installed user's hooks in step with this handmux version on every server start, so a plain
-// `./deploy.sh` (restart) rolls out newly-added lifecycle events (e.g. SessionStart) and refreshed hook
-// scripts — no phone re-enable needed. Two moves: (1) re-deploy the bundled hook scripts (idempotent — picks
-// up a fixed handmux-write.cjs), and (2) add any of our BASE events a prior install predates.
-//
-// Strictly opt-in-preserving: a NO-OP unless our hooks are already present ('installed'). It never enables
-// hooks for a user who hasn't opted in ('absent') and never creates ~/.claude ('no-claude'). BASE events
-// only — it deliberately does NOT touch the version-gated ext events (compact pair / StopFailure): reconciling
-// those needs the Claude version (a null read would PRUNE the ext hooks a user already has), and detecting it
-// means spawning `claude --version` on the hot startup path. So sync stays pure-fs and non-pruning; ext-event
-// rollout stays with the explicit installHooks (phone re-enable) path. settings.json is rewritten only when
-// the merge actually changes it, so a steady state writes nothing.
-export function syncHooks(home = homedir(), { srcDir, stateFile } = {}) {
-  const status = hooksStatus(home);
-  if (status !== 'installed') return { status, changed: false };
-  const hooksDir = path.join(claudeDir(home), 'hooks');
-  deployHookScripts(hooksDir, srcDir, stateFile); // refresh the deployed scripts (idempotent)
-  const dest = path.join(hooksDir, 'handmux-notify.sh');
-  let settings = {};
-  try { settings = JSON.parse(fs.readFileSync(settingsPath(home), 'utf8')); } catch { /* missing/corrupt → {} */ }
-  const hooks = (settings.hooks && typeof settings.hooks === 'object' && !Array.isArray(settings.hooks)) ? { ...settings.hooks } : {};
-  const before = JSON.stringify(hooks);
-  for (const e of HOOK_EVENTS) addHook(hooks, e, dest); // add only MISSING base events; never add/prune ext
-  const changed = JSON.stringify(hooks) !== before;
-  if (changed) writeJsonAtomic(settingsPath(home), { ...settings, hooks });
-  return { status: 'installed', changed };
-}
-
-// Uninstall: strip our hooks from settings.json and remove the copied scripts/env. Best-effort on the file
-// deletes (a missing file is fine). Leaves ~/.claude and the user's own hooks intact.
-export function uninstallHooks(home = homedir()) {
-  let settings = {};
-  try { settings = JSON.parse(fs.readFileSync(settingsPath(home), 'utf8')); } catch { /* nothing to strip */ }
-  if (fs.existsSync(settingsPath(home))) writeJsonAtomic(settingsPath(home), stripHooks(settings));
-  removeHookScripts(path.join(claudeDir(home), 'hooks'));
-  return { status: 'absent' };
-}

package/src/cli/cloudflared.js

@@ -1,99 +0,0 @@
-// Resolve a usable `cloudflared` binary so `--tunnel cloudflare` is truly one-click (no brew/manual
-// install). Order: $PATH → ~/.handmux/bin/ → download the latest release for this OS/arch from GitHub.
-// `which`/`fetchImpl` are injectable so the pure mapping (assetFor) unit-tests offline.
-import fs from 'node:fs';
-import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { pocketHome } from './state.js';
-import { t } from './i18n/index.js';
-
-const fmtMB = (n) => (n / 1048576).toFixed(1);
-
-// Stream a fetch response into a Buffer, reporting progress per chunk as onProgress(received, total).
-// `total` is the content-length (0 if the server didn't send one). Falls back to arrayBuffer() when the
-// response isn't a readable stream (older/mock fetch), so callers still get the bytes.
-export async function drain(res, onProgress) {
-  const total = Number(res.headers?.get?.('content-length')) || 0;
-  if (!res.body?.getReader) {
-    const b = Buffer.from(await res.arrayBuffer());
-    onProgress?.(b.length, total || b.length);
-    return b;
-  }
-  const reader = res.body.getReader();
-  const chunks = [];
-  let received = 0;
-  for (;;) {
-    const { done, value } = await reader.read();
-    if (done) break;
-    const c = Buffer.from(value);
-    chunks.push(c);
-    received += c.length;
-    onProgress?.(received, total);
-  }
-  return Buffer.concat(chunks);
-}
-
-// Default progress renderer: a single \r-updated line on a TTY (throttled to ~10/s), e.g.
-// `  cloudflared  45%  (9.2/20.4 MB)`. Non-TTY (piped/logged) gets nothing — the start line already
-// announced the download and a spammy animation would just fill the log with control chars.
-export function defaultProgress(out = process.stdout, name = 'cloudflared') {
-  if (!out.isTTY) return () => {};
-  let last = 0;
-  return (received, total) => {
-    const done = total && received >= total;
-    const now = Date.now();
-    if (!done && now - last < 100) return;
-    last = now;
-    const body = total
-      ? `${Math.floor((received / total) * 100)}%  (${fmtMB(received)}/${fmtMB(total)} MB)`
-      : `${fmtMB(received)} MB`;
-    out.write(`\r  ${name}  ${body}   `);
-    if (done) out.write('\n');
-  };
-}
-
-// Map Node's platform/arch to cloudflared's release asset. Linux/Windows ship a bare binary; macOS
-// ships a .tgz that contains a `cloudflared` executable.
-export function assetFor(platform = process.platform, arch = process.arch) {
-  const a = { x64: 'amd64', arm64: 'arm64', arm: 'arm', ia32: '386' }[arch] || arch;
-  if (platform === 'darwin') return { file: `cloudflared-darwin-${a}.tgz`, archive: 'tgz', bin: 'cloudflared' };
-  if (platform === 'win32') return { file: `cloudflared-windows-${a}.exe`, archive: null, bin: 'cloudflared.exe' };
-  return { file: `cloudflared-linux-${a}`, archive: null, bin: 'cloudflared' };
-}
-
-export function onPath(exec = 'cloudflared') {
-  const finder = process.platform === 'win32' ? 'where' : 'which';
-  const r = spawnSync(finder, [exec], { encoding: 'utf8' });
-  return r.status === 0 ? String(r.stdout).trim().split(/\r?\n/)[0] : null;
-}
-
-export async function resolveCloudflared(home, { which = onPath, fetchImpl, log = console, progress } = {}) {
-  const found = which('cloudflared');
-  if (found) return found;
-
-  const dir = path.join(pocketHome(home), 'bin');
-  const asset = assetFor();
-  const dest = path.join(dir, asset.bin);
-  if (fs.existsSync(dest)) return dest;
-
-  const doFetch = fetchImpl || globalThis.fetch;
-  if (!doFetch) throw new Error('no fetch available to download cloudflared (Node 18+ required)');
-  fs.mkdirSync(dir, { recursive: true });
-  const url = `https://github.com/cloudflare/cloudflared/releases/latest/download/${asset.file}`;
-  log.log?.(t('cf.downloading', { file: asset.file }));
-  const res = await doFetch(url, { redirect: 'follow' });
-  if (!res.ok) throw new Error(`cloudflared download failed: HTTP ${res.status} (${url})`);
-  const buf = await drain(res, progress || defaultProgress(process.stdout));
-
-  if (asset.archive === 'tgz') {
-    const tmp = path.join(dir, asset.file);
-    fs.writeFileSync(tmp, buf);
-    const r = spawnSync('tar', ['xzf', tmp, '-C', dir], { encoding: 'utf8' });
-    fs.unlinkSync(tmp);
-    if (r.status !== 0) throw new Error(`failed to extract cloudflared: ${r.stderr || r.status}`);
-  } else {
-    fs.writeFileSync(dest, buf);
-  }
-  fs.chmodSync(dest, 0o755);
-  return dest;
-}

package/src/cli/codexManaged.js

@@ -1,77 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import { spawn as spawnChild } from 'node:child_process';
-
-const PANE_RE = /^%\d+$/;
-
-export function codexAppSocketPath(pane, home = os.homedir()) {
-  if (!PANE_RE.test(pane || '')) throw new Error('managed Codex requires a tmux pane');
-  return path.join(home, '.handmux', 'codex-app', `${pane.slice(1)}.sock`);
-}
-
-function waitForSocket(socketPath, child, {
-  exists = fs.existsSync,
-  wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
-  timeoutMs = 5_000,
-  now = Date.now,
-} = {}) {
-  return new Promise((resolve, reject) => {
-    let exited = false;
-    let exitCode = null;
-    child.once('exit', (code) => { exited = true; exitCode = code; });
-    child.once('error', reject);
-    (async () => {
-      const started = now();
-      while (!exists(socketPath)) {
-        if (exited) throw new Error(`Codex App Server exited before startup (${exitCode ?? 'unknown'})`);
-        if (now() - started >= timeoutMs) throw new Error('Codex App Server startup timed out');
-        await wait(25);
-      }
-      resolve();
-    })().catch(reject);
-  });
-}
-
-function finish(child) {
-  return new Promise((resolve, reject) => {
-    child.once('error', reject);
-    child.once('exit', (code, signal) => resolve({ code, signal }));
-  });
-}
-
-// One App Server belongs to one tmux pane. The TUI and Handmux connect to that pane-owned Unix socket,
-// so thread identity, messages, approvals, settings, interrupts and inbox state share one runtime.
-export async function runManagedCodex(args = [], {
-  home = os.homedir(),
-  env = process.env,
-  spawn = spawnChild,
-  mkdir = (dir) => fs.mkdirSync(dir, { recursive: true, mode: 0o700 }),
-  unlink = (file) => { try { fs.unlinkSync(file); } catch (error) { if (error?.code !== 'ENOENT') throw error; } },
-  waitOptions,
-} = {}) {
-  const pane = env.TMUX_PANE;
-  const socketPath = codexAppSocketPath(pane, home);
-  mkdir(path.dirname(socketPath));
-  unlink(socketPath);
-
-  const managedEnv = { ...env, HANDMUX_CODEX_MANAGED: '1' };
-  const appServer = spawn('codex', ['app-server', '--listen', `unix://${socketPath}`], {
-    env: managedEnv,
-    stdio: ['ignore', 'ignore', 'ignore'],
-  });
-  let tui = null;
-  try {
-    await waitForSocket(socketPath, appServer, waitOptions);
-    tui = spawn('codex', ['--remote', `unix://${socketPath}`, ...args], {
-      env: managedEnv,
-      stdio: 'inherit',
-    });
-    const result = await finish(tui);
-    return Number.isInteger(result.code) ? result.code : 1;
-  } finally {
-    if (tui && tui.exitCode == null && tui.signalCode == null) tui.kill('SIGTERM');
-    if (appServer.exitCode == null && appServer.signalCode == null) appServer.kill('SIGTERM');
-    unlink(socketPath);
-  }
-}

package/src/cli/drivers.js

@@ -1,97 +0,0 @@
-// Tunnel driver registry. A driver only DESCRIBES how to expose the local server (what process to spawn,
-// how to read the public URL out of its output); the supervisor owns process lifecycle (spawn, restart,
-// kill). Declarative → unit-testable without spawning. matchUrl receives (chunk, cfg): cloudflare scrapes
-// a random URL from logs; ssh / cloudflare-named already KNOW the URL (cfg.publicUrl) and only gate it on
-// a readiness signal so the QR isn't shown before the tunnel is live.
-import { extractCloudflareUrl } from './cloudflareUrl.js';
-import { isTunnelConnected } from './sshTunnel.js';
-import { cfNamedReady } from './cfNamed.js';
-import { extractNatappUrl } from './natappUrl.js';
-import { extractCpolarUrl, cpolarNamedArgs } from './cpolarUrl.js';
-import { hostIn } from './urlHost.js';
-
-export const DRIVERS = {
-  none: {
-    name: 'none',
-    needsProcess: false,
-    proc: () => null,
-    matchUrl: () => null,
-  },
-  cloudflare: {
-    name: 'cloudflare',
-    needsProcess: true,
-    notFoundHint: 'cloudflared not found — install it (brew install cloudflared)',
-    proc: (cfg) => ({
-      cmd: cfg.cloudflaredBin || 'cloudflared',
-      // --grace-period 0s: drop the edge connection immediately on SIGTERM instead of draining for the 30s
-      // default, so `stop`/`restart` don't leave the tunnel lingering on Cloudflare's side (it would look
-      // "still running" remotely and overlap a restart). See supervisor.shutdown for the local-process side.
-      args: ['tunnel', '--grace-period', '0s', '--url', `http://localhost:${cfg.port}`],
-    }),
-    matchUrl: (chunk) => extractCloudflareUrl(chunk),
-  },
-  'cloudflare-named': {
-    name: 'cloudflare-named',
-    needsProcess: true,
-    notFoundHint: 'cloudflared not found — run `handmux setup` to provision the named tunnel',
-    proc: (cfg) => ({
-      cmd: cfg.cloudflaredBin || 'cloudflared',
-      // --grace-period 0s goes BEFORE the `run` subcommand (it's a `cloudflared tunnel` flag). Same reason as
-      // the quick tunnel: disconnect immediately on stop so the named tunnel doesn't linger on the edge.
-      args: ['tunnel', '--grace-period', '0s', 'run', cfg.cfTunnelName],
-    }),
-    matchUrl: (chunk, cfg) => (cfNamedReady(chunk) ? cfg.publicUrl : null),
-  },
-  ssh: {
-    name: 'ssh',
-    needsProcess: true,
-    notFoundHint: 'tunlite not found — install it (npm i -g tunlite / npx tunlite install)',
-    proc: (cfg) => ({
-      cmd: cfg.tunliteBin || 'tunlite',
-      args: ['run', '--to', cfg.sshHost, '-R', `${cfg.remotePort}:localhost:${cfg.port}`,
-        '--name', 'handmux', '--json', ...(cfg.sshJump ? ['--jump', cfg.sshJump] : [])],
-    }),
-    matchUrl: (chunk, cfg) => (isTunnelConnected(chunk) ? cfg.publicUrl : null),
-  },
-  // natapp / cpolar — ngrok-derived domestic tunnels (China-usable when cloudflare's edge isn't). Both take a
-  // stable `authtoken`; both default to a full-screen TUI, so we force `-log=stdout` to get scrapeable text.
-  // FREE tier = random domain we scrape; a fixed/reserved domain arrives via publicUrl (see cfg.publicUrl).
-  natapp: {
-    name: 'natapp',
-    needsProcess: true,
-    notFoundHint: 'natapp not found — download it from https://natapp.cn (login required) into ~/.handmux/bin/',
-    proc: (cfg) => ({
-      cmd: cfg.natappBin || 'natapp',
-      args: [`-authtoken=${cfg.authtoken}`, '-log=stdout'],
-    }),
-    // The reserved/paid zone is arbitrary (natapp1.cc / your own) so we can't scrape it — gate on the known
-    // host echoing in the log. Free tier has no publicUrl → scrape the natappfree.cc URL.
-    matchUrl: (chunk, cfg) => (cfg.publicUrl
-      ? (hostIn(chunk, cfg.publicUrl) ? cfg.publicUrl : null)
-      : extractNatappUrl(chunk)),
-  },
-  cpolar: {
-    name: 'cpolar',
-    needsProcess: true,
-    notFoundHint: 'cpolar not found — install it (or run `handmux setup`, which auto-downloads it)',
-    proc: (cfg) => ({
-      cmd: cfg.cpolarBin || 'cpolar',
-      // authtoken is seeded into cpolar's own config beforehand (handmux.js / setup); a reserved subdomain or
-      // bound domain becomes -subdomain/-hostname; -region selects the edge (cn = mainland China).
-      args: ['http', '-log=stdout',
-        ...cpolarNamedArgs(cfg.publicUrl),
-        ...(cfg.cpolarRegion ? [`-region=${cfg.cpolarRegion}`] : []),
-        String(cfg.port)],
-    }),
-    // A reserved subdomain is still on the cpolar zone, so scrape it (learns the region-qualified host cpolar
-    // serves); a bound custom domain is off-zone → gate on its known host from publicUrl.
-    matchUrl: (chunk, cfg) => extractCpolarUrl(chunk)
-      || (cfg.publicUrl && hostIn(chunk, cfg.publicUrl) ? cfg.publicUrl : null),
-  },
-};
-
-export function getDriver(name) {
-  const d = DRIVERS[name];
-  if (!d) throw new Error(`unknown tunnel: ${name}`);
-  return d;
-}

package/src/cli/hookScaffold.js

@@ -1,33 +0,0 @@
-// Shared IO scaffolding for the Claude Code hook installer and statusLine capturer.
-import fs from 'node:fs';
-import path from 'node:path';
-
-export const HOOK_SCRIPTS = ['handmux-notify.sh', 'handmux-write.cjs'];
-const LEGACY_HOOK_SCRIPTS = ['handmux-codex-usage.cjs'];
-
-// Atomic write (tmp + rename) so a crash can't leave a half-written config file. Text in, text out — callers
-// pass raw TOML for config.toml, or use writeJsonAtomic for pretty-printed settings.json.
-export function writeFileAtomic(file, text) {
-  const tmp = `${file}.tmp`;
-  fs.writeFileSync(tmp, text);
-  fs.renameSync(tmp, file);
-}
-export const writeJsonAtomic = (file, obj) => writeFileAtomic(file, JSON.stringify(obj, null, 2));
-
-// Deploy the Claude notify/write scripts into `hooksDir` and point their env at the shared state file.
-export function deployHookScripts(hooksDir, srcDir, stateFile) {
-  fs.mkdirSync(hooksDir, { recursive: true });
-  for (const f of HOOK_SCRIPTS) fs.copyFileSync(path.join(srcDir, f), path.join(hooksDir, f));
-  for (const f of LEGACY_HOOK_SCRIPTS) {
-    try { fs.unlinkSync(path.join(hooksDir, f)); } catch { /* absent */ }
-  }
-  fs.chmodSync(path.join(hooksDir, 'handmux-notify.sh'), 0o755);
-  fs.writeFileSync(path.join(hooksDir, 'handmux-notify.env'), `HANDMUX_STATE=${stateFile}\n`, { mode: 0o600 });
-}
-
-// Remove the deployed scripts + env (uninstall). Best-effort: a missing file is fine.
-export function removeHookScripts(hooksDir) {
-  for (const f of [...HOOK_SCRIPTS, ...LEGACY_HOOK_SCRIPTS, 'handmux-notify.env']) {
-    try { fs.unlinkSync(path.join(hooksDir, f)); } catch { /* already gone */ }
-  }
-}