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

package/src/lib/release-doctor.js

@@ -0,0 +1,321 @@
+"use strict";
+
+const fs = require("fs-extra");
+const path = require("path");
+const config = require("./config");
+const { buildRunPreflightReport } = require("../commands/run");
+const { runDoctorTarget } = require("./certification");
+
+const REPORT_DIR = path.join(process.cwd(), ".reshot", "reports");
+const RELEASE_DOCTOR_REPORT_PATH = path.join(REPORT_DIR, "release-doctor.json");
+const DEFAULT_DOCS_ASSET_MAP_MAX_AGE_DAYS = 30;
+const RESHOT_CDN_ORIGIN = "https://cdn.reshot.dev/";
+
+function ensureReportDir() {
+  fs.ensureDirSync(REPORT_DIR);
+  return REPORT_DIR;
+}
+
+function parseScenarioKeys(value) {
+  if (!value) {
+    return null;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((entry) => String(entry || "").trim()).filter(Boolean);
+  }
+
+  return String(value)
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+}
+
+function resolveDocsAssetMapMaxAgeDays() {
+  const parsed = Number.parseInt(
+    process.env.RESHOT_DOCS_ASSET_MAP_MAX_AGE_DAYS || String(DEFAULT_DOCS_ASSET_MAP_MAX_AGE_DAYS),
+    10,
+  );
+
+  return Number.isFinite(parsed) && parsed >= 0
+    ? parsed
+    : DEFAULT_DOCS_ASSET_MAP_MAX_AGE_DAYS;
+}
+
+function createDocsHealth(options = {}) {
+  return {
+    checked: false,
+    skipped: false,
+    ok: false,
+    path: null,
+    exportedAt: null,
+    ageDays: null,
+    maxAgeDays: resolveDocsAssetMapMaxAgeDays(),
+    summary: {
+      visuals: 0,
+      assets: 0,
+      steps: 0,
+    },
+    issues: [],
+    ...options,
+  };
+}
+
+function createDocsIssueCollector(summary, issues, groupKey, visualKey, contextKey) {
+  return {
+    checkEntry(entry) {
+      summary.assets += 1;
+
+      if (!entry || typeof entry !== "object") {
+        issues.push(`Asset map entry \"${groupKey}/${visualKey}/${contextKey}\" is invalid.`);
+        return;
+      }
+
+      if (!entry.type) {
+        issues.push(`Asset map entry \"${groupKey}/${visualKey}/${contextKey}\" is missing type.`);
+      }
+
+      if (!entry.alt) {
+        issues.push(`Asset map entry \"${groupKey}/${visualKey}/${contextKey}\" is missing alt text.`);
+      }
+
+      if (entry.src && !String(entry.src).startsWith(RESHOT_CDN_ORIGIN)) {
+        issues.push(
+          `Asset map entry \"${groupKey}/${visualKey}/${contextKey}\" does not use a direct cdn.reshot.dev URL.`,
+        );
+      }
+
+      if (entry.poster && !String(entry.poster).startsWith(RESHOT_CDN_ORIGIN)) {
+        issues.push(
+          `Asset map poster \"${groupKey}/${visualKey}/${contextKey}\" does not use a direct cdn.reshot.dev URL.`,
+        );
+      }
+
+      for (const step of entry.steps || []) {
+        summary.steps += 1;
+        if (!step?.src || !String(step.src).startsWith(RESHOT_CDN_ORIGIN)) {
+          issues.push(
+            `Asset map step \"${groupKey}/${visualKey}/${contextKey}/${step?.step || "unknown"}\" does not use a direct cdn.reshot.dev URL.`,
+          );
+        }
+      }
+    },
+  };
+}
+
+function inspectDocsAssetMap(assetMap, options = {}) {
+  const maxAgeDays = Number.isFinite(options.maxAgeDays)
+    ? options.maxAgeDays
+    : resolveDocsAssetMapMaxAgeDays();
+  const now = options.now || new Date();
+  const issues = [];
+  const summary = {
+    visuals: 0,
+    assets: 0,
+    steps: 0,
+  };
+
+  if (!assetMap || typeof assetMap !== "object") {
+    return createDocsHealth({
+      checked: true,
+      ok: false,
+      maxAgeDays,
+      issues: ["Asset map is missing or invalid."],
+    });
+  }
+
+  const exportedAt = typeof assetMap.meta?.exportedAt === "string"
+    ? assetMap.meta.exportedAt
+    : null;
+  const exportedAtMs = exportedAt ? Date.parse(exportedAt) : Number.NaN;
+  let ageDays = null;
+
+  if (!assetMap.meta?.projectId) {
+    issues.push("Asset map meta.projectId is missing.");
+  }
+
+  if (!exportedAt || Number.isNaN(exportedAtMs)) {
+    issues.push("Asset map meta.exportedAt is missing or invalid.");
+  } else {
+    ageDays = Math.max(0, Math.floor((now.getTime() - exportedAtMs) / 86_400_000));
+    if (ageDays > maxAgeDays) {
+      issues.push(`Asset map is stale: exported ${ageDays} day(s) ago (max ${maxAgeDays}).`);
+    }
+  }
+
+  const groups = assetMap.assets && typeof assetMap.assets === "object"
+    ? Object.entries(assetMap.assets)
+    : [];
+  if (groups.length === 0) {
+    issues.push("Asset map has no assets.");
+  }
+
+  for (const [groupKey, visuals] of groups) {
+    if (!visuals || typeof visuals !== "object") {
+      issues.push(`Asset map group \"${groupKey}\" is invalid.`);
+      continue;
+    }
+
+    for (const [visualKey, contexts] of Object.entries(visuals)) {
+      summary.visuals += 1;
+
+      if (!contexts || typeof contexts !== "object") {
+        issues.push(`Asset map visual \"${groupKey}/${visualKey}\" is invalid.`);
+        continue;
+      }
+
+      for (const [contextKey, entry] of Object.entries(contexts)) {
+        createDocsIssueCollector(summary, issues, groupKey, visualKey, contextKey)
+          .checkEntry(entry);
+      }
+    }
+  }
+
+  if (
+    typeof assetMap.meta?.totalVisuals === "number" &&
+    assetMap.meta.totalVisuals !== summary.visuals
+  ) {
+    issues.push(`Asset map meta.totalVisuals=${assetMap.meta.totalVisuals} but counted ${summary.visuals}.`);
+  }
+
+  if (
+    typeof assetMap.meta?.totalAssets === "number" &&
+    assetMap.meta.totalAssets !== summary.assets
+  ) {
+    issues.push(`Asset map meta.totalAssets=${assetMap.meta.totalAssets} but counted ${summary.assets}.`);
+  }
+
+  if (
+    typeof assetMap.meta?.totalSteps === "number" &&
+    assetMap.meta.totalSteps !== summary.steps
+  ) {
+    issues.push(`Asset map meta.totalSteps=${assetMap.meta.totalSteps} but counted ${summary.steps}.`);
+  }
+
+  return createDocsHealth({
+    checked: true,
+    ok: issues.length === 0,
+    exportedAt,
+    ageDays,
+    maxAgeDays,
+    summary,
+    issues,
+  });
+}
+
+function resolveDocsAssetMapCandidates(cwd = process.cwd()) {
+  return [
+    path.join(cwd, "src", "data", "reshot-assets.json"),
+    path.join(cwd, "app", "src", "data", "reshot-assets.json"),
+  ];
+}
+
+function inspectDocsAssetMapFile(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const candidates = resolveDocsAssetMapCandidates(cwd);
+  const assetMapPath = candidates.find((candidate) => fs.existsSync(candidate));
+
+  if (!assetMapPath) {
+    return createDocsHealth({
+      checked: false,
+      skipped: true,
+      ok: true,
+      issues: ["No docs asset map found; skipping docs asset verification."],
+    });
+  }
+
+  try {
+    const assetMap = fs.readJsonSync(assetMapPath);
+    return {
+      ...inspectDocsAssetMap(assetMap, options),
+      path: assetMapPath,
+    };
+  } catch (error) {
+    return createDocsHealth({
+      checked: true,
+      ok: false,
+      path: assetMapPath,
+      issues: [`Failed to read docs asset map: ${error.message}`],
+    });
+  }
+}
+
+async function runReleaseDoctor(options = {}) {
+  ensureReportDir();
+  const scenarioKeys = parseScenarioKeys(options.scenarioKeys || options.scenarios);
+  const docSyncConfig = config.readConfig();
+  const preflight = await buildRunPreflightReport(docSyncConfig, { scenarioKeys });
+  const targetDoctor = docSyncConfig.target?.tier === "certified"
+    ? await runDoctorTarget({ scenarioKeys })
+    : {
+        skipped: true,
+        ok: true,
+        target: docSyncConfig.target,
+        summary: {
+          overallSeverity: "info",
+          blockingIssues: [],
+          advisories: [],
+          info: [{ message: "Target doctor skipped for non-certified target." }],
+        },
+      };
+  const docsAssetMap = inspectDocsAssetMapFile({ cwd: process.cwd() });
+
+  const blockingIssues = [];
+  const advisories = [];
+
+  for (const error of preflight.errors || []) {
+    blockingIssues.push({ scope: "run-preflight", message: error });
+  }
+  for (const warning of preflight.warnings || []) {
+    advisories.push({ scope: "run-preflight", message: warning });
+  }
+  for (const issue of targetDoctor.summary?.blockingIssues || []) {
+    blockingIssues.push({ scope: "target-doctor", ...issue });
+  }
+  for (const issue of targetDoctor.summary?.advisories || []) {
+    advisories.push({ scope: "target-doctor", ...issue });
+  }
+  // A stale/mismatched docs asset map (e.g. src/data/reshot-assets.json left
+  // behind by an earlier `reshot pull`) describes a generated artifact, not the
+  // config being published. It must NOT hard-block a publish of the current
+  // config — surface it as an advisory with a concrete remedy instead.
+  if (!docsAssetMap.skipped && !docsAssetMap.ok) {
+    const remedy =
+      docsAssetMap.path
+        ? `Re-run \`reshot pull\` to regenerate it, or delete ${docsAssetMap.path}.`
+        : "Re-run `reshot pull` to regenerate it, or delete the stale src/data/reshot-assets.json.";
+    for (const issue of docsAssetMap.issues) {
+      advisories.push({ scope: "docs-asset-map", message: `${issue} ${remedy}` });
+    }
+  }
+
+  const ok = preflight.ok && targetDoctor.ok;
+  const report = {
+    type: "ReleaseDoctorReport",
+    stage: "doctor-release",
+    generatedAt: new Date().toISOString(),
+    ok,
+    scenarioKeys: scenarioKeys || null,
+    target: docSyncConfig.target || null,
+    runPreflight: preflight,
+    targetDoctor,
+    docsAssetMap,
+    summary: {
+      blockingIssues,
+      advisories,
+    },
+  };
+
+  await fs.writeJson(RELEASE_DOCTOR_REPORT_PATH, report, { spaces: 2 });
+  report.reportPath = RELEASE_DOCTOR_REPORT_PATH;
+  return report;
+}
+
+module.exports = {
+  RELEASE_DOCTOR_REPORT_PATH,
+  parseScenarioKeys,
+  resolveDocsAssetMapCandidates,
+  inspectDocsAssetMap,
+  inspectDocsAssetMapFile,
+  runReleaseDoctor,
+};

