9remote 0.1.52 → 0.1.53

package/cli/index.js

@@ -8,48 +8,12 @@ import path from "path";
 import { fileURLToPath } from "url";
 import fs from "fs";
 import os from "os";
-import dns from "dns";
-import https from "https";
-import { promisify } from "util";
 import { getConsistentMachineId } from "./utils/machineId.js";
 import { generateApiKeyWithMachine } from "./utils/apiKey.js";
 import { loadKey, saveKey, loadState, saveState, clearState } from "./utils/state.js";
 import { createTempKey } from "./utils/token.js";
 import { checkAndUpdate } from "./utils/updateChecker.js";
-import { ensureCloudflared, spawnCloudflared, killCloudflared, resetRestartCounter } from "./utils/cloudflared.js";
-
-// DNS resolver using Cloudflare — ensures tunnel domains resolve immediately
-const cfResolver = new dns.Resolver();
-cfResolver.setServers(["1.1.1.1", "1.0.0.1"]);
-const cfResolve4 = promisify(cfResolver.resolve4.bind(cfResolver));
-
-/** Fetch via IP with correct TLS SNI — bypasses system DNS */
-function fetchWithCfDns(url, timeoutMs = 5000) {
-  return new Promise(async (resolve, reject) => {
-    try {
-      const parsed = new URL(url);
-      const [ip] = await cfResolve4(parsed.hostname);
-      const req = https.request({
-        hostname: ip,
-        port: 443,
-        path: parsed.pathname + parsed.search,
-        method: "GET",
-        headers: { host: parsed.hostname },
-        servername: parsed.hostname,
-        rejectUnauthorized: true
-      }, (res) => {
-        let body = "";
-        res.on("data", d => { body += d; });
-        res.on("end", () => resolve({ ok: res.statusCode >= 200 && res.statusCode < 300, status: res.statusCode, body }));
-      });
-      req.setTimeout(timeoutMs, () => { req.destroy(); reject(new Error("timeout")); });
-      req.on("error", reject);
-      req.end();
-    } catch (err) {
-      reject(err);
-    }
-  });
-}
+import { spawnQuickTunnel, killCloudflared, resetRestartCounter } from "./utils/cloudflared.js";
 
 // Parse --skip-update flag
 const skipUpdate = process.argv.includes("--skip-update");
@@ -62,7 +26,6 @@ const STANDALONE_SERVER = path.resolve(__dirname, "../dist/server.cjs");
 const DEV_SERVER = path.resolve(__dirname, "../index.js");
 const WORKER_URL = "https://9remote.cc";
 const SERVER_PORT = 2208;
-const SHORT_ID_CHARS = "abcdefghijklmnpqrstuvwxyz23456789";
 const MAX_RESTART_ATTEMPTS = 10;
 const RESTART_WINDOW_MS = 60000; // 1 minute
 
@@ -125,17 +88,6 @@ function showBanner() {
   console.log("");
 }
 
-/**
- * Generate short random ID for tunnel subdomain
- */
-function generateShortId() {
-  let result = "";
-  for (let i = 0; i < 6; i++) {
-    result += SHORT_ID_CHARS.charAt(Math.floor(Math.random() * SHORT_ID_CHARS.length));
-  }
-  return result;
-}
-
 /**
  * Helper: Show QR code for connect URL
  */
