@minionry/minion 0.7.36

package/bin/commands/create-sandbox.js

@@ -0,0 +1,542 @@
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+
+
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, rmSync, truncateSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import { APP_NAME } from '../branding.js';
+import { machinePath } from '../machine-layout.js';
+import {
+  buildDiskImageCommands,
+  buildPlainVolumeArgs,
+  buildRunArgs,
+  checkSandboxName,
+  defaultSandboxName,
+  parseRepoInput,
+  parseSandboxArgs,
+  REPO_KINDS,
+  SANDBOX_IMAGE_TAG,
+  sandboxNames,
+} from '../sandbox-config.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const BUILD_CONTEXT = resolve(__dirname, '..', 'sandbox');
+const PUBLIC_REGISTRY = 'https://registry.npmjs.org/';
+const CLI_REGISTRY =
+  JSON.parse(readFileSync(resolve(__dirname, '..', '..', 'package.json'), 'utf-8')).publishConfig?.registry ??
+  PUBLIC_REGISTRY;
+const REGISTRY_LABEL = 'minionry.registry';
+export const IMAGE_BUILD_ARGS = [
+  '-t',
+  SANDBOX_IMAGE_TAG,
+  '--build-arg',
+  `MINION_REGISTRY=${CLI_REGISTRY}`,
+  '--label',
+  `${REGISTRY_LABEL}=${CLI_REGISTRY}`,
+  BUILD_CONTEXT,
+];
+const SANDBOXES_DIR = machinePath('sandboxes');
+
+const colors = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m',
+};
+
+function log(msg, color = '') {
+  console.log(`${color}${msg}${colors.reset}`);
+}
+
+export function runCapture(cmd, args) {
+  return new Promise((resolveRun) => {
+    const child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    child.stdout.on('data', (d) => {
+      stdout += d;
+    });
+    child.stderr.on('data', (d) => {
+      stderr += d;
+    });
+    child.on('error', (err) => {
+      resolveRun({ ok: false, code: null, stdout, stderr, missing: err.code === 'ENOENT' });
+    });
+    child.on('exit', (code) => {
+      resolveRun({ ok: code === 0, code, stdout, stderr, missing: false });
+    });
+  });
+}
+
+function runInherit(cmd, args) {
+  return new Promise((resolveRun) => {
+    const child = spawn(cmd, args, { stdio: ['ignore', 'inherit', 'inherit'] });
+    child.on('error', () => resolveRun({ ok: false, code: null }));
+    child.on('exit', (code) => resolveRun({ ok: code === 0, code }));
+  });
+}
+
+export function createAsker() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const pending = [];
+  const waiters = [];
+  let closed = false;
+
+  rl.on('line', (line) => {
+    const waiter = waiters.shift();
+    if (waiter) waiter(line);
+    else pending.push(line);
+  });
+  rl.on('close', () => {
+    closed = true;
+    while (waiters.length > 0) waiters.shift()(null);
+  });
+  rl.on('SIGINT', () => {
+    rl.close();
+    process.stdout.write('\n');
+    process.exit(130);
+  });
+
+  const question = (text) => {
+    if (pending.length > 0) {
+      const line = pending.shift();
+      process.stdout.write(`${text}${line}\n`);
+      return Promise.resolve(line);
+    }
+    if (closed) {
+      process.stdout.write(`${text}\n`);
+      return Promise.resolve(null);
+    }
+    rl.setPrompt(text);
+    rl.prompt();
+    return new Promise((resolveAnswer) => waiters.push(resolveAnswer));
+  };
+
+  return { rl, question };
+}
+
+function aborted() {
+  log('\n  Cancelled — nothing was created.\n', colors.dim);
+  process.exit(130);
+}
+
+async function askRepo(question, label) {
+  for (;;) {
+    const answer = await question(`  ${label} ${colors.dim}(press Enter to skip):${colors.reset} `);
+    if (answer === null) aborted();
+    const parsed = parseRepoInput(answer);
+    if (parsed.ok) return parsed.url;
+    log(`  ${parsed.error}`, colors.yellow);
+  }
+}
+
+export async function confirm(question, text, { defaultYes = true } = {}) {
+  const answer = await question(`${text} ${colors.dim}${defaultYes ? '[Y/n]' : '[y/N]'}${colors.reset} `);
+  if (answer === null) return false;
+  const trimmed = answer.trim();
+  if (trimmed === '') return defaultYes;
+  return defaultYes ? !/^n/i.test(trimmed) : /^y/i.test(trimmed);
+}
+
+async function checkDocker() {
+  const info = await runCapture('docker', ['info', '--format', '{{json .}}']);
+  if (info.missing) return { status: 'missing' };
+  if (!info.ok) return { status: 'daemon', message: info.stderr.trim() || info.stdout.trim() };
+  try {
+    const parsed = JSON.parse(info.stdout);
+    if (parsed.ServerErrors?.length) {
+      return { status: 'daemon', message: parsed.ServerErrors.join('; ') };
+    }
+    const rootless = (parsed.SecurityOptions || []).some((o) => String(o).includes('rootless'));
+    return { status: 'ok', osType: parsed.OSType || 'unknown', rootless };
+  } catch {
+    return { status: 'daemon', message: 'Could not parse `docker info` output.' };
+  }
+}
+
+function printDockerMissing() {
+  log('  Docker is required for sandboxes but was not found on this machine.\n', colors.red);
+  log('  Install it, then re-run this command:', colors.bold);
+  log('    Linux:  curl -fsSL https://get.docker.com | sh', colors.cyan);
+  log('            sudo usermod -aG docker $USER && newgrp docker', colors.cyan);
+  log('    macOS:  https://docs.docker.com/desktop/setup/install/mac-install/', colors.cyan);
+  log('');
+}
+
+function printDockerDaemonHelp(message) {
+  log('  Docker is installed but the daemon is not reachable.\n', colors.red);
+  if (message) log(`  ${colors.dim}${message}${colors.reset}`);
+  log('  Try:', colors.bold);
+  if (process.platform === 'darwin') {
+    log('    Open Docker Desktop and wait for it to finish starting.', colors.cyan);
+  } else {
+    log('    sudo systemctl start docker', colors.cyan);
+    if (/permission denied/i.test(message || '')) {
+      log('    sudo usermod -aG docker $USER && newgrp docker   (fixes "permission denied")', colors.cyan);
+    }
+  }
+  log('');
+}
+
+export async function takenDockerNames() {
+  const [containers, volumes] = await Promise.all([
+    runCapture('docker', ['ps', '-a', '--format', '{{.Names}}']),
+    runCapture('docker', ['volume', 'ls', '--format', '{{.Name}}']),
+  ]);
+  const names = [];
+  for (const result of [containers, volumes]) {
+    if (result.ok) names.push(...result.stdout.split('\n').map((l) => l.trim()).filter(Boolean));
+  }
+  return names;
+}
+
+export const imagePathFor = (name) => join(SANDBOXES_DIR, `${name}.img`);
+
+const nameProblem = (name, taken) =>
+  checkSandboxName(name, { taken, imageExists: existsSync(imagePathFor(name)) });
+
+function printNameProblem(name, problem, color) {
+  if (problem.invalid) {
+    log(`  ${problem.invalid}`, color);
+    return;
+  }
+  const { container, volume } = sandboxNames(name);
+  log(`  A sandbox named "${name}" already exists (or left remains):`, color);
+  if (problem.clashes.includes('container')) {
+    log(`    - container "${container}" (docker rm -f ${container})`, colors.dim);
+  }
+  if (problem.clashes.includes('volume')) {
+    log(`    - volume "${volume}" (docker volume rm ${volume})`, colors.dim);
+  }
+  if (problem.clashes.includes('image')) {
+    log(`    - disk image ${imagePathFor(name)} (rm it if you no longer need that data)`, colors.dim);
+  }
+  if (!problem.clashes.includes('container')) {
+    log('    (a rename keeps the original volume name — check: minion list sandboxes)', colors.dim);
+  }
+}
+
+function firstFreeName(taken) {
+  let candidate = defaultSandboxName(taken);
+  while (existsSync(imagePathFor(candidate))) {
+    taken.push(sandboxNames(candidate).container, sandboxNames(candidate).volume);
+    candidate = defaultSandboxName(taken);
+  }
+  return candidate;
+}
+
+async function resolveName(explicitName) {
+  const taken = await takenDockerNames();
+
+  if (!explicitName) return { taken, names: null, suggested: firstFreeName(taken) };
+
+  const problem = nameProblem(explicitName, taken);
+  if (problem) {
+    log('');
+    printNameProblem(explicitName, problem, colors.red);
+    log('\n  Pick another name: minion create sandbox <name>\n', colors.dim);
+    process.exit(1);
+  }
+  return { taken, names: sandboxNames(explicitName), suggested: explicitName };
+}
+
+async function askName(question, taken, suggested) {
+  for (;;) {
+    const answer = await question(`  Sandbox name ${colors.dim}[${suggested}]:${colors.reset} `);
+    if (answer === null) aborted();
+    const name = answer.trim() === '' ? suggested : answer.trim();
+    const problem = nameProblem(name, taken);
+    if (!problem) return sandboxNames(name);
+    printNameProblem(name, problem, colors.yellow);
+  }
+}
+
+async function createCappedDisk(names, diskGb) {
+  const imagePath = imagePathFor(names.name);
+  const plan = buildDiskImageCommands({ imagePath, sizeGb: diskGb, volume: names.volume });
+
+  mkdirSync(SANDBOXES_DIR, { recursive: true });
+
+  const cleanup = async ({ volume }) => {
+    if (volume) await runCapture('docker', ['volume', 'rm', names.volume]);
+    rmSync(imagePath, { force: true });
+  };
+
+  try {
+    writeFileSync(imagePath, '');
+    truncateSync(imagePath, plan.imageBytes);
+  } catch (err) {
+    log(`  Could not create the disk image: ${err.message}`, colors.yellow);
+    return false;
+  }
+
+  const mkfs = await runCapture(plan.mkfs[0], plan.mkfs[1]);
+  if (!mkfs.ok) {
+    log(`  mkfs.ext4 failed${mkfs.missing ? ' (not installed — e2fsprogs)' : ''}: ${mkfs.stderr.trim()}`, colors.yellow);
+    await cleanup({ volume: false });
+    return false;
+  }
+
+  const volume = await runCapture(plan.volumeCreate[0], plan.volumeCreate[1]);
+  if (!volume.ok) {
+    log(`  docker volume create failed: ${volume.stderr.trim()}`, colors.yellow);
+    await cleanup({ volume: false });
+    return false;
+  }
+
+  const smoke = await runCapture('docker', [
+    'run', '--rm', '--entrypoint', '/bin/true', '-v', `${names.volume}:/mnt`, SANDBOX_IMAGE_TAG,
+  ]);
+  if (!smoke.ok) {
+    log(`  This Docker daemon could not mount the loopback disk: ${smoke.stderr.trim()}`, colors.yellow);
+    await cleanup({ volume: true });
+    return false;
+  }
+
+  return true;
+}
+
+function waitForFirstBoot(container) {
+  return runCapture('docker', [
+    'exec', container, 'bash', '-c',
+    'for i in $(seq 180); do [ -f "$HOME/.sandbox-provisioned" ] && exit 0; sleep 1; done; exit 1',
+  ]);
+}
+
+async function pendingCliInstall(container) {
+  const marker = await runCapture('docker', [
+    'exec', container, 'bash', '-c', 'cat "$HOME/.minion-cli-missing" 2>/dev/null',
+  ]);
+  return marker.ok ? marker.stdout.trim() : '';
+}
+
+export async function requireDocker() {
+  const docker = await checkDocker();
+  if (docker.status === 'missing') {
+    printDockerMissing();
+    process.exit(1);
+  }
+  if (docker.status === 'daemon') {
+    printDockerDaemonHelp(docker.message);
+    process.exit(1);
+  }
+  return docker;
+}
+
+async function diskCapSupported(docker) {
+  if (docker.osType !== 'linux' || docker.rootless || process.platform !== 'linux') return false;
+  return !(await runCapture('mkfs.ext4', ['-V'])).missing;
+}
+
+function printPlan({ names, memoryGb, diskGb, repoUrls, capPlanned, imageExists, rebuild }) {
+  log(`\n  ${colors.bold}Plan${colors.reset}`);
+  log(`    Sandbox   ${names.name}  ${colors.dim}(container ${names.container})${colors.reset}`);
+  if (memoryGb) log(`    Memory    ${memoryGb} GB cap, swap disabled`);
+  if (diskGb && capPlanned) {
+    log(`    Disk      ${diskGb} GB hard cap  ${colors.dim}(loopback ext4 at ${imagePathFor(names.name)})${colors.reset}`);
+  } else if (diskGb) {
+    log(`    Disk      ${diskGb} GB requested — ${colors.yellow}no hard cap on this host${colors.reset} ${colors.dim}(needs a root Linux Docker daemon + mkfs.ext4)${colors.reset}`);
+  }
+  for (const { kind } of REPO_KINDS) {
+    const rowLabel = kind[0].toUpperCase() + kind.slice(1);
+    log(`    ${rowLabel.padEnd(10)}${repoUrls[kind] ?? `${colors.dim}skipped${colors.reset}`}`);
+  }
+  const imageNote = imageExists && !rebuild
+    ? `${colors.dim}(cached)${colors.reset}`
+    : `${colors.yellow}(will build now — several minutes on the first run)${colors.reset}`;
+  log(`    Image     ${SANDBOX_IMAGE_TAG} ${imageNote}`);
+  log('');
+}
+
+async function runWizard({ names, suggested, taken, memoryGb, diskGb, capPlanned, imageExists, rebuild }) {
+  const { rl, question } = createAsker();
+
+  let resolved = names;
+  if (!resolved) {
+    log(`  ${colors.dim}Name it whatever you like — it becomes the sandbox's hostname and how${colors.reset}`);
+    log(`  ${colors.dim}every minion command refers to it. Enter takes the suggestion.${colors.reset}`);
+    resolved = await askName(question, taken, suggested);
+    log('');
+  }
+
+  log(`  ${colors.dim}Optionally seed the sandbox from public git repos (installable later too):${colors.reset}`);
+  log(`  ${colors.dim}Press Enter to skip any of them.${colors.reset}`);
+  const repoUrls = {};
+  for (const { kind, label, dest } of REPO_KINDS) {
+    repoUrls[kind] = await askRepo(question, `${label} → ${dest}`);
+  }
+
+  printPlan({ names: resolved, memoryGb, diskGb, repoUrls, capPlanned, imageExists, rebuild });
+  const confirmed = await confirm(question, '  Create this sandbox?');
+  rl.close();
+  return { names: resolved, repoUrls, confirmed };
+}
+
+async function cachedImageMatches() {
+  const image = await runCapture('docker', ['image', 'inspect', '--format', '{{ json .Config.Labels }}', SANDBOX_IMAGE_TAG]);
+  if (!image.ok) return false;
+  let labels = null;
+  try {
+    labels = JSON.parse(image.stdout);
+  } catch {
+  }
+  const registry = labels?.[REGISTRY_LABEL];
+  if (registry ? registry === CLI_REGISTRY : CLI_REGISTRY !== PUBLIC_REGISTRY) return true;
+  log(`  ${colors.dim}The cached ${SANDBOX_IMAGE_TAG} image installs the minion CLI from ${registry ?? 'another registry'}; this CLI came from ${CLI_REGISTRY}, so it will be rebuilt.${colors.reset}\n`);
+  return false;
+}
+
+async function ensureImage(imageExists, rebuild) {
+  if (imageExists && !rebuild) return;
+  log(`\n  Building ${SANDBOX_IMAGE_TAG}...`, colors.bold);
+  const build = await runInherit('docker', ['build', ...IMAGE_BUILD_ARGS]);
+  if (!build.ok) {
+    log('\n  Image build failed — nothing was created. Re-run to try again.\n', colors.red);
+    process.exit(1);
+  }
+}
+
+async function provisionDisk(names, diskGb, capPlanned) {
+  let diskCapped = false;
+  if (diskGb && capPlanned) {
+    log('\n  Creating the capped disk region...', colors.bold);
+    diskCapped = await createCappedDisk(names, diskGb);
+    if (!diskCapped) {
+      log('  Falling back to an uncapped volume — the sandbox still gets its own isolated disk region, but the size cap will not be enforced.', colors.yellow);
+    }
+  }
+  if (!diskCapped) {
+    const plain = await runCapture('docker', buildPlainVolumeArgs(names.volume));
+    if (!plain.ok) {
+      log(`\n  Could not create the sandbox volume: ${plain.stderr.trim()}\n`, colors.red);
+      process.exit(1);
+    }
+  }
+  return diskCapped;
+}
+
+async function installRepos(names, repoUrls, bootOk) {
+  for (const { kind, label, dest } of REPO_KINDS) {
+    const url = repoUrls[kind];
+    if (!url) continue;
+    const retryCmd = `docker exec -it ${names.container} sandbox-install-repo ${kind} ${url}`;
+    if (!bootOk) {
+      log(`  Skipped the ${kind} install — run it once the sandbox is healthy: ${retryCmd}`, colors.yellow);
+      continue;
+    }
+    log(`\n  Installing ${label} → ${dest}...`, colors.bold);
+    const install = await runInherit('docker', ['exec', names.container, 'sandbox-install-repo', kind, url]);
+    if (!install.ok) {
+      log(`  Failed — retry any time with: ${retryCmd}`, colors.yellow);
+    }
+  }
+}
+
+function printDone({ names, memoryGb, diskGb, diskCapped, cliInstall, sandboxedBrowser = true }) {
+  log(`\n  Sandbox "${names.name}" is ready.\n`, colors.bold + colors.green);
+  if (memoryGb) log(`    Memory   ${memoryGb} GB cap (swap disabled)`);
+  if (diskCapped) {
+    log(`    Disk     ${diskGb} GB hard cap — ${imagePathFor(names.name)} ${colors.dim}(sparse: uses host disk only as the sandbox writes)${colors.reset}`);
+  } else if (diskGb) {
+    log(`    Disk     volume ${names.volume} ${colors.yellow}(size cap not enforced on this host)${colors.reset}`);
+  }
+  if (!sandboxedBrowser) {
+    log(`    Browser  Chromium runs unsandboxed inside this sandbox ${colors.dim}(the daemon rejected the seccomp profile; the container is the boundary)${colors.reset}`, colors.yellow);
+  }
+  if (memoryGb || diskGb || !sandboxedBrowser) log('');
+  log('  Enter it:', colors.bold);
+  log(`    docker exec -it ${names.container} zsh`, colors.cyan);
+  log('');
+  if (cliInstall) {
+    log('  Install the minion CLI:', colors.bold + colors.yellow);
+    log('    The build skipped it — the registry rejected the install. Inside the', colors.dim);
+    log('    sandbox, authenticate to the registry, then run:', colors.dim);
+    log(`    ${cliInstall}`, colors.cyan);
+    log('');
+  }
+  log('  Create Spaces in it:', colors.bold);
+  log('    Inside the sandbox, run "minion login", then "minion" from any folder', colors.dim);
+  log('    (~/spaces is ready for them). The sandbox then appears as its own', colors.dim);
+  log(`    machine in ${APP_NAME}.`, colors.dim);
+  log('');
+  log('  Manage it:', colors.bold);
+  log('    minion list sandboxes', colors.dim);
+  log(`    minion rename sandbox ${names.name} <new-name>`, colors.dim);
+  log(`    minion restart sandbox ${names.name}`, colors.dim);
+  if (memoryGb) log(`    minion restart sandbox ${names.name} --uncap   (lift the memory cap later)`, colors.dim);
+  log(`    Stop: docker stop ${names.container}`, colors.dim);
+  log(`    Delete: docker rm -f ${names.container} && docker volume rm ${names.volume}${diskCapped ? ` && rm ${imagePathFor(names.name)}` : ''}`, colors.dim);
+  log('');
+}
+
+export async function createSandbox(args = []) {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    log('\n  "minion create sandbox" is interactive — run it from a terminal.\n', colors.red);
+    process.exit(1);
+  }
+
+  const parsed = parseSandboxArgs(args);
+  if (!parsed.ok) {
+    log(`\n  ${parsed.error}`, colors.red);
+    log('  Usage: minion create sandbox [name] [--rebuild] [--memory <GB>] [--disk <GB>]\n', colors.dim);
+    process.exit(1);
+  }
+  const { name: explicitName, rebuild, memoryGb, diskGb } = parsed;
+
+  log(`\n  ${APP_NAME} Sandbox Setup\n`, colors.bold + colors.cyan);
+  log('  Creates an isolated sandbox — its own disk region, provisioned with', colors.dim);
+  log('  zsh, Node, Claude Code and the minion CLI, ready for you to create', colors.dim);
+  log('  Spaces in.\n', colors.dim);
+
+  const docker = await requireDocker();
+  const { taken, names: explicitNames, suggested } = await resolveName(explicitName);
+  const imageExists = await cachedImageMatches();
+  const capPlanned = diskGb !== null && (await diskCapSupported(docker));
+
+  const { names, repoUrls, confirmed } = await runWizard({
+    names: explicitNames, suggested, taken, memoryGb, diskGb, capPlanned, imageExists, rebuild,
+  });
+  if (!confirmed) {
+    log('\n  Cancelled — nothing was created.\n', colors.dim);
+    process.exit(0);
+  }
+
+  await ensureImage(imageExists, rebuild);
+  const diskCapped = await provisionDisk(names, diskGb, capPlanned);
+
+  log('  Starting the sandbox...', colors.bold);
+  let run = await runCapture('docker', buildRunArgs({ names, memoryGb, diskGb, diskCapped }));
+  let sandboxedBrowser = true;
+  if (!run.ok && /seccomp/i.test(run.stderr)) {
+    log(`  This Docker daemon rejected the browser seccomp profile — starting without it: ${run.stderr.trim()}`, colors.yellow);
+    await runCapture('docker', ['rm', '-f', names.container]);
+    run = await runCapture('docker', buildRunArgs({ names, memoryGb, diskGb, diskCapped, seccompProfile: null }));
+    sandboxedBrowser = false;
+  }
+  if (!run.ok) {
+    log(`\n  docker run failed: ${run.stderr.trim()}`, colors.red);
+    await runCapture('docker', ['volume', 'rm', names.volume]);
+    if (diskCapped) rmSync(imagePathFor(names.name), { force: true });
+    log('  Cleaned up — nothing was left behind. Re-run to try again.\n', colors.dim);
+    process.exit(1);
+  }
+
+  log(`  ${colors.dim}First boot: installing the toolchain into the sandbox disk...${colors.reset}`);
+  const boot = await waitForFirstBoot(names.container);
+  if (!boot.ok) {
+    log(`  First boot did not finish cleanly — inspect it with: docker logs ${names.container}`, colors.yellow);
+  }
+
+  await installRepos(names, repoUrls, boot.ok);
+  const cliInstall = boot.ok ? await pendingCliInstall(names.container) : '';
+  printDone({ names, memoryGb, diskGb, diskCapped, cliInstall, sandboxedBrowser });
+}
+
+export default createSandbox;

