9remote 0.1.8 → 0.1.9

package/index.js

@@ -0,0 +1,535 @@
+#!/usr/bin/env node
+
+import inquirer from "inquirer";
+import chalk from "chalk";
+import qrcode from "qrcode-terminal";
+import { spawn, execSync } from "child_process";
+import path from "path";
+import { fileURLToPath } from "url";
+import fs from "fs";
+import dns from "dns/promises";
+import { getConsistentMachineId } from "./utils/machineId.js";
+import { generateApiKeyWithMachine } from "./utils/apiKey.js";
+import { loadKey, saveKey, saveState, clearState } from "./utils/state.js";
+import { createTempKey } from "./utils/token.js";
+import { checkForUpdates } from "./utils/updateChecker.js";
+import { ensureNativeDeps } from "./utils/installer.js";
+import { ensureCloudflared, spawnCloudflared, killCloudflared } from "./utils/cloudflared.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = path.resolve(__dirname, "..");
+const STANDALONE_SERVER = path.join(__dirname, "dist/server.cjs");
+const WORKER_URL = "https://remote.9router.com";
+const SERVER_PORT = 2208;
+const MAX_RESTART_ATTEMPTS = 3;
+const RESTART_WINDOW_MS = 60000; // 1 minute
+
+/**
+ * Helper: Show QR code for connect URL
+ */
+function showQRCode(url, title = "📱 Scan QR to connect:") {
+  console.log(chalk.cyan(`\n${title}`));
+  qrcode.generate(url, {
+    small: true,
+    type: 'terminal',
+    margin: 0,
+  }, qr => {
+    const lines = qr.trim().split('\n');
+    console.log(lines.join('\n'));
+  });
+}
+
+/**
+ * Helper: Show connection info
+ */
+async function showConnectionInfo(selectedKey, tunnelUrl) {
+  const tempKeyData = await createTempKey(selectedKey, WORKER_URL);
+  
+  if (!tempKeyData) {
+    console.log(chalk.red("❌ Failed to create temp key"));
+    return;
+  }
+
+  const connectUrl = `${WORKER_URL}/login?k=${tempKeyData.tempKey}`;
+
+  showQRCode(connectUrl);
+
+  console.log(chalk.gray(`\nQR will expire in 30 minutes (one-time use)`));
+  console.log(chalk.gray(`Or enter key manually:\n`));
+  console.log(chalk.gray(`┌──────────────┬────────────────────────────────────────┐`));
+  console.log(chalk.gray(`│`) + chalk.white(` App URL      `) + chalk.gray(`│`) + chalk.blue(` ${WORKER_URL}/login`.padEnd(39)) + chalk.gray(`│`));
+  console.log(chalk.gray(`├──────────────┼────────────────────────────────────────┤`));
+  console.log(chalk.gray(`│`) + chalk.white(` One-Time Key `) + chalk.gray(`│`) + chalk.bold.yellow(` ${tempKeyData.tempKey}`.padEnd(39)) + chalk.gray(`│`));
+  console.log(chalk.gray(`├──────────────┼────────────────────────────────────────┤`));
+  console.log(chalk.gray(`│`) + chalk.white(` Key          `) + chalk.gray(`│`) + chalk.gray(` ${selectedKey}`.padEnd(39)) + chalk.gray(`│`));
+  console.log(chalk.gray(`└──────────────┴────────────────────────────────────────┘`));
+}
+
+/**
+ * Kill process on specific port
+ */
+function killProcessOnPort(port) {
+  try {
+    if (process.platform === "win32") {
+      execSync(`for /f "tokens=5" %a in ('netstat -aon ^| findstr :${port}') do taskkill /F /PID %a`, { stdio: "ignore" });
+    } else {
+      const nullDevice = "/dev/null";
+      execSync(`lsof -ti:${port} | xargs kill -9 2>${nullDevice} || true`, { stdio: "ignore" });
+    }
+  } catch { }
+}
+
+/**
+ * Start server with auto-restart on crash
+ */
+function startServerWithRestart(onReady) {
+  const restartTimes = [];
+  let currentProcess = null;
+  let isShuttingDown = false;
+  let isFirstStart = true;
+
+  const spawnServer = () => {
+    // Only kill port on first start, not on restart
+    if (isFirstStart) {
+      killProcessOnPort(SERVER_PORT);
+      isFirstStart = false;
+    }
+
+    // Use dev server if src/ exists (development), otherwise use standalone (npm package)
+    const devServerPath = path.join(PROJECT_ROOT, "server/index.js");
+    const srcExists = fs.existsSync(path.join(PROJECT_ROOT, "server"));
+    const serverPath = srcExists ? devServerPath : STANDALONE_SERVER;
+    
+    currentProcess = spawn("node", [serverPath], {
+      cwd: path.dirname(serverPath),
+      stdio: ["ignore", "inherit", "inherit"],
+      detached: false,
+      env: { ...process.env, PORT: String(SERVER_PORT) }
+    });
+
+    currentProcess.on("exit", (code, signal) => {
+      if (isShuttingDown) return;
+
+      // Check if it's a crash (non-zero exit code or unexpected signal)
+      if (code !== 0 || signal) {
+        console.log(chalk.red(`\n💥 Server crashed (code: ${code}, signal: ${signal})`));
+
+        // Check restart limit
+        const now = Date.now();
+        restartTimes.push(now);
+        
+        // Remove old restart times outside window
+        while (restartTimes.length > 0 && restartTimes[0] < now - RESTART_WINDOW_MS) {
+          restartTimes.shift();
+        }
+
+        if (restartTimes.length > MAX_RESTART_ATTEMPTS) {
+          console.log(chalk.red(`❌ Too many restarts (${MAX_RESTART_ATTEMPTS} in ${RESTART_WINDOW_MS / 1000}s). Giving up.`));
+          process.exit(1);
+        }
+
+        console.log(chalk.yellow(`🔄 Restarting server... (attempt ${restartTimes.length}/${MAX_RESTART_ATTEMPTS})`));
+        
+        // Wait a bit before restart
+        setTimeout(() => {
+          spawnServer();
+        }, 1000);
+      }
+    });
+
+    currentProcess.on("error", (err) => {
+      console.log(chalk.red(`❌ Server error: ${err.message}`));
+    });
+
+    if (onReady) {
+      onReady(currentProcess);
+    }
+  };
+
+  spawnServer();
+
+  return {
+    getProcess: () => currentProcess,
+    shutdown: () => {
+      isShuttingDown = true;
+      if (currentProcess) {
+        currentProcess.kill();
+      }
+    }
+  };
+}
+
+/**
+ * Helper: Setup exit handler for server processes
+ */
+function setupExitHandler(serverManager, tunnelProcess, apiKey) {
+  process.on("SIGINT", async () => {
+    console.log(chalk.yellow("\n\n🛑 Stopping server..."));
+    serverManager.shutdown();
+    tunnelProcess.kill();
+    
+    // Cleanup tunnel on worker
+    try {
+      await fetch(`${WORKER_URL}/api/tunnel/delete`, {
+        method: "DELETE",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ apiKey })
+      });
+    } catch { }
+    
+    clearState();
+    console.log(chalk.green("✅ Server stopped"));
+    process.exit(0);
+  });
+}
+
+/**
+ * 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");
+  }
+
+  return response.json();
+}
+
+/**
+ * Helper: Start server and tunnel
+ */
+async function startServerAndTunnel(selectedKey) {
+  console.log(chalk.cyan("\n🚀 Starting server..."));
+
+  // Kill existing processes
+  try {
+    killCloudflared();
+    if (process.platform === "win32") {
+      execSync("taskkill /F /IM node.exe /FI \"WINDOWTITLE eq server.js*\" 2>nul || exit 0", { stdio: "ignore" });
+    } else {
+      execSync("pkill -f 'node server.js' 2>/dev/null || true", { stdio: "ignore" });
+    }
+  } catch { }
+
+  // Create session first
+  try {
+    await fetch(`${WORKER_URL}/api/session/create`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ apiKey: selectedKey })
+    });
+  } catch (error) {
+    console.log(chalk.red(`❌ Failed to create session: ${error.message}`));
+    return null;
+  }
+
+  // Start server with auto-restart
+  const serverManager = startServerWithRestart();
+
+  // Wait for server to start
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+
+  console.log(chalk.cyan("✅ Creating tunnel..."));
+
+  // 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;
+  try {
+    tunnelData = await createNamedTunnel(selectedKey);
+    console.log(chalk.gray(`✅ Tunnel ID: ${tunnelData.tunnelId}`));
+  } 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
+  console.log(chalk.cyan("✅ Starting tunnel..."));
+  let tunnelProcess;
+  try {
+    tunnelProcess = await spawnCloudflared(token);
+  } catch (error) {
+    console.log(chalk.red(`❌ Failed to start cloudflared: ${error.message}`));
+    serverManager.shutdown();
+    return null;
+  }
+
+  // Wait for tunnel to be ready
+  console.log(chalk.cyan(`✅ Tunnel URL: ${tunnelUrl}`));
+  
+  const maxWaitTime = 60000;
+  const checkInterval = 2000;
+  const maxRetries = Math.floor(maxWaitTime / checkInterval);
+  let tunnelReady = false;
+  
+  // Resolve IP using Cloudflare DNS to bypass local cache
+  const hostname = new URL(tunnelUrl).hostname;
+  let resolvedIp = null;
+  
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      // Resolve DNS using Cloudflare DNS server (bypass local cache)
+      if (!resolvedIp) {
+        const resolver = new dns.Resolver();
+        resolver.setServers(["1.1.1.1", "1.0.0.1"]);
+        const addresses = await resolver.resolve4(hostname);
+        if (addresses.length > 0) {
+          resolvedIp = addresses[0];
+        }
+      }
+      
+      if (resolvedIp) {
+        // Use curl with --resolve to bypass DNS cache and SSL issues
+        const curlResult = execSync(
+          `curl -s --max-time 5 --resolve "${hostname}:443:${resolvedIp}" "${tunnelUrl}/api/health"`,
+          { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }
+        );
+        if (curlResult.includes("ok")) {
+          tunnelReady = true;
+          break;
+        }
+      }
+    } catch { }
+    
+    const spinners = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    process.stdout.write(`\r${chalk.cyan("   Waiting for tunnel")} ${chalk.yellow(spinners[i % spinners.length])} ${chalk.gray(`(${i * 2}s)`)}`);
+    
+    await new Promise(r => setTimeout(r, checkInterval));
+  }
+  
+  process.stdout.write("\r" + " ".repeat(50) + "\r");
+  
+  if (!tunnelReady) {
+    console.log(chalk.red("❌ Tunnel connection timeout"));
+    serverManager.shutdown();
+    tunnelProcess.kill();
+    return null;
+  }
+  
+  console.log(chalk.green(`✅ Connection established`));
+
+  // Save state
+  saveState({
+    apiKey: selectedKey,
+    tunnelUrl,
+    serverPid: serverManager.getProcess()?.pid,
+    tunnelPid: tunnelProcess.pid
+  });
+
+  return { serverManager, tunnelProcess, tunnelUrl };
+}
+
+
+/**
+ * Show main menu
+ */
+async function mainMenu() {
+  console.clear();
+  console.log(chalk.cyan.bold("\n🖥️  9Remote Terminal"));
+  console.log(chalk.gray("━".repeat(30)));
+
+  const { action } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "action",
+      message: "Select action:",
+      choices: [
+        { name: "🚀 Start Server", value: "start" },
+        { name: "🔑 Manage Key", value: "key" },
+        { name: "❌ Exit", value: "exit" }
+      ]
+    }
+  ]);
+
+  switch (action) {
+    case "start":
+      await startServer();
+      break;
+    case "key":
+      await manageKey();
+      break;
+    case "exit":
+      console.log(chalk.gray("Goodbye!"));
+      process.exit(0);
+  }
+}
+
+/**
+ * Start server with single key
+ */
+async function startServer() {
+  const machineId = await getConsistentMachineId();
+  let keyData = loadKey();
+
+  // Auto create key if none exists
+  if (!keyData.key) {
+    console.log(chalk.yellow("\n⚠️  No key found. Creating default key..."));
+    const { key } = generateApiKeyWithMachine(machineId);
+    keyData = saveKey(machineId, key, "Default");
+    console.log(chalk.green("✅ Default key created!"));
+  }
+
+  const result = await startServerAndTunnel(keyData.key);
+  if (!result) {
+    await mainMenu();
+    return;
+  }
+
+  const { serverManager, tunnelProcess, tunnelUrl } = result;
+
+  await showConnectionInfo(keyData.key, tunnelUrl);
+  setupExitHandler(serverManager, tunnelProcess, keyData.key);
+
+  // Keep process alive
+  await new Promise(() => { });
+}
+
+/**
+ * Manage single key menu
+ */
+async function manageKey() {
+  const machineId = await getConsistentMachineId();
+  let keyData = loadKey();
+
+  // Auto create key if none exists
+  if (!keyData.key) {
+    console.log(chalk.yellow("\n⚠️  No key found. Creating default key..."));
+    const { key } = generateApiKeyWithMachine(machineId);
+    keyData = saveKey(machineId, key, "Default");
+    console.log(chalk.green("✅ Default key created!"));
+  }
+
+  console.log(chalk.cyan("\n🔑 Manage Key"));
+  console.log(chalk.gray("━".repeat(30)));
+  console.log(chalk.white(`Key: ${keyData.key}`));
+  console.log(chalk.gray(`Created: ${keyData.createdAt}\n`));
+
+  const { action } = await inquirer.prompt([
+    {
+      type: "list",
+      name: "action",
+      message: "Action:",
+      choices: [
+        { name: "🔐 Create One-Time Key", value: "oneTime" },
+        { name: "🔄 Regenerate Key", value: "regenerate" },
+        { name: chalk.gray("← Back"), value: "back" }
+      ]
+    }
+  ]);
+
+  if (action === "oneTime") {
+    console.log(chalk.gray("\nCreating one-time key..."));
+    const tempKeyData = await createTempKey(keyData.key, WORKER_URL);
+    
+    if (tempKeyData) {
+      const connectUrl = `${WORKER_URL}/login?k=${tempKeyData.tempKey}`;
+      showQRCode(connectUrl);
+      
+      console.log(chalk.gray(`\nQR will expire in 30 minutes (one-time use)`));
+      console.log(chalk.gray(`Or enter key manually:\n`));
+      console.log(chalk.gray(`┌──────────────┬────────────────────────────────────────┐`));
+      console.log(chalk.gray(`│`) + chalk.white(` App URL      `) + chalk.gray(`│`) + chalk.blue(` ${WORKER_URL}/login`.padEnd(39)) + chalk.gray(`│`));
+      console.log(chalk.gray(`├──────────────┼────────────────────────────────────────┤`));
+      console.log(chalk.gray(`│`) + chalk.white(` One-Time Key `) + chalk.gray(`│`) + chalk.bold.yellow(` ${tempKeyData.tempKey}`.padEnd(39)) + chalk.gray(`│`));
+      console.log(chalk.gray(`└──────────────┴────────────────────────────────────────┘`));
+    } else {
+      console.log(chalk.red("❌ Failed to create one-time key"));
+    }
+    await inquirer.prompt([{ type: "input", name: "continue", message: "Press Enter to continue..." }]);
+  }
+
+  if (action === "regenerate") {
+    const { confirm } = await inquirer.prompt([
+      {
+        type: "confirm",
+        name: "confirm",
+        message: chalk.yellow("⚠️  This will replace your current key. Continue?"),
+        default: false
+      }
+    ]);
+
+    if (confirm) {
+      const { key } = generateApiKeyWithMachine(machineId);
+      keyData = saveKey(machineId, key, keyData.name);
+      
+      console.log(chalk.green(`\n✅ Key regenerated: ${keyData.key}`));
+      await inquirer.prompt([{ type: "input", name: "continue", message: "Press Enter to continue..." }]);
+    }
+  }
+
+  await mainMenu();
+}
+
+/**
+ * Auto start dev server (--auto flag)
+ */
+async function autoStartDev() {
+  console.log(chalk.cyan.bold("\n🖥️  9Remote Dev Mode"));
+  console.log(chalk.gray("━".repeat(30)));
+
+  const machineId = await getConsistentMachineId();
+  let keyData = loadKey();
+
+  // Auto create key if none exists
+  if (!keyData.key) {
+    console.log(chalk.yellow("⚠️  No key found. Creating default key..."));
+    const { key } = generateApiKeyWithMachine(machineId);
+    keyData = saveKey(machineId, key, "Default");
+    console.log(chalk.green("✅ Default key created!"));
+  }
+
+  console.log(chalk.gray(`Using key: ${keyData.key.slice(0, 20)}... (${keyData.name})`));
+
+  const result = await startServerAndTunnel(keyData.key);
+  if (!result) {
+    process.exit(1);
+  }
+
+  const { serverManager, tunnelProcess, tunnelUrl } = result;
+
+  await showConnectionInfo(keyData.key, tunnelUrl);
+  setupExitHandler(serverManager, tunnelProcess, keyData.key);
+
+  // Keep process alive
+  await new Promise(() => { });
+}
+
+
+// Start app
+async function start() {
+  checkForUpdates();
+  
+  // Ensure native dependencies are installed (first time only)
+  const depsReady = await ensureNativeDeps();
+  if (!depsReady) {
+    console.log(chalk.red("❌ Failed to install dependencies. Please try again."));
+    process.exit(1);
+  }
+  
+  // Wait a bit for symlinks to be fully created (filesystem sync)
+  await new Promise(r => setTimeout(r, 1000));
+  
+  if (process.argv.includes("--auto")) {
+    await autoStartDev();
+  } else {
+    await mainMenu();
+  }
+}
+
+start().catch(console.error);

