@juangadm/pre-post 0.3.0 → 1.1.0

package/dist/bin/cli.js

@@ -1,498 +1,283 @@
 #!/usr/bin/env node
 import { parseArgs } from 'node:util';
-import path from 'path';
-import fs from 'fs';
-import { BeforeAndAfter, generateFilename } from '../index.js';
-import { VIEWPORT_PRESETS } from '../types.js';
-import { closeBrowser } from '../browser.js';
-import { captureScreenshot } from '../capture.js';
-import { captureVideo } from '../video.js';
-import { uploadBeforeAfter } from '../upload.js';
-import { copyToClipboard } from '../clipboard.js';
-import { detectRoutes, getChangedFiles, detectFramework } from '../routes.js';
-import { resolveViewport } from '../viewport.js';
-// Determine subcommand
-const subcommand = process.argv[2];
-const isSubcommand = ['detect', 'compare', 'run'].includes(subcommand);
-if (isSubcommand) {
-    // Remove subcommand from argv for parseArgs
-    process.argv.splice(2, 1);
+import { createRequire } from 'module';
+import { runPr } from '../commands/pr.js';
+import { runCompare } from '../commands/compare.js';
+import { runLogin } from '../commands/login.js';
+import { runPrune } from '../commands/prune.js';
+import { doctorExitCode, runDoctor } from '../commands/doctor.js';
+import { runDetect } from '../commands/detect.js';
+import { NeedsHumanError } from '../errors.js';
+import { buildSummary } from '../report.js';
+const require = createRequire(import.meta.url);
+const VERSION = (() => {
+    try {
+        return require('../../package.json').version;
+    }
+    catch {
+        return '0.0.0';
+    }
+})();
+const SUBCOMMANDS = ['pr', 'detect', 'login', 'prune', 'doctor', 'compare'];
+const argv = process.argv.slice(2);
+const subcommand = SUBCOMMANDS.includes(argv[0]) ? argv.shift() : null;
+/**
+ * parseArgs throws a TypeError for an unknown flag, and an uncaught one prints
+ * a Node-internal stack trace: eight lines of `node:internal/util/parse_args`
+ * for a typo. The CLI is mostly read by agents, so the first line has to be the
+ * thing to fix, not a frame from Node's parser.
+ *
+ * Only the parse is wrapped, and the message is Node's own — this reformats a
+ * failure, it does not decide what counts as one.
+ */
+function parse() {
+    try {
+        return parseArgs({
+            args: argv,
+            allowPositionals: true,
+            options: OPTIONS,
+        });
+    }
+    catch (err) {
+        const message = err?.message?.split('\n')[0] ?? 'could not parse the arguments';
+        console.error(`pre-post: ${message}`);
+        console.error('Run: pre-post --help');
+        process.exit(2);
+    }
 }
-const { values, positionals } = parseArgs({
-    allowPositionals: true,
-    options: {
-        help: { type: 'boolean', short: 'h' },
-        // Viewport presets (default: desktop)
-        mobile: { type: 'boolean', short: 'm' },
-        tablet: { type: 'boolean', short: 't' },
-        size: { type: 'string' }, // WxH custom size
-        // Capture options
-        full: { type: 'boolean', short: 'f' },
-        selector: { type: 'string', short: 's' },
-        // Output options
-        output: { type: 'string', short: 'o' },
-        markdown: { type: 'boolean' },
-        'upload-url': { type: 'string' },
-        // New options
-        responsive: { type: 'boolean', short: 'r' },
-        routes: { type: 'string' },
-        'max-routes': { type: 'string' },
-        framework: { type: 'string' },
-        'before-base': { type: 'string' },
-        'after-base': { type: 'string' },
-        // Video/GIF options
-        video: { type: 'boolean' },
-        duration: { type: 'string' },
-        fps: { type: 'string' },
-        delay: { type: 'string' },
-    },
-});
+const OPTIONS = {
+    help: { type: 'boolean', short: 'h' },
+    version: { type: 'boolean', short: 'v' },
+    before: { type: 'string' },
+    after: { type: 'string' },
+    routes: { type: 'string' },
+    'max-routes': { type: 'string' },
+    framework: { type: 'string' },
+    base: { type: 'string' },
+    'no-local-baseline': { type: 'boolean' },
+    viewports: { type: 'string' },
+    mobile: { type: 'boolean', short: 'm' },
+    tablet: { type: 'boolean', short: 't' },
+    responsive: { type: 'boolean', short: 'r' },
+    size: { type: 'string' },
+    full: { type: 'boolean', short: 'f' },
+    'viewport-only': { type: 'boolean' },
+    scale: { type: 'string' },
+    threshold: { type: 'string' },
+    'max-height': { type: 'string' },
+    wait: { type: 'string' },
+    header: { type: 'string', multiple: true },
+    cookie: { type: 'string', multiple: true },
+    output: { type: 'string', short: 'o' },
+    'dry-run': { type: 'boolean' },
+    'no-comment': { type: 'boolean' },
+    pr: { type: 'string' },
+    json: { type: 'boolean' },
+    days: { type: 'string' },
+    quiet: { type: 'boolean', short: 'q' },
+};
+const { values, positionals } = parse();
 function printHelp() {
-    console.log(`
-pre-post — Visual diff tool for PRs
-
-USAGE:
-  pre-post <before> <after> [selector] [selector2]
-  pre-post detect [options]
-  pre-post compare --before-base <url> --after-base <url> [options]
-  pre-post run --before-base <url> --after-base <url> [options]
-
-SUBCOMMANDS:
-  detect              Detect affected routes from git diff (JSON output)
-  compare             Compare before/after URLs with screenshots
-  run                 Auto-detect routes + compare (detect + compare)
-
-  Arguments can be URLs or image files (auto-detected).
-  Selectors are optional - use one for both, or two for different selectors.
-
-VIEWPORT OPTIONS:
-      (default)              Desktop viewport (1280x800)
-  -m, --mobile               Mobile viewport (375x812)
-  -t, --tablet               Tablet viewport (768x1024)
-      --size <WxH>           Custom viewport (e.g., 1920x1080)
-
-CAPTURE OPTIONS:
-  -f, --full                 Capture full scrollable page
-  -s, --selector <css>       Scroll element into view before capture
-  -r, --responsive           Capture at desktop + mobile viewports
-
-ROUTE DETECTION OPTIONS:
-      --routes <paths>       Explicit route list (comma-separated)
-      --max-routes <n>       Max routes to detect (default: 5)
-      --framework <name>     Force framework (nextjs-app, nextjs-pages, generic)
-
-COMPARE OPTIONS:
-      --before-base <url>    Base URL for "before" state (production)
-      --after-base <url>     Base URL for "after" state (localhost)
-
-VIDEO OPTIONS:
-      --video                Capture animated GIF instead of static screenshot
-      --duration <seconds>   Recording duration (default: 3, max: 10)
-      --fps <n>              Target frames per second (default: 5, max: 10)
-      --delay <ms>           Wait after page load before recording (default: 0)
-
-OUTPUT OPTIONS:
-  -o, --output <dir>         Output directory (default: ~/Downloads)
-      --markdown             Upload images & output markdown table
-      --upload-url <url>     Upload endpoint (overrides git-native default)
-                             Auto-detects: 0x0.st, blob.vercel, generic PUT
-
-OTHER OPTIONS:
-  -h, --help                 Show this help
-
-EXAMPLES:
-  # Compare two URLs (protocol optional)
-  pre-post google.com facebook.com
-  pre-post https://old.example.com https://new.example.com
-
-  # Detect routes from git diff
-  pre-post detect
-  pre-post detect --framework nextjs-app
-
-  # Compare with auto-detected routes
-  pre-post run --before-base https://prod.com --after-base http://localhost:3000
-
-  # Compare specific routes
-  pre-post compare --before-base https://prod.com --after-base http://localhost:3000 --routes /dashboard,/settings
+    console.log(`pre-post ${VERSION} — before/after screenshots for pull requests
 
-  # Responsive capture (desktop + mobile)
-  pre-post compare --before-base url1 --after-base url2 --responsive
+USAGE
+  pre-post pr [options]                 Detect routes, capture, diff, publish, comment on the PR
+  pre-post <before> <after> [options]   Compare two URLs (or two PNG files)
+  pre-post detect                       Print the routes this branch affects (JSON)
+  pre-post ... --base <ref>             Compare against <ref> instead of the detected fork point
+  pre-post login <url>                  Sign in once; the session is reused for captures
+  pre-post prune [--days 90]            Delete screenshots for PRs closed longer ago
+  pre-post doctor                       Check browser, GitHub auth, dev server
 
-  # Capture animated GIFs instead of static screenshots
-  pre-post google.com facebook.com --video
-  pre-post google.com facebook.com --video --duration 5 --fps 8
+OPTIONS
+  --before <url>            Production base URL (saved to .pre-post.json)
+  --after <url>             Local base URL (auto-detected)
+  --routes /a,/b            Explicit routes instead of detection
+  --max-routes <n>          Cap on detected routes (default 6)
+  --viewports desktop,mobile,1440x900   Viewports (default desktop)
+  -r, --responsive          Desktop and mobile
+  -m, --mobile  -t, --tablet  --size WxH   Single-viewport shorthands
+  -f, --full | --viewport-only          Full page (default for pr) or first screen only
+  --scale <n>               Device scale factor (default 2)
+  --threshold <0..1>        Change ratio treated as "no change" (default 0.001)
+  --max-height <px>         Full-page height cap in CSS px (default 2400)
+  --wait <ms>               Extra wait after the page settles
+  --header k=v              Extra request header (repeatable)
+  --cookie name=value       Cookie for the production host (repeatable)
+  -o, --output <dir>        Where to write images (default: temp dir)
+  --no-local-baseline       Do not rebuild the baseline from the base commit
+  --dry-run                 Capture and diff only; no upload, no comment
+  --no-comment              Publish images but do not touch the PR
+  --pr <number>             Target a specific PR
+  --json                    Machine-readable output
+  -q, --quiet               Only the final summary
 
-  # GIF capture with compare mode
-  pre-post compare --before-base url1 --after-base url2 --video --delay 500
-
-  # Use existing images (auto-detected)
-  pre-post before.png after.png --markdown
+ENVIRONMENT
+  GH_TOKEN / GITHUB_TOKEN               GitHub token (default: gh auth token)
+  VERCEL_AUTOMATION_BYPASS_SECRET       Bypass Vercel Deployment Protection
+  PRE_POST_CONCURRENCY                  Parallel pages (default 6)
+  PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH   Use a specific Chromium binary
 `);
 }
-const IMAGE_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.tiff'];
-function isImageFile(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
-    return IMAGE_EXTENSIONS.includes(ext) && fs.existsSync(filePath);
-}
-function normalizeUrl(url) {
-    if (/^(https?|file):\/\//i.test(url)) {
-        return url;
-    }
-    if (/^(localhost|127\.0\.0\.1)(:|\/|$)/i.test(url)) {
-        return `http://${url}`;
-    }
-    return `https://${url}`;
-}
-function parseStrictNumber(value, flag) {
-    if (!/^-?\d+(?:\.\d+)?$/.test(value.trim())) {
-        console.error(`Invalid value for ${flag}: ${value}. Expected a number.`);
-        process.exit(1);
-    }
-    const parsed = Number(value);
-    if (!Number.isFinite(parsed)) {
-        console.error(`Invalid value for ${flag}: ${value}. Expected a finite number.`);
-        process.exit(1);
-    }
-    return parsed;
-}
-function parseStrictInteger(value, flag) {
-    if (!/^-?\d+$/.test(value.trim())) {
-        console.error(`Invalid value for ${flag}: ${value}. Expected an integer.`);
-        process.exit(1);
-    }
-    const parsed = Number(value);
-    if (!Number.isSafeInteger(parsed)) {
-        console.error(`Invalid value for ${flag}: ${value}. Expected a safe integer.`);
-        process.exit(1);
+function num(v, flag) {
+    if (v === undefined)
+        return undefined;
+    const n = Number(v);
+    if (!Number.isFinite(n)) {
+        console.error(`Invalid value for ${flag}: ${v}`);
+        process.exit(2);
     }
-    return parsed;
+    return n;
 }
-/**
- * Validate --video flag combinations and parse video-related options.
- * Returns parsed options if --video is set, undefined otherwise.
- */
-function validateVideoFlags() {
-    if (!values.video)
+function kv(list) {
+    if (!list?.length)
         return undefined;
-    if (values.full) {
-        console.error('--full (fullPage) is not supported with --video');
-        process.exit(1);
-    }
-    const duration = values.duration ? parseStrictNumber(values.duration, '--duration') : undefined;
-    if (duration !== undefined && (duration <= 0 || duration > 10)) {
-        console.error('Duration must be between 0.1 and 10 seconds');
-        process.exit(1);
-    }
-    const fps = values.fps ? parseStrictInteger(values.fps, '--fps') : undefined;
-    if (fps !== undefined && (fps < 1 || fps > 10)) {
-        console.error('FPS must be between 1 and 10');
-        process.exit(1);
-    }
-    const delay = values.delay ? parseStrictInteger(values.delay, '--delay') : undefined;
-    if (delay !== undefined && delay < 0) {
-        console.error('Delay must be a non-negative integer in milliseconds');
-        process.exit(1);
+    const out = {};
+    for (const item of list) {
+        const sep = item.search(/[=:]/);
+        if (sep === -1) {
+            console.error(`Expected key=value, got: ${item}`);
+            process.exit(2);
+        }
+        out[item.slice(0, sep).trim()] = item.slice(sep + 1).trim();
     }
-    return { duration, fps, delay };
+    return out;
 }
-function resolveViewportFlag() {
+function viewportsFromFlags() {
+    if (values.viewports)
+        return values.viewports.split(',').map(s => s.trim()).filter(Boolean);
+    if (values.responsive)
+        return ['desktop', 'mobile'];
     if (values.mobile)
-        return 'mobile';
+        return ['mobile'];
     if (values.tablet)
-        return 'tablet';
-    if (values.size) {
-        const match = values.size.match(/^(\d+)x(\d+)$/);
-        if (match) {
-            return { width: parseInt(match[1]), height: parseInt(match[2]) };
-        }
-        console.error(`Invalid size: ${values.size}. Use WxH format (e.g., 1920x1080).`);
-        process.exit(1);
-    }
-    return 'desktop';
+        return ['tablet'];
+    if (values.size)
+        return [values.size];
+    return undefined;
 }
-// ============================================================
-// Subcommand: detect
-// ============================================================
-async function runDetect() {
-    const framework = values.framework;
-    const maxRoutes = values['max-routes'] ? parseInt(values['max-routes']) : undefined;
-    const changedFiles = getChangedFiles();
-    if (changedFiles.length === 0) {
-        console.log(JSON.stringify({ routes: [], message: 'No changed files detected' }, null, 2));
-        return;
-    }
-    const detectedFramework = framework || detectFramework();
-    const routes = detectRoutes(changedFiles, { framework, maxRoutes });
-    console.log(JSON.stringify({
-        framework: detectedFramework,
-        changedFiles,
-        routes,
-    }, null, 2));
+/** `before`/`after` come from flags for `pr` and `compare`, from positionals otherwise. */
+function resolveTargets() {
+    if (subcommand === 'pr' || subcommand === 'compare')
+        return { before: values.before, after: values.after };
+    return { before: positionals[0], after: positionals[1] };
 }
-// ============================================================
-// Subcommand: compare
-// ============================================================
-async function runCompare(routeOverrides, videoOpts) {
-    const beforeBase = values['before-base'];
-    const afterBase = values['after-base'];
-    if (!beforeBase || !afterBase) {
-        console.error('Both --before-base and --after-base are required for compare.');
-        process.exit(1);
-    }
-    const routeList = routeOverrides
-        ?? (values.routes ? values.routes.split(',').map(r => r.trim()) : ['/']);
-    const responsive = values.responsive ?? false;
-    const isVideo = values.video ?? false;
-    const ext = isVideo ? 'gif' : 'png';
-    const captureType = isVideo ? 'GIF' : 'screenshot';
-    const outputDir = values.output || path.join(process.env.HOME || '~', 'Downloads');
-    fs.mkdirSync(outputDir, { recursive: true });
-    const timestamp = new Date();
-    const viewports = responsive
-        ? ['desktop', 'mobile'].map(p => ({ label: p, size: VIEWPORT_PRESETS[p] }))
-        : [{ size: resolveViewport(resolveViewportFlag()) }];
-    const tasks = [];
-    for (const route of routeList) {
-        const beforeUrl = normalizeUrl(beforeBase.replace(/\/$/, '') + route);
-        const afterUrl = normalizeUrl(afterBase.replace(/\/$/, '') + route);
-        const routeSlug = route === '/' ? 'home' : route.replace(/^\//, '').replace(/\//g, '-');
-        for (const { label: presetLabel, size: vp } of viewports) {
-            const filePrefix = presetLabel ? `${routeSlug}-${presetLabel}` : routeSlug;
-            tasks.push({
-                route,
-                presetLabel,
-                vp,
-                beforeUrl,
-                afterUrl,
-                beforeFilename: `${filePrefix}-before-${formatTimestamp(timestamp)}.${ext}`,
-                afterFilename: `${filePrefix}-after-${formatTimestamp(timestamp)}.${ext}`,
-            });
-        }
-    }
-    const totalCaptures = tasks.length * 2;
-    console.log(`Capturing ${totalCaptures} ${captureType}s across ${routeList.length} route(s)...`);
-    try {
-        // Execute all tasks in parallel (pool limits concurrency)
-        const results = await Promise.allSettled(tasks.map(async (task) => {
-            if (isVideo) {
-                const opts = { viewport: task.vp, ...videoOpts, selector: values.selector };
-                const [beforeResult, afterResult] = await Promise.all([
-                    captureVideo(task.beforeUrl, opts),
-                    captureVideo(task.afterUrl, opts),
-                ]);
-                fs.writeFileSync(path.join(outputDir, task.beforeFilename), beforeResult.gif);
-                fs.writeFileSync(path.join(outputDir, task.afterFilename), afterResult.gif);
-                console.log(`  Done: ${task.route}${task.presetLabel ? ` @ ${task.presetLabel}` : ''} (${beforeResult.frameCount}f + ${afterResult.frameCount}f)`);
-            }
-            else {
-                const [beforeResult, afterResult] = await Promise.all([
-                    captureScreenshot({
-                        url: task.beforeUrl, viewport: task.vp, fullPage: values.full, selector: values.selector,
-                    }),
-                    captureScreenshot({
-                        url: task.afterUrl, viewport: task.vp, fullPage: values.full, selector: values.selector,
-                    }),
-                ]);
-                fs.writeFileSync(path.join(outputDir, task.beforeFilename), beforeResult.image);
-                fs.writeFileSync(path.join(outputDir, task.afterFilename), afterResult.image);
-                console.log(`  Done: ${task.route}${task.presetLabel ? ` @ ${task.presetLabel}` : ''}`);
-            }
-        }));
-        const failures = results.filter((r) => r.status === 'rejected');
-        if (failures.length > 0) {
-            for (const f of failures)
-                console.error(`  Failed: ${f.reason}`);
-            if (failures.length === results.length)
-                throw new Error('All captures failed');
-        }
-        console.log(`\nAll ${captureType}s saved to: ${outputDir}`);
-    }
-    finally {
-        await closeBrowser();
+const quiet = values.quiet || values.json;
+const log = (msg) => { if (!quiet)
+    console.error(msg); };
+function output(result) {
+    if (values.json) {
+        console.log(JSON.stringify(result, null, 2));
+        return;
     }
+    console.log(buildSummary(result));
+    console.log(`Files: ${result.outputDir}`);
+    if (result.markdown && !result.commentUrl)
+        console.log('\n' + result.markdown);
 }
-// ============================================================
-// Subcommand: run (detect + compare)
-// ============================================================
-async function runFull(videoOpts) {
-    const beforeBase = values['before-base'];
-    const afterBase = values['after-base'];
-    if (!beforeBase || !afterBase) {
-        console.error('Both --before-base and --after-base are required for run.');
-        process.exit(1);
-    }
-    const framework = values.framework;
-    const maxRoutes = values['max-routes'] ? parseInt(values['max-routes']) : undefined;
-    const changedFiles = getChangedFiles();
-    let routeList;
-    if (values.routes) {
-        routeList = values.routes.split(',').map(r => r.trim());
-    }
-    else if (changedFiles.length > 0) {
-        const routes = detectRoutes(changedFiles, { framework, maxRoutes });
-        if (routes.length === 0) {
-            console.log('No visual routes detected. Defaulting to /');
-            routeList = ['/'];
-        }
-        else {
-            routeList = routes.map(r => r.path);
-            console.log(`Detected routes: ${routeList.join(', ')}`);
-        }
-    }
-    else {
-        console.log('No changed files detected. Defaulting to /');
-        routeList = ['/'];
+async function main() {
+    if (values.version) {
+        console.log(VERSION);
+        return;
     }
-    await runCompare(routeList, videoOpts);
-}
-// ============================================================
-// Default mode (original before-and-after behavior)
-// ============================================================
-async function runDefault(videoOpts) {
-    if (values.help) {
+    if (values.help || (!subcommand && positionals.length < 2)) {
         printHelp();
+        if (!values.help && !subcommand && positionals.length > 0)
+            process.exit(2);
         return;
     }
-    if (positionals.length < 2) {
-        console.error('Two arguments required (URLs or image paths). Run with --help for usage.');
-        process.exit(1);
-    }
-    const [first, second, ...rest] = positionals;
-    const viewport = resolveViewportFlag();
-    const ba = new BeforeAndAfter({ viewport });
-    try {
-        // Auto-detect image mode
-        if (isImageFile(first) && isImageFile(second)) {
-            const result = await ba.fromImages({
-                before: first,
-                after: second,
-            });
-            if (values.markdown) {
-                await uploadAndOutputMarkdown(result.beforeImage, result.afterImage, path.basename(first), path.basename(second));
-            }
-            else {
-                console.log(`Before: ${first}`);
-                console.log(`After:  ${second}`);
+    const common = {
+        routes: values.routes ? values.routes.split(',').map(r => r.trim()).filter(Boolean) : undefined,
+        viewports: viewportsFromFlags(),
+        fullPage: values['viewport-only'] ? false : values.full ? true : undefined,
+        scale: num(values.scale, '--scale'),
+        threshold: num(values.threshold, '--threshold'),
+        maxHeight: num(values['max-height'], '--max-height'),
+        maxRoutes: num(values['max-routes'], '--max-routes'),
+        wait: num(values.wait, '--wait'),
+        headers: kv(values.header),
+        output: values.output,
+        log,
+    };
+    const { before, after } = resolveTargets();
+    switch (subcommand) {
+        case 'pr': {
+            // before/after come from flags here; positionals would be silently dropped.
+            if (positionals.length) {
+                console.error(`pre-post pr takes no positional arguments (got: ${positionals.join(' ')}). Use --before and --after.`);
+                process.exit(2);
             }
+            const cookies = values.cookie ? Object.entries(kv(values.cookie)).map(([name, value]) => ({ name, value })) : undefined;
+            const result = await runPr({
+                ...common,
+                before,
+                after,
+                framework: values.framework,
+                base: values.base,
+                cookies,
+                dryRun: values['dry-run'],
+                localBaseline: !values['no-local-baseline'],
+                comment: !values['no-comment'],
+                pr: num(values.pr, '--pr'),
+                version: VERSION,
+            });
+            output(result);
+            if (result.outcomes.length && result.outcomes.every(o => o.status === 'error'))
+                process.exit(1);
             return;
         }
-        // URL mode
-        const beforeUrl = normalizeUrl(first);
-        const afterUrl = normalizeUrl(second);
-        // Resolve selectors: positional args override -s flag
-        let beforeSelector = values.selector;
-        let afterSelector = values.selector;
-        if (rest.length >= 1) {
-            beforeSelector = rest[0];
-            afterSelector = rest[0];
-        }
-        if (rest.length >= 2) {
-            afterSelector = rest[1];
+        case 'detect': {
+            const detection = runDetect({ maxRoutes: common.maxRoutes, framework: values.framework, base: values.base });
+            console.log(JSON.stringify(detection, null, values.json ? 2 : 0));
+            return;
         }
-        const outputDir = values.output || path.join(process.env.HOME || '~', 'Downloads');
-        fs.mkdirSync(outputDir, { recursive: true });
-        const isVideo = values.video ?? false;
-        const captureType = isVideo ? 'GIF' : 'screenshot';
-        console.log(`Capturing ${captureType} before: ${beforeUrl}${beforeSelector ? ` (${beforeSelector})` : ''}`);
-        console.log(`Capturing ${captureType} after:  ${afterUrl}${afterSelector ? ` (${afterSelector})` : ''}`);
-        if (isVideo) {
-            // Video/GIF mode
-            const resolvedViewport = resolveViewport(viewport);
-            const opts = {
-                viewport: resolvedViewport,
-                ...videoOpts,
-                selector: beforeSelector,
-            };
-            const beforeResult = await captureVideo(beforeUrl, opts);
-            const afterResult = await captureVideo(afterUrl, { ...opts, selector: afterSelector });
-            const timestamp = new Date();
-            const beforeFilename = generateFilename({ url: beforeUrl, suffix: 'before', timestamp, format: 'gif' });
-            const afterFilename = generateFilename({ url: afterUrl, suffix: 'after', timestamp, format: 'gif' });
-            const beforePath = path.join(outputDir, beforeFilename);
-            const afterPath = path.join(outputDir, afterFilename);
-            fs.writeFileSync(beforePath, beforeResult.gif);
-            fs.writeFileSync(afterPath, afterResult.gif);
-            console.log(`\nSaved: ${beforePath} (${beforeResult.frameCount} frames)`);
-            console.log(`Saved: ${afterPath} (${afterResult.frameCount} frames)`);
-            if (values.markdown) {
-                await uploadAndOutputMarkdown(beforeResult.gif, afterResult.gif, beforeFilename, afterFilename);
+        case 'login': {
+            if (!positionals[0]) {
+                console.error('Usage: pre-post login <url>');
+                process.exit(2);
             }
+            await runLogin(positionals[0]);
+            return;
         }
-        else {
-            // Static screenshot mode
-            const result = await ba.captureBeforeAfter({
-                before: {
-                    url: beforeUrl,
-                    selector: beforeSelector,
-                    fullPage: values.full,
-                },
-                after: {
-                    url: afterUrl,
-                    selector: afterSelector,
-                    fullPage: values.full,
-                },
-            });
-            const timestamp = new Date();
-            const beforeFilename = generateFilename({ url: beforeUrl, suffix: 'before', timestamp });
-            const afterFilename = generateFilename({ url: afterUrl, suffix: 'after', timestamp });
-            const beforePath = path.join(outputDir, beforeFilename);
-            const afterPath = path.join(outputDir, afterFilename);
-            fs.writeFileSync(beforePath, result.before.image);
-            fs.writeFileSync(afterPath, result.after.image);
-            console.log(`\nSaved: ${beforePath}`);
-            console.log(`Saved: ${afterPath}`);
-            if (values.markdown) {
-                await uploadAndOutputMarkdown(result.before.image, result.after.image, beforeFilename, afterFilename);
+        case 'prune': {
+            const result = await runPrune({ days: num(values.days, '--days'), dryRun: values['dry-run'] });
+            console.log(values['dry-run'] ? 'Would remove:' : 'Removed:', result.removed.length ? result.removed.join(', ') : 'nothing');
+            console.log('Kept:', result.kept.length ? result.kept.join(', ') : 'nothing');
+            return;
+        }
+        case 'doctor': {
+            const checks = await runDoctor();
+            for (const c of checks) {
+                // Advisory failures are worth reading and are not failures of the
+                // command, so they must not look like the ones that are.
+                const status = c.ok ? 'ok' : c.required ? 'FAIL' : 'note';
+                console.log(`${c.name.padEnd(10)} ${status.padEnd(4)}  ${c.detail}`);
             }
+            const code = doctorExitCode(checks);
+            console.log(code === 0
+                ? 'ready — pre-post pr can run'
+                : `not ready — fix: ${checks.filter(c => c.required && !c.ok).map(c => c.name).join(', ')}`);
+            process.exit(code);
         }
-    }
-    finally {
-        await closeBrowser();
-    }
-}
-function formatTimestamp(date) {
-    return date.toISOString().replace(/[:.]/g, '-').slice(0, 19);
-}
-function buildMarkdownTable(beforeUrl, afterUrl) {
-    const header = '| Pre | Post |';
-    const divider = '|:---:|:----:|';
-    const row = `| ![Pre](${beforeUrl}) | ![Post](${afterUrl}) |`;
-    return `${header}\n${divider}\n${row}`;
-}
-async function uploadAndOutputMarkdown(beforeImage, afterImage, beforeFilename, afterFilename) {
-    const uploadUrl = values['upload-url'] || process.env.UPLOAD_URL;
-    console.log(`Uploading images${uploadUrl ? ` to ${uploadUrl}` : ''}...`);
-    const { beforeUrl, afterUrl } = await uploadBeforeAfter({ image: beforeImage, filename: beforeFilename }, { image: afterImage, filename: afterFilename }, uploadUrl);
-    const markdown = buildMarkdownTable(beforeUrl, afterUrl);
-    console.log(`\n${markdown}`);
-    if (copyToClipboard(markdown)) {
-        console.log('\nMarkdown copied to clipboard');
-    }
-}
-// ============================================================
-// Main dispatch
-// ============================================================
-async function main() {
-    if (values.help && !isSubcommand) {
-        printHelp();
-        return;
-    }
-    const videoOpts = validateVideoFlags();
-    switch (subcommand) {
-        case 'detect':
-            return runDetect();
         case 'compare':
-            return runCompare(undefined, videoOpts);
-        case 'run':
-            return runFull(videoOpts);
-        default:
-            return runDefault(videoOpts);
+        default: {
+            if (!before || !after) {
+                console.error('Two URLs (or two PNG files) are required.');
+                process.exit(2);
+            }
+            output(await runCompare({ ...common, before, after }));
+            return;
+        }
     }
 }
 main()
     .then(() => process.exit(0))
-    .catch((err) => {
-    console.error(err.message);
+    .catch(err => {
+    if (err instanceof NeedsHumanError) {
+        console.error(`\n${err.message}`);
+        process.exit(3);
+    }
+    console.error(err?.stack && process.env.PRE_POST_DEBUG ? err.stack : `Error: ${err?.message || err}`);
     process.exit(1);
 });
 //# sourceMappingURL=cli.js.map