laxy-verify 1.0.1 → 1.1.0

package/dist/auth.d.ts

@@ -0,0 +1,6 @@
+export declare const LAXY_API_URL: string;
+export declare function loadToken(): string | null;
+export declare function saveToken(token: string, email: string, expiresInSec: number): void;
+export declare function clearToken(): void;
+export declare function whoami(): void;
+export declare function login(emailArg?: string): Promise<void>;

package/dist/auth.js

@@ -0,0 +1,186 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LAXY_API_URL = void 0;
+exports.loadToken = loadToken;
+exports.saveToken = saveToken;
+exports.clearToken = clearToken;
+exports.whoami = whoami;
+exports.login = login;
+/**
+ * auth.ts — laxy-verify CLI 인증 토큰 저장/로드/삭제
+ *
+ * 토큰은 ~/.laxy/credentials.json 에 저장됩니다.
+ * 로그인: POST /api/cli-auth (이메일 + 비밀번호)
+ * 로그아웃: 로컬 파일 삭제
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const os = __importStar(require("node:os"));
+const readline = __importStar(require("node:readline"));
+const CREDENTIALS_DIR = path.join(os.homedir(), ".laxy");
+const CREDENTIALS_PATH = path.join(CREDENTIALS_DIR, "credentials.json");
+exports.LAXY_API_URL = process.env.LAXY_API_URL ?? "https://laxy.io";
+function loadToken() {
+    // 환경변수 우선
+    const envToken = process.env.LAXY_TOKEN;
+    if (envToken)
+        return envToken;
+    try {
+        if (!fs.existsSync(CREDENTIALS_PATH))
+            return null;
+        const raw = fs.readFileSync(CREDENTIALS_PATH, "utf-8");
+        const creds = JSON.parse(raw);
+        if (!creds.token)
+            return null;
+        // 만료 여부 로컬 체크 (서버도 재확인하지만 UX 개선)
+        if (creds.expires_at) {
+            const exp = new Date(creds.expires_at).getTime();
+            if (exp < Date.now()) {
+                console.error("  ⚠️  저장된 CLI 토큰이 만료되었습니다. 다시 로그인하세요: laxy-verify login");
+                return null;
+            }
+        }
+        return creds.token;
+    }
+    catch {
+        return null;
+    }
+}
+function saveToken(token, email, expiresInSec) {
+    if (!fs.existsSync(CREDENTIALS_DIR)) {
+        fs.mkdirSync(CREDENTIALS_DIR, { recursive: true });
+    }
+    const creds = {
+        token,
+        email,
+        saved_at: new Date().toISOString(),
+        expires_at: new Date(Date.now() + expiresInSec * 1000).toISOString(),
+    };
+    fs.writeFileSync(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), { encoding: "utf-8", mode: 0o600 });
+}
+function clearToken() {
+    if (fs.existsSync(CREDENTIALS_PATH)) {
+        fs.rmSync(CREDENTIALS_PATH);
+        console.log("  로그아웃 완료 — 인증 정보를 삭제했습니다.");
+    }
+    else {
+        console.log("  저장된 인증 정보가 없습니다.");
+    }
+}
+function whoami() {
+    const envToken = process.env.LAXY_TOKEN;
+    if (envToken) {
+        console.log("  인증: 환경변수 LAXY_TOKEN 사용 중");
+        return;
+    }
+    try {
+        if (!fs.existsSync(CREDENTIALS_PATH)) {
+            console.log("  로그인되지 않았습니다. laxy-verify login 명령으로 로그인하세요.");
+            return;
+        }
+        const raw = fs.readFileSync(CREDENTIALS_PATH, "utf-8");
+        const creds = JSON.parse(raw);
+        const expDate = creds.expires_at ? new Date(creds.expires_at).toLocaleDateString("ko-KR") : "알 수 없음";
+        console.log(`  이메일: ${creds.email}`);
+        console.log(`  토큰 만료: ${expDate}`);
+    }
+    catch {
+        console.log("  인증 정보를 읽을 수 없습니다.");
+    }
+}
+/** readline으로 비밀번호 입력 (터미널 에코 숨김) */
+function promptPassword(prompt) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: true,
+        });
+        process.stdout.write(prompt);
+        // 에코 끄기 (Unix 계열만, Windows는 readline이 처리)
+        if (process.stdin.isTTY) {
+            // @ts-ignore — private API
+            process.stdin._handle?.setRawMode?.(true);
+        }
+        let password = "";
+        process.stdin.on("data", (chunk) => {
+            const char = chunk.toString("utf-8");
+            if (char === "\n" || char === "\r" || char === "\u0004") {
+                process.stdout.write("\n");
+                rl.close();
+                resolve(password);
+            }
+            else if (char === "\u0008" || char === "\u007f") {
+                password = password.slice(0, -1);
+            }
+            else {
+                password += char;
+            }
+        });
+    });
+}
+async function login(emailArg) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const askEmail = () => {
+        if (emailArg) {
+            rl.close();
+            return Promise.resolve(emailArg);
+        }
+        return new Promise((res) => rl.question("  이메일: ", (ans) => { rl.close(); res(ans.trim()); }));
+    };
+    const email = await askEmail();
+    const password = await promptPassword("  비밀번호: ");
+    console.log("\n  로그인 중...");
+    let res;
+    try {
+        res = await fetch(`${exports.LAXY_API_URL}/api/cli-auth`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ email, password }),
+        });
+    }
+    catch (err) {
+        console.error(`  ❌ 서버에 연결할 수 없습니다. (${exports.LAXY_API_URL})`);
+        process.exit(1);
+    }
+    const data = (await res.json());
+    if (!res.ok || !data.token) {
+        console.error(`  ❌ ${data.error ?? "로그인에 실패했습니다."}`);
+        process.exit(1);
+    }
+    saveToken(data.token, email, data.expires_in ?? 30 * 24 * 60 * 60);
+    console.log("  ✅ 로그인 성공! laxy-verify . 을 실행해 검증을 시작하세요.");
+}