package/package.json

@@ -1,69 +1,37 @@
 {
   "name": "9remote",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "type": "module",
+  "description": "Remote terminal access from anywhere",
+  "main": "index.js",
+  "bin": {
+    "9remote": "./dist/cli.cjs"
+  },
   "scripts": {
-    "dev": "node cli/index.js --auto",
-    "build": "next build",
-    "build:pkg": "node scripts/buildPkg.js",
-    "build:worker": "next build && node scripts/buildWorkerStatic.js",
-    "deploy": "npm run build:worker && cd worker && wrangler deploy",
-    "start": "node cli/index.js",
-    "server": "node server.js",
-    "lint": "eslint",
-    "publish": "npm run build:pkg && npm publish",
+    "start": "node index.js",
+    "dev": "node index.js --auto",
+    "build": "node ../scripts/buildPkg.js",
     "postinstall": "node scripts/install.js || true"
   },
   "dependencies": {
-    "@codemirror/commands": "^6.10.1",
-    "@codemirror/lang-css": "^6.3.1",
-    "@codemirror/lang-html": "^6.4.11",
-    "@codemirror/lang-javascript": "^6.2.4",
-    "@codemirror/lang-json": "^6.0.2",
-    "@codemirror/lang-markdown": "^6.5.0",
-    "@codemirror/lang-python": "^6.2.1",
-    "@codemirror/language": "^6.12.1",
-    "@codemirror/search": "^6.6.0",
-    "@codemirror/state": "^6.5.4",
-    "@codemirror/theme-one-dark": "^6.1.3",
-    "@codemirror/view": "^6.39.11",
-    "@xterm/addon-fit": "^0.11.0",
-    "@xterm/xterm": "^6.0.0",
     "chalk": "^5.4.1",
-    "codemirror": "^6.0.2",
-    "diff2html": "^3.4.55",
-    "http-proxy": "^1.18.1",
     "inquirer": "^9.3.8",
-    "next": "16.1.1",
+    "qrcode-terminal": "^0.12.0",
     "node-machine-id": "^1.1.12",
-    "node-pty": "^1.2.0-beta.7",
     "ora": "^8.1.1",
-    "os": "^0.1.2",
-    "qrcode-terminal": "^0.12.0",
-    "react": "19.2.3",
-    "react-dom": "19.2.3",
-    "sharp": "^0.33.5",
     "socket.io": "^4.8.3",
-    "socket.io-client": "^4.8.3",
-    "zustand": "^5.0.10"
+    "http-proxy": "^1.18.1"
   },
   "optionalDependencies": {
-    "@hurdlegroup/robotjs": "^0.12.1"
-  },
-  "devDependencies": {
-    "@cloudflare/workers-types": "^4.20241218.0",
-    "@tailwindcss/postcss": "^4",
-    "esbuild": "^0.27.2",
-    "eslint": "^9",
-    "eslint-config-next": "16.1.1",
-    "tailwindcss": "^4",
-    "wrangler": "^3.92.0"
-  },
-  "bin": {
-    "9remote": "./dist/cli.cjs"
+    "node-pty": "^1.2.0-beta.7",
+    "@hurdlegroup/robotjs": "^0.12.1",
+    "sharp": "^0.33.5"
   },
   "files": [
     "dist/",
-    "scripts/install.js"
-  ]
+    "utils/",
+    "scripts/"
+  ],
+  "keywords": ["remote", "terminal", "ssh", "cli"],
+  "license": "MIT"
 }

