9remote 0.1.8 → 0.1.9

package/utils/cloudflared.js

@@ -0,0 +1,226 @@
+import fs from "fs";
+import path from "path";
+import https from "https";
+import os from "os";
+import { execSync, spawn } from "child_process";
+
+const BIN_DIR = path.join(os.homedir(), ".9remote", "bin");
+const BINARY_NAME = "cloudflared";
+const IS_WINDOWS = os.platform() === "win32";
+const BIN_NAME = IS_WINDOWS ? `${BINARY_NAME}.exe` : BINARY_NAME;
+const BIN_PATH = path.join(BIN_DIR, BIN_NAME);
+const PID_FILE = path.join(os.homedir(), ".9remote", "cloudflared.pid");
+
+const GITHUB_BASE_URL = "https://github.com/cloudflare/cloudflared/releases/latest/download";
+
+/**
+ * Platform mappings for cloudflared
+ */
+const PLATFORM_MAPPINGS = {
+  darwin: {
+    x64: "cloudflared-darwin-amd64.tgz",
+    arm64: "cloudflared-darwin-amd64.tgz"
+  },
+  win32: {
+    x64: "cloudflared-windows-amd64.exe"
+  },
+  linux: {
+    x64: "cloudflared-linux-amd64",
+    arm64: "cloudflared-linux-arm64"
+  }
+};
+
+/**
+ * Get download URL
+ */
+function getDownloadUrl() {
+  const platform = os.platform();
+  const arch = os.arch();
+  
+  const platformMapping = PLATFORM_MAPPINGS[platform];
+  if (!platformMapping) {
+    throw new Error(`Unsupported platform: ${platform}`);
+  }
+  
+  const binaryName = platformMapping[arch];
+  if (!binaryName) {
+    throw new Error(`Unsupported architecture: ${arch} for platform ${platform}`);
+  }
+  
+  return `${GITHUB_BASE_URL}/${binaryName}`;
+}
+
+/**
+ * Download file from URL
+ */
+async function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    
+    https.get(url, (response) => {
+      if ([301, 302].includes(response.statusCode)) {
+        file.close();
+        fs.unlinkSync(dest);
+        downloadFile(response.headers.location, dest).then(resolve).catch(reject);
+        return;
+      }
+      
+      if (response.statusCode !== 200) {
+        file.close();
+        fs.unlinkSync(dest);
+        reject(new Error(`Download failed with status ${response.statusCode}`));
+        return;
+      }
+      
+      response.pipe(file);
+      
+      file.on("finish", () => {
+        file.close(() => resolve(dest));
+      });
+      
+      file.on("error", (err) => {
+        file.close();
+        fs.unlinkSync(dest);
+        reject(err);
+      });
+    }).on("error", (err) => {
+      file.close();
+      if (fs.existsSync(dest)) fs.unlinkSync(dest);
+      reject(err);
+    });
+  });
+}
+
+/**
+ * Ensure cloudflared binary exists
+ */
+export async function ensureCloudflared() {
+  if (!fs.existsSync(BIN_DIR)) {
+    fs.mkdirSync(BIN_DIR, { recursive: true });
+  }
+  
+  if (fs.existsSync(BIN_PATH)) {
+    if (!IS_WINDOWS) {
+      fs.chmodSync(BIN_PATH, "755");
+    }
+    return BIN_PATH;
+  }
+  
+  console.log("📥 Downloading tunnel binary...");
+  
+  const url = getDownloadUrl();
+  const isArchive = url.endsWith(".tgz");
+  const downloadDest = isArchive ? path.join(BIN_DIR, "cloudflared.tgz") : BIN_PATH;
+  
+  try {
+    await downloadFile(url, downloadDest);
+    
+    if (isArchive) {
+      console.log("✅ Extracting...");
+      execSync(`tar -xzf "${downloadDest}" -C "${BIN_DIR}"`, { stdio: "pipe" });
+      fs.unlinkSync(downloadDest);
+    }
+    
+    if (!IS_WINDOWS) {
+      fs.chmodSync(BIN_PATH, "755");
+    }
+    
+    console.log("✅ cloudflared ready");
+    return BIN_PATH;
+  } catch (error) {
+    console.error("❌ Failed to download cloudflared:", error.message);
+    throw error;
+  }
+}
+
+// Log patterns to filter cloudflared output
+const LOG_IGNORE = [
+  "INF Starting tunnel",
+  "INF Version",
+  "GOOS:",
+  "Settings:",
+  "Autoupdate frequency",
+  "Generated Connector",
+  "Initial protocol",
+  "ICMP proxy",
+  "Created ICMP",
+  "Starting metrics server",
+  "curve preferences",
+  "Updated to new configuration"
+];
+
+/**
+ * Spawn cloudflared tunnel
+ * @param {string} tunnelToken
+ * @returns {ChildProcess}
+ */
+export async function spawnCloudflared(tunnelToken) {
+  const binaryPath = await ensureCloudflared();
+  
+  const child = spawn(binaryPath, ["tunnel", "run", "--token", tunnelToken], {
+    detached: false,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  
+  let connectionCount = 0;
+  
+  const handleLog = (data) => {
+    const msg = data.toString().trim();
+    
+    // Skip ignored messages
+    if (LOG_IGNORE.some(pattern => msg.includes(pattern))) {
+      return;
+    }
+    
+    // Show connection status briefly
+    if (msg.includes("Registered tunnel connection")) {
+      connectionCount++;
+      if (connectionCount <= 4) {
+        process.stdout.write(`\r   ✔ Connection ${connectionCount}/4 established`);
+        if (connectionCount === 4) {
+          process.stdout.write("\n");
+        }
+      }
+      return;
+    }
+    
+    // Show errors
+    if (msg.includes("ERR") || msg.includes("error") || msg.includes("failed")) {
+      console.error(`[cloudflared] ${msg}`);
+    }
+  };
+  
+  child.stdout.on("data", handleLog);
+  child.stderr.on("data", handleLog);
+  
+  child.on("error", (error) => {
+    console.error("❌ cloudflared error:", error);
+  });
+  
+  child.on("exit", (code) => {
+    if (code !== 0 && code !== null) {
+      console.log(`cloudflared exited with code ${code}`);
+    }
+  });
+  
+  // Save PID
+  fs.writeFileSync(PID_FILE, child.pid.toString());
+  
+  return child;
+}
+
+/**
+ * Kill cloudflared process
+ */
+export function killCloudflared() {
+  try {
+    if (fs.existsSync(PID_FILE)) {
+      const pid = parseInt(fs.readFileSync(PID_FILE, "utf8"));
+      process.kill(pid);
+      fs.unlinkSync(PID_FILE);
+      console.log("✅ cloudflared stopped");
+    }
+  } catch (error) {
+    // Silently ignore errors
+  }
+}

package/utils/installer.js

@@ -0,0 +1,137 @@
+import { execSync } from "child_process";
+import ora from "ora";
+import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import os from "os";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = path.resolve(__dirname, "../..");
+
+/**
+ * Check if running from global installation
+ */
+function isGlobalInstall() {
+  // Check if we're in global node_modules
+  return PROJECT_ROOT.includes("/node_modules/9remote") || 
+         PROJECT_ROOT.includes("\\node_modules\\9remote");
+}
+
+/**
+ * Get dependencies directory
+ * For global install: use ~/.9remote/node_modules
+ * For local dev: use project node_modules
+ */
+function getDepsDir() {
+  if (isGlobalInstall()) {
+    const homeDir = os.homedir();
+    return path.join(homeDir, ".9remote");
+  }
+  return PROJECT_ROOT;
+}
+
+const DEPS_DIR = getDepsDir();
+const INSTALL_MARKER = path.join(DEPS_DIR, "node_modules", ".deps-installed");
+
+/**
+ * Ensure all dependencies are installed
+ * Only runs once on first launch
+ */
+export async function ensureNativeDeps() {
+  // Create deps directory if needed
+  if (!fs.existsSync(DEPS_DIR)) {
+    fs.mkdirSync(DEPS_DIR, { recursive: true });
+  }
+
+  // Check if already installed
+  if (fs.existsSync(INSTALL_MARKER)) {
+    // Add deps to NODE_PATH for global install
+    if (isGlobalInstall()) {
+      const depsNodeModules = path.join(DEPS_DIR, "node_modules");
+      if (process.env.NODE_PATH) {
+        process.env.NODE_PATH = `${depsNodeModules}${path.delimiter}${process.env.NODE_PATH}`;
+      } else {
+        process.env.NODE_PATH = depsNodeModules;
+      }
+      require("module").Module._initPaths();
+    }
+    return true;
+  }
+
+  const spinner = ora("Checking dependencies...").start();
+
+  try {
+    // Check if cloudflared is installed
+    let allInstalled = true;
+    try {
+      await import("cloudflared");
+    } catch {
+      allInstalled = false;
+    }
+
+    if (allInstalled) {
+      spinner.succeed("Dependencies ready");
+      
+      // Mark as installed
+      fs.mkdirSync(path.dirname(INSTALL_MARKER), { recursive: true });
+      fs.writeFileSync(INSTALL_MARKER, new Date().toISOString());
+      
+      return true;
+    }
+
+    // Install cloudflared only (other deps are in package.json)
+    spinner.stop();
+    console.log(chalk.cyan("📦 Installing cloudflared (first time only, ~10 seconds)...\n"));
+    
+    const packageNames = ["cloudflared"];
+    
+    try {
+      console.log(chalk.gray("   Installing cloudflared..."));
+      
+      // Create package.json if in global install mode
+      if (isGlobalInstall()) {
+        const pkgJsonPath = path.join(DEPS_DIR, "package.json");
+        if (!fs.existsSync(pkgJsonPath)) {
+          fs.writeFileSync(pkgJsonPath, JSON.stringify({
+            name: "9remote-deps",
+            version: "1.0.0",
+            private: true
+          }, null, 2));
+        }
+      }
+      
+      execSync(`npm install --no-save --prefer-offline ${packageNames.join(" ")}`, {
+        cwd: DEPS_DIR,
+        stdio: "inherit"
+      });
+      console.log(chalk.green("\n✔ Cloudflared installed successfully"));
+      
+      // Add deps to NODE_PATH for global install
+      if (isGlobalInstall()) {
+        const depsNodeModules = path.join(DEPS_DIR, "node_modules");
+        if (process.env.NODE_PATH) {
+          process.env.NODE_PATH = `${depsNodeModules}${path.delimiter}${process.env.NODE_PATH}`;
+        } else {
+          process.env.NODE_PATH = depsNodeModules;
+        }
+        require("module").Module._initPaths();
+      }
+    } catch (error) {
+      console.log(chalk.red("\n✖ Failed to install dependencies"));
+      console.error(error.message);
+      console.log(chalk.yellow("\n💡 Tip: Try running with sudo if permission denied"));
+      return false;
+    }
+    
+    // Mark as installed
+    fs.mkdirSync(path.dirname(INSTALL_MARKER), { recursive: true });
+    fs.writeFileSync(INSTALL_MARKER, new Date().toISOString());
+    
+    return true;
+  } catch (error) {
+    spinner.fail("Failed to install dependencies");
+    console.error(error.message);
+    return false;
+  }
+}

package/utils/machineId.js

@@ -0,0 +1,22 @@
+import pkg from "node-machine-id";
+const { machineIdSync } = pkg;
+import crypto from "crypto";
+
+/**
+ * Get consistent machine ID using node-machine-id with salt
+ * This ensures the same physical machine gets the same ID across runs
+ * 
+ * @param {string} salt - Optional salt to use (defaults to environment variable)
+ * @returns {Promise<string>} Machine ID (16-character hex)
+ */
+export async function getConsistentMachineId(salt = null) {
+  const saltValue = salt || process.env.MACHINE_ID_SALT || "9remote-salt";
+  try {
+    const rawMachineId = machineIdSync();
+    const hashedMachineId = crypto.createHash("sha256").update(rawMachineId + saltValue).digest("hex");
+    return hashedMachineId.substring(0, 16);
+  } catch (error) {
+    console.error("Error getting machine ID:", error);
+    return crypto.randomUUID().replace(/-/g, "").substring(0, 16);
+  }
+}

package/utils/state.js

@@ -0,0 +1,92 @@
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+const STATE_DIR = path.join(os.homedir(), ".9remote");
+const STATE_FILE = path.join(STATE_DIR, "state.json");
+const KEYS_FILE = path.join(STATE_DIR, "keys.json");
+
+/**
+ * Ensure state directory exists
+ */
+function ensureDir() {
+  if (!fs.existsSync(STATE_DIR)) {
+    fs.mkdirSync(STATE_DIR, { recursive: true });
+  }
+}
+
+// ==================== STATE ====================
+
+/**
+ * Load state from file
+ */
+export function loadState() {
+  try {
+    ensureDir();
+    if (!fs.existsSync(STATE_FILE)) return null;
+    return JSON.parse(fs.readFileSync(STATE_FILE, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Save state to file
+ */
+export function saveState(state) {
+  try {
+    ensureDir();
+    fs.writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+  } catch (error) {
+    console.error("Error saving state:", error);
+  }
+}
+
+/**
+ * Clear state file
+ */
+export function clearState() {
+  try {
+    if (fs.existsSync(STATE_FILE)) {
+      fs.unlinkSync(STATE_FILE);
+    }
+  } catch {}
+}
+
+// ==================== KEYS ====================
+
+/**
+ * Load single key from file
+ * @returns {{ machineId: string, key: string | null, name: string, createdAt: string | null }}
+ */
+export function loadKey() {
+  try {
+    ensureDir();
+    if (!fs.existsSync(KEYS_FILE)) {
+      return { machineId: null, key: null, name: "Default", createdAt: null };
+    }
+    return JSON.parse(fs.readFileSync(KEYS_FILE, "utf8"));
+  } catch {
+    return { machineId: null, key: null, name: "Default", createdAt: null };
+  }
+}
+
+/**
+ * Save single key to file (overwrites existing)
+ */
+export function saveKey(machineId, key, name = "Default") {
+  try {
+    ensureDir();
+    const data = {
+      machineId,
+      key,
+      name,
+      createdAt: new Date().toISOString()
+    };
+    fs.writeFileSync(KEYS_FILE, JSON.stringify(data, null, 2));
+    return data;
+  } catch (error) {
+    console.error("Error saving key:", error);
+    return null;
+  }
+}

package/utils/token.js

@@ -0,0 +1,30 @@
+const TEMP_KEY_EXPIRY_MINUTES = 30;
+
+/**
+ * Create temp key on Worker for API key
+ * @param {string} apiKey - API key
+ * @param {string} workerUrl - Worker URL
+ * @returns {Promise<{tempKey: string, expiresAt: number} | null>}
+ */
+export async function createTempKey(apiKey, workerUrl) {
+  try {
+    const response = await fetch(`${workerUrl}/api/temp-key/create`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ 
+        apiKey, 
+        expiryMinutes: TEMP_KEY_EXPIRY_MINUTES 
+      })
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.error || "Failed to create temp key");
+    }
+
+    return await response.json();
+  } catch (error) {
+    console.error("Error creating temp key:", error);
+    return null;
+  }
+}

package/utils/updateChecker.js

@@ -0,0 +1,64 @@
+import chalk from "chalk";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import path from "path";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_NAME = "9remote";
+const NPM_REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+
+/**
+ * Get current version from package.json
+ */
+function getCurrentVersion() {
+  try {
+    const packagePath = path.resolve(__dirname, "../../package.json");
+    const packageJson = JSON.parse(readFileSync(packagePath, "utf-8"));
+    return packageJson.version;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Compare semver versions
+ * Returns true if latest > current
+ */
+function isNewerVersion(current, latest) {
+  const currentParts = current.split(".").map(Number);
+  const latestParts = latest.split(".").map(Number);
+
+  for (let i = 0; i < 3; i++) {
+    if (latestParts[i] > currentParts[i]) return true;
+    if (latestParts[i] < currentParts[i]) return false;
+  }
+  return false;
+}
+
+/**
+ * Check for npm updates (non-blocking)
+ */
+export async function checkForUpdates() {
+  try {
+    const currentVersion = getCurrentVersion();
+    if (!currentVersion) return;
+
+    const response = await fetch(NPM_REGISTRY_URL, {
+      signal: AbortSignal.timeout(3000)
+    });
+
+    if (!response.ok) return;
+
+    const data = await response.json();
+    const latestVersion = data.version;
+
+    if (latestVersion && isNewerVersion(currentVersion, latestVersion)) {
+      console.log(
+        chalk.yellow(`\n⬆️  New version ${chalk.green(latestVersion)} available (current: ${currentVersion})`)
+      );
+      console.log(chalk.gray(`   Run: npm i -g ${PACKAGE_NAME}\n`));
+    }
+  } catch {
+    // Silent fail - don't block CLI
+  }
+}

package/dist/standalone/.env

@@ -1 +0,0 @@
-NODE_ENV=production

package/dist/standalone/.next/BUILD_ID

@@ -1 +0,0 @@
-niBV9uszI8DM_Av9_qyqt

package/dist/standalone/.next/app-path-routes-manifest.json

@@ -1,9 +0,0 @@
-{
-  "/_global-error/page": "/_global-error",
-  "/_not-found/page": "/_not-found",
-  "/favicon.ico/route": "/favicon.ico",
-  "/login/page": "/login",
-  "/page": "/",
-  "/remote/page": "/remote",
-  "/terminal/page": "/terminal"
-}

package/dist/standalone/.next/build-manifest.json

@@ -1,21 +0,0 @@
-{
-  "pages": {
-    "/_app": []
-  },
-  "devFiles": [],
-  "polyfillFiles": [
-    "static/chunks/a6dad97d9634a72d.js"
-  ],
-  "lowPriorityFiles": [
-    "static/niBV9uszI8DM_Av9_qyqt/_ssgManifest.js",
-    "static/niBV9uszI8DM_Av9_qyqt/_buildManifest.js"
-  ],
-  "rootMainFiles": [
-    "static/chunks/d59f830a2b8e768c.js",
-    "static/chunks/ee14715dfc7e4ab9.js",
-    "static/chunks/9b6ba4b26e676f37.js",
-    "static/chunks/31da8ada704e8c5a.js",
-    "static/chunks/236f7e5abd6f09ff.js",
-    "static/chunks/turbopack-05d7f903ec930a40.js"
-  ]
-}

package/dist/standalone/.next/package.json

@@ -1 +0,0 @@
-{"type": "commonjs"}