@yina-npm/openrouterx 0.4.80 → 0.5.10

package/cli.js

@@ -1,519 +1,832 @@
 #!/usr/bin/env node
 
-const { spawn } = require("node:child_process");
-const fs = require("node:fs");
-const os = require("node:os");
-const path = require("node:path");
-const net = require("node:net");
+const { spawn, exec, execSync } = require("child_process");
+const path = require("path");
+const fs = require("fs");
+const https = require("https");
+const os = require("os");
+
+// Native spinner - no external dependency
+function createSpinner(text) {
+  const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  let i = 0;
+  let interval = null;
+  let currentText = text;
+  return {
+    start() {
+      if (process.stdout.isTTY) {
+        process.stdout.write(`\r${frames[0]} ${currentText}`);
+        interval = setInterval(() => {
+          process.stdout.write(`\r${frames[i++ % frames.length]} ${currentText}`);
+        }, 80);
+      }
+      return this;
+    },
+    stop() {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+      if (process.stdout.isTTY) {
+        process.stdout.write("\r\x1b[K");
+      }
+    },
+    succeed(msg) {
+      this.stop();
+      console.log(`✅ ${msg}`);
+    },
+    fail(msg) {
+      this.stop();
+      console.log(`❌ ${msg}`);
+    }
+  };
+}
 
 const pkg = require("./package.json");
+const { ensureSqliteRuntime, buildEnvWithRuntime } = require("./hooks/sqliteRuntime");
+const { ensureTrayRuntime } = require("./hooks/trayRuntime");
+const args = process.argv.slice(2);
 
-const APP_NAME = "openrouterX";
-const APP_DATA_DIR_NAME = "openrouterx";
-const DATA_DIR = process.platform === "win32"
-  ? path.join(process.env.APPDATA || os.homedir(), APP_DATA_DIR_NAME)
-  : path.join(os.homedir(), `.${APP_DATA_DIR_NAME}`);
-const PID_FILE = path.join(DATA_DIR, "server.pid");
-const META_FILE = path.join(DATA_DIR, "server.json");
-const LOG_FILE = path.join(DATA_DIR, "server.log");
-const MITM_PID_FILE = path.join(DATA_DIR, "mitm", ".mitm.pid");
-const DEFAULT_PORT = "20502";
-const DEFAULT_HOST = "0.0.0.0";
+// Self-heal SQLite runtime deps (sql.js + better-sqlite3) into ~/.9router/runtime
+// so the server can resolve them via NODE_PATH. Best-effort — sql.js is required,
+// better-sqlite3 is optional. Logs to stderr only on failure.
+try { ensureSqliteRuntime({ silent: true }); } catch {}
 
-function parseArgs(argv = process.argv.slice(2)) {
-  const options = {
-    command: "start",
-    port: undefined,
-    host: undefined,
-    foreground: false,
-    noBrowser: false,
-    skipUpdate: false,
-    help: false,
-    version: false,
-  };
+// Self-heal tray runtime (systray for macOS/Linux only). Windows skipped.
+try { ensureTrayRuntime({ silent: true }); } catch {}
 
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-
-    if (["start", "status", "stop", "restart", "open", "logs"].includes(arg)) {
-      options.command = arg;
-    } else if (arg === "--port" || arg === "-p") {
-      options.port = argv[index + 1];
-      index += 1;
-    } else if (arg.startsWith("--port=")) {
-      options.port = arg.slice("--port=".length);
-    } else if (arg === "--host" || arg === "-H") {
-      options.host = argv[index + 1];
-      index += 1;
-    } else if (arg.startsWith("--host=")) {
-      options.host = arg.slice("--host=".length);
-    } else if (arg === "--foreground" || arg === "--log" || arg === "-l") {
-      options.foreground = true;
-    } else if (arg === "--no-browser" || arg === "-n") {
-      options.noBrowser = true;
-    } else if (arg === "--skip-update") {
-      options.skipUpdate = true;
-    } else if (arg === "--help" || arg === "-h") {
-      options.help = true;
-    } else if (arg === "--version" || arg === "-v") {
-      options.version = true;
-    }
-  }
+// Configuration constants
+const APP_NAME = pkg.name; // Use from package.json
+const INSTALL_CMD_LATEST = `npm i -g ${APP_NAME}@latest --prefer-online`;
 
-  return options;
-}
+const DEFAULT_PORT = 20502;
+const DEFAULT_HOST = "0.0.0.0";
 
