qunitx-cli 0.17.1 → 0.17.6

package/bin/qunitx.js

@@ -4,7 +4,7 @@
 // (qunitx-cli-linux-x64, qunitx-cli-darwin-arm64, etc.) when available.
 // Falls back to the bundled JS CLI (dist/cli.js) which requires Node.js + node_modules.
 import { spawn } from 'node:child_process';
-import { access, constants } from 'node:fs/promises';
+import { access, constants, readFile } from 'node:fs/promises';
 import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
 import { dirname, join } from 'node:path';
@@ -12,6 +12,10 @@ import { dirname, join } from 'node:path';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
 
+const currentVersion = JSON.parse(
+  await readFile(join(__dirname, '../package.json'), 'utf8'),
+).version;
+
 const platformMap = {
   'linux-x64': { seaPkg: 'qunitx-cli-linux-x64', esbuildPkg: '@esbuild/linux-x64', bin: 'qunitx' },
   'linux-arm64': {
@@ -41,7 +45,10 @@ const target = platformMap[`${process.platform}-${process.arch}`];
 async function trySeaBinary() {
   if (!target) return false;
   try {
-    const pkgDir = dirname(require.resolve(`${target.seaPkg}/package.json`));
+    const pkgJsonPath = require.resolve(`${target.seaPkg}/package.json`);
+    const seaVersion = JSON.parse(await readFile(pkgJsonPath, 'utf8')).version;
+    if (seaVersion !== currentVersion) return false;
+    const pkgDir = dirname(pkgJsonPath);
     const binaryPath = join(pkgDir, 'bin', target.bin);
     await access(binaryPath, constants.X_OK);
 
@@ -52,10 +59,12 @@ async function trySeaBinary() {
           `${target.esbuildPkg}/bin/esbuild${process.platform === 'win32' ? '.exe' : ''}`,
         );
         env = { ...env, ESBUILD_BINARY_PATH: esbuildBin };
-      } catch (_) {}
+      } catch (_e) {
+        // esbuild binary not found in optional package — env stays as-is
+      }
     }
 
-    await new Promise((resolve, reject) => {
+    await new Promise((_resolve, reject) => {
       const child = spawn(binaryPath, process.argv.slice(2), { stdio: 'inherit', env });
       child.on('close', (code) => process.exit(code ?? 1));
       child.on('error', reject);

package/dist/cli.js

@@ -37,6 +37,22 @@ var init_find_chrome = __esm({
   }
 });
 
+// lib/utils/kill-process-group.ts
+function killProcessGroup(pid) {
+  try {
+    if (process.platform === "win32") {
+      process.kill(pid, "SIGKILL");
+    } else {
+      process.kill(-pid, "SIGKILL");
+    }
+  } catch {
+  }
+}
+var init_kill_process_group = __esm({
+  "lib/utils/kill-process-group.ts"() {
+  }
+});
+
 // lib/utils/pre-launch-chrome.ts
 import { spawn } from "node:child_process";
 import { mkdtemp, rm } from "node:fs/promises";
@@ -45,16 +61,20 @@ import path from "node:path";
 async function preLaunchChrome(chromePath, args, headless = true) {
   if (!chromePath) return null;
   const userDataDir = await mkdtemp(path.join(os.tmpdir(), "qunitx-chrome-"));
-  const cleanup = () => rm(userDataDir, { recursive: true, force: true }).catch(() => {
-  });
   const headlessArgs = headless ? ["--headless=new"] : [];
   const proc = spawn(
     chromePath,
     ["--remote-debugging-port=0", `--user-data-dir=${userDataDir}`, ...headlessArgs, ...args],
-    { stdio: ["ignore", "ignore", "pipe"] }
+    // detached: true puts Chrome in its own process group (PGID = proc.pid).
+    // This lets shutdown() kill the entire group (main process + all renderer/GPU/utility
+    // children) with process.kill(-proc.pid, 'SIGKILL'), preventing orphaned Chrome
+    // subprocesses from accumulating inotify watches across test runs.
+    { stdio: ["ignore", "ignore", "pipe"], detached: true }
   );
+  let cdpConnected = false;
   proc.on("close", () => {
-    cleanup();
+    if (!cdpConnected) rm(userDataDir, { recursive: true, force: true }).catch(() => {
+    });
     resolveWith(null);
   });
   proc.on("error", () => resolveWith(null));
@@ -66,6 +86,7 @@ async function preLaunchChrome(chromePath, args, headless = true) {
       buffer += chunk.toString();
       const match = buffer.match(CDP_URL_REGEX);
       if (!match) return;
+      cdpConnected = true;
       proc.unref();
       proc.stderr.unref();
       resolve({
@@ -84,25 +105,45 @@ async function preLaunchChrome(chromePath, args, headless = true) {
       }
       proc.once("close", resolve);
     });
-    try {
-      if (proc.exitCode === null) proc.kill("SIGKILL");
-    } catch {
-    }
-    await closed.then(() => cleanup());
+    if (proc.exitCode === null) killProcessGroup(proc.pid);
+    await closed;
+    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((r) => setTimeout(r, 20));
+      }
+      clearTimeout(warnTimer);
+      await rm(userDataDir, { recursive: true, force: true }).catch(() => {
+      });
+    });
   }
 }
 var CDP_URL_REGEX;
 var init_pre_launch_chrome = __esm({
   "lib/utils/pre-launch-chrome.ts"() {
+    init_kill_process_group();
     CDP_URL_REGEX = /DevTools listening on (ws:\/\/[^\s]+)/;
   }
 });
 
 // lib/utils/chromium-args.ts
-var chromium_args_default;
+var CHROMIUM_ARGS;
 var init_chromium_args = __esm({
   "lib/utils/chromium-args.ts"() {
-    chromium_args_default = [
+    CHROMIUM_ARGS = [
       // ── Sandbox / rendering ──────────────────────────────────────────────────────
       "--no-sandbox",
       // required in most CI/container environments
@@ -202,6 +243,7 @@ var init_early_chrome = __esm({
   "lib/utils/early-chrome.ts"() {
     init_find_chrome();
     init_pre_launch_chrome();
+    init_kill_process_group();
     init_chromium_args();
     init_perf_logger();
     NON_RUN_COMMANDS = /* @__PURE__ */ new Set(["help", "h", "p", "print", "new", "n", "g", "generate", "init"]);
@@ -220,16 +262,13 @@ var init_early_chrome = __esm({
     if (!openWatchMode) {
       process.on("exit", () => {
         if (!earlyChrome) return;
-        try {
-          earlyChrome.proc.kill("SIGKILL");
-        } catch {
-        }
+        killProcessGroup(earlyChrome.proc.pid);
       });
     }
     perfLog("early-chrome.js: module evaluated");
     earlyBrowserPromise = isRunCommand && browserFromArgv === "chromium" ? findChrome().then((chromePath) => {
       perfLog("early-chrome.js: findChrome resolved", chromePath);
-      return preLaunchChrome(chromePath, chromium_args_default, !openWatchMode);
+      return preLaunchChrome(chromePath, CHROMIUM_ARGS, !openWatchMode);
     }).then((info) => {
       perfLog("early-chrome.js: Chrome CDP ready", info?.cdpEndpoint ?? null);
       if (info) earlyChrome = info;
@@ -611,8 +650,12 @@ var init_http = __esm({
        * @returns {Promise<void>}
        */
       close() {
+        this.wss.clients.forEach((client) => client.terminate());
+        const wssClose = new Promise((resolve) => this.wss.close(() => resolve()));
         this._server.closeAllConnections?.();
-        return new Promise((resolve) => this._server.close(resolve));
+        const serverClose = new Promise((resolve) => this._server.close(resolve));
+        return Promise.all([wssClose, serverClose]).then(() => {
+        });
       }
       /** Registers a GET route handler. */
       get(path6, handler) {
@@ -1118,7 +1161,7 @@ async function launchBrowser(config) {
     }
     const executablePath = await findChrome();
     const launchOptions = {
-      args: chromium_args_default,
+      args: CHROMIUM_ARGS,
       headless: true,
       // Disable Playwright's async SIGTERM/SIGHUP handlers. When the CLI is killed by an
       // external signal (e.g. exec() timeout in tests), those handlers start an async browser
@@ -1281,6 +1324,7 @@ async function buildTestBundle(config, cachedContent) {
     return;
   }
   const outfile = `${projectRoot}/${output}/tests.js`;
+  await fs8.mkdir(`${projectRoot}/${output}`, { recursive: true });
   const sourcemap = config.debug ? "inline" : config.watch ? "linked" : false;
   const needsDisk = true;
   const [allTestCode] = await Promise.all([
@@ -1824,7 +1868,8 @@ var init_write_output_static_files = __esm({
 // lib/commands/run.ts
 var run_exports = {};
 __export(run_exports, {
-  default: () => run
+  default: () => run,
+  run: () => run
 });
 import fs11 from "node:fs/promises";
 import { normalize } from "node:path";
@@ -2096,7 +2141,7 @@ init_color();
 var package_default = {
   name: "qunitx-cli",
   type: "module",
-  version: "0.17.1",
+  version: "0.17.6",
   description: "Browser runner for QUnitx: run your qunitx tests in google-chrome",
   author: "Izel Nakri",
   license: "MIT",
@@ -2119,7 +2164,7 @@ var package_default = {
     prepublishOnly: "npm run build",
     format: 'prettier --check "lib/**/*.ts" "test/**/*.ts" "scripts/**/*.js" "bin/**/*.js" "*.ts" "package.json" ".github/**/*.yml"',
     "format:fix": 'prettier --write "lib/**/*.ts" "test/**/*.ts" "scripts/**/*.js" "bin/**/*.js" "*.ts" "package.json" ".github/**/*.yml"',
-    lint: "deno lint lib/ cli.ts",
+    lint: "deno lint lib/ bin/ cli.ts",
     "lint:docs": "node scripts/lint-docs.js",
     docs: `deno doc --html --name="qunitx-cli" --output=docs/lib 'lib/**/*.ts' README.md`,
     "changelog:unreleased": "git-cliff --unreleased --strip all",
@@ -2226,12 +2271,11 @@ async function searchInParentDirectories(directory, targetEntry) {
     targetEntry
   );
 }
-var search_in_parent_directories_default = searchInParentDirectories;
 
 // lib/utils/find-project-root.ts
 async function findProjectRoot() {
   try {
-    const absolutePath = await search_in_parent_directories_default(".", "package.json");
+    const absolutePath = await searchInParentDirectories(".", "package.json");
     if (!absolutePath.includes("package.json")) {
       throw new Error("package.json mising");
     }
@@ -2246,7 +2290,7 @@ async function findProjectRoot() {
 init_path_exists();
 
 // lib/setup/default-project-config-values.ts
-var default_project_config_values_default = {
+var defaultProjectConfigValues = {
   output: "tmp",
   timeout: 2e4,
   failFast: false,
@@ -2262,7 +2306,7 @@ async function initializeProject() {
   const oldPackageJSON = JSON.parse(await fs3.readFile(`${projectRoot}/package.json`));
   const existingQunitx = oldPackageJSON.qunitx || {};
   const cliHtmlPaths = process.argv.slice(2).filter((arg) => arg.endsWith(".html"));
-  const config = Object.assign({}, default_project_config_values_default, existingQunitx, {
+  const config = Object.assign({}, defaultProjectConfigValues, existingQunitx, {
     htmlPaths: cliHtmlPaths.length > 0 ? cliHtmlPaths : existingQunitx.htmlPaths || ["test/tests.html"]
   });
   await Promise.all([
@@ -2313,9 +2357,22 @@ init_color();
 import fs4 from "node:fs/promises";
 init_path_exists();
 init_read_boilerplate();
+
+// lib/utils/convert-to-pascal-case.ts
+function convertToPascalCase(str) {
+  return str.split(/[-_]+/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+
+// lib/commands/generate.ts
+function pathToModuleName(filePath) {
+  const withoutExt = filePath.replace(/\.(js|ts)$/, "");
+  const segments = withoutExt.split("/");
+  const targetNames = segments[0] === "test" || segments[0] === "tests" ? segments.slice(1) : segments;
+  return targetNames.map(convertToPascalCase).join(" | ");
+}
 async function generateTestFiles() {
   const projectRoot = await findProjectRoot();
-  const moduleName = process.argv[3];
+  const moduleName = pathToModuleName(process.argv[3]);
   const path6 = process.argv[3].endsWith(".js") || process.argv[3].endsWith(".ts") ? `${projectRoot}/${process.argv[3]}` : `${projectRoot}/${process.argv[3]}.js`;
   if (await pathExists(path6)) {
     console.log(`${path6} already exists!`);
@@ -2523,7 +2580,7 @@ async function setupConfig() {
   const projectPackageJSON = await readConfigFromPackageJSON(projectRoot);
   const inputs2 = cliConfigFlags.inputs.concat(readInputsFromPackageJSON(projectPackageJSON));
   const config = {
-    ...default_project_config_values_default,
+    ...defaultProjectConfigValues,
     htmlPaths: [],
     ...projectPackageJSON.qunitx || {},
     ...cliConfigFlags,
@@ -2568,10 +2625,7 @@ process4.title = "qunitx";
   } else if (["init"].includes(process4.argv[2])) {
     return await initializeProject();
   }
-  const [config, { default: run2 }] = await Promise.all([
-    setupConfig(),
-    Promise.resolve().then(() => (init_run(), run_exports))
-  ]);
+  const [config, { run: run2 }] = await Promise.all([setupConfig(), Promise.resolve().then(() => (init_run(), run_exports))]);
   try {
     return await run2(config);
   } catch (error) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "qunitx-cli",
   "type": "module",
-  "version": "0.17.1",
+  "version": "0.17.6",
   "description": "Browser runner for QUnitx: run your qunitx tests in google-chrome",
   "author": "Izel Nakri",
   "license": "MIT",
@@ -24,7 +24,7 @@
     "prepublishOnly": "npm run build",
     "format": "prettier --check \"lib/**/*.ts\" \"test/**/*.ts\" \"scripts/**/*.js\" \"bin/**/*.js\" \"*.ts\" \"package.json\" \".github/**/*.yml\"",
     "format:fix": "prettier --write \"lib/**/*.ts\" \"test/**/*.ts\" \"scripts/**/*.js\" \"bin/**/*.js\" \"*.ts\" \"package.json\" \".github/**/*.yml\"",
-    "lint": "deno lint lib/ cli.ts",
+    "lint": "deno lint lib/ bin/ cli.ts",
     "lint:docs": "node scripts/lint-docs.js",
     "docs": "deno doc --html --name=\"qunitx-cli\" --output=docs/lib 'lib/**/*.ts' README.md",
     "changelog:unreleased": "git-cliff --unreleased --strip all",