nport 2.0.1 → 2.0.3

package/analytics.js

@@ -0,0 +1,259 @@
+// ============================================================================
+// Firebase Analytics for CLI
+// Using Google Analytics 4 Measurement Protocol
+// ============================================================================
+
+import axios from "axios";
+import { createHash, randomUUID } from "crypto";
+import os from "os";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Firebase/GA4 Configuration (from website/home.html)
+// Full Firebase config for reference (if needed for future features)
+const FIREBASE_WEB_CONFIG = {
+  apiKey: "AIzaSyArRxHZJUt4o2RxiLqX1yDSkuUd6ZFy45I",
+  authDomain: "nport-link.firebaseapp.com",
+  projectId: "nport-link",
+  storageBucket: "nport-link.firebasestorage.app",
+  messagingSenderId: "515584605320",
+  appId: "1:515584605320:web:88daabc8d77146c6e7f33d",
+  measurementId: "G-8MYXZL6PGD"
+};
+
+// Analytics-specific config (for GA4 Measurement Protocol)
+const FIREBASE_CONFIG = {
+  measurementId: FIREBASE_WEB_CONFIG.measurementId,
+  apiSecret: process.env.NPORT_ANALYTICS_SECRET || "YOUR_API_SECRET_HERE", // Get from Firebase Console
+};
+
+// Analytics Configuration
+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"),
+};
+
+// ============================================================================
+// Analytics Manager
+// ============================================================================
+
+class AnalyticsManager {
+  constructor() {
+    this.userId = null;
+    this.sessionId = null;
+    this.disabled = false;
+    
+    // Disable analytics if environment variable is set
+    if (process.env.NPORT_ANALYTICS === "false") {
+      this.disabled = true;
+    }
+  }
+
+  /**
+   * Initialize analytics - must be called before tracking
+   */
+  async initialize() {
+    if (this.disabled) return;
+
+    // Check if API secret is configured
+    if (!FIREBASE_CONFIG.apiSecret || FIREBASE_CONFIG.apiSecret === "YOUR_API_SECRET_HERE") {
+      if (ANALYTICS_CONFIG.debug) {
+        console.warn("[Analytics] API secret not configured. Analytics disabled.");
+        console.warn("[Analytics] Set NPORT_ANALYTICS_SECRET environment variable.");
+      }
+      this.disabled = true;
+      return;
+    }
+
+    try {
+      this.userId = await this.getUserId();
+      this.sessionId = this.generateSessionId();
+      
+      if (ANALYTICS_CONFIG.debug) {
+        console.log("[Analytics] Initialized successfully");
+        console.log("[Analytics] User ID:", this.userId.substring(0, 8) + "...");
+      }
+    } catch (error) {
+      if (ANALYTICS_CONFIG.debug) {
+        console.error("[Analytics] Initialization failed:", error.message);
+      }
+      this.disabled = true;
+    }
+  }
+
+  /**
+   * Get or create a persistent user ID
+   */
+  async getUserId() {
+    try {
+      // Try to read existing user ID
+      if (fs.existsSync(ANALYTICS_CONFIG.userIdFile)) {
+        const userId = fs.readFileSync(ANALYTICS_CONFIG.userIdFile, "utf8").trim();
+        if (userId) return userId;
+      }
+
+      // Generate new anonymous user ID
+      const userId = this.generateAnonymousId();
+      
+      // Save for future use
+      fs.writeFileSync(ANALYTICS_CONFIG.userIdFile, userId, "utf8");
+      
+      return userId;
+    } catch (error) {
+      // If file operations fail, use session-based ID
+      return this.generateAnonymousId();
+    }
+  }
+
+  /**
+   * Generate anonymous user ID based on machine characteristics
+   */
+  generateAnonymousId() {
+    const machineId = [
+      os.hostname(),
+      os.platform(),
+      os.arch(),
+      os.homedir(),
+    ].join("-");
+    
+    return createHash("sha256").update(machineId).digest("hex").substring(0, 32);
+  }
+
+  /**
+   * Generate session ID
+   */
+  generateSessionId() {
+    return randomUUID();
+  }
+
+  /**
+   * Track an event
+   */
+  async trackEvent(eventName, params = {}) {
+    if (this.disabled || !ANALYTICS_CONFIG.enabled) return;
+
+    try {
+      const payload = this.buildPayload(eventName, params);
+      
+      // Send to GA4 Measurement Protocol (non-blocking)
+      axios.post(
+        `https://www.google-analytics.com/mp/collect?measurement_id=${FIREBASE_CONFIG.measurementId}&api_secret=${FIREBASE_CONFIG.apiSecret}`,
+        payload,
+        {
+          timeout: ANALYTICS_CONFIG.timeout,
+          headers: { "Content-Type": "application/json" },
+        }
+      ).catch((error) => {
+        // Silently fail - don't interrupt CLI operations
+        if (ANALYTICS_CONFIG.debug) {
+          console.error("[Analytics] Failed to send event:", error.message);
+        }
+      });
+
+      if (ANALYTICS_CONFIG.debug) {
+        console.log("[Analytics] Event tracked:", eventName, params);
+      }
+    } catch (error) {
+      // Silently fail
+      if (ANALYTICS_CONFIG.debug) {
+        console.error("[Analytics] Error tracking event:", error.message);
+      }
+    }
+  }
+
+  /**
+   * Build GA4 Measurement Protocol payload
+   */
+  buildPayload(eventName, params) {
+    return {
+      client_id: this.userId,
+      events: [
+        {
+          name: eventName,
+          params: {
+            session_id: this.sessionId,
+            engagement_time_msec: "100",
+            ...this.getSystemInfo(),
+            ...params,
+          },
+        },
+      ],
+    };
+  }
+
+  /**
+   * Get system information for context
+   */
+  getSystemInfo() {
+    return {
+      os_platform: os.platform(),
+      os_version: os.release(),
+      os_arch: os.arch(),
+      node_version: process.version,
+    };
+  }
+
+  /**
+   * Track CLI start
+   */
+  async trackCliStart(port, subdomain, version) {
+    await this.trackEvent("cli_start", {
+      port: String(port),
+      has_custom_subdomain: subdomain && !subdomain.startsWith("user-"),
+      cli_version: version,
+    });
+  }
+
+  /**
+   * Track tunnel creation
+   */
+  async trackTunnelCreated(subdomain, port) {
+    await this.trackEvent("tunnel_created", {
+      subdomain_type: subdomain.startsWith("user-") ? "random" : "custom",
+      port: String(port),
+    });
+  }
+
+  /**
+   * Track tunnel error
+   */
+  async trackTunnelError(errorType, errorMessage) {
+    await this.trackEvent("tunnel_error", {
+      error_type: errorType,
+      error_message: errorMessage.substring(0, 100), // Limit length
+    });
+  }
+
+  /**
+   * Track tunnel shutdown
+   */
+  async trackTunnelShutdown(reason, durationSeconds) {
+    await this.trackEvent("tunnel_shutdown", {
+      shutdown_reason: reason, // "manual", "timeout", "error"
+      duration_seconds: String(Math.floor(durationSeconds)),
+    });
+  }
+
+  /**
+   * Track CLI update notification shown
+   */
+  async trackUpdateAvailable(currentVersion, latestVersion) {
+    await this.trackEvent("update_available", {
+      current_version: currentVersion,
+      latest_version: latestVersion,
+    });
+  }
+}
+
+// ============================================================================
+// Export singleton instance
+// ============================================================================
+
+export const analytics = new AnalyticsManager();
+

