handmux 0.23.0 → 0.25.0

package/src/docs.js

@@ -1,228 +0,0 @@
-import { promises as fs } from 'node:fs';
-import { homedir } from 'node:os';
-import { join, basename } from 'node:path';
-import { docTypeFor, imageTypeFor, isUnder, hasHiddenSegment } from './docPath.js';
-
-const MAX_READ_BYTES = 2 * 1024 * 1024;        // 2MB cap for in-app text reads (readDoc)
-// Single source of truth for the 50MB transfer cap, shared by download (maxDownloadBytes default
-// below) and upload (httpApi.js imports this as the maxUploadBytes default). Server-side only.
-export const MAX_TRANSFER_BYTES = 50 * 1024 * 1024;
-
-// Flatten an absolute cwd into ONE filesystem-safe path segment for the per-project upload space,
-// Claude-Code style: '/' → '-' (so /Users/x/proj → -Users-x-proj), and any other non-portable char
-// → '_'. A valid cwd always starts with '/', so the key always starts with '-' — it can never be
-// '..'/'.' and, having no separators, can never escape the uploads root. Empty/relative → '_default'.
-export function encodeCwdKey(cwd) {
-  if (typeof cwd !== 'string' || cwd[0] !== '/') return '_default';
-  return cwd.replace(/\//g, '-').replace(/[^A-Za-z0-9._-]/g, '_') || '_default';
-}
-
-// Factory bound to a `home` root. All reads pass through fs.realpath then isUnder(realHome):
-// realpath collapses ../ and resolves symlinks, so the home-containment check is the final word —
-// a symlink whose target escapes home resolves outside and gets rejected.
-export function createDocs({ home, extraRoots = [], maxDownloadBytes = MAX_TRANSFER_BYTES } = {}) {
-  // $HOME is constant at runtime — resolve once at construction, reuse the same promise everywhere.
-  const realHomeP = fs.realpath(home);
-  // Browse / read / download / upload may also reach a few EXTRA roots OUTSIDE $HOME (e.g. /tmp,
-  // $TMPDIR) so transient files an agent drops there are reachable from the phone. Resolved once:
-  // realpath'd, deduped, missing ones skipped, and any extra already inside home dropped (home
-  // covers it). `home` is always roots[0]. Session-cwd (resolveCwd) and the upload stash stay
-  // home-only on purpose. The "under one of these roots" check replaces the old single isUnder(home).
-  const rootsP = (async () => {
-    const rh = await realHomeP;
-    const out = [rh];
-    for (const r of extraRoots) {
-      if (typeof r !== 'string' || !r) continue;
-      let real;
-      try { real = await fs.realpath(r); } catch { continue; } // not present on this host → skip
-      if (isUnder(real, rh) || out.includes(real)) continue;   // already covered by home / dup
-      out.push(real);
-    }
-    return out;
-  })();
-  // The allowed root that contains `real` (longest match wins should roots ever nest), or null.
-  const rootOf = (real, roots) => {
-    let best = null;
-    for (const r of roots) if (isUnder(real, r) && (!best || r.length > best.length)) best = r;
-    return best;
-  };
-
-  // `knownMtime` (ms) makes this a conditional read: if the file's mtime is unchanged the body is
-  // skipped and `{ notModified: true }` comes back (no readFile), so re-visiting an unchanged doc on
-  // the phone neither transfers content nor forces a re-render. `mtimeMs` is always returned so the
-  // client can store it for the next check.
-  async function readDoc(rawPath, knownMtime = null) {
-    if (typeof rawPath !== 'string' || rawPath[0] !== '/') return { error: 'not absolute', status: 400 };
-    const type = docTypeFor(rawPath);
-    if (!type) return { error: 'bad extension', status: 400 };
-    let real;
-    try { real = await fs.realpath(rawPath); }
-    catch { return { error: 'not found', status: 404 }; }
-    if (!rootOf(real, await rootsP)) return { error: 'outside home', status: 400 };
-    let st;
-    try { st = await fs.stat(real); }
-    catch { return { error: 'not accessible', status: 404 }; }
-    if (!st.isFile()) return { error: 'not a file', status: 400 };
-    if (st.size > MAX_READ_BYTES) return { error: 'too large', status: 413 };
-    const mtimeMs = st.mtimeMs;
-    if (knownMtime != null && mtimeMs === knownMtime) return { name: basename(real), type, mtimeMs, notModified: true };
-    const content = await fs.readFile(real, 'utf8');
-    return { name: basename(real), type, content, mtimeMs };
-  }
-
-  async function listDir(rawPath) {
-    const rh = await realHomeP;
-    const roots = await rootsP;
-    let real;
-    try { real = await fs.realpath(rawPath ? rawPath : home); }
-    catch { return { error: 'not found', status: 404 }; }
-    if (!rootOf(real, roots)) return { error: 'outside home', status: 400 };
-    const st = await fs.stat(real);
-    if (!st.isDirectory()) return { error: 'not a directory', status: 400 };
-    const dirents = await fs.readdir(real, { withFileTypes: true });
-    // withFileTypes uses lstat semantics: d.isFile() is false for symlinks, so symlinks are
-    // intentionally NOT listed (security property). Every regular file is listed now (not just
-    // docs); the extension decides whether it opens in-app as a doc ('doc'), an image viewer
-    // ('image'), or can only be downloaded ('file').
-    const dirEntries = [];
-    const fileDirents = [];
-    for (const d of dirents) {
-      if (d.isDirectory()) dirEntries.push({ name: d.name, type: 'dir' });
-      else if (d.isFile()) fileDirents.push(d);
-    }
-    // stat every file IN PARALLEL — a big dir is thousands of files, and one awaited stat each
-    // (serial) is what made listing hang for seconds. Promise.all lets the OS pipeline them.
-    const fileEntries = await Promise.all(fileDirents.map(async (d) => {
-      const type = docTypeFor(d.name) ? 'doc' : imageTypeFor(d.name) ? 'image' : 'file';
-      let size = 0;
-      try { size = (await fs.stat(join(real, d.name))).size; } catch { /* gone mid-list → size 0 */ }
-      return { name: d.name, type, size };
-    }));
-    const entries = [...dirEntries, ...fileEntries];
-    // dirs first; files (doc+file) interleaved alphabetically
-    entries.sort((a, b) =>
-      (a.type === 'dir' ? 0 : 1) - (b.type === 'dir' ? 0 : 1) || a.name.localeCompare(b.name));
-    // "up" stops at whichever allowed root we're in (each root is a ceiling), not only at home.
-    const parent = roots.includes(real) ? null : join(real, '..');
-    return { path: real, home: rh, roots, parent, entries };
-  }
-
-  // Resolve a path for DOWNLOAD: any regular file under home, no extension white-list (unlike
-  // readDoc). Same realpath+isUnder boundary; symlinks escaping home resolve outside → rejected.
-  async function statForDownload(rawPath) {
-    if (typeof rawPath !== 'string' || rawPath[0] !== '/') return { error: 'not absolute', status: 400 };
-    let real;
-    try { real = await fs.realpath(rawPath); }
-    catch { return { error: 'not found', status: 404 }; }
-    if (!rootOf(real, await rootsP)) return { error: 'outside home', status: 400 };
-    let st;
-    try { st = await fs.stat(real); }
-    catch { return { error: 'not accessible', status: 404 }; }
-    if (!st.isFile()) return { error: 'not a file', status: 400 };
-    if (st.size > maxDownloadBytes) return { error: 'too large', status: 413 };
-    return { real, name: basename(real), size: st.size, mtimeMs: st.mtimeMs };
-  }
-
-  // Resolve a path for UPLOAD TARGET: a directory under one of the allowed roots, not inside any
-  // hidden directory (relative to its own root). The $HOME root itself is off-limits (don't litter
-  // the home dir); an extra root like /tmp IS uploadable directly, since dropping files there is the
-  // whole point. Same realpath boundary as the rest.
-  async function resolveUploadDir(rawDir) {
-    if (typeof rawDir !== 'string' || rawDir[0] !== '/') return { error: 'not absolute', status: 400 };
-    const rh = await realHomeP;
-    let real;
-    try { real = await fs.realpath(rawDir); }
-    catch { return { error: 'not found', status: 404 }; }
-    const root = rootOf(real, await rootsP);
-    if (!root) return { error: 'outside home', status: 400 };
-    if (real === rh) return { error: 'home root not allowed', status: 400 };
-    if (hasHiddenSegment(real, root)) return { error: 'hidden directory not allowed', status: 400 };
-    let st;
-    try { st = await fs.stat(real); }
-    catch { return { error: 'not accessible', status: 404 }; }
-    if (!st.isDirectory()) return { error: 'not a directory', status: 400 };
-    return { real };
-  }
-
-  // Resolve the STASH upload target: a per-project folder under ~/.handmux/uploads, created on
-  // demand. Deliberately OUTSIDE the user's project trees (so uploads can never be `git add`-ed by
-  // accident) yet still under $HOME, so the absolute path the chat box pastes stays readable by an
-  // agent running anywhere. Mirrors Claude Code's per-project layout: the caller's cwd is flattened
-  // ('/'→'-') into a single path segment (see encodeCwdKey), so each working directory gets its own
-  // space; an unknown cwd falls into `_default`. Returns the realpath'd dir.
-  async function resolveStashDir(rawCwd) {
-    const rh = await realHomeP;
-    const target = join(rh, '.handmux', 'uploads', encodeCwdKey(rawCwd));
-    try { await fs.mkdir(target, { recursive: true }); }
-    catch { return { error: 'mkdir failed', status: 500 }; }
-    let real;
-    try { real = await fs.realpath(target); }       // re-resolve in case a segment is a symlink
-    catch { return { error: 'not accessible', status: 404 }; }
-    if (!isUnder(real, rh)) return { error: 'outside home', status: 400 };
-    return { real };
-  }
-
-  // Resolve a path for use as a NEW session/window CWD: any directory under home (home root IS
-  // allowed, and hidden dirs ARE allowed — the browser can navigate into them). Same realpath +
-  // isUnder boundary as the rest; symlinks escaping home resolve outside → rejected.
-  async function resolveCwd(rawDir) {
-    if (typeof rawDir !== 'string' || rawDir[0] !== '/') return { error: 'not absolute', status: 400 };
-    const rh = await realHomeP;
-    let real;
-    try { real = await fs.realpath(rawDir); }
-    catch { return { error: 'not found', status: 404 }; }
-    if (!isUnder(real, rh)) return { error: 'outside home', status: 400 };
-    let st;
-    try { st = await fs.stat(real); }
-    catch { return { error: 'not accessible', status: 404 }; }
-    if (!st.isDirectory()) return { error: 'not a directory', status: 400 };
-    return { real };
-  }
-
-  // Resolve a directory for BROWSE-side ops (the mkdir target): a directory under ANY allowed root
-  // (the root itself + hidden dirs allowed, like resolveCwd but multi-root). resolveCwd stays
-  // home-only — a new session's cwd should never land in a temp root by accident.
-  async function resolveBrowseDir(rawDir) {
-    if (typeof rawDir !== 'string' || rawDir[0] !== '/') return { error: 'not absolute', status: 400 };
-    let real;
-    try { real = await fs.realpath(rawDir); }
-    catch { return { error: 'not found', status: 404 }; }
-    if (!rootOf(real, await rootsP)) return { error: 'outside home', status: 400 };
-    let st;
-    try { st = await fs.stat(real); }
-    catch { return { error: 'not accessible', status: 404 }; }
-    if (!st.isDirectory()) return { error: 'not a directory', status: 400 };
-    return { real };
-  }
-
-  // Create a new directory `name` inside `parentRaw`. The parent must be a directory under one of
-  // the allowed roots (root + hidden dirs allowed). `name` must be a single safe path segment.
-  async function makeDir(parentRaw, name) {
-    const nm = typeof name === 'string' ? name.trim() : '';
-    if (!nm || nm === '.' || nm === '..' || nm.includes('/') || nm.includes('\\') || nm.includes('\0')) {
-      return { error: 'bad name', status: 400 };
-    }
-    const parent = await resolveBrowseDir(parentRaw); // realpath + under-a-root + isDirectory
-    if (parent.error) return parent;
-    const target = join(parent.real, nm);
-    try {
-      await fs.mkdir(target);
-    } catch (e) {
-      if (e.code === 'EEXIST') return { error: 'exists', status: 409 };
-      return { error: 'mkdir failed', status: 500 };
-    }
-    return { real: target };
-  }
-
-  return { readDoc, listDir, statForDownload, resolveUploadDir, resolveStashDir, resolveCwd, makeDir };
-}
-
-// The extra (outside-$HOME) roots the file browser may reach: the system temp dir and, if set, the
-// per-user $TMPDIR (on macOS that's /var/folders/.../T). Missing ones are skipped at resolve time.
-export function defaultExtraRoots(env = process.env) {
-  const roots = ['/tmp'];
-  if (env.TMPDIR) roots.push(env.TMPDIR);
-  return roots;
-}
-
-export const defaultDocs = createDocs({ home: homedir(), extraRoots: defaultExtraRoots() });

package/src/git.js

@@ -1,208 +0,0 @@
-import { promises as fs } from 'node:fs';
-import { homedir } from 'node:os';
-import { join, basename, isAbsolute } from 'node:path';
-import { execFile } from 'node:child_process';
-import { isUnder } from './docPath.js';
-import { defaultExtraRoots } from './docs.js';
-
-// 只读子命令白名单：命令层硬过滤，杜绝任何写操作混入。
-const READONLY = new Set(['rev-parse', 'status', 'log', 'for-each-ref', 'diff', 'show', 'diff-tree']);
-const MAX_BUFFER = 8 * 1024 * 1024;
-
-export function createGit({ home, extraRoots = [] } = {}) {
-  const realHomeP = fs.realpath(home);
-  // Same multi-root allow-list as createDocs: $HOME plus a few roots OUTSIDE it (/tmp, $TMPDIR) so a repo
-  // an agent is working in under /tmp is reachable from the phone. Resolved once — realpath'd, deduped,
-  // missing ones skipped, extras already inside home dropped (home covers them). Keeps git browsing in
-  // lock-step with the file/doc browser; git.js used to be home-only, which rejected legit repos under
-  // /tmp with a red "outside home".
-  const rootsP = (async () => {
-    const rh = await realHomeP;
-    const out = [rh];
-    for (const r of extraRoots) {
-      if (typeof r !== 'string' || !r) continue;
-      let real;
-      try { real = await fs.realpath(r); } catch { continue; } // not present on this host → skip
-      if (isUnder(real, rh) || out.includes(real)) continue;   // already covered by home / dup
-      out.push(real);
-    }
-    return out;
-  })();
-  // The allowed root that contains `real` (longest match wins should roots ever nest), or null.
-  const rootOf = (real, roots) => {
-    let best = null;
-    for (const r of roots) if (isUnder(real, r) && (!best || r.length > best.length)) best = r;
-    return best;
-  };
-
-  function git(cwd, args) {
-    const sub = args[0];
-    if (!READONLY.has(sub)) return Promise.reject(new Error(`blocked subcommand: ${sub}`));
-    return new Promise((resolve, reject) => {
-      execFile('git', ['-C', cwd, '-c', 'core.quotepath=false', ...args], { maxBuffer: MAX_BUFFER }, (err, stdout) => {
-        if (err) reject(err); else resolve(stdout);
-      });
-    });
-  }
-
-  async function resolveRepo(rawPath) {
-    if (typeof rawPath !== 'string' || !isAbsolute(rawPath)) return { error: 'not absolute', status: 400 };
-    let real;
-    try { real = await fs.realpath(rawPath); } catch { return { error: 'not found', status: 404 }; }
-    if (!rootOf(real, await rootsP)) return { error: 'outside home', status: 400 };
-    return { real };
-  }
-
-  async function isRepo(dir) {
-    try { return (await git(dir, ['rev-parse', '--is-inside-work-tree'])).trim() === 'true'; }
-    catch { return false; }
-  }
-
-  // `realDir` is used for git operations; `displayPath` is what we expose (the caller's original path,
-  // avoiding macOS /private/var vs /var confusion when the caller passed a non-realpath'd path).
-  async function repoMeta(realDir, displayPath) {
-    const p = displayPath ?? realDir;
-    let branch = 'HEAD';
-    try { branch = (await git(realDir, ['rev-parse', '--abbrev-ref', 'HEAD'])).trim(); } catch { /* empty repo */ }
-    let dirty = false;
-    try { dirty = (await git(realDir, ['status', '--porcelain'])).trim().length > 0; } catch { /* ignore */ }
-    return { name: basename(p), path: p, branch, dirty };
-  }
-
-  async function detectRepos(rawDir) {
-    const r = await resolveRepo(rawDir);
-    if (r.error) return r;
-    if (await isRepo(r.real)) return { repos: [await repoMeta(r.real, rawDir)] };
-    const repos = [];
-    let dirents = [];
-    try { dirents = await fs.readdir(r.real, { withFileTypes: true }); } catch { /* ignore */ }
-    for (const d of dirents) {
-      if (!d.isDirectory()) continue;
-      const child = join(r.real, d.name);
-      const childDisplay = join(rawDir, d.name);
-      if (await isRepo(child)) repos.push(await repoMeta(child, childDisplay));
-    }
-    repos.sort((a, b) => a.name.localeCompare(b.name));
-    return { repos };
-  }
-
-  async function status(rawRepo) {
-    const r = await resolveRepo(rawRepo);
-    if (r.error) return r;
-    if (!(await isRepo(r.real))) return { error: 'not a repo', status: 400 };
-    let out;
-    try { out = await git(r.real, ['status', '--porcelain']); }
-    catch { return { error: 'git error', status: 500 }; }
-    const changes = out.split('\n').filter(Boolean).map((line) => {
-      const x = line[0], y = line[1];
-      let path = line.slice(3);
-      const arrow = path.indexOf(' -> ');
-      if (arrow >= 0) path = path.slice(arrow + 4);
-      return { x: x === ' ' ? '' : x, y: y === ' ' ? '' : y, path };
-    });
-    return { changes };
-  }
-
-  const SEP = '\x1f';
-
-  // 分支 / ref 名校验:挡选项注入(开头 '-')、路径穿越('..')、NUL,并限定到安全字符子集。
-  // 只读 git log 用,失败时 git 自己会再拒一次。
-  function safeRef(ref) {
-    if (typeof ref !== 'string' || !ref) return null;
-    if (ref[0] === '-' || ref.includes('..') || ref.includes('\0')) return null;
-    if (!/^[A-Za-z0-9._/-]+$/.test(ref)) return null;
-    return ref;
-  }
-
-  async function log(rawRepo, limit = 50, ref) {
-    const r = await resolveRepo(rawRepo);
-    if (r.error) return r;
-    if (!(await isRepo(r.real))) return { error: 'not a repo', status: 400 };
-    const n = Math.max(1, Math.min(500, Number(limit) || 50));
-    const safeR = ref == null || ref === '' ? null : safeRef(ref);
-    if (ref && !safeR) return { error: 'bad ref', status: 400 };
-    const args = ['log', `-n${n}`, `--pretty=format:%H${SEP}%h${SEP}%s${SEP}%an${SEP}%ar`];
-    if (safeR) args.push(safeR); // git log <ref> …(指定分支只读看历史,不动工作树)
-    let out = '';
-    try { out = await git(r.real, args); }
-    catch { return { commits: [] }; } // 空仓库(无提交)/ 无此 ref → 空列表
-    const commits = out.split('\n').filter(Boolean).map((line) => {
-      const [hash, short, subject, author, relDate] = line.split(SEP);
-      return { hash, short, subject, author, relDate };
-    });
-    return { commits };
-  }
-
-  async function branches(rawRepo) {
-    const r = await resolveRepo(rawRepo);
-    if (r.error) return r;
-    if (!(await isRepo(r.real))) return { error: 'not a repo', status: 400 };
-    const fmt = ['%(refname:short)', '%(HEAD)', '%(upstream:short)', '%(upstream:track)'].join(SEP);
-    let out;
-    try { out = await git(r.real, ['for-each-ref', `--format=${fmt}`, 'refs/heads']); }
-    catch { return { branches: [] }; }
-    const branches = out.split('\n').filter(Boolean).map((line) => {
-      const [name, head, upstream, track] = line.split(SEP);
-      const ahead = Number((track.match(/ahead (\d+)/) || [])[1] || 0);
-      const behind = Number((track.match(/behind (\d+)/) || [])[1] || 0);
-      return { name, current: head === '*', upstream: upstream || null, ahead, behind };
-    });
-    return { branches };
-  }
-
-  // 文件路径校验:相对、非绝对、不以 '-' 开头(防选项注入)、无 '..' 段、无 NUL。
-  function safeRelPath(p) {
-    if (typeof p !== 'string' || !p || p[0] === '-' || isAbsolute(p)) return null;
-    if (p.includes('\0') || p.split('/').some((seg) => seg === '..')) return null;
-    return p;
-  }
-
-  const MAX_DIFF_BYTES = 512 * 1024;
-  function cap(text) {
-    if (text.length <= MAX_DIFF_BYTES) return { diff: text, truncated: false };
-    return { diff: text.slice(0, MAX_DIFF_BYTES), truncated: true };
-  }
-
-  // diff 语义:仅 path → 工作区 vs HEAD;staged → 暂存区 vs HEAD;commit → 该提交 vs 其父。
-  async function diff(rawRepo, { path, commit, staged } = {}) {
-    const r = await resolveRepo(rawRepo);
-    if (r.error) return r;
-    if (!(await isRepo(r.real))) return { error: 'not a repo', status: 400 };
-    const rel = safeRelPath(path);
-    if (!rel) return { error: 'bad path', status: 400 };
-    let args;
-    if (commit) {
-      if (!/^[0-9a-fA-F]{4,40}$/.test(commit)) return { error: 'bad commit', status: 400 };
-      args = ['show', '--format=', commit, '--', rel];
-    } else if (staged) {
-      args = ['diff', '--staged', '--', rel];
-    } else {
-      args = ['diff', 'HEAD', '--', rel];
-    }
-    let out = '';
-    try { out = await git(r.real, args); } catch (e) { return { error: 'diff failed', status: 500 }; }
-    return cap(out);
-  }
-
-  async function commit(rawRepo, hash) {
-    const r = await resolveRepo(rawRepo);
-    if (r.error) return r;
-    if (!(await isRepo(r.real))) return { error: 'not a repo', status: 400 };
-    if (!/^[0-9a-fA-F]{4,40}$/.test(hash)) return { error: 'bad commit', status: 400 };
-    let message, ns;
-    try {
-      message = (await git(r.real, ['show', '-s', '--format=%B', hash])).trim();
-      // --root 让首次提交(无父)也能列出文件。
-      ns = await git(r.real, ['diff-tree', '--no-commit-id', '--name-status', '-r', '--root', hash]);
-    } catch { return { error: 'git error', status: 500 }; }
-    const files = ns.split('\n').filter(Boolean).map((line) => {
-      const [code, ...rest] = line.split('\t');
-      return { x: code[0], y: '', path: rest[rest.length - 1] };
-    });
-    return { message, files };
-  }
-
-  return { resolveRepo, isRepo, detectRepos, status, log, branches, diff, commit };
-}
-
-export const defaultGit = createGit({ home: homedir(), extraRoots: defaultExtraRoots() });

package/src/httpApi.js

@@ -1,72 +0,0 @@
-// API composition root. Applies auth + JSON parsing, then mounts the per-domain route modules under
-// /api. Each module (routes/*.js) owns one domain and receives only the deps it needs; the closure deps
-// (commands, docs, git, previews, token, home, …) pass straight through. Behaviour is unchanged from when
-// every route lived here — this file is just the wiring.
-import express from 'express';
-import { expressAuth } from './auth.js';
-import * as defaultCommands from './tmux/commands.js';
-import { defaultDocs, MAX_TRANSFER_BYTES } from './docs.js';
-import { defaultGit } from './git.js';
-import * as push from './push.js';
-import * as notifications from './notifications.js';
-import { createClaudeEvents } from './claudeEvents.js';
-import { homedir } from 'node:os';
-import { DEFAULT_UPLOAD_EXTS } from './uploadTypes.js';
-import { claudeStatePath } from './cli/state.js';
-import { sessionRoutes } from './routes/sessions.js';
-import { terminalRoutes } from './routes/terminal.js';
-import { gitRoutes } from './routes/git.js';
-import { fileRoutes } from './routes/files.js';
-import { pushRoutes } from './routes/push.js';
-import { systemRoutes } from './routes/system.js';
-import { previewRoutes } from './routes/previews.js';
-import { notificationRoutes } from './routes/notifications.js';
-import { transcriptRoutes } from './routes/transcript.js';
-import { DEFAULT_SHORTCUTS } from './shortcutConfig.js';
-import { workspaceRoutes } from './routes/workspace.js';
-import { browserRoutes } from './browser/routes.js';
-import { codexRoutes } from './routes/codex.js';
-
-// Re-exported for tests (test/keys.test.js) and any caller that imported it by this path historically.
-export { isAllowedKey } from './routes/terminal.js';
-
-export function createApiRouter({
-  token, commands = defaultCommands, docs = defaultDocs, git = defaultGit, events,
-  uploadExts = DEFAULT_UPLOAD_EXTS, maxUploadBytes = MAX_TRANSFER_BYTES,
-  asrEnv = process.env, previews,
-  shortcuts = DEFAULT_SHORTCUTS,
-  browser,
-  browserBootstrap,
-  previewDomain,
-  workspace,
-  codexApp,
-  home = homedir(), stateFile = process.env.CLAUDE_STATE_FILE || claudeStatePath(homedir()),
-} = {}) {
-  const r = express.Router();
-  r.use(expressAuth(token));
-  r.use(express.json());
-  const claudeEvents = events || createClaudeEvents({ commands, push });
-
-  const deps = {
-    token, commands, docs, git, push, notifications, claudeEvents,
-    uploadExts, maxUploadBytes, asrEnv, previews, shortcuts, home, stateFile, workspace, browser, browserBootstrap, previewDomain, codexApp,
-  };
-
-  r.use(sessionRoutes(deps));
-  r.use(terminalRoutes(deps));
-  r.use(gitRoutes(deps));
-  r.use(fileRoutes(deps));
-  r.use(pushRoutes(deps));
-  r.use(notificationRoutes(deps));
-  r.use(systemRoutes(deps));
-  r.use(previewRoutes(deps));
-  // In the main process browser APIs are forwarded to the isolated worker before this router. Keep
-  // preview-domain wiring out of this unused fallback route so capability reporting does not require
-  // the worker-owned bootstrap ticket store.
-  r.use('/browser-proxy', browserRoutes(browser ? deps : { ...deps, previewDomain: null }));
-  r.use(transcriptRoutes(deps));
-  r.use(codexRoutes(deps));
-  if (workspace) r.use(workspaceRoutes(deps));
-
-  return r;
-}

package/src/jsonStore.js

@@ -1,24 +0,0 @@
-// Shared JSON-store persistence for the small single-writer runtime registries (push subs, previews).
-// Both hold their records IN MEMORY (loaded once at startup) and flush the whole array on each mutation —
-// there is only ever one server process, so the in-memory copy is the source of truth and a read never
-// touches disk. Writes are atomic (tmp + rename) so a concurrent reader (or a crash mid-write) can never
-// observe a half-written file. Persistence is best-effort: a lost flush just means the client re-subscribes
-// / the preview is re-registered next launch.
-import fs from 'node:fs';
-import path from 'node:path';
-
-// Read a JSON array from `file`, tolerating missing/corrupt/non-array content (→ []). Never throws.
-export function readJsonArray(file) {
-  try { const v = JSON.parse(fs.readFileSync(file, 'utf8')); return Array.isArray(v) ? v : []; }
-  catch { return []; }
-}
-
-// Atomic write: serialize `obj` to a sibling .tmp then rename over `file` (atomic on the same fs).
-export function writeJsonAtomic(file, obj) {
-  try {
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    const tmp = `${file}.tmp`;
-    fs.writeFileSync(tmp, JSON.stringify(obj));
-    fs.renameSync(tmp, file);
-  } catch { /* best effort — a lost flush is recoverable by the client re-registering */ }
-}

package/src/notifications.js

@@ -1,68 +0,0 @@
-// Per-device manual-push inbox: each subscribed device gets its own file `<NOTIF_DIR>/<pushKey>.json`, so a
-// `--device`/`--session`-scoped push only lands in the targeted devices' inboxes (delete/read are naturally
-// per-device too). NOTIF_DIR is injected by the CLI (~/.handmux/notifications) — NEVER the package-internal
-// default, which a global reinstall wipes. Low-frequency, so each op is a plain read-modify-write of one
-// device file (no in-memory state). The same push shares one record id across its target devices so a
-// notification tap's inboxId resolves on whichever device opens it.
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import crypto from 'node:crypto';
-import { readJsonArray, writeJsonAtomic } from './jsonStore.js';
-import { sanitizeNotificationUrl } from './urlPolicy.js';
-
-const here = path.dirname(fileURLToPath(import.meta.url));
-const DIR = process.env.NOTIF_DIR || path.resolve(here, '../data/notifications');
-const CAP = 100;
-const genId = () => crypto.randomBytes(9).toString('base64url');
-
-// pushKey is base64url already; sanitize anyway so a hostile value can't escape DIR. Empty → null (skip).
-function fileFor(key) {
-  const safe = String(key || '').replace(/[^A-Za-z0-9_-]/g, '');
-  return safe ? path.join(DIR, `${safe}.json`) : null;
-}
-const load = (file) => readJsonArray(file).filter((n) => n && typeof n.title === 'string');
-
-export function record(pushKeys, { title, body, tag, url, delivery } = {}) {
-  const rec = { id: genId(), ts: Date.now(), title: String(title ?? ''), body: String(body ?? '') };
-  if (tag) rec.tag = String(tag);
-  if (delivery?.status === 'pending') rec.delivery = { status: 'pending' };
-  const safeUrl = sanitizeNotificationUrl(url);
-  if (safeUrl) rec.url = safeUrl;
-  for (const key of pushKeys || []) {
-    const file = fileFor(key);
-    if (!file) continue;
-    const items = load(file);
-    items.push(rec);
-    writeJsonAtomic(file, items.length > CAP ? items.slice(items.length - CAP) : items);
-  }
-  return rec;
-}
-
-export function updateDelivery(pushKey, id, delivery) {
-  const file = fileFor(pushKey);
-  if (!file) return false;
-  const items = load(file);
-  const item = items.find((n) => n.id === id);
-  if (!item) return false;
-  const status = delivery?.status;
-  if (!['pending', 'success', 'failed'].includes(status)) return false;
-  item.delivery = { status };
-  if (status === 'failed' && typeof delivery.reason === 'string') item.delivery.reason = delivery.reason;
-  writeJsonAtomic(file, items);
-  return true;
-}
-
-export function list(pushKey) {
-  const file = fileFor(pushKey);
-  return file ? load(file).reverse() : [];
-}
-
-export function remove(pushKey, id) {
-  const file = fileFor(pushKey);
-  if (!file) return false;
-  const items = load(file);
-  const kept = items.filter((n) => n.id !== id);
-  if (kept.length === items.length) return false;
-  writeJsonAtomic(file, kept);
-  return true;
-}