@@ -165,12 +117,15 @@ async function showConnectionInfo(selectedKey, tunnelUrl) {
   const connectUrl = `${WORKER_URL}/login?k=${tempKeyData.tempKey}`;
   const width = Math.min(44, process.stdout.columns || 55);
 
-  // Push ready state to UI
+  // Push ready state to UI (include permanentKey, expiresAt, workerUrl for server-side key generation)
   pushUiState({
     step: 3,
     tunnelUrl,
     oneTimeKey: tempKeyData.tempKey,
+    oneTimeKeyExpiresAt: tempKeyData.expiresAt,
+    permanentKey: selectedKey,
     qrUrl: connectUrl,
+    workerUrl: WORKER_URL,
   });
 
   showQRCode(connectUrl);
@@ -237,11 +192,15 @@ function startServerWithRestart(onReady, onServerCrash) {
       process.exit(1);
     }
     
+    // Strip NODE_ENV=development when running standalone server (production build)
+    const spawnEnv = { ...process.env, PORT: String(SERVER_PORT) };
+    if (!useDevServer) delete spawnEnv.NODE_ENV;
+
     currentProcess = spawn("node", [serverPath], {
       cwd: path.dirname(serverPath),
       stdio: ["ignore", "inherit", "inherit"],
       detached: false,
-      env: { ...process.env, PORT: String(SERVER_PORT) }
+      env: spawnEnv,
     });
     
 
@@ -342,25 +301,6 @@ function getLanIp() {
   return null;
 }
 
-/**
- * Helper: Create Named Tunnel via Worker API
- */
-async function createNamedTunnel(apiKey) {
-  const response = await fetch(`${WORKER_URL}/api/tunnel/create`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ apiKey })
-  });
-
-  if (!response.ok) {
-    const error = await response.json();
-    throw new Error(error.error || "Failed to create tunnel");
-  }
-
-  const data = await response.json();
-  return data;
-}
-
 /** Push UI state to server via HTTP */
 async function pushUiState(data) {
   try {
@@ -373,7 +313,25 @@ async function pushUiState(data) {
 }
 
 /**
- * Helper: Start server and tunnel
+ * Update session tunnelUrl on worker + push to UI
+ */
+async function updateTunnelUrl(selectedKey, tunnelUrl) {
+  const lanIp = getLanIp();
+  try {
+    await fetch(`${WORKER_URL}/api/session/update`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        apiKey: selectedKey,
+        tunnelUrl,
+        localIp: lanIp ? `${lanIp}:${SERVER_PORT}` : null
+      })
+    });
+  } catch { }
+}
+
+/**
+ * Helper: Start server and quick tunnel
  */
 async function startServerAndTunnel(selectedKey) {
   console.log(ORANGE("\n🚀 Starting server..."));
@@ -382,193 +340,65 @@ async function startServerAndTunnel(selectedKey) {
   // Kill existing cloudflared process
   try {
     killCloudflared();
-    await new Promise(resolve => setTimeout(resolve, 1000));
+    await new Promise(resolve => setTimeout(resolve, 500));
   } catch { }
 
-  // Reuse existing shortId or generate new one
-  const existingState = loadState();
-  const shortId = existingState?.shortId || generateShortId();
-
-  // Create session first
+  // Create session on worker
   try {
     const sessionResponse = await fetch(`${WORKER_URL}/api/session/create`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ apiKey: selectedKey, shortId })
+      body: JSON.stringify({ apiKey: selectedKey })
     });
-    
     if (!sessionResponse.ok) {
       const text = await sessionResponse.text();
-      console.log(chalk.red(`❌ Failed to create session: ${sessionResponse.status} ${sessionResponse.statusText}`));
-      console.log(chalk.yellow(`Response: ${text.substring(0, 200)}`));
+      console.log(chalk.red(`❌ Failed to create session: ${sessionResponse.status} ${text.substring(0, 200)}`));
       return null;
     }
-    
-    const sessionData = await sessionResponse.json();
   } catch (error) {
     console.log(chalk.red(`❌ Failed to create session: ${error.message}`));
     return null;
   }
 
-  // tunnelProcess declared here so the serverManager crash callback can reference it
-  let tunnelProcess = null;
-
   // Skip spawning server if already running (e.g. nodemon in dev mode)
   const alreadyRunning = await isServerRunning();
-
-  // Start server with auto-restart (skip if already running)
   const serverManager = alreadyRunning
     ? { getProcess: () => null, shutdown: () => {} }
