laxy-verify 1.1.10 → 1.1.11

package/dist/multi-viewport.js

@@ -39,88 +39,163 @@ exports.allViewportsPass = allViewportsPass;
 /**
  * Pro+ multi-viewport Lighthouse checks.
  *
- * This runs one Lighthouse collection per viewport and summarizes the results
- * for desktop, tablet, and mobile. The median logic is kept so the output
- * shape stays compatible with the existing verification report flow.
+ * Each viewport runs through the same direct Lighthouse execution path used by
+ * the main verify flow so Windows cleanup behavior is consistent.
  */
 const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
-const node_module_1 = require("node:module");
-const req = (0, node_module_1.createRequire)(__filename);
-function resolveLhciBin() {
-    return req.resolve("@lhci/cli/src/cli.js");
-}
 const VIEWPORTS = [
-    { name: "desktop", preset: "desktop" },
-    { name: "tablet", preset: "desktop", screenEmulation: "1024x768" },
-    { name: "mobile", preset: "perf" },
+    {
+        name: "desktop",
+        formFactor: "desktop",
+        screen: { mobile: false, width: 1350, height: 940, deviceScaleFactor: 1, disabled: false },
+    },
+    {
+        name: "tablet",
+        formFactor: "desktop",
+        screen: { mobile: false, width: 1024, height: 768, deviceScaleFactor: 1, disabled: false },
+    },
+    {
+        name: "mobile",
+        formFactor: "mobile",
+        screen: { mobile: true, width: 390, height: 844, deviceScaleFactor: 2, disabled: false },
+    },
 ];
