qunitx-cli 0.17.5 → 0.17.7

package/dist/cli.js

@@ -53,6 +53,76 @@ var init_kill_process_group = __esm({
   }
 });
 
+// lib/utils/cleanup-browser-dir.ts
+import fs from "node:fs/promises";
+async function cleanupBrowserDir(dirPath) {
+  if (process.platform !== "linux") {
+    await fs.rm(dirPath, { recursive: true, force: true }).catch(() => {
+    });
+    return;
+  }
+  const dirName = dirPath.split("/").pop();
+  const killedPids = /* @__PURE__ */ new Set();
+  const procEntries = await fs.readdir("/proc").catch(() => []);
+  await Promise.all(
+    procEntries.map(async (entry) => {
+      if (!/^\d+$/.test(entry)) return;
+      const pid = parseInt(entry);
+      try {
+        const [cwd, cmdline] = await Promise.all([
+          fs.readlink(`/proc/${entry}/cwd`).catch(() => ""),
+          fs.readFile(`/proc/${entry}/cmdline`, "utf8").catch(() => "")
+        ]);
+        if (!cwd.startsWith(dirPath) && !cmdline.includes(dirName)) return;
+        try {
+          process.kill(pid, "SIGKILL");
+          killedPids.add(pid);
+        } catch {
+        }
+      } catch {
+      }
+    })
+  );
+  while (killedPids.size > 0) {
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    for (const pid of killedPids) {
+      try {
+        process.kill(pid, 0);
+      } catch {
+        killedPids.delete(pid);
+      }
+    }
+  }
+  const deadline = Date.now() + 1e3;
+  while (Date.now() < deadline) {
+    const removed = await fs.rm(dirPath, { recursive: true, force: true }).then(() => true).catch(() => false);
+    if (removed) break;
+    await new Promise((resolve) => setTimeout(resolve, 20));
+  }
+  if (await fs.access(dirPath).then(() => true).catch(() => false)) {
+    const diagEntries = await fs.readdir("/proc").catch(() => []);
+    await Promise.all(
+      diagEntries.map(async (entry) => {
+        if (!/^\d+$/.test(entry)) return;
+        try {
+          const cwd = await fs.readlink(`/proc/${entry}/cwd`).catch(() => "");
+          if (!cwd.startsWith(dirPath)) return;
+          const cmdline = await fs.readFile(`/proc/${entry}/cmdline`, "utf8").catch(() => "");
+          process.stderr.write(
+            `# [qunitx] cleanup failed: pid ${entry} still holds ${dirPath} as cwd (cmdline: ${cmdline.replace(/\0/g, " ").slice(0, 120)})
+`
+          );
+        } catch {
+        }
+      })
+    );
+  }
+}
+var init_cleanup_browser_dir = __esm({
+  "lib/utils/cleanup-browser-dir.ts"() {
+  }
+});
+
 // lib/utils/pre-launch-chrome.ts
 import { spawn } from "node:child_process";
 import { mkdtemp, rm } from "node:fs/promises";
@@ -107,7 +177,26 @@ async function preLaunchChrome(chromePath, args, headless = true) {
     });
     if (proc.exitCode === null) killProcessGroup(proc.pid);
     await closed;
-    await rm(userDataDir, { recursive: true, force: true }).catch(() => {
+    await rm(userDataDir, { recursive: true, force: true }).catch(async () => {
+      const pgid = proc.pid;
+      const warnTimer = setTimeout(
+        () => process.stderr.write(
+          `# [qunitx] warning: Chrome process group ${pgid} still alive 500ms after SIGKILL, waiting...
+`
+        ),
+        500
+      );
+      warnTimer.unref();
+      while (true) {
+        try {
+          process.kill(-pgid, 0);
+        } catch {
+          break;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 20));
+      }
+      clearTimeout(warnTimer);
+      await cleanupBrowserDir(userDataDir);
     });
   }
 }
@@ -115,6 +204,7 @@ var CDP_URL_REGEX;
 var init_pre_launch_chrome = __esm({
   "lib/utils/pre-launch-chrome.ts"() {
     init_kill_process_group();
+    init_cleanup_browser_dir();
     CDP_URL_REGEX = /DevTools listening on (ws:\/\/[^\s]+)/;
   }
 });
@@ -296,10 +386,10 @@ var init_color = __esm({
 });
 
 // lib/utils/path-exists.ts
