@reshotdev/screenshot 0.0.1-beta.2 → 0.0.1-beta.20

package/src/commands/run.js

@@ -1,9 +1,15 @@
 // run.js - Execute all scenarios from config using the robust capture engine
+const axios = require("axios");
 const chalk = require("chalk");
 const fs = require("fs-extra");
 const path = require("path");
 const config = require("../lib/config");
-const { runAllScenarios, generateVersionTimestamp, detectOptimalConcurrency } = require("../lib/capture-script-runner");
+const {
+  runAllScenarios,
+  generateVersionTimestamp,
+  detectOptimalConcurrency,
+  resolveAuthPreflightTargets,
+} = require("../lib/capture-script-runner");
 const { getBaselines } = require("../lib/api-client");
 const {
   downloadBaselines,
@@ -14,6 +20,12 @@ const {
   writeLocalDiffManifest,
   CACHE_DIR,
 } = require("../lib/diff-engine");
+const {
+  checkCdpEndpoint,
+  getDefaultSessionPath,
+  assessSessionHealth,
+} = require("../lib/record-cdp");
+const { writeRunManifest, normalizeScenarioResults } = require("../lib/run-manifest");
 
 /**
  * Generate all variant combinations from dimensions config
@@ -68,6 +80,224 @@ function generateVariantCombinations(dimensions, dimensionKeys = null) {
   });
 }
 
+async function probeBaseUrl(baseUrl) {
+  if (!baseUrl) {
+    return {
+      ok: false,
+      status: null,
+      message: "baseUrl is not configured.",
+    };
+  }
+
+  try {
+    const response = await axios.get(baseUrl, {
+      timeout: 8000,
+      maxRedirects: 0,
+      validateStatus: () => true,
+    });
+
+    if (response.status >= 500) {
+      return {
+        ok: false,
+        status: response.status,
+        message: `baseUrl responded with ${response.status}. Fix the app before running capture.`,
+      };
+    }
+
+    return {
+      ok: true,
+      status: response.status,
+      message: `baseUrl responded with ${response.status}`,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      status: null,
+      message:
+        `Could not reach baseUrl ${baseUrl}. ` +
+        `Make sure the app is running and reachable before capture. (${error.message})`,
+    };
+  }
+}
+
+function formatSessionAge(minutes) {
+  if (minutes < 60) {
+    return `${minutes}m`;
+  }
+
+  const hours = Math.round(minutes / 60);
+  if (hours < 24) {
+    return `${hours}h`;
+  }
+
+  return `${Math.round(hours / 24)}d`;
+}
+
+function writeRunPreflightReport(report) {
+  const diagnosticsPath = path.join(
+    process.cwd(),
+    ".reshot",
+    "diagnostics",
+    "run-preflight.json",
+  );
+
+  try {
+    fs.ensureDirSync(path.dirname(diagnosticsPath));
+    fs.writeJsonSync(diagnosticsPath, report, { spaces: 2 });
+  } catch (error) {
+    report.diagnosticsWriteError = error.message;
+  }
+
+  return diagnosticsPath;
+}
+
+async function buildRunPreflightReport(docSyncConfig, options = {}) {
+  const { scenarioKeys = null } = options;
+  const validation = config.validateConfig({
+    scenarioKeys,
+    requireReadyContract: docSyncConfig.target?.tier === "certified",
+  });
+  const errors = [...validation.errors];
+  const warnings = [...validation.warnings];
+  const report = {
+    generatedAt: new Date().toISOString(),
+    ok: false,
+    baseUrl: docSyncConfig.baseUrl || null,
+    selectedScenarioKeys: validation.details?.selectedScenarioKeys || [],
+    configValidation: validation,
+    checks: [],
+    auth: {
+      required: Boolean(validation.details?.liveAuthScenarioCount),
+      sessionPath: null,
+      hasCachedSession: false,
+      sessionAgeMinutes: null,
+      sessionCompatible: null,
+      sessionSourceOrigin: null,
+      sessionStale: null,
+      preflightTargets: [],
+      cdpAvailable: null,
+    },
+    errors,
+    warnings,
+  };
+
+  if (validation.details?.baseUrl) {
+    const baseUrlCheck = await probeBaseUrl(validation.details.baseUrl);
+    report.checks.push({ name: "baseUrl", ...baseUrlCheck });
+    if (!baseUrlCheck.ok) {
+      errors.push(baseUrlCheck.message);
+    }
+  }
+
+  if (report.auth.required) {
+    report.auth.preflightTargets = resolveAuthPreflightTargets(docSyncConfig, {
+      scenarioKeys,
+    }).targets;
+    const sessionPath = getDefaultSessionPath();
+    report.auth.sessionPath = sessionPath;
+    report.auth.hasCachedSession = fs.existsSync(sessionPath);
+
+    if (report.auth.hasCachedSession) {
+      const sessionHealth = assessSessionHealth(
+        sessionPath,
+        validation.details?.baseUrl || docSyncConfig.baseUrl || null,
+      );
+      report.auth.sessionAgeMinutes = sessionHealth.ageMinutes;
+      report.auth.sessionCompatible = sessionHealth.compatible;
+      report.auth.sessionSourceOrigin = sessionHealth.evidence.sourceOrigin;
+      report.auth.sessionStale = sessionHealth.stale;
+      report.checks.push({
+        name: "authSession",
+        ok: sessionHealth.compatible,
+        status: sessionHealth.stale ? "stale" : "ready",
+        message: sessionHealth.compatible
+          ? sessionHealth.evidence.sourceOrigin
+            ? `Cached auth session matches ${sessionHealth.evidence.sourceOrigin}`
+            : "Cached auth session is present"
+          : sessionHealth.issues[0],
+      });
+
+      warnings.push(...sessionHealth.warnings);
+
+      if (!sessionHealth.compatible) {
+        const cdpCheck = await checkCdpEndpoint();
+        report.auth.cdpAvailable = cdpCheck.available;
+        report.checks.push({
+          name: "cdp",
+          ok: cdpCheck.available,
+          status: null,
+          message: cdpCheck.available
+            ? "Chrome CDP endpoint is available and can refresh the cached session."
+            : `Chrome CDP endpoint is unavailable: ${cdpCheck.error}`,
+        });
+
+        if (cdpCheck.available) {
+          warnings.push(
+            `Cached auth session does not match ${validation.details?.baseUrl || docSyncConfig.baseUrl}. Chrome CDP is available, so Reshot will try to refresh it from the live browser before capture.`,
+          );
+        } else {
+          errors.push(sessionHealth.issues[0]);
+          errors.push(
+            "Chrome CDP is unavailable, so Reshot cannot automatically replace the mismatched auth session.",
+          );
+        }
+      }
+
+      if (sessionHealth.stale) {
+        warnings.push(
+          `Cached auth session is ${formatSessionAge(sessionHealth.ageMinutes)} old. ` +
+            `Refresh it with 'reshot record --refresh-session' if captures start redirecting to login.`,
+        );
+      }
+    } else {
+      const cdpCheck = await checkCdpEndpoint();
+      report.auth.cdpAvailable = cdpCheck.available;
+      report.checks.push({
+        name: "cdp",
+        ok: cdpCheck.available,
+        status: null,
+        message: cdpCheck.available
+          ? "Chrome CDP endpoint is available for live session sync."
+          : `Chrome CDP endpoint is unavailable: ${cdpCheck.error}`,
+      });
+
+      if (!cdpCheck.available) {
+        errors.push(
+          "Authenticated scenarios need either a cached .reshot session or a Chrome browser running with remote debugging enabled.",
+        );
+      }
+    }
+  }
+
+  report.ok = errors.length === 0;
+  report.diagnosticsPath = writeRunPreflightReport(report);
+  return report;
+}
+
+function printRunPreflightReport(report) {
+  console.log(chalk.cyan("🧪 Run Preflight\n"));
+
+  for (const check of report.checks) {
+    const prefix = check.ok ? chalk.green("  ✔") : chalk.red("  ✖");
+    const statusSuffix = check.status ? ` (${check.status})` : "";
+    console.log(`${prefix} ${check.name}${statusSuffix}: ${check.message}`);
+  }
+
+  for (const warning of report.warnings) {
+    console.log(chalk.yellow(`  ⚠ ${warning}`));
+  }
+
+  for (const error of report.errors) {
+    console.log(chalk.red(`  ✖ ${error}`));
+  }
+
+  if (report.diagnosticsPath) {
+    console.log(chalk.gray(`\n  Diagnostics: ${report.diagnosticsPath}`));
+  }
+
+  console.log();
+}
+
 /**
  * Run scenarios from config
  * @param {Object} options - Run options
@@ -111,6 +341,30 @@ async function runCommand(options = {}) {
     return;
   }
 
+  const preflightReport = await buildRunPreflightReport(docSyncConfig, {
+    scenarioKeys,
+  });
+  printRunPreflightReport(preflightReport);
+
+  if (!preflightReport.ok) {
+    writeRunManifest({
+      success: false,
+      selectedScenarioKeys: preflightReport.selectedScenarioKeys || scenarioKeys || [],
+      outputBaseDir: path.join(
+        process.cwd(),
+        docSyncConfig.assetDir || ".reshot/output",
+      ),
+      scenarios: [],
+      preflight: preflightReport,
+      diffEnabled: false,
+    });
+    process.exitCode = 1;
+    if (!noExit) {
+      setImmediate(() => process.exit(process.exitCode || 1));
+    }
+    return { success: false, results: [], preflight: preflightReport };
+  }
+
   // Determine if diffing is enabled
   // CLI flag takes precedence, then config, default is TRUE (always diff locally)
   const shouldDiff =
@@ -164,6 +418,23 @@ async function runCommand(options = {}) {
   // - If --all-variants or variants are configured: expand all combinations
   const shouldExpandVariants = !noVariants && !variantOverride && hasVariants;
 
+  const outputBaseDir = path.join(
+    process.cwd(),
+    docSyncConfig.assetDir || ".reshot/output"
+  );
+
+  function persistRunManifest(success, scenarios) {
+    return writeRunManifest({
+      success,
+      selectedScenarioKeys:
+        preflightReport.selectedScenarioKeys || scenarioKeys || [],
+      outputBaseDir,
+      scenarios: normalizeScenarioResults(scenarios),
+      preflight: preflightReport,
+      diffEnabled: shouldDiff,
+    });
+  }
+
   if (shouldExpandVariants) {
     const combinations = generateVariantCombinations(dimensions);
     
@@ -238,15 +509,17 @@ async function runCommand(options = {}) {
         process.exitCode = 1;
       }
 
-      if (!allSuccess) {
-        process.exitCode = 1;
-      }
+      const flattenedScenarioResults = allResults.flatMap(
+        (runResult) => runResult.results || [],
+      );
+      const persisted = persistRunManifest(allSuccess, flattenedScenarioResults);
+      console.log(chalk.gray(`\nRun manifest saved to: ${persisted.manifestPath}`));
 
       // Exit after variant expansion completes unless called programmatically
       if (!noExit) {
         process.exit(allSuccess ? 0 : 1);
       }
-      return { success: allSuccess, results: allResults };
+      return { success: allSuccess, results: allResults, runManifest: persisted.manifest };
     }
   }
 
@@ -263,11 +536,6 @@ async function runCommand(options = {}) {
   // ============================================
   // POST-PROCESSING: Local Version-to-Version Diffing
   // ============================================
-  const outputBaseDir = path.join(
-    process.cwd(),
-    docSyncConfig.assetDir || ".reshot/output"
-  );
-
   // ============================================
   // CLOUD BASELINE SYNC: Download approved baselines from platform
   // ============================================
@@ -464,6 +732,8 @@ async function runCommand(options = {}) {
   }
 
   console.log(chalk.gray(`\nOutput saved to: ${outputBaseDir}`));
+  const persisted = persistRunManifest(result.success, result.results || []);
+  console.log(chalk.gray(`Run manifest saved to: ${persisted.manifestPath}`));
 
   // Offer to open Studio for review (interactive TTY only, on success)
   if (result.success && process.stdin.isTTY && !noExit) {
@@ -481,7 +751,11 @@ async function runCommand(options = {}) {
       console.log(chalk.cyan("\n🎬 Launching Reshot Studio...\n"));
       const uiCommand = require("./ui");
       await uiCommand({ open: true });
-      return { success: result.success, results: result.results };
+      return {
+        success: result.success,
+        results: result.results,
+        runManifest: persisted.manifest,
+      };
     }
   }
 
@@ -490,7 +764,13 @@ async function runCommand(options = {}) {
     setImmediate(() => process.exit(process.exitCode || 0));
   }
 
-  return { success: result.success, results: result.results };
+  return {
+    success: result.success,
+    results: result.results,
+    runManifest: persisted.manifest,
+  };
 }
 
 module.exports = runCommand;
+module.exports.buildRunPreflightReport = buildRunPreflightReport;
+module.exports.probeBaseUrl = probeBaseUrl;