-async function runLighthouseForViewport(port, viewport, outputDir) {
-    const lhciBin = resolveLhciBin();
-    const vpDir = path.join(outputDir, viewport.name);
-    if (!fs.existsSync(vpDir))
-        fs.mkdirSync(vpDir, { recursive: true });
-    const args = [
-        lhciBin,
-        "collect",
-        `--url=http://localhost:${port}`,
-        "--numberOfRuns=1",
-        `--outputDir=${vpDir}`,
-        `--preset=${viewport.preset}`,
-    ];
-    const child = (0, node_child_process_1.spawn)("node", args, { shell: false, stdio: ["ignore", "pipe", "pipe"] });
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function removeDirWithRetries(dirPath, retries = 5) {
+    for (let attempt = 0; attempt < retries; attempt++) {
+        try {
+            if (fs.existsSync(dirPath)) {
+                fs.rmSync(dirPath, { recursive: true, force: true });
+            }
+            return;
+        }
+        catch {
+            if (attempt === retries - 1)
+                return;
+            await sleep(250);
+        }
+    }
+}
+function writeViewportRunnerScript(runnerPath) {
+    const source = `import fs from "node:fs/promises";
+import lighthouse from "lighthouse";
+import { launch } from "chrome-launcher";
+
+const [url, reportPath, chromeDir, formFactor, screenJson] = process.argv.slice(2);
+const screen = JSON.parse(screenJson);
+
+const chrome = await launch({
+  logLevel: "error",
+  chromeFlags: [
+    "--headless=new",
+    "--no-sandbox",
+    "--disable-dev-shm-usage",
+    \`--user-data-dir=\${chromeDir}\`,
+  ],
+});
+
+try {
+  const result = await lighthouse(
+    url,
+    {
+      port: chrome.port,
+      output: "json",
+      logLevel: "error",
+      onlyCategories: ["performance", "accessibility", "seo", "best-practices"],
+    },
+    {
+      extends: "lighthouse:default",
+      settings: {
+        formFactor,
+        screenEmulation: screen,
+      },
+    }
+  );
+
+  if (!result?.lhr) {
+    throw new Error("Lighthouse returned no report.");
+  }
+
+  await fs.writeFile(reportPath, JSON.stringify(result.lhr), "utf8");
+} finally {
+  await chrome.kill();
+}
+`;
+    fs.writeFileSync(runnerPath, source, "utf-8");
+}
+async function runLighthouseForViewport(port, viewport, tempRoot) {
+    const runnerPath = path.join(tempRoot, "run-viewport-lighthouse.mjs");
+    const reportPath = path.join(tempRoot, `${viewport.name}.json`);
+    const chromeDir = path.join(tempRoot, `chrome-${viewport.name}`);
+    writeViewportRunnerScript(runnerPath);
+    fs.mkdirSync(chromeDir, { recursive: true });
+    const child = (0, node_child_process_1.spawn)("node", [
+        runnerPath,
+        `http://127.0.0.1:${port}/`,
+        reportPath,
+        chromeDir,
+        viewport.formFactor,
+        JSON.stringify(viewport.screen),
+    ], {
+        shell: false,
+        stdio: ["ignore", "pipe", "pipe"],
+        env: {
+            ...process.env,
+            TEMP: tempRoot,
+            TMP: tempRoot,
+            TMPDIR: tempRoot,
+        },
+    });
     child.stdout?.on("data", (chunk) => {
         const lines = chunk.toString().split("\n").filter(Boolean);
         for (const line of lines)
-            console.log(`    [lhci:${viewport.name}] ${line}`);
+            console.log(`    [lh:${viewport.name}] ${line}`);
     });
     child.stderr?.on("data", (chunk) => {
         const lines = chunk.toString().split("\n").filter(Boolean);
         for (const line of lines)
-            console.error(`    [lhci:${viewport.name}] ${line}`);
+            console.error(`    [lh:${viewport.name}] ${line}`);
     });
     const code = await new Promise((resolve) => child.on("exit", (exitCode) => resolve(exitCode ?? 1)));
-    if (code !== 0)
+    if (code !== 0 || !fs.existsSync(reportPath)) {
+        await removeDirWithRetries(chromeDir);
         return null;
+    }
     try {
-        const files = fs.readdirSync(vpDir).filter((file) => file.startsWith("lhr-") && file.endsWith(".json"));
-        if (files.length === 0)
-            return null;
-        const scores = files.map((file) => {
-            const lhr = JSON.parse(fs.readFileSync(path.join(vpDir, file), "utf-8"));
-            return {
-                performance: Math.round((lhr.categories.performance?.score ?? 0) * 100),
-                accessibility: Math.round((lhr.categories.accessibility?.score ?? 0) * 100),
-                seo: Math.round((lhr.categories.seo?.score ?? 0) * 100),
-                bestPractices: Math.round((lhr.categories["best-practices"]?.score ?? 0) * 100),
-            };
-        });
-        const median = (values) => {
-            const sorted = [...values].sort((a, b) => a - b);
-            const mid = Math.floor(sorted.length / 2);
-            return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
-        };
+        const lhr = JSON.parse(fs.readFileSync(reportPath, "utf-8"));
         return {
-            performance: median(scores.map((score) => score.performance)),
-            accessibility: median(scores.map((score) => score.accessibility)),
-            seo: median(scores.map((score) => score.seo)),
-            bestPractices: median(scores.map((score) => score.bestPractices)),
+            performance: Math.round((lhr.categories.performance?.score ?? 0) * 100),
+            accessibility: Math.round((lhr.categories.accessibility?.score ?? 0) * 100),
+            seo: Math.round((lhr.categories.seo?.score ?? 0) * 100),
+            bestPractices: Math.round((lhr.categories["best-practices"]?.score ?? 0) * 100),
         };
     }
     catch {
         return null;
     }
+    finally {
+        await removeDirWithRetries(chromeDir);
+    }
 }
 async function runMultiViewportLighthouse(port) {
     console.log("\n  [Pro+] Running multi-viewport Lighthouse checks (desktop, tablet, mobile)...");
-    const outputDir = ".lighthouseci-mvp";
+    const tempRoot = path.join(process.cwd(), ".laxy-tmp", `multi-viewport-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+    fs.mkdirSync(tempRoot, { recursive: true });
     const results = { desktop: null, tablet: null, mobile: null };
-    for (const viewport of VIEWPORTS) {
-        console.log(`\n    Viewport: ${viewport.name}`);
-        results[viewport.name] = await runLighthouseForViewport(port, viewport, outputDir);
+    try {
+        for (const viewport of VIEWPORTS) {
+            console.log(`\n    Viewport: ${viewport.name}`);
+            results[viewport.name] = await runLighthouseForViewport(port, viewport, tempRoot);
+        }
+        return results;
+    }
+    finally {
+        await removeDirWithRetries(tempRoot);
     }
-    return results;
 }
 function printMultiViewportResults(scores, thresholds) {
     const check = (passed) => (passed ? "OK" : "FAIL");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "laxy-verify",
-  "version": "1.1.10",
+  "version": "1.1.11",
   "description": "Frontend quality gate: build + Lighthouse verification",
   "license": "MIT",
   "type": "commonjs",
@@ -19,7 +19,7 @@
   "dependencies": {
     "@lhci/cli": "^0.14.0",
     "chrome-launcher": "^0.13.4",
-    "js-yaml": "^4.1.0",
+    "js-yaml": "^4.1.0",
     "lighthouse": "^12.1.0",
     "pixelmatch": "^7.1.0",
     "pngjs": "^7.0.0",