package/dist/cli.js

@@ -46,6 +46,9 @@ const init_js_1 = require("./init.js");
 const badge_js_1 = require("./badge.js");
 const comment_js_1 = require("./comment.js");
 const status_js_1 = require("./status.js");
+const auth_js_1 = require("./auth.js");
+const entitlement_js_1 = require("./entitlement.js");
+const multi_viewport_js_1 = require("./multi-viewport.js");
 function parseArgs() {
     const raw = process.argv.slice(2);
     // Single-pass: collect flags and first positional
@@ -77,8 +80,26 @@ function parseArgs() {
             }
         }
     }
+    // 서브커맨드 처리: login [email], logout, whoami
+    let subcommand;
+    let subcommandArg;
+    if (projectDir === "login" || projectDir === "logout" || projectDir === "whoami") {
+        subcommand = projectDir;
+        projectDir = ".";
+        // login 뒤에 이메일이 올 수 있음
+        if (subcommand === "login" && raw.length > 0 && !raw[0].startsWith("-")) {
+            // already consumed via loop above if it was first; re-check flags
+        }
+        // 첫 번째 non-flag를 이메일로 취급
+        subcommandArg = flags["email"];
+        if (!subcommandArg) {
+            // login PSM@example.com 형태 — positional already captured in projectDir before reset
+        }
+    }
     return {
         projectDir: path.resolve(projectDir),
+        subcommand,
+        subcommandArg,
         format: flags["format"] ?? "console",
         ciMode: flags["ci"] !== undefined || process.env.CI === "true",
         configPath: flags["config"],
@@ -86,6 +107,8 @@ function parseArgs() {
         skipLighthouse: flags["skip-lighthouse"] !== undefined,
         badge: flags["badge"] !== undefined,
         init: flags["init"] !== undefined,
+        multiViewport: flags["multi-viewport"] !== undefined,
+        failureAnalysis: flags["failure-analysis"] !== undefined,
     };
 }
 function writeResultFile(projectDir, result) {
@@ -128,6 +151,22 @@ function consoleOutput(result) {
 }
 async function run() {
     const args = parseArgs();
+    // ── 서브커맨드 처리 ──────────────────────────────────────────────────────
+    if (args.subcommand === "login") {
+        await (0, auth_js_1.login)(args.subcommandArg);
+        process.exit(0);
+        return;
+    }
+    if (args.subcommand === "logout") {
+        (0, auth_js_1.clearToken)();
+        process.exit(0);
+        return;
+    }
+    if (args.subcommand === "whoami") {
+        (0, auth_js_1.whoami)();
+        process.exit(0);
+        return;
+    }
     // --init
     if (args.init) {
         (0, init_js_1.runInit)(args.projectDir);
@@ -202,7 +241,31 @@ async function run() {
         seo: config.thresholds.seo,
         bestPractices: config.thresholds.bestPractices,
     };
+    // ── 플랜 기능 조회 (토큰 없으면 Free 폴백) ──────────────────────────────
+    let entitlements = null;
+    try {
+        entitlements = await (0, entitlement_js_1.getEntitlements)();
+        (0, entitlement_js_1.printPlanBanner)(entitlements);
+    }
+    catch {
+        // 네트워크 오류 시 Free로 진행
+    }
+    const features = entitlements ?? {
+        plan: "free",
+        gold_grade: false,
+        lighthouse_runs_3: false,
+        verbose_failure: false,
+        multi_viewport: false,
+        failure_analysis: false,
+        fast_lane: false,
+    };
+    // Pro 이상이면 Lighthouse 3회 실행 (더 정밀)
+    if (features.lighthouse_runs_3 && config.lighthouse_runs < 3) {
+        config = { ...config, lighthouse_runs: 3 };
+    }
     // Phase 2: Dev server + Lighthouse (only if build succeeded and not skipped)
+    let multiViewportScores = null;
+    let allViewportsOk = false;
     if (buildResult.success && !args.skipLighthouse) {
         let servePid;
         try {
@@ -224,6 +287,20 @@ async function run() {
             catch (lhErr) {
                 console.error(`Lighthouse error: ${lhErr instanceof Error ? lhErr.message : String(lhErr)}`);
             }
+            // ── Pro+: 멀티 뷰포트 (dev server가 돌리는 중) ─────────────────────
+            if (args.multiViewport && !features.multi_viewport) {
+                console.log("\n  ⚠️  --multi-viewport는 Pro+ 플랜 전용입니다. laxy-verify login 으로 로그인하세요.");
+            }
+            else if (features.multi_viewport) {
+                try {
+                    multiViewportScores = await (0, multi_viewport_js_1.runMultiViewportLighthouse)(port);
+                    (0, multi_viewport_js_1.printMultiViewportResults)(multiViewportScores, adjustedThresholds);
+                    allViewportsOk = (0, multi_viewport_js_1.allViewportsPass)(multiViewportScores, adjustedThresholds);
+                }
+                catch (mvErr) {
+                    console.error(`Multi-viewport error: ${mvErr instanceof Error ? mvErr.message : String(mvErr)}`);
+                }
+            }
         }
         catch (serveErr) {
             console.error(`Dev server error: ${serveErr instanceof Error ? serveErr.message : String(serveErr)}`);
@@ -240,6 +317,7 @@ async function run() {
         scores,
         thresholds: adjustedThresholds,
         failOn: config.fail_on,
+        goldEligible: features.gold_grade && allViewportsOk,
     });
     // Build result object
     const resultObj = {

package/dist/entitlement.d.ts

@@ -0,0 +1,11 @@
+export interface EntitlementFeatures {
+    plan: string;
+    gold_grade: boolean;
+    lighthouse_runs_3: boolean;
+    verbose_failure: boolean;
+    multi_viewport: boolean;
+    failure_analysis: boolean;
+    fast_lane: boolean;
+}
+export declare function getEntitlements(): Promise<EntitlementFeatures>;
+export declare function printPlanBanner(features: EntitlementFeatures): void;

package/dist/entitlement.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEntitlements = getEntitlements;
+exports.printPlanBanner = printPlanBanner;
+/**
+ * entitlement.ts — Pro/Pro+ 기능 게이팅
+ *
+ * /api/v1/cli-entitlement 를 호출하여 사용자의 플랜 기능을 조회합니다.
+ * 결과는 5분간 메모리 캐시됩니다.
+ * 토큰이 없거나 서버 오류 시 Free 플랜으로 폴백합니다.
+ */
+const auth_js_1 = require("./auth.js");
+const FREE_FEATURES = {
+    plan: "free",
+    gold_grade: false,
+    lighthouse_runs_3: false,
+    verbose_failure: false,
+    multi_viewport: false,
+    failure_analysis: false,
+    fast_lane: false,
+};
+let cache = null;
+const CACHE_TTL_MS = 5 * 60 * 1000; // 5분
+async function getEntitlements() {
+    // 캐시 유효 시 반환
+    if (cache && Date.now() - cache.fetchedAt < CACHE_TTL_MS) {
+        return cache.features;
+    }
+    const token = (0, auth_js_1.loadToken)();
+    if (!token)
+        return FREE_FEATURES;
+    try {
+        const res = await fetch(`${auth_js_1.LAXY_API_URL}/api/v1/cli-entitlement`, {
+            headers: { Authorization: `Bearer ${token}` },
+        });
+        if (!res.ok) {
+            if (res.status === 401) {
+                console.error("  ⚠️  CLI 토큰이 만료되었거나 유효하지 않습니다. laxy-verify login 으로 다시 로그인하세요.");
+            }
+            return FREE_FEATURES;
+        }
+        const features = (await res.json());
+        cache = { features, fetchedAt: Date.now() };
+        return features;
+    }
+    catch {
+        // 네트워크 오류 → Free로 폴백 (오프라인에서도 기본 검증 가능)
+        return FREE_FEATURES;
+    }
+}
+function printPlanBanner(features) {
+    const planLabels = {
+        free: "Free",
+        pro: "Pro",
+        pro_plus: "Pro+",
+        team: "Team",
+        enterprise: "Enterprise",
+    };
+    const label = planLabels[features.plan] ?? features.plan;
+    if (features.plan !== "free") {
+        console.log(`  플랜: ${label}`);
+    }
+}

package/dist/grade.d.ts

@@ -26,6 +26,8 @@ export declare function calculateGrade(options: {
         bestPractices: number;
     };
     failOn: VerificationGrade;
+    /** Pro+ 전용: true면 Gold 달성 가능 (모든 뷰포트 Lighthouse 통과 시) */
+    goldEligible?: boolean;
 }): GradeResult;
 export declare function gradeToColor(grade: VerificationGrade): {
     text: string;

package/dist/grade.js

@@ -18,11 +18,15 @@ function isWorseOrEqual(actual, threshold) {
     return GRADE_ORDER.indexOf(actual) > GRADE_ORDER.indexOf(threshold);
 }
 function calculateGrade(options) {
-    const { buildSuccess, scores, thresholds, failOn } = options;
+    const { buildSuccess, scores, thresholds, failOn, goldEligible = false } = options;
     let grade;
     if (!buildSuccess) {
         grade = "unverified";
     }
+    else if (goldEligible && scores && getLighthousePass(scores, thresholds)) {
+        // Pro+: 모든 뷰포트 Lighthouse 통과 → Gold
+        grade = "gold";
+    }
     else if (scores && getLighthousePass(scores, thresholds)) {
         grade = "silver";
     }

package/dist/multi-viewport.d.ts

@@ -0,0 +1,20 @@
+import type { LighthouseScores } from "./grade.js";
+export interface ViewportScores {
+    desktop: LighthouseScores | null;
+    tablet: LighthouseScores | null;
+    mobile: LighthouseScores | null;
+}
+export declare function runMultiViewportLighthouse(port: number): Promise<ViewportScores>;
+export declare function printMultiViewportResults(scores: ViewportScores, thresholds: {
+    performance: number;
+    accessibility: number;
+    seo: number;
+    bestPractices: number;
+}): void;
+/** 모든 뷰포트가 임계치를 통과하면 true */
+export declare function allViewportsPass(scores: ViewportScores, thresholds: {
+    performance: number;
+    accessibility: number;
+    seo: number;
+    bestPractices: number;
+}): boolean;

package/dist/multi-viewport.js

@@ -0,0 +1,155 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMultiViewportLighthouse = runMultiViewportLighthouse;
+exports.printMultiViewportResults = printMultiViewportResults;
+exports.allViewportsPass = allViewportsPass;
+/**
+ * multi-viewport.ts — Pro+ 멀티 뷰포트 Lighthouse 실행
+ *
+ * 데스크톱·태블릿·모바일 3종 뷰포트에서 각각 Lighthouse를 실행하고
+ * 각 뷰포트의 점수를 반환합니다.
+ */
+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" },
+];
+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"] });
+    child.stdout?.on("data", (chunk) => {
+        const lines = chunk.toString().split("\n").filter(Boolean);
+        for (const l of lines)
+            console.log(`    [lhci:${viewport.name}] ${l}`);
+    });
+    child.stderr?.on("data", (chunk) => {
+        const lines = chunk.toString().split("\n").filter(Boolean);
+        for (const l of lines)
+            console.error(`    [lhci:${viewport.name}] ${l}`);
+    });
+    const code = await new Promise((res) => child.on("exit", (c) => res(c ?? 1)));
+    if (code !== 0)
+        return null;
+    // 결과 JSON 파싱
+    try {
+        const files = fs.readdirSync(vpDir).filter((f) => f.startsWith("lhr-") && f.endsWith(".json"));
+        if (files.length === 0)
+            return null;
+        const scores = files.map((f) => {
+            const lhr = JSON.parse(fs.readFileSync(path.join(vpDir, f), "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 med = (arr) => {
+            const s = [...arr].sort((a, b) => a - b);
+            const m = Math.floor(s.length / 2);
+            return s.length % 2 !== 0 ? s[m] : (s[m - 1] + s[m]) / 2;
+        };
+        return {
+            performance: med(scores.map((s) => s.performance)),
+            accessibility: med(scores.map((s) => s.accessibility)),
+            seo: med(scores.map((s) => s.seo)),
+            bestPractices: med(scores.map((s) => s.bestPractices)),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+async function runMultiViewportLighthouse(port) {
+    console.log("\n  [Pro+] 멀티 뷰포트 Lighthouse 실행 중 (데스크톱 / 태블릿 / 모바일)...");
+    const outputDir = ".lighthouseci-mvp";
+    const results = { desktop: null, tablet: null, mobile: null };
+    for (const vp of VIEWPORTS) {
+        console.log(`\n    뷰포트: ${vp.name}`);
+        results[vp.name] = await runLighthouseForViewport(port, vp, outputDir);
+    }
+    return results;
+}
+function printMultiViewportResults(scores, thresholds) {
+    const check = (passed) => (passed ? "✅" : "❌");
+    const labels = ["desktop", "tablet", "mobile"];
+    const vpLabel = { desktop: "데스크톱", tablet: "태블릿 ", mobile: "모바일  " };
+    console.log("\n  [Pro+] 멀티 뷰포트 결과:");
+    for (const vp of labels) {
+        const s = scores[vp];
+        if (!s) {
+            console.log(`    ${vpLabel[vp]}: 실행 실패`);
+            continue;
+        }
+        const all = s.performance >= thresholds.performance &&
+            s.accessibility >= thresholds.accessibility &&
+            s.seo >= thresholds.seo &&
+            s.bestPractices >= thresholds.bestPractices;
+        console.log(`    ${vpLabel[vp]}: P=${s.performance} A=${s.accessibility} SEO=${s.seo} BP=${s.bestPractices}  ${check(all)}`);
+    }
+}
+/** 모든 뷰포트가 임계치를 통과하면 true */
+function allViewportsPass(scores, thresholds) {
+    return ["desktop", "tablet", "mobile"].every((vp) => {
+        const s = scores[vp];
+        if (!s)
+            return false;
+        return (s.performance >= thresholds.performance &&
+            s.accessibility >= thresholds.accessibility &&
+            s.seo >= thresholds.seo &&
+            s.bestPractices >= thresholds.bestPractices);
+    });
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "laxy-verify",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "description": "Frontend quality gate: build + Lighthouse verification",
   "type": "commonjs",
   "bin": {
-    "laxy-verify": "./dist/cli.js"
+    "laxy-verify": "dist/cli.js"
   },
   "files": [
     "dist/"