devtunnel-cli 3.0.0

package/src/core/setup-cloudflared.js

@@ -0,0 +1,334 @@
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import https from 'https';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const BIN_DIR = path.join(__dirname, '../../bin');
+const CLOUDFLARED_VERSION = '2024.8.2'; // Latest stable version
+
+// Binary URLs with multiple mirrors for reliability
+const DOWNLOAD_URLS = {
+  win32: [
+    `https://github.com/cloudflare/cloudflared/releases/download/${CLOUDFLARED_VERSION}/cloudflared-windows-amd64.exe`,
+    `https://cloudflared-releases.pages.dev/${CLOUDFLARED_VERSION}/cloudflared-windows-amd64.exe`
+  ],
+  darwin: [
+    `https://github.com/cloudflare/cloudflared/releases/download/${CLOUDFLARED_VERSION}/cloudflared-darwin-amd64`,
+    `https://cloudflared-releases.pages.dev/${CLOUDFLARED_VERSION}/cloudflared-darwin-amd64`
+  ],
+  linux: [
+    `https://github.com/cloudflare/cloudflared/releases/download/${CLOUDFLARED_VERSION}/cloudflared-linux-amd64`,
+    `https://cloudflared-releases.pages.dev/${CLOUDFLARED_VERSION}/cloudflared-linux-amd64`
+  ]
+};
+
+// Get platform display name
+function getPlatformName() {
+  const platform = process.platform;
+  return platform === 'win32' ? 'Windows' : platform === 'darwin' ? 'macOS' : 'Linux';
+}
+
+export function getBinaryPath() {
+  const platform = process.platform;
+  const binName = platform === 'win32' ? 'cloudflared.exe' : 'cloudflared';
+  return path.join(BIN_DIR, platform, binName);
+}
+
+// Check available disk space (basic check)
+function hasEnoughDiskSpace() {
+  try {
+    const stats = fs.statfsSync ? fs.statfsSync(BIN_DIR) : null;
+    if (stats) {
+      const availableSpace = stats.bavail * stats.bsize;
+      const requiredSpace = 50 * 1024 * 1024; // 50MB
+      return availableSpace > requiredSpace;
+    }
+    return true; // Assume OK if we can't check
+  } catch {
+    return true; // Assume OK if check fails
+  }
+}
+
+function downloadFile(url, dest, retryCount = 0) {
+  return new Promise((resolve, reject) => {
+    // Create directory if needed
+    const dir = path.dirname(dest);
+    try {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+    } catch (err) {
+      reject(new Error(`Cannot create directory: ${err.message}`));
+      return;
+    }
+
+    // Create temp file first
+    const tempDest = dest + '.download';
+    const file = fs.createWriteStream(tempDest);
+    
+    const request = https.get(url, { 
+      headers: { 
+        'User-Agent': 'DevTunnel/3.0',
+        'Accept': '*/*'
+      },
+      timeout: 30000 // 30 second timeout
+    }, (response) => {
+      // Follow redirects
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        file.close();
+        fs.unlinkSync(tempDest);
+        downloadFile(response.headers.location, dest, retryCount)
+          .then(resolve)
+          .catch(reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        file.close();
+        fs.unlinkSync(tempDest);
+        reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
+        return;
+      }
+
+      const totalSize = parseInt(response.headers['content-length'], 10);
+      let downloaded = 0;
+      let lastPercent = 0;
+
+      response.on('data', (chunk) => {
+        downloaded += chunk.length;
+        if (totalSize) {
+          const percent = Math.round((downloaded / totalSize) * 100);
+          if (percent !== lastPercent && percent % 5 === 0) {
+            const mb = (downloaded / 1024 / 1024).toFixed(1);
+            const totalMb = (totalSize / 1024 / 1024).toFixed(1);
+            process.stdout.write(`\r⏳ Downloading: ${percent}% (${mb}/${totalMb} MB)`);
+            lastPercent = percent;
+          }
+        }
+      });
+
+      response.pipe(file);
+
+      file.on('finish', () => {
+        file.close(() => {
+          // Move temp file to final destination
+          try {
+            if (fs.existsSync(dest)) {
+              fs.unlinkSync(dest);
+            }
+            fs.renameSync(tempDest, dest);
+            
+            console.log('\n✅ Download complete');
+            
+            // Make executable on Unix-like systems
+            if (process.platform !== 'win32') {
+              try {
+                fs.chmodSync(dest, 0o755);
+                console.log('✅ Permissions set (executable)');
+              } catch (err) {
+                console.log('⚠️  Warning: Could not set executable permissions');
+                console.log('   Run: chmod +x ' + dest);
+              }
+            }
+            
+            // Verify file size
+            const stats = fs.statSync(dest);
+            if (stats.size < 1000000) { // Less than 1MB is suspicious
+              fs.unlinkSync(dest);
+              reject(new Error('Downloaded file is too small (corrupted)'));
+              return;
+            }
+            
+            resolve();
+          } catch (err) {
+            reject(new Error(`Cannot finalize download: ${err.message}`));
+          }
+        });
+      });
+    });
+
+    request.on('timeout', () => {
+      request.destroy();
+      file.close();
+      if (fs.existsSync(tempDest)) fs.unlinkSync(tempDest);
+      reject(new Error('Download timeout (30 seconds)'));
+    });
+
+    request.on('error', (err) => {
+      file.close();
+      if (fs.existsSync(tempDest)) fs.unlinkSync(tempDest);
+      reject(err);
+    });
+
+    file.on('error', (err) => {
+      file.close();
+      if (fs.existsSync(tempDest)) fs.unlinkSync(tempDest);
+      reject(new Error(`File write error: ${err.message}`));
+    });
+  });
+}
+
+// Try downloading from multiple URLs with retries
+async function downloadWithRetry(urls, dest, maxRetries = 3) {
+  for (let urlIndex = 0; urlIndex < urls.length; urlIndex++) {
+    const url = urls[urlIndex];
+    console.log(`📥 Source: ${urlIndex === 0 ? 'GitHub' : 'Mirror'} (${urlIndex + 1}/${urls.length})`);
+    
+    for (let retry = 0; retry < maxRetries; retry++) {
+      try {
+        if (retry > 0) {
+          console.log(`🔄 Retry ${retry}/${maxRetries - 1}...`);
+          await new Promise(resolve => setTimeout(resolve, 2000)); // Wait 2s before retry
+        }
+        
+        await downloadFile(url, dest, retry);
+        return true; // Success!
+        
+      } catch (err) {
+        const isLastRetry = retry === maxRetries - 1;
+        const isLastUrl = urlIndex === urls.length - 1;
+        
+        if (err.message.includes('ENOTFOUND') || err.message.includes('ECONNREFUSED')) {
+          console.log(`\n❌ Network error: ${err.message}`);
+        } else if (err.message.includes('timeout')) {
+          console.log(`\n❌ Download timeout`);
+        } else {
+          console.log(`\n❌ Error: ${err.message}`);
+        }
+        
+        if (isLastRetry && isLastUrl) {
+          throw new Error(`All download attempts failed: ${err.message}`);
+        }
+        
+        if (isLastRetry) {
+          console.log('💡 Trying alternative source...\n');
+          break; // Try next URL
+        }
+      }
+    }
+  }
+  
+  throw new Error('All download sources failed');
+}
+
+export async function setupCloudflared() {
+  const platform = process.platform;
+  const binaryPath = getBinaryPath();
+  
+  console.log('\n╔════════════════════════════════════════╗');
+  console.log('║   📦 Cloudflare Setup (First Run)    ║');
+  console.log('╚════════════════════════════════════════╝\n');
+  
+  // Check if binary already exists
+  if (fs.existsSync(binaryPath)) {
+    try {
+      // Verify it works
+      const testProc = spawn(binaryPath, ['--version'], { shell: true, stdio: 'pipe' });
+      const works = await new Promise((resolve) => {
+        testProc.on('close', (code) => resolve(code === 0));
+        testProc.on('error', () => resolve(false));
+        setTimeout(() => resolve(false), 5000);
+      });
+      
+      if (works) {
+        console.log('✅ Cloudflare already installed and working\n');
+        return binaryPath;
+      } else {
+        console.log('⚠️  Existing binary not working, re-downloading...\n');
+        fs.unlinkSync(binaryPath);
+      }
+    } catch {
+      console.log('⚠️  Existing binary corrupted, re-downloading...\n');
+      try {
+        fs.unlinkSync(binaryPath);
+      } catch {}
+    }
+  }
+
+  const urls = DOWNLOAD_URLS[platform];
+  if (!urls) {
+    console.error(`❌ ERROR: Platform "${platform}" not supported`);
+    console.error('   Supported: Windows, macOS, Linux\n');
+    return null;
+  }
+
+  console.log(`🖥️  Platform: ${getPlatformName()}`);
+  console.log(`📍 Install to: ${binaryPath}`);
+  console.log(`📊 Size: ~40 MB\n`);
+  
+  // Check disk space
+  if (!hasEnoughDiskSpace()) {
+    console.error('❌ ERROR: Not enough disk space (need 50+ MB)\n');
+    return null;
+  }
+  
+  // Check write permissions
+  try {
+    const dir = path.dirname(binaryPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const testFile = path.join(dir, '.write-test');
+    fs.writeFileSync(testFile, 'test');
+    fs.unlinkSync(testFile);
+  } catch (err) {
+    console.error('❌ ERROR: Cannot write to installation directory');
+    console.error(`   Location: ${path.dirname(binaryPath)}`);
+    console.error(`   Reason: ${err.message}\n`);
+    return null;
+  }
+  
+  console.log('📥 Starting download...\n');
+  
+  try {
+    await downloadWithRetry(urls, binaryPath);
+    
+    // Final verification
+    console.log('\n🔍 Verifying installation...');
+    const testProc = spawn(binaryPath, ['--version'], { shell: true, stdio: 'pipe' });
+    const works = await new Promise((resolve) => {
+      testProc.on('close', (code) => resolve(code === 0));
+      testProc.on('error', () => resolve(false));
+      setTimeout(() => resolve(false), 5000);
+    });
+    
+    if (works) {
+      console.log('✅ Verification successful!');
+      console.log('✅ Cloudflare ready to use\n');
+      return binaryPath;
+    } else {
+      console.error('❌ Downloaded binary not working properly');
+      try {
+        fs.unlinkSync(binaryPath);
+      } catch {}
+      return null;
+    }
+    
+  } catch (err) {
+    console.error('\n╔════════════════════════════════════════╗');
+    console.error('║   ❌ Installation Failed              ║');
+    console.error('╚════════════════════════════════════════╝\n');
+    console.error(`Reason: ${err.message}\n`);
+    
+    console.log('💡 Troubleshooting:');
+    console.log('   1. Check internet connection');
+    console.log('   2. Check firewall/antivirus settings');
+    console.log('   3. Try again later');
+    console.log('   4. Install manually: https://github.com/cloudflare/cloudflared/releases\n');
+    
+    console.log('🔄 DevTunnel will use fallback tunnels (Ngrok/LocalTunnel)\n');
+    
+    return null;
+  }
+}
+
+// Check if bundled cloudflared exists and is working
+export function hasBundledCloudflared() {
+  const binaryPath = getBinaryPath();
+  return fs.existsSync(binaryPath);
+}

package/src/core/start.js

@@ -0,0 +1,200 @@
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { join, dirname, basename } from "path";
+import { fileURLToPath } from "url";
+import prompts from "prompts";
+import { selectFolder } from "../utils/folder-picker.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Get project root directory dynamically (two levels up from src/core/)
+const PROJECT_ROOT = dirname(dirname(__dirname));
+
+// Helper to run command
+function runCommand(command, args = [], cwd = process.cwd()) {
+  return new Promise((resolve) => {
+    const proc = spawn(command, args, { 
+      shell: true, 
+      stdio: "pipe",
+      cwd: cwd
+    });
+    let output = "";
+    
+    proc.stdout?.on("data", (data) => output += data.toString());
+    proc.stderr?.on("data", (data) => output += data.toString());
+    
+    proc.on("close", (code) => resolve({ code, output }));
+    proc.on("error", () => resolve({ code: 1, output: "" }));
+  });
+}
+
+// Check if command exists
+async function commandExists(command) {
+  const result = await runCommand("where", [command]);
+  return result.code === 0;
+}
+
+// Main function
+async function main() {
+  console.clear();
+  console.log("\n╔════════════════════════════════════════════╗");
+  console.log("║                                            ║");
+  console.log("║           🚀 DevTunnel v3.0               ║");
+  console.log("║                                            ║");
+  console.log("║      Share local servers worldwide         ║");
+  console.log("║                                            ║");
+  console.log("╚════════════════════════════════════════════╝\n");
+
+  // Step 1: Check Node.js
+  console.log("[1/4] Checking Node.js...");
+  if (!await commandExists("node")) {
+    console.log("❌ ERROR: Node.js not found!");
+    console.log("Install from: https://nodejs.org/");
+    process.exit(1);
+  }
+  console.log("✅ SUCCESS: Node.js installed\n");
+
+  // Step 2: Check Cloudflare (bundled or system-installed)
+  console.log("[2/4] Checking Cloudflare...");
+  
+  // Import bundled cloudflared helpers
+  const { setupCloudflared, hasBundledCloudflared } = await import("./setup-cloudflared.js");
+  
+  let cloudflareAvailable = false;
+  
+  if (hasBundledCloudflared()) {
+    console.log("✅ SUCCESS: Using bundled Cloudflare (no install needed)");
+    cloudflareAvailable = true;
+  } else if (await commandExists("cloudflared")) {
+    console.log("✅ SUCCESS: Cloudflare installed on system");
+    cloudflareAvailable = true;
+  } else {
+    console.log("📦 First time setup - Downloading Cloudflare...");
+    console.log("💡 This only happens once (~40MB, 10-30 seconds)\n");
+    
+    try {
+      const bundledPath = await setupCloudflared();
+      
+      if (bundledPath) {
+        console.log("✅ SUCCESS: Cloudflare ready to use");
+        cloudflareAvailable = true;
+      } else {
+        console.log("⚠️  Could not download Cloudflare");
+        console.log("🔄 Will use alternative tunnel services\n");
+      }
+    } catch (err) {
+      console.log(`⚠️  Setup error: ${err.message}`);
+      console.log("🔄 Will use alternative tunnel services\n");
+    }
+  }
+  
+  // Show what's available
+  if (!cloudflareAvailable) {
+    console.log("💡 DevTunnel has multi-service fallback:");
+    console.log("   → Cloudflare (fastest, no password)");
+    console.log("   → Ngrok (fast alternative)");
+    console.log("   → LocalTunnel (backup option)");
+    console.log("");
+  }
+
+  // Step 3: Check dependencies
+  console.log("[3/4] Checking dependencies...");
+  const nodeModulesPath = join(PROJECT_ROOT, "node_modules");
+  if (!existsSync(nodeModulesPath)) {
+    console.log("📦 Installing dependencies...\n");
+    // Run npm install in the project root directory
+    const result = await runCommand("npm", ["install"], PROJECT_ROOT);
+    if (result.code !== 0) {
+      console.log("\n❌ ERROR: npm install failed");
+      process.exit(1);
+    }
+    console.log("\n✅ SUCCESS: Dependencies installed");
+  } else {
+    console.log("✅ SUCCESS: Dependencies already installed");
+  }
+  console.log("");
+
+  // Step 4: Select folder using native OS dialog
+  console.log("[4/4] Select your project folder...");
+  console.log("⏳ Opening folder picker...\n");
+  
+  const projectPath = await selectFolder();
+  
+  if (!projectPath || projectPath.length === 0) {
+    console.log("❌ ERROR: No folder selected");
+    process.exit(1);
+  }
+  
+  const projectName = basename(projectPath);
+  console.log(`✅ Selected: ${projectPath}\n`);
+
+  // Get port
+  const portResponse = await prompts({
+    type: "number",
+    name: "port",
+    message: "Enter your dev server port:",
+    initial: 5173
+  });
+  
+  if (!portResponse.port) {
+    console.log("❌ ERROR: No port entered");
+    process.exit(1);
+  }
+  
+  const devPort = portResponse.port;
+  const proxyPort = devPort + 1000; // Use port 1000 higher for proxy
+
+  console.log("\n╔════════════════════════════════════════════╗");
+  console.log("║           🔧 Configuration                ║");
+  console.log("╠════════════════════════════════════════════╣");
+  console.log(`║  📦 Project: ${projectName.padEnd(28)} ║`);
+  console.log(`║  🎯 Dev Server: localhost:${devPort.toString().padEnd(17)} ║`);
+  console.log(`║  🔌 Proxy Port: ${proxyPort.toString().padEnd(28)} ║`);
+  console.log("╚════════════════════════════════════════════╝\n");
+
+  // Start proxy server
+  console.log("⚡ Starting services...\n");
+  const proxyPath = join(__dirname, "proxy-server.js");
+  const proxyProcess = spawn("node", [proxyPath, devPort.toString(), proxyPort.toString(), projectName], {
+    stdio: "inherit",
+    shell: false
+  });
+
+  // Wait for proxy to start
+  await new Promise(resolve => setTimeout(resolve, 2000));
+
+  // Run main tunnel app (connects to proxy port)
+  // Use shell: false to properly handle paths with spaces
+  const indexPath = join(__dirname, "index.js");
+  const tunnelProcess = spawn("node", [indexPath, proxyPort.toString(), projectName, projectPath], {
+    stdio: "inherit",
+    shell: false
+  });
+
+  // Handle cleanup
+  const cleanup = () => {
+    console.log("\n🛑 Shutting down...");
+    proxyProcess.kill();
+    tunnelProcess.kill();
+    process.exit(0);
+  };
+
+  tunnelProcess.on("close", (code) => {
+    cleanup();
+  });
+
+  proxyProcess.on("close", () => {
+    cleanup();
+  });
+
+  // Handle Ctrl+C
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+}
+
+// Run
+main().catch((error) => {
+  console.error("\n❌ ERROR:", error.message);
+  process.exit(1);
+});

package/src/utils/folder-picker.js

@@ -0,0 +1,140 @@
+import { spawn } from "child_process";
+import { platform } from "os";
+import { writeFileSync, readFileSync, unlinkSync, existsSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+// Cross-platform native folder picker
+export async function selectFolder() {
+  const os = platform();
+  const tempFile = join(tmpdir(), `folder-picker-${Date.now()}.txt`);
+  
+  try {
+    if (os === "win32") {
+      // Windows - Use MODERN OpenFileDialog (like website file uploads)
+      const script = `
+        Add-Type -AssemblyName System.Windows.Forms
+        [System.Windows.Forms.Application]::EnableVisualStyles()
+        
+        $dialog = New-Object System.Windows.Forms.OpenFileDialog
+        $dialog.Title = "Select your project folder"
+        $dialog.Filter = "All files (*.*)|*.*"
+        $dialog.CheckFileExists = $false
+        $dialog.CheckPathExists = $true
+        $dialog.ValidateNames = $false
+        $dialog.FileName = "Folder Selection"
+        $dialog.Multiselect = $false
+        $dialog.InitialDirectory = [Environment]::GetFolderPath("UserProfile")
+        
+        $result = $dialog.ShowDialog()
+        if ($result -eq [System.Windows.Forms.DialogResult]::OK) {
+          $folderPath = Split-Path -Parent $dialog.FileName
+          if (-not $folderPath) {
+            $folderPath = $dialog.FileName
+          }
+          $folderPath | Out-File -FilePath "${tempFile.replace(/\\/g, '\\\\')}" -Encoding UTF8 -NoNewline
+        }
+      `;
+      
+      await runPowerShell(script);
+      
+    } else if (os === "darwin") {
+      // macOS - Use osascript
+      const script = `
+        set folderPath to choose folder with prompt "Select your project folder"
+        set posixPath to POSIX path of folderPath
+        do shell script "echo " & quoted form of posixPath & " > '${tempFile}'"
+      `;
+      
+      await runCommand("osascript", ["-e", script]);
+      
+    } else {
+      // Linux - Try zenity first, then kdialog
+      try {
+        await runCommand("zenity", [
+          "--file-selection",
+          "--directory",
+          "--title=Select your project folder"
+        ], tempFile);
+      } catch {
+        await runCommand("kdialog", [
+          "--getexistingdirectory",
+          process.env.HOME || "/",
+          "--title", "Select your project folder"
+        ], tempFile);
+      }
+    }
+    
+    // Read the selected folder
+    if (existsSync(tempFile)) {
+      const folderPath = readFileSync(tempFile, "utf8").trim();
+      unlinkSync(tempFile);
+      return folderPath;
+    }
+    
+    return null;
+    
+  } catch (error) {
+    console.error("Folder picker error:", error.message);
+    return null;
+  }
+}
+
+// Run PowerShell command
+function runPowerShell(script) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn("powershell", [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy", "Bypass",
+      "-Command", script
+    ], { 
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: false
+    });
+    
+    let stderr = "";
+    proc.stderr?.on("data", (data) => stderr += data.toString());
+    
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(stderr || `PowerShell exited with code ${code}`));
+      }
+    });
+    
+    proc.on("error", reject);
+  });
+}
+
+// Run generic command
+function runCommand(command, args, outputFile) {
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, args, { 
+      stdio: outputFile ? ["ignore", "pipe", "pipe"] : "pipe",
+      shell: true
+    });
+    
+    let stdout = "";
+    
+    if (outputFile) {
+      proc.stdout?.on("data", (data) => {
+        stdout += data.toString();
+      });
+    }
+    
+    proc.on("close", (code) => {
+      if (code === 0) {
+        if (outputFile && stdout) {
+          writeFileSync(outputFile, stdout.trim());
+        }
+        resolve();
+      } else {
+        reject(new Error(`Command failed with code ${code}`));
+      }
+    });
+    
+    proc.on("error", reject);
+  });
+}