package/utils/apiKey.js

@@ -0,0 +1,72 @@
+import crypto from "crypto";
+
+const API_KEY_SECRET = process.env.API_KEY_SECRET || "9remote-api-key-secret";
+
+/**
+ * Generate 6-char random keyId
+ */
+function generateKeyId() {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  for (let i = 0; i < 6; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}
+
+/**
+ * Generate CRC (8-char HMAC)
+ */
+function generateCrc(machineId, keyId) {
+  return crypto
+    .createHmac("sha256", API_KEY_SECRET)
+    .update(machineId + keyId)
+    .digest("hex")
+    .slice(0, 8);
+}
+
+/**
+ * Generate API key with machineId embedded
+ * Format: sk-{machineId}-{keyId}-{crc8}
+ * @param {string} machineId - 16-char machine ID
+ * @returns {{ key: string, keyId: string }}
+ */
+export function generateApiKeyWithMachine(machineId) {
+  const keyId = generateKeyId();
+  const crc = generateCrc(machineId, keyId);
+  const key = `sk-${machineId}-${keyId}-${crc}`;
+  return { key, keyId };
+}
+
+/**
+ * Parse API key and extract machineId + keyId
+ * Format: sk-{machineId}-{keyId}-{crc8}
+ * @param {string} apiKey
+ * @returns {{ machineId: string, keyId: string } | null}
+ */
+export function parseApiKey(apiKey) {
+  if (!apiKey || !apiKey.startsWith("sk-")) return null;
+
+  const parts = apiKey.split("-");
+  
+  if (parts.length === 4) {
+    const [, machineId, keyId, crc] = parts;
+    
+    const expectedCrc = generateCrc(machineId, keyId);
+    if (crc !== expectedCrc) return null;
+    
+    return { machineId, keyId };
+  }
+  
+  return null;
+}
+
+/**
+ * Verify API key CRC
+ * @param {string} apiKey
+ * @returns {boolean}
+ */
+export function verifyApiKeyCrc(apiKey) {
+  const parsed = parseApiKey(apiKey);
+  return parsed !== null;
+}