9remote 0.1.63 → 2.0.1

package/cli/utils/tui.js

@@ -26,7 +26,7 @@ const W = () => Math.min(44, process.stdout.columns || 44);
 
 // ── Banner ────────────────────────────────────────────────────────────────────
 
-export function showBanner(currentVersion, latestVersion = null) {
+export function getBannerText(currentVersion, latestVersion = null) {
   const w = W();
   const inner = w - 2;
 
@@ -43,58 +43,161 @@ export function showBanner(currentVersion, latestVersion = null) {
     return C.orange + "║" + C.reset + " ".repeat(lp) + colorFn(text) + " ".repeat(rp) + C.orange + "║" + C.reset;
   };
 
-  console.log("");
-  console.log(C.orange + "╔" + "═".repeat(inner) + "╗" + C.reset);
-  console.log(line());
-  console.log(center(`🚀  9Remote v${currentVersion}`, (s) => C.bold + C.orange + s + C.reset));
-  console.log(center("Remote terminal access from anywhere", (s) => C.dim + s + C.reset));
-  console.log(line());
+  const lines = [
+    "",
+    C.orange + "╔" + "═".repeat(inner) + "╗" + C.reset,
+    line(),
+    center(`🚀  9Remote v${currentVersion}`, (s) => C.bold + C.orange + s + C.reset),
+    center("Remote terminal access from anywhere", (s) => C.dim + s + C.reset),
+    line(),
+  ];
 
   if (latestVersion) {
-    const notice = `⬆  New version v${latestVersion} available!`;
-    console.log(center(notice, (s) => C.yellow + C.bold + s + C.reset));
-    const hint = `Run: npm i -g 9remote@latest`;
-    console.log(center(hint, (s) => C.dim + s + C.reset));
-    console.log(line());
+    lines.push(center(`⬆  New version v${latestVersion} available!`, (s) => C.yellow + C.bold + s + C.reset));
+    lines.push(center(`Run: npm i -g 9remote@latest`, (s) => C.dim + s + C.reset));
+    lines.push(line());
   }
 
-  console.log(C.orange + "╚" + "═".repeat(inner) + "╝" + C.reset);
-  console.log("");
+  lines.push(C.orange + "╚" + "═".repeat(inner) + "╝" + C.reset);
+  lines.push("");
+  return lines.join("\n");
+}
+
+export function showBanner(currentVersion, latestVersion = null) {
+  console.log(getBannerText(currentVersion, latestVersion));
 }
 
 // ── Progress ──────────────────────────────────────────────────────────────────
 
+const SPINNER_FRAMES = ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"];
+
 const STEPS = [
-  { label: "Preparing",       desc: "Checking dependencies" },
-  { label: "Connecting",      desc: "Creating session"      },
-  { label: "Starting tunnel", desc: "Spawning cloudflared"  },
-  { label: "Ready",           desc: "Tunnel is live"        },
+  { label: "Preparing",         desc: "Checking dependencies" },
+  { label: "Connecting",        desc: "Creating session"      },
+  { label: "Starting tunnel",   desc: "Spawning tunnel"  },
+  { label: "Verifying tunnel",  desc: "Health check"          },
+  { label: "Ready",             desc: "Tunnel is live"        },
 ];
 
-let _progressLines = 0;
+const IS_WIN = process.platform === "win32";
+const SPINNER_INTERVAL_MS = IS_WIN ? 120 : 80;
 
-export function renderProgress(activeIdx, redraw = false) {
-  if (redraw && _progressLines > 0) {
-    process.stdout.write(`\x1b[${_progressLines}A\x1b[0J`);
-  }
+// Ensure cursor is restored on any unexpected exit
+process.on("exit", () => process.stdout.write("\x1b[?25h"));
+process.on("SIGINT", () => { process.stdout.write("\x1b[?25h"); });
+process.on("SIGTERM", () => { process.stdout.write("\x1b[?25h"); });
 
+let _progressLines = 0;
+let _spinnerInterval = null;
+let _spinnerFrame = 0;
+let _activeIdx = -1;
+let _activeDesc = null;
+let _infoLine = null;
+let _cursorHidden = false;
+
+function _buildLines() {
   const lines = [];
+  const isFinal = _activeIdx === STEPS.length - 1;
   STEPS.forEach((step, i) => {
-    if (i < activeIdx) {
+    const desc = (i === _activeIdx && _activeDesc) ? _activeDesc : step.desc;
+    if (i < _activeIdx || (isFinal && i === _activeIdx)) {
       lines.push(`  ${C.green}✓${C.reset} ${C.dim}${step.label}${C.reset}`);
-    } else if (i === activeIdx) {
-      lines.push(`  ${C.orange}●${C.reset} ${C.bold}${step.label}${C.reset}  ${C.dim}${step.desc}${C.reset}`);
+      if (_infoLine && i === _infoLine.afterIdx) {
+        lines.push(`  ${C.green}✓${C.reset} ${C.cyan}${_infoLine.text}${C.reset}`);
+      }
+    } else if (i === _activeIdx) {
+      const frame = SPINNER_FRAMES[_spinnerFrame % SPINNER_FRAMES.length];
+      lines.push(`  ${C.orange}${frame}${C.reset} ${C.bold}${step.label}${C.reset}  ${C.dim}${desc}${C.reset}`);
     } else {
       lines.push(`  ${C.dim}○ ${step.label}${C.reset}`);
     }
   });
+  return lines;
+}
 
-  lines.forEach((l) => console.log(l));
+function _fullRedraw() {
+  const lines = _buildLines();
+  if (_progressLines > 0) {
+    process.stdout.write(`\x1b[${_progressLines}A\x1b[0J`);
+  }
+  process.stdout.write(lines.join("\n") + "\n");
   _progressLines = lines.length;
 }
 
+// Only repaint the active spinner line to avoid flicker on Windows conhost
+function _tickSpinner() {
+  if (_progressLines === 0 || _activeIdx < 0) return;
+  const lines = _buildLines();
+  if (lines.length !== _progressLines) {
+    _fullRedraw();
+    return;
+  }
+  const activeLineOffset = _activeIdx + (_infoLine && _infoLine.afterIdx < _activeIdx ? 1 : 0);
+  const up = _progressLines - activeLineOffset;
+  // Move up, clear line, write, move back down — single write = no flicker
+  process.stdout.write(`\x1b[${up}A\r\x1b[2K${lines[activeLineOffset]}\x1b[${up}B\r`);
+}
+
+function _hideCursor() {
+  if (!_cursorHidden) {
+    process.stdout.write("\x1b[?25l");
+    _cursorHidden = true;
+  }
+}
+
+function _showCursor() {
+  if (_cursorHidden) {
+    process.stdout.write("\x1b[?25h");
+    _cursorHidden = false;
+  }
+}
+
+export function renderProgress(activeIdx, redraw = false, desc = null) {
+  if (_spinnerInterval) {
+    clearInterval(_spinnerInterval);
+    _spinnerInterval = null;
+  }
+
+  _activeIdx = activeIdx;
+  _activeDesc = desc;
+  _spinnerFrame = 0;
+
+  if (!redraw) _progressLines = 0;
+  _fullRedraw();
+
+  if (activeIdx < STEPS.length - 1) {
+    _hideCursor();
+    _spinnerInterval = setInterval(() => {
+      _spinnerFrame++;
+      _tickSpinner();
+    }, SPINNER_INTERVAL_MS);
+  } else {
+    _showCursor();
+  }
+}
+
+/** Show an extra info line after a completed step */
+export function setProgressInfo(afterIdx, text) {
+  _infoLine = text ? { afterIdx, text } : null;
+}
+
+/** Update desc of current active step without changing step index */
+export function updateProgressDesc(desc) {
+  _activeDesc = desc;
+  if (_progressLines > 0) _tickSpinner();
+}
+
 export function resetProgress() {
+  if (_spinnerInterval) {
+    clearInterval(_spinnerInterval);
+    _spinnerInterval = null;
+  }
+  _showCursor();
   _progressLines = 0;
+  _activeIdx = -1;
+  _activeDesc = null;
+  _infoLine = null;
+  _spinnerFrame = 0;
 }
 
 // ── selectMenu ────────────────────────────────────────────────────────────────
@@ -126,7 +229,7 @@ export function selectMenu(title, items, defaultIndex = 0, headerContent = "", o
       if (header) {
         process.stdout.write(header + "\n");
       }
-      process.stdout.write(`${C.dim}${title}${C.reset}\n\n`);
+      if (title) process.stdout.write(`${C.dim}${title}${C.reset}\n\n`);
       items.forEach((item, i) => {
         const icon = i === selected ? (isWin ? ">" : "★") : (isWin ? " " : "☆");
         if (i === selected) {
@@ -191,15 +294,87 @@ export function selectMenu(title, items, defaultIndex = 0, headerContent = "", o
  */
 export function confirm(message) {
   return new Promise((resolve) => {
-    // Ensure clean state
+    // Clean state
+    process.stdin.removeAllListeners("keypress");
     if (process.stdin.isTTY) { try { process.stdin.setRawMode(false); } catch {} }
+    process.stdin.pause();
+
+    process.stdout.write(`${message} (y/N): `);
+
+    // Use raw keypress (same pattern as selectMenu)
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) { try { process.stdin.setRawMode(true); } catch {} }
+    process.stdin.resume();
+
+    const onKeypress = (str, key) => {
+      if (!key) return;
+      process.stdin.removeListener("keypress", onKeypress);
+      if (process.stdin.isTTY) { try { process.stdin.setRawMode(false); } catch {} }
+      process.stdin.pause();
+
+      if (key.ctrl && key.name === "c") { process.stdout.write("\n"); process.exit(0); }
+      const approved = (key.name || "").toLowerCase() === "y";
+      console.log(approved ? "y" : "n");
+      resolve(approved);
+    };
+
+    process.stdin.on("keypress", onKeypress);
+  });
+}
+
+// ── Device Approval Prompt ────────────────────────────────────────────────────
+
+/**
+ * Show device approval prompt with raw-mode single-key capture.
+ * Fully takes over stdin from selectMenu, resolves with true/false.
+ */
+export function showDeviceApproval(deviceId, ip) {
+  return new Promise((resolve) => {
+    const shortId = deviceId ? deviceId.slice(0, 8) : "unknown";
+    const w = W();
+
+    // Fully take over stdin from selectMenu
     process.stdin.removeAllListeners("keypress");
+    if (process.stdin.isTTY) { try { process.stdin.setRawMode(false); } catch {} }
+    process.stdin.pause();
+
+    // Clear screen for clean approval UI
+    process.stdout.write("\x1b[2J\x1b[H");
+    console.log("");
+    console.log(`${C.orange}${'═'.repeat(w)}${C.reset}`);
+  console.log(`${C.orange}${C.bold} 🔔 New Device Connection${C.reset}`);
+  console.log(`${C.orange}${'═'.repeat(w)}${C.reset}`);
+  console.log(`  Device:  ${C.cyan}${shortId}...${C.reset}`);
+  console.log(`  IP:      ${C.cyan}${ip}${C.reset}`);
+  console.log(`${C.orange}${'═'.repeat(w)}${C.reset}`);
+  console.log("");
 
-    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
-    rl.question(`${message} (y/N): `, (answer) => {
-      rl.close();
-      resolve(answer.trim().toLowerCase() === "y");
-    });
+  process.stdout.write(`  Allow this device? ${C.dim}(y/n)${C.reset} `);
+
+    // Use keypress events (same pattern as selectMenu)
+    readline.emitKeypressEvents(process.stdin);
+    if (process.stdin.isTTY) { try { process.stdin.setRawMode(true); } catch {} }
+    process.stdin.resume();
+
+    const onKeypress = (str, key) => {
+      if (!key) return;
+      const ch = (key.name || "").toLowerCase();
+      if (ch === "y" || ch === "n" || key.name === "return" || (key.ctrl && key.name === "c")) {
+        process.stdin.removeListener("keypress", onKeypress);
+        if (process.stdin.isTTY) { try { process.stdin.setRawMode(false); } catch {} }
+        process.stdin.pause();
+        if (key.ctrl && key.name === "c") process.exit(0);
+
+        const approved = ch === "y";
+        console.log(approved ? `${C.green}y${C.reset}` : `${C.red}n${C.reset}`);
+        console.log(approved
+          ? `\n  ${C.green}\u2713 Device approved${C.reset}`
+          : `\n  ${C.red}\u2717 Device rejected${C.reset}`);
+        setTimeout(() => resolve(approved), 500);
+      }
+    };
+
+    process.stdin.on("keypress", onKeypress);
   });
 }
 

package/cli/utils/updateChecker.js

@@ -1,15 +1,63 @@
 import chalk from "chalk";
-import { readFileSync, writeFileSync, existsSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, unlinkSync } from "fs";
 import { fileURLToPath } from "url";
-import { spawn } from "child_process";
+import { spawn, execSync } from "child_process";
 import path from "path";
 import os from "os";
+import { browserFetch } from "../../lib/constants.js";
+import { killAll as killAllPids, getPidsDir } from "./pids.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PACKAGE_NAME = "9remote";
 const NPM_REGISTRY_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
 const UPDATE_CHECK_TIMEOUT = 3000;
 const SAFETY_TIMEOUT = 8000;
+const SERVER_PORT = 2208;
+// Legacy path from pre-pids.js installs — clean up once so old instances
+// can still be killed during upgrade from older versions.
+const LEGACY_CLOUDFLARED_PID_FILE = path.join(os.homedir(), ".9remote", "cloudflared.pid");
+
+/**
+ * Kill all 9remote-related child processes to release file locks before npm install.
+ *
+ * Critical on Windows: node.exe / tray helper / cloudflared.exe lock files inside
+ * node_modules\9remote\dist, so `npm i -g` fails with EBUSY when trying to rename
+ * the old dist folder.
+ *
+ * We kill ONLY by PID (from ~/.9remote/pids/) — never by image name (taskkill /IM)
+ * or by commandline match, because those would also kill unrelated apps on the
+ * machine that happen to use cloudflared.exe, tray_windows_release.exe, or node.exe.
+ */
+function cleanupBeforeUpdate() {
+  // 1. Kill tracked processes (cloudflared + agent tree) via pids.js.
+  //    Agent kill with taskkill /F /T sweeps its server child + tray helper.
+  try { killAllPids(); } catch {}
+
+  // 2. Legacy: older versions stored cloudflared PID at a different path.
+  try {
+    if (existsSync(LEGACY_CLOUDFLARED_PID_FILE)) {
+      const pid = parseInt(readFileSync(LEGACY_CLOUDFLARED_PID_FILE, "utf8"));
+      if (Number.isFinite(pid)) { try { process.kill(pid); } catch {} }
+      try { unlinkSync(LEGACY_CLOUDFLARED_PID_FILE); } catch {}
+    }
+  } catch {}
+
+  // 3. Safety net for stale server on SERVER_PORT (e.g. crashed without clearing PID).
+  //    Scoped to one specific port, so we only touch 9remote's own server.
+  try {
+    if (process.platform === "win32") {
+      execSync(`for /f "tokens=5" %a in ('netstat -aon ^| findstr :${SERVER_PORT}') do taskkill /F /PID %a`, { stdio: "ignore", windowsHide: true });
+    } else {
+      execSync(`lsof -ti:${SERVER_PORT} | xargs kill -9 2>/dev/null || true`, { stdio: "ignore" });
+    }
+  } catch {}
+
+  // 4. Give Windows a moment to release file handles before npm tries to rename.
+  if (process.platform === "win32") {
+    const end = Date.now() + 1500;
+    while (Date.now() < end) { /* spin-wait; Atomics.wait not worth importing */ }
+  }
+}
 
 /**
  * Get current version
@@ -34,7 +82,7 @@ function getCurrentVersion() {
  * Compare semver versions
  * Returns true if latest > current
  */
-function isNewerVersion(current, latest) {
+export function isNewerVersion(current, latest) {
   const currentParts = current.split(".").map(Number);
   const latestParts = latest.split(".").map(Number);
 
@@ -61,12 +109,20 @@ function isRestrictedEnvironment() {
 /**
  * Check for npm updates (non-blocking, notification only)
  */
+/**
+ * Kill running 9remote processes so user can safely run `npm i -g 9remote@latest`.
+ * Called when user chooses manual update from startup menu.
+ */
+export function stopRunningInstances() {
+  cleanupBeforeUpdate();
+}
+
 export async function checkForUpdates() {
   try {
     const currentVersion = getCurrentVersion();
     if (!currentVersion) return;
 
-    const response = await fetch(NPM_REGISTRY_URL, {
+    const response = await browserFetch(NPM_REGISTRY_URL, {
       signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT)
     });
 
@@ -94,7 +150,7 @@ export async function checkLatestVersion() {
   try {
     const currentVersion = getCurrentVersion();
     if (!currentVersion) return null;
-    const response = await fetch(NPM_REGISTRY_URL, {
+    const response = await browserFetch(NPM_REGISTRY_URL, {
       signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT)
     });
     if (!response.ok) return null;
@@ -158,7 +214,7 @@ export async function checkAndUpdate(skipUpdate = false) {
 
     startSpinner("Checking for updates...");
 
-    fetch(NPM_REGISTRY_URL, { signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT) })
+    browserFetch(NPM_REGISTRY_URL, { signal: AbortSignal.timeout(UPDATE_CHECK_TIMEOUT) })
       .then((res) => res.json())
       .then((data) => {
         if (resolved) return;
@@ -191,11 +247,33 @@ export async function checkAndUpdate(skipUpdate = false) {
 
         let scriptPath, shellCmd;
 
+        // The update script must kill our tracked processes by PID ONLY.
+        // Never use `taskkill /IM <image>` or `pkill -f <name>` — those match
+        // by binary name / commandline and would nuke unrelated apps on the
+        // machine (other cloudflared tunnels, other tray apps, any node.exe).
+        const pidsDir = getPidsDir();
+
         if (platform === "win32") {
           const script = `@echo off
 echo 📥 Downloading update...
-echo ⏳ Waiting for process to exit...
-timeout /t 2 /nobreak >nul
+echo ⏳ Stopping 9remote processes...
+
+REM Kill cloudflared first so it stops reconnecting, then kill the agent
+REM tree (/T also terminates its server child + tray helper). PID-based so
+REM we never touch unrelated node.exe / cloudflared.exe on this machine.
+REM ptyDaemon is intentionally NOT killed — keep terminal sessions alive.
+for %%N in (cloudflared agent) do (
+  if exist "${pidsDir}\\%%N.pid" (
+    for /f %%P in ('type "${pidsDir}\\%%N.pid"') do taskkill /F /T /PID %%P >nul 2>&1
+    del /f /q "${pidsDir}\\%%N.pid" >nul 2>&1
+  )
+)
+
+REM Safety net: kill anything still bound to our server port.
+for /f "tokens=5" %%a in ('netstat -aon ^| findstr :${SERVER_PORT}') do taskkill /F /PID %%a >nul 2>&1
+
+REM Let Windows flush file handles before npm renames node_modules\\9remote.
+timeout /t 3 /nobreak >nul
 
 echo 🔄 Installing new version...
 call npm cache clean --force >nul 2>&1
@@ -218,11 +296,24 @@ if %ERRORLEVEL% EQU 0 (
         } else {
           const script = `#!/bin/bash
 echo "📥 Downloading update..."
-echo "⏳ Waiting for process to exit..."
-sleep 1
-
-pkill -f "${PACKAGE_NAME}" 2>/dev/null || true
-sleep 1
+echo "⏳ Stopping 9remote processes..."
+
+# Kill cloudflared first, then the agent (children die with the agent on
+# POSIX once the parent process exits and systemd/init reaps them, or here
+# because we SIGKILL them via kill -9). PID-based so unrelated apps are safe.
+# ptyDaemon is intentionally NOT killed — keep terminal sessions alive.
+for name in cloudflared agent; do
+  f="${pidsDir}/\${name}.pid"
+  if [ -f "$f" ]; then
+    pid=$(cat "$f" 2>/dev/null)
+    [ -n "$pid" ] && kill -9 "$pid" 2>/dev/null || true
+    rm -f "$f"
+  fi
+done
+
+# Safety net: kill anything still bound to our server port.
+lsof -ti:${SERVER_PORT} | xargs kill -9 2>/dev/null || true
+sleep 2
 
 echo "🔄 Installing new version..."
 npm cache clean --force 2>/dev/null
@@ -247,6 +338,9 @@ fi
           shellCmd = ["sh", [scriptPath]];
         }
 
+        // Cleanup child processes to release file locks before npm install
+        cleanupBeforeUpdate();
+
         // Execute update script in background
         const child = spawn(shellCmd[0], shellCmd[1], {
           detached: true,