-import fs from "node:fs/promises";
+import fs2 from "node:fs/promises";
 async function pathExists(path6) {
   try {
-    await fs.access(path6);
+    await fs2.access(path6);
     return true;
   } catch {
     return false;
@@ -311,7 +401,7 @@ var init_path_exists = __esm({
 });
 
 // lib/utils/read-boilerplate.ts
-import fs2 from "node:fs/promises";
+import fs3 from "node:fs/promises";
 import { dirname, join as join2 } from "node:path";
 import { fileURLToPath } from "node:url";
 async function readBoilerplate(relativePath) {
@@ -320,7 +410,7 @@ async function readBoilerplate(relativePath) {
   const __dirname = dirname(fileURLToPath(import.meta.url));
   for (const base of ["../templates", "../../templates"]) {
     try {
-      return (await fs2.readFile(join2(__dirname, base, relativePath))).toString();
+      return (await fs3.readFile(join2(__dirname, base, relativePath))).toString();
     } catch {
     }
   }
@@ -790,7 +880,7 @@ var init_http = __esm({
 });
 
 // lib/setup/web-server.ts
-import fs7 from "node:fs";
+import fs8 from "node:fs";
 import path4 from "node:path";
 function setupWebServer(config, cachedContent) {
   const STATIC_FILES_PATH = path4.join(config.projectRoot, config.output);
@@ -934,7 +1024,7 @@ function setupWebServer(config, cachedContent) {
     if (statusCode === 404) {
       res.end();
     } else {
-      fs7.createReadStream(filePath).pipe(res);
+      fs8.createReadStream(filePath).pipe(res);
     }
     console.log(`# [HTTPServer] GET ${url} ${statusCode} - ${/* @__PURE__ */ new Date() - requestStartedAt}ms`);
   });
@@ -1114,7 +1204,7 @@ var init_web_server = __esm({
     init_color();
     init_path_exists();
     init_http();
-    fsPromise = fs7.promises;
+    fsPromise = fs8.promises;
   }
 });
 
@@ -1294,7 +1384,7 @@ var init_display_final_result = __esm({
 });
 
 // lib/commands/run/tests-in-browser.ts
-import fs8 from "node:fs/promises";
+import fs9 from "node:fs/promises";
 import esbuild from "esbuild";
 async function buildTestBundle(config, cachedContent) {
   const { projectRoot, output } = config;
@@ -1304,7 +1394,7 @@ async function buildTestBundle(config, cachedContent) {
     return;
   }
   const outfile = `${projectRoot}/${output}/tests.js`;
-  await fs8.mkdir(`${projectRoot}/${output}`, { recursive: true });
+  await fs9.mkdir(`${projectRoot}/${output}`, { recursive: true });
   const sourcemap = config.debug ? "inline" : config.watch ? "linked" : false;
   const needsDisk = true;
   const [allTestCode] = await Promise.all([
@@ -1333,8 +1423,8 @@ async function buildTestBundle(config, cachedContent) {
       cachedContent.htmlPathsToRunTests.map(async (htmlPath) => {
         const targetPath = `${config.projectRoot}/${config.output}${htmlPath}`;
         if (htmlPath !== "/") {
-          await fs8.rm(targetPath, { force: true, recursive: true });
-          await fs8.mkdir(targetPath.split("/").slice(0, -1).join("/"), { recursive: true });
+          await fs9.rm(targetPath, { force: true, recursive: true });
+          await fs9.mkdir(targetPath.split("/").slice(0, -1).join("/"), { recursive: true });
         }
       })
     )
@@ -1447,7 +1537,7 @@ async function buildWithOverlayfsRetry(options, needsDisk) {
   }
   if (needsDisk) {
     await Promise.all(
-      result.outputFiles.map((outputFile) => fs8.writeFile(outputFile.path, outputFile.contents))
+      result.outputFiles.map((outputFile) => fs9.writeFile(outputFile.path, outputFile.contents))
     );
   }
   return js;
@@ -1559,7 +1649,7 @@ var init_tests_in_browser = __esm({
 });
 
 // lib/setup/file-watcher.ts
-import fs9 from "node:fs";
+import fs10 from "node:fs";
 import { stat, lstat } from "node:fs/promises";
 import path5 from "node:path";
 function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFunc) {
@@ -1572,15 +1662,15 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
     if (symlinkPollers.has(filePath)) return;
     const handler = (curr) => {
       if (curr.nlink === 0) {
-        fs9.unwatchFile(filePath, handler);
+        fs10.unwatchFile(filePath, handler);
         symlinkPollers.delete(filePath);
         if (filePath in config.fsTree) {
           handleWatchEvent(config, extensions, "unlink", filePath, onEventFunc, onFinishFunc);
         }
       }
     };
-    fs9.watchFile(filePath, { interval: 500, persistent: false }, handler);
-    symlinkPollers.set(filePath, () => fs9.unwatchFile(filePath, handler));
+    fs10.watchFile(filePath, { interval: 500, persistent: false }, handler);
+    symlinkPollers.set(filePath, () => fs10.unwatchFile(filePath, handler));
   }
   function untrackSymlink(filePath) {
     symlinkPollers.get(filePath)?.();
@@ -1589,7 +1679,7 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
   for (const watchPath of testFileLookupPaths) {
     let ready = false;
     const lastChangeMs = {};
-    const childWatcher = fs9.watch(watchPath, { recursive: true }, async (eventType, filename) => {
+    const childWatcher = fs10.watch(watchPath, { recursive: true }, async (eventType, filename) => {
       if (!ready || !filename) return;
       const fullPath = path5.join(watchPath, filename);
       if (eventType === "change") {
@@ -1619,7 +1709,7 @@ function setupFileWatchers(testFileLookupPaths, config, onEventFunc, onFinishFun
     const parentDir = path5.dirname(watchPath);
     const watchedBasename = path5.basename(watchPath);
     let parentUnlinkFired = false;
-    const parentWatcher = fs9.watch(parentDir, async (eventType, filename) => {
+    const parentWatcher = fs10.watch(parentDir, async (eventType, filename) => {
       if (!ready || filename !== watchedBasename || eventType !== "rename") return;
       if (parentUnlinkFired) return;
       parentUnlinkFired = true;
@@ -1820,12 +1910,12 @@ var init_keyboard_events = __esm({
 });
 
 // lib/setup/write-output-static-files.ts
-import fs10 from "node:fs/promises";
+import fs11 from "node:fs/promises";
 async function writeOutputStaticFiles({ projectRoot, output }, cachedContent) {
   const staticHTMLPromises = Object.keys(cachedContent.staticHTMLs).map(async (staticHTMLKey) => {
     const htmlRelativePath = staticHTMLKey.replace(`${projectRoot}/`, "");
     await ensureFolderExists(`${projectRoot}/${output}/${htmlRelativePath}`);
-    await fs10.writeFile(
+    await fs11.writeFile(
       `${projectRoot}/${output}/${htmlRelativePath}`,
       cachedContent.staticHTMLs[staticHTMLKey]
     );
@@ -1833,12 +1923,12 @@ async function writeOutputStaticFiles({ projectRoot, output }, cachedContent) {
   const assetPromises = Array.from(cachedContent.assets).map(async (assetAbsolutePath) => {
     const assetRelativePath = assetAbsolutePath.replace(`${projectRoot}/`, "");
     await ensureFolderExists(`${projectRoot}/${output}/${assetRelativePath}`);
-    await fs10.copyFile(assetAbsolutePath, `${projectRoot}/${output}/${assetRelativePath}`);
+    await fs11.copyFile(assetAbsolutePath, `${projectRoot}/${output}/${assetRelativePath}`);
   });
   await Promise.all(staticHTMLPromises.concat(assetPromises));
 }
 async function ensureFolderExists(assetPath) {
-  await fs10.mkdir(assetPath.split("/").slice(0, -1).join("/"), { recursive: true });
+  await fs11.mkdir(assetPath.split("/").slice(0, -1).join("/"), { recursive: true });
 }
 var init_write_output_static_files = __esm({
   "lib/setup/write-output-static-files.ts"() {
@@ -1851,7 +1941,7 @@ __export(run_exports, {
   default: () => run,
   run: () => run
 });
-import fs11 from "node:fs/promises";
+import fs12 from "node:fs/promises";
 import { normalize } from "node:path";
 import { availableParallelism } from "node:os";
 async function run(config) {
@@ -2016,7 +2106,7 @@ async function run(config) {
 }
 async function buildCachedContent(config, htmlPaths) {
   const htmlBuffers = await Promise.all(
-    config.htmlPaths.map((htmlPath) => fs11.readFile(htmlPath).catch(() => null))
+    config.htmlPaths.map((htmlPath) => fs12.readFile(htmlPath).catch(() => null))
   );
   const cachedContent = htmlPaths.reduce(
     (result, _htmlPath, index) => {
@@ -2121,7 +2211,7 @@ init_color();
 var package_default = {
   name: "qunitx-cli",
   type: "module",
-  version: "0.17.5",
+  version: "0.17.7",
   description: "Browser runner for QUnitx: run your qunitx tests in google-chrome",
   author: "Izel Nakri",
   license: "MIT",
@@ -2231,7 +2321,7 @@ ${color("$ qunitx new $testFileName")}  # Creates a qunitx test file
 }
 
 // lib/commands/init.ts
-import fs3 from "node:fs/promises";
+import fs4 from "node:fs/promises";
 import path2 from "node:path";
 
 // lib/utils/find-project-root.ts
@@ -2283,7 +2373,7 @@ var defaultProjectConfigValues = {
 init_read_boilerplate();
 async function initializeProject() {
   const projectRoot = await findProjectRoot();
-  const oldPackageJSON = JSON.parse(await fs3.readFile(`${projectRoot}/package.json`));
+  const oldPackageJSON = JSON.parse(await fs4.readFile(`${projectRoot}/package.json`));
   const existingQunitx = oldPackageJSON.qunitx || {};
   const cliHtmlPaths = process.argv.slice(2).filter((arg) => arg.endsWith(".html"));
   const config = Object.assign({}, defaultProjectConfigValues, existingQunitx, {
@@ -2312,8 +2402,8 @@ async function writeTestsHTML(projectRoot, config, oldPackageJSON) {
           "{{applicationName}}",
           oldPackageJSON.name
         );
-        await fs3.mkdir(targetDirectory, { recursive: true });
-        await fs3.writeFile(targetPath, testHTMLTemplate);
+        await fs4.mkdir(targetDirectory, { recursive: true });
+        await fs4.writeFile(targetPath, testHTMLTemplate);
         console.log(`${targetPath} written`);
       }
     })
@@ -2321,20 +2411,20 @@ async function writeTestsHTML(projectRoot, config, oldPackageJSON) {
 }
 async function rewritePackageJSON(projectRoot, config, oldPackageJSON) {
   const newPackageJSON = Object.assign(oldPackageJSON, { qunitx: config });
-  await fs3.writeFile(`${projectRoot}/package.json`, JSON.stringify(newPackageJSON, null, 2));
+  await fs4.writeFile(`${projectRoot}/package.json`, JSON.stringify(newPackageJSON, null, 2));
 }
 async function writeTSConfigIfNeeded(projectRoot) {
   const targetPath = `${projectRoot}/tsconfig.json`;
   if (!await pathExists(targetPath)) {
     const tsConfigTemplate = await readBoilerplate("setup/tsconfig.json");
-    await fs3.writeFile(targetPath, tsConfigTemplate);
+    await fs4.writeFile(targetPath, tsConfigTemplate);
     console.log(`${targetPath} written`);
   }
 }
 
 // lib/commands/generate.ts
 init_color();
-import fs4 from "node:fs/promises";
+import fs5 from "node:fs/promises";
 init_path_exists();
 init_read_boilerplate();
 
@@ -2361,22 +2451,22 @@ async function generateTestFiles() {
   const testJSContent = await readBoilerplate("test.js");
   const targetFolderPaths = path6.split("/");
   targetFolderPaths.pop();
-  await fs4.mkdir(targetFolderPaths.join("/"), { recursive: true });
-  await fs4.writeFile(path6, testJSContent.replace("{{moduleName}}", moduleName));
+  await fs5.mkdir(targetFolderPaths.join("/"), { recursive: true });
+  await fs5.writeFile(path6, testJSContent.replace("{{moduleName}}", moduleName));
   console.log(green(`${path6} written`));
 }
 
 // lib/setup/config.ts
-import fs6 from "node:fs/promises";
+import fs7 from "node:fs/promises";
 
 // lib/setup/fs-tree.ts
-import fs5, { glob as fsGlob } from "node:fs/promises";
+import fs6, { glob as fsGlob } from "node:fs/promises";
 import path3 from "node:path";
 function isGlob(str) {
   return /[*?{[]/.test(str);
 }
 async function readDirRecursive(dir, filter) {
-  const entries = await fs5.readdir(dir, { recursive: true, withFileTypes: true });
+  const entries = await fs6.readdir(dir, { recursive: true, withFileTypes: true });
   const candidates = entries.filter(
     (dirent) => (dirent.isFile() || dirent.isSymbolicLink()) && filter(dirent.name)
   );
@@ -2385,7 +2475,7 @@ async function readDirRecursive(dir, filter) {
       const fullPath = path3.join(dirent.parentPath, dirent.name);
       if (dirent.isFile()) return fullPath;
       try {
-        const statResult = await fs5.stat(fullPath);
+        const statResult = await fs6.stat(fullPath);
         return statResult.isFile() ? fullPath : null;
       } catch {
         return null;
@@ -2407,7 +2497,7 @@ async function buildFSTree(fileAbsolutePaths, config = {}) {
             }
           }
         } else {
-          const entry = await fs5.stat(fileAbsolutePath);
+          const entry = await fs6.stat(fileAbsolutePath);
           if (entry.isFile()) {
             fsTree[fileAbsolutePath] = null;
           } else if (entry.isDirectory()) {
@@ -2580,7 +2670,7 @@ async function setupConfig() {
   return config;
 }
 async function readConfigFromPackageJSON(projectRoot) {
-  const packageJSON = await fs6.readFile(`${projectRoot}/package.json`);
+  const packageJSON = await fs7.readFile(`${projectRoot}/package.json`);
   return JSON.parse(packageJSON.toString());
 }
 function normalizeHTMLPaths(projectRoot, htmlPaths) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx-cli",
   "type": "module",
-  "version": "0.17.5",
+  "version": "0.17.7",
   "description": "Browser runner for QUnitx: run your qunitx tests in google-chrome",
   "author": "Izel Nakri",
   "license": "MIT",