-    : startServerWithRestart(null, async () => {
-    // Callback khi server crash - đợi server ready rồi gửi SIGHUP
-    
-    if (!tunnelProcess) {
-      return;
-    }
-    
-    // Wait for server to be ready
-    const maxWait = 60000; // 60s
-    const checkInterval = 1000; // 1s
-    const maxRetries = Math.floor(maxWait / checkInterval);
-    let serverReady = false;
-    
-    for (let i = 0; i < maxRetries; i++) {
-      try {
-        const response = await fetch(`http://localhost:${SERVER_PORT}/api/health`, {
-          method: "GET",
-          timeout: 2000
-        });
-        
-        if (response.ok) {
-          const data = await response.json();
-          if (data.status === "ok") {
-            serverReady = true;
-            console.log(chalk.green(`✅ Server ready after ${i + 1}s`));
-            break;
-          }
-        }
-      } catch (err) {
-        // Server not ready yet
-      }
-      
-      if (i % 5 === 0) {
-      }
-      
-      await new Promise(resolve => setTimeout(resolve, checkInterval));
-    }
-    
-    if (!serverReady) {
-      console.log(chalk.red("❌ Server not ready after 60s - skipping tunnel reconnect"));
-      return;
-    }
-    
-    // Server ready - send SIGHUP to cloudflared to reconnect
-    try {
-      process.kill(tunnelProcess.pid, "SIGHUP");
-      console.log(chalk.green("✅ SIGHUP sent - cloudflared should reconnect"));
-    } catch (err) {      
-      // Fallback: kill and restart
-      try {
-        tunnelProcess.kill();
-        await new Promise(resolve => setTimeout(resolve, 1000));
-        tunnelProcess = await startTunnel(token);
-        console.log(chalk.green("✅ Tunnel restarted"));
-      } catch (restartErr) {
-        console.log(chalk.red(`❌ Failed to restart tunnel: ${restartErr.message}`));
-      }
-    }
-  });
+    : startServerWithRestart(null, null);
 
-  // Wait for server to start (skip if already running)
-  if (!alreadyRunning) await new Promise((resolve) => setTimeout(resolve, 2000));
+  if (!alreadyRunning) await new Promise(resolve => setTimeout(resolve, 2000));
 
-  console.log(ORANGE("✅ Creating tunnel..."));
+  console.log(ORANGE("✅ Starting tunnel..."));
   pushUiState({ step: 2 });
 
-  // Ensure cloudflared binary
-  try {
-    await ensureCloudflared();
-  } catch (error) {
-    console.log(chalk.red(`❌ Failed to install cloudflared: ${error.message}`));
-    serverManager.shutdown();
-    return null;
-  }
-
-  // Create Named Tunnel via Worker API
-  let tunnelData;
+  // Spawn quick tunnel — URL comes directly from cloudflared stdout
+  let tunnelProcess, tunnelUrl;
   try {
-    tunnelData = await createNamedTunnel(selectedKey);
-    console.log(ORANGE(`✅ Tunnel ID: ${tunnelData.tunnelId}`));
+    const result = await spawnQuickTunnel(SERVER_PORT, async (newUrl) => {
+      // URL rotated — update worker + UI
+      console.log(ORANGE(`🔄 Tunnel URL rotated: ${newUrl}`));
+      await updateTunnelUrl(selectedKey, newUrl);
+      pushUiState({ tunnelUrl: newUrl });
+    });
+    tunnelProcess = result.child;
+    tunnelUrl = result.tunnelUrl;
   } catch (error) {
-    console.log(chalk.red(`❌ Failed to create tunnel: ${error.message}`));
-    serverManager.shutdown();
-    return null;
-  }
-
-  const { token, hostname: tunnelUrl } = tunnelData;
-
-  // Spawn cloudflared with token and auto-restart callback
-  console.log(ORANGE("✅ Starting tunnel..."));
-  
-  const startTunnel = async (tunnelToken) => {
-    try {
-      tunnelProcess = await spawnCloudflared(tunnelToken, startTunnel);
-      return tunnelProcess;
-    } catch (error) {
-      console.log(chalk.red(`❌ Failed to start cloudflared: ${error.message}`));
-      return null;
-    }
-  };
-  
-  tunnelProcess = await startTunnel(token);
-  if (!tunnelProcess) {
+    console.log(chalk.red(`❌ Failed to start tunnel: ${error.message}`));
     serverManager.shutdown();
     return null;
   }
 
