@thangnm.nip/arouter 0.1.11 → 0.1.13

package/bin/arouter.mjs

@@ -1,148 +1,301 @@
 #!/usr/bin/env node
 
-import { spawn } from 'child_process';
-import path from 'path';
-import fs from 'fs';
-import { fileURLToPath } from 'url';
-import os from 'os';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const args = process.argv.slice(2);
-const command = args[0] || 'start';
-
-let port = '20129';
-const portIndex = args.indexOf('--port');
-if (portIndex !== -1 && args[portIndex + 1]) {
-  port = args[portIndex + 1];
-}
-// If running from node_modules after npm install -g, the standalone structure is slightly different
-// than running it locally in the dev repo.
-// Path to the Next.js standalone server
-// When installed globally, the structure is:
-// global/node_modules/@thangnm.nip/arouter/
-// ├── bin/arouter.mjs
-// └── .next/standalone/server.js
-const serverPath = path.join(__dirname, '..', '.next', 'standalone', 'server.js');
-
-
-const arouterHome = path.join(os.homedir(), '.arouter');
-const pidFile = path.join(arouterHome, 'server.pid');
-const logFile = path.join(arouterHome, 'server.log');
-const portFile = path.join(arouterHome, 'server.port');
-
-if (!fs.existsSync(arouterHome)) {
-  fs.mkdirSync(arouterHome, { recursive: true });
+import { spawn, execSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync, unlinkSync, openSync, cpSync } from "fs";
+import { resolve } from "path";
+import { platform } from "os";
+import { createServer } from "net";
+import { PROJECT_ROOT, DATA_DIR, PID_FILE, LOG_FILE, PORT, DASHBOARD_URL } from "./paths.mjs";
+
+// ─── Helpers ────────────────────────────────────────────────────────────
+
+const IS_WIN = platform() === "win32";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const RED = "\x1b[31m";
+const CYAN = "\x1b[36m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+const RESET = "\x1b[0m";
+
+function log(msg) { console.log(`${DIM}[arouter]${RESET} ${msg}`); }
+function success(msg) { console.log(`${GREEN}✔${RESET} ${msg}`); }
+function warn(msg) { console.log(`${YELLOW}⚠${RESET} ${msg}`); }
+function error(msg) { console.error(`${RED}✖${RESET} ${msg}`); }
+
+/** Cross-platform port check using Node.js net module */
+function isPortInUse(port) {
+  return new Promise((resolve) => {
+    const server = createServer();
+    server.once("error", (err) => {
+      if (err.code === "EADDRINUSE") resolve(true);
+      else resolve(false);
+    });
+    server.once("listening", () => {
+      server.close(() => resolve(false));
+    });
+    server.listen(port, "0.0.0.0");
+  });
 }
 
-function checkStatus() {
-  if (!fs.existsSync(pidFile)) {
-    return false;
-  }
-  const pid = parseInt(fs.readFileSync(pidFile, 'utf8'), 10);
+function getRunningPid() {
+  if (!existsSync(PID_FILE)) return null;
+  const pid = parseInt(readFileSync(PID_FILE, "utf-8").trim(), 10);
+  if (isNaN(pid)) return null;
   try {
-    // process.kill(pid, 0) throws an error if the process doesn't exist
     process.kill(pid, 0);
     return pid;
+  } catch {
+    try { unlinkSync(PID_FILE); } catch { /* ignore */ }
+    return null;
+  }
+}
+
+function waitForServer(timeoutMs = 60000) {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    const check = () => {
+      if (Date.now() - start > timeoutMs) {
+        return reject(new Error("Server startup timed out"));
+      }
+      import("http").then(({ default: http }) => {
+        const req = http.get(`http://localhost:${PORT}`, (res) => {
+          res.resume();
+          resolve();
+        });
+        req.on("error", () => setTimeout(check, 500));
+        req.setTimeout(2000, () => { req.destroy(); setTimeout(check, 500); });
+      });
+    };
+    check();
+  });
+}
+
+function npmCommand() {
+  return IS_WIN ? "npm.cmd" : "npm";
+}
+
+// ─── Commands ───────────────────────────────────────────────────────────
+
+async function buildIfNeeded() {
+  const standaloneServer = resolve(PROJECT_ROOT, ".next/standalone/server.js");
+  if (existsSync(standaloneServer)) return;
+
+  log("First run — building production bundle...");
+  log(`${DIM}This will take a minute, please wait...${RESET}`);
+
+  try {
+    execSync(`${npmCommand()} run build`, {
+      cwd: PROJECT_ROOT,
+      stdio: "inherit",
+      env: { ...process.env, NODE_ENV: "production" },
+      shell: true,
+    });
+    success("Build complete!");
+
+    // Next.js standalone requires static assets + public to be copied manually
+    const standaloneDir = resolve(PROJECT_ROOT, ".next/standalone");
+    const staticSrc = resolve(PROJECT_ROOT, ".next/static");
+    const staticDest = resolve(standaloneDir, ".next/static");
+    const publicSrc = resolve(PROJECT_ROOT, "public");
+    const publicDest = resolve(standaloneDir, "public");
+
+    if (existsSync(staticSrc) && !existsSync(staticDest)) {
+      log("Copying static assets...");
+      cpSync(staticSrc, staticDest, { recursive: true });
+    }
+    if (existsSync(publicSrc) && !existsSync(publicDest)) {
+      log("Copying public files...");
+      cpSync(publicSrc, publicDest, { recursive: true });
+    }
+    success("Assets ready!");
   } catch (e) {
-    // Process is not running, clean up stale PID file
-    fs.unlinkSync(pidFile);
-    return false;
+    error("Build failed. Check the output above.");
+    process.exit(1);
   }
 }
 
-if (command === 'start') {
-  const currentPid = checkStatus();
-  if (currentPid) {
-    const savedPort = fs.existsSync(portFile) ? fs.readFileSync(portFile, 'utf8') : port;
-    console.log(`arouter is already running (PID: ${currentPid}). Access it at http://localhost:${savedPort}`);
-    process.exit(0);
+async function startServer() {
+  const pid = getRunningPid();
+  if (pid) {
+    success(`aRouter is already running ${DIM}(PID: ${pid})${RESET}`);
+    console.log();
+    console.log(`  ${BOLD}Dashboard${RESET}  ${CYAN}${DASHBOARD_URL}${RESET}`);
+    console.log();
+    return;
   }
 
-  if (!fs.existsSync(serverPath)) {
-    console.error(`Error: Could not find standalone server at ${serverPath}`);
-    console.error('Make sure you have built the application using `npm run build`.');
+  const portBusy = await isPortInUse(PORT);
+  if (portBusy) {
+    error(`Port ${PORT} is already in use by another process.`);
+    log(`Stop the other process or change the port.`);
     process.exit(1);
   }
 
-  console.log('Starting arouter server in the background...');
-  
-  // We use standard out/err redirection to a log file
-  const out = fs.openSync(logFile, 'a');
-  const err = fs.openSync(logFile, 'a');
+  await buildIfNeeded();
+
+  log("Starting aRouter...");
+
+  const logFd = openSync(LOG_FILE, "a");
 
-  const child = spawn(process.execPath, [serverPath], {
-    detached: true,
-    stdio: ['ignore', out, err],
+  const serverScript = resolve(PROJECT_ROOT, ".next/standalone/server.js");
+  const child = spawn(process.execPath, [serverScript], {
+    cwd: PROJECT_ROOT,  // Important: CWD must be PROJECT_ROOT so MITM can find src/mitm/
+    detached: !IS_WIN,
+    stdio: ["ignore", logFd, logFd],
     env: {
       ...process.env,
-      NODE_ENV: 'production',
-      PORT: port
-    }
+      NODE_ENV: "production",
+      PORT: String(PORT),
+      HOSTNAME: "0.0.0.0",
+      // Tell MITM manager where the real server.js is (not the standalone bundled one)
+      MITM_SERVER_PATH: resolve(PROJECT_ROOT, "src/mitm/server.js"),
+    },
+    ...(IS_WIN ? { windowsHide: true } : {}),
   });
 
-  child.unref(); // Allow the parent process to exit gracefully
-
-  if (child.pid) {
-    fs.writeFileSync(pidFile, child.pid.toString());
-    fs.writeFileSync(portFile, port.toString());
-    console.log(`Server started successfully in background! (PID: ${child.pid})`);
-    console.log(`You can view logs at: ${logFile}`);
-    
-    // Give it a moment to bind to the port before telling the user it's ready
-    setTimeout(() => {
-        console.log(`\n🚀 arouter is available at http://localhost:${port}\n`);
-        process.exit(0);
-    }, 1000);
-  } else {
-    console.error('Failed to start server.');
-    process.exit(1);
+  writeFileSync(PID_FILE, String(child.pid));
+  child.unref();
+
+  try {
+    process.stdout.write(`  Waiting for server `);
+    await waitForServer(60000);
+    process.stdout.write(`${GREEN}ready!${RESET}\n`);
+  } catch {
+    process.stdout.write(`${YELLOW}(timeout — check logs)${RESET}\n`);
   }
 
-} else if (command === 'stop') {
-  const pid = checkStatus();
+  console.log();
+  console.log(`  ${GREEN}${BOLD}aRouter is running!${RESET}`);
+  console.log();
+  console.log(`  ${BOLD}Dashboard${RESET}  ${CYAN}${DASHBOARD_URL}${RESET}`);
+  console.log(`  ${BOLD}API${RESET}        ${CYAN}${DASHBOARD_URL}/v1${RESET}`);
+  console.log(`  ${BOLD}PID${RESET}        ${DIM}${child.pid}${RESET}`);
+  console.log(`  ${BOLD}Logs${RESET}       ${DIM}${LOG_FILE}${RESET}`);
+  console.log();
+  console.log(`  ${DIM}Run ${RESET}arouter stop${DIM} to stop the server.${RESET}`);
+  console.log();
+}
+
+function stopServer() {
+  const pid = getRunningPid();
   if (!pid) {
-    console.log('arouter is not currently running.');
-    if (fs.existsSync(portFile)) fs.unlinkSync(portFile);
-    process.exit(0);
+    warn("aRouter is not running.");
+    return;
   }
 
-  console.log(`Stopping arouter (PID: ${pid})...`);
+  log(`Stopping aRouter (PID: ${pid})...`);
   try {
-    process.kill(pid); // Send default SIGTERM
-    fs.unlinkSync(pidFile);
-    if (fs.existsSync(portFile)) fs.unlinkSync(portFile);
-    console.log('Server stopped successfully.');
+    if (IS_WIN) {
+      execSync(`taskkill /PID ${pid} /T /F`, { stdio: "ignore", shell: true });
+    } else {
+      process.kill(pid, "SIGTERM");
+      setTimeout(() => {
+        try {
+          process.kill(pid, 0);
+          process.kill(pid, "SIGKILL");
+        } catch { /* already dead */ }
+      }, 3000);
+    }
   } catch (e) {
-    console.error(`Failed to stop server: ${e.message}`);
-    process.exit(1);
+    warn(`Could not kill process: ${e.message}`);
   }
 
-} else if (command === 'status') {
-  const pid = checkStatus();
+  try { unlinkSync(PID_FILE); } catch { /* ignore */ }
+  success("aRouter stopped.");
+}
+
+function showStatus() {
+  const pid = getRunningPid();
   if (pid) {
-    const savedPort = fs.existsSync(portFile) ? fs.readFileSync(portFile, 'utf8') : port;
-    console.log(`arouter is running (PID: ${pid}).`);
-    console.log(`Interface: http://localhost:${savedPort}`);
-    console.log(`Logs: ${logFile}`);
+    success(`aRouter is running ${DIM}(PID: ${pid})${RESET}`);
+    console.log(`  ${BOLD}Dashboard${RESET}  ${CYAN}${DASHBOARD_URL}${RESET}`);
   } else {
-    console.log('arouter is not running.');
+    warn("aRouter is not running.");
   }
+}
 
-} else if (command === 'logs') {
-    if (fs.existsSync(logFile)) {
-        // Simple log dump, you could use 'tail' for streaming if preferred
-        console.log(`Reading logs from ${logFile}:`);
-        console.log(fs.readFileSync(logFile, 'utf8'));
+function showLogs() {
+  if (!existsSync(LOG_FILE)) {
+    warn("No log file found. Start the server first.");
+    return;
+  }
+  try {
+    const content = readFileSync(LOG_FILE, "utf-8");
+    const lines = content.split("\n").slice(-50);
+    console.log(lines.join("\n"));
+  } catch (e) {
+    error(`Could not read logs: ${e.message}`);
+  }
+}
+
+async function restartServer() {
+  stopServer();
+  await new Promise(r => setTimeout(r, 1500));
+  await startServer();
+}
+
+function showHelp() {
+  console.log();
+  console.log(`  ${BOLD}aRouter${RESET} — AI Model Router & MITM Proxy`);
+  console.log();
+  console.log(`  ${BOLD}Usage:${RESET}`);
+  console.log(`    ${CYAN}arouter${RESET}              Start the server (background)`);
+  console.log(`    ${CYAN}arouter start${RESET}         Same as above`);
+  console.log(`    ${CYAN}arouter stop${RESET}          Stop the server`);
+  console.log(`    ${CYAN}arouter restart${RESET}       Restart the server`);
+  console.log(`    ${CYAN}arouter status${RESET}        Show server status`);
+  console.log(`    ${CYAN}arouter logs${RESET}          Show recent logs`);
+  console.log(`    ${CYAN}arouter dev${RESET}           Run in foreground (dev mode)`);
+  console.log(`    ${CYAN}arouter build${RESET}         Force rebuild`);
+  console.log(`    ${CYAN}arouter help${RESET}          Show this help`);
+  console.log();
+  console.log(`  ${BOLD}Data:${RESET}  ${DIM}${DATA_DIR}${RESET}`);
+  console.log(`  ${BOLD}Port:${RESET}  ${DIM}${PORT}${RESET}`);
+  console.log();
+}
+
+function devMode() {
+  log("Starting in dev mode (foreground)...");
+  const child = spawn(npmCommand(), ["run", "dev"], {
+    cwd: PROJECT_ROOT,
+    stdio: "inherit",
+    env: { ...process.env },
+    shell: IS_WIN,
+  });
+  child.on("exit", (code) => process.exit(code || 0));
+}
+
+async function forceBuild() {
+  log("Force rebuilding...");
+  const nextDir = resolve(PROJECT_ROOT, ".next");
+  try {
+    if (IS_WIN) {
+      execSync(`rmdir /s /q "${nextDir}"`, { cwd: PROJECT_ROOT, shell: true, stdio: "ignore" });
     } else {
-        console.log(`No logs found at ${logFile}`);
+      execSync(`rm -rf "${nextDir}"`, { cwd: PROJECT_ROOT, stdio: "ignore" });
     }
-} else {
-  console.log('Usage: arouter <command>');
-  console.log('Commands:');
-  console.log('  start   Start the server in the background');
-  console.log('  stop    Stop the running server');
-  console.log('  status  Check if the server is running');
-  console.log('  logs    View the server logs');
+  } catch { /* ignore */ }
+  await buildIfNeeded();
+}
+
+// ─── Main ───────────────────────────────────────────────────────────────
+
+const command = process.argv[2] || "start";
+
+switch (command) {
+  case "start":   await startServer(); break;
+  case "stop":    stopServer(); break;
+  case "restart": await restartServer(); break;
+  case "status":  showStatus(); break;
+  case "logs":    showLogs(); break;
+  case "dev":     devMode(); break;
+  case "build":   await forceBuild(); break;
+  case "help":
+  case "--help":
+  case "-h":      showHelp(); break;
+  default:
+    error(`Unknown command: ${command}`);
+    showHelp();
+    process.exit(1);
 }

package/bin/paths.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+import { existsSync, mkdirSync } from "fs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Project root (where package.json lives)
+export const PROJECT_ROOT = resolve(__dirname, "..");
+
+// User data directory (~/.arouter/)
+export const DATA_DIR = resolve(homedir(), ".arouter");
+
+// Ensure data dir exists
+if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
+
+// Files in data dir
+export const PID_FILE = resolve(DATA_DIR, "arouter.pid");
+export const LOG_FILE = resolve(DATA_DIR, "arouter.log");
+export const PORT = 20129;
+export const DASHBOARD_URL = `http://localhost:${PORT}`;

package/bin/paths.mjs

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+import { existsSync, mkdirSync } from "fs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Project root (where package.json lives)
+export const PROJECT_ROOT = resolve(__dirname, "..");
+
+// User data directory (~/.arouter/)
+export const DATA_DIR = resolve(homedir(), ".arouter");
+
+// Ensure data dir exists
+if (!existsSync(DATA_DIR)) mkdirSync(DATA_DIR, { recursive: true });
+
+// Files in data dir
+export const PID_FILE = resolve(DATA_DIR, "arouter.pid");
+export const LOG_FILE = resolve(DATA_DIR, "arouter.log");
+export const PORT = 20129;
+export const DASHBOARD_URL = `http://localhost:${PORT}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thangnm.nip/arouter",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "aRouter",
   "bin": {
     "arouter": "./bin/arouter.mjs"

package/scripts/postinstall.mjs

@@ -117,16 +117,15 @@ function setupMacOS() {
   log(`✅ User service started (arouter UI)`);
 
   // 2. LaunchDaemon for MITM Server (System space - needs root)
-  // We write it to a temp file, then ask macOS to move it to /Library/LaunchDaemons
-  const mitmPlistName = 'com.arouter.mitm.plist';
-  const mitmTmpPath = path.join(os.tmpdir(), mitmPlistName);
-  const mitmDaemonPath = `/Library/LaunchDaemons/${mitmPlistName}`;
-
   if (!fs.existsSync(mitmServerPath)) {
-    warn(`MITM server not found at: ${mitmServerPath}. Skipping MITM startup.`);
+    warn(`MITM server not found at: ${mitmServerPath}. Skipping MITM LaunchDaemon setup.`);
     return;
   }
 
+  const mitmPlistName = 'com.arouter.mitm.plist';
+  const mitmTmpPath = path.join(os.tmpdir(), mitmPlistName);
+  const mitmSystemPath = `/Library/LaunchDaemons/${mitmPlistName}`;
+
   const mitmPlist = `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
@@ -144,11 +143,11 @@ function setupMacOS() {
         <string>${os.homedir()}</string>
         <key>DATA_DIR</key>
         <string>${path.join(os.homedir(), '.arouter')}</string>
+        <key>NODE_ENV</key>
+        <string>production</string>
     </dict>
     <key>RunAtLoad</key>
     <true/>
-    <key>KeepAlive</key>
-    <true/>
     <key>StandardOutPath</key>
     <string>${path.join(logDir, 'mitm.startup.log')}</string>
     <key>StandardErrorPath</key>
@@ -157,21 +156,20 @@ function setupMacOS() {
 </plist>`;
 
   fs.writeFileSync(mitmTmpPath, mitmPlist, 'utf8');
-  
-  log('Requesting Administrator privileges to install MITM LaunchDaemon (auto-bind port 443)...');
-  const commands = [
-    `mkdir -p /Library/LaunchDaemons`,
-    `mv "${mitmTmpPath}" "${mitmDaemonPath}"`,
-    `chown root:wheel "${mitmDaemonPath}"`,
-    `chmod 644 "${mitmDaemonPath}"`,
-    `launchctl unload "${mitmDaemonPath}" || true`,
-    `launchctl load "${mitmDaemonPath}"`
+
+  log('Requesting administrator privileges to install MITM LaunchDaemon (port 443 requires root)...');
+  const cmds = [
+    `cp '${mitmTmpPath}' '${mitmSystemPath}'`,
+    `chmod 644 '${mitmSystemPath}'`,
+    `chown root:wheel '${mitmSystemPath}'`,
+    `launchctl unload '${mitmSystemPath}' 2>/dev/null || true`,
+    `launchctl load '${mitmSystemPath}'`
   ].join(' && ');
 
-  if (execElevatedMac(commands)) {
-    log(`✅ System service started (MITM Server on port 443)`);
+  if (execElevatedMac(cmds)) {
+    log(`✅ MITM LaunchDaemon installed and started`);
   } else {
-    warn('Failed to install MITM LaunchDaemon. You can start it manually or run this setup script as root.');
+    warn('Failed to install MITM LaunchDaemon. You can start the MITM server manually from the UI.');
   }
 }
 
@@ -225,8 +223,6 @@ Type=simple
 Environment="HOME=${os.homedir()}"
 Environment="DATA_DIR=${path.join(os.homedir(), '.arouter')}"
 ExecStart=${nodeBin} ${mitmServerPath}
-Restart=always
-RestartSec=5
 StandardOutput=append:${path.join(logDir, 'mitm.startup.log')}
 StandardError=append:${path.join(logDir, 'mitm.startup.error.log')}
 
@@ -302,7 +298,7 @@ function setupWindows() {
 
   log('Requesting Administrator privileges to install MITM scheduled task...');
   const psCmd = `Start-Process schtasks -ArgumentList '/Create /TN "${mitmTask}" /XML "${mitmXmlPath}" /F' -Verb RunAs -WindowStyle Hidden -Wait`;
-  
+
   if (execElevatedWindows(psCmd)) {
     log(`✅ Windows Task Scheduler: Admin task (MITM) created`);
   } else {