-function getPreferredPort(env = process.env, options = {}) {
-  const raw = options.port || env?.PORT;
-  if (raw === undefined || raw === null || String(raw).trim() === "") {
-    return DEFAULT_PORT;
+// First non-internal IPv4 — the address remote peers actually reach when bound to 0.0.0.0.
+function getLanIp() {
+  for (const ifaces of Object.values(os.networkInterfaces())) {
+    for (const i of ifaces || []) {
+      if (i.family === "IPv4" && !i.internal) return i.address;
+    }
   }
-  return String(raw);
+  return null;
 }
 
-function getPortConflictMessage(port) {
-  return [
-    `Port ${port} is already in use by an existing ${APP_NAME} instance.`,
-    `Use PORT=<new-port> ${APP_NAME} to run on a different port.`,
-  ].join("\n");
+// Local URL stays "localhost"; warn separately when bound to all interfaces (network-exposed).
+function getDisplayHost() {
+  return host === DEFAULT_HOST ? "localhost" : host;
 }
-
-function formatHelp() {
-  return `
-Usage: ${APP_NAME} [command] [options]
-
-Commands:
-  start               Start server in background (default)
-  status              Show background server status
-  stop                Stop background server
-  restart             Restart background server
-  open                Open dashboard in browser
-  logs                Print log file path
+const MAX_PORT_ATTEMPTS = 10;
+// Identifiers for killAllAppProcesses - keep the openrouterX publish command scoped.
+const PROCESS_IDENTIFIERS = [
+  "openrouterX",
+  "@yina-npm/openrouterx",
+  "9router",
+];
+
+// Parse arguments
+let port = DEFAULT_PORT;
+let host = DEFAULT_HOST;
+let noBrowser = false;
+let skipUpdate = false;
+let showLog = false;
+let trayMode = false;
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--port" || args[i] === "-p") {
+    port = parseInt(args[i + 1], 10) || DEFAULT_PORT;
+    i++;
+  } else if (args[i] === "--host" || args[i] === "-H") {
+    host = args[i + 1] || DEFAULT_HOST;
+    i++;
+  } else if (args[i] === "--no-browser" || args[i] === "-n") {
+    noBrowser = true;
+  } else if (args[i] === "--log" || args[i] === "-l") {
+    showLog = true;
+  } else if (args[i] === "--skip-update") {
+    skipUpdate = true;
+  } else if (args[i] === "--tray" || args[i] === "-t") {
+    trayMode = true;
+    process.env.TRAY_MODE = "1";
+  } else if (args[i] === "--help" || args[i] === "-h") {
+    console.log(`
+Usage: ${APP_NAME} [options]
 
 Options:
   -p, --port <port>   Port to run the server (default: ${DEFAULT_PORT})
   -H, --host <host>   Host to bind (default: ${DEFAULT_HOST})
-  -n, --no-browser    Do not open browser automatically
-  -l, --log           Show server logs in foreground
-  --foreground        Run in foreground
+  -n, --no-browser    Don't open browser automatically
+  -l, --log           Show server logs (default: hidden)
+  -t, --tray          Run in system tray mode (background)
   --skip-update       Skip auto-update check
   -h, --help          Show this help message
   -v, --version       Show version
-`;
-}
-
-function formatChooserBanner(serverUrl) {
-  return [
-    "========================================",
-    `  ${APP_NAME}`,
-    `  Server: ${serverUrl}`,
-    "========================================",
-  ].join("\n");
+`);
+    process.exit(0);
+  } else if (args[i] === "--version" || args[i] === "-v") {
+    console.log(pkg.version);
+    process.exit(0);
+  }
 }
 
-function getChooserOptions() {
-  return ["Web UI", "Terminal UI", "Hide to Tray", "Exit"];
+// Auto-relaunch after update: detached process has no TTY → fallback to tray
+if (skipUpdate && !trayMode && !process.stdin.isTTY) {
+  trayMode = true;
+  process.env.TRAY_MODE = "1";
 }
 
-function ensureDataDir() {
-  fs.mkdirSync(DATA_DIR, { recursive: true });
-}
+// Always use Node.js runtime with absolute path
+const RUNTIME = process.execPath;
 
-function readMeta() {
-  try {
-    return JSON.parse(fs.readFileSync(META_FILE, "utf8"));
-  } catch {
-    return null;
+// Compare semver versions: returns 1 if a > b, -1 if a < b, 0 if equal
+function compareVersions(a, b) {
+  const partsA = a.split(".").map(Number);
+  const partsB = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if (partsA[i] > partsB[i]) return 1;
+    if (partsA[i] < partsB[i]) return -1;
   }
+  return 0;
 }
 
-function writeMeta(meta) {
-  ensureDataDir();
-  fs.writeFileSync(META_FILE, `${JSON.stringify(meta, null, 2)}\n`);
+// Get app data dir (matches app/src/lib/dataDir.js convention)
+function getAppDataDir() {
+  return process.platform === "win32"
+    ? path.join(process.env.APPDATA || "", "9router")
+    : path.join(os.homedir(), ".9router");
 }
 
-function writePid(pid) {
-  ensureDataDir();
-  fs.writeFileSync(PID_FILE, `${pid}\n`);
+// Kill PID from file (best-effort, removes file after)
+function killByPidFile(pidFile) {
+  try {
+    if (!fs.existsSync(pidFile)) return;
+    const pid = parseInt(fs.readFileSync(pidFile, "utf8").trim(), 10);
+    if (!pid) return;
+    try {
+      if (process.platform === "win32") {
+        execSync(`taskkill /F /T /PID ${pid}`, { stdio: "ignore", windowsHide: true, timeout: 3000 });
+      } else {
+        process.kill(pid, "SIGKILL");
+      }
+    } catch { }
+    try { fs.unlinkSync(pidFile); } catch { }
+  } catch { }
 }
 
-function readPid() {
-  try {
-    const pid = Number(fs.readFileSync(PID_FILE, "utf8").trim());
-    return Number.isFinite(pid) && pid > 0 ? pid : null;
-  } catch {
-    return null;
-  }
+// Kill tunnel processes (cloudflared/tailscale) by their PID files
+function killTunnelByPidFile() {
+  const tunnelDir = path.join(getAppDataDir(), "tunnel");
+  killByPidFile(path.join(tunnelDir, "cloudflared.pid"));
+  killByPidFile(path.join(tunnelDir, "tailscale.pid"));
 }
 
-function readPidFile(filePath) {
+// Kill cloudflared whose --url targets this app's port (covers stale PID file case)
+function killCloudflaredByAppPort(appPort) {
+  if (!appPort) return [];
+  const portMatchers = [`localhost:${appPort}`, `127.0.0.1:${appPort}`];
+  const pids = [];
   try {
-    const pid = Number(fs.readFileSync(filePath, "utf8").trim());
-    return Number.isFinite(pid) && pid > 0 ? pid : null;
-  } catch {
-    return null;
-  }
+    if (process.platform === "win32") {
+      const psCmd = `powershell -NonInteractive -WindowStyle Hidden -Command "Get-WmiObject Win32_Process -Filter 'Name=\\"cloudflared.exe\\"' | Select-Object ProcessId,CommandLine | ConvertTo-Csv -NoTypeInformation"`;
+      const output = execSync(psCmd, { encoding: "utf8", windowsHide: true, timeout: 5000 });
+      const lines = output.split("\n").slice(1).filter(l => l.trim());
+      lines.forEach(line => {
+        if (portMatchers.some(m => line.includes(m))) {
+          const match = line.match(/^"(\d+)"/);
+          if (match && match[1]) pids.push(match[1]);
+        }
+      });
+    } else {
+      const output = execSync("ps -eo pid,command 2>/dev/null", { encoding: "utf8", timeout: 5000 });
+      output.split("\n").forEach(line => {
+        if (line.includes("cloudflared") && portMatchers.some(m => line.includes(m))) {
+          const parts = line.trim().split(/\s+/);
+          const pid = parts[0];
+          if (pid && !isNaN(pid)) pids.push(pid);
+        }
+      });
+    }
+  } catch { }
+  return pids;
 }
 
-function removeRuntimeFiles() {
-  fs.rmSync(PID_FILE, { force: true });
-  fs.rmSync(META_FILE, { force: true });
-  fs.rmSync(MITM_PID_FILE, { force: true });
+// Kill all 9router processes
+function killAllAppProcesses(appPort) {
+  return new Promise((resolve) => {
+    try {
+      // Kill MIT first (privileged process, needs special handling)
+      killProxyByPidFile();
+      // Kill cloudflared/tailscale by PID file (precise, only this app's tunnel)
+      killTunnelByPidFile();
+
+      const platform = process.platform;
+      let pids = [];
+
+      // Catch stale PID files: kill cloudflared bound to this app's port
+      pids.push(...killCloudflaredByAppPort(appPort));
+
+      if (platform === "win32") {
+        // Windows: use WMI to get full CommandLine (tasklist /V doesn't include it)
+        try {
+          const psCmd = `powershell -NonInteractive -WindowStyle Hidden -Command "Get-WmiObject Win32_Process -Filter 'Name=\\"node.exe\\"' | Select-Object ProcessId,CommandLine | ConvertTo-Csv -NoTypeInformation"`;
+          const output = execSync(psCmd, {
+            encoding: "utf8",
+            windowsHide: true,
+            timeout: 5000
+          });
+          const lines = output.split("\n").slice(1).filter(l => l.trim());
+          lines.forEach(line => {
+            // Whitelist: real node process running 9router/cli.js, or next-server.
+            // Avoids killing editors/grep/strace/cursor that just have "9router" in cmdline.
+            const cmd = line.toLowerCase();
+            const isAppProcess =
+              (cmd.includes("node") && cmd.includes("9router") && (cmd.includes("cli.js") || cmd.includes("\\9router") || cmd.includes("/9router")))
+              || cmd.includes("next-server");
+            if (isAppProcess) {
+              const match = line.match(/^"(\d+)"/);
+              if (match && match[1] && match[1] !== process.pid.toString()) {
+                pids.push(match[1]);
+              }
+            }
+          });
+        } catch (e) {
+          // No processes found or error - continue
+        }
+      } else {
+        // macOS/Linux: use ps to find all matching processes
+        try {
+          const output = execSync('ps aux 2>/dev/null', {
+            encoding: 'utf8',
+            timeout: 5000
+          });
+          const lines = output.split('\n');
+
+          lines.forEach(line => {
+            // Whitelist: real node process running 9router/cli.js, or next-server.
+            // Avoids killing grep/strace/editors/cursor that incidentally match "9router".
+            const cmd = line.toLowerCase();
+            const isAppProcess =
+              (cmd.includes("node") && cmd.includes("9router") && (cmd.includes("cli.js") || cmd.includes("/9router")))
+              || cmd.includes("next-server");
+            if (isAppProcess) {
+              const parts = line.trim().split(/\s+/);
+              const pid = parts[1];
+              if (pid && !isNaN(pid) && pid !== process.pid.toString()) {
+                pids.push(pid);
+              }
+            }
+          });
+        } catch (e) {
+          // No processes found or error - continue
+        }
+      }
+
+      // Kill all found processes
+      if (pids.length > 0) {
+        pids.forEach(pid => {
+          try {
+            if (platform === "win32") {
+              execSync(`taskkill /F /PID ${pid} 2>nul`, { stdio: 'ignore', shell: true, windowsHide: true, timeout: 3000 });
+            } else {
+              execSync(`kill -9 ${pid} 2>/dev/null`, { stdio: 'ignore', timeout: 3000 });
+            }
+          } catch (err) {
+            // Process already dead or can't kill - continue
+          }
+        });
+
+        // Wait for processes to fully terminate
+        setTimeout(() => resolve(), 1000);
+      } else {
+        resolve();
+      }
+    } catch (err) {
+      // Silent fail - continue anyway
+      resolve();
+    }
+  });
 }
 
-function isProcessRunning(pid) {
-  if (!pid) {
-    return false;
-  }
+// Sleep helper using SharedArrayBuffer wait (sync, no busy-loop)
+function sleepSync(ms) {
+  try { Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms); } catch { /* ignore */ }
+}
 
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
+// Wait until process dies or timeout reached
+function waitForExit(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    try { process.kill(pid, 0); } catch { return true; }
+    sleepSync(100);
   }
+  return false;
 }
 
-function getUnixProcessTable() {
-  if (process.platform === "win32") return [];
+// Kill MIT server by PID file (runs privileged, needs special handling)
+// Sends SIGTERM first so MIT can clean up host entries before dying.
+function killProxyByPidFile() {
   try {
-    const output = require("node:child_process").execFileSync(
-      "ps",
-      ["-axo", "pid=,ppid=,command="],
-      { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }
-    );
-    return output.split("\n").map((line) => {
-      const match = line.trim().match(/^(\d+)\s+(\d+)\s+(.*)$/);
-      if (!match) return null;
-      return { pid: Number(match[1]), ppid: Number(match[2]), command: match[3] || "" };
-    }).filter(Boolean);
-  } catch {
-    return [];
-  }
+    const pidFile = path.join(getAppDataDir(), "mitm", ".mitm.pid");
+    if (!fs.existsSync(pidFile)) return;
+    const pid = parseInt(fs.readFileSync(pidFile, "utf8").trim(), 10);
+    if (!pid) return;
+
+    if (process.platform === "win32") {
+      // Graceful first (lets server cleanup hosts), then force
+      try { execSync(`taskkill /T /PID ${pid}`, { stdio: "ignore", windowsHide: true, timeout: 2000 }); } catch { }
+      if (!waitForExit(pid, 1500)) {
+        try { execSync(`taskkill /F /T /PID ${pid}`, { stdio: "ignore", windowsHide: true, timeout: 3000 }); } catch { }
+      }
+      // Last-resort: PowerShell Stop-Process (sometimes succeeds where taskkill fails on admin processes)
+      if (!waitForExit(pid, 500)) {
+        try { execSync(`powershell -NonInteractive -WindowStyle Hidden -Command "Stop-Process -Id ${pid} -Force"`, { stdio: "ignore", windowsHide: true, timeout: 3000 }); } catch { }
+      }
+    } else {
+      // SIGTERM via cached sudo token first
+      try { execSync(`sudo -n kill -TERM ${pid} 2>/dev/null`, { stdio: "ignore", timeout: 2000 }); }
+      catch { try { process.kill(pid, "SIGTERM"); } catch { } }
+      if (!waitForExit(pid, 1500)) {
+        try { execSync(`sudo -n kill -9 ${pid} 2>/dev/null`, { stdio: "ignore", timeout: 2000 }); }
+        catch { try { process.kill(pid, "SIGKILL"); } catch { } }
+      }
+    }
+    try { fs.unlinkSync(pidFile); } catch { }
+  } catch { }
 }
 
-function getDescendantPids(rootPid, table = getUnixProcessTable()) {
-  const root = Number(rootPid);
-  if (!Number.isFinite(root) || root <= 0) return [];
-  const childrenByParent = new Map();
-  for (const proc of table) {
-    const list = childrenByParent.get(proc.ppid) || [];
-    list.push(proc.pid);
-    childrenByParent.set(proc.ppid, list);
-  }
+// Kill any process on specific port
+function killProcessOnPort(port) {
+  return new Promise((resolve) => {
+    try {
+      const platform = process.platform;
+      let pid;
+
+      if (platform === "win32") {
+        try {
+          const output = execSync(`netstat -ano | findstr :${port}`, {
+            encoding: 'utf8',
+            shell: true,
+            windowsHide: true,
+            timeout: 5000
+          }).trim();
+          const lines = output.split('\n').filter(l => l.includes('LISTENING'));
+          if (lines.length > 0) {
+            pid = lines[0].trim().split(/\s+/).pop();
+            execSync(`taskkill /F /PID ${pid} 2>nul`, { stdio: 'ignore', shell: true, windowsHide: true, timeout: 3000 });
+          }
+        } catch (e) {
+          // Port is free or error
+        }
+      } else {
+        // macOS/Linux
+        try {
+          const pidOutput = execSync(`lsof -ti:${port}`, {
+            encoding: 'utf8',
+            stdio: ['pipe', 'pipe', 'ignore']
+          }).trim();
+          if (pidOutput) {
+            pid = pidOutput.split('\n')[0];
+            execSync(`kill -9 ${pid} 2>/dev/null`, { stdio: 'ignore', timeout: 3000 });
+          }
+        } catch (e) {
+          // Port is free or error
+        }
+      }
 
-  const descendants = [];
-  const stack = [...(childrenByParent.get(root) || [])];
-  while (stack.length > 0) {
-    const pid = stack.pop();
-    descendants.push(pid);
-    stack.push(...(childrenByParent.get(pid) || []));
-  }
-  return descendants;
+      // Wait for port to be released
+      setTimeout(() => resolve(), 500);
+    } catch (err) {
+      // Silent fail - continue anyway
+      resolve();
+    }
+  });
 }
 
-function killPid(pid, signal = "SIGTERM") {
-  const target = Number(pid);
-  if (!Number.isFinite(target) || target <= 0 || target === process.pid) return false;
 
-  if (process.platform === "win32") {
-    try {
-      require("node:child_process").execFileSync("taskkill", ["/F", "/T", "/PID", String(target)], {
-        stdio: "ignore",
-        windowsHide: true,
-      });
-      return true;
-    } catch {
-      return false;
-    }
+// Detect if running in restricted environment (Codespaces, Docker)
+function isRestrictedEnvironment() {
+  // Check for Codespaces
+  if (process.env.CODESPACES === "true" || process.env.GITHUB_CODESPACES_PORT_FORWARDING_DOMAIN) {
+    return "GitHub Codespaces";
   }
 
-  try {
-    process.kill(target, signal);
-    return true;
-  } catch (error) {
-    if (error?.code !== "EPERM") return false;
-    try {
-      require("node:child_process").execFileSync("sudo", ["-n", "kill", signal === "SIGKILL" ? "-9" : "-TERM", String(target)], {
-        stdio: "ignore",
-      });
-      return true;
-    } catch {
-      return false;
-    }
+  // Check for Docker
+  if (fs.existsSync("/.dockerenv") || (fs.existsSync("/proc/1/cgroup") && fs.readFileSync("/proc/1/cgroup", "utf8").includes("docker"))) {
+    return "Docker";
   }
+
+  return null;
 }
 
-function killProcessTree(pid) {
-  const root = Number(pid);
-  if (!Number.isFinite(root) || root <= 0 || root === process.pid) return false;
+// Check if new version available, return latest version or null
+function checkForUpdate() {
+  return new Promise((resolve) => {
+    if (skipUpdate) {
+      resolve(null);
+      return;
+    }
 
-  if (process.platform === "win32") {
-    return killPid(root);
-  }
+    const spinner = createSpinner("Checking for updates...").start();
+    let resolved = false;
 
-  const table = getUnixProcessTable();
-  const targets = [...getDescendantPids(root, table).reverse(), root];
-  let killedAny = false;
-  for (const target of targets) {
-    killedAny = killPid(target, "SIGTERM") || killedAny;
-  }
+    const safetyTimeout = setTimeout(() => {
+      if (!resolved) {
+        resolved = true;
+        spinner.stop();
+        resolve(null);
+      }
+    }, 8000);
+
+    const done = (version) => {
+      if (resolved) return;
+      resolved = true;
+      clearTimeout(safetyTimeout);
+      spinner.stop();
+      resolve(version);
+    };
+
+    const req = https.get(`https://registry.npmjs.org/${pkg.name}/latest`, { timeout: 3000 }, (res) => {
+      let data = "";
+      res.on("data", chunk => data += chunk);
+      res.on("end", () => {
+        try {
+          const latest = JSON.parse(data);
+          if (latest.version && compareVersions(latest.version, pkg.version) > 0) {
+            done(latest.version);
+          } else {
+            done(null);
+          }
+        } catch (e) {
+          done(null);
+        }
+      });
+    });
+
+    req.on("error", () => done(null));
+    req.on("timeout", () => { req.destroy(); done(null); });
+  });
+}
 
-  const deadline = Date.now() + 1500;
-  while (Date.now() < deadline && targets.some((target) => isProcessRunning(target))) {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 100);
+// Open browser
+function openBrowser(url) {
+  const platform = process.platform;
+  let cmd;
+
+  if (platform === "darwin") {
+    cmd = `open "${url}"`;
+  } else if (platform === "win32") {
+    cmd = `start "" "${url}"`;
+  } else {
+    cmd = `xdg-open "${url}"`;
   }
 
-  for (const target of targets) {
-    if (isProcessRunning(target)) {
-      killedAny = killPid(target, "SIGKILL") || killedAny;
+  exec(cmd, { windowsHide: true }, (err) => {
+    if (err) {
+      console.log(`Open browser manually: ${url}`);
     }
-  }
-  return killedAny;
+  });
 }
 
-function collectOpenrouterXPids() {
-  if (process.platform === "win32") return [];
-  return getUnixProcessTable()
-    .filter((proc) => proc.pid !== process.pid)
-    .filter((proc) => {
-      const command = proc.command.toLowerCase();
-      const isRuntimeProcess = command.includes("node")
-        || command.includes("sudo");
-      const isOpenrouterXPackage = command.includes("openrouterx")
-        || command.includes("@yina-npm/openrouterx");
-      const isMitmServer = command.includes("mitm/server.js");
-      return isRuntimeProcess && (isOpenrouterXPackage || isMitmServer);
-    })
-    .map((proc) => proc.pid);
+// Find standalone server (bundled in bin/app for published package).
+// Prefer custom-server.js (injects real socket IP) when present.
+const standaloneDir = path.join(__dirname, "app");
+const customServerPath = path.join(standaloneDir, "custom-server.js");
+const serverPath = fs.existsSync(customServerPath)
+  ? customServerPath
+  : path.join(standaloneDir, "server.js");
+
+if (!fs.existsSync(serverPath)) {
+  console.error("Error: Standalone build not found.");
+  console.error("Please run 'npm run build:cli' first.");
+  process.exit(1);
 }
 
-function stopRelatedProcesses() {
-  let stoppedAny = false;
-  const mitmPid = readPidFile(MITM_PID_FILE);
-  if (mitmPid && isProcessRunning(mitmPid)) {
-    stoppedAny = killProcessTree(mitmPid) || stoppedAny;
-  }
+// Check for updates FIRST, then start server
+checkForUpdate().then((latestVersion) => {
+  killAllAppProcesses(port).then(() => {
+    return killProcessOnPort(port);
+  }).then(() => {
+    startServer(latestVersion);
+  });
+});
 
-  const serverPid = readPid();
-  if (serverPid && isProcessRunning(serverPid)) {
-    stoppedAny = killProcessTree(serverPid) || stoppedAny;
-  }
+// Show interface selection menu
+async function showInterfaceMenu(latestVersion) {
+  const { selectMenu } = require("./src/cli/utils/input");
+  const { clearScreen } = require("./src/cli/utils/display");
+  const { getEndpoint } = require("./src/cli/utils/endpoint");
 
-  for (const pid of collectOpenrouterXPids()) {
-    if (pid !== process.pid && isProcessRunning(pid)) {
-      stoppedAny = killProcessTree(pid) || stoppedAny;
-    }
+  clearScreen();
+
+  const displayHost = getDisplayHost();
+
+  // Detect tunnel/local mode for server URL display
+  let serverUrl;
+  try {
+    const { endpoint, tunnelEnabled } = await getEndpoint(port);
+    serverUrl = tunnelEnabled ? endpoint.replace(/\/v1$/, "") : `http://${displayHost}:${port}`;
+  } catch (e) {
+    serverUrl = `http://${displayHost}:${port}`;
   }
-  return stoppedAny;
-}
 
-function openBrowser(url) {
-  const command = process.platform === "darwin"
-    ? "open"
-    : process.platform === "win32"
-      ? "cmd"
-      : "xdg-open";
-  const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
-  spawn(command, args, { detached: true, stdio: "ignore" }).unref();
-}
+  const subtitle = `🚀 Server: \x1b[32m${serverUrl}\x1b[0m`;
 
-function printStatus() {
-  const pid = readPid();
-  const meta = readMeta();
+  const menuItems = [];
 
-  if (isProcessRunning(pid)) {
-    console.log(`${APP_NAME} is running`);
-    console.log(`PID: ${pid}`);
-    console.log(`URL: ${meta?.baseUrl || `http://localhost:${DEFAULT_PORT}`}`);
-    console.log(`Log: ${LOG_FILE}`);
-    return true;
+  if (latestVersion) {
+    menuItems.push({ label: `Update to v${latestVersion} (current: v${pkg.version})`, icon: "⬆" });
   }
 
-  removeRuntimeFiles();
-  console.log(`${APP_NAME} is not running`);
-  return false;
-}
+  menuItems.push(
+    { label: "Web UI (Open in Browser)", icon: "🌐" },
+    { label: "Terminal UI (Interactive CLI)", icon: "💻" },
+    { label: "Hide to Tray (Background)", icon: "🔔" },
+    { label: "Exit", icon: "🚪" }
+  );
 
-function stopServer() {
-  const stoppedAny = stopRelatedProcesses();
-  removeRuntimeFiles();
-  console.log(stoppedAny ? `${APP_NAME} stopped` : `${APP_NAME} is not running`);
-  return stoppedAny;
-}
+  const selected = await selectMenu(`Choose Interface (v${pkg.version})`, menuItems, 0, subtitle);
 
-function createLogFileDescriptors() {
-  ensureDataDir();
-  fs.appendFileSync(LOG_FILE, `\n[${new Date().toISOString()}] Starting ${APP_NAME}\n`);
-  const out = fs.openSync(LOG_FILE, "a");
-  const err = fs.openSync(LOG_FILE, "a");
-  return ["ignore", out, err];
-}
+  const offset = latestVersion ? 1 : 0;
 
-function closeLogFileDescriptors(stdio) {
-  for (const fd of stdio.slice(1)) {
-    try {
-      fs.closeSync(fd);
-    } catch {}
-  }
+  if (latestVersion && selected === 0) return "update";
+  if (selected === offset) return "web";
+  if (selected === offset + 1) return "terminal";
+  if (selected === offset + 2) return "hide";
+  return "exit";
 }
 
-function checkPortAvailable(port, host) {
-  return new Promise((resolve) => {
-    const server = net.createServer();
+const MAX_RESTARTS = 2;
+const RESTART_RESET_MS = 30000; // Reset counter if alive > 30s
 
-    server.once("error", (err) => {
-      if (err && err.code === "EADDRINUSE") {
-        resolve(false);
-        return;
+function startServer(latestVersion) {
+  const displayHost = getDisplayHost();
+  const url = `http://${displayHost}:${port}/dashboard`;
+  // Surface real network exposure when bound to all interfaces (default 0.0.0.0).
+  if (host === DEFAULT_HOST) {
+    const lanIp = getLanIp();
+    if (lanIp) console.log(`\x1b[33m⚠ Network-exposed: reachable at http://${lanIp}:${port} (bound 0.0.0.0). Use --host 127.0.0.1 for local-only.\x1b[0m`);
+  }
+
+  let restartCount = 0;
+  let serverStartTime = Date.now();
+
+  const CRASH_LOG_LINES = 50;
+  let crashLog = [];
+
+  function spawnServer() {
+    serverStartTime = Date.now();
+    crashLog = [];
+    const child = spawn(RUNTIME, ["--max-old-space-size=6144", serverPath], {
+      cwd: standaloneDir,
+      stdio: showLog ? "inherit" : ["ignore", "ignore", "pipe"],
+      detached: true,
+      windowsHide: true,
+      env: {
+        ...buildEnvWithRuntime(process.env),
+        PORT: port.toString(),
+        HOSTNAME: host
       }
-      resolve(true);
     });
+    if (!showLog && child.stderr) {
+      child.stderr.on("data", (data) => {
+        const lines = data.toString().split("\n").filter(Boolean);
+        crashLog.push(...lines);
+        if (crashLog.length > CRASH_LOG_LINES) crashLog = crashLog.slice(-CRASH_LOG_LINES);
+      });
+    }
+    return child;
+  }
 
-    server.once("listening", () => {
-      server.close(() => resolve(true));
-    });
+  let server = spawnServer();
 
-    server.listen(Number(port), host);
-  });
-}
+  // Cleanup function - force kill server process
+  let isCleaningUp = false;
+  function cleanup() {
+    if (isCleaningUp) return;
+    isCleaningUp = true;
+    try {
+      // Kill tray if running
+      try {
+        const { killTray } = require("./src/cli/tray/tray");
+        killTray();
+      } catch (e) { }
+      // Kill MIT server (privileged process) via PID file
+      killProxyByPidFile();
+      // Kill cloudflared/tailscale via PID file (only this app's tunnel)
+      killTunnelByPidFile();
+      // Kill server process directly
+      if (server.pid) {
+        process.kill(server.pid, "SIGKILL");
+      }
+      // Also try to kill process group
+      process.kill(-server.pid, "SIGKILL");
+    } catch (e) { }
+  }
 
-function printChooser(serverUrl) {
-  console.log(formatChooserBanner(serverUrl));
-  getChooserOptions().forEach((option, index) => {
-    const marker = index === 0 ? "★" : "☆";
-    console.log(` ${marker} ${option}`);
+  // Suppress all errors during shutdown (systray lib throws JSON parse errors)
+  let isShuttingDown = false;
+  process.on("uncaughtException", (err) => {
+    if (isShuttingDown) return;
+    console.error("Error:", err.message);
   });
-}
 
-async function runCli() {
-  const options = parseArgs();
-
-  if (options.help) {
-    console.log(formatHelp());
-    process.exit(0);
-    return;
-  }
+  // Handle all exit scenarios
+  process.on("SIGINT", () => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    console.log("\nExiting...");
+    cleanup();
+    setTimeout(() => process.exit(0), 100);
+  });
+  process.on("SIGTERM", () => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    cleanup();
+    setTimeout(() => process.exit(0), 100);
+  });
+  process.on("SIGHUP", () => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    cleanup();
+    setTimeout(() => process.exit(0), 100);
+  });
 
-  if (options.version) {
-    console.log(pkg.version);
-    process.exit(0);
-    return;
-  }
+  // Initialize tray icon (runs alongside TUI)
+  const initTrayIcon = () => {
+    try {
+      const { initTray } = require("./src/cli/tray/tray");
+      initTray({
+        port,
+        onQuit: () => {
+          isShuttingDown = true;
+          console.log("\n👋 Shutting down from tray...");
+          cleanup();
+          setTimeout(() => process.exit(0), 100);
+        },
+        onOpenDashboard: () => openBrowser(url)
+      });
+    } catch (err) {
+      // Tray not available - continue without it
+    }
+  };
 
-  if (options.command === "status") {
-    process.exit(printStatus() ? 0 : 1);
-    return;
-  }
+  // Tray-only mode: no TUI, just tray icon
+  if (trayMode) {
+    // Ignore SIGHUP so macOS terminal close doesn't kill the background tray process
+    process.removeAllListeners("SIGHUP");
+    process.on("SIGHUP", () => {});
 
-  if (options.command === "stop") {
-    stopServer();
-    process.exit(0);
-    return;
-  }
+    console.log(`\n🚀 ${pkg.name} v${pkg.version}`);
+    console.log(`Server: http://${displayHost}:${port}`);
 
-  if (options.command === "logs") {
-    console.log(LOG_FILE);
-    process.exit(0);
-    return;
-  }
+    setTimeout(() => {
+      initTrayIcon();
+      console.log("\n💡 Router is now running in system tray. Close this terminal if you want.");
+      console.log("   Right-click tray icon to open dashboard or quit.\n");
+    }, 2000);
 
-  const meta = readMeta();
-  if (options.command === "open") {
-    const url = meta?.baseUrl || `http://localhost:${DEFAULT_PORT}`;
-    openBrowser(`${url}/dashboard`);
-    console.log(`Opened ${url}/dashboard`);
-    process.exit(0);
     return;
   }
 
-  if (options.command === "restart") {
-    stopServer();
-  }
-
-  const projectRoot = __dirname;
-  const appRoot = path.join(projectRoot, "app");
-  const serverEntry = path.join(appRoot, "server.js");
-  const port = getPreferredPort(process.env, options);
-  const host = options.host || process.env.HOSTNAME || DEFAULT_HOST;
-  const baseUrl = process.env.NEXT_PUBLIC_BASE_URL || `http://localhost:${port}`;
-  const foreground = options.foreground || (process.env.ORX_CHOOSER_ACTION !== undefined && process.env.ORX_CHOOSER_ACTION !== "hide");
-  const runningPid = readPid();
-
-  if (isProcessRunning(runningPid) && options.command !== "restart") {
-    const runningMeta = readMeta();
-    console.log(`${APP_NAME} is already running on ${runningMeta?.baseUrl || baseUrl}`);
-    console.log(`PID: ${runningPid}`);
-    process.exit(0);
-    return;
-  }
+  // Wait for server to be ready, then show interface menu loop + tray
+  setTimeout(async () => {
+    // Start tray icon alongside TUI
+    initTrayIcon();
 
-  const available = await checkPortAvailable(port, host);
-  if (!available) {
-    console.error(getPortConflictMessage(port));
-    process.exit(1);
-    return;
-  }
+    try {
+      while (true) {
+        const choice = await showInterfaceMenu(latestVersion);
+
+        if (choice === "update") {
+          isShuttingDown = true;
+          const { clearScreen } = require("./src/cli/utils/display");
+          clearScreen();
+          console.log(`\n⬆  Update v${pkg.version} → v${latestVersion}\n`);
+          console.log(`Run this after exit:\n`);
+          console.log(`   \x1b[33m${INSTALL_CMD_LATEST}\x1b[0m\n`);
+          cleanup();
+          await killAllAppProcesses(port);
+          await killProcessOnPort(port);
+          setTimeout(() => process.exit(0), 200);
+          return;
+        } else if (choice === "web") {
+          openBrowser(url);
+          // Wait for user to come back
+          const { pause } = require("./src/cli/utils/input");
+          await pause("\nPress Enter to go back to menu...");
+        } else if (choice === "terminal") {
+          // Start Terminal UI - it will return when user selects Back
+          const { startTerminalUI } = require("./src/cli/terminalUI");
+          await startTerminalUI(port);
+          // Loop continues, show menu again
+        } else if (choice === "hide") {
+          const { clearScreen } = require("./src/cli/utils/display");
+          clearScreen();
+
+          // Enable auto startup on OS boot
+          try {
+            const { enableAutoStart } = require("./src/cli/tray/autostart");
+            enableAutoStart(__filename);
+          } catch (e) { }
+
+          if (process.platform === "darwin") {
+            // macOS: keep current process alive — spawning a detached child puts
+            // it outside the login session so NSStatusItem silently fails.
+            process.removeAllListeners("SIGHUP");
+            process.on("SIGHUP", () => {});
+
+            console.log(`\n⏳ Switching to tray mode... (icon already visible in menu bar)`);
+            console.log(`🔔 9Router is running in tray (PID: ${process.pid})`);
+            console.log(`   Server: http://${displayHost}:${port}`);
+            console.log(`\n💡 You can close this terminal. Right-click tray icon to quit.\n`);
+
+            // Tray already init'd at startup — just keep event loop alive.
+            return;
+          }
+
+          // Windows/Linux: spawn detached bgProcess (systray works fine in child)
+          console.log(`\n⏳ Starting background process... (tray icon will appear in ~3s)`);
+
+          const bgProcess = spawn(process.execPath, [__filename, "--tray", "--skip-update", "-p", port.toString()], {
+            detached: true,
+            stdio: "ignore",
+            windowsHide: true,
+            env: { ...process.env }
+          });
+          bgProcess.unref();
+
+          console.log(`🔔 9Router is now running in background (PID: ${bgProcess.pid})`);
+          console.log(`   Server: http://${displayHost}:${port}`);
+          console.log(`\n💡 You can close this terminal. Right-click tray icon to quit.\n`);
+
+          // cleanup() kills server so bgProcess can claim the port fresh
+          cleanup();
+          process.exit(0);
+        } else if (choice === "exit") {
+          isShuttingDown = true;
+          console.log("\nExiting...");
+          cleanup();
+          setTimeout(() => process.exit(0), 100);
+        }
+      }
+    } catch (err) {
+      console.error("Error:", err.message);
+      cleanup();
+      process.exit(1);
+    }
+  }, 3000);
 
-  printChooser(baseUrl);
-
-  const stdio = foreground ? "inherit" : createLogFileDescriptors();
-  const child = spawn(process.execPath, [serverEntry], {
-    cwd: appRoot,
-    stdio,
-    detached: !foreground,
-    env: {
-      ...process.env,
-      PORT: port,
-      HOSTNAME: host,
-      NEXT_PUBLIC_BASE_URL: baseUrl,
-    },
-  });
+  function attachServerEvents() {
+    server.on("error", (err) => {
+      console.error("Failed to start server:", err.message);
+      if (!isShuttingDown) tryRestart();
+      else { cleanup(); process.exit(1); }
+    });
 
-  if (!foreground) {
-    writePid(child.pid);
-    writeMeta({
-      pid: child.pid,
-      port,
-      host,
-      baseUrl,
-      dashboardUrl: `${baseUrl}/dashboard`,
-      logFile: LOG_FILE,
-      startedAt: new Date().toISOString(),
+    server.on("close", (code) => {
+      if (isShuttingDown || code === 0) {
+        process.exit(code || 0);
+        return;
+      }
+      tryRestart(code);
     });
-    child.unref();
-    closeLogFileDescriptors(stdio);
-    if (!options.noBrowser) {
-      openBrowser(`${baseUrl}/dashboard`);
-    }
-    console.log(`${APP_NAME} is running in background on ${baseUrl}`);
-    console.log(`Dashboard: ${baseUrl}/dashboard`);
-    console.log(`Log: ${LOG_FILE}`);
-    process.exit(0);
-    return;
   }
 
-  child.on("exit", (code, signal) => {
-    if (signal) {
-      process.kill(process.pid, signal);
+  function tryRestart(code) {
+    const aliveMs = Date.now() - serverStartTime;
+    // Reset counter if last run was stable
+    if (aliveMs >= RESTART_RESET_MS) restartCount = 0;
+
+    if (restartCount >= MAX_RESTARTS) {
+      console.error(`\n⚠️  Server crashed ${MAX_RESTARTS} times. Disabling MIT and restarting...`);
+      try {
+        const dbPath = path.join(os.homedir(), process.platform === "win32" ? path.join("AppData", "Roaming", "9router", "db.json") : path.join(".9router", "db.json"));
+        if (fs.existsSync(dbPath)) {
+          const db = JSON.parse(fs.readFileSync(dbPath, "utf-8"));
+          if (db.settings) db.settings.mitmEnabled = false;
+          fs.writeFileSync(dbPath, JSON.stringify(db, null, 2));
+        }
+      } catch { /* best effort */ }
+      restartCount = 0;
+      server = spawnServer();
+      attachServerEvents();
       return;
     }
-    process.exit(code ?? 0);
-  });
-}
 
-if (require.main === module) {
-  runCli();
-}
+    restartCount++;
+    const delay = Math.min(1000 * restartCount, 10000);
+    console.error(`\n⚠️  Server exited (code=${code ?? "unknown"}). Restarting in ${delay / 1000}s... (${restartCount}/${MAX_RESTARTS})`);
+    if (crashLog.length) {
+      console.error("\n--- Server crash log ---");
+      crashLog.forEach(l => console.error(l));
+      console.error("--- End crash log ---\n");
+    }
+
+    setTimeout(() => {
+      server = spawnServer();
+      attachServerEvents();
+    }, delay);
+  }
 
-module.exports = {
-  parseArgs,
-  getPreferredPort,
-  getPortConflictMessage,
-  formatHelp,
-  formatChooserBanner,
-  getChooserOptions,
-  isProcessRunning,
-  printStatus,
-  stopServer,
-};
+  attachServerEvents();
+}