9remote 0.1.48 → 0.1.49

package/cli/index.js

@@ -0,0 +1,848 @@
+#!/usr/bin/env node
+
+import inquirer from "inquirer";
+import chalk from "chalk";
+import qrcode from "qrcode-terminal";
+import { spawn, execSync } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+import fs from "fs";
+import os from "os";
+import dns from "dns";
+import https from "https";
+import { promisify } from "util";
+import { getConsistentMachineId } from "./utils/machineId.js";
+import { generateApiKeyWithMachine } from "./utils/apiKey.js";
+import { loadKey, saveKey, loadState, saveState, clearState } from "./utils/state.js";
+import { createTempKey } from "./utils/token.js";
+import { checkAndUpdate } from "./utils/updateChecker.js";
+import { ensureCloudflared, spawnCloudflared, killCloudflared, resetRestartCounter } from "./utils/cloudflared.js";
+
+// DNS resolver using Cloudflare — ensures tunnel domains resolve immediately
+const cfResolver = new dns.Resolver();
+cfResolver.setServers(["1.1.1.1", "1.0.0.1"]);
+const cfResolve4 = promisify(cfResolver.resolve4.bind(cfResolver));
+
+/** Fetch via IP with correct TLS SNI — bypasses system DNS */
+function fetchWithCfDns(url, timeoutMs = 5000) {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const parsed = new URL(url);
+      const [ip] = await cfResolve4(parsed.hostname);
+      const req = https.request({
+        hostname: ip,
+        port: 443,
+        path: parsed.pathname + parsed.search,
+        method: "GET",
+        headers: { host: parsed.hostname },
+        servername: parsed.hostname,
+        rejectUnauthorized: true
+      }, (res) => {
+        let body = "";
+        res.on("data", d => { body += d; });
+        res.on("end", () => resolve({ ok: res.statusCode >= 200 && res.statusCode < 300, status: res.statusCode, body }));
+      });
+      req.setTimeout(timeoutMs, () => { req.destroy(); reject(new Error("timeout")); });
+      req.on("error", reject);
+      req.end();
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
+
+// Parse --skip-update flag
+const skipUpdate = process.argv.includes("--skip-update");
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = path.resolve(__dirname, "../..");
+// When bundled (dist/cli.cjs), server.cjs is in same dist/ folder
+// When dev (server/cli/index.js), use server/index.js directly
+const STANDALONE_SERVER = path.resolve(__dirname, "../dist/server.cjs");
+const DEV_SERVER = path.resolve(__dirname, "../index.js");
+const WORKER_URL = "https://9remote.cc";
+const SERVER_PORT = 2208;
+const SHORT_ID_CHARS = "abcdefghijklmnpqrstuvwxyz23456789";
+const MAX_RESTART_ATTEMPTS = 10;
+const RESTART_WINDOW_MS = 60000; // 1 minute
+
+// Orange color from gitbook (#E68A6E)
+const ORANGE = chalk.rgb(230, 138, 110);
+const ORANGE_DIM = chalk.rgb(200, 120, 95);
+
+/**
+ * Get current version from package.json
+ */
+function getVersion() {
+  // When bundled, version is injected at build time
+  if (typeof __CLI_VERSION__ !== "undefined") {
+    return __CLI_VERSION__;
+  }
+  
+  // Dev mode: read from package.json
+  try {
+    const packagePath = path.join(__dirname, "..", "package.json");
+    const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+    return packageJson.version;
+  } catch {
+    return "unknown";
+  }
+}
+
+/**
+ * Show banner
+ */
+function showBanner() {
+  const version = getVersion();
+  const width = Math.min(44, process.stdout.columns || 44);
+  
+  console.log("");
+  console.log(ORANGE("╔" + "═".repeat(width - 2) + "╗"));
+  console.log(ORANGE("║") + " ".repeat(width - 2) + ORANGE("║"));
+  
+  const title = `🚀  9Remote v${version}`;
+  const titlePadding = Math.floor((width - 2 - title.length) / 2);
+  console.log(
+    ORANGE("║") + 
+    " ".repeat(titlePadding) + 
+    ORANGE.bold(title) + 
+    " ".repeat(width - 2 - titlePadding - title.length) + 
+    ORANGE("║")
+  );
+  
+  const subtitle = "Remote terminal access from anywhere";
+  const subtitlePadding = Math.floor((width - 2 - subtitle.length) / 2);
+  console.log(
+    ORANGE("║") + 
+    " ".repeat(subtitlePadding) + 
+    chalk.gray(subtitle) + 
+    " ".repeat(width - 2 - subtitlePadding - subtitle.length) + 
+    ORANGE("║")
+  );
+  
+  console.log(ORANGE("║") + " ".repeat(width - 2) + ORANGE("║"));
+  console.log(ORANGE("╚" + "═".repeat(width - 2) + "╝"));
+  console.log("");
+}
+
+/**
+ * Generate short random ID for tunnel subdomain
+ */
+function generateShortId() {
+  let result = "";
+  for (let i = 0; i < 6; i++) {
+    result += SHORT_ID_CHARS.charAt(Math.floor(Math.random() * SHORT_ID_CHARS.length));
+  }
+  return result;
+}
+
+/**
+ * Helper: Show QR code for connect URL
+ */
+function showQRCode(url, title = "📱 Scan QR to connect:") {
+  console.log(ORANGE(`\n${title}`));
+  qrcode.generate(url, {
+    small: true,
+    type: 'terminal',
+    margin: 0,
+  }, qr => {
+    const lines = qr.trim().split('\n');
+    console.log(lines.join('\n'));
+  });
+}
+
+/**
+ * Helper: Show connection info
+ */
+async function showConnectionInfo(selectedKey, tunnelUrl) {
+  const tempKeyData = await createTempKey(selectedKey, WORKER_URL);
+  
+  if (!tempKeyData) {
+    console.log(chalk.red("❌ Failed to create temp key"));
+    return;
+  }
+
+  const connectUrl = `${WORKER_URL}/login?k=${tempKeyData.tempKey}`;
+  const width = Math.min(44, process.stdout.columns || 55);
+
+  // Push ready state to UI
+  pushUiState({
+    step: 3,
+    tunnelUrl,
+    oneTimeKey: tempKeyData.tempKey,
+    qrUrl: connectUrl,
+  });
+
+  showQRCode(connectUrl);
+
+  console.log(chalk.gray(`\nQR will expire in 30 minutes (one-time use)\n`));
+  
+  console.log(ORANGE("═".repeat(width)));
+  
+  // App URL
+  const appLabel = "App URL";
+  const appValue = `${WORKER_URL}/login`;
+  console.log(chalk.white(appLabel.padEnd(14)) + chalk.gray(appValue));
+  
+  // One-Time Key
+  const keyLabel = "One-Time Key";
+  const keyValue = tempKeyData.tempKey;
+  console.log(chalk.white(keyLabel.padEnd(14)) + ORANGE.bold(keyValue));
+  
+  // Permanent Key
+  const permLabel = "Key";
+  const permValue = selectedKey;
+  console.log(chalk.white(permLabel.padEnd(14)) + chalk.gray(permValue));
+  
+  console.log(ORANGE("═".repeat(width)));
+}
+
+/**
+ * Kill process on specific port
+ */
+function killProcessOnPort(port) {
+  try {
+    if (process.platform === "win32") {
+      execSync(`for /f "tokens=5" %a in ('netstat -aon ^| findstr :${port}') do taskkill /F /PID %a`, { stdio: "ignore" });
+    } else {
+      const nullDevice = "/dev/null";
+      execSync(`lsof -ti:${port} | xargs kill -9 2>${nullDevice} || true`, { stdio: "ignore" });
+    }
+  } catch { }
+}
+
+/**
+ * Start server with auto-restart on crash
+ */
+function startServerWithRestart(onReady, onServerCrash) {
+  const restartTimes = [];
+  let currentProcess = null;
+  let isShuttingDown = false;
+  let isFirstStart = true;
+
+  const spawnServer = () => {
+    // Only kill port on first start, not on restart
+    if (isFirstStart) {
+      killProcessOnPort(SERVER_PORT);
+      isFirstStart = false;
+    } else {
+    }
+
+    // Use dev server if exists (development), otherwise use standalone (npm package)
+    const useDevServer = process.env.NODE_ENV === "development" && fs.existsSync(DEV_SERVER);
+    const serverPath = useDevServer ? DEV_SERVER : STANDALONE_SERVER;
+    
+    if (!fs.existsSync(serverPath)) {
+      console.error(`❌ Server not found: ${serverPath}`);
+      process.exit(1);
+    }
+    
+    currentProcess = spawn("node", [serverPath], {
+      cwd: path.dirname(serverPath),
+      stdio: ["ignore", "inherit", "inherit"],
+      detached: false,
+      env: { ...process.env, PORT: String(SERVER_PORT) }
+    });
+    
+
+    currentProcess.on("exit", (code, signal) => {
+      if (isShuttingDown) {
+        return;
+      }
+
+      // Check if it's a crash (non-zero exit code or unexpected signal)
+      if (code !== 0 || signal) {
+        console.log(chalk.red(`\n💥 Server crashed (code: ${code}, signal: ${signal})`));
+
+        // Check restart limit
+        const now = Date.now();
+        restartTimes.push(now);
+        
+        // Remove old restart times outside window
+        while (restartTimes.length > 0 && restartTimes[0] < now - RESTART_WINDOW_MS) {
+          restartTimes.shift();
+        }
+
+        if (restartTimes.length > MAX_RESTART_ATTEMPTS) {
+          console.log(chalk.red(`❌ Too many restarts (${MAX_RESTART_ATTEMPTS} in ${RESTART_WINDOW_MS / 1000}s). Giving up.`));
+          process.exit(1);
+        }
+
+        console.log(chalk.yellow(`🔄 Restarting server... (attempt ${restartTimes.length}/${MAX_RESTART_ATTEMPTS})`));
+        console.log(ORANGE_DIM("⚠️  [DEBUG] NOTE: Tunnel connection may be stale - will restart tunnel"));
+        
+        // ✅ Callback để restart cloudflared
+        if (onServerCrash) {
+          console.log(chalk.yellow("✅ Restarting tunnel connection..."));
+          onServerCrash();
+        }
+        
+        // Wait a bit before restart
+        setTimeout(() => {
+          spawnServer();
+        }, 1000);
+      } else {
+      }
+    });
+
+    currentProcess.on("error", (err) => {
+      console.log(chalk.red(`❌ Server error: ${err.message}`));
+    });
+
+    if (onReady) {
+      onReady(currentProcess);
+    }
+  };
+
+  spawnServer();
+
+  return {
+    getProcess: () => currentProcess,
+    shutdown: () => {
+      isShuttingDown = true;
+      if (currentProcess) {
+        currentProcess.kill();
+      }
+    }
+  };
+}
+
+/**
+ * Helper: Setup exit handler for server processes
+ */
+let exitHandlerRegistered = false;
+
+function setupExitHandler(serverManager, tunnelProcess, apiKey) {
+  if (exitHandlerRegistered) return;
+  exitHandlerRegistered = true;
+  
+  process.on("SIGINT", async () => {
+    console.log(chalk.yellow("\n\n🛑 Stopping server..."));
+    
+    serverManager.shutdown();
+    tunnelProcess.kill();
+    resetRestartCounter();
+    clearState();
+    
+    console.log(chalk.green("✅ Server stopped"));
+    process.exit(0);
+  });
+}
+
+/**
+ * Get first non-internal LAN IPv4 address
+ */
+function getLanIp() {
+  const interfaces = os.networkInterfaces();
+  for (const iface of Object.values(interfaces)) {
+    for (const addr of iface) {
+      if (addr.family === "IPv4" && !addr.internal) return addr.address;
+    }
+  }
+  return null;
+}
+
+/**
+ * Helper: Create Named Tunnel via Worker API
+ */
+async function createNamedTunnel(apiKey) {
+  const response = await fetch(`${WORKER_URL}/api/tunnel/create`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ apiKey })
+  });
+
+  if (!response.ok) {
+    const error = await response.json();
+    throw new Error(error.error || "Failed to create tunnel");
+  }
+
+  const data = await response.json();
+  return data;
+}
+
+/** Push UI state to server via HTTP */
+async function pushUiState(data) {
+  try {
+    await fetch(`http://localhost:${SERVER_PORT}/api/ui/state`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(data),
+    });
+  } catch { /* server may not be ready yet */ }
+}
+
+/**
+ * Helper: Start server and tunnel
+ */
+async function startServerAndTunnel(selectedKey) {
+  console.log(ORANGE("\n🚀 Starting server..."));
+  pushUiState({ step: 1 });
+
+  // Kill existing cloudflared process
+  try {
+    killCloudflared();
+    await new Promise(resolve => setTimeout(resolve, 1000));
+  } catch { }
+
+  // Reuse existing shortId or generate new one
+  const existingState = loadState();
+  const shortId = existingState?.shortId || generateShortId();
+
+  // Create session first
+  try {
+    const sessionResponse = await fetch(`${WORKER_URL}/api/session/create`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ apiKey: selectedKey, shortId })
+    });
+    
+    if (!sessionResponse.ok) {
+      const text = await sessionResponse.text();
+      console.log(chalk.red(`❌ Failed to create session: ${sessionResponse.status} ${sessionResponse.statusText}`));
+      console.log(chalk.yellow(`Response: ${text.substring(0, 200)}`));
+      return null;
+    }
+    
+    const sessionData = await sessionResponse.json();
+  } catch (error) {
+    console.log(chalk.red(`❌ Failed to create session: ${error.message}`));
+    return null;
+  }
+
+  // tunnelProcess declared here so the serverManager crash callback can reference it
+  let tunnelProcess = null;
+
+  // Skip spawning server if already running (e.g. nodemon in dev mode)
+  const alreadyRunning = await isServerRunning();
+
+  // Start server with auto-restart (skip if already running)
+  const serverManager = alreadyRunning
+    ? { getProcess: () => null, shutdown: () => {} }
+    : startServerWithRestart(null, async () => {
+    // Callback khi server crash - đợi server ready rồi gửi SIGHUP
+    
+    if (!tunnelProcess) {
+      return;
+    }
+    
+    // Wait for server to be ready
+    const maxWait = 60000; // 60s
+    const checkInterval = 1000; // 1s
+    const maxRetries = Math.floor(maxWait / checkInterval);
+    let serverReady = false;
+    
+    for (let i = 0; i < maxRetries; i++) {
+      try {
+        const response = await fetch(`http://localhost:${SERVER_PORT}/api/health`, {
+          method: "GET",
+          timeout: 2000
+        });
+        
+        if (response.ok) {
+          const data = await response.json();
+          if (data.status === "ok") {
+            serverReady = true;
+            console.log(chalk.green(`✅ Server ready after ${i + 1}s`));
+            break;
+          }
+        }
+      } catch (err) {
+        // Server not ready yet
+      }
+      
+      if (i % 5 === 0) {
+      }
+      
+      await new Promise(resolve => setTimeout(resolve, checkInterval));
+    }
+    
+    if (!serverReady) {
+      console.log(chalk.red("❌ Server not ready after 60s - skipping tunnel reconnect"));
+      return;
+    }
+    
+    // Server ready - send SIGHUP to cloudflared to reconnect
+    try {
+      process.kill(tunnelProcess.pid, "SIGHUP");
+      console.log(chalk.green("✅ SIGHUP sent - cloudflared should reconnect"));
+    } catch (err) {      
+      // Fallback: kill and restart
+      try {
+        tunnelProcess.kill();
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        tunnelProcess = await startTunnel(token);
+        console.log(chalk.green("✅ Tunnel restarted"));
+      } catch (restartErr) {
+        console.log(chalk.red(`❌ Failed to restart tunnel: ${restartErr.message}`));
+      }
+    }
+  });
+
+  // Wait for server to start (skip if already running)
+  if (!alreadyRunning) await new Promise((resolve) => setTimeout(resolve, 2000));
+
+  console.log(ORANGE("✅ Creating tunnel..."));
+  pushUiState({ step: 2 });
+
+  // Ensure cloudflared binary
+  try {
+    await ensureCloudflared();
+  } catch (error) {
+    console.log(chalk.red(`❌ Failed to install cloudflared: ${error.message}`));
+    serverManager.shutdown();
+    return null;
+  }
+
+  // Create Named Tunnel via Worker API
+  let tunnelData;
+  try {
+    tunnelData = await createNamedTunnel(selectedKey);
+    console.log(ORANGE(`✅ Tunnel ID: ${tunnelData.tunnelId}`));
+  } catch (error) {
+    console.log(chalk.red(`❌ Failed to create tunnel: ${error.message}`));
+    serverManager.shutdown();
+    return null;
+  }
+
+  const { token, hostname: tunnelUrl } = tunnelData;
+
+  // Spawn cloudflared with token and auto-restart callback
+  console.log(ORANGE("✅ Starting tunnel..."));
+  
+  const startTunnel = async (tunnelToken) => {
+    try {
+      tunnelProcess = await spawnCloudflared(tunnelToken, startTunnel);
+      return tunnelProcess;
+    } catch (error) {
+      console.log(chalk.red(`❌ Failed to start cloudflared: ${error.message}`));
+      return null;
+    }
+  };
+  
+  tunnelProcess = await startTunnel(token);
+  if (!tunnelProcess) {
+    serverManager.shutdown();
+    return null;
+  }
+
+  // Verify tunnel reachable via Cloudflare DNS + https.request (bypasses system DNS)
+  const spinners = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  let tunnelReady = false;
+  for (let i = 0; i < 30; i++) {
+    try {
+      const res = await fetchWithCfDns(`${tunnelUrl}/api/health`);
+      if (res.ok) { tunnelReady = true; break; }
+    } catch { }
+    process.stdout.write(`\r   Verifying tunnel ${spinners[i % spinners.length]} (${i * 2}s)`);
+    await new Promise(r => setTimeout(r, 2000));
+  }
+  process.stdout.write("\r" + " ".repeat(40) + "\r");
+
+  if (!tunnelReady) {
+    console.log(chalk.red("❌ Tunnel not reachable from outside"));
+    serverManager.shutdown();
+    tunnelProcess.kill();
+    return null;
+  }
+
+  console.log(ORANGE(`✅ Tunnel URL: ${tunnelUrl}`));
+  const lanIpLog = getLanIp();
+  if (lanIpLog) console.log(ORANGE(`✅ Local IP: ${lanIpLog}:${SERVER_PORT} (LAN direct available)`));
+  console.log(ORANGE(`✅ Connection established`));
+
+  // Update session with tunnelUrl + localIp (worker detects publicIp via CF-Connecting-IP)
+  const lanIp = lanIpLog;
+  try {
+    await fetch(`${WORKER_URL}/api/session/update`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        apiKey: selectedKey,
+        tunnelUrl,
+        localIp: lanIp ? `${lanIp}:${SERVER_PORT}` : null
+      })
+    });
+  } catch { }
+
+  // Save state (persist shortId for reuse on restart)
+  saveState({
+    apiKey: selectedKey,
+    shortId,
+    tunnelUrl,
+    serverPid: serverManager.getProcess()?.pid,
+    tunnelPid: tunnelProcess.pid
+  });
+
+  return { serverManager, tunnelProcess, tunnelUrl };
+}
+
+
+/**
+ * Show main menu
+ */
+async function mainMenu() {
+  console.clear();
+  showBanner();
+
+  const { action } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "action",
+      message: "Select action:",
+      choices: [
+        { name: "🚀 Start Server", value: "start" },
+        { name: "🔑 Manage Key", value: "key" },
+        { name: "❌ Exit", value: "exit" }
+      ]
+    }
+  ]);
+
+  switch (action) {
+    case "start":
+      await startServer();
+      break;
+    case "key":
+      await manageKey();
+      break;
+    case "exit":
+      console.log(chalk.gray("Goodbye!"));
+      process.exit(0);
+  }
+}
+
+/**
+ * Start server with single key
+ */
+async function startServer() {
+  const machineId = await getConsistentMachineId();
+  let keyData = loadKey();
+
+  // Auto create key if none exists
+  if (!keyData.key) {
+    console.log(chalk.yellow("\n⚠️  No key found. Creating default key..."));
+    const { key } = generateApiKeyWithMachine(machineId);
+    keyData = saveKey(machineId, key, "Default");
+    console.log(chalk.green("✅ Default key created!"));
+  }
+
+  const result = await startServerAndTunnel(keyData.key);
+  if (!result) {
+    await inquirer.prompt([{ type: "input", name: "c", message: "Press Enter to go back..." }]);
+    await mainMenu();
+    return;
+  }
+
+  const { serverManager, tunnelProcess, tunnelUrl } = result;
+
+  await showConnectionInfo(keyData.key, tunnelUrl);
+  setupExitHandler(serverManager, tunnelProcess, keyData.key);
+
+  // Keep process alive
+  await new Promise(() => { });
+}
+
+/**
+ * Manage single key menu
+ */
+async function manageKey() {
+  const machineId = await getConsistentMachineId();
+  let keyData = loadKey();
+
+  // Auto create key if none exists
+  if (!keyData.key) {
+    console.log(chalk.yellow("\n⚠️  No key found. Creating default key..."));
+    const { key } = generateApiKeyWithMachine(machineId);
+    keyData = saveKey(machineId, key, "Default");
+    console.log(chalk.green("✅ Default key created!"));
+  }
+
+  console.log(ORANGE("\n🔑 Manage Key"));
+  console.log(chalk.gray("━".repeat(30)));
+  console.log(chalk.white(`Key: ${keyData.key}`));
+  console.log(chalk.gray(`Created: ${keyData.createdAt}\n`));
+
+  const { action } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "action",
+      message: "Action:",
+      choices: [
+        { name: "🔐 Create One-Time Key", value: "oneTime" },
+        { name: "🔄 Regenerate Key", value: "regenerate" },
+        { name: chalk.gray("← Back"), value: "back" }
+      ]
+    }
+  ]);
+
+  if (action === "oneTime") {
+    console.log(chalk.gray("\nCreating one-time key..."));
+    const tempKeyData = await createTempKey(keyData.key, WORKER_URL);
+    
+    if (tempKeyData) {
+      const connectUrl = `${WORKER_URL}/login?k=${tempKeyData.tempKey}`;
+      const width = Math.min(50, process.stdout.columns || 50);
+      
+      showQRCode(connectUrl);
+      
+      console.log(chalk.gray(`\nQR will expire in 30 minutes (one-time use)\n`));
+      
+      console.log(ORANGE("═".repeat(width)));
+      
+      // App URL
+      const appLabel = "App URL";
+      const appValue = `${WORKER_URL}/login`;
+      console.log(chalk.white(appLabel.padEnd(16)) + chalk.gray(appValue));
+      
+      // One-Time Key
+      const keyLabel = "One-Time Key";
+      const keyValue = tempKeyData.tempKey;
+      console.log(chalk.white(keyLabel.padEnd(16)) + ORANGE.bold(keyValue));
+      
+      console.log(ORANGE("═".repeat(width)));
+    } else {
+      console.log(chalk.red("❌ Failed to create one-time key"));
+    }
+    await inquirer.prompt([{ type: "input", name: "continue", message: "Press Enter to continue..." }]);
+  }
+
+  if (action === "regenerate") {
+    const { confirm } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: chalk.yellow("⚠️  This will replace your current key. Continue?"),
+        default: false
+      }
+    ]);
+
+    if (confirm) {
+      const { key } = generateApiKeyWithMachine(machineId);
+      keyData = saveKey(machineId, key, keyData.name);
+      
+      console.log(chalk.green(`\n✅ Key regenerated: ${keyData.key}`));
+      await inquirer.prompt([{ type: "input", name: "continue", message: "Press Enter to continue..." }]);
+    }
+  }
+
+  await mainMenu();
+}
+
+/**
+ * Auto start dev server (--auto flag)
+ */
+async function autoStartDev() {
+  showBanner();
+
+  const machineId = await getConsistentMachineId();
+  let keyData = loadKey();
+
+  // Auto create key if none exists
+  if (!keyData.key) {
+    console.log(chalk.yellow("⚠️  No key found. Creating default key..."));
+    const { key } = generateApiKeyWithMachine(machineId);
+    keyData = saveKey(machineId, key, "Default");
+    console.log(chalk.green("✅ Default key created!"));
+  }
+
+  console.log(chalk.gray(`Using key: ${keyData.key.slice(0, 20)}... (${keyData.name})`));
+
+  const result = await startServerAndTunnel(keyData.key);
+  if (!result) {
+    process.exit(1);
+  }
+
+  const { serverManager, tunnelProcess, tunnelUrl } = result;
+
+  await showConnectionInfo(keyData.key, tunnelUrl);
+  setupExitHandler(serverManager, tunnelProcess, keyData.key);
+
+  // Push stats to UI every 5s
+  const startTime = Date.now();
+  setInterval(() => {
+    const uptime = Math.floor((Date.now() - startTime) / 1000);
+    const h = Math.floor(uptime / 3600), m = Math.floor((uptime % 3600) / 60), s = uptime % 60;
+    pushUiState({ uptime: `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}` });
+  }, 5000);
+
+  // Keep process alive
+  await new Promise(() => { });
+}
+
+
+/**
+ * Check if server is already running on SERVER_PORT
+ */
+async function isServerRunning() {
+  try {
+    const res = await fetch(`http://localhost:${SERVER_PORT}/api/health`);
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * UI mode: start server (if not running) + tunnel + open browser
+ * Same as "Start Server" in TUI but auto-opens browser
+ */
+async function startUiMode() {
+  showBanner();
+
+  const machineId = await getConsistentMachineId();
+  let keyData = loadKey();
+
+  if (!keyData.key) {
+    const { key } = generateApiKeyWithMachine(machineId);
+    keyData = saveKey(machineId, key, "Default");
+  }
+
+  const result = await startServerAndTunnel(keyData.key);
+  if (!result) process.exit(1);
+
+  const { serverManager, tunnelProcess, tunnelUrl } = result;
+
+  await showConnectionInfo(keyData.key, tunnelUrl);
+
+  // Open browser pointing to UI
+  const url = `http://localhost:${SERVER_PORT}`;
+  const openCmd = process.platform === "darwin" ? "open"
+    : process.platform === "win32" ? "start"
+    : "xdg-open";
+  spawn(openCmd, [url], { detached: true, stdio: "ignore" }).unref();
+  console.log(chalk.green(`\n🌐 UI ready at ${url}`));
+
+  setupExitHandler(serverManager, tunnelProcess, keyData.key);
+
+  // Push stats to UI every 5s
+  const startTime = Date.now();
+  setInterval(() => {
+    const uptime = Math.floor((Date.now() - startTime) / 1000);
+    const h = Math.floor(uptime / 3600), m = Math.floor((uptime % 3600) / 60), s = uptime % 60;
+    pushUiState({ uptime: `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}` });
+  }, 5000);
+
+  await new Promise(() => { });
+}
+
+// Start app
+async function start() {
+  // Check and auto-update (exits if update started)
+  const hasUpdate = await checkAndUpdate(skipUpdate);
+  if (hasUpdate) return;
+  
+  const command = process.argv[2];
+  
+  if (command === "ui") {
+    // UI mode: 9remote ui
+    await startUiMode();
+  } else if (command === "start" || process.argv.includes("--auto")) {
+    // Direct start: 9remote start
+    await autoStartDev();
+  } else {
+    // Menu mode: 9remote
+    await mainMenu();
+  }
+}
+
+start().catch(console.error);