zevairouter 1.0.152 → 1.0.154

package/src/lib/headroom/process.js

@@ -27,8 +27,12 @@ function writePid(pid) {
   fs.writeFileSync(PID_FILE, String(pid));
 }
 
-function clearPid() {
-  try { if (fs.existsSync(PID_FILE)) fs.unlinkSync(PID_FILE); } catch { /* ignore */ }
+function clearPid(expectedPid = null) {
+  try {
+    if (!fs.existsSync(PID_FILE)) return;
+    if (expectedPid != null && readPid() !== expectedPid) return;
+    fs.unlinkSync(PID_FILE);
+  } catch { /* ignore */ }
 }
 
 // process.kill throws if pid is dead — use this to probe.
@@ -69,12 +73,22 @@ export async function startHeadroomProxy({ port = DEFAULT_PORT, codeAware = fals
   const outFd = fs.openSync(LOG_FILE, "a");
 
   const args = ["proxy", "--port", String(safePort), ...extrasProxyArgs({ codeAware, kompress })];
-  const child = spawn(binary, args, {
-    stdio: ["ignore", outFd, outFd],
-    detached: true,
-    windowsHide: true,
-    env: { ...process.env },
-  });
+  let child;
+  try {
+    child = spawn(binary, args, {
+      stdio: ["ignore", outFd, outFd],
+      detached: true,
+      windowsHide: true,
+      env: { ...process.env },
+    });
+  } catch (error) {
+    fs.closeSync(outFd);
+    throw error;
+  }
+  // Node reports ENOENT as pid=undefined followed by an asynchronous `error`.
+  // Consume that event until the full startup handler is installed below.
+  const earlyErrorHandler = () => {};
+  child.once("error", earlyErrorHandler);
 
   if (!child.pid) {
     fs.closeSync(outFd);
@@ -83,29 +97,58 @@ export async function startHeadroomProxy({ port = DEFAULT_PORT, codeAware = fals
     throw err;
   }
 
+  try {
+    writePid(child.pid);
+  } catch (error) {
+    try { child.kill("SIGTERM"); } catch { /* best effort */ }
+    fs.closeSync(outFd);
+    throw error;
+  }
   child.unref();
-  writePid(child.pid);
 
   // Wait until the process either stays alive briefly (success) or exits fast (failure).
   await new Promise((resolve, reject) => {
+    child.removeListener("error", earlyErrorHandler);
+    let settled = false;
+    let logFdOpen = true;
+    const closeLogFd = () => {
+      if (!logFdOpen) return;
+      logFdOpen = false;
+      try { fs.closeSync(outFd); } catch { /* already closed */ }
+    };
+    const failStartup = (error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(startupTimer);
+      clearPid(child.pid);
+      closeLogFd();
+      reject(error);
+    };
     const startupTimer = setTimeout(() => {
-      if (isPidAlive(child.pid)) resolve();
-      else reject(new Error("headroom proxy exited during startup — see proxy.log"));
+      if (isPidAlive(child.pid)) {
+        settled = true;
+        closeLogFd();
+        resolve();
+      } else {
+        failStartup(new Error("headroom proxy exited during startup — see proxy.log"));
+      }
     }, STARTUP_TIMEOUT_MS);
 
+    child.once("error", (error) => {
+      failStartup(error);
+    });
+
     child.once("exit", (code) => {
       clearTimeout(startupTimer);
-      clearPid();
-      fs.closeSync(outFd);
+      clearPid(child.pid);
+      closeLogFd();
+      if (settled) return;
       const e = new Error(`headroom proxy exited early (code=${code}) — see proxy.log`);
       e.code = "EARLY_EXIT";
-      reject(e);
+      failStartup(e);
     });
   });
 
-  // Close parent's copy of the fd; child retains its own after unref.
-  fs.closeSync(outFd);
-
   return { pid: child.pid, alreadyRunning: false };
 }
 
@@ -115,11 +158,12 @@ export function stopHeadroomProxy() {
   try {
     process.kill(pid, "SIGTERM");
     // Give it a moment, then force if still alive.
-    setTimeout(() => {
+    const forceKillTimer = setTimeout(() => {
       if (isPidAlive(pid)) {
         try { process.kill(pid, "SIGKILL"); } catch { /* already gone */ }
       }
     }, 2000);
+    forceKillTimer.unref?.();
     clearPid();
     return { stopped: true, pid };
   } catch (e) {
@@ -158,6 +202,51 @@ export function getHeadroomLogTail(maxLines = 200) {
   } catch { return ""; }
 }
 
+function runLoggedCommand(binary, args, { label, errorCode, onSuccess }) {
+  ensureDir();
+  const outFd = fs.openSync(INSTALL_LOG_FILE, "w");
+  let child;
+  try {
+    child = spawn(binary, args, {
+      stdio: ["ignore", outFd, outFd],
+      windowsHide: true,
+      env: { ...process.env },
+    });
+  } catch (error) {
+    fs.closeSync(outFd);
+    throw error;
+  }
+
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (error, resultFactory = null) => {
+      if (settled) return;
+      settled = true;
+      try { fs.closeSync(outFd); } catch { /* already closed */ }
+      if (error) {
+        reject(error);
+        return;
+      }
+      try {
+        resolve(resultFactory());
+      } catch (resultError) {
+        reject(resultError);
+      }
+    };
+
+    child.once("error", (error) => finish(error));
+    child.once("exit", (code) => {
+      if (code === 0) {
+        finish(null, onSuccess);
+        return;
+      }
+      const error = new Error(`${label} exited with code=${code} — see headroom/install.log`);
+      error.code = errorCode;
+      finish(error);
+    });
+  });
+}
+
 // Install (or upgrade) headroom-ai with the requested compression extras.
 // `extras` is a whitelist from HEADROOM_COMPRESSION_EXTRAS — anything else
 // is rejected to keep the install surface predictable. Always installs the
@@ -183,28 +272,17 @@ export async function installHeadroomExtras(extras = []) {
   const spec = `headroom-ai[${extrasList}]`;
   const args = ["-m", "pip", "install", "--upgrade", spec];
 
-  ensureDir();
-  // Truncate ("w") so the log reflects only the current install for live progress.
-  const outFd = fs.openSync(INSTALL_LOG_FILE, "w");
-  const child = spawn(py, args, {
-    stdio: ["ignore", outFd, outFd],
-    windowsHide: true,
-    env: { ...process.env },
-  });
-
-  return new Promise((resolve, reject) => {
-    child.once("error", (e) => { fs.closeSync(outFd); reject(e); });
-    child.once("exit", (code) => {
-      fs.closeSync(outFd);
-      if (code === 0) {
-        const status = getInstalledHeadroomExtras(py);
-        resolve({ success: true, code, spec, extras: requested, ...status });
-      } else {
-        const err = new Error(`pip install exited with code=${code} — see headroom/install.log`);
-        err.code = "INSTALL_FAILED";
-        reject(err);
-      }
-    });
+  // Truncate the shared log so live progress reflects only this command.
+  return runLoggedCommand(py, args, {
+    label: "pip install",
+    errorCode: "INSTALL_FAILED",
+    onSuccess: () => ({
+      success: true,
+      code: 0,
+      spec,
+      extras: requested,
+      ...getInstalledHeadroomExtras(py),
+    }),
   });
 }
 
@@ -226,27 +304,16 @@ export async function uninstallHeadroomExtras(extras = []) {
   }
   const args = ["-m", "pip", "uninstall", "-y", ...pkgs];
 
-  ensureDir();
-  const outFd = fs.openSync(INSTALL_LOG_FILE, "w");
-  const child = spawn(py, args, {
-    stdio: ["ignore", outFd, outFd],
-    windowsHide: true,
-    env: { ...process.env },
-  });
-
-  return new Promise((resolve, reject) => {
-    child.once("error", (e) => { fs.closeSync(outFd); reject(e); });
-    child.once("exit", (code) => {
-      fs.closeSync(outFd);
-      if (code === 0) {
-        const status = getInstalledHeadroomExtras(py);
-        resolve({ success: true, code, removed: pkgs, extras: requested, ...status });
-      } else {
-        const err = new Error(`pip uninstall exited with code=${code} — see headroom/install.log`);
-        err.code = "UNINSTALL_FAILED";
-        reject(err);
-      }
-    });
+  return runLoggedCommand(py, args, {
+    label: "pip uninstall",
+    errorCode: "UNINSTALL_FAILED",
+    onSuccess: () => ({
+      success: true,
+      code: 0,
+      removed: pkgs,
+      extras: requested,
+      ...getInstalledHeadroomExtras(py),
+    }),
   });
 }
 

package/src/lib/oauth/services/bulkImportBrowserEngine.js

@@ -15,6 +15,12 @@ export const DEFAULT_BULK_IMPORT_ENGINE = "cloakbrowser";
 
 const SUPPORTED_ENGINES = new Set(["cloakbrowser"]);
 const CLOAK_PROXY_PROFILES = new WeakMap();
+const CLOAK_BROWSER_PROCESSES = new WeakMap();
+const CLOAK_BROWSER_HEADLESS = new WeakMap();
+
+export const DEFAULT_BROWSER_LAUNCH_TIMEOUT_MS = 90_000;
+export const DEFAULT_CONTEXT_CREATE_TIMEOUT_MS = 30_000;
+export const DEFAULT_CONTEXT_CLOSE_TIMEOUT_MS = 5_000;
 
 export const PROXY_EGRESS_ECHO_URLS = Object.freeze([
   "https://myip.ipip.net",
@@ -231,6 +237,44 @@ export async function newStealthContext(browser, options = {}) {
   return context;
 }
 
+export async function withAutomationTimeout(
+  task,
+  {
+    timeoutMs,
+    message = `Automation operation timed out after ${timeoutMs}ms`,
+    code = "AUTOMATION_TIMEOUT",
+    onTimeout,
+    onLateResolve,
+  } = {},
+) {
+  const operation = Promise.resolve(task);
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) return operation;
+
+  let timer = null;
+  let timedOut = false;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        onTimeout?.();
+      } catch {
+        // Preserve the timeout as the primary failure.
+      }
+      reject(Object.assign(new Error(message), { code }));
+    }, timeoutMs);
+    timer.unref?.();
+  });
+
+  try {
+    return await Promise.race([operation, timeout]);
+  } finally {
+    if (timer) clearTimeout(timer);
+    if (timedOut && typeof onLateResolve === "function") {
+      void operation.then(onLateResolve).catch(() => null);
+    }
+  }
+}
+
 export function parseProxyEgressIp(value) {
   const raw = String(value || "").trim();
   if (!raw) return null;
@@ -469,6 +513,48 @@ export function getCloakProxyProfile(browser) {
     : null;
 }
 
+export function getBulkImportBrowserHeadless(browser) {
+  return browser && typeof browser === "object" && CLOAK_BROWSER_HEADLESS.has(browser)
+    ? CLOAK_BROWSER_HEADLESS.get(browser)
+    : null;
+}
+
+function resolveBrowserProcess(browser) {
+  if (!browser || typeof browser !== "object") return null;
+
+  const tracked = CLOAK_BROWSER_PROCESSES.get(browser);
+  if (tracked) return tracked;
+
+  // Puppeteer exposes process(); Playwright does not. CloakBrowser returns a
+  // local Playwright Browser, so resolve its server-side BrowserProcess once
+  // while the connection is still alive and keep that owned handle in a WeakMap.
+  try {
+    const documented = typeof browser.process === "function" ? browser.process() : null;
+    if (documented?.pid) return documented;
+  } catch {
+    // Fall through to the local Playwright implementation.
+  }
+  try {
+    const impl = browser?._connection?.toImpl?.(browser);
+    const processHandle = impl?.options?.browserProcess?.process || null;
+    if (processHandle?.pid) return processHandle;
+  } catch {
+    // Remote Playwright connections intentionally do not expose a process.
+  }
+  return null;
+}
+
+function trackBrowserProcess(browser) {
+  const processHandle = resolveBrowserProcess(browser);
+  if (browser && processHandle) CLOAK_BROWSER_PROCESSES.set(browser, processHandle);
+  return processHandle;
+}
+
+export function getBrowserProcessId(browser) {
+  const pid = Number(resolveBrowserProcess(browser)?.pid);
+  return Number.isFinite(pid) && pid > 1 ? pid : null;
+}
+
 async function launchCloakbrowser({
   proxyUrl,
   headless = false,
@@ -538,6 +624,8 @@ async function launchCloakbrowser({
   try {
     // Do not wrap with stock stealth scripts — CloakBrowser patches at binary level.
     const browser = await cloak.launch(effectiveLaunchOpts);
+    trackBrowserProcess(browser);
+    CLOAK_BROWSER_HEADLESS.set(browser, useHeadless);
     if (proxyProfile) {
       CLOAK_PROXY_PROFILES.set(browser, Object.freeze({ ...proxyProfile }));
     }
@@ -548,6 +636,8 @@ async function launchCloakbrowser({
       const display = ensureDisplayForHeadedBrowser();
       if (display.ok) {
         const browser = await cloak.launch(effectiveLaunchOpts);
+        trackBrowserProcess(browser);
+        CLOAK_BROWSER_HEADLESS.set(browser, useHeadless);
         if (proxyProfile) {
           CLOAK_PROXY_PROFILES.set(browser, Object.freeze({ ...proxyProfile }));
         }
@@ -581,15 +671,22 @@ export async function launchBulkImportBrowser({
   headless = false,
   windowSize = null,
   requireProxyGeoip = false,
+  timeoutMs = DEFAULT_BROWSER_LAUNCH_TIMEOUT_MS,
 } = {}) {
   // engine arg kept for API compatibility; always cloakbrowser.
   void normalizeBulkImportEngine(engine);
-  return launchCloakbrowser({
+  const launchTask = launchCloakbrowser({
     proxyUrl,
     headless: headless === true,
     windowSize,
     requireProxyGeoip,
   });
+  return withAutomationTimeout(launchTask, {
+    timeoutMs,
+    message: `CloakBrowser launch timed out after ${Math.round(timeoutMs / 1000)}s`,
+    code: "BROWSER_LAUNCH_TIMEOUT",
+    onLateResolve: (browser) => forceCloseBrowser(browser),
+  });
 }
 
 export function makeBrowserLauncher({ engine, proxyUrl, headless = false, windowSize = null } = {}) {
@@ -602,45 +699,58 @@ export function makeBrowserLauncher({ engine, proxyUrl, headless = false, window
 export async function forceCloseBrowser(browser, { timeoutMs = 4_000 } = {}) {
   if (!browser) return;
 
-  let pid = null;
-  try {
-    const proc = typeof browser.process === "function" ? browser.process() : null;
-    pid = proc?.pid || null;
-  } catch {
-    pid = null;
-  }
+  const ownedProcess = resolveBrowserProcess(browser);
+  const pid = Number(ownedProcess?.pid);
+  const validPid = Number.isFinite(pid) && pid > 1 ? pid : null;
 
   try {
-    await Promise.race([
-      Promise.resolve()
-        .then(() => browser.close())
-        .catch(() => null),
-      new Promise((resolve) => setTimeout(resolve, timeoutMs)),
-    ]);
+    await withAutomationTimeout(
+      Promise.resolve().then(() => browser.close()),
+      {
+        timeoutMs,
+        message: `Browser close timed out after ${timeoutMs}ms`,
+        code: "BROWSER_CLOSE_TIMEOUT",
+      },
+    );
   } catch {
-    // ignore
+    // Escalate to the process owned by this browser below.
   }
 
-  if (pid && Number.isFinite(pid) && pid > 1) {
-    for (const signal of ["SIGTERM", "SIGKILL"]) {
-      try {
-        process.kill(pid, 0);
-      } catch {
-        break;
-      }
-      try {
-        process.kill(pid, signal);
-      } catch {
-        // ignore
+  const isAlive = () => {
+    if (!ownedProcess) return false;
+    if (ownedProcess.exitCode != null || ownedProcess.signalCode != null) return false;
+    if (!validPid) return true;
+    try {
+      process.kill(validPid, 0);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+
+  if (ownedProcess && isAlive()) {
+    const signalOwnedProcess = (signal) => {
+      // Playwright launches Chromium detached on Unix. Signal the process group
+      // first so renderer children cannot outlive the browser parent.
+      if (validPid && process.platform !== "win32") {
+        try {
+          process.kill(-validPid, signal);
+        } catch {
+          // A non-detached process has no group keyed by its pid.
+        }
       }
       try {
-        process.kill(-pid, signal);
+        if (typeof ownedProcess.kill === "function") ownedProcess.kill(signal);
+        else if (validPid) process.kill(validPid, signal);
       } catch {
-        // ignore
-      }
-      if (signal === "SIGTERM") {
-        await new Promise((r) => setTimeout(r, 400));
+        // Process may have exited between the liveness check and signal.
       }
+    };
+
+    signalOwnedProcess("SIGTERM");
+    await new Promise((resolve) => setTimeout(resolve, 400));
+    if (isAlive()) {
+      signalOwnedProcess("SIGKILL");
     }
   }
 }