@wanosoft/wanolink 1.0.1

package/index.js

@@ -0,0 +1,991 @@
+#!/usr/bin/env node
+
+import axios from "axios";
+import { spawn } from "child_process";
+import chalk from "chalk";
+import ora from "ora";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+import { createInterface } from "readline";
+import os from "os";
+import { analytics } from "./analytics.js";
+
+// ============================================================================
+// Module Setup & Constants
+// ============================================================================
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const require = createRequire(import.meta.url);
+const packageJson = require("./package.json");
+
+// Application constants
+const CONFIG = {
+  PACKAGE_NAME: packageJson.name,
+  CURRENT_VERSION: packageJson.version,
+  BACKEND_URL: "https://wanolink.wanolink.workers.dev",
+  DEFAULT_PORT: 8080,
+  SUBDOMAIN_PREFIX: "user-",
+  TUNNEL_TIMEOUT_HOURS: 4,
+  UPDATE_CHECK_TIMEOUT: 3000,
+};
+
+// Platform-specific configuration
+const PLATFORM = {
+  IS_WINDOWS: process.platform === "win32",
+  BIN_NAME: process.platform === "win32" ? "cloudflared.exe" : "cloudflared",
+};
+
+// Paths
+const PATHS = {
+  BIN_DIR: path.join(__dirname, "bin"),
+  BIN_PATH: path.join(__dirname, "bin", PLATFORM.BIN_NAME),
+  CONFIG_DIR: path.join(os.homedir(), ".wanolink"),
+  CONFIG_FILE: path.join(os.homedir(), ".wanolink", "config.json"),
+};
+
+// Log patterns for filtering cloudflared output
+const LOG_PATTERNS = {
+  SUCCESS: ["Registered tunnel connection"],
+  ERROR: ["ERR", "error"],
+  IGNORE: [
+    "Cannot determine default origin certificate path",
+    "No file cert.pem",
+    "origincert option",
+    "TUNNEL_ORIGIN_CERT",
+    "context canceled",
+    "failed to run the datagram handler",
+    "failed to serve tunnel connection",
+    "Connection terminated",
+    "no more connections active and exiting",
+    "Serve tunnel error",
+    "accept stream listener encountered a failure",
+    "Retrying connection",
+    "icmp router terminated",
+    "use of closed network connection",
+    "Application error 0x0",
+    "Failed to fetch features",
+    "Failed to initialize DNS",
+    "i/o timeout",
+    "argotunnel.com",
+  ],
+};
+
+// Helper function to compute timeout MS from hours (0 = unlimited)
+function computeTimeoutMs(hours) {
+  if (hours === 0 || hours === null) return null; // Unlimited
+  return hours * 60 * 60 * 1000;
+}
+
+// ============================================================================
+// Token Manager
+// ============================================================================
+
+class TokenManager {
+  static loadConfig() {
+    try {
+      if (fs.existsSync(PATHS.CONFIG_FILE)) {
+        const content = fs.readFileSync(PATHS.CONFIG_FILE, "utf-8");
+        return JSON.parse(content);
+      }
+    } catch (error) {
+      // Config file corrupt or unreadable
+    }
+    return {};
+  }
+
+  static saveConfig(config) {
+    try {
+      // Create config directory if it doesn't exist
+      if (!fs.existsSync(PATHS.CONFIG_DIR)) {
+        fs.mkdirSync(PATHS.CONFIG_DIR, { recursive: true });
+      }
+      fs.writeFileSync(PATHS.CONFIG_FILE, JSON.stringify(config, null, 2));
+      return true;
+    } catch (error) {
+      console.error(chalk.red(`Failed to save config: ${error.message}`));
+      return false;
+    }
+  }
+
+  static getToken() {
+    const config = this.loadConfig();
+    return config.token || null;
+  }
+
+  static setToken(token) {
+    const config = this.loadConfig();
+    config.token = token;
+    return this.saveConfig(config);
+  }
+
+  static clearToken() {
+    const config = this.loadConfig();
+    delete config.token;
+    return this.saveConfig(config);
+  }
+
+  static async promptToken() {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+
+    return new Promise((resolve) => {
+      rl.question(chalk.cyan("🔐 Enter token: "), (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    });
+  }
+
+  static async handleAuth() {
+    console.log(chalk.bold("\n🔑 Wanolink Authentication\n"));
+
+    const existingToken = this.getToken();
+    if (existingToken) {
+      console.log(chalk.gray(`Current token: ${existingToken.substring(0, 8)}...`));
+    }
+
+    const token = await this.promptToken();
+
+    if (!token) {
+      console.log(chalk.red("❌ No token provided."));
+      process.exit(1);
+    }
+
+    if (this.setToken(token)) {
+      console.log(chalk.green("\n✔ Token saved successfully!"));
+      console.log(chalk.gray(`  Config: ${PATHS.CONFIG_FILE}`));
+    } else {
+      console.log(chalk.red("\n❌ Failed to save token."));
+      process.exit(1);
+    }
+  }
+
+  static handleLogout() {
+    const existingToken = this.getToken();
+
+    if (!existingToken) {
+      console.log(chalk.yellow("No token found. Already logged out."));
+      return;
+    }
+
+    if (this.clearToken()) {
+      console.log(chalk.green("✔ Logged out successfully. Token removed."));
+    } else {
+      console.log(chalk.red("❌ Failed to remove token."));
+    }
+  }
+}
+
+// ============================================================================
+// Connection Progress Tracker
+// ============================================================================
+
+class ConnectionProgressTracker {
+  constructor() {
+    this.startTime = null;
+    this.intervalId = null;
+    this.isActive = false;
+    this.spinnerFrames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    this.currentFrame = 0;
+    this.bouncePosition = 0;
+    this.bounceDirection = 1;
+    this.barWidth = 20;
+    this.blockWidth = 4;
+  }
+
+  start() {
+    if (this.isActive) return;
+
+    this.isActive = true;
+    this.startTime = Date.now();
+    this.currentFrame = 0;
+    this.bouncePosition = 0;
+    this.bounceDirection = 1;
+
+    // Clear line and show initial state
+    this.render();
+
+    // Update every 80ms for smooth animation
+    this.intervalId = setInterval(() => {
+      this.currentFrame = (this.currentFrame + 1) % this.spinnerFrames.length;
+
+      // Bounce animation - move block back and forth
+      this.bouncePosition += this.bounceDirection;
+      if (this.bouncePosition >= this.barWidth - this.blockWidth) {
+        this.bounceDirection = -1;
+      } else if (this.bouncePosition <= 0) {
+        this.bounceDirection = 1;
+      }
+
+      this.render();
+    }, 80);
+  }
+
+  formatElapsedTime(ms) {
+    const totalSeconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(totalSeconds / 60);
+    const seconds = totalSeconds % 60;
+    const tenths = Math.floor((ms % 1000) / 100);
+
+    if (minutes > 0) {
+      return `${minutes}:${seconds.toString().padStart(2, "0")}.${tenths}`;
+    }
+    return `${seconds}.${tenths}s`;
+  }
+
+  getIndeterminateBar() {
+    // Create bouncing block animation
+    const emptyChar = "░";
+    const blockChar = "█";
+
+    const before = emptyChar.repeat(this.bouncePosition);
+    const block = blockChar.repeat(this.blockWidth);
+    const after = emptyChar.repeat(this.barWidth - this.bouncePosition - this.blockWidth);
+
+    return before + block + after;
+  }
+
+  render() {
+    if (!this.isActive) return;
+
+    const elapsed = Date.now() - this.startTime;
+    const spinner = this.spinnerFrames[this.currentFrame];
+    const elapsedFormatted = this.formatElapsedTime(elapsed);
+    const bar = this.getIndeterminateBar();
+
+    // Clear line and move cursor to beginning
+    process.stdout.write("\r\x1b[K");
+
+    // Render professional progress line with indeterminate animation
+    const line = chalk.cyan(spinner) +
+      chalk.gray(" Connecting to global network") +
+      chalk.gray(" │ ") +
+      chalk.blue(bar) +
+      chalk.gray(" │ ") +
+      chalk.gray(`⏱ ${elapsedFormatted}`);
+
+    process.stdout.write(line);
+  }
+
+  stop(success = true) {
+    if (!this.isActive) return;
+
+    this.isActive = false;
+
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+    }
+
+    const elapsed = Date.now() - this.startTime;
+    const elapsedFormatted = this.formatElapsedTime(elapsed);
+
+    // Clear the progress line
+    process.stdout.write("\r\x1b[K");
+
+    // Show final status
+    if (success) {
+      console.log(
+        chalk.green("✔") +
+        chalk.green(" Connected to global network") +
+        chalk.gray(" │ ") +
+        chalk.gray(`Completed in ${elapsedFormatted}`)
+      );
+    } else {
+      console.log(
+        chalk.red("✖") +
+        chalk.red(" Connection failed") +
+        chalk.gray(" │ ") +
+        chalk.gray(`Duration: ${elapsedFormatted}`)
+      );
+    }
+  }
+}
+
+const progressTracker = new ConnectionProgressTracker();
+
+// ============================================================================
+// Application State
+// ============================================================================
+
+class TunnelState {
+  constructor() {
+    this.tunnelId = null;
+    this.subdomain = null;
+    this.port = null;
+    this.tunnelProcess = null;
+    this.timeoutId = null;
+    this.connectionCount = 0;
+    this.startTime = null;
+  }
+
+  setTunnel(tunnelId, subdomain, port) {
+    this.tunnelId = tunnelId;
+    this.subdomain = subdomain;
+    this.port = port;
+    if (!this.startTime) {
+      this.startTime = Date.now();
+    }
+  }
+
+  setProcess(process) {
+    this.tunnelProcess = process;
+  }
+
+  setTimeout(timeoutId) {
+    this.timeoutId = timeoutId;
+  }
+
+  clearTimeout() {
+    if (this.timeoutId) {
+      clearTimeout(this.timeoutId);
+      this.timeoutId = null;
+    }
+  }
+
+  incrementConnection() {
+    this.connectionCount++;
+    return this.connectionCount;
+  }
+
+  hasTunnel() {
+    return this.tunnelId !== null;
+  }
+
+  hasProcess() {
+    return this.tunnelProcess && !this.tunnelProcess.killed;
+  }
+
+  getDurationSeconds() {
+    if (!this.startTime) return 0;
+    return (Date.now() - this.startTime) / 1000;
+  }
+
+  reset() {
+    this.clearTimeout();
+    this.tunnelId = null;
+    this.subdomain = null;
+    this.port = null;
+    this.tunnelProcess = null;
+    this.connectionCount = 0;
+    this.startTime = null;
+  }
+}
+
+const state = new TunnelState();
+
+// ============================================================================
+// Argument Parsing
+// ============================================================================
+
+class ArgumentParser {
+  static parse(argv) {
+    // Check for help flag
+    if (argv.includes("--help") || argv.includes("-h")) {
+      this.displayHelp();
+      process.exit(0);
+    }
+
+    const port = this.parsePort(argv);
+    const subdomain = this.parseSubdomain(argv);
+    const timeout = this.parseTimeout(argv);
+    return { port, subdomain, timeout };
+  }
+
+  static displayHelp() {
+    console.log(`
+${chalk.bold("Wanolink")} - Tunnel localhost to the internet via Cloudflare Edge
+
+${chalk.yellow("Usage:")}
+  wanolink <port> [options]
+  wanolink <command>
+
+${chalk.yellow("Commands:")}
+  ${chalk.cyan("auth")}                      Authenticate with a token
+  ${chalk.cyan("logout")}                    Remove saved token
+
+${chalk.yellow("Options:")}
+  ${chalk.cyan("-s, --subdomain <name>")}   Custom subdomain (default: random)
+  ${chalk.cyan("-t, --timeout <hours>")}    Timeout in hours, 0 for unlimited (default: ${CONFIG.TUNNEL_TIMEOUT_HOURS})
+  ${chalk.cyan("-h, --help")}               Show this help message
+
+${chalk.yellow("Examples:")}
+  ${chalk.gray("# First time: authenticate")}
+  wanolink auth
+
+  ${chalk.gray("# Basic usage with default timeout (4 hours)")}
+  wanolink 3000
+
+  ${chalk.gray("# Custom subdomain")}
+  wanolink 3000 -s myapp
+
+  ${chalk.gray("# Custom timeout (2 hours)")}
+  wanolink 3000 --timeout 2
+
+  ${chalk.gray("# Unlimited timeout (no auto-shutdown)")}
+  wanolink 3000 -t 0
+
+  ${chalk.gray("# Combine all options")}
+  wanolink 3000 -s myapp -t 0
+`);
+  }
+
+  static parsePort(argv) {
+    const portArg = parseInt(argv[0]);
+    return portArg || CONFIG.DEFAULT_PORT;
+  }
+
+  static parseSubdomain(argv) {
+    // Try all subdomain formats
+    const formats = [
+      () => this.findFlagWithEquals(argv, "--subdomain="),
+      () => this.findFlagWithEquals(argv, "-s="),
+      () => this.findFlagWithValue(argv, "--subdomain"),
+      () => this.findFlagWithValue(argv, "-s"),
+    ];
+
+    for (const format of formats) {
+      const subdomain = format();
+      if (subdomain) return subdomain;
+    }
+
+    return this.generateRandomSubdomain();
+  }
+
+  static findFlagWithEquals(argv, flag) {
+    const arg = argv.find((a) => a.startsWith(flag));
+    return arg ? arg.split("=")[1] : null;
+  }
+
+  static findFlagWithValue(argv, flag) {
+    const index = argv.indexOf(flag);
+    return index !== -1 && argv[index + 1] ? argv[index + 1] : null;
+  }
+
+  static generateRandomSubdomain() {
+    return `${CONFIG.SUBDOMAIN_PREFIX}${Math.floor(Math.random() * 10000)}`;
+  }
+
+  static parseTimeout(argv) {
+    // Try all timeout formats
+    const formats = [
+      () => this.findFlagWithEquals(argv, "--timeout="),
+      () => this.findFlagWithEquals(argv, "-t="),
+      () => this.findFlagWithValue(argv, "--timeout"),
+      () => this.findFlagWithValue(argv, "-t"),
+    ];
+
+    for (const format of formats) {
+      const value = format();
+      if (value !== null) {
+        const parsed = parseFloat(value);
+        if (!isNaN(parsed) && parsed >= 0) {
+          return parsed;
+        }
+      }
+    }
+
+    return CONFIG.TUNNEL_TIMEOUT_HOURS; // Default
+  }
+}
+
+// ============================================================================
+// Binary Management
+// ============================================================================
+
+class BinaryManager {
+  static validate(binaryPath) {
+    if (fs.existsSync(binaryPath)) {
+      return true;
+    }
+
+    console.error(
+      chalk.red(`\n❌ Error: Cloudflared binary not found at: ${binaryPath}`)
+    );
+    console.error(
+      chalk.yellow(
+        "👉 Please run 'npm install' again to download the binary.\n"
+      )
+    );
+    return false;
+  }
+
+  static spawn(binaryPath, token, port) {
+    return spawn(binaryPath, [
+      "tunnel",
+      "run",
+      "--token",
+      token,
+      "--url",
+      `http://localhost:${port}`,
+    ]);
+  }
+
+  static attachHandlers(process, spinner = null) {
+    process.stderr.on("data", (chunk) => this.handleStderr(chunk));
+    process.on("error", (err) => this.handleError(err, spinner));
+    process.on("close", (code) => this.handleClose(code));
+  }
+
+  static handleStderr(chunk) {
+    const msg = chunk.toString();
+
+    // Skip harmless warnings
+    if (LOG_PATTERNS.IGNORE.some((pattern) => msg.includes(pattern))) {
+      return;
+    }
+
+    // Show success messages with connection count
+    if (LOG_PATTERNS.SUCCESS.some((pattern) => msg.includes(pattern))) {
+      const count = state.incrementConnection();
+
+      // Stop progress tracker on first connection
+      if (count === 1) {
+        progressTracker.stop(true);
+      }
+
+      const messages = [
+        "✔ Connection established [1/4] - Establishing redundancy...",
+        "✔ Connection established [2/4] - Building tunnel network...",
+        "✔ Connection established [3/4] - Almost there...",
+        "✔ Connection established [4/4] - Tunnel is fully active! 🚀",
+      ];
+
+      if (count <= 4) {
+        console.log(chalk.blueBright(messages[count - 1]));
+      }
+      return;
+    }
+
+    // Show critical errors only
+    if (LOG_PATTERNS.ERROR.some((pattern) => msg.includes(pattern))) {
+      // Stop progress tracker if still running (connection failed)
+      if (progressTracker.isActive) {
+        progressTracker.stop(false);
+      }
+      console.error(chalk.red(`[Cloudflared] ${msg.trim()}`));
+    }
+  }
+
+  static handleError(err, spinner) {
+    // Stop progress tracker if still running
+    if (progressTracker.isActive) {
+      progressTracker.stop(false);
+    }
+    if (spinner) {
+      spinner.fail("Failed to spawn cloudflared process.");
+    }
+    console.error(chalk.red(`Process Error: ${err.message}`));
+  }
+
+  static handleClose(code) {
+    // Stop progress tracker if still running (unexpected exit)
+    if (progressTracker.isActive) {
+      progressTracker.stop(false);
+    }
+    if (code !== 0 && code !== null) {
+      console.log(chalk.red(`Tunnel process exited with code ${code}`));
+    }
+  }
+}
+
+// ============================================================================
+// API Client
+// ============================================================================
+
+class APIClient {
+  static async createTunnel(subdomain) {
+    const token = TokenManager.getToken();
+
+    if (!token) {
+      throw new Error(
+        chalk.red("❌ Authentication required.\n\n") +
+        chalk.yellow("Please run: ") + chalk.cyan("wanolink auth") + chalk.yellow(" to authenticate.")
+      );
+    }
+
+    try {
+      const { data } = await axios.post(CONFIG.BACKEND_URL, { subdomain, token });
+
+      if (!data.success) {
+        throw new Error(data.error || "Unknown error from backend");
+      }
+
+      return {
+        tunnelId: data.tunnelId,
+        tunnelToken: data.tunnelToken,
+        url: data.url,
+      };
+    } catch (error) {
+      throw this.handleError(error, subdomain);
+    }
+  }
+
+  static async deleteTunnel(subdomain, tunnelId) {
+    const token = TokenManager.getToken();
+    await axios.delete(CONFIG.BACKEND_URL, {
+      data: { subdomain, tunnelId, token },
+    });
+  }
+
+  static handleError(error, subdomain) {
+    if (error.response?.data?.error) {
+      const errorMsg = error.response.data.error;
+
+      // Check for auth errors
+      if (errorMsg.includes("AUTH_REQUIRED") || errorMsg.includes("AUTH_INVALID")) {
+        return new Error(
+          chalk.red("❌ Authentication failed.\n\n") +
+          chalk.yellow("Your token is invalid or has been revoked.\n") +
+          chalk.white("Please run: ") + chalk.cyan("wanolink auth") + chalk.white(" to re-authenticate.\n")
+        );
+      }
+
+      // Check for subdomain in use (active tunnel)
+      if (
+        errorMsg.includes("SUBDOMAIN_IN_USE:") ||
+        errorMsg.includes("currently in use") ||
+        errorMsg.includes("already exists and is currently active")
+      ) {
+        return new Error(
+          chalk.red(`✗ Subdomain "${subdomain}" is already in use!\n\n`) +
+          chalk.yellow(`💡 This subdomain is currently being used by another active tunnel.\n\n`) +
+          chalk.white(`Choose a different subdomain:\n`) +
+          chalk.gray(`   1. Add a suffix:     `) +
+          chalk.cyan(`wanolink ${state.port || CONFIG.DEFAULT_PORT} -s ${subdomain}-2\n`) +
+          chalk.gray(`   2. Try a variation:  `) +
+          chalk.cyan(`wanolink ${state.port || CONFIG.DEFAULT_PORT} -s my-${subdomain}\n`) +
+          chalk.gray(`   3. Use random name:  `) +
+          chalk.cyan(`wanolink ${state.port || CONFIG.DEFAULT_PORT}\n`)
+        );
+      }
+
+      // Check for duplicate tunnel error (other Cloudflare errors)
+      if (
+        errorMsg.includes("already have a tunnel") ||
+        errorMsg.includes("[1013]")
+      ) {
+        return new Error(
+          `Subdomain "${subdomain}" is already taken or in use.\n\n` +
+          chalk.yellow(`💡 Try one of these options:\n`) +
+          chalk.gray(`   1. Choose a different subdomain: `) +
+          chalk.cyan(`wanolink ${state.port || CONFIG.DEFAULT_PORT} -s ${subdomain}-v2\n`) +
+          chalk.gray(`   2. Use a random subdomain:       `) +
+          chalk.cyan(`wanolink ${state.port || CONFIG.DEFAULT_PORT}\n`) +
+          chalk.gray(
+            `   3. Wait a few minutes and retry if you just stopped a tunnel with this name`
+          )
+        );
+      }
+
+      return new Error(`Backend Error: ${errorMsg}`);
+    }
+
+    if (error.response) {
+      const errorMsg = JSON.stringify(error.response.data, null, 2);
+      return new Error(`Backend Error: ${errorMsg}`);
+    }
+
+    return error;
+  }
+}
+
+// ============================================================================
+// Version Management
+// ============================================================================
+
+class VersionManager {
+  static async checkForUpdates() {
+    try {
+      const response = await axios.get(
+        `https://registry.npmjs.org/${CONFIG.PACKAGE_NAME}/latest`,
+        { timeout: CONFIG.UPDATE_CHECK_TIMEOUT }
+      );
+
+      const latestVersion = response.data.version;
+      const shouldUpdate =
+        this.compareVersions(latestVersion, CONFIG.CURRENT_VERSION) > 0;
+
+      // Track update notification if available
+      if (shouldUpdate) {
+        analytics.trackUpdateAvailable(CONFIG.CURRENT_VERSION, latestVersion);
+      }
+
+      return {
+        current: CONFIG.CURRENT_VERSION,
+        latest: latestVersion,
+        shouldUpdate,
+      };
+    } catch (error) {
+      // Silently fail if can't check for updates
+      return null;
+    }
+  }
+
+  static compareVersions(v1, v2) {
+    const parts1 = v1.split(".").map(Number);
+    const parts2 = v2.split(".").map(Number);
+
+    // Compare up to the maximum length of both version arrays
+    const maxLength = Math.max(parts1.length, parts2.length);
+
+    for (let i = 0; i < maxLength; i++) {
+      // Treat missing parts as 0 (e.g., "1.0" is "1.0.0")
+      const part1 = parts1[i] || 0;
+      const part2 = parts2[i] || 0;
+
+      if (part1 > part2) return 1;
+      if (part1 < part2) return -1;
+    }
+
+    return 0;
+  }
+}
+
+// ============================================================================
+// UI Display
+// ============================================================================
+
+class UI {
+  static displayUpdateNotification(updateInfo) {
+    if (!updateInfo || !updateInfo.shouldUpdate) return;
+
+    const border = "═".repeat(59);
+    const boxWidth = 59;
+
+    // Calculate padding dynamically
+    const currentVersionText = `  Current version: v${updateInfo.current}`;
+    const latestVersionText = `  Latest version:  v${updateInfo.latest}`;
+    const runCommandText = `  Run: npm install -g ${CONFIG.PACKAGE_NAME}@latest`;
+
+    console.log(chalk.yellow(`\n╔${border}╗`));
+    console.log(
+      chalk.yellow("║") +
+      chalk.bold.yellow("  📦 Update Available!") +
+      " ".repeat(37) +
+      chalk.yellow("║")
+    );
+    console.log(chalk.yellow(`╠${border}╣`));
+    console.log(
+      chalk.yellow("║") +
+      chalk.gray(`  Current version: `) +
+      chalk.red(`v${updateInfo.current}`) +
+      " ".repeat(boxWidth - currentVersionText.length) +
+      chalk.yellow("║")
+    );
+    console.log(
+      chalk.yellow("║") +
+      chalk.gray(`  Latest version:  `) +
+      chalk.green(`v${updateInfo.latest}`) +
+      " ".repeat(boxWidth - latestVersionText.length) +
+      chalk.yellow("║")
+    );
+    console.log(chalk.yellow(`╠${border}╣`));
+    console.log(
+      chalk.yellow("║") +
+      chalk.cyan(`  Run: `) +
+      chalk.bold(`npm install -g ${CONFIG.PACKAGE_NAME}@latest`) +
+      " ".repeat(boxWidth - runCommandText.length) +
+      chalk.yellow("║")
+    );
+    console.log(chalk.yellow(`╚${border}╝\n`));
+  }
+
+  static displayStartupBanner(port) {
+    console.log(`🚀 Starting Tunnel for port ${port}...`);
+  }
+
+  static displayTunnelSuccess(url, timeout) {
+    console.log(chalk.bold(`🌍 Public URL: ${url}`));
+    if (timeout === 0) {
+      console.log(chalk.gray(`   No auto-cleanup (unlimited duration)`));
+    } else {
+      console.log(
+        chalk.gray(`   Auto-cleanup in ${timeout} hour${timeout !== 1 ? 's' : ''}`)
+      );
+    }
+    console.log(""); // Empty line before progress
+    // Start the progress tracker instead of static message
+    progressTracker.start();
+  }
+
+  static displayTimeoutWarning(timeout) {
+    console.log(
+      chalk.yellow(
+        `\n⏰ Tunnel has been running for ${timeout} hour${timeout !== 1 ? 's' : ''}.`
+      )
+    );
+    console.log(chalk.yellow("   Automatically shutting down..."));
+  }
+
+  static displayError(error, spinner = null) {
+    if (spinner) {
+      spinner.fail("Failed to connect to server.");
+    }
+    console.error(chalk.red(error.message));
+  }
+
+  static displayCleanupStart() {
+    console.log(
+      chalk.yellow("\n\n🛑 Shutting down... Cleaning up resources...")
+    );
+  }
+
+  static displayCleanupSuccess() {
+    console.log(chalk.green("✔ Cleanup successful. Subdomain released."));
+  }
+
+  static displayCleanupError() {
+    console.error(
+      chalk.red("✖ Cleanup failed (Server might be down or busy).")
+    );
+  }
+}
+
+// ============================================================================
+// Tunnel Orchestrator
+// ============================================================================
+
+class TunnelOrchestrator {
+  static async start(config) {
+    state.setTunnel(null, config.subdomain, config.port);
+
+    // Initialize analytics
+    await analytics.initialize();
+
+    // Track CLI start
+    analytics.trackCliStart(config.port, config.subdomain, CONFIG.CURRENT_VERSION);
+
+    // Display UI
+    UI.displayStartupBanner(config.port);
+
+    // Check for updates
+    const updateInfo = await VersionManager.checkForUpdates();
+    UI.displayUpdateNotification(updateInfo);
+
+    // Validate binary
+    if (!BinaryManager.validate(PATHS.BIN_PATH)) {
+      analytics.trackTunnelError("binary_missing", "Cloudflared binary not found");
+      // Give analytics a moment to send before exiting
+      await new Promise(resolve => setTimeout(resolve, 100));
+      process.exit(1);
+    }
+
+    const spinner = ora("Requesting access...").start();
+
+    try {
+      // Create tunnel
+      const tunnel = await APIClient.createTunnel(config.subdomain);
+      state.setTunnel(tunnel.tunnelId, config.subdomain, config.port);
+
+      // Track successful tunnel creation
+      analytics.trackTunnelCreated(config.subdomain, config.port);
+
+      spinner.succeed(chalk.green("Tunnel created!"));
+      UI.displayTunnelSuccess(tunnel.url, config.timeout);
+
+      // Spawn cloudflared
+      const process = BinaryManager.spawn(
+        PATHS.BIN_PATH,
+        tunnel.tunnelToken,
+        config.port
+      );
+      state.setProcess(process);
+      BinaryManager.attachHandlers(process, spinner);
+
+      // Set timeout only if not unlimited (timeout > 0)
+      const timeoutMs = computeTimeoutMs(config.timeout);
+      if (timeoutMs !== null) {
+        const timeoutId = setTimeout(() => {
+          UI.displayTimeoutWarning(config.timeout);
+          this.cleanup("timeout");
+        }, timeoutMs);
+        state.setTimeout(timeoutId);
+      }
+    } catch (error) {
+      // Track tunnel creation error
+      const errorType = error.message.includes("already taken")
+        ? "subdomain_taken"
+        : "tunnel_creation_failed";
+      analytics.trackTunnelError(errorType, error.message);
+
+      UI.displayError(error, spinner);
+      // Give analytics a moment to send before exiting
+      await new Promise(resolve => setTimeout(resolve, 100));
+      process.exit(1);
+    }
+  }
+
+  static async cleanup(reason = "manual") {
+    state.clearTimeout();
+
+    if (!state.hasTunnel()) {
+      process.exit(0);
+    }
+
+    UI.displayCleanupStart();
+
+    // Track tunnel shutdown with duration
+    const duration = state.getDurationSeconds();
+    analytics.trackTunnelShutdown(reason, duration);
+
+    try {
+      // Kill process
+      if (state.hasProcess()) {
+        state.tunnelProcess.kill();
+      }
+
+      // Delete tunnel
+      await APIClient.deleteTunnel(state.subdomain, state.tunnelId);
+      UI.displayCleanupSuccess();
+    } catch (err) {
+      UI.displayCleanupError();
+    }
+
+    // Give analytics a moment to send (non-blocking)
+    await new Promise(resolve => setTimeout(resolve, 100));
+
+    process.exit(0);
+  }
+}
+
+// ============================================================================
+// Application Entry Point
+// ============================================================================
+
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+
+  // Handle special commands
+  if (command === "auth") {
+    await TokenManager.handleAuth();
+    process.exit(0);
+  }
+
+  if (command === "logout") {
+    TokenManager.handleLogout();
+    process.exit(0);
+  }
+
+  // Normal tunnel flow
+  try {
+    const config = ArgumentParser.parse(args);
+    await TunnelOrchestrator.start(config);
+  } catch (error) {
+    console.error(chalk.red(`Fatal Error: ${error.message}`));
+    process.exit(1);
+  }
+}
+
+// Register cleanup handlers
+process.on("SIGINT", () => TunnelOrchestrator.cleanup());
+process.on("SIGTERM", () => TunnelOrchestrator.cleanup());
+
+// Start application
+main();