-  // Verify tunnel reachable via Cloudflare DNS + https.request (bypasses system DNS)
-  const spinners = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-  let tunnelReady = false;
-  for (let i = 0; i < 30; i++) {
-    try {
-      const res = await fetchWithCfDns(`${tunnelUrl}/api/health`);
-      if (res.ok) { tunnelReady = true; break; }
-    } catch { }
-    process.stdout.write(`\r   Verifying tunnel ${spinners[i % spinners.length]} (${i * 2}s)`);
-    await new Promise(r => setTimeout(r, 2000));
-  }
-  process.stdout.write("\r" + " ".repeat(40) + "\r");
-
-  if (!tunnelReady) {
-    console.log(chalk.red("❌ Tunnel not reachable from outside"));
-    serverManager.shutdown();
-    tunnelProcess.kill();
-    return null;
-  }
-
   console.log(ORANGE(`✅ Tunnel URL: ${tunnelUrl}`));
-  const lanIpLog = getLanIp();
-  if (lanIpLog) console.log(ORANGE(`✅ Local IP: ${lanIpLog}:${SERVER_PORT} (LAN direct available)`));
+  const lanIp = getLanIp();
+  if (lanIp) console.log(ORANGE(`✅ Local IP: ${lanIp}:${SERVER_PORT} (LAN direct available)`));
   console.log(ORANGE(`✅ Connection established`));
 
-  // Update session with tunnelUrl + localIp (worker detects publicIp via CF-Connecting-IP)
-  const lanIp = lanIpLog;
-  try {
-    await fetch(`${WORKER_URL}/api/session/update`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        apiKey: selectedKey,
-        tunnelUrl,
-        localIp: lanIp ? `${lanIp}:${SERVER_PORT}` : null
-      })
-    });
-  } catch { }
+  // Save tunnelUrl to worker DB
+  await updateTunnelUrl(selectedKey, tunnelUrl);
 
