@minionry/minion 0.7.36

package/bin/minion.js

@@ -0,0 +1,839 @@
+#!/usr/bin/env node
+// Copyright (c) 2025-present Minionry, Inc.
+// SPDX-License-Identifier: LicenseRef-Minionry-Software
+
+
+import { spawn } from 'node:child_process';
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+import { fileURLToPath } from 'node:url';
+import { APP_NAME } from './branding.js';
+import { launchFlagSuffix, resolveLaunchTargets } from './launch-env.js';
+import { ensureMachineDir, machineFile, machinePath } from './machine-layout.js';
+import { describeSource, loadNodePty, nativeRoot, prebuiltPlatformDir } from './pty-locator.js';
+import { normalizeNodePtyTree, provisionNodePty } from './pty-provision.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const CLIENT_ROOT = resolve(__dirname, '..');
+
+const pkg = JSON.parse(readFileSync(join(CLIENT_ROOT, 'package.json'), 'utf-8'));
+
+const UPDATE_CHECK_INTERVAL = 1000 * 60 * 60;
+const REGISTRY_URL = (pkg.publishConfig?.registry ?? 'https://registry.npmjs.org').replace(/\/+$/, '');
+const REGISTRY_FLAG = `--${pkg.name.split('/')[0]}:registry=${REGISTRY_URL}/`;
+const manualUpdateCommand = () => `npm i -g ${pkg.name}@latest ${REGISTRY_FLAG}`;
+
+const USER_CWD = process.cwd();
+
+function setTerminalTitle(directory) {
+  if (!process.stdout.isTTY) return;
+  const dirName = directory.split('/').pop() || directory;
+  const title = `minion: ${dirName}`;
+  process.stdout.write(`\x1b]0;${title}\x07`);
+}
+
+setTerminalTitle(process.cwd());
+
+const colors = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  red: '\x1b[31m',
+  dim: '\x1b[2m',
+  cyan: '\x1b[36m',
+};
+
+function log(msg, color = '') {
+  console.log(`${color}${msg}${colors.reset}`);
+}
+
+async function isNodePtyAvailable() {
+  return loadNodePty().ok;
+}
+
+function hasUserDismissedPtySetup() {
+  return existsSync(machineFile('ptySetupDismissed'));
+}
+
+function showPtyWarning() {
+  log('  Terminal support not available. Run: minion install terminal', colors.dim);
+  log('  (already tried? "minion doctor terminal" reports the actual reason)', colors.dim);
+}
+
+function reportPtyFailure(diagnosis, attempts, logPath) {
+  const tail = (attempts.at(-1)?.output ?? '')
+    .split('\n')
+    .filter((line) => line.trim())
+    .slice(-12);
+  if (tail.length > 0) {
+    log('\n  Build output:', colors.bold);
+    for (const line of tail) log(`    ${line}`, colors.dim);
+    log('');
+  }
+
+  log(`  ${diagnosis.title}`, colors.red);
+  log(`  ${colors.dim}(${diagnosis.code})${colors.reset}\n`);
+  for (const line of diagnosis.remedies) log(`    ${line}`, colors.dim);
+  log('');
+  if (logPath) log(`  Full build log: ${logPath}`, colors.dim);
+  log('  Diagnose again any time: minion doctor terminal\n', colors.dim);
+}
+
+async function runPtySetup() {
+  const { probeToolchain, toolchainReady, classifyPtyFailure, writeInstallLog } = await import('./pty-doctor.js');
+  const probe = probeToolchain();
+  const loadErrors = loadNodePty().errors ?? [];
+
+  if (!toolchainReady(probe).ready) {
+    reportPtyFailure(classifyPtyFailure({ attempts: [], loadErrors, probe }), [], null);
+    return false;
+  }
+
+  log('\n  The prebuilt terminal binary did not load on this machine — compiling node-pty instead.', colors.dim);
+  log(`  Target: ${probe.node.version} (${process.platform}-${process.arch}) → ${nativeRoot()}\n`, colors.dim);
+
+  const result = await provisionNodePty({
+    probe,
+    onProgress: (label) => log(`  → ${label}`, colors.dim),
+  });
+
+  if (result.ok) {
+    log('\n  Terminal support enabled successfully!\n', colors.bold + colors.green);
+    return true;
+  }
+
+  const afterErrors = loadNodePty().errors ?? [];
+  const diagnosis = classifyPtyFailure({ attempts: result.attempts, loadErrors: afterErrors, probe });
+  reportPtyFailure(diagnosis, result.attempts, writeInstallLog(result.attempts, afterErrors));
+  return false;
+}
+
+async function doctorTerminal() {
+  const { probeToolchain, renderProbe } = await import('./pty-doctor.js');
+  log(`\n  ${APP_NAME} Terminal Doctor\n`, colors.bold + colors.cyan);
+
+  const loaded = loadNodePty();
+  if (loaded.ok) {
+    log(`  Terminal: ready ${colors.dim}(${describeSource(loaded.source)})${colors.reset}`, colors.green);
+    log(`  ${colors.dim}${loaded.path}${colors.reset}\n`);
+  } else {
+    log('  Terminal: not available\n', colors.yellow);
+    for (const error of loaded.errors) {
+      log(`    ${error.source} — ${describeSource(error.source)}`, colors.dim);
+      log(`      ${error.code}: ${error.message.split('\n')[0]}`, colors.dim);
+    }
+    log('');
+  }
+
+  for (const line of renderProbe(probeToolchain())) log(`  ${line}`, colors.dim);
+  log('');
+  if (!loaded.ok) log('  Run: minion install terminal\n', colors.cyan);
+}
+
+async function doctorBrowser() {
+  log(`\n  ${APP_NAME} Browser Doctor\n`, colors.bold + colors.cyan);
+
+  const { loadPreflight, renderChecks } = await import('./commands/browser-install.js');
+  let preflightMod;
+  try {
+    preflightMod = await loadPreflight();
+  } catch (err) {
+    log(`  Could not load preflight: ${err.message}`, colors.red);
+    return;
+  }
+
+  const result = await preflightMod.preflight();
+  renderChecks(result.checks);
+  log('');
+  if (!result.ok) log('  Run: minion install browser\n', colors.cyan);
+}
+
+function getAliveInstances() {
+  const instancesPath = machineFile('instances');
+  const tokenPath = machineFile('sessionToken');
+
+  if (!existsSync(instancesPath) || !existsSync(tokenPath)) return null;
+
+  try {
+    const instances = JSON.parse(readFileSync(instancesPath, 'utf-8'));
+    const token = readFileSync(tokenPath, 'utf-8').trim();
+    if (!Array.isArray(instances) || !token) return null;
+
+    const now = Date.now();
+    const alive = instances.filter(i => now - i.lastHeartbeat < 2 * 60 * 1000);
+    return alive.length > 0 ? { alive, token } : null;
+  } catch {
+    return null;
+  }
+}
+
+async function notifyRunningServers() {
+  const result = getAliveInstances();
+  if (!result) {
+    log('  Restart minion to enable terminal support.\n', colors.dim);
+    return;
+  }
+
+  let reloaded = 0;
+  for (const instance of result.alive) {
+    try {
+      const res = await fetch(`http://localhost:${instance.port}/api/reload-pty`, {
+        method: 'POST',
+        headers: { 'x-session-token': result.token },
+      });
+      if (res.ok) {
+        const data = await res.json();
+        if (data.success) reloaded++;
+      }
+    } catch {
+    }
+  }
+
+  if (reloaded > 0) {
+    log(`  Notified ${reloaded} running minion server${reloaded > 1 ? 's' : ''} — terminal is ready!\n`, colors.green);
+  } else {
+    log('  Restart minion to enable terminal support.\n', colors.dim);
+  }
+}
+
+function confirm(question) {
+  return new Promise((resolveAnswer) => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    let answered = false;
+    rl.on('SIGINT', () => {
+      rl.close();
+      process.stdout.write('\n');
+      process.exit(130);
+    });
+    rl.on('close', () => {
+      if (!answered) resolveAnswer(false);
+    });
+    rl.question(`${question} ${colors.dim}[Y/n]${colors.reset} `, (answer) => {
+      answered = true;
+      rl.close();
+      resolveAnswer(!/^n/i.test(answer.trim()));
+    });
+  });
+}
+
+async function offerTerminalSetup(interactive) {
+  const loaded = loadNodePty();
+  if (loaded.ok) {
+    log(`  Terminal: ready (${describeSource(loaded.source)})`, colors.dim);
+    return;
+  }
+  if (!interactive) {
+    log('  Terminal: not set up. Run "minion install terminal" to enable the web terminal.', colors.dim);
+    return;
+  }
+  log('  Terminal: not set up (the web terminal needs a one-time native module build).', colors.yellow);
+  if (await confirm('  Set up the terminal now?')) {
+    const success = await runPtySetup();
+    if (success) await notifyRunningServers();
+  } else {
+    log('  Skipped. Run "minion install terminal" any time.\n', colors.dim);
+  }
+}
+
+async function offerBrowserSetup(interactive) {
+  let browserPreflight = null;
+  try {
+    const { loadPreflight } = await import('./commands/browser-install.js');
+    const preflightMod = await loadPreflight();
+    browserPreflight = await preflightMod.preflight();
+  } catch {
+    return;
+  }
+
+  if (browserPreflight.ok) {
+    log('  Browser: ready', colors.dim);
+    return;
+  }
+
+  const missing = browserPreflight.checks
+    .filter((c) => !c.ok && !c.advisory)
+    .map((c) => c.label);
+  if (!interactive) {
+    log(`  Browser: missing ${missing.join(', ')}. Run "minion install browser".`, colors.dim);
+    return;
+  }
+
+  log(`  Browser: missing ${missing.join(', ')}.`, colors.yellow);
+  if (await confirm('  Install browser dependencies now?')) {
+    const { browserInstall } = await import('./commands/browser-install.js');
+    await browserInstall([], { exit: false });
+  } else {
+    log('  Skipped. Run "minion install browser" any time.\n', colors.dim);
+  }
+}
+
+async function runPostLoginSetup() {
+  const interactive = process.stdin.isTTY && process.stdout.isTTY;
+  await offerTerminalSetup(interactive);
+  await offerBrowserSetup(interactive);
+}
+
+async function installTerminal() {
+  log(`\n  ${APP_NAME} Terminal Setup\n`, colors.bold + colors.cyan);
+  const loaded = loadNodePty();
+  if (loaded.ok) {
+    log(`  Terminal support is already enabled — ${describeSource(loaded.source)}.`, colors.green);
+    log(`  ${colors.dim}${loaded.path}${colors.reset}\n`);
+    await notifyRunningServers();
+    return;
+  }
+  const success = await runPtySetup();
+  if (success) {
+    await notifyRunningServers();
+  }
+  process.exit(success ? 0 : 1);
+}
+
+function showHelp() {
+  log(`\n  ${APP_NAME} CLI\n`, colors.bold + colors.cyan);
+  log('  Connects this machine to app.minionry.com.\n', colors.dim);
+  log('  Usage:', colors.bold);
+  log(`    minion                       Start ${APP_NAME} in the background (logs in automatically if needed)`, colors.dim);
+  log('    minion login                 Re-authenticate this device with minionry.com', colors.dim);
+  log('    minion logout                Sign out of minionry.com', colors.dim);
+  log('    minion whoami                Show current user and device info', colors.dim);
+  log('    minion status                Show connection and auth status', colors.dim);
+  log('    minion list minions          List the minion servers running on this machine', colors.dim);
+  log('    minion shutdown <pid>        Stop one minion server on this machine', colors.dim);
+  log('    minion shutdown all          Stop every minion server on this machine', colors.dim);
+  log('    minion fingerprint [key]     Show the safety number to verify encryption', colors.dim);
+  log('    minion create sandbox        Create an isolated sandbox to make Spaces in', colors.dim);
+  log('    minion list sandboxes        List this machine\'s sandboxes and what they cap', colors.dim);
+  log('    minion rename sandbox <old> <new>', colors.dim);
+  log('                                 Rename a sandbox, keeping its disk', colors.dim);
+  log('    minion restart sandbox <name>', colors.dim);
+  log('                                 Restart a sandbox (also starts a stopped one);', colors.dim);
+  log('                                 --uncap lifts its memory cap, replacing the container', colors.dim);
+  log('    minion install browser       Install in-app browser dependencies for your platform', colors.dim);
+  log('    minion doctor                Report why the terminal or in-app browser is unavailable', colors.dim);
+  log(`    minion update                Update ${APP_NAME} to the latest version`, colors.dim);
+  log('');
+  log('  Options:', colors.bold);
+  log('    --port, -p <port>            Override automatic port selection', colors.dim);
+  log('    --foreground                 Run attached to the terminal instead of in the background', colors.dim);
+  log('    --version, -V                Show version number', colors.dim);
+  log('    --help, -h                   Show this help message', colors.dim);
+  log('');
+  log('  Authentication:', colors.bold);
+  log('    Running "minion" will prompt you to log in automatically if needed.', colors.dim);
+  log('    Once logged in, this machine and its Spaces appear at app.minionry.com.', colors.dim);
+  log('');
+}
+
+function resolveStartScript() {
+  if (existsSync(join(CLIENT_ROOT, 'dist', 'server', 'index.js'))) return 'start';
+  log('  No build found — starting from TypeScript sources. Run "npm run build" for the production entry.', colors.dim);
+  return 'dev';
+}
+
+function runNpmScriptDetached(script, args = [], envOverrides = {}) {
+  const logDir = machinePath('logs');
+  if (!existsSync(logDir)) mkdirSync(logDir, { recursive: true });
+  const logPath = join(logDir, `minionry-${new Date().toISOString().replace(/[:.]/g, '-')}.log`);
+  const logFd = openSync(logPath, 'a');
+
+  const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  const child = spawn(npmCmd, ['run', '--silent', script, ...args], {
+    cwd: CLIENT_ROOT,
+    stdio: ['ignore', logFd, logFd],
+    env: { ...process.env, MINIONRY_WORKING_DIR: USER_CWD, ...envOverrides },
+    detached: true,
+    ...(process.platform === 'win32' ? { windowsHide: true } : {}),
+  });
+
+  child.on('error', (err) => {
+    log(`Error: ${err.message}`, colors.red);
+    closeSync(logFd);
+    process.exit(1);
+  });
+
+  child.unref();
+  closeSync(logFd);
+
+  log(`\n  ${APP_NAME} started in background`, colors.bold + colors.green);
+  log(`  Stop: kill ${child.pid}`, colors.dim);
+  log('  Status: minion status', colors.dim);
+  log(`  Remote control: ${envOverrides.APP_ORIGIN || 'https://app.minionry.com'}\n`, colors.dim);
+  process.exit(0);
+}
+
+function runNpmScript(script, args = [], envOverrides = {}) {
+  const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  const child = spawn(npmCmd, ['run', '--silent', script, ...args], {
+    cwd: CLIENT_ROOT,
+    stdio: 'inherit',
+    env: { ...process.env, MINIONRY_WORKING_DIR: USER_CWD, ...envOverrides },
+  });
+
+  let isShuttingDown = false;
+
+  process.on('SIGINT', () => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    child.kill('SIGTERM');
+  });
+
+  try {
+    process.chdir(USER_CWD);
+  } catch (_e) {
+  }
+
+  child.on('error', (err) => {
+    log(`Error: ${err.message}`, colors.red);
+    process.exit(1);
+  });
+
+  child.on('exit', (code) => {
+    if (isShuttingDown) {
+      process.stdout.write('\n');
+    }
+    process.exit(code || 0);
+  });
+}
+
+const args = process.argv.slice(2);
+
+function parsePort(args) {
+  const portIndex = args.findIndex(a => a === '--port' || a === '-p');
+  if (portIndex !== -1 && args[portIndex + 1]) {
+    const port = parseInt(args[portIndex + 1], 10);
+    if (!Number.isNaN(port) && port > 0 && port < 65536) {
+      return port;
+    }
+    log(`Invalid port: ${args[portIndex + 1]}`, colors.red);
+    process.exit(1);
+  }
+  return null;
+}
+
+function resolveLaunchEnv(args) {
+  const requestedPort = parsePort(args);
+  const { minionryEnv, appOrigin, serverUrl } = resolveLaunchTargets(args);
+
+  process.env.MINIONRY_ENV = minionryEnv;
+  delete process.env.PLATFORM_URL;
+  delete process.env.APP_ORIGIN;
+  if (serverUrl) process.env.PLATFORM_URL = serverUrl;
+  if (appOrigin) process.env.APP_ORIGIN = appOrigin;
+
+  return {
+    ...(requestedPort ? { PORT: String(requestedPort) } : {}),
+    ...(serverUrl ? { PLATFORM_URL: serverUrl } : {}),
+    ...(appOrigin ? { APP_ORIGIN: appOrigin } : {}),
+    MINIONRY_ENV: minionryEnv,
+  };
+}
+
+function compareVersions(a, b) {
+  const pa = a.split('.').map(Number);
+  const pb = b.split('.').map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((pa[i] || 0) > (pb[i] || 0)) return 1;
+    if ((pa[i] || 0) < (pb[i] || 0)) return -1;
+  }
+  return 0;
+}
+
+function readUpdateCache() {
+  try {
+    const file = machineFile('updateCheck');
+    if (!existsSync(file)) return null;
+    const cache = JSON.parse(readFileSync(file, 'utf-8'));
+    return cache?.registry === REGISTRY_URL ? cache : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeUpdateCache(latest) {
+  try {
+    ensureMachineDir('cache');
+    writeFileSync(machineFile('updateCheck'), JSON.stringify({ latest, checkedAt: Date.now(), registry: REGISTRY_URL }));
+  } catch {
+  }
+}
+
+function readNpmrcValue(key) {
+  try {
+    const npmrc = readFileSync(join(homedir(), '.npmrc'), 'utf-8');
+    for (const line of npmrc.split('\n')) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith(';')) continue;
+      const eq = trimmed.indexOf('=');
+      if (eq !== -1 && trimmed.slice(0, eq).trim() === key) return trimmed.slice(eq + 1);
+    }
+  } catch {
+  }
+  return null;
+}
+
+function readNpmAuthToken() {
+  const key = `${REGISTRY_URL.replace(/^https?:/, '').replace(/\/+$/, '')}/:_authToken`;
+  const raw =
+    process.env[`npm_config_${key}`] ?? process.env[`npm_config_${key.toLowerCase()}`] ?? readNpmrcValue(key);
+  if (!raw) return null;
+
+  const value = raw.trim().replace(/^["']|["']$/g, '').replace(/\$\{([^}]+)\}/g, (_, name) => process.env[name] ?? '');
+  return value && !value.includes('${') ? value : null;
+}
+
+async function fetchLatestVersion(timeoutMs = 3000) {
+  try {
+    const token = readNpmAuthToken();
+    const res = await fetch(`${REGISTRY_URL}/${encodeURIComponent(pkg.name)}/latest`, {
+      signal: AbortSignal.timeout(timeoutMs),
+      ...(token ? { headers: { authorization: `Bearer ${token}` } } : {}),
+    });
+    if (!res.ok) return null;
+    const { version } = await res.json();
+    if (version) writeUpdateCache(version);
+    return version || null;
+  } catch {
+    return null;
+  }
+}
+
+function updateType(current, latest) {
+  const c = current.split('.').map(Number);
+  const l = latest.split('.').map(Number);
+  if (l[0] > c[0]) return 'major';
+  if (l[1] > c[1]) return 'minor';
+  return 'patch';
+}
+
+async function resolveLatestVersion() {
+  const cache = readUpdateCache();
+
+  if (cache?.latest && (Date.now() - cache.checkedAt) < UPDATE_CHECK_INTERVAL) {
+    return cache.latest;
+  }
+
+  const fetched = await fetchLatestVersion(3000);
+  if (fetched) return fetched;
+
+  return cache?.latest || null;
+}
+
+function installGlobalVersion(version) {
+  const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  return new Promise((resolve) => {
+    const child = spawn(npmCmd, ['install', '-g', `${pkg.name}@${version}`, REGISTRY_FLAG], {
+      stdio: ['ignore', 'ignore', 'pipe'],
+    });
+    let stderr = '';
+    child.stderr.on('data', (d) => { stderr += d; });
+    child.on('error', () => resolve({ ok: false, stderr: '' }));
+    child.on('exit', (code) => resolve({ ok: code === 0, stderr }));
+  });
+}
+
+function updateCli() {
+  const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+  const target = `${pkg.name}@latest`;
+  const manualCmd = manualUpdateCommand();
+  log(`\n  Updating minion — installing ${colors.cyan}${target}${colors.reset} ${colors.dim}(${manualCmd})${colors.reset}\n`);
+
+  const child = spawn(npmCmd, ['install', '-g', target, REGISTRY_FLAG], { stdio: 'inherit' });
+
+  child.on('error', (err) => {
+    log(`\n  Update failed: ${err.message}`, colors.red);
+    log(`  Run manually: ${colors.cyan}${manualCmd}${colors.reset}\n`, colors.dim);
+    process.exit(1);
+  });
+
+  child.on('exit', (code) => {
+    if (code === 0) {
+      log(`\n  ${APP_NAME} updated to the latest version.`, colors.bold + colors.green);
+      log('  Run "minion" to start.\n', colors.dim);
+    } else {
+      log(`\n  Update failed (npm exited with code ${code}).`, colors.red);
+      log(`  Run manually: ${colors.cyan}${manualCmd}${colors.reset}\n`, colors.dim);
+    }
+    process.exit(code || 0);
+  });
+}
+
+async function autoUpdate() {
+  try {
+    const latest = await resolveLatestVersion();
+
+    if (!latest || compareVersions(latest, pkg.version) <= 0) {
+      return false;
+    }
+
+    const current = pkg.version;
+    const type = updateType(current, latest);
+    log(`\n  Updating minion: ${colors.dim}${current}${colors.reset} → ${colors.green}${latest}${colors.reset} ${colors.dim}(${type})${colors.reset}`);
+
+    const installResult = await installGlobalVersion(latest);
+
+    if (!installResult.ok) {
+      log(`  Update failed — continuing with v${current}`, colors.yellow);
+      if (installResult.stderr) {
+        const reason = installResult.stderr.split('\n').find(l => l.trim()) || '';
+        if (reason) log(`  ${colors.dim}${reason.trim()}${colors.reset}`);
+      }
+      log(`  Run manually: ${colors.cyan}${manualUpdateCommand()}${colors.reset}\n`);
+      return false;
+    }
+
+    log(`  Updated to v${latest}. Restarting...\n`, colors.green);
+
+    const child = spawn(process.argv[0], process.argv.slice(1), {
+      stdio: 'inherit',
+      env: { ...process.env, MINIONRY_SKIP_UPDATE_CHECK: '1' },
+    });
+
+    process.on('SIGINT', () => {});
+    process.on('SIGTERM', () => child.kill('SIGTERM'));
+
+    child.on('exit', (code, signal) => {
+      process.exit(signal ? 1 : (code || 0));
+    });
+    child.on('error', () => process.exit(1));
+
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isLoggedIn() {
+  const env = process.env.MINIONRY_ENV || 'production';
+  const credentialsFile = machineFile(env === 'dev' ? 'platformCredentialsDev' : 'platformCredentials');
+  if (!existsSync(credentialsFile)) {
+    return false;
+  }
+  try {
+    const creds = JSON.parse(readFileSync(credentialsFile, 'utf-8'));
+    return !!(creds.token && creds.userId && creds.email);
+  } catch {
+    return false;
+  }
+}
+
+async function ensureLoggedIn() {
+  if (isLoggedIn()) return;
+  log('\n  Not logged in — starting authentication...\n', colors.bold + colors.cyan);
+  try {
+    const { login } = await import('./commands/login.js');
+    await login(args, { inline: true });
+  } catch (err) {
+    log(`\n  Login failed: ${err.message}`, colors.red);
+    log('  Run "minion login" to try again.\n', colors.dim);
+    process.exit(1);
+  }
+}
+
+async function ensurePtySetup() {
+  const ptyAvailable = await isNodePtyAvailable();
+  if (ptyAvailable) return;
+  if (hasUserDismissedPtySetup()) return;
+  showPtyWarning();
+}
+
+async function startServer(envOverrides, { foreground = false } = {}) {
+  if (!foreground && !isLoggedIn() && !(process.stdin.isTTY && process.stdout.isTTY)) {
+    log('\n  Not logged in.', colors.red);
+    log('  Run "minion login" first, then retry "minion".\n', colors.dim);
+    process.exit(1);
+  }
+
+  await ensureLoggedIn();
+
+  await ensurePtySetup();
+
+  const script = resolveStartScript();
+  if (foreground) {
+    runNpmScript(script, [], envOverrides);
+  } else {
+    runNpmScriptDetached(script, [], envOverrides);
+  }
+}
+
+async function main() {
+  if (process.env.MINIONRY_SKIP_UPDATE_CHECK) {
+    delete process.env.MINIONRY_SKIP_UPDATE_CHECK;
+  } else {
+    const updated = await autoUpdate();
+    if (updated) return;
+  }
+
+  normalizeNodePtyTree(prebuiltPlatformDir());
+
+  const envOverrides = resolveLaunchEnv(args);
+
+  const subcommand = args.find(arg => !arg.startsWith('-') && !arg.startsWith('--'));
+
+  const commands = new Map([
+    ['login', async () => {
+      const { login } = await import('./commands/login.js');
+      const freshLogin = await login(args.slice(args.indexOf('login') + 1));
+      if (freshLogin) {
+        await runPostLoginSetup();
+        const envSuffix = launchFlagSuffix(process.env.MINIONRY_ENV);
+        log('');
+        log(`  Run "minion${envSuffix}" to start a machine.`, colors.cyan);
+        log('');
+      }
+    }],
+    ['logout', async () => {
+      const { logout } = await import('./commands/logout.js');
+      await logout(args.slice(args.indexOf('logout') + 1));
+    }],
+    ['whoami', async () => {
+      const { whoami } = await import('./commands/whoami.js');
+      await whoami(args.slice(args.indexOf('whoami') + 1));
+    }],
+    ['status', async () => {
+      const { status } = await import('./commands/status.js');
+      await status();
+    }],
+    ['fingerprint', async () => {
+      const { fingerprint } = await import('./commands/fingerprint.js');
+      await fingerprint(args.slice(args.indexOf('fingerprint') + 1));
+    }],
+    ['update', updateCli],
+    ['install', async () => {
+      const installArgs = args.slice(args.indexOf('install') + 1);
+      const target = installArgs.find((a) => !a.startsWith('-'));
+      if (target === 'terminal') {
+        await installTerminal();
+        return;
+      }
+      if (target === 'browser') {
+        const { browserInstall } = await import('./commands/browser-install.js');
+        await browserInstall(installArgs.slice(installArgs.indexOf('browser') + 1));
+        return;
+      }
+      log('\n  Usage: minion install <terminal|browser>', colors.dim);
+      log('         minion install browser [--uninstall] [--json] [--no-deps] [--check]\n', colors.dim);
+      process.exit(target ? 1 : 0);
+    }],
+    ['doctor', async () => {
+      const doctorArgs = args.slice(args.indexOf('doctor') + 1);
+      const target = doctorArgs.find((a) => !a.startsWith('-'));
+      if (target === undefined) {
+        await doctorTerminal();
+        await doctorBrowser();
+        return;
+      }
+      if (target === 'terminal') {
+        await doctorTerminal();
+        return;
+      }
+      if (target === 'browser') {
+        await doctorBrowser();
+        return;
+      }
+      log('\n  Usage: minion doctor [terminal|browser]\n', colors.dim);
+      process.exit(1);
+    }],
+    ['create', async () => {
+      const createArgs = args.slice(args.indexOf('create') + 1);
+      const target = createArgs.find((a) => !a.startsWith('-'));
+      if (target === 'sandbox') {
+        const { createSandbox } = await import('./commands/create-sandbox.js');
+        await createSandbox(createArgs.slice(createArgs.indexOf('sandbox') + 1));
+        return;
+      }
+      log('\n  Usage: minion create sandbox [name] [--rebuild] [--memory <GB>] [--disk <GB>]', colors.dim);
+      log('         Creates an isolated sandbox to make Spaces in. Asks for a name when', colors.dim);
+      log('         none is given (Enter takes the suggestion), and is uncapped unless', colors.dim);
+      log('         --memory / --disk ask for a limit.\n', colors.dim);
+      process.exit(target ? 1 : 0);
+    }],
+    ['rename', async () => {
+      const renameArgs = args.slice(args.indexOf('rename') + 1);
+      const target = renameArgs.find((a) => !a.startsWith('-'));
+      if (target === 'sandbox' || target === 'sandboxes') {
+        const { renameSandbox } = await import('./commands/sandboxes.js');
+        await renameSandbox(renameArgs.slice(renameArgs.indexOf(target) + 1));
+        return;
+      }
+      log('\n  Usage: minion rename sandbox <current-name> <new-name>\n', colors.dim);
+      process.exit(target ? 1 : 0);
+    }],
+    ['list', async () => {
+      const listArgs = args.slice(args.indexOf('list') + 1);
+      const target = listArgs.find((a) => !a.startsWith('-'));
+      if (target === 'sandboxes' || target === 'sandbox') {
+        const { listSandboxes } = await import('./commands/sandboxes.js');
+        await listSandboxes();
+        return;
+      }
+      if (target === 'minions' || target === 'minion') {
+        const { listMinions } = await import('./commands/minions.js');
+        listMinions();
+        return;
+      }
+      log('\n  Usage: minion list sandboxes', colors.dim);
+      log('         minion list minions\n', colors.dim);
+      process.exit(target ? 1 : 0);
+    }],
+    ['restart', async () => {
+      const restartArgs = args.slice(args.indexOf('restart') + 1);
+      const target = restartArgs.find((a) => !a.startsWith('-'));
+      if (target === 'sandbox' || target === 'sandboxes') {
+        const { restartSandbox } = await import('./commands/sandboxes.js');
+        await restartSandbox(restartArgs.slice(restartArgs.indexOf(target) + 1));
+        return;
+      }
+      log('\n  Usage: minion restart sandbox <name> [--uncap]\n', colors.dim);
+      process.exit(target ? 1 : 0);
+    }],
+    ['shutdown', async () => {
+      const { shutdownMinion } = await import('./commands/minions.js');
+      shutdownMinion(args.slice(args.indexOf('shutdown') + 1));
+    }],
+    ['setup-terminal', async () => {
+      log('\n  Note: "minion setup-terminal" is now "minion install terminal".', colors.dim);
+      await installTerminal();
+    }],
+    ['browser', async () => {
+      const browserArgs = args.slice(args.indexOf('browser') + 1);
+      const sub = browserArgs.find((a) => !a.startsWith('-'));
+      if (sub === 'install') {
+        if (!browserArgs.includes('--json')) {
+          log('\n  Note: "minion browser install" is now "minion install browser".', colors.dim);
+        }
+        const { browserInstall } = await import('./commands/browser-install.js');
+        await browserInstall(browserArgs.slice(browserArgs.indexOf('install') + 1));
+        return;
+      }
+      log('\n  Usage: minion install browser [--uninstall] [--json] [--no-deps] [--check]\n', colors.dim);
+      process.exit(sub ? 1 : 0);
+    }],
+  ]);
+
+  if (args.includes('--version') || args.includes('-V')) {
+    log(`minion v${pkg.version}`);
+    return;
+  }
+
+  if (args.includes('--help') || args.includes('-h')) {
+    showHelp();
+    return;
+  }
+
+  const handler = subcommand ? commands.get(subcommand) : undefined;
+  if (handler) {
+    await handler();
+    return;
+  }
+
+  const foreground = args.includes('--foreground');
+  await startServer(envOverrides, { foreground });
+}
+
+main();