laxy-verify 1.2.1 → 1.2.3

package/dist/compare-env.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Multi-environment Lighthouse comparison (Pro feature).
+ *
+ * Compares Lighthouse scores between the local build and a reference
+ * environment URL (e.g. staging, production) to detect regressions
+ * introduced by the current PR.
+ */
+import type { LighthouseScores } from "./grade.js";
+export interface EnvComparisonResult {
+    localUrl: string;
+    compareUrl: string;
+    local: LighthouseScores | null;
+    compare: LighthouseScores | null;
+    /** Positive = local is better, negative = compare env is better */
+    delta: {
+        performance: number | null;
+        accessibility: number | null;
+        seo: number | null;
+        bestPractices: number | null;
+    } | null;
+}
+export declare function runEnvComparison(localPort: number, compareUrl: string, runs?: number): Promise<EnvComparisonResult>;
+export declare function printEnvComparison(result: EnvComparisonResult): void;

package/dist/compare-env.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runEnvComparison = runEnvComparison;
+exports.printEnvComparison = printEnvComparison;
+const lighthouse_js_1 = require("./lighthouse.js");
+function scoreDelta(local, compare) {
+    if (!local || !compare)
+        return null;
+    return {
+        performance: local.performance - compare.performance,
+        accessibility: local.accessibility - compare.accessibility,
+        seo: local.seo - compare.seo,
+        bestPractices: local.bestPractices - compare.bestPractices,
+    };
+}
+async function runEnvComparison(localPort, compareUrl, runs = 1) {
+    const localUrl = `http://127.0.0.1:${localPort}/`;
+    console.log(`\n  [compare] Running env comparison: local vs ${compareUrl}`);
+    const [localResult, compareResult] = await Promise.all([
+        (0, lighthouse_js_1.runLighthouseOnUrl)(localUrl, runs),
+        (0, lighthouse_js_1.runLighthouseOnUrl)(compareUrl, runs),
+    ]);
+    return {
+        localUrl,
+        compareUrl,
+        local: localResult.scores,
+        compare: compareResult.scores,
+        delta: scoreDelta(localResult.scores, compareResult.scores),
+    };
+}
+function printEnvComparison(result) {
+    console.log("\n  Environment comparison:");
+    console.log(`    Local:   ${result.localUrl}`);
+    console.log(`    Compare: ${result.compareUrl}`);
+    if (!result.local && !result.compare) {
+        console.log("    Both environments returned no Lighthouse data.");
+        return;
+    }
+    const fmt = (v) => (v === null ? "—" : String(v));
+    const fmtDelta = (d) => {
+        if (d === null)
+            return "";
+        if (d > 0)
+            return ` (+${d})`;
+        if (d < 0)
+            return ` (${d})`;
+        return " (=)";
+    };
+    const d = result.delta;
+    console.log("    Metric           Local  Compare  Delta");
+    console.log(`    Performance      ${fmt(result.local?.performance ?? null).padEnd(6)} ${fmt(result.compare?.performance ?? null).padEnd(8)}${fmtDelta(d?.performance ?? null)}`);
+    console.log(`    Accessibility    ${fmt(result.local?.accessibility ?? null).padEnd(6)} ${fmt(result.compare?.accessibility ?? null).padEnd(8)}${fmtDelta(d?.accessibility ?? null)}`);
+    console.log(`    SEO              ${fmt(result.local?.seo ?? null).padEnd(6)} ${fmt(result.compare?.seo ?? null).padEnd(8)}${fmtDelta(d?.seo ?? null)}`);
+    console.log(`    Best Practices   ${fmt(result.local?.bestPractices ?? null).padEnd(6)} ${fmt(result.compare?.bestPractices ?? null).padEnd(8)}${fmtDelta(d?.bestPractices ?? null)}`);
+}

package/dist/config.d.ts

@@ -18,6 +18,13 @@ export interface UserScenario {
     name: string;
     steps: UserScenarioStep[];
 }