package/index.js

@@ -8,6 +8,7 @@ import fs from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
 import { createRequire } from "module";
+import { analytics } from "./analytics.js";
 
 // ============================================================================
 // Module Setup & Constants
@@ -79,12 +80,16 @@ class TunnelState {
     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) {
@@ -115,6 +120,11 @@ class TunnelState {
     return this.tunnelProcess && !this.tunnelProcess.killed;
   }
 
+  getDurationSeconds() {
+    if (!this.startTime) return 0;
+    return (Date.now() - this.startTime) / 1000;
+  }
+
   reset() {
     this.clearTimeout();
     this.tunnelId = null;
@@ -122,6 +132,7 @@ class TunnelState {
     this.port = null;
     this.tunnelProcess = null;
     this.connectionCount = 0;
+    this.startTime = null;
   }
 }
 
@@ -337,6 +348,11 @@ class VersionManager {
       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,
@@ -352,9 +368,16 @@ class VersionManager {
     const parts1 = v1.split(".").map(Number);
     const parts2 = v2.split(".").map(Number);
 
-    for (let i = 0; i < 3; i++) {
-      if (parts1[i] > parts2[i]) return 1;
-      if (parts1[i] < parts2[i]) return -1;
+    // 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;
@@ -370,6 +393,13 @@ class UI {
     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("║") +
@@ -382,14 +412,14 @@ class UI {
       chalk.yellow("║") +
         chalk.gray(`  Current version: `) +
         chalk.red(`v${updateInfo.current}`) +
-        " ".repeat(26) +
+        " ".repeat(boxWidth - currentVersionText.length) +
         chalk.yellow("║")
     );
     console.log(
       chalk.yellow("║") +
         chalk.gray(`  Latest version:  `) +
         chalk.green(`v${updateInfo.latest}`) +
-        " ".repeat(26) +
+        " ".repeat(boxWidth - latestVersionText.length) +
         chalk.yellow("║")
     );
     console.log(chalk.yellow(`╠${border}╣`));
@@ -397,7 +427,7 @@ class UI {
       chalk.yellow("║") +
         chalk.cyan(`  Run: `) +
         chalk.bold(`npm install -g ${CONFIG.PACKAGE_NAME}@latest`) +
-        " ".repeat(10) +
+        " ".repeat(boxWidth - runCommandText.length) +
         chalk.yellow("║")
     );
     console.log(chalk.yellow(`╚${border}╝\n`));
@@ -498,6 +528,12 @@ 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);
 
@@ -507,6 +543,9 @@ class TunnelOrchestrator {
 
     // 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);
     }
 
@@ -517,6 +556,9 @@ class TunnelOrchestrator {
       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);
 
@@ -532,16 +574,24 @@ class TunnelOrchestrator {
       // Set timeout
       const timeoutId = setTimeout(() => {
         UI.displayTimeoutWarning();
-        this.cleanup();
+        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() {
+  static async cleanup(reason = "manual") {
     state.clearTimeout();
 
     if (!state.hasTunnel()) {
@@ -550,6 +600,10 @@ class TunnelOrchestrator {
 
     UI.displayCleanupStart();
 
+    // Track tunnel shutdown with duration
+    const duration = state.getDurationSeconds();
+    analytics.trackTunnelShutdown(reason, duration);
+
     try {
       // Kill process
       if (state.hasProcess()) {
@@ -563,6 +617,9 @@ class TunnelOrchestrator {
       UI.displayCleanupError();
     }
 
+    // Give analytics a moment to send (non-blocking)
+    await new Promise(resolve => setTimeout(resolve, 100));
+
     process.exit(0);
   }
 }
@@ -586,4 +643,4 @@ process.on("SIGINT", () => TunnelOrchestrator.cleanup());
 process.on("SIGTERM", () => TunnelOrchestrator.cleanup());
 
 // Start application
-main();
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nport",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "Free & open source ngrok alternative - Tunnel HTTP/HTTPS connections via Cloudflare Edge with custom subdomains",
   "type": "module",
   "main": "index.js",
@@ -73,6 +73,7 @@
   },
   "files": [
     "index.js",
+    "analytics.js",
     "bin-manager.js",
     "README.md",
     "LICENSE"