apex-auditor 0.1.1 → 0.1.5

package/dist/cli.js

@@ -34,8 +34,8 @@ export async function runAuditCli(argv) {
 }
 function buildMarkdown(results) {
     const header = [
-        "| Label | Path | Device | P | A | BP | SEO | LCP (s) | FCP (s) | TBT (ms) | CLS | Top issues |",
-        "|-------|------|--------|---|---|----|-----|---------|---------|----------|-----|-----------|",
+        "| Label | Path | Device | P | A | BP | SEO | LCP (s) | FCP (s) | TBT (ms) | CLS | Error | Top issues |",
+        "|-------|------|--------|---|---|----|-----|---------|---------|----------|-----|-------|-----------|",
     ].join("\n");
     const lines = results.map((result) => buildRow(result));
     return `${header}\n${lines.join("\n")}`;
@@ -48,7 +48,8 @@ function buildRow(result) {
     const tbtMs = metrics.tbtMs !== undefined ? Math.round(metrics.tbtMs).toString() : "-";
     const cls = metrics.cls !== undefined ? metrics.cls.toFixed(3) : "-";
     const issues = formatTopIssues(result.opportunities);
-    return `| ${result.label} | ${result.path} | ${result.device} | ${scores.performance ?? "-"} | ${scores.accessibility ?? "-"} | ${scores.bestPractices ?? "-"} | ${scores.seo ?? "-"} | ${lcpSeconds} | ${fcpSeconds} | ${tbtMs} | ${cls} | ${issues} |`;
+    const error = result.runtimeErrorCode ?? (result.runtimeErrorMessage !== undefined ? result.runtimeErrorMessage : "");
+    return `| ${result.label} | ${result.path} | ${result.device} | ${scores.performance ?? "-"} | ${scores.accessibility ?? "-"} | ${scores.bestPractices ?? "-"} | ${scores.seo ?? "-"} | ${lcpSeconds} | ${fcpSeconds} | ${tbtMs} | ${cls} | ${error} | ${issues} |`;
 }
 function formatTopIssues(opportunities) {
     if (opportunities.length === 0) {

package/dist/config.js

@@ -27,11 +27,16 @@ function normaliseConfig(input, absolutePath) {
     const query = typeof maybeConfig.query === "string" ? maybeConfig.query : undefined;
     const chromePort = typeof maybeConfig.chromePort === "number" ? maybeConfig.chromePort : undefined;
     const runs = typeof maybeConfig.runs === "number" && maybeConfig.runs > 0 ? maybeConfig.runs : undefined;
+    const rawLogLevel = maybeConfig.logLevel;
+    const logLevel = rawLogLevel === "silent" || rawLogLevel === "error" || rawLogLevel === "info" || rawLogLevel === "verbose"
+        ? rawLogLevel
+        : undefined;
     return {
         baseUrl,
         query,
         chromePort,
         runs,
+        logLevel,
         pages,
     };
 }

package/dist/lighthouse-runner.js

@@ -1,10 +1,12 @@
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
 import lighthouse from "lighthouse";
-import chromeLauncher from "chrome-launcher";
+import { launch as launchChrome } from "chrome-launcher";
 async function createChromeSession(chromePort) {
     if (typeof chromePort === "number") {
         return { port: chromePort };
     }
-    const chrome = await chromeLauncher.launch({
+    const chrome = await launchChrome({
         chromeFlags: [
             "--headless=new",
             "--disable-gpu",
@@ -19,16 +21,53 @@ async function createChromeSession(chromePort) {
     return {
         port: chrome.port,
         close: async () => {
-            await chrome.kill();
+            try {
+                await chrome.kill();
+            }
+            catch {
+                return;
+            }
         },
     };
 }
+async function ensureUrlReachable(url) {
+    const parsed = new URL(url);
+    const client = parsed.protocol === "https:" ? httpsRequest : httpRequest;
+    await new Promise((resolve, reject) => {
+        const request = client({
+            hostname: parsed.hostname,
+            port: parsed.port ? Number(parsed.port) : parsed.protocol === "https:" ? 443 : 80,
+            path: `${parsed.pathname}${parsed.search}`,
+            method: "GET",
+        }, (response) => {
+            const statusCode = response.statusCode ?? 0;
+            response.resume();
+            if (statusCode >= 200 && statusCode < 400) {
+                resolve();
+            }
+            else {
+                reject(new Error(`HTTP ${statusCode}`));
+            }
+        });
+        request.on("error", (error) => {
+            reject(error);
+        });
+        request.end();
+    }).catch((error) => {
+        // eslint-disable-next-line no-console
+        console.error(`Could not reach ${url}. Is your dev server running?`, error);
+        throw error instanceof Error ? error : new Error(`URL not reachable: ${url}`);
+    });
+}
 /**
  * Run audits for all pages defined in the config and return a structured summary.
  */
 export async function runAuditsForConfig({ config, configPath, }) {
     const runs = config.runs ?? 1;
     const results = [];
+    const firstPage = config.pages[0];
+    const healthCheckUrl = buildUrl({ baseUrl: config.baseUrl, path: firstPage.path, query: config.query });
+    await ensureUrlReachable(healthCheckUrl);
     const session = await createChromeSession(config.chromePort);
     try {
         for (const page of config.pages) {
@@ -42,6 +81,7 @@ export async function runAuditsForConfig({ config, configPath, }) {
                         label: page.label,
                         device,
                         port: session.port,
+                        logLevel: config.logLevel ?? "error",
                     });
                     summaries.push(summary);
                 }
@@ -66,7 +106,7 @@ async function runSingleAudit(params) {
     const options = {
         port: params.port,
         output: "json",
-        logLevel: "error",
+        logLevel: params.logLevel,
         onlyCategories: ["performance", "accessibility", "best-practices", "seo"],
         emulatedFormFactor: params.device,
     };
@@ -87,6 +127,8 @@ async function runSingleAudit(params) {
         scores,
         metrics,
         opportunities,
+        runtimeErrorCode: typeof lhr.runtimeError?.code === "string" ? lhr.runtimeError.code : undefined,
+        runtimeErrorMessage: typeof lhr.runtimeError?.message === "string" ? lhr.runtimeError.message : undefined,
     };
 }
 function extractScores(lhr) {
@@ -168,6 +210,8 @@ function aggregateSummaries(summaries) {
         scores: aggregateScores,
         metrics: aggregateMetrics,
         opportunities,
+        runtimeErrorCode: base.runtimeErrorCode,
+        runtimeErrorMessage: base.runtimeErrorMessage,
     };
 }
 function averageOf(values) {

package/dist/project-discovery.js

@@ -0,0 +1,92 @@
+import { readdir, readFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { pathExists } from "./fs-utils.js";
+const DEFAULT_MAX_DEPTH = 3;
+const IGNORED_DIRECTORIES = [
+    "node_modules",
+    ".git",
+    ".next",
+    ".turbo",
+    ".vercel",
+    "dist",
+    "build",
+    "out",
+    "coverage",
+    ".cache",
+];
+/**
+ * Discover Next.js projects below the given repository root.
+ * This performs a shallow breadth-first search and looks for either
+ * a next.config.* file or a package.json that depends on "next".
+ */
+export async function discoverNextProjects(options) {
+    const maxDepth = options.maxDepth ?? DEFAULT_MAX_DEPTH;
+    const queue = [{ path: options.repoRoot, depth: 0 }];
+    const visited = new Set();
+    const projects = [];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (visited.has(current.path)) {
+            continue;
+        }
+        visited.add(current.path);
+        if (await isNextProjectRoot(current.path)) {
+            const name = basename(current.path) || ".";
+            projects.push({ name, root: current.path, framework: "next" });
+            continue;
+        }
+        if (current.depth >= maxDepth) {
+            continue;
+        }
+        let entries;
+        try {
+            entries = await readdir(current.path, { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            if (IGNORED_DIRECTORIES.includes(entry.name)) {
+                continue;
+            }
+            const childPath = join(current.path, entry.name);
+            queue.push({ path: childPath, depth: current.depth + 1 });
+        }
+    }
+    return projects;
+}
+async function isNextProjectRoot(directory) {
+    const nextConfigCandidates = [
+        "next.config.js",
+        "next.config.mjs",
+        "next.config.cjs",
+        "next.config.ts",
+    ];
+    for (const candidate of nextConfigCandidates) {
+        const configPath = join(directory, candidate);
+        if (await pathExists(configPath)) {
+            return true;
+        }
+    }
+    const packageJsonPath = join(directory, "package.json");
+    if (!(await pathExists(packageJsonPath))) {
+        return false;
+    }
+    try {
+        const raw = await readFile(packageJsonPath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+            return false;
+        }
+        const maybePackage = parsed;
+        const hasNextDependency = Boolean((maybePackage.dependencies && typeof maybePackage.dependencies.next === "string") ||
+            (maybePackage.devDependencies && typeof maybePackage.devDependencies.next === "string"));
+        return hasNextDependency;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/route-detectors.js

@@ -42,15 +42,43 @@ export async function detectRoutes(options) {
 function createNextAppDetector() {
     return {
         id: SOURCE_NEXT_APP,
-        canDetect: async (options) => pathExists(join(options.projectRoot, "app")),
-        detect: async (options) => detectAppRoutes(join(options.projectRoot, "app"), options.limit),
+        canDetect: async (options) => {
+            const roots = await findNextAppRoots(options.projectRoot);
+            return roots.length > 0;
+        },
+        detect: async (options) => {
+            const roots = await findNextAppRoots(options.projectRoot);
+            const allRoutes = [];
+            for (const root of roots) {
+                const routes = await detectAppRoutes(root, options.limit);
+                allRoutes.push(...routes);
+                if (allRoutes.length >= options.limit) {
+                    break;
+                }
+            }
+            return allRoutes;
+        },
     };
 }
 function createNextPagesDetector() {
     return {
         id: SOURCE_NEXT_PAGES,
-        canDetect: async (options) => pathExists(join(options.projectRoot, "pages")),
-        detect: async (options) => detectPagesRoutes(join(options.projectRoot, "pages"), options.limit),
+        canDetect: async (options) => {
+            const roots = await findNextPagesRoots(options.projectRoot);
+            return roots.length > 0;
+        },
+        detect: async (options) => {
+            const roots = await findNextPagesRoots(options.projectRoot);
+            const allRoutes = [];
+            for (const root of roots) {
+                const routes = await detectPagesRoutes(root, options.limit);
+                allRoutes.push(...routes);
+                if (allRoutes.length >= options.limit) {
+                    break;
+                }
+            }
+            return allRoutes;
+        },
     };
 }
 function createRemixRoutesDetector() {
@@ -67,6 +95,90 @@ function createSpaHtmlDetector() {
         detect: async (options) => detectSpaRoutes(options.projectRoot, options.limit),
     };
 }
+async function findNextAppRoots(projectRoot) {
+    const roots = [];
+    const seen = new Set();
+    const addRoot = (candidate) => {
+        if (!seen.has(candidate)) {
+            seen.add(candidate);
+            roots.push(candidate);
+        }
+    };
+    const directCandidates = [
+        join(projectRoot, "app"),
+        join(projectRoot, "src", "app"),
+    ];
+    for (const candidate of directCandidates) {
+        if (await pathExists(candidate)) {
+            addRoot(candidate);
+        }
+    }
+    const containers = ["apps", "packages"];
+    for (const container of containers) {
+        const containerPath = join(projectRoot, container);
+        if (!(await pathExists(containerPath))) {
+            continue;
+        }
+        const entries = await readdir(containerPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const appRoot = join(containerPath, entry.name, "app");
+            const srcAppRoot = join(containerPath, entry.name, "src", "app");
+            if (await pathExists(appRoot)) {
+                addRoot(appRoot);
+                continue;
+            }
+            if (await pathExists(srcAppRoot)) {
+                addRoot(srcAppRoot);
+            }
+        }
+    }
+    return roots;
+}
+async function findNextPagesRoots(projectRoot) {
+    const roots = [];
+    const seen = new Set();
+    const addRoot = (candidate) => {
+        if (!seen.has(candidate)) {
+            seen.add(candidate);
+            roots.push(candidate);
+        }
+    };
+    const directCandidates = [
+        join(projectRoot, "pages"),
+        join(projectRoot, "src", "pages"),
+    ];
+    for (const candidate of directCandidates) {
+        if (await pathExists(candidate)) {
+            addRoot(candidate);
+        }
+    }
+    const containers = ["apps", "packages"];
+    for (const container of containers) {
+        const containerPath = join(projectRoot, container);
+        if (!(await pathExists(containerPath))) {
+            continue;
+        }
+        const entries = await readdir(containerPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+            const pagesRoot = join(containerPath, entry.name, "pages");
+            const srcPagesRoot = join(containerPath, entry.name, "src", "pages");
+            if (await pathExists(pagesRoot)) {
+                addRoot(pagesRoot);
+                continue;
+            }
+            if (await pathExists(srcPagesRoot)) {
+                addRoot(srcPagesRoot);
+            }
+        }
+    }
+    return roots;
+}
 async function detectAppRoutes(appRoot, limit) {
     const files = await collectRouteFiles(appRoot, limit, isAppPageFile);
     return files.map((file) => buildRoute(file, appRoot, formatAppRoutePath, SOURCE_NEXT_APP));

package/dist/wizard-cli.js

@@ -3,6 +3,7 @@ import { resolve } from "node:path";
 import prompts from "prompts";
 import { detectRoutes } from "./route-detectors.js";
 import { pathExists } from "./fs-utils.js";
+import { discoverNextProjects } from "./project-discovery.js";
 const PROFILE_TO_DETECTOR = {
     "next-app": "next-app",
     "next-pages": "next-pages",
@@ -194,18 +195,44 @@ async function maybeDetectPages(profile) {
     }
     const preferredDetector = await selectDetector(profile);
     const projectRootAnswer = await ask(projectRootQuestion);
-    const absoluteRoot = resolve(projectRootAnswer.projectRoot);
-    if (!(await pathExists(absoluteRoot))) {
-        console.log(`No project found at ${absoluteRoot}. Skipping auto-detection.`);
+    const repoRoot = resolve(projectRootAnswer.projectRoot);
+    if (!(await pathExists(repoRoot))) {
+        console.log(`No project found at ${repoRoot}. Skipping auto-detection.`);
         return [];
     }
-    const routes = await detectRoutes({ projectRoot: absoluteRoot, preferredDetectorId: preferredDetector });
+    const detectionRoot = await chooseDetectionRoot({ profile, repoRoot });
+    const routes = await detectRoutes({ projectRoot: detectionRoot, preferredDetectorId: preferredDetector });
     if (routes.length === 0) {
         console.log("No routes detected. Add pages manually.");
         return [];
     }
     return selectDetectedRoutes(routes);
 }
+async function chooseDetectionRoot({ profile, repoRoot, }) {
+    if (profile !== "next-app" && profile !== "next-pages") {
+        return repoRoot;
+    }
+    const projects = await discoverNextProjects({ repoRoot });
+    if (projects.length === 0) {
+        return repoRoot;
+    }
+    if (projects.length === 1) {
+        const onlyProject = projects[0];
+        console.log(`Detected Next.js app at ${onlyProject.root}.`);
+        return onlyProject.root;
+    }
+    const choices = projects.map((project) => ({
+        title: `${project.name} (${project.root})`,
+        value: project.root,
+    }));
+    const answer = await ask({
+        type: "select",
+        name: "projectRoot",
+        message: "Multiple Next.js apps found. Which one do you want to audit?",
+        choices,
+    });
+    return answer.projectRoot ?? repoRoot;
+}
 async function selectDetector(profile) {
     const preset = PROFILE_TO_DETECTOR[profile];
     if (preset) {
@@ -219,7 +246,8 @@ async function selectDetectedRoutes(routes) {
         type: "multiselect",
         name: "indexes",
         message: "Select routes to include",
-        instructions: false,
+        instructions: true,
+        hint: "Use Space to toggle, ↑/↓ to move, and Enter to confirm.",
         min: 1,
         choices: buildRouteChoices(routes),
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apex-auditor",
-  "version": "0.1.1",
+  "version": "0.1.5",
   "private": false,
   "description": "CLI to run structured Lighthouse audits (Performance, Accessibility, Best Practices, SEO) across routes.",
   "type": "module",
@@ -18,8 +18,8 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "chrome-launcher": "^0.15.2",
-    "lighthouse": "^12.6.1",
+    "chrome-launcher": "^1.2.1",
+    "lighthouse": "^13.0.1",
     "prompts": "^2.4.2"
   },
   "devDependencies": {
@@ -27,6 +27,6 @@
     "typescript": "^5.9.3",
     "@types/node": "^22.0.0",
     "@types/prompts": "^2.4.9",
-    "vitest": "^1.3.1"
+    "vitest": "^4.0.14"
   }
 }