nport 2.0.4 → 2.0.5

package/src/state.js

@@ -0,0 +1,76 @@
+/**
+ * Application State Manager
+ * Manages tunnel state including connection info, process, and timers
+ */
+class TunnelState {
+  constructor() {
+    this.tunnelId = null;
+    this.subdomain = null;
+    this.port = null;
+    this.tunnelProcess = null;
+    this.timeoutId = null;
+    this.connectionCount = 0;
+    this.startTime = null;
+    this.updateInfo = null;
+  }
+
+  setTunnel(tunnelId, subdomain, port) {
+    this.tunnelId = tunnelId;
+    this.subdomain = subdomain;
+    this.port = port;
+    if (!this.startTime) {
+      this.startTime = Date.now();
+    }
+  }
+
+  setUpdateInfo(updateInfo) {
+    this.updateInfo = updateInfo;
+  }
+
+  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;
+    this.updateInfo = null;
+  }
+}
+
+export const state = new TunnelState();
+

package/src/tunnel.js

@@ -0,0 +1,116 @@
+import ora from "ora";
+import chalk from "chalk";
+import { CONFIG, PATHS, TUNNEL_TIMEOUT_MS } from "./config.js";
+import { state } from "./state.js";
+import { BinaryManager } from "./binary.js";
+import { APIClient } from "./api.js";
+import { VersionManager } from "./version.js";
+import { UI } from "./ui.js";
+import { analytics } from "./analytics.js";
+import { lang } from "./lang.js";
+
+/**
+ * Tunnel Orchestrator
+ * Main controller for tunnel lifecycle management
+ */
+export 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();
+    state.setUpdateInfo(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(lang.t("creatingTunnel", { port: config.port })).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.stop();
+      console.log(chalk.green(`   ${lang.t("tunnelLive")}`));
+      UI.displayTunnelSuccess(tunnel.url, config.port, updateInfo);
+
+      // Spawn cloudflared
+      const process = BinaryManager.spawn(
+        PATHS.BIN_PATH,
+        tunnel.tunnelToken,
+        config.port
+      );
+      state.setProcess(process);
+      BinaryManager.attachHandlers(process, spinner);
+
+      // Set timeout
+      const timeoutId = setTimeout(() => {
+        UI.displayTimeoutWarning();
+        this.cleanup("timeout");
+      }, TUNNEL_TIMEOUT_MS);
+      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);
+  }
+}
+

package/src/ui.js

@@ -0,0 +1,98 @@
+import chalk from "chalk";
+import { CONFIG } from "./config.js";
+import { lang } from "./lang.js";
+
+/**
+ * UI Display Manager
+ * Handles all console output and user interface with multilingual support
+ */
+export class UI {
+  static displayProjectInfo() {
+    const line = "─".repeat(56);
+    console.log(chalk.gray(`\n ╭${line}╮`));
+    console.log(chalk.cyan.bold(` │  ${lang.t("header")}`) + " ".repeat(56 - lang.t("header").length - 4) + chalk.gray("│"));
+    console.log(chalk.gray(` ╰${line}╯\n`));
+  }
+
+  static displayStartupBanner(port) {
+    this.displayProjectInfo();
+  }
+
+  static displayTunnelSuccess(url, port, updateInfo) {
+    console.log(); // Extra spacing
+    console.log(chalk.cyan.bold(`   👉  ${url}  👈\n`));
+    console.log(chalk.gray("   " + "─".repeat(54) + "\n"));
+    console.log(chalk.gray(`   ${lang.t("timeRemaining", { hours: CONFIG.TUNNEL_TIMEOUT_HOURS })}\n`));
+  }
+  
+  static displayFooter(updateInfo) {
+    console.log(chalk.gray("   " + "─".repeat(54) + "\n"));
+    console.log(chalk.yellow.bold(`   ${lang.t("footerTitle")}\n`));
+    console.log(chalk.gray(`      ${lang.t("footerSubtitle")}\n`));
+    console.log(chalk.cyan(`   ${lang.t("dropStar")}`) + chalk.white("https://github.com/tuanngocptn/nport"));
+    console.log(chalk.yellow(`   ${lang.t("sendCoffee")}`) + chalk.white("https://buymeacoffee.com/tuanngocptn"));
+    
+    if (updateInfo && updateInfo.shouldUpdate) {
+      console.log(chalk.red.bold(`\n   ${lang.t("newVersion", { version: updateInfo.latest })}`));
+      console.log(chalk.gray("      ") + chalk.cyan(lang.t("updateCommand")));
+    }
+    console.log();
+  }
+
+  static displayTimeoutWarning() {
+    console.log(
+      chalk.yellow(
+        `\n⏰ Tunnel has been running for ${CONFIG.TUNNEL_TIMEOUT_HOURS} hours.`
+      )
+    );
+    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.red.bold(`\n\n   ${lang.t("tunnelShutdown")}\n`));
+    process.stdout.write(chalk.gray(`      ${lang.t("cleaningUp")}`));
+  }
+
+  static displayCleanupSuccess() {
+    console.log(chalk.green(lang.t("cleanupDone")));
+    console.log(chalk.gray(`      ${lang.t("subdomainReleased")}\n`));
+    this.displayGoodbye();
+  }
+
+  static displayCleanupError() {
+    console.log(chalk.red(lang.t("cleanupFailed")));
+    console.log(chalk.gray(`      ${lang.t("serverBusy")}\n`));
+    this.displayGoodbye();
+  }
+
+  static displayGoodbye() {
+    console.log(chalk.gray("   " + "─".repeat(54) + "\n"));
+    console.log(chalk.cyan.bold(`   ${lang.t("goodbyeTitle")}\n`));
+    console.log(chalk.gray(`      ${lang.t("goodbyeMessage")}\n`));
+    console.log(chalk.cyan(`      ${lang.t("website")}`) + chalk.white("https://nport.link"));
+    console.log(chalk.cyan(`      ${lang.t("author")}`) + chalk.white("Nick Pham (https://github.com/tuanngocptn)"));
+    console.log(chalk.cyan(`      ${lang.t("changeLanguage")}`) + chalk.yellow(lang.t("changeLanguageHint")));
+    console.log();
+  }
+
+  static displayVersion(current, updateInfo) {
+    console.log(chalk.cyan.bold(`\n${lang.t("versionTitle", { version: current })}`));
+    console.log(chalk.gray(`${lang.t("versionSubtitle")}\n`));
+    
+    if (updateInfo && updateInfo.shouldUpdate) {
+      console.log(chalk.yellow(lang.t("versionAvailable", { version: updateInfo.latest })));
+      console.log(chalk.cyan(lang.t("versionUpdate")) + chalk.white(`npm install -g nport@latest\n`));
+    } else {
+      console.log(chalk.green(`${lang.t("versionLatest")}\n`));
+    }
+    
+    console.log(chalk.gray(lang.t("learnMore")) + chalk.cyan("https://nport.link\n"));
+  }
+}

package/src/version.js

@@ -0,0 +1,56 @@
+import axios from "axios";
+import { CONFIG } from "./config.js";
+import { analytics } from "./analytics.js";
+
+/**
+ * Version Manager
+ * Handles version checking and update notifications
+ */
+export 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;
+  }
+}
+