-  // Save state (persist shortId for reuse on restart)
+  // Save local state
   saveState({
     apiKey: selectedKey,
-    shortId,
     tunnelUrl,
     serverPid: serverManager.getProcess()?.pid,
     tunnelPid: tunnelProcess.pid
@@ -756,6 +586,7 @@ async function autoStartDev() {
 
   await showConnectionInfo(keyData.key, tunnelUrl);
   setupExitHandler(serverManager, tunnelProcess, keyData.key);
+  setupKeyRegenListener();
 
   // Push stats to UI every 5s
   const startTime = Date.now();
@@ -770,6 +601,20 @@ async function autoStartDev() {
 }
 
 
+/**
+ * Listen for key regen request from server UI
+ */
+function setupKeyRegenListener() {
+  process.on("9remote:regenerate-key", async () => {
+    const machineId = await getConsistentMachineId();
+    const { key } = generateApiKeyWithMachine(machineId);
+    const existing = loadKey();
+    saveKey(machineId, key, existing?.name || "Default");
+    pushUiState({ permanentKey: key });
+    console.log(chalk.green(`✅ Key regenerated: ${key}`));
+  });
+}
+
 /**
  * Check if server is already running on SERVER_PORT
  */
@@ -813,6 +658,7 @@ async function startUiMode() {
   console.log(chalk.green(`\n🌐 UI ready at ${url}`));
 
   setupExitHandler(serverManager, tunnelProcess, keyData.key);
+  setupKeyRegenListener();
 
   // Push stats to UI every 5s
   const startTime = Date.now();

package/cli/utils/cloudflared.js

@@ -163,6 +163,112 @@ const LOG_IGNORE = [
   "Updated to new configuration"
 ];
 
+/**
+ * Parse trycloudflare.com URL from cloudflared log output
+ */
+function parseQuickTunnelUrl(message) {
+  const regex = /https:\/\/([a-z0-9-]+)\.trycloudflare\.com/gi;
+  const candidates = [];
+  for (const match of message.matchAll(regex)) {
+    if (match[1] === "api") continue;
+    candidates.push(`https://${match[1]}.trycloudflare.com`);
+  }
+  return candidates.length ? candidates[candidates.length - 1] : null;
+}
+
+/**
+ * Spawn cloudflared quick tunnel (no account needed)
+ * @param {number} localPort - Local port to tunnel
+ * @param {Function} onUrlUpdate - Called when URL changes after initial connect
+ * @returns {Promise<{child, tunnelUrl}>}
+ */
+export async function spawnQuickTunnel(localPort, onUrlUpdate = null) {
+  const binaryPath = await ensureCloudflared();
+
+  // Use temp config to avoid conflicting with ~/.cloudflared/config.yml
+  const configDir = fs.mkdtempSync(path.join(os.tmpdir(), "9remote-quick-"));
+  const configPath = path.join(configDir, "config.yml");
+  fs.writeFileSync(configPath, "# quick-tunnel\n", "utf8");
+
+  let cleaned = false;
+  const cleanup = () => {
+    if (cleaned) return;
+    cleaned = true;
+    try { fs.rmSync(configDir, { recursive: true, force: true }); } catch { }
+  };
+
+  const child = spawn(
+    binaryPath,
+    ["tunnel", "--url", `http://localhost:${localPort}`, "--config", configPath, "--no-autoupdate"],
+    { detached: false, windowsHide: true, stdio: ["ignore", "pipe", "pipe"] }
+  );
+
+  fs.writeFileSync(PID_FILE, child.pid.toString());
+  isIntentionalShutdown = false;
+
+  return new Promise((resolve, reject) => {
+    let resolved = false;
+    let lastUrl = null;
+
+    const timeout = setTimeout(() => {
+      if (resolved) return;
+      resolved = true;
+      cleanup();
+      reject(new Error("Quick tunnel timed out after 90s"));
+    }, 90000);
+
+    const handleLog = (data) => {
+      const msg = data.toString();
+      const tunnelUrl = parseQuickTunnelUrl(msg);
+      if (!tunnelUrl) return;
+
+      if (!resolved) {
+        resolved = true;
+        lastUrl = tunnelUrl;
+        clearTimeout(timeout);
+        cleanup();
+        resolve({ child, tunnelUrl });
+        return;
+      }
+
+      // URL rotated after initial connect — notify caller
+      if (tunnelUrl !== lastUrl) {
+        lastUrl = tunnelUrl;
+        onUrlUpdate?.(tunnelUrl);
+      }
+    };
+
+    child.stdout.on("data", handleLog);
+    child.stderr.on("data", handleLog);
+
+    child.on("error", (err) => {
+      if (resolved) return;
+      resolved = true;
+      clearTimeout(timeout);
+      cleanup();
+      reject(err);
+    });
+
+    child.on("exit", (code) => {
+      cleanup();
+      if (!resolved) {
+        resolved = true;
+        clearTimeout(timeout);
+        reject(new Error(`cloudflared exited with code ${code}`));
+        return;
+      }
+      if (!isIntentionalShutdown && restartCallback) {
+        const now = Date.now();
+        restartTimes.push(now);
+        restartTimes = restartTimes.filter(t => t > now - RESTART_WINDOW_MS);
+        if (restartTimes.length <= MAX_RESTART_ATTEMPTS) {
+          setTimeout(() => restartCallback(localPort), 2000);
+        }
+      }
+    });
+  });
+}
+
 /**
  * Spawn cloudflared tunnel
  * @param {string} tunnelToken