instabox 0.5.0 → 0.5.2

package/skills/instabox-move-all/scripts/scan.mjs

@@ -1,811 +0,0 @@
-#!/usr/bin/env node
-// Read-only inventory of what could move to an instabox box: git repos and
-// their agent history, credentials (presence only, never values), dotfiles,
-// agent config and globally installed tools. Prints JSON.
-//
-//   node scan.mjs [--root DIR]... [--no-default-roots] [--depth N] [--no-tools] > scan.json
-//
-// Nothing is written and no value of a credential is read into the output:
-// files that hold secrets are only checked for which keys they have.
-import { readdirSync, realpathSync } from 'node:fs';
-import { basename, dirname, join, resolve } from 'node:path';
-import {
-  BOX_WORKSPACE,
-  MACOS_ONLY,
-  SECRET_VALUE,
-  STAGE_DIR,
-  VAULT_MAX_VALUE,
-  claudeProjectName,
-  hasCommand,
-  isMain,
-  isSecretName,
-  listFiles,
-  lstatOrNull,
-  readHead,
-  readJSON,
-  readText,
-  run,
-  safeName,
-  treeBytes,
-  vaultEnvNameOK,
-  vaultFileName,
-  vaultPathOK,
-} from './lib.mjs';
-
-export const DEFAULT_ROOTS = [
-  'Work',
-  'work',
-  'code',
-  'Code',
-  'src',
-  'projects',
-  'Projects',
-  'dev',
-  'Developer',
-  'repos',
-  'git',
-  'github',
-];
-const SKIP_DIRS = new Set([
-  'node_modules',
-  'vendor',
-  'target',
-  'dist',
-  'build',
-  'venv',
-  '__pycache__',
-  'Library',
-  'Applications',
-  'Pictures',
-  'Music',
-  'Movies',
-]);
-
-// Shell startup files: scanned for exported credentials, copied without them.
-export const SHELL_RC = ['.zshrc', '.zshenv', '.zprofile', '.bashrc', '.bash_profile', '.profile', '.bash_aliases'];
-
-// Dotfiles and config directories copied as they are (secrets and macOS-only lines filtered).
-const DOTFILES = [
-  ...SHELL_RC,
-  '.aliases',
-  '.gitconfig',
-  '.config/git/config',
-  '.config/git/ignore',
-  '.gitignore_global',
-  '.gitmessage',
-  '.tmux.conf',
-  '.config/tmux',
-  '.vimrc',
-  '.config/nvim',
-  '.config/helix',
-  '.editorconfig',
-  '.inputrc',
-  '.config/starship.toml',
-  '.ssh/config',
-  '.aws/config',
-  '.config/gh/config.yml',
-  '.npmrc',
-  '.nvmrc',
-  '.node-version',
-  '.python-version',
-  '.ruby-version',
-  '.tool-versions',
-  '.config/mise/config.toml',
-  '.psqlrc',
-  '.curlrc',
-  '.wgetrc',
-  '.gemrc',
-];
-const DOT_DIR_MAX = 20 * 1024 * 1024;
-
-// Git repos: found under the roots, at most depth levels down, not inside another repo.
-function findRepos(roots, depth) {
-  const found = [];
-  const walk = (dir, d) => {
-    const st = lstatOrNull(join(dir, '.git'));
-    if (st) {
-      found.push(dir);
-      return;
-    }
-    if (d >= depth) return;
-    let names = [];
-    try {
-      names = readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const e of names) {
-      if (!e.isDirectory() || e.name.startsWith('.') || SKIP_DIRS.has(e.name)) continue;
-      walk(join(dir, e.name), d + 1);
-    }
-  };
-  const seen = new Set();
-  for (const r of roots) {
-    if (!lstatOrNull(r)?.isDirectory()) continue;
-    const real = realOrSelf(r);
-    if (seen.has(real)) continue;
-    seen.add(real);
-    walk(r, 0);
-  }
-  return found;
-}
-
-// The canonical path: realpathSync.native also settles case on macOS, where ~/Work and ~/work are one directory.
-function realOrSelf(p) {
-  try {
-    return realpathSync.native(p);
-  } catch {
-    return p;
-  }
-}
-
-function git(repo, args, env) {
-  // GIT_OPTIONAL_LOCKS=0: `git status` must not refresh the index (read-only scan).
-  return run(['git', '-C', repo, ...args], { env: { ...env, GIT_OPTIONAL_LOCKS: '0' } });
-}
-
-const nulList = (s) => s.split('\0').filter(Boolean);
-const lines = (s) => s.split('\n').filter((l) => l.trim() !== '');
-const ENV_FILE = /(^|\/)\.env(\.[^/]*)?$/;
-const ENV_TEMPLATE = /\.(example|sample|template|dist|defaults?)$/;
-
-function inspectRepo(path, env) {
-  const g = (args) => git(path, args, env);
-  const gitPath = join(path, '.git');
-  const worktree = !lstatOrNull(gitPath)?.isDirectory();
-  const r = { path, worktree };
-  r.branch = g(['symbolic-ref', '--short', '-q', 'HEAD']).stdout.trim() || 'detached';
-  r.head = g(['rev-parse', '--short', 'HEAD']).stdout.trim() || null;
-  r.dirty = lines(g(['status', '--porcelain', '--untracked-files=no']).stdout).length;
-  const tracked = nulList(g(['ls-files', '-z', '--cached']).stdout);
-  const untracked = nulList(
-    g([
-      'ls-files',
-      '-z',
-      '--others',
-      '--exclude-standard',
-      '--',
-      '.',
-      ':(exclude,glob)**/.env',
-      ':(exclude,glob)**/.env.*',
-    ]).stdout,
-  );
-  r.untracked = untracked.length;
-  r.stashes = lines(g(['stash', 'list']).stdout).length;
-  r.remotes = lines(g(['remote']).stdout).length;
-  r.unpushed = r.head ? Number(g(['rev-list', '--count', '--branches', '--not', '--remotes']).stdout.trim()) || 0 : 0;
-  // What instabox-migrate copies: all of .git, tracked files and untracked files git does not ignore.
-  let bytes = worktree ? 0 : treeBytes(gitPath);
-  for (const f of new Set([...tracked, ...untracked])) {
-    const st = lstatOrNull(join(path, f));
-    if (st && !st.isDirectory()) bytes += st.size;
-  }
-  r.bytes = bytes;
-  // .env files git does not track: they stay behind with the repo, and can go to the Vault.
-  r.envFiles = nulList(
-    g(['ls-files', '-z', '--others', '--', ':(glob)**/.env', ':(glob)**/.env.*']).stdout,
-  ).filter((f) => ENV_FILE.test(f) && !ENV_TEMPLATE.test(f) && !/(^|\/)(node_modules|vendor)\//.test(f));
-  if (worktree) {
-    const common = g(['rev-parse', '--path-format=absolute', '--git-common-dir']).stdout.trim();
-    r.mainCheckout = common ? dirname(common) : null;
-  }
-  return r;
-}
-
-// Claude Code: ~/.claude/projects/<encoded cwd>/*.jsonl. The cwd is read from a session line.
-function claudeHistory(home) {
-  const base = join(home, '.claude', 'projects');
-  const byCwd = new Map();
-  let dirs = [];
-  try {
-    dirs = readdirSync(base, { withFileTypes: true });
-  } catch {
-    return byCwd;
-  }
-  for (const d of dirs) {
-    if (!d.isDirectory()) continue;
-    const dir = join(base, d.name);
-    const sessions = listFiles(dir, () => false).filter((f) => !f.includes('/') && f.endsWith('.jsonl'));
-    if (!sessions.length) continue;
-    let cwd = null;
-    for (const s of sessions) {
-      const m = readHead(join(dir, s), 256 * 1024).match(/"cwd":("(?:[^"\\]|\\.)*")/);
-      if (m) {
-        try {
-          cwd = JSON.parse(m[1]);
-        } catch {}
-        if (cwd) break;
-      }
-    }
-    if (!cwd || claudeProjectName(cwd) !== d.name) continue;
-    byCwd.set(cwd, { dir: d.name, sessions: sessions.length, bytes: treeBytes(dir) });
-  }
-  return byCwd;
-}
-
-// Codex: ~/.codex/sessions/**/rollout-*.jsonl, each recording its cwd near the top.
-function codexHistory(home) {
-  const base = join(home, '.codex', 'sessions');
-  const byCwd = new Map();
-  for (const f of listFiles(base)) {
-    if (!/(^|\/)rollout-[^/]*\.jsonl$/.test(f)) continue;
-    const m = readHead(join(base, f), 256 * 1024).match(/"cwd":("(?:[^"\\]|\\.)*")/);
-    if (!m) continue;
-    let cwd;
-    try {
-      cwd = JSON.parse(m[1]);
-    } catch {
-      continue;
-    }
-    const e = byCwd.get(cwd) || { sessions: 0, bytes: 0 };
-    e.sessions++;
-    e.bytes += lstatOrNull(join(base, f))?.size || 0;
-    byCwd.set(cwd, e);
-  }
-  return byCwd;
-}
-
-function scanWork({ home, cwd, roots, depth, env }) {
-  const claude = claudeHistory(home);
-  const codex = codexHistory(home);
-  const candidates = findRepos(roots, depth);
-  // The current directory's repo, and repos the agents' history points at, wherever they are.
-  for (const dir of [cwd, ...claude.keys(), ...codex.keys()]) {
-    if (!dir || !lstatOrNull(dir)?.isDirectory()) continue;
-    const top = git(dir, ['rev-parse', '--show-toplevel'], env).stdout.trim();
-    if (top) candidates.push(top);
-  }
-  const seen = new Map();
-  for (const c of candidates) {
-    const real = realOrSelf(c);
-    if (real === home || seen.has(real)) continue;
-    // Keep the spelling the agents' history uses when the path is a symlink or differs in case.
-    seen.set(real, c);
-  }
-  const repos = [...seen.values()].sort().map((p) => inspectRepo(p, env));
-  // One workspace directory each: the repo's name, -2, -3... when two repos share a name.
-  const used = new Map();
-  const work = [];
-  const history = [];
-  for (const r of repos) {
-    const base = safeName(basename(r.path));
-    const n = (used.get(base) || 0) + 1;
-    used.set(base, n);
-    r.name = n === 1 ? base : `${base}-${n}`;
-    r.dest = `${BOX_WORKSPACE}/${r.name}`;
-    const real = realOrSelf(r.path);
-    const c = claude.get(r.path) || [...claude].find(([k]) => realOrSelf(k) === real)?.[1];
-    const x = codex.get(r.path) || [...codex].find(([k]) => realOrSelf(k) === real)?.[1];
-    const reasons = [];
-    if (r.dirty) reasons.push(`${r.dirty} changed`);
-    if (r.untracked) reasons.push(`${r.untracked} untracked`);
-    if (r.stashes) reasons.push(`${r.stashes} stashed`);
-    if (r.unpushed) reasons.push(`${r.unpushed} unpushed`);
-    if (!r.remotes) reasons.push('no remote');
-    r.id = `repo:${r.path}`;
-    r.checked = reasons.length > 0 && !r.worktree;
-    r.why = r.worktree
-      ? `a git worktree: move its main checkout${r.mainCheckout ? ` (${r.mainCheckout})` : ''} instead`
-      : reasons.length
-        ? `unsaved work: ${reasons.join(', ')}`
-        : 'clean and pushed: can be cloned again any time';
-    work.push(r);
-    if (c || x) {
-      history.push({
-        id: `history:${r.path}`,
-        repo: r.id,
-        claude: c || null,
-        codex: x || null,
-        bytes: (c?.bytes || 0) + (x?.bytes || 0),
-        checked: r.checked,
-      });
-    }
-  }
-  return { work, history };
-}
-
-// --- credentials ---------------------------------------------------------
-
-// `export NAME=value` / `NAME=value` lines of a shell file: names and line numbers only.
-function shellAssignments(text) {
-  const out = [];
-  text.split('\n').forEach((line, i) => {
-    const m = line.match(/^\s*(?:export\s+|declare\s+-x\s+|typeset\s+-x\s+)?([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
-    if (!m) return;
-    out.push({ name: m[1], line: i + 1, secretValue: SECRET_VALUE.test(m[2]), keychain: MACOS_ONLY.test(m[2]) });
-  });
-  return out;
-}
-
-// Section names of an INI-style file ([default], [profile x]) and which keys appear; never values.
-function iniShape(text) {
-  const sections = [];
-  const keys = new Set();
-  for (const line of (text || '').split('\n')) {
-    const s = line.match(/^\s*\[([^\]]+)\]\s*$/);
-    if (s) sections.push(s[1].trim());
-    const k = line.match(/^\s*([A-Za-z0-9_.-]+)\s*=/);
-    if (k) keys.add(k[1].toLowerCase());
-  }
-  return { sections, keys };
-}
-
-function scanCredentials({ home, env, procEnv, work, platform }) {
-  const creds = [];
-  const byName = new Map();
-  const add = (c) => {
-    if (c.kind === 'env') {
-      if (byName.has(c.name)) return; // the first source of a name wins; the Vault holds one value per name
-      byName.set(c.name, c);
-    }
-    creds.push(c);
-  };
-  const envItem = (name, source, from, extra = {}) => ({
-    id: `cred:env:${name}`,
-    kind: 'env',
-    name,
-    source,
-    from,
-    checked: true,
-    ...extra,
-  });
-  const fileItem = (path, source, from, extra = {}) => {
-    const bytes = lstatOrNull(source.path)?.size ?? 0;
-    const item = {
-      id: `cred:file:${path}`,
-      kind: 'file',
-      name: vaultFileName(path),
-      path,
-      source,
-      from,
-      bytes,
-      checked: true,
-      ...extra,
-    };
-    if (bytes > VAULT_MAX_VALUE) {
-      item.kind = 'manual';
-      item.id = `cred:manual:${path}`;
-      item.checked = false;
-      item.reason = `${bytes} bytes: over the Vault's 64 KiB limit per item`;
-      item.manual = `copy it yourself: instabox ssh <box> -- 'mkdir -p "$(dirname ~/${path})" && cat > ~/${path}' < ${source.path}`;
-    }
-    return item;
-  };
-  const manual = (key, label, reason, commands, extra = {}) => ({
-    id: `cred:manual:${key}`,
-    kind: 'manual',
-    name: label,
-    checked: false,
-    reason,
-    manual: commands,
-    ...extra,
-  });
-  // A credential whose name the Vault refuses for env items (INSTABOX_*, SSH_*, reserved names):
-  // it is removed from the staged copies, so the user sets it on the box by hand.
-  // One item per name, listing every place it was found (each copy is scrubbed).
-  const unvaultableFrom = new Map();
-  const unvaultable = (name, from) => {
-    const seen = unvaultableFrom.get(name);
-    if (seen) {
-      if (seen.includes(from)) return;
-      seen.push(from);
-      creds.find((c) => c.id === `cred:manual:env:${name}`).name = `${name} (${seen.join('; ')})`;
-      return;
-    }
-    unvaultableFrom.set(name, [from]);
-    add(
-      manual(
-        `env:${name}`,
-        `${name} (${from})`,
-        'the Vault does not store env items with this name (INSTABOX_*, SSH_* and a few system names are refused), so it is removed from the staged copy',
-        `if the box needs it: \`instabox ssh <box>\`, then set ${name} there by hand in each place listed (for a shell file, add \`export ${name}=…\` to ~/.bashrc)`,
-      ),
-    );
-  };
-  const tilde = (p) => (p.startsWith(home + '/') ? '~' + p.slice(home.length) : p);
-
-  // gh: the token gh keeps (keychain or hosts.yml) goes over as GH_TOKEN.
-  if (hasCommand('gh', env)) {
-    const st = run(['gh', 'auth', 'status', '--hostname', 'github.com'], { env });
-    if (st.ok) {
-      const who = (st.stdout + st.stderr).match(/account (\S+)/)?.[1] || null;
-      add(
-        envItem('GH_TOKEN', { type: 'cmd', argv: ['gh', 'auth', 'token', '--hostname', 'github.com'] }, '`gh auth token`', {
-          note: who ? `GitHub account ${who}; gh and git over HTTPS use it on the box` : 'gh and git over HTTPS use it on the box',
-        }),
-      );
-    }
-  }
-
-  // Shell startup files: exported credentials.
-  for (const f of SHELL_RC) {
-    const text = readText(join(home, f));
-    if (text === null) continue;
-    for (const a of shellAssignments(text)) {
-      if (!isSecretName(a.name) && !a.secretValue) continue;
-      if (!vaultEnvNameOK(a.name)) {
-        unvaultable(a.name, `~/${f}:${a.line}`);
-        continue;
-      }
-      const extra = a.keychain ? { note: 'set from the macOS keychain when the shell starts; its current value goes over' } : {};
-      if (a.name === 'AWS_SESSION_TOKEN') {
-        extra.checked = false;
-        extra.reason = 'temporary AWS session token: it expires';
-      }
-      add(envItem(a.name, { type: 'rc', file: join(home, f), name: a.name }, `~/${f}:${a.line}`, extra));
-    }
-  }
-  // The environment the scan runs in.
-  for (const name of Object.keys(procEnv).sort()) {
-    // INSTABOX_* and SSH_* here belong to this machine's session (the CLI key, the agent socket).
-    if (!isSecretName(name) || !vaultEnvNameOK(name) || byName.has(name)) continue;
-    const extra = {};
-    if (name === 'AWS_SESSION_TOKEN') {
-      extra.checked = false;
-      extra.reason = 'temporary AWS session token: it expires';
-    }
-    add(envItem(name, { type: 'env', name }, 'this shell’s environment', extra));
-  }
-
-  // Claude Code: settings.json env, the sign-in, MCP servers.
-  const settingsPath = join(home, '.claude', 'settings.json');
-  const settings = readJSON(settingsPath);
-  for (const [k, v] of Object.entries(settings?.env || {})) {
-    if (typeof v !== 'string' || !(isSecretName(k) || SECRET_VALUE.test(v))) continue;
-    if (vaultEnvNameOK(k)) add(envItem(k, { type: 'json', path: settingsPath, keys: ['env', k] }, '~/.claude/settings.json env'));
-    else unvaultable(k, '~/.claude/settings.json env');
-  }
-  const claudeJSONPath = join(home, '.claude.json');
-  const claudeJSON = readJSON(claudeJSONPath);
-  if (claudeJSON?.oauthAccount || lstatOrNull(join(home, '.claude', '.credentials.json'))) {
-    add(
-      manual(
-        'claude-code-login',
-        'Claude Code sign-in',
-        platform === 'darwin'
-          ? 'kept in the macOS keychain, and its OAuth refresh token rotates: a copy would sign one side out'
-          : 'its OAuth refresh token rotates: a copy would sign one side out',
-        'on the box: `claude`, then /login. Or, for a token that lasts a year: run `claude setup-token` here, then `instabox vault set CLAUDE_CODE_OAUTH_TOKEN --selector migrated=<box>` and paste it at the prompt',
-      ),
-    );
-  }
-  for (const [name, s] of Object.entries(claudeJSON?.mcpServers || {})) {
-    const http = s.type === 'http' || s.type === 'sse' || (!s.command && s.url);
-    if (http) {
-      const headers = Object.keys(s.headers || {});
-      add(
-        manual(
-          `mcp:${name}`,
-          `MCP server ${name} (${s.url || 'remote'})`,
-          headers.length
-            ? `sends headers (${headers.join(', ')}) that may hold a secret`
-            : 'a remote server: its OAuth sign-in stays with this machine',
-          headers.length
-            ? `on the box: \`claude mcp add --scope user --transport ${s.type || 'http'} ${name} ${s.url} --header "<header>: <value>"\``
-            : `on the box, after the move: \`claude\`, then /mcp and sign in to ${name}`,
-        ),
-      );
-    }
-    for (const [k, v] of Object.entries(s.env || {})) {
-      if (typeof v !== 'string' || !(isSecretName(k) || SECRET_VALUE.test(v))) continue;
-      if (!vaultEnvNameOK(k)) unvaultable(k, `MCP server ${name} env`);
-      else
-        add(
-          envItem(k, { type: 'json', path: claudeJSONPath, keys: ['mcpServers', name, 'env', k] }, `MCP server ${name} env`, {
-            note: `the ${name} MCP server reads it from the environment on the box`,
-          }),
-        );
-    }
-  }
-
-  // Codex: an API key in auth.json goes over; a ChatGPT sign-in cannot.
-  const codexAuthPath = join(home, '.codex', 'auth.json');
-  const codexAuth = readJSON(codexAuthPath);
-  if (codexAuth) {
-    if (typeof codexAuth.OPENAI_API_KEY === 'string' && codexAuth.OPENAI_API_KEY)
-      add(envItem('OPENAI_API_KEY', { type: 'json', path: codexAuthPath, keys: ['OPENAI_API_KEY'] }, '~/.codex/auth.json'));
-    if (codexAuth.tokens)
-      add(
-        manual(
-          'codex-chatgpt',
-          'Codex ChatGPT sign-in (~/.codex/auth.json)',
-          'its refresh token rotates: a copy on the box would sign this machine out, or the other way round',
-          'on the box: `codex login --device-auth`',
-        ),
-      );
-  }
-
-  // AWS.
-  const awsCreds = join(home, '.aws', 'credentials');
-  if (lstatOrNull(awsCreds)) {
-    const shape = iniShape(readText(awsCreds));
-    const temp = shape.keys.has('aws_session_token');
-    add(
-      fileItem('.aws/credentials', { type: 'file', path: awsCreds }, `~/.aws/credentials (profiles: ${shape.sections.join(', ') || 'none'})`, {
-        checked: !temp,
-        ...(temp ? { reason: 'holds a temporary session token: it expires' } : {}),
-      }),
-    );
-  }
-  const awsConfig = readText(join(home, '.aws', 'config'));
-  if (awsConfig) {
-    const shape = iniShape(awsConfig);
-    if (shape.keys.has('sso_start_url') || shape.keys.has('sso_session'))
-      add(
-        manual(
-          'aws-sso',
-          'AWS SSO sign-in',
-          'SSO sessions are short-lived and tied to this machine’s browser sign-in',
-          'on the box (~/.aws/config goes over with Environment): `aws sso login --use-device-code`',
-        ),
-      );
-    if (shape.keys.has('credential_process'))
-      add(
-        manual(
-          'aws-credential-process',
-          'AWS credential_process',
-          'runs a local program for credentials (often a macOS keychain helper)',
-          'install the same helper on the box, or use static keys or SSO there',
-        ),
-      );
-  }
-
-  // Google Cloud.
-  const adcPath = join(home, '.config', 'gcloud', 'application_default_credentials.json');
-  const adc = readJSON(adcPath);
-  if (adc?.type === 'service_account')
-    add(
-      fileItem(
-        '.config/gcloud/application_default_credentials.json',
-        { type: 'file', path: adcPath },
-        '~/.config/gcloud/application_default_credentials.json (service account)',
-      ),
-    );
-  else if (adc)
-    add(
-      manual(
-        'gcloud-adc',
-        'gcloud application-default credentials (user)',
-        'a user sign-in’s refresh token, tied to your Google login on this machine',
-        'on the box: `gcloud auth application-default login --no-launch-browser`',
-      ),
-    );
-  if (lstatOrNull(join(home, '.config', 'gcloud', 'credentials.db')))
-    add(
-      manual(
-        'gcloud-login',
-        'gcloud CLI sign-in',
-        'user OAuth credentials tied to this machine',
-        'on the box: `gcloud auth login --no-launch-browser`',
-      ),
-    );
-
-  // Kubernetes.
-  const kube = join(home, '.kube', 'config');
-  if (lstatOrNull(kube)) {
-    const text = readText(kube) || '';
-    const plugins = [...new Set([...text.matchAll(/^\s*command:\s*(\S+)/gm)].map((m) => basename(m[1])))];
-    add(
-      fileItem('.kube/config', { type: 'file', path: kube }, '~/.kube/config', {
-        ...(plugins.length
-          ? { note: `uses exec plugins (${plugins.join(', ')}): install them on the box and sign in to their cloud` }
-          : {}),
-      }),
-    );
-  }
-
-  // Docker: inline auths can go; a credential store is the macOS keychain.
-  const dockerPath = join(home, '.docker', 'config.json');
-  const docker = readJSON(dockerPath);
-  if (docker) {
-    const inline = Object.values(docker.auths || {}).some((a) => a && (a.auth || a.identitytoken));
-    if (inline) add(fileItem('.docker/config.json', { type: 'file', path: dockerPath }, '~/.docker/config.json'));
-    if (docker.credsStore || docker.credHelpers)
-      add(
-        manual(
-          'docker-login',
-          `Docker registry logins (${docker.credsStore ? `credsStore ${docker.credsStore}` : 'credHelpers'})`,
-          'kept by a credential helper (the macOS keychain or Docker Desktop)',
-          `on the box: \`docker login <registry>\` for each of ${Object.keys(docker.auths || {}).join(', ') || 'your registries'}`,
-        ),
-      );
-  }
-
-  // Files whose whole content is a credential.
-  const tokenFiles = [
-    ['.npmrc', /_authToken|_auth\s*=|_password/],
-    ['.pypirc', /password/i],
-    ['.netrc', /password/],
-    ['.git-credentials', /:\/\//],
-    ['.cargo/credentials.toml', /token/],
-    ['.cargo/credentials', /token/],
-    ['.config/gh/hosts.yml', /oauth_token/],
-  ];
-  for (const [rel, re] of tokenFiles) {
-    const p = join(home, rel);
-    const text = readText(p);
-    if (text === null || !re.test(text)) continue;
-    if (rel === '.config/gh/hosts.yml' && byName.has('GH_TOKEN')) continue; // GH_TOKEN covers it
-    add(fileItem(rel, { type: 'file', path: p }, `~/${rel}`));
-  }
-
-  // SSH private keys: possible, off by default.
-  const sshDir = join(home, '.ssh');
-  let sshNames = [];
-  try {
-    sshNames = readdirSync(sshDir).sort();
-  } catch {}
-  for (const n of sshNames) {
-    const p = join(sshDir, n);
-    if (!lstatOrNull(p)?.isFile() || n.endsWith('.pub') || ['config', 'known_hosts', 'authorized_keys'].includes(n))
-      continue;
-    if (!/PRIVATE KEY-----/.test(readHead(p, 64))) continue;
-    add(
-      fileItem(`.ssh/${n}`, { type: 'file', path: p }, `~/.ssh/${n}`, {
-        checked: false,
-        reason:
-          'a private key on a cloud box: prefer GH_TOKEN for git over HTTPS, or make a new key on the box and add it where needed',
-      }),
-    );
-  }
-
-  // Repos' .env files: to the Vault as files, linked into the repo on the box.
-  for (const r of work) {
-    for (const rel of r.envFiles) {
-      const p = join(r.path, rel);
-      const path = `${STAGE_DIR}/env/${r.name}/${rel}`;
-      if (!vaultPathOK(path)) continue;
-      add(
-        fileItem(path, { type: 'file', path: p }, tilde(p), {
-          id: `cred:file:${path}`,
-          repo: r.id,
-          link: `${r.dest}/${rel}`,
-          checked: r.checked,
-          note: `linked from ${r.dest}/${rel}`,
-        }),
-      );
-    }
-  }
-  return creds;
-}
-
-// --- environment ---------------------------------------------------------
-
-const skipJunk = (n) => n === '.git' || n === 'node_modules' || n === '.DS_Store' || n === '__pycache__';
-
-function scanEnvironment({ home, env, creds }) {
-  const out = [];
-  const credPaths = new Set(creds.filter((c) => c.kind === 'file').map((c) => c.path));
-  for (const rel of DOTFILES) {
-    if (credPaths.has(rel)) continue; // goes to the Vault instead
-    const p = join(home, rel);
-    const st = lstatOrNull(p);
-    if (!st) continue;
-    const dir = st.isDirectory();
-    const bytes = dir ? treeBytes(p, skipJunk) : st.size;
-    const item = { id: `env:file:${rel}`, kind: 'dotfile', path: rel, dir, bytes, checked: true };
-    if (SHELL_RC.includes(rel)) item.note = 'credentials and macOS-only lines left out';
-    if (dir && bytes > DOT_DIR_MAX) {
-      item.checked = false;
-      item.note = `${Math.round(bytes / 1048576)} MB: probably caches or plugins; reinstall them on the box`;
-    }
-    out.push(item);
-  }
-
-  const claudeDir = join(home, '.claude');
-  if (lstatOrNull(join(claudeDir, 'settings.json')))
-    out.push({ id: 'env:claude:settings', kind: 'claude', path: '.claude/settings.json', bytes: lstatOrNull(join(claudeDir, 'settings.json')).size, checked: true, note: 'merged into the box’s settings; secrets left out' });
-  if (lstatOrNull(join(claudeDir, 'CLAUDE.md')))
-    out.push({ id: 'env:claude:CLAUDE.md', kind: 'claude', path: '.claude/CLAUDE.md', bytes: lstatOrNull(join(claudeDir, 'CLAUDE.md')).size, checked: true });
-  for (const sub of ['skills', 'commands', 'agents']) {
-    const p = join(claudeDir, sub);
-    if (!lstatOrNull(p)?.isDirectory()) continue;
-    let names = readdirSync(p).filter((n) => !n.startsWith('.')).sort();
-    // Skills the instabox package installed are on the box already.
-    if (sub === 'skills') names = names.filter((n) => !(readText(join(p, n, 'SKILL.md')) || '').includes('installed-by: instabox'));
-    if (!names.length) continue;
-    out.push({ id: `env:claude:${sub}`, kind: 'claude', path: `.claude/${sub}`, names, bytes: names.reduce((s, n) => s + treeBytes(join(p, n), skipJunk), 0), checked: true });
-  }
-  const claudeJSON = readJSON(join(home, '.claude.json'));
-  const stdio = Object.entries(claudeJSON?.mcpServers || {}).filter(([, s]) => s.command);
-  if (stdio.length)
-    out.push({ id: 'env:claude:mcp', kind: 'claude', path: '.claude.json', names: stdio.map(([n]) => n).sort(), bytes: 0, checked: true, note: 'local (stdio) MCP servers, added with `claude mcp add-json` on the box; secrets come from the Vault' });
-
-  const codexDir = join(home, '.codex');
-  if (lstatOrNull(join(codexDir, 'config.toml')))
-    out.push({ id: 'env:codex:config', kind: 'codex', path: '.codex/config.toml', bytes: lstatOrNull(join(codexDir, 'config.toml')).size, checked: true, note: 'secret-looking lines left out' });
-  if (lstatOrNull(join(codexDir, 'AGENTS.md')))
-    out.push({ id: 'env:codex:AGENTS.md', kind: 'codex', path: '.codex/AGENTS.md', bytes: lstatOrNull(join(codexDir, 'AGENTS.md')).size, checked: true });
-  const agentsSkills = join(home, '.agents', 'skills');
-  if (lstatOrNull(agentsSkills)?.isDirectory()) {
-    const names = readdirSync(agentsSkills).filter((n) => !n.startsWith('.') && !(readText(join(agentsSkills, n, 'SKILL.md')) || '').includes('installed-by: instabox')).sort();
-    if (names.length)
-      out.push({ id: 'env:agents:skills', kind: 'agents', path: '.agents/skills', names, bytes: names.reduce((s, n) => s + treeBytes(join(agentsSkills, n), skipJunk), 0), checked: true });
-  }
-  return out;
-}
-
-// --- tools ---------------------------------------------------------------
-
-export function scanTools({ home, env }) {
-  const tools = [];
-  if (hasCommand('brew', env)) {
-    const r = run(['brew', 'leaves'], { env, timeout: 60_000 });
-    const names = lines(r.stdout).map((l) => l.trim()).sort();
-    if (names.length) tools.push({ id: 'tool:brew', kind: 'tools', manager: 'brew', names, checked: true });
-  }
-  if (hasCommand('npm', env)) {
-    const r = run(['npm', 'ls', '-g', '--depth=0', '--json'], { env, timeout: 60_000 });
-    let deps = {};
-    try {
-      deps = JSON.parse(r.stdout).dependencies || {};
-    } catch {}
-    const names = Object.keys(deps).sort();
-    if (names.length) tools.push({ id: 'tool:npm', kind: 'tools', manager: 'npm', names, checked: true });
-  }
-  if (hasCommand('uv', env)) {
-    const r = run(['uv', 'tool', 'list'], { env });
-    const names = lines(r.stdout).filter((l) => !/^\s|^-/.test(l)).map((l) => l.split(/\s+/)[0]).sort();
-    if (names.length) tools.push({ id: 'tool:uv', kind: 'tools', manager: 'uv', names, checked: true });
-  }
-  if (hasCommand('cargo', env)) {
-    const r = run(['cargo', 'install', '--list'], { env });
-    const names = lines(r.stdout).filter((l) => !/^\s/.test(l)).map((l) => l.split(/\s+/)[0]).sort();
-    if (names.length) tools.push({ id: 'tool:cargo', kind: 'tools', manager: 'cargo', names, checked: true, note: 'built from source on the box: slow' });
-  }
-  const gobin = env.GOBIN || join(env.GOPATH || join(home, 'go'), 'bin');
-  let gonames = [];
-  try {
-    gonames = readdirSync(gobin).filter((n) => lstatOrNull(join(gobin, n))?.isFile()).sort();
-  } catch {}
-  if (gonames.length) {
-    const modules = [];
-    const unknown = [];
-    for (const n of gonames) {
-      const m = hasCommand('go', env) ? run(['go', 'version', '-m', join(gobin, n)], { env }).stdout.match(/^\s*path\s+(\S+)/m) : null;
-      if (m) modules.push(m[1]);
-      else unknown.push(n);
-    }
-    tools.push({ id: 'tool:go', kind: 'tools', manager: 'go', names: modules.sort(), unknown, checked: true });
-  }
-  return tools;
-}
-
-// --- main ----------------------------------------------------------------
-
-export function scan(opts = {}) {
-  const env = opts.env || process.env;
-  const home = resolve(opts.home || env.HOME);
-  const cwd = opts.cwd ? resolve(opts.cwd) : null;
-  const roots = [
-    ...(opts.defaultRoots === false ? [] : DEFAULT_ROOTS.map((r) => join(home, r))),
-    ...(opts.roots || []).map((r) => resolve(r)),
-  ];
-  const platform = opts.platform || process.platform;
-  const { work, history } = scanWork({ home, cwd, roots, depth: opts.depth ?? 3, env });
-  const credentials = scanCredentials({ home, env, procEnv: opts.procEnv || env, work, platform });
-  const environment = [...scanEnvironment({ home, env, creds: credentials }), ...(opts.tools === false ? [] : scanTools({ home, env }))];
-  return { version: 1, home, platform, roots: [...new Set(roots.filter((r) => lstatOrNull(r)?.isDirectory()).map(realOrSelf))], work, history, credentials, environment };
-}
-
-function main() {
-  const args = process.argv.slice(2);
-  const opts = { roots: [], cwd: process.cwd() };
-  for (let i = 0; i < args.length; i++) {
-    const a = args[i];
-    if (a === '--root') opts.roots.push(args[++i]);
-    else if (a === '--no-default-roots') opts.defaultRoots = false;
-    else if (a === '--depth') opts.depth = Number(args[++i]);
-    else if (a === '--no-tools') opts.tools = false;
-    else if (a === '--no-cwd') opts.cwd = null;
-    else {
-      process.stderr.write(
-        'usage: scan.mjs [--root DIR]... [--no-default-roots] [--depth N] [--no-tools] [--no-cwd]\n',
-      );
-      process.exit(2);
-    }
-  }
-  process.stdout.write(JSON.stringify(scan(opts), null, 2) + '\n');
-}
-
-if (isMain(import.meta)) main();