nport 2.0.4 → 2.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nport",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "Free & open source ngrok alternative - Tunnel HTTP/HTTPS connections via Cloudflare Edge with custom subdomains",
   "type": "module",
   "main": "index.js",
@@ -63,7 +63,7 @@
     }
   ],
   "scripts": {
-    "postinstall": "node bin-manager.js",
+    "postinstall": "node src/bin-manager.js",
     "start": "node index.js"
   },
   "dependencies": {
@@ -73,9 +73,9 @@
   },
   "files": [
     "index.js",
-    "analytics.js",
-    "bin-manager.js",
+    "src/",
     "README.md",
+    "CHANGELOG.md",
     "LICENSE"
   ],
   "os": [

package/{analytics.js → src/analytics.js}

@@ -11,7 +11,7 @@ import path from "path";
 import { fileURLToPath } from "url";
 
 const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+const __dirname = path.dirname(path.dirname(__filename));
 
 // Firebase/GA4 Configuration (from website/home.html)
 // Full Firebase config for reference (if needed for future features)
@@ -36,7 +36,7 @@ const ANALYTICS_CONFIG = {
   enabled: true, // Can be disabled by environment variable
   debug: process.env.NPORT_DEBUG === "true",
   timeout: 2000, // Don't block CLI for too long
-  userIdFile: path.join(os.homedir(), ".nport-analytics"),
+  userIdFile: path.join(os.homedir(), ".nport", "analytics-id"),
 };
 
 // ============================================================================
@@ -92,6 +92,12 @@ class AnalyticsManager {
    */
   async getUserId() {
     try {
+      // Ensure .nport directory exists
+      const configDir = path.join(os.homedir(), ".nport");
+      if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+      }
+
       // Try to read existing user ID
       if (fs.existsSync(ANALYTICS_CONFIG.userIdFile)) {
         const userId = fs.readFileSync(ANALYTICS_CONFIG.userIdFile, "utf8").trim();

package/src/api.js

@@ -0,0 +1,89 @@
+import axios from "axios";
+import chalk from "chalk";
+import { CONFIG } from "./config.js";
+import { state } from "./state.js";
+
+/**
+ * API Client
+ * Handles communication with the NPort backend service
+ */
+export class APIClient {
+  static async createTunnel(subdomain, backendUrl = null) {
+    const url = backendUrl || CONFIG.BACKEND_URL;
+    try {
+      const { data } = await axios.post(url, { subdomain });
+
+      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, backendUrl = null) {
+    const url = backendUrl || CONFIG.BACKEND_URL;
+    await axios.delete(url, {
+      data: { subdomain, tunnelId },
+    });
+  }
+
+  static handleError(error, subdomain) {
+    if (error.response?.data?.error) {
+      const errorMsg = error.response.data.error;
+
+      // 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(`nport ${state.port || CONFIG.DEFAULT_PORT} -s ${subdomain}-2\n`) +
+            chalk.gray(`   2. Try a variation:  `) +
+            chalk.cyan(`nport ${state.port || CONFIG.DEFAULT_PORT} -s my-${subdomain}\n`) +
+            chalk.gray(`   3. Use random name:  `) +
+            chalk.cyan(`nport ${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(`nport ${state.port || CONFIG.DEFAULT_PORT} -s ${subdomain}-v2\n`) +
+            chalk.gray(`   2. Use a random subdomain:       `) +
+            chalk.cyan(`nport ${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;
+  }
+}
+

package/src/args.js

@@ -0,0 +1,122 @@
+import { CONFIG } from "./config.js";
+
+/**
+ * Command Line Argument Parser
+ * Handles parsing of CLI arguments for port, subdomain, language, and backend URL
+ */
+export class ArgumentParser {
+  static parse(argv) {
+    const port = this.parsePort(argv);
+    const subdomain = this.parseSubdomain(argv);
+    const language = this.parseLanguage(argv);
+    const backendUrl = this.parseBackendUrl(argv);
+    const setBackend = this.parseSetBackend(argv);
+    return { port, subdomain, language, backendUrl, setBackend };
+  }
+
+  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 parseLanguage(argv) {
+    // Check if --language flag exists without value (to trigger prompt)
+    if (argv.includes('--language') || argv.includes('--lang') || argv.includes('-l')) {
+      const langIndex = argv.indexOf('--language') !== -1 ? argv.indexOf('--language') :
+                        argv.indexOf('--lang') !== -1 ? argv.indexOf('--lang') :
+                        argv.indexOf('-l');
+      
+      // If flag is present but next arg is another flag or doesn't exist, return 'prompt'
+      const nextArg = argv[langIndex + 1];
+      if (!nextArg || nextArg.startsWith('-')) {
+        return 'prompt';
+      }
+    }
+
+    // Try language flag formats: --language=en, --lang=en, -l en
+    const formats = [
+      () => this.findFlagWithEquals(argv, "--language="),
+      () => this.findFlagWithEquals(argv, "--lang="),
+      () => this.findFlagWithEquals(argv, "-l="),
+      () => this.findFlagWithValue(argv, "--language"),
+      () => this.findFlagWithValue(argv, "--lang"),
+      () => this.findFlagWithValue(argv, "-l"),
+    ];
+
+    for (const format of formats) {
+      const language = format();
+      if (language) return language;
+    }
+
+    return null; // No language specified
+  }
+
+  static parseBackendUrl(argv) {
+    // Try backend URL flag formats: --backend=url, --backend url, -b url
+    const formats = [
+      () => this.findFlagWithEquals(argv, "--backend="),
+      () => this.findFlagWithEquals(argv, "-b="),
+      () => this.findFlagWithValue(argv, "--backend"),
+      () => this.findFlagWithValue(argv, "-b"),
+    ];
+
+    for (const format of formats) {
+      const url = format();
+      if (url) return url;
+    }
+
+    return null; // No backend URL specified
+  }
+
+  static parseSetBackend(argv) {
+    // Try set-backend flag formats: --set-backend=url, --set-backend url
+    const formats = [
+      () => this.findFlagWithEquals(argv, "--set-backend="),
+      () => this.findFlagWithValue(argv, "--set-backend"),
+    ];
+
+    for (const format of formats) {
+      const url = format();
+      if (url) return url;
+    }
+
+    // Check if --set-backend flag exists without value (to clear)
+    if (argv.includes('--set-backend')) {
+      return 'clear';
+    }
+
+    return null; // No set-backend specified
+  }
+
+  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)}`;
+  }
+}
+

package/{bin-manager.js → src/bin-manager.js}

@@ -11,7 +11,7 @@ import { fileURLToPath } from "url";
 
 // Fix for __dirname in ES modules
 const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+const __dirname = path.dirname(path.dirname(__filename));
 
 // Binary configuration
 const BIN_DIR = path.join(__dirname, "bin");
@@ -376,3 +376,4 @@ async function main() {
 if (process.argv[1] === __filename) {
   main();
 }
+

package/src/binary.js

@@ -0,0 +1,88 @@
+import { spawn } from "child_process";
+import chalk from "chalk";
+import fs from "fs";
+import { LOG_PATTERNS } from "./config.js";
+import { state } from "./state.js";
+import { UI } from "./ui.js";
+import { lang } from "./lang.js";
+
+/**
+ * Binary Manager
+ * Handles cloudflared binary validation, spawning, and process management
+ */
+export 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();
+      
+      if (count === 1) {
+        console.log(chalk.green(lang.t("connection1")));
+      } else if (count === 4) {
+        console.log(chalk.green(lang.t("connection2")));
+        // Display footer after tunnel is fully active
+        UI.displayFooter(state.updateInfo);
+      }
+      return;
+    }
+
+    // Show critical errors only
+    if (LOG_PATTERNS.ERROR.some((pattern) => msg.includes(pattern))) {
+      console.error(chalk.red(`[Cloudflared] ${msg.trim()}`));
+    }
+  }
+
+  static handleError(err, spinner) {
+    if (spinner) {
+      spinner.fail("Failed to spawn cloudflared process.");
+    }
+    console.error(chalk.red(`Process Error: ${err.message}`));
+  }
+
+  static handleClose(code) {
+    if (code !== 0 && code !== null) {
+      console.log(chalk.red(`Tunnel process exited with code ${code}`));
+    }
+  }
+}
+

package/src/config-manager.js

@@ -0,0 +1,139 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+/**
+ * Configuration Manager
+ * Handles persistent storage of user preferences (backend URL, language, etc.)
+ */
+class ConfigManager {
+  constructor() {
+    this.configDir = path.join(os.homedir(), ".nport");
+    this.configFile = path.join(this.configDir, "config.json");
+    this.oldLangFile = path.join(this.configDir, "lang"); // For migration
+    this.config = this.loadConfig();
+    this.migrateOldConfig();
+  }
+
+  /**
+   * Load configuration from file
+   * @returns {object} Configuration object
+   */
+  loadConfig() {
+    try {
+      if (fs.existsSync(this.configFile)) {
+        const data = fs.readFileSync(this.configFile, "utf8");
+        return JSON.parse(data);
+      }
+    } catch (error) {
+      // If config is corrupted or invalid, return default
+      console.warn("Warning: Could not load config file, using defaults");
+    }
+    return {};
+  }
+
+  /**
+   * Migrate old configuration files to new unified format from version 2.0.5
+   */
+  migrateOldConfig() {
+    try {
+      // Migrate old language file if it exists and no language in config
+      if (!this.config.language && fs.existsSync(this.oldLangFile)) {
+        const oldLang = fs.readFileSync(this.oldLangFile, "utf8").trim();
+        if (oldLang && ["en", "vi"].includes(oldLang)) {
+          this.config.language = oldLang;
+          this.saveConfig();
+          // Optionally delete old file
+          try {
+            fs.unlinkSync(this.oldLangFile);
+          } catch (err) {
+            // Ignore if can't delete
+          }
+        }
+      }
+    } catch (error) {
+      // Ignore migration errors
+    }
+  }
+
+  /**
+   * Save configuration to file
+   */
+  saveConfig() {
+    try {
+      // Ensure .nport directory exists
+      if (!fs.existsSync(this.configDir)) {
+        fs.mkdirSync(this.configDir, { recursive: true });
+      }
+      fs.writeFileSync(this.configFile, JSON.stringify(this.config, null, 2), "utf8");
+      return true;
+    } catch (error) {
+      console.warn("Warning: Could not save configuration");
+      return false;
+    }
+  }
+
+  /**
+   * Get backend URL from config
+   * @returns {string|null} Saved backend URL or null
+   */
+  getBackendUrl() {
+    return this.config.backendUrl || null;
+  }
+
+  /**
+   * Set backend URL in config
+   * @param {string} url - Backend URL to save
+   * @returns {boolean} Success status
+   */
+  setBackendUrl(url) {
+    if (!url) {
+      delete this.config.backendUrl;
+    } else {
+      this.config.backendUrl = url;
+    }
+    return this.saveConfig();
+  }
+
+  /**
+   * Get language from config
+   * @returns {string|null} Saved language code or null
+   */
+  getLanguage() {
+    return this.config.language || null;
+  }
+
+  /**
+   * Set language in config
+   * @param {string} lang - Language code to save (e.g., 'en', 'vi')
+   * @returns {boolean} Success status
+   */
+  setLanguage(lang) {
+    if (!lang) {
+      delete this.config.language;
+    } else {
+      this.config.language = lang;
+    }
+    return this.saveConfig();
+  }
+
+  /**
+   * Get all configuration
+   * @returns {object} All configuration
+   */
+  getAll() {
+    return { ...this.config };
+  }
+
+  /**
+   * Clear all configuration
+   * @returns {boolean} Success status
+   */
+  clear() {
+    this.config = {};
+    return this.saveConfig();
+  }
+}
+
+// Export singleton instance
+export const configManager = new ConfigManager();

package/src/config.js

@@ -0,0 +1,70 @@
+import path from "path";
+import { fileURLToPath } from "url";
+import { createRequire } from "module";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(path.dirname(__filename));
+const require = createRequire(import.meta.url);
+const packageJson = require("../package.json");
+
+// Helper function to get backend URL with priority order
+function getBackendUrl() {
+  // Priority 1: Environment variable
+  if (process.env.NPORT_BACKEND_URL) {
+    return process.env.NPORT_BACKEND_URL;
+  }
+  
+  // Priority 2: Saved config (will be set by config-manager if available)
+  // Priority 3: Default
+  return "https://api.nport.link";
+}
+
+// Application constants
+export const CONFIG = {
+  PACKAGE_NAME: packageJson.name,
+  CURRENT_VERSION: packageJson.version,
+  BACKEND_URL: getBackendUrl(),
+  DEFAULT_PORT: 8080,
+  SUBDOMAIN_PREFIX: "user-",
+  TUNNEL_TIMEOUT_HOURS: 4,
+  UPDATE_CHECK_TIMEOUT: 3000,
+};
+
+// Platform-specific configuration
+export const PLATFORM = {
+  IS_WINDOWS: process.platform === "win32",
+  BIN_NAME: process.platform === "win32" ? "cloudflared.exe" : "cloudflared",
+};
+
+// Paths
+export const PATHS = {
+  BIN_DIR: path.join(__dirname, "bin"),
+  BIN_PATH: path.join(__dirname, "bin", PLATFORM.BIN_NAME),
+};
+
+// Log patterns for filtering cloudflared output
+export 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",
+  ],
+};
+
+// Computed constants
+export const TUNNEL_TIMEOUT_MS = CONFIG.TUNNEL_TIMEOUT_HOURS * 60 * 60 * 1000;
+