package/bin/commands/fingerprint.js

@@ -0,0 +1,101 @@
+
+import { APP_NAME } from '../branding.js';
+import { launchFlagSuffix } from '../launch-env.js';
+
+const colors = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m',
+};
+
+function log(msg, color = '') {
+  console.log(`${color}${msg}${colors.reset}`);
+}
+
+const E2EE_PUBLIC_KEY_PATTERN = /^[A-Za-z0-9_-]{43}$/;
+
+async function loadE2eeIdentityModule() {
+  try {
+    return await import('../../dist/server/services/e2ee-identity.js');
+  } catch {
+    try {
+      const tsx = await import('tsx/esm/api');
+      return await tsx.tsImport('../../server/services/e2ee-identity.ts', import.meta.url);
+    } catch {
+      return null;
+    }
+  }
+}
+
+export async function fingerprint(args = []) {
+  const envSuffix = launchFlagSuffix(process.env.MINIONRY_ENV);
+  const peerKey = args.find((a) => !a.startsWith('-'));
+
+  log(`\n  ${APP_NAME} — Verify encryption\n`, colors.bold + colors.cyan);
+
+  const mod = await loadE2eeIdentityModule();
+  if (!mod?.ensureE2eeIdentity) {
+    log('  Could not load the encryption module on this runtime.', colors.yellow);
+    log('  End-to-end encryption may be unavailable here.', colors.dim);
+    log('');
+    return;
+  }
+
+  const status = await mod.ensureE2eeIdentity();
+  if (!status?.available || !status.publicKey) {
+    log('  Encryption isn\'t set up on this machine yet.', colors.yellow);
+    if (status?.reason) log(`  Reason: ${status.reason}`, colors.dim);
+    log('');
+    log(`  Sign in to set up an encryption identity:`, colors.dim);
+    log(`    minion login${envSuffix}`, colors.dim);
+    log('');
+    return;
+  }
+
+  if (!peerKey) {
+    log('  This machine\'s encryption key', colors.bold);
+    log(`    ${status.publicKey}`, colors.dim);
+    log('');
+    log('  To check that your browser is talking to THIS machine (and not an', colors.dim);
+    log('  impostor), open the Space in the web app, choose "Verify encryption",', colors.dim);
+    log('  and run the command it shows you here. Then compare the two safety', colors.dim);
+    log('  numbers — they must match exactly.', colors.dim);
+    log('');
+    return;
+  }
+
+  if (!E2EE_PUBLIC_KEY_PATTERN.test(peerKey)) {
+    log('  That doesn\'t look like a web session key.', colors.red);
+    log('  Copy the exact command shown under "Verify encryption" in the web app.', colors.dim);
+    log('');
+    log(`  Usage: minion fingerprint <web-session-key>`, colors.dim);
+    log('');
+    process.exitCode = 1;
+    return;
+  }
+
+  let safetyNumber;
+  try {
+    safetyNumber = await mod.deriveSessionSafetyNumber(peerKey);
+  } catch (err) {
+    log('  Could not compute a safety number.', colors.red);
+    log(`  ${err instanceof Error ? err.message : String(err)}`, colors.dim);
+    log('');
+    process.exitCode = 1;
+    return;
+  }
+
+  log('  Safety number', colors.bold);
+  log(`    ${safetyNumber}`, colors.green + colors.bold);
+  log('');
+  log('  Compare this with the number shown in the web app.', colors.dim);
+  log('  If every group matches, your connection is verified end to end.', colors.dim);
+  log(`  If they ${colors.reset}${colors.yellow}don't${colors.reset}${colors.dim} match, stop — someone may be intercepting this Space.`, colors.dim);
+  log('');
+}
+
+export default fingerprint;