handmux 0.23.0 → 0.25.0

package/src/cli/shortcutEditor.js

@@ -1,288 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { normalizeShortcuts, shortcutIdentity } from '../shortcutConfig.js';
-import { t } from './i18n/index.js';
-import * as prompts from './prompt.js';
-import { acquireLifecycleLock, isAlive, readState } from './state.js';
-
-const MODIFIERS = {
-  none: { prefixes: [], labels: [] },
-  ctrl: { prefixes: ['C-'], labels: ['Ctrl'] },
-  shift: { prefixes: ['S-'], labels: ['Shift'] },
-  alt: { prefixes: ['M-'], labels: ['Alt'] },
-  'ctrl-shift': { prefixes: ['C-', 'S-'], labels: ['Ctrl', 'Shift'] },
-  'ctrl-alt': { prefixes: ['C-', 'M-'], labels: ['Ctrl', 'Alt'] },
-};
-const NAMED_BASES = ['Up', 'Down', 'Left', 'Right', 'Tab', 'Enter', 'Escape', 'Space', 'BSpace', 'Home', 'End', 'PageUp', 'PageDown'];
-const CHAR_BASES = [...'abcdefghijklmnopqrstuvwxyz', ...'0123456789'];
-const DISPLAY = { Escape: 'Esc', BSpace: '⌫', PageUp: 'PgUp', PageDown: 'PgDn' };
-
-export function buildShortcutKey(modifier, base) {
-  const mod = MODIFIERS[modifier];
-  if (!mod) throw new Error(`unknown modifier: ${modifier}`);
-  if (!NAMED_BASES.includes(base) && !CHAR_BASES.includes(base)) throw new Error(`unsupported base key: ${base}`);
-  if (CHAR_BASES.includes(base) && modifier === 'none') throw new Error('a character key needs a modifier');
-  if (CHAR_BASES.includes(base) && mod.prefixes.includes('S-')) throw new Error('Shift + character is not a distinct tmux key');
-  const key = base === 'Tab' && modifier === 'shift'
-    ? 'BTab'
-    : `${mod.prefixes.join('')}${CHAR_BASES.includes(base) ? base.toLowerCase() : base}`;
-  const shownBase = CHAR_BASES.includes(base) ? base.toUpperCase() : (DISPLAY[base] || base);
-  return { type: 'key', key, label: [...mod.labels, shownBase].join('+') };
-}
-
-export function moveShortcut(items, index, target) {
-  if (index < 0 || target < 0 || index >= items.length || target >= items.length || target === index) return items;
-  const next = items.slice();
-  const [item] = next.splice(index, 1);
-  next.splice(target, 0, item);
-  return next;
-}
-
-function readExisting(target) {
-  try { return JSON.parse(fs.readFileSync(target, 'utf8')); }
-  catch (error) {
-    if (error.code === 'ENOENT') return {};
-    throw error;
-  }
-}
-
-export function saveShortcutConfig(target, shortcuts) {
-  const existing = readExisting(target);
-  const cfg = { ...existing, shortcuts: normalizeShortcuts(shortcuts) };
-  fs.mkdirSync(path.dirname(target), { recursive: true });
-  const tmp = `${target}.tmp`;
-  fs.writeFileSync(tmp, JSON.stringify(cfg, null, 2) + '\n', { mode: 0o600 });
-  fs.renameSync(tmp, target);
-  fs.chmodSync(target, 0o600);
-  return cfg;
-}
-
-const defaultUi = {
-  intro: prompts.intro,
-  outro: prompts.outro,
-  cancel: prompts.cancel,
-  select: prompts.select,
-  text: prompts.text,
-  confirm: prompts.confirm,
-  ask: prompts.ask,
-};
-
-const modeLabel = (mode) => t(mode === 'command' ? 'shortcuts.command' : 'shortcuts.chat');
-const itemLabel = (item) => item.type === 'key' ? item.label : item.text;
-const itemHint = (item) => item.type === 'key'
-  ? t('shortcuts.key')
-  : t(item.enter ? 'shortcuts.textEnter' : 'shortcuts.textOnly');
-const positionOptions = (items, index = null) => {
-  const remaining = index === null ? items : items.filter((_item, i) => i !== index);
-  const count = remaining.length + 1;
-  if (remaining.length === 0) return [{ value: 0, label: t('shortcuts.positionLast', { n: 1 }) }];
-  return Array.from({ length: count }, (_item, target) => {
-    if (target === 0) return { value: target, label: t('shortcuts.positionFirst') };
-    if (target === count - 1) return { value: target, label: t('shortcuts.positionLast', { n: count }) };
-    return {
-      value: target,
-      label: t('shortcuts.positionAfter', { n: target + 1, item: itemLabel(remaining[target - 1]) }),
-    };
-  });
-};
-const validateText = (value) => {
-  if (typeof value !== 'string' || !value.length || /[\r\n\x00-\x1f\x7f]/.test(value)) return t('shortcuts.badText');
-  return undefined;
-};
-
-function parseShortcutKey(item) {
-  if (!item || item.type !== 'key') return { modifier: 'none', base: 'Escape' };
-  if (item.key === 'BTab') return { modifier: 'shift', base: 'Tab' };
-  let key = item.key;
-  const ctrl = key.startsWith('C-'); if (ctrl) key = key.slice(2);
-  const alt = key.startsWith('M-'); if (alt) key = key.slice(2);
-  const shift = key.startsWith('S-'); if (shift) key = key.slice(2);
-  const modifier = ctrl && alt ? 'ctrl-alt' : ctrl && shift ? 'ctrl-shift'
-    : ctrl ? 'ctrl' : alt ? 'alt' : shift ? 'shift' : 'none';
-  return { modifier, base: key };
-}
-
-const modifierOptions = () => Object.entries(MODIFIERS).map(([value, item]) => ({
-  value, label: item.labels.length ? item.labels.join('+') : t('shortcuts.noModifier'),
-}));
-const baseOptions = (modifier) => {
-  const allowChars = modifier !== 'none' && !MODIFIERS[modifier].prefixes.includes('S-');
-  return [...NAMED_BASES, ...(allowChars ? CHAR_BASES : [])].map((value) => ({
-    value, label: DISPLAY[value] || value.toUpperCase?.() || value,
-  }));
-};
-
-async function editItem(mode, seed, ui, forcedType = null) {
-  const type = forcedType || await ui.ask(ui.select({
-    message: t('shortcuts.type'), initialValue: seed?.type || 'text',
-    options: [
-      { value: 'text', label: t('shortcuts.text') },
-      { value: 'key', label: t('shortcuts.key') },
-    ],
-  }));
-  if (type === 'text') {
-    const text = await ui.ask(ui.text({
-      message: t('shortcuts.textPrompt'), initialValue: seed?.type === 'text' ? seed.text : '', validate: validateText,
-    }));
-    const enter = await ui.ask(ui.confirm({
-      message: t('shortcuts.enter'), initialValue: seed?.type === 'text' ? seed.enter : mode === 'chat',
-    }));
-    return { type: 'text', text, enter };
-  }
-  const parsed = parseShortcutKey(seed);
-  const modifier = await ui.ask(ui.select({
-    message: t('shortcuts.modifier'), initialValue: parsed.modifier, options: modifierOptions(),
-  }));
-  const available = baseOptions(modifier);
-  const base = await ui.ask(ui.select({
-    message: t('shortcuts.base'),
-    initialValue: available.some((option) => option.value === parsed.base) ? parsed.base : available[0].value,
-    options: available,
-  }));
-  return buildShortcutKey(modifier, base);
-}
-
-async function editMode(mode, initial, ui) {
-  let items = initial.slice();
-  for (;;) {
-    const choice = await ui.ask(ui.select({
-      message: modeLabel(mode),
-      options: [
-        ...items.map((item, index) => ({ value: `item:${index}`, label: itemLabel(item), hint: itemHint(item) })),
-        { value: 'add-key', label: t('shortcuts.addKey') },
-        { value: 'add-text', label: t('shortcuts.addText') },
-        { value: 'back', label: t('shortcuts.back') },
-      ],
-    }));
-    if (choice === 'back') return items;
-    if (choice === 'add-key' || choice === 'add-text') {
-      const item = await editItem(mode, null, ui, choice === 'add-key' ? 'key' : 'text');
-      if (!items.some((existing) => shortcutIdentity(existing) === shortcutIdentity(item))) {
-        const target = await ui.ask(ui.select({
-          message: t('shortcuts.addPositionPrompt'), options: positionOptions(items),
-        }));
-        items = moveShortcut([...items, item], items.length, target);
-      }
-      continue;
-    }
-    const index = Number(choice.slice(5));
-    const action = await ui.ask(ui.select({
-      message: itemLabel(items[index]),
-      options: [
-        { value: 'edit', label: t('shortcuts.edit') },
-        ...(items.length > 1 ? [{ value: 'move', label: t('shortcuts.move') }] : []),
-        { value: 'delete', label: t('shortcuts.delete') },
-        { value: 'back', label: t('shortcuts.back') },
-      ],
-    }));
-    if (action === 'edit') {
-      const edited = await editItem(mode, items[index], ui);
-      if (!items.some((item, i) => i !== index && shortcutIdentity(item) === shortcutIdentity(edited))) {
-        items = items.map((item, i) => i === index ? edited : item);
-      }
-    } else if (action === 'move') {
-      const target = await ui.ask(ui.select({
-        message: t('shortcuts.movePrompt', { n: index + 1 }), options: positionOptions(items, index),
-      }));
-      items = moveShortcut(items, index, target);
-    } else if (action === 'delete') items = items.filter((_item, i) => i !== index);
-  }
-}
-
-export async function runShortcutEditor({
-  target, log = console, isTTY = process.stdin.isTTY, ui = defaultUi,
-  commit = async (file, shortcuts) => ({ cfg: saveShortcutConfig(file, shortcuts) }),
-} = {}) {
-  if (!isTTY) { log.error(t('shortcuts.needTty')); return { error: 'non-tty' }; }
-  const existing = readExisting(target);
-  let shortcuts = normalizeShortcuts(existing.shortcuts);
-  ui.intro('handmux shortcuts');
-  try {
-    for (;;) {
-      const choice = await ui.ask(ui.select({
-        message: t('shortcuts.title'),
-        options: [
-          { value: 'command', label: modeLabel('command'), hint: t('shortcuts.count', { n: shortcuts.command.length }) },
-          { value: 'chat', label: modeLabel('chat'), hint: t('shortcuts.count', { n: shortcuts.chat.length }) },
-          { value: 'save', label: t('shortcuts.save') },
-          { value: 'exit', label: t('shortcuts.exit') },
-        ],
-      }));
-      if (choice === 'exit') { ui.cancel(t('shortcuts.exited')); return null; }
-      if (choice === 'command' || choice === 'chat') {
-        shortcuts = { ...shortcuts, [choice]: await editMode(choice, shortcuts[choice], ui) };
-        continue;
-      }
-      const result = await commit(target, shortcuts);
-      ui.outro(t('shortcuts.wrote', { path: target }));
-      return result;
-    }
-  } catch (error) {
-    if (error === prompts.CANCELLED) { ui.cancel(t('shortcuts.exited')); return null; }
-    throw error;
-  }
-}
-
-export async function applyShortcutsLive({
-  state, shortcuts, fetchImpl = globalThis.fetch, timeoutMs = 8000,
-}) {
-  if (!state?.localUrl || !state?.token) throw new Error('running server state is incomplete');
-  const base = state.localUrl.replace(/\/$/, '');
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
-  try {
-    const response = await fetchImpl(`${base}/api/config/shortcuts`, {
-      method: 'PUT',
-      redirect: 'manual',
-      signal: controller.signal,
-      headers: { Authorization: `Bearer ${state.token}`, 'Content-Type': 'application/json' },
-      body: JSON.stringify({ shortcuts }),
-    });
-    if (!response.ok) throw new Error(`server returned HTTP ${response.status}`);
-    let acknowledgment;
-    try { acknowledgment = await response.json(); } catch { /* validated below */ }
-    if (acknowledgment?.ok !== true) throw new Error('invalid server response');
-  } catch (error) {
-    if (controller.signal.aborted) throw new Error(`server request timed out after ${timeoutMs}ms`);
-    throw error;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
-// Keep the durable write and the runtime replacement in one short cross-process critical section.
-// Otherwise two editors can interleave their save/PUT calls and leave disk and memory disagreeing.
-export async function commitShortcuts({
-  home, target, shortcuts,
-  acquireLock = acquireLifecycleLock,
-  readStateImpl = readState,
-  isAliveImpl = isAlive,
-  saveImpl = saveShortcutConfig,
-  fetchImpl = globalThis.fetch,
-  timeoutMs = 8000,
-}) {
-  const release = acquireLock(home);
-  try {
-    const cfg = saveImpl(target, shortcuts);
-    const state = readStateImpl(home);
-    if (!state || !isAliveImpl(state.supervisorPid)) return { cfg, running: false, applied: false };
-    try {
-      await applyShortcutsLive({ state, shortcuts: cfg.shortcuts, fetchImpl, timeoutMs });
-      return { cfg, running: true, applied: true };
-    } catch (error) {
-      return { cfg, running: true, applied: false, error };
-    }
-  } finally {
-    release();
-  }
-}
-
-export function reportShortcutCommit(result, output = console) {
-  if (!result.running) return 0;
-  if (result.applied) {
-    output.log(t('shortcuts.applied'));
-    return 0;
-  }
-  output.error(t('shortcuts.applyFailed', { msg: result.error?.message || 'unknown error' }));
-  return 1;
-}

package/src/cli/sshTunnel.js

@@ -1,12 +0,0 @@
-// Pure: detect tunlite `run --json` reaching the `connected` state from an NDJSON log chunk. tunlite
-// self-reconnects, so we only flip to "live" on a real connected event (mirrors cloudflare URL-scrape:
-// don't surface the public URL until the tunnel is actually up). Side-effect-free → unit-tested against
-// real captured NDJSON lines.
-export function isTunnelConnected(text) {
-  for (const line of String(text || '').split('\n')) {
-    const s = line.trim();
-    if (!s) continue;
-    try { if (JSON.parse(s).state === 'connected') return true; } catch { /* partial / non-json line */ }
-  }
-  return false;
-}

package/src/cli/state.js

@@ -1,90 +0,0 @@
-// Runtime state lives in ~/.handmux/ — a single state.json (pids + the live public URL) plus a log
-// file the detached supervisor writes to. `home` is injectable so this unit-tests in a temp dir.
-import fs from 'node:fs';
-import path from 'node:path';
-import { homedir } from 'node:os';
-
-export function pocketHome(home = homedir()) { return path.join(home, '.handmux'); }
-export function statePath(home) { return path.join(pocketHome(home), 'state.json'); }
-export function lifecycleLockPath(home) { return path.join(pocketHome(home), 'lifecycle.lock'); }
-export function logPath(home) { return path.join(pocketHome(home), 'handmux.log'); }
-export function configPath(home) { return path.join(pocketHome(home), 'config.json'); }
-
-// The hook-maintained Claude state file, on a stable per-user path (survives a global reinstall, unlike
-// the package-internal server/data default). The CLI sets this as CLAUDE_STATE_FILE for the server child
-// and writes the same path into the hook's env, so both ends read/write one file.
-export function claudeStatePath(home) { return path.join(pocketHome(home), 'claude-state.json'); }
-
-// Push subscriptions and the dynamic-preview registry are mutable runtime data too, so they belong on the
-// same stable per-user path — NOT the package-internal server/data default, which a `npm i -g handmux`
-// reinstall replaces (silently dropping every saved subscription). The CLI injects these as PUSH_STORE /
-// PREVIEW_STORE for the server child.
-export function pushStorePath(home) { return path.join(pocketHome(home), 'push-subs.json'); }
-export function previewStorePath(home) { return path.join(pocketHome(home), 'previews.json'); }
-export function notificationsDirPath(home) { return path.join(pocketHome(home), 'notifications'); }
-
-export function readState(home) {
-  try { return JSON.parse(fs.readFileSync(statePath(home), 'utf8')); } catch { return null; }
-}
-
-// Atomic write (tmp + rename): the supervisor persist()s frequently while the CLI concurrently readState()s
-// (waitAndPrint/status), so a plain writeFileSync could be caught mid-write and JSON.parse-fail — silently
-// degrading to "not running". rename is atomic on the same filesystem, so a reader sees old or new, never torn.
-export function writeState(state, home) {
-  fs.mkdirSync(pocketHome(home), { recursive: true });
-  const file = statePath(home);
-  const tmp = `${file}.tmp`;
-  fs.writeFileSync(tmp, JSON.stringify(state, null, 2));
-  fs.renameSync(tmp, file);
-}
-
-export function clearState(home) {
-  try { fs.unlinkSync(statePath(home)); } catch { /* already gone */ }
-}
-
-// pid liveness without sending a real signal: kill(pid, 0) throws ESRCH if dead, EPERM if alive but
-// not ours (still counts as running).
-export function isAlive(pid) {
-  if (!pid) return false;
-  try { process.kill(pid, 0); return true; } catch (e) { return e.code === 'EPERM'; }
-}
-
-const LIFECYCLE_LOCK_STALE_MS = 10 * 60 * 1000;
-
-// Cross-process mutex for start/stop/restart/service operations. `wx` is atomic even when two shells run
-// start at exactly the same time. A killed CLI leaves a tiny stale file; its dead owner is detected and
-// reclaimed on the next operation. The release closure only removes a lock still owned by this process.
-export function acquireLifecycleLock(home, pid = process.pid) {
-  fs.mkdirSync(pocketHome(home), { recursive: true });
-  const file = lifecycleLockPath(home);
-  const stamp = JSON.stringify({ pid, createdAt: Date.now() });
-  for (let attempt = 0; attempt < 2; attempt++) {
-    try {
-      fs.writeFileSync(file, stamp, { flag: 'wx' });
-      return () => {
-        try {
-          if (fs.readFileSync(file, 'utf8') === stamp) fs.unlinkSync(file);
-        } catch { /* already gone/replaced */ }
-      };
-    } catch (e) {
-      if (e.code !== 'EEXIST') throw e;
-      let owner = 0, createdAt = 0;
-      try {
-        const raw = fs.readFileSync(file, 'utf8').trim();
-        const parsed = JSON.parse(raw);
-        owner = Number(parsed.pid);
-        createdAt = Number(parsed.createdAt);
-      } catch { /* malformed/legacy → stale unless its plain pid is live */
-        try { owner = Number(fs.readFileSync(file, 'utf8').trim()); } catch { /* stale */ }
-      }
-      const fresh = !createdAt || (Date.now() - createdAt) < LIFECYCLE_LOCK_STALE_MS;
-      if (owner && fresh && isAlive(owner)) {
-        const err = new Error(`lifecycle operation already running (pid ${owner})`);
-        err.ownerPid = owner;
-        throw err;
-      }
-      try { fs.unlinkSync(file); } catch { /* raced with another contender */ }
-    }
-  }
-  throw new Error('could not acquire lifecycle lock');
-}

package/src/cli/statusLine.js

@@ -1,90 +0,0 @@
-// Install/uninstall the handmux Claude statusLine — the capturer that snapshots the 5h/weekly rate-limit %
-// (from Claude Code's statusLine stdin, the only documented local source) to ~/.handmux/claude-usage.json
-// for the phone's Usage page. Opt-in, and NON-DESTRUCTIVE by design: Claude allows exactly one statusLine,
-// so if the user already has their OWN we NEVER clobber it — we report 'foreign' and the CLI prints a
-// one-line compose snippet instead. We only ever write settings.statusLine when it's absent or already ours.
-//
-// Iron rule (same as claudeHooks): only ever touch ~/.handmux/ and — after opt-in — ~/.claude/. Never
-// create ~/.claude.
-import fs from 'node:fs';
-import path from 'node:path';
-import { homedir } from 'node:os';
-import { writeJsonAtomic } from './hookScaffold.js';
-
-const STATUS_MARK = 'handmux-statusline.cjs'; // identifies our statusLine command among the user's own
-const SCRIPT = 'handmux-statusline.cjs';
-
-function claudeDir(home = homedir()) { return path.join(home, '.claude'); }
-function settingsPath(home = homedir()) { return path.join(claudeDir(home), 'settings.json'); }
-
-function readSettings(home) {
-  try { return JSON.parse(fs.readFileSync(settingsPath(home), 'utf8')); } catch { return {}; }
-}
-
-function isOurs(sl) {
-  return !!(sl && typeof sl.command === 'string' && sl.command.includes(STATUS_MARK));
-}
-
-// 'no-claude' → ~/.claude absent. 'ours' → our statusLine is installed. 'foreign' → the user has their own
-// statusLine (we must not touch it). 'absent' → Claude Code is here but no statusLine configured.
-export function statusLineStatus(home = homedir()) {
-  if (!fs.existsSync(claudeDir(home))) return 'no-claude';
-  const sl = readSettings(home).statusLine;
-  if (isOurs(sl)) return 'ours';
-  if (sl && (sl.command || sl.type)) return 'foreign';
-  return 'absent';
-}
-
-// The exact command a user with an EXISTING statusline appends to capture without changing their display:
-// pipe their statusline's stdin through our capturer in TEE mode first. Returned so the CLI can print it.
-export function composeHint(home = homedir(), { usageFile } = {}) {
-  const dest = path.join(claudeDir(home), 'hooks', SCRIPT);
-  return `HANDMUX_STATUS_TEE=1 node ${dest} ${usageFile} | <your existing statusline>`;
-}
-
-// Install (opt-in): copy the capturer to ~/.claude/hooks/ and point settings.statusLine at it — but ONLY
-// when it's safe (absent or already ours). A 'foreign' statusLine is left untouched. Returns { status }.
-//   srcDir    = bundled hooks dir (server/hooks)
-//   usageFile = ~/.handmux/claude-usage.json (the snapshot the server reads)
-export function installStatusLine(home = homedir(), { srcDir, usageFile } = {}) {
-  if (!fs.existsSync(claudeDir(home))) return { status: 'no-claude' };
-  const status = statusLineStatus(home);
-  // Always deploy the capturer script (it's ours, inert until invoked) so the compose one-liner works even
-  // in the foreign case. Only the settings.statusLine write is gated on not clobbering the user's own.
-  const hooksDir = path.join(claudeDir(home), 'hooks');
-  fs.mkdirSync(hooksDir, { recursive: true });
-  const dest = path.join(hooksDir, SCRIPT);
-  fs.copyFileSync(path.join(srcDir, SCRIPT), dest);
-  if (status === 'foreign') return { status: 'foreign', script: dest }; // never touch their statusLine
-  const settings = readSettings(home);
-  settings.statusLine = { type: 'command', command: `node ${dest} ${usageFile}` };
-  writeJsonAtomic(settingsPath(home), settings);
-  return { status: 'installed' };
-}
-
-// Refresh the on-disk capturer script to the BUNDLED version without touching settings.statusLine — so an
-// npm upgrade actually reaches a user who already opted in. Critically settings-safe: a user who composed us
-// into their OWN statusline (the TEE form) still reads as 'ours' (the command contains our mark), and we must
-// NOT rewrite their command to the bare form (that would drop their downstream renderer). So this only ever
-// copies the script. No-op (returns false) when we're not installed. Idempotent; safe to call every start.
-export function refreshStatusLineScript(home = homedir(), { srcDir } = {}) {
-  if (statusLineStatus(home) !== 'ours') return false;
-  try {
-    const dest = path.join(claudeDir(home), 'hooks', SCRIPT);
-    fs.mkdirSync(path.dirname(dest), { recursive: true });
-    fs.copyFileSync(path.join(srcDir, SCRIPT), dest);
-    return true;
-  } catch { return false; }
-}
-
-// Uninstall: drop settings.statusLine only if it's ours, and remove the copied script. Leaves a foreign
-// statusLine and everything else intact.
-export function uninstallStatusLine(home = homedir()) {
-  const settings = readSettings(home);
-  if (isOurs(settings.statusLine)) {
-    delete settings.statusLine;
-    if (fs.existsSync(settingsPath(home))) writeJsonAtomic(settingsPath(home), settings);
-  }
-  try { fs.unlinkSync(path.join(claudeDir(home), 'hooks', SCRIPT)); } catch { /* already gone */ }
-  return { status: 'absent' };
-}

package/src/cli/supervisor.js

@@ -1,183 +0,0 @@
-// The single long-running supervisor. It owns the node server (and, for a process-backed tunnel like
-// cloudflare, the tunnel) as CHILD processes, restarts them with a small backoff on exit, and records
-// the live public URL into state.json. There is only ever one daemon here — cloudflared (and, later,
-// `tunlite run`) are just its children, exactly like the server is.
-import { spawn } from 'node:child_process';
-import net from 'node:net';
-import path from 'node:path';
-import os from 'node:os';
-import { fileURLToPath } from 'node:url';
-import { createRequire } from 'node:module';
-import { getDriver } from './drivers.js';
-import { writeState, clearState, claudeStatePath, pushStorePath, previewStorePath, notificationsDirPath } from './state.js';
-
-const here = path.dirname(fileURLToPath(import.meta.url));
-const SERVER = path.resolve(here, '../server.js');
-const require = createRequire(import.meta.url);
-const VERSION = require('../../package.json').version;
-
-// First non-internal IPv4 — the address a phone on the same wifi uses when there's no tunnel.
-export function lanUrl(port, ifaces = os.networkInterfaces()) {
-  for (const list of Object.values(ifaces)) {
-    for (const ni of list || []) {
-      if (ni.family === 'IPv4' && !ni.internal) return `http://${ni.address}:${port}`;
-    }
-  }
-  return null;
-}
-
-// The token rides in the query string so the first navigation (or a QR scan) authenticates in one shot.
-export function publicUrlWithToken(base, token) {
-  if (!base) return base;
-  return `${base.replace(/\/$/, '')}/?token=${encodeURIComponent(token)}`;
-}
-
-// Bare address with no token in it — printed/QR-encoded so a link can be shared or screenshotted without
-// leaking the secret; the token is shown separately for the user to paste in.
-export function bareUrl(base) {
-  if (!base) return base;
-  return `${base.replace(/\/$/, '')}/`;
-}
-
-export function browserPublicOriginEnv(cfg) {
-  return {
-    ...(cfg.previewDomain ? { HANDMUX_PREVIEW_DOMAIN: cfg.previewDomain } : {}),
-    ...(cfg.publicUrl ? { HANDMUX_PUBLIC_URL: cfg.publicUrl } : {}),
-  };
-}
-
-export function supervise(cfg, { home, log = console } = {}) {
-  const driver = getDriver(cfg.tunnel);
-  const children = {};
-  let stopping = false;
-  let urlBuf = '';
-  let backoff = 500;
-
-  const state = {
-    supervisorPid: process.pid,
-    version: VERSION,
-    startedAt: Date.now(),
-    tunnel: cfg.tunnel,
-    port: cfg.port,
-    host: cfg.host,
-    token: cfg.token,
-    localUrl: `http://localhost:${cfg.port}`,
-    lanUrl: lanUrl(cfg.port),
-    publicUrl: null,
-    ready: false,
-    error: null,
-  };
-  const persist = () => writeState(state, home);
-  persist();
-
-  // The server socket comes up a beat after spawn; don't report "ready" (and don't let the CLI print an
-  // access URL) until a TCP connect to it actually succeeds, or callers race an unbound port.
-  const waitListening = () => {
-    if (stopping || state.ready) return;
-    const s = net.connect({ port: cfg.port, host: '127.0.0.1' });
-    const retry = () => { s.destroy(); if (!stopping) setTimeout(waitListening, 200); };
-    s.setTimeout(500, retry);
-    s.once('error', retry);
-    s.once('connect', () => { s.destroy(); state.ready = true; persist(); });
-  };
-
-  const startServer = () => {
-    // The server reads only process.env (no .env files) — the CLI resolved the one config file and we
-    // hand the server everything it needs here. This is the single injection point: config.json fields →
-    // the env names the server already reads (HANDMUX_* / VAPID_* / XFYUN_*).
-    const env = {
-      ...process.env,
-      NODE_ENV: 'handmux',
-      HANDMUX_PORT: String(cfg.port),
-      HANDMUX_HOST: cfg.host,
-      HANDMUX_TOKEN: cfg.token,
-      CLAUDE_STATE_FILE: claudeStatePath(home),
-      PUSH_STORE: pushStorePath(home),
-      PREVIEW_STORE: previewStorePath(home),
-      NOTIF_DIR: notificationsDirPath(home),
-      ...browserPublicOriginEnv(cfg),
-    };
-    if (cfg.name) env.HANDMUX_APP_NAME = cfg.name;
-    if (cfg.staticDir) env.HANDMUX_STATIC_DIR = cfg.staticDir;
-    if (cfg.uploadExts) env.HANDMUX_UPLOAD_EXTS = cfg.uploadExts;
-    env.HANDMUX_SHORTCUTS = JSON.stringify(cfg.shortcuts);
-    if (cfg.vapid) {
-      if (cfg.vapid.public) env.VAPID_PUBLIC = cfg.vapid.public;
-      if (cfg.vapid.private) env.VAPID_PRIVATE = cfg.vapid.private;
-      if (cfg.vapid.subject) env.VAPID_SUBJECT = cfg.vapid.subject;
-    }
-    if (cfg.xfyun) {
-      if (cfg.xfyun.appId) env.XFYUN_APPID = cfg.xfyun.appId;
-      if (cfg.xfyun.apiKey) env.XFYUN_APIKEY = cfg.xfyun.apiKey;
-      if (cfg.xfyun.apiSecret) env.XFYUN_APISECRET = cfg.xfyun.apiSecret;
-    }
-    const c = spawn(process.execPath, [SERVER], { env, stdio: ['ignore', 'inherit', 'inherit'] });
-    children.server = c;
-    state.serverPid = c.pid; persist();
-    c.on('exit', () => { if (!stopping) backoffRestart('server', startServer); });
-  };
-
-  const startTunnel = () => {
-    if (!driver.needsProcess) { // 'none' — reachable directly on LAN/localhost (or a tunnel you run yourself)
-      state.publicUrl = cfg.publicUrl || state.lanUrl || state.localUrl; persist(); return;
-    }
-    const spec = driver.proc(cfg);
-    const c = spawn(spec.cmd, spec.args, { stdio: ['ignore', 'pipe', 'pipe'] });
-    children.tunnel = c;
-    state.tunnelPid = c.pid; persist();
-    const onData = (b) => {
-      const s = b.toString();
-      process.stdout.write(s);
-      if (state.publicUrl) return;
-      urlBuf = (urlBuf + s).slice(-4000);
-      const url = driver.matchUrl(urlBuf, cfg);
-      if (url) { state.publicUrl = url; state.error = null; backoff = 500; persist(); }
-    };
-    c.stdout.on('data', onData);
-    c.stderr.on('data', onData);
-    c.on('error', (e) => {
-      state.error = e.code === 'ENOENT'
-        ? (driver.notFoundHint || `${spec.cmd} not found`)
-        : String(e);
-      persist();
-    });
-    c.on('exit', () => { if (!stopping) { state.publicUrl = null; persist(); backoffRestart('tunnel', startTunnel); } });
-  };
-
-  const backoffRestart = (what, fn) => {
-    const d = Math.min(backoff, 15000);
-    backoff = Math.min(backoff * 2, 15000);
-    log.warn?.(`[handmux] ${what} exited; restarting in ${d}ms`);
-    setTimeout(() => { if (!stopping) fn(); }, d);
-  };
-
-  const shutdown = () => {
-    stopping = true;
-    const kids = Object.values(children).filter(Boolean);
-    for (const c of kids) { try { c.kill('SIGTERM'); } catch { /* already dead */ } }
-    clearState(home);
-    // Don't exit on a fixed timer — that orphans any child still shutting down (a SIGKILL'd or crashed
-    // supervisor was how a stray cloudflared kept running after `stop`). Poll until the children are gone,
-    // then SIGKILL any straggler so we NEVER leak a tunnel process. With --grace-period 0s, cloudflared
-    // exits near-instantly; the 3s ceiling is just a backstop.
-    const alive = () => kids.filter((c) => { try { process.kill(c.pid, 0); return true; } catch { return false; } });
-    let waited = 0;
-    const tick = () => {
-      const left = alive();
-      if (left.length === 0 || waited >= 3000) {
-        for (const c of left) { try { c.kill('SIGKILL'); } catch { /* already dead */ } }
-        process.exit(0);
-      }
-      waited += 150;
-      setTimeout(tick, 150);
-    };
-    tick();
-  };
-  process.on('SIGTERM', shutdown);
-  process.on('SIGINT', shutdown);
-
-  startServer();
-  startTunnel();
-  waitListening();
-  return { state };
-}