package/src/lib/resolve-targets.js

@@ -0,0 +1,60 @@
+// resolve-targets.js - Resolve compose target coordinates from a Playwright page
+
+async function resolveTargets(page, targets = {}) {
+  const resolved = {};
+
+  for (const [name, config] of Object.entries(targets || {})) {
+    const target = normalizeTarget(config);
+
+    for (const step of target.navigate) {
+      if (step.clickText) {
+        await page.getByText(step.clickText, { exact: true }).first().click();
+      } else if (step.selector) {
+        await page.locator(step.selector).first().click();
+      }
+      if (step.waitMs) {
+        await page.waitForTimeout(step.waitMs);
+      }
+    }
+
+    const locator = page.locator(target.selector).first();
+    await locator.waitFor({ state: 'visible', timeout: target.timeoutMs });
+    const box = await locator.boundingBox();
+    if (!box) {
+      throw new Error(`Could not resolve target "${name}"`);
+    }
+
+    resolved[name] = {
+      x: Math.round(box.x),
+      y: Math.round(box.y),
+      w: Math.round(box.width),
+      h: Math.round(box.height),
+    };
+  }
+
+  return resolved;
+}
+
+function normalizeTarget(config) {
+  if (typeof config === 'string') {
+    return {
+      selector: config,
+      navigate: [],
+      timeoutMs: 10000,
+    };
+  }
+
+  if (!config || typeof config !== 'object' || !config.selector) {
+    throw new Error('Target config must be a selector string or an object with selector');
+  }
+
+  return {
+    selector: config.selector,
+    navigate: Array.isArray(config.navigate) ? config.navigate : [],
+    timeoutMs: config.timeoutMs || 10000,
+  };
+}
+
+module.exports = {
+  resolveTargets,
+};