+export interface VisualDiffConfig {
+    pixelmatchThreshold: number;
+    warnThreshold: number;
+    rollbackThreshold: number;
+    ignoreSelectors: string[];
+    disableAnimations: boolean;
+}
 export interface LaxyConfig {
     framework: string;
     build_command: string;
@@ -34,18 +41,61 @@ export interface LaxyConfig {
     max_crawl_depth: number;
     max_crawl_pages: number;
     browsers: string[];
+    /** Explicit list of routes to audit with Lighthouse (e.g. ["/", "/about", "/pricing"]). */
+    lighthouse_routes?: string[];
+    /** Extra routes to audit even if the crawler cannot discover them (e.g. SPA router.push routes). */
+    extra_routes?: string[];
+    /** Maximum number of crawl-discovered routes to run Lighthouse on. Default: 5. */
+    max_lighthouse_routes: number;
+    visual_diff: VisualDiffConfig;
+    /** Run TypeScript type check (tsc --noEmit). Default: false. */
+    typecheck: boolean;
+    /** Run secret/credential leak scan. Default: false. */
+    secret_scan: boolean;
+    /** Paths to ignore during secret scan. */
+    secret_scan_ignore_paths: string[];
+    /** Run bundle size analysis. Default: false. */
+    bundle_size: boolean;
+    /** Run outdated dependency check. Default: false. */
+    outdated_check: boolean;
+    /** Run deep accessibility audit (axe-core). Default: false. */
+    a11y_deep: boolean;
+    /** Run deep SEO audit. Default: false. */
+    seo_deep: boolean;
+    /** Run Core Web Vitals budget check. Default: false. */
+    vitals_budget: boolean;
 }
 export declare class ConfigParseError extends Error {
     constructor(msg: string);
 }
+export interface TeamThresholdsConfig {
+    performance: number;
+    accessibility: number;
+    seo: number;
+    best_practices: number;
+    fail_on: FailOn;
+}
+/**
+ * 로그인된 CLI 토큰으로 팀 공통 임계값을 서버에서 가져온다.
+ * 토큰 없음 / 팀 없음 / 네트워크 오류 시 null 반환 (graceful degradation).
+ */
+export declare function fetchTeamThresholds(): Promise<TeamThresholdsConfig | null>;
 export interface LoadConfigOptions {
     dir: string;
     configPath?: string;
     cliFlags?: {
         failOn?: FailOn;
         skipLighthouse?: boolean;
+        typecheck?: boolean;
+        secretScan?: boolean;
+        bundleSize?: boolean;
+        outdatedCheck?: boolean;
+        a11yDeep?: boolean;
+        seoDeep?: boolean;
+        vitalsBudget?: boolean;
     };
     ciMode: boolean;
+    teamThresholds?: TeamThresholdsConfig | null;
 }
 export declare function loadConfig(options: LoadConfigOptions): LaxyConfig & {
     ciMode: boolean;

package/dist/config.js

@@ -34,10 +34,12 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigParseError = void 0;
+exports.fetchTeamThresholds = fetchTeamThresholds;
 exports.loadConfig = loadConfig;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const yaml = __importStar(require("js-yaml"));
+const auth_js_1 = require("./auth.js");
 const DEFAULT_CONFIG = {
     framework: "auto",
     build_command: "",
@@ -46,7 +48,7 @@ const DEFAULT_CONFIG = {
     port: 3000,
     build_timeout: 300,
     dev_timeout: 60,
-    lighthouse_runs: 1,
+    lighthouse_runs: 3,
     thresholds: {
         performance: 70,
         accessibility: 85,
@@ -58,6 +60,22 @@ const DEFAULT_CONFIG = {
     max_crawl_depth: 3,
     max_crawl_pages: 10,
     browsers: ["chromium"],
+    max_lighthouse_routes: 5,
+    visual_diff: {
+        pixelmatchThreshold: 0.1,
+        warnThreshold: 30,
+        rollbackThreshold: 60,
+        ignoreSelectors: [],
+        disableAnimations: true,
+    },
+    typecheck: false,
+    secret_scan: false,
+    secret_scan_ignore_paths: [],
+    bundle_size: false,
+    outdated_check: false,
+    a11y_deep: false,
+    seo_deep: false,
+    vitals_budget: false,
 };
 const VALID_FAIL_ON = ["unverified", "bronze", "silver", "gold"];
 class ConfigParseError extends Error {
@@ -103,6 +121,47 @@ function parseYaml(filePath) {
         if (browsers.length > 0)
             result.browsers = browsers;
     }
+    if (Array.isArray(raw.lighthouse_routes)) {
+        const routes = raw.lighthouse_routes
+            .filter((r) => typeof r === "string" && r.startsWith("/"))
+            .slice(0, 20);
+        if (routes.length > 0)
+            result.lighthouse_routes = routes;
+    }
+    if (Array.isArray(raw.extra_routes)) {
+        const routes = raw.extra_routes
+            .filter((r) => typeof r === "string" && r.startsWith("/"))
+            .slice(0, 20);
+        if (routes.length > 0)
+            result.extra_routes = routes;
+    }
+    if (typeof raw.max_lighthouse_routes === "number") {
+        result.max_lighthouse_routes = Math.max(1, Math.min(20, raw.max_lighthouse_routes));
+    }
+    if (typeof raw.visual_diff === "object" &&
+        raw.visual_diff !== null &&
+        !Array.isArray(raw.visual_diff)) {
+        const vd = raw.visual_diff;
+        const visualDiff = {};
+        if (typeof vd.pixelmatch_threshold === "number") {
+            visualDiff.pixelmatchThreshold = Math.max(0, Math.min(1, vd.pixelmatch_threshold));
+        }
+        if (typeof vd.warn_threshold === "number") {
+            visualDiff.warnThreshold = Math.max(0, Math.min(100, vd.warn_threshold));
+        }
+        if (typeof vd.rollback_threshold === "number") {
+            visualDiff.rollbackThreshold = Math.max(0, Math.min(100, vd.rollback_threshold));
+        }
+        if (Array.isArray(vd.ignore_selectors)) {
+            visualDiff.ignoreSelectors = vd.ignore_selectors
+                .filter((selector) => typeof selector === "string" && selector.trim().length > 0)
+                .slice(0, 30);
+        }
+        if (typeof vd.disable_animations === "boolean") {
+            visualDiff.disableAnimations = vd.disable_animations;
+        }
+        result.visual_diff = visualDiff;
+    }
     if (typeof raw.fail_on === "string") {
         const f = raw.fail_on;
         if (!VALID_FAIL_ON.includes(f)) {
@@ -162,14 +221,66 @@ function parseYaml(filePath) {
             result.scenarios = scenarios;
         }
     }
+    if (typeof raw.typecheck === "boolean")
+        result.typecheck = raw.typecheck;
+    if (typeof raw.secret_scan === "boolean")
+        result.secret_scan = raw.secret_scan;
+    if (Array.isArray(raw.secret_scan_ignore_paths)) {
+        result.secret_scan_ignore_paths = raw.secret_scan_ignore_paths
+            .filter((p) => typeof p === "string");
+    }
+    if (typeof raw.bundle_size === "boolean")
+        result.bundle_size = raw.bundle_size;
+    if (typeof raw.outdated_check === "boolean")
+        result.outdated_check = raw.outdated_check;
+    if (typeof raw.a11y_deep === "boolean")
+        result.a11y_deep = raw.a11y_deep;
+    if (typeof raw.seo_deep === "boolean")
+        result.seo_deep = raw.seo_deep;
+    if (typeof raw.vitals_budget === "boolean")
+        result.vitals_budget = raw.vitals_budget;
     return result;
 }
+/**
+ * 로그인된 CLI 토큰으로 팀 공통 임계값을 서버에서 가져온다.
+ * 토큰 없음 / 팀 없음 / 네트워크 오류 시 null 반환 (graceful degradation).
+ */
+async function fetchTeamThresholds() {
+    const token = (0, auth_js_1.loadToken)();
+    if (!token)
+        return null;
+    try {
+        const res = await fetch(`${auth_js_1.LAXY_API_URL}/api/v1/team-thresholds`, {
+            headers: { Authorization: `Bearer ${token}` },
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return data.thresholds ?? null;
+    }
+    catch {
+        return null;
+    }
+}
 function loadConfig(options) {
     const configPath = options.configPath ?? path.join(options.dir, ".laxy.yml");
     let base = {};
-    if (fs.existsSync(configPath)) {
+    const hasLocalConfig = fs.existsSync(configPath);
+    if (hasLocalConfig) {
         base = parseYaml(configPath);
     }
+    // 팀 임계값: 로컬 .laxy.yml에 thresholds가 없을 때만 적용
+    const team = options.teamThresholds ?? null;
+    const teamThresholdFallback = (!hasLocalConfig || !base.thresholds) && team
+        ? {
+            performance: team.performance,
+            accessibility: team.accessibility,
+            seo: team.seo,
+            bestPractices: team.best_practices,
+        }
+        : {};
+    const teamFailOnFallback = (!hasLocalConfig || !base.fail_on) && team ? team.fail_on : undefined;
     const config = {
         ...DEFAULT_CONFIG,
         framework: base.framework ?? DEFAULT_CONFIG.framework,
@@ -180,14 +291,33 @@ function loadConfig(options) {
         build_timeout: base.build_timeout ?? DEFAULT_CONFIG.build_timeout,
         dev_timeout: base.dev_timeout ?? DEFAULT_CONFIG.dev_timeout,
         lighthouse_runs: base.lighthouse_runs ?? DEFAULT_CONFIG.lighthouse_runs,
-        fail_on: base.fail_on ?? DEFAULT_CONFIG.fail_on,
+        fail_on: base.fail_on ?? teamFailOnFallback ?? DEFAULT_CONFIG.fail_on,
         scenarios: base.scenarios,
         crawl: base.crawl ?? DEFAULT_CONFIG.crawl,
         max_crawl_depth: base.max_crawl_depth ?? DEFAULT_CONFIG.max_crawl_depth,
         max_crawl_pages: base.max_crawl_pages ?? DEFAULT_CONFIG.max_crawl_pages,
         browsers: base.browsers ?? DEFAULT_CONFIG.browsers,
+        lighthouse_routes: base.lighthouse_routes,
+        extra_routes: base.extra_routes,
+        max_lighthouse_routes: base.max_lighthouse_routes ?? DEFAULT_CONFIG.max_lighthouse_routes,
+        visual_diff: {
+            ...DEFAULT_CONFIG.visual_diff,
+            ...(base.visual_diff ?? {}),
+        },
+        typecheck: base.typecheck ?? DEFAULT_CONFIG.typecheck,
+        secret_scan: base.secret_scan ?? DEFAULT_CONFIG.secret_scan,
+        secret_scan_ignore_paths: base.secret_scan_ignore_paths ?? DEFAULT_CONFIG.secret_scan_ignore_paths,
+        bundle_size: base.bundle_size ?? DEFAULT_CONFIG.bundle_size,
+        outdated_check: base.outdated_check ?? DEFAULT_CONFIG.outdated_check,
+        a11y_deep: base.a11y_deep ?? DEFAULT_CONFIG.a11y_deep,
+        seo_deep: base.seo_deep ?? DEFAULT_CONFIG.seo_deep,
+        vitals_budget: base.vitals_budget ?? DEFAULT_CONFIG.vitals_budget,
+    };
+    config.thresholds = {
+        ...DEFAULT_CONFIG.thresholds,
+        ...teamThresholdFallback,
+        ...(base.thresholds ?? {}),
     };
-    config.thresholds = { ...DEFAULT_CONFIG.thresholds, ...(base.thresholds ?? {}) };
     // CLI flag overrides
     if (options.cliFlags?.failOn !== undefined) {
         if (!VALID_FAIL_ON.includes(options.cliFlags.failOn)) {
@@ -211,5 +341,20 @@ function loadConfig(options) {
     if (options.cliFlags?.skipLighthouse) {
         // Effectively disables Lighthouse grading
     }
+    // CLI flag overrides for new checks
+    if (options.cliFlags?.typecheck !== undefined)
+        config.typecheck = options.cliFlags.typecheck;
+    if (options.cliFlags?.secretScan !== undefined)
+        config.secret_scan = options.cliFlags.secretScan;
+    if (options.cliFlags?.bundleSize !== undefined)
+        config.bundle_size = options.cliFlags.bundleSize;
+    if (options.cliFlags?.outdatedCheck !== undefined)
+        config.outdated_check = options.cliFlags.outdatedCheck;
+    if (options.cliFlags?.a11yDeep !== undefined)
+        config.a11y_deep = options.cliFlags.a11yDeep;
+    if (options.cliFlags?.seoDeep !== undefined)
+        config.seo_deep = options.cliFlags.seoDeep;
+    if (options.cliFlags?.vitalsBudget !== undefined)
+        config.vitals_budget = options.cliFlags.vitalsBudget;
     return { ...config, ciMode };
 }

package/dist/entitlement.d.ts

@@ -3,6 +3,8 @@ export interface EntitlementFeatures {
     github_actions: boolean;
     queue_priority: boolean;
     parallel_execution: boolean;
+    ai_failure_analysis: boolean;
+    compare_env: boolean;
 }
 export type TestablePlan = "free" | "pro" | "team";
 export declare function normalizePlan(plan?: string | null): TestablePlan;

package/dist/entitlement.js

@@ -18,6 +18,8 @@ const FREE_FEATURES = {
     github_actions: false,
     queue_priority: false,
     parallel_execution: false,
+    ai_failure_analysis: false,
+    compare_env: false,
 };
 let cache = null;
 const CACHE_TTL_MS = 5 * 60 * 1000;
@@ -70,8 +72,10 @@ function applyPlanOverride(features, overridePlan) {
         ...features,
         plan: overridePlan,
         // All verification features run on every plan
-        // github_actions — Pro and Team
+        // github_actions, ai_failure_analysis, compare_env — Pro and Team
         github_actions: isPro,
+        ai_failure_analysis: isPro,
+        compare_env: isPro,
         // queue_priority, parallel_execution — Team only
         queue_priority: isTeam,
         parallel_execution: isTeam,

package/dist/init-analysis.d.ts

@@ -0,0 +1,6 @@
+import type { UserScenario } from "./config.js";
+export interface InitAnalysisResult {
+    scenarios: UserScenario[];
+    extraRoutes: string[];
+}
+export declare function analyzeProjectForInit(dir: string): InitAnalysisResult;