apex-auditor 0.1.0 → 0.1.3

package/dist/lighthouse-runner.js

@@ -1,26 +1,57 @@
 import lighthouse from "lighthouse";
+import { launch as launchChrome } from "chrome-launcher";
+async function createChromeSession(chromePort) {
+    if (typeof chromePort === "number") {
+        return { port: chromePort };
+    }
+    const chrome = await launchChrome({
+        chromeFlags: [
+            "--headless=new",
+            "--disable-gpu",
+            "--no-sandbox",
+            "--disable-dev-shm-usage",
+            "--disable-extensions",
+            "--disable-default-apps",
+            "--no-first-run",
+            "--no-default-browser-check",
+        ],
+    });
+    return {
+        port: chrome.port,
+        close: async () => {
+            await chrome.kill();
+        },
+    };
+}
 /**
  * Run audits for all pages defined in the config and return a structured summary.
  */
 export async function runAuditsForConfig({ config, configPath, }) {
-    const port = config.chromePort ?? 9222;
     const runs = config.runs ?? 1;
     const results = [];
-    for (const page of config.pages) {
-        for (const device of page.devices) {
-            const url = buildUrl({ baseUrl: config.baseUrl, path: page.path, query: config.query });
-            const summaries = [];
-            for (let i = 0; i < runs; i += 1) {
-                const summary = await runSingleAudit({
-                    url,
-                    path: page.path,
-                    label: page.label,
-                    device,
-                    port,
-                });
-                summaries.push(summary);
+    const session = await createChromeSession(config.chromePort);
+    try {
+        for (const page of config.pages) {
+            for (const device of page.devices) {
+                const url = buildUrl({ baseUrl: config.baseUrl, path: page.path, query: config.query });
+                const summaries = [];
+                for (let index = 0; index < runs; index += 1) {
+                    const summary = await runSingleAudit({
+                        url,
+                        path: page.path,
+                        label: page.label,
+                        device,
+                        port: session.port,
+                    });
+                    summaries.push(summary);
+                }
+                results.push(aggregateSummaries(summaries));
             }
-            results.push(aggregateSummaries(summaries));
+        }
+    }
+    finally {
+        if (session.close) {
+            await session.close();
         }
     }
     return { configPath, results };

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",
@@ -11,9 +12,8 @@ const PROFILE_TO_DETECTOR = {
     custom: undefined,
 };
 const DEFAULT_BASE_URL = "http://localhost:3000";
-const DEFAULT_CHROME_PORT = 9222;
 const DEFAULT_RUNS = 1;
-const DEFAULT_PROJECT_ROOT = "..";
+const DEFAULT_PROJECT_ROOT = ".";
 const DEFAULT_PRESELECT_COUNT = 5;
 const DEFAULT_DEVICES = ["mobile", "desktop"];
 const PROMPT_OPTIONS = { onCancel: handleCancel };
@@ -49,13 +49,6 @@ const baseQuestions = [
         message: "Query string appended to every route (optional)",
         initial: "",
     },
-    {
-        type: "number",
-        name: "chromePort",
-        message: "Chrome remote debugging port",
-        initial: DEFAULT_CHROME_PORT,
-        min: 1,
-    },
     {
         type: "number",
         name: "runs",
@@ -168,7 +161,6 @@ async function collectBaseAnswers() {
     return {
         baseUrl: answers.baseUrl.trim(),
         query: answers.query && answers.query.length > 0 ? answers.query : undefined,
-        chromePort: answers.chromePort,
         runs: answers.runs,
     };
 }
@@ -203,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) {
@@ -261,7 +279,6 @@ async function buildConfig() {
     return {
         baseUrl: baseAnswers.baseUrl,
         query: baseAnswers.query,
-        chromePort: baseAnswers.chromePort,
         runs: baseAnswers.runs,
         pages,
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apex-auditor",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "private": false,
   "description": "CLI to run structured Lighthouse audits (Performance, Accessibility, Best Practices, SEO) across routes.",
   "type": "module",
@@ -18,7 +18,8 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "lighthouse": "^12.6.1",
+    "chrome-launcher": "^1.2.1",
+    "lighthouse": "^13.0.1",
     "prompts": "^2.4.2"
   },
   "devDependencies": {
@@ -26,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"
   }
 }