package/src/lib/run-manifest.js

@@ -0,0 +1,148 @@
+"use strict";
+
+const fs = require("fs-extra");
+const path = require("path");
+
+const RUN_MANIFEST_DIR = path.join(
+  process.cwd(),
+  ".reshot",
+  "manifests",
+  "runs",
+);
+const LATEST_RUN_MANIFEST_PATH = path.join(RUN_MANIFEST_DIR, "run-latest.json");
+
+function ensureRunManifestDir() {
+  fs.ensureDirSync(RUN_MANIFEST_DIR);
+  return RUN_MANIFEST_DIR;
+}
+
+function normalizeScenarioResults(results = []) {
+  return results.map((result) => ({
+    key: result.key || result.scenario || null,
+    scenario: result.scenario || result.key || null,
+    success: result.success !== false,
+    timestamp: result.timestamp || null,
+    outputDir: result.outputDir || null,
+    variant: result.variant || null,
+    assetCount: Array.isArray(result.assets) ? result.assets.length : 0,
+  }));
+}
+
+function buildRunManifest(payload = {}) {
+  const generatedAt = payload.generatedAt || new Date().toISOString();
+  return {
+    type: "ReshotRunManifest",
+    runId: payload.runId || generatedAt.replace(/[:.]/g, "-"),
+    generatedAt,
+    success: payload.success !== false,
+    outputBaseDir: payload.outputBaseDir || null,
+    selectedScenarioKeys: payload.selectedScenarioKeys || [],
+    diffEnabled: Boolean(payload.diffEnabled),
+    scenarios: normalizeScenarioResults(payload.scenarios || []),
+    preflight: payload.preflight || null,
+  };
+}
+
+function writeRunManifest(payload = {}) {
+  const manifest = buildRunManifest(payload);
+  ensureRunManifestDir();
+  const manifestPath = path.join(RUN_MANIFEST_DIR, `run-${manifest.runId}.json`);
+  fs.writeJsonSync(manifestPath, manifest, { spaces: 2 });
+  fs.writeJsonSync(LATEST_RUN_MANIFEST_PATH, manifest, { spaces: 2 });
+  return { manifest, manifestPath, latestPath: LATEST_RUN_MANIFEST_PATH };
+}
+
+function readRunManifest(manifestPath) {
+  if (!manifestPath || !fs.existsSync(manifestPath)) {
+    return null;
+  }
+
+  return fs.readJsonSync(manifestPath);
+}
+
+function listRunManifestPaths() {
+  if (!fs.existsSync(RUN_MANIFEST_DIR)) {
+    return [];
+  }
+
+  return fs
+    .readdirSync(RUN_MANIFEST_DIR)
+    .filter(
+      (entry) =>
+        /^run-.*\.json$/.test(entry) && entry !== path.basename(LATEST_RUN_MANIFEST_PATH),
+    )
+    .map((entry) => path.join(RUN_MANIFEST_DIR, entry))
+    .sort((left, right) => right.localeCompare(left));
+}
+
+function getLatestSuccessfulRunManifest() {
+  const latest = readRunManifest(LATEST_RUN_MANIFEST_PATH);
+  if (latest?.success) {
+    return latest;
+  }
+
+  for (const manifestPath of listRunManifestPaths()) {
+    const manifest = readRunManifest(manifestPath);
+    if (manifest?.success) {
+      return manifest;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Returns the latest run manifest that has at least one successful scenario,
+ * even if the overall run was not fully successful. This prevents falling back
+ * to stale manifests when only some scenarios failed.
+ *
+ * Returns { manifest, isFallback, isPartialSuccess } where:
+ * - isFallback: true if the returned manifest is NOT the latest run
+ * - isPartialSuccess: true if the manifest has both succeeded and failed scenarios
+ */
+function getLatestUsableRunManifest() {
+  const latest = readRunManifest(LATEST_RUN_MANIFEST_PATH);
+
+  if (latest) {
+    const successfulScenarios = (latest.scenarios || []).filter(
+      (s) => s.success !== false,
+    );
+    if (successfulScenarios.length > 0) {
+      return {
+        manifest: latest,
+        isFallback: false,
+        isPartialSuccess: !latest.success,
+      };
+    }
+  }
+
+  // Latest has zero successful scenarios — search historical manifests
+  for (const manifestPath of listRunManifestPaths()) {
+    const manifest = readRunManifest(manifestPath);
+    if (!manifest) continue;
+    const successfulScenarios = (manifest.scenarios || []).filter(
+      (s) => s.success !== false,
+    );
+    if (successfulScenarios.length > 0) {
+      return {
+        manifest,
+        isFallback: true,
+        isPartialSuccess: !manifest.success,
+      };
+    }
+  }
+
+  return null;
+}
+
+module.exports = {
+  RUN_MANIFEST_DIR,
+  LATEST_RUN_MANIFEST_PATH,
+  buildRunManifest,
+  writeRunManifest,
+  readRunManifest,
+  listRunManifestPaths,
+  getLatestSuccessfulRunManifest,
+  getLatestUsableRunManifest,
+  normalizeScenarioResults,
+};

package/src/lib/standalone-mode.js

@@ -103,7 +103,7 @@ const DEFAULT_STANDALONE_SETTINGS = {
 };
 
 const SETTINGS_DIR = ".reshot";
-const CONFIG_PATH = "docsync.config.json";
+const CONFIG_PATH = "reshot.config.json";
 const SETTINGS_PATH = path.join(SETTINGS_DIR, "settings.json");
 
 /**

package/src/lib/storage-providers.js

@@ -114,7 +114,7 @@ ${chalk.cyan('AWS S3 Setup:')}
    ${chalk.gray('export AWS_SECRET_ACCESS_KEY="your-secret-access-key"')}
    ${chalk.gray('export AWS_REGION="us-east-1"  # optional, defaults to us-east-1')}
 
-3. ${chalk.yellow('Update docsync.config.json:')}
+3. ${chalk.yellow('Update reshot.config.json:')}
    ${chalk.gray(JSON.stringify({
      storage: {
        type: 's3',
@@ -143,7 +143,7 @@ ${chalk.cyan('Cloudflare R2 Setup:')}
    ${chalk.gray('export R2_ACCESS_KEY_ID="your-r2-access-key"')}
    ${chalk.gray('export R2_SECRET_ACCESS_KEY="your-r2-secret-key"')}
 
-3. ${chalk.yellow('Update docsync.config.json:')}
+3. ${chalk.yellow('Update reshot.config.json:')}
    ${chalk.gray(JSON.stringify({
      storage: {
        type: 'r2',
@@ -165,7 +165,7 @@ ${chalk.cyan('Local Storage Setup:')}
 
 For local testing or self-hosted scenarios:
 
-1. ${chalk.yellow('Update docsync.config.json:')}
+1. ${chalk.yellow('Update reshot.config.json:')}
    ${chalk.gray(JSON.stringify({
      storage: {
        type: 'local',
@@ -191,7 +191,7 @@ Use Reshot for full governance features (review queue, version control, etc.):
 1. ${chalk.yellow('Authenticate:')}
    ${chalk.gray('reshot auth')}
 
-2. ${chalk.yellow('Or set environment variable for CI/CD:')}
+2. ${chalk.yellow('Or set environment variable:')}
    ${chalk.gray('export RESHOT_API_KEY="your-api-key"')}
 
 3. ${chalk.yellow('Config (optional):')}
@@ -536,7 +536,7 @@ function createStorageProvider(config) {
 
 /**
  * Determine storage mode from config
- * @param {object} docSyncConfig - The docsync.config.json content
+ * @param {object} docSyncConfig - The reshot.config.json content
  * @returns {'platform'|'byos'}
  */
 function getStorageMode(docSyncConfig) {

package/src/lib/style-engine.js

@@ -16,10 +16,10 @@ try {
  * Default style configuration
  */
 const DEFAULT_STYLE_CONFIG = {
-  enabled: true,
+  enabled: false,
   frame: "none",
-  shadow: "medium",
-  padding: 40,
+  shadow: "none",
+  padding: 0,
   background: "transparent",
   borderRadius: 0,
 };
@@ -479,8 +479,8 @@ async function applyStyle(inputBuffer, styleConfig, logger, dpr = 1) {
 
   const {
     frame = "none",
-    shadow = "medium",
-    padding = 40,
+    shadow = "none",
+    padding = 0,
     background = "transparent",
     borderRadius = 0,
   } = styleConfig;