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

package/src/commands/capture-dom.js

@@ -0,0 +1,50 @@
+// capture-dom.js - Capture a self-contained DOM reconstruction artifact from a
+// live URL (Tier-3 Phase 2). Emits <slug>.dom.html (+ sidecars), remounted.png,
+// and live.png so the calibrated quality gate can diff them:
+//
+//   reshot capture-dom <url> --out /tmp/cap
+//   pnpm --dir packages/compose verify diff /tmp/cap/remounted.png /tmp/cap/live.png
+
+const chalk = require("chalk");
+const path = require("path");
+const { captureDomFromUrl } = require("../lib/dom-capture");
+
+function registerCaptureDom(program) {
+  program
+    .command("capture-dom <url>")
+    .description("Capture a self-contained DOM reconstruction artifact from a live URL")
+    .option("-o, --out <dir>", "Output directory", "./.reshot/capture-dom")
+    .option("-s, --slug <slug>", "Artifact slug", "capture")
+    .option("--width <px>", "Viewport width", (v) => parseInt(v, 10))
+    .option("--height <px>", "Viewport height", (v) => parseInt(v, 10))
+    .option("--dpr <n>", "Device scale factor", (v) => parseInt(v, 10))
+    .action(async (url, options) => {
+      const outDir = path.resolve(options.out);
+      const settings =
+        options.width || options.height || options.dpr
+          ? {
+              width: options.width || 1000,
+              height: options.height || 800,
+              deviceScaleFactor: options.dpr || 2,
+            }
+          : undefined;
+
+      console.log(chalk.cyan(`\n  Capturing DOM from ${url} ...\n`));
+      const result = await captureDomFromUrl({ url, outDir, slug: options.slug, settings });
+
+      console.log(chalk.green(`  ✔ method: ${result.method}`));
+      console.log(`  artifact:  ${result.artifact}`);
+      console.log(`  remounted: ${result.remounted}`);
+      console.log(`  live:      ${result.live}`);
+      if (result.sidecars.length) {
+        console.log(`  sidecars:  ${result.sidecars.map((s) => `${s.kind}(rasterized=${s.rasterized})`).join(", ")}`);
+      }
+      console.log(
+        chalk.gray(
+          `\n  Verify: pnpm --dir packages/compose verify diff ${result.remounted} ${result.live}\n`,
+        ),
+      );
+    });
+}
+
+module.exports = { registerCaptureDom };

package/src/commands/certify.js

@@ -0,0 +1,62 @@
+"use strict";
+
+const chalk = require("chalk");
+const { runCertification } = require("../lib/certification");
+
+async function certifyCommand(options = {}) {
+  const scenarioKeys = options.scenarios
+    ? String(options.scenarios)
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean)
+    : null;
+
+  const report = await runCertification({
+    scenarioKeys,
+    tag: options.tag,
+    message: options.message,
+    skipReleaseDoctor: options.skipReleaseDoctor,
+  });
+
+  if (options.json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(chalk.cyan("\n🏅 Certified Target Verification\n"));
+    console.log(chalk.gray(`Target: ${report.target.displayName}`));
+    console.log(
+      report.ok
+        ? chalk.green(`  ✔ Final status: ${report.finalStatus}`)
+        : chalk.red(`  ✖ Final status: ${report.finalStatus}`),
+    );
+    console.log(
+      report.releaseDoctor?.skipped
+        ? chalk.gray("  • Release doctor skipped")
+        : report.releaseDoctor?.ok
+          ? chalk.green("  ✔ Release doctor passed")
+          : chalk.red("  ✖ Release doctor failed"),
+    );
+    console.log(
+      report.doctor.ok
+        ? chalk.green("  ✔ Doctor passed")
+        : chalk.red("  ✖ Doctor failed"),
+    );
+    console.log(
+      report.capture.success
+        ? chalk.green("  ✔ Capture passed")
+        : chalk.red("  ✖ Capture failed"),
+    );
+    console.log(
+      report.publishVerification.ok
+        ? chalk.green("  ✔ Publish verification passed")
+        : chalk.red("  ✖ Publish verification failed"),
+    );
+  }
+
+  if (!report.ok) {
+    process.exitCode = 1;
+  }
+
+  return report;
+}
+
+module.exports = certifyCommand;

package/src/commands/compose.js

@@ -0,0 +1,220 @@
+// compose.js - Render a local @reshot/compose file into a video pack
+const path = require("path");
+const fs = require("fs-extra");
+const chalk = require("chalk");
+const { composeDistDir } = require("../lib/compose-runtime");
+const {
+  DEFAULT_FORMATS,
+  assertCaptureExists,
+  deriveSlug,
+  parseFormats,
+  parseSize,
+  resolveCapturePath,
+  resolveComposeContext,
+  resolveMetadataPath,
+  resolveOutBase,
+} = require("../lib/compose-context");
+const {
+  assertUploadPackExists,
+  packFromExistingOutputs,
+} = require("../lib/compose-pack");
+const {
+  buildDashboardUrl,
+  getComposeApiBaseUrl,
+  humanizeName,
+  resolveComposeProjectContext,
+  uploadComposition,
+} = require("../lib/compose-upload");
+
+async function runCompose(file, options = {}, deps = {}) {
+  const context = await resolveComposeContext(file, options);
+
+  const size = parseSize(options.size || "1440x900");
+  const formats = parseFormats(options.formats, options.gif);
+  const outBase = resolveOutBase(context.compositionPath, options.out);
+
+  const { render } = deps.renderModule || loadComposeRender();
+
+  console.log(chalk.cyan(`\n-> Rendering ${chalk.bold(context.slug)} (${size.width}x${size.height})`));
+  console.log(chalk.gray(`  composition ${relativePath(context.compositionPath)}`));
+  console.log(chalk.gray(`  metadata    ${relativePath(context.metadataPath)}`));
+  console.log(chalk.gray(`  capture     ${relativePath(context.capturePath)}`));
+  console.log(chalk.gray(`  out         ${relativePath(outBase)}`));
+
+  const result = await withComposeEnvironment(
+    {
+      RESHOT_COMPOSE_SLUG: context.slug,
+      RESHOT_COMPOSE_METADATA_PATH: context.metadataPath,
+      RESHOT_COMPOSE_CAPTURE_PATH: context.capturePath,
+    },
+    () =>
+      render(context.compositionPath, {
+        slug: context.slug,
+        out: outBase,
+        size,
+        formats,
+        metadataPath: context.metadataPath,
+        capturePath: context.capturePath,
+      }),
+  );
+
+  console.log(chalk.green(`\nRendered ${context.slug}`));
+  printPack(result.pack || {});
+  return result;
+}
+
+async function runComposePush(file, options = {}, deps = {}) {
+  const context = await resolveComposeContext(file, options);
+  const outBase = resolveOutBase(context.compositionPath, options.out);
+  const pack = options.skipRender
+    ? await packFromExistingOutputs(outBase)
+    : (await runCompose(file, options, deps)).pack || {};
+
+  await assertUploadPackExists(pack, Boolean(options.skipRender));
+
+  const projectContext = resolveComposeProjectContext({
+    projectOption: options.project,
+    settings: deps.settings,
+  });
+  const apiBaseUrl = getComposeApiBaseUrl(deps.apiBaseUrl);
+  const name = options.name || humanizeName(context.slug);
+  const upload = deps.uploadComposition || uploadComposition;
+
+  console.log(chalk.cyan(`\n-> Uploading ${chalk.bold(name)} to project ${projectContext.projectId}`));
+  const response = await upload({
+    apiBaseUrl,
+    apiKey: projectContext.apiKey,
+    projectId: projectContext.projectId,
+    name,
+    slug: context.slug,
+    sourceTsx: await fs.readFile(context.compositionPath, "utf8"),
+    metadataJson: await fs.readFile(context.metadataPath, "utf8"),
+    pack,
+    autoApprove: Boolean(options.autoApprove),
+    httpClient: deps.httpClient,
+  });
+  const dashboardUrl = buildDashboardUrl(response, apiBaseUrl, projectContext.projectId);
+
+  console.log(chalk.green(`\nUploaded ${context.slug}`));
+  console.log(chalk.gray(`  Dashboard: ${dashboardUrl}`));
+  printPublicUrls(response?.publicUrls);
+  if (response?.attributionWarning === "legacy-key-no-user-attribution") {
+    console.log(
+      chalk.yellow(
+        "  Attribution: re-issue your API key to enable per-engineer render attribution.",
+      ),
+    );
+  }
+
+  return { response, dashboardUrl, projectId: projectContext.projectId };
+}
+
+function registerCompose(program) {
+  const compose = program
+    .command("compose")
+    .description("Render and upload local JSX compositions")
+    .argument("<file>", "Composition file to render")
+    .option("--slug <slug>", "Matrix variant slug; defaults to the composition filename")
+    .option("--out <path>", "Output base path; defaults to <file-stem>.composed")
+    .option("--size <size>", "Viewport size as WIDTHxHEIGHT", "1440x900")
+    .option("--formats <formats>", "Comma-separated output formats", DEFAULT_FORMATS.join(","))
+    .option("--gif", "Also emit a gif")
+    .action(async (file, options) => {
+      try {
+        await runCompose(file, normalizeCommandOptions(options));
+      } catch (error) {
+        console.error(chalk.red("Error:"), error.message);
+        process.exit(1);
+      }
+    });
+
+  compose
+    .command("push <file>")
+    .description("Render and upload a local JSX composition to the dashboard")
+    .option("--name <name>", "Composition display name")
+    .option("--project <projectId>", "Project id; defaults to local Reshot settings")
+    .option("--out <path>", "Output base path to upload when --skip-render is used")
+    .option("--skip-render", "Upload existing local outputs without re-rendering")
+    .option("--auto-approve", "Immediately approve this composition render and update live embed URLs")
+    .action(async (file, options) => {
+      try {
+        await runComposePush(file, normalizeCommandOptions(options));
+      } catch (error) {
+        console.error(chalk.red("Error:"), error.message);
+        process.exit(1);
+      }
+    });
+}
+
+function normalizeCommandOptions(options) {
+  return typeof options?.opts === "function" ? options.opts() : options || {};
+}
+
+function loadComposeRender() {
+  return require(path.join(composeDistDir(), "render.cjs"));
+}
+
+async function withComposeEnvironment(env, callback) {
+  const previous = {};
+  for (const [key, value] of Object.entries(env)) {
+    previous[key] = process.env[key];
+    process.env[key] = value;
+  }
+
+  try {
+    return await callback();
+  } finally {
+    for (const [key, value] of Object.entries(previous)) {
+      if (value === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  }
+}
+
+function printPack(pack) {
+  for (const format of ["mp4", "webm", "poster", "gif"]) {
+    if (pack[format]) {
+      console.log(chalk.gray(`  ${format.padEnd(6)} ${relativePath(pack[format])}`));
+    }
+  }
+}
+
+function printPublicUrls(publicUrls) {
+  if (!publicUrls || typeof publicUrls !== "object") return;
+  if (publicUrls.embed) {
+    console.log(chalk.gray(`  Live embed: ${publicUrls.embed}`));
+  }
+  if (publicUrls.live?.mp4) {
+    console.log(chalk.gray(`  Live MP4:   ${publicUrls.live.mp4}`));
+  }
+  if (publicUrls.pinned?.mp4) {
+    console.log(chalk.gray(`  Pinned MP4: ${publicUrls.pinned.mp4}`));
+  }
+}
+
+function relativePath(filePath) {
+  const relative = path.relative(process.cwd(), filePath);
+  return relative && !relative.startsWith("..") ? relative : filePath;
+}
+
+module.exports = {
+  DEFAULT_FORMATS,
+  assertCaptureExists,
+  deriveSlug,
+  normalizeCommandOptions,
+  parseFormats,
+  parseSize,
+  printPublicUrls,
+  registerCompose,
+  resolveComposeContext,
+  resolveComposeProjectContext,
+  resolveCapturePath,
+  resolveMetadataPath,
+  resolveOutBase,
+  runCompose,
+  runComposePush,
+  uploadComposition,
+};

package/src/commands/doctor-release.js

@@ -0,0 +1,74 @@
+"use strict";
+
+const chalk = require("chalk");
+const { runReleaseDoctor } = require("../lib/release-doctor");
+
+async function doctorReleaseCommand(options = {}) {
+  const report = await runReleaseDoctor(options);
+
+  if (options.json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(chalk.cyan("\n🧪 Release Doctor\n"));
+    console.log(
+      report.ok
+        ? chalk.green("  ✔ Release gate checks passed")
+        : chalk.red("  ✖ Release gate checks failed"),
+    );
+
+    console.log(
+      report.runPreflight.ok
+        ? chalk.green("  ✔ Run preflight healthy")
+        : chalk.red("  ✖ Run preflight failed"),
+    );
+
+    if (report.targetDoctor.skipped) {
+      console.log(chalk.gray("  • Target doctor skipped (non-certified target)"));
+    } else {
+      console.log(
+        report.targetDoctor.ok
+          ? chalk.green("  ✔ Target doctor healthy")
+          : chalk.red("  ✖ Target doctor failed"),
+      );
+    }
+
+    if (report.docsAssetMap.skipped) {
+      console.log(chalk.gray("  • Docs asset map skipped"));
+    } else {
+      console.log(
+        report.docsAssetMap.ok
+          ? chalk.green("  ✔ Docs asset map healthy")
+          : chalk.red("  ✖ Docs asset map failed"),
+      );
+      if (report.docsAssetMap.path) {
+        console.log(chalk.gray(`    ${report.docsAssetMap.path}`));
+      }
+    }
+
+    const blockingIssues = report.summary?.blockingIssues || [];
+    if (blockingIssues.length > 0) {
+      for (const issue of blockingIssues.slice(0, 10)) {
+        console.log(chalk.red(`  ✖ ${issue.scope}: ${issue.message}`));
+      }
+    }
+
+    const advisories = report.summary?.advisories || [];
+    if (advisories.length > 0) {
+      for (const advisory of advisories.slice(0, 10)) {
+        console.log(chalk.yellow(`  ⚠ ${advisory.scope}: ${advisory.message}`));
+      }
+    }
+
+    if (report.reportPath) {
+      console.log(chalk.gray(`\n  Report: ${report.reportPath}`));
+    }
+  }
+
+  if (!report.ok) {
+    process.exitCode = 1;
+  }
+
+  return report;
+}
+
+module.exports = doctorReleaseCommand;

package/src/commands/doctor-target.js

@@ -0,0 +1,108 @@
+"use strict";
+
+const chalk = require("chalk");
+const { runDoctorTarget } = require("../lib/certification");
+const config = require("../lib/config");
+
+async function doctorTargetCommand(options = {}) {
+  const scenarioKeys = options.scenarios
+    ? String(options.scenarios)
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean)
+    : null;
+
+  // Check for a config BEFORE the banner so we don't print "scenarios: all
+  // certified" immediately above a "Config file not found" error (audit run-11
+  // F5). Without a config there is nothing to certify.
+  let hasConfig = false;
+  try {
+    hasConfig = config.configExists();
+  } catch {
+    hasConfig = false;
+  }
+  if (!hasConfig) {
+    if (options.json) {
+      console.log(
+        JSON.stringify({ ok: false, error: "Config file not found" }, null, 2),
+      );
+    } else {
+      console.error(
+        chalk.red("\n  ✖ Target doctor aborted: Config file not found."),
+      );
+      console.error(
+        chalk.gray("  Run `reshot init` (or `reshot setup`) to create one."),
+      );
+    }
+    process.exitCode = 1;
+    return { ok: false, error: "Config file not found" };
+  }
+
+  // Emit an immediate banner BEFORE any async work so the command is never
+  // silent — previously it produced zero output while preparing fixtures and
+  // launching a browser, which read as a hang.
+  if (!options.json) {
+    console.log(chalk.cyan("🩺 Running target doctor…"));
+    console.log(
+      chalk.gray(
+        scenarioKeys
+          ? `  scenarios: ${scenarioKeys.join(", ")}`
+          : "  scenarios: all certified",
+      ),
+    );
+  }
+
+  const progressLogger = options.json
+    ? null
+    : (message) => console.log(chalk.gray(`  → ${message}`));
+
+  let report;
+  try {
+    report = await runDoctorTarget({
+      scenarioKeys,
+      onProgress: progressLogger,
+      timeoutMs: options.timeout ? Number(options.timeout) : undefined,
+    });
+  } catch (error) {
+    // Fail fast with an actionable message + report path rather than hanging.
+    if (!options.json) {
+      console.error(chalk.red(`\n  ✖ Target doctor aborted: ${error.message}`));
+      console.error(
+        chalk.gray(
+          "  Confirm the dev server is reachable and the target is configured (see .reshot/reports).",
+        ),
+      );
+    } else {
+      console.log(JSON.stringify({ ok: false, error: error.message }, null, 2));
+    }
+    process.exitCode = 1;
+    return { ok: false, error: error.message };
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(chalk.cyan("\n🩺 Certified Target Doctor\n"));
+    console.log(chalk.gray(`Target: ${report.target.displayName} (${report.target.tier})`));
+    console.log(
+      report.ok
+        ? chalk.green("  ✔ Target contract is healthy")
+        : chalk.red("  ✖ Target contract check failed"),
+    );
+    for (const audit of report.readinessAudits) {
+      console.log(
+        audit.ok
+          ? chalk.green(`  ✔ ${audit.scenario}`)
+          : chalk.red(`  ✖ ${audit.scenario}${audit.contractFailure ? ` — ${audit.contractFailure}` : ""}`),
+      );
+    }
+  }
+
+  if (!report.ok) {
+    process.exitCode = 1;
+  }
+
+  return report;
+}
+
+module.exports = doctorTargetCommand;

package/src/commands/drifts.js

@@ -12,7 +12,7 @@
  * - reshot drifts sync <id>     Mark as manually synced (external_host)
  * - reshot drifts approve-all   Approve all pending drifts
  * - reshot drifts reject-all    Reject all pending drifts
- * - reshot drifts validate      Validate journey bindings against visual inventory
+ * - reshot drifts approve-all   Approve all pending drifts
  */
 
 const chalk = require("chalk");
@@ -234,7 +234,7 @@ async function batchDriftAction(apiKey, projectId, action, options = {}) {
 
   try {
     // Fetch all pending drifts
-    const response = await apiClient.getDrifts(apiKey, projectId, { status: "PENDING" });
+    const response = await apiClient.getDrifts(apiKey, projectId, { status: "pending" });
     const drifts = response.drifts || [];
 
     if (drifts.length === 0) {
@@ -268,66 +268,18 @@ async function batchDriftAction(apiKey, projectId, action, options = {}) {
       console.log(chalk.red(`  ${failed} drift(s) failed`));
     }
   } catch (error) {
-    console.error(chalk.red("Error:"), error.message);
-    process.exit(1);
-  }
-}
-
-/**
- * Validate journey bindings against visual inventory
- */
-async function validateBindings(apiKey, projectId, options = {}) {
-  console.log(chalk.blue("\n🔍 Validating Journey Bindings\n"));
-
-  try {
-    // Fetch visual keys from server
-    const visualKeys = await apiClient.getVisualKeys(projectId, apiKey);
-    console.log(chalk.green(`  ✓ Fetched ${visualKeys.size} visual keys from project`));
-
-    // Read docsync config
-    const docSyncConfig = config.readDocSyncConfig();
-    const docConfig = docSyncConfig.documentation;
-
-    if (!docConfig || !docConfig.root) {
-      console.log(chalk.yellow("  ⚠ No documentation.root configured"));
+    const status = error.reshot?.status ?? error.response?.status;
+    if (status === 400 || status === 404) {
+      console.log(chalk.green("  ✓ No pending drifts to approve."));
+      console.log(
+        chalk.gray(
+          "    Drifts only exist when a capture differs from a baseline. New captures\n" +
+          "    with no prior version go to the review queue — use `reshot publish\n" +
+          "    --auto-approve` or approve them in the studio."
+        )
+      );
       return;
     }
-
-    // Use the validate-docs module for full validation
-    const validateDocs = require("./validate-docs");
-    const result = await validateDocs.validateDocSync({
-      strict: options.strict,
-      verbose: options.verbose,
-    });
-
-    // Additional server-side validation: check if any journey keys in the project
-    // are not bound to any documentation
-    const mappings = docConfig.mappings || {};
-    const boundKeys = new Set(Object.values(mappings));
-
-    const orphanedVisuals = [];
-    for (const key of visualKeys) {
-      if (!boundKeys.has(key)) {
-        orphanedVisuals.push(key);
-      }
-    }
-
-    if (orphanedVisuals.length > 0) {
-      console.log(chalk.yellow(`\n  ⚠ ${orphanedVisuals.length} visual(s) not bound to documentation:`));
-      if (options.verbose) {
-        orphanedVisuals.slice(0, 10).forEach((key) => {
-          console.log(chalk.gray(`      - ${key}`));
-        });
-        if (orphanedVisuals.length > 10) {
-          console.log(chalk.gray(`      ... and ${orphanedVisuals.length - 10} more`));
-        }
-      }
-    }
-
-    if (!result.valid) {
-      process.exit(1);
-    }
-  } catch (error) {
     console.error(chalk.red("Error:"), error.message);
     process.exit(1);
   }
@@ -338,11 +290,11 @@ async function validateBindings(apiKey, projectId, options = {}) {
  */
 async function driftsCommand(subcommand, args = [], options = {}) {
   // Read configuration
-  let docSyncConfig;
+  let reshotConfig;
   try {
-    docSyncConfig = config.readDocSyncConfig();
+    reshotConfig = config.readConfigLenient();
   } catch (error) {
-    console.error(chalk.red("Error:"), "docsync.config.json not found. Run `reshot init` first.");
+    console.error(chalk.red("Error:"), "reshot.config.json not found. Run `reshot init` first.");
     process.exit(1);
   }
 
@@ -352,7 +304,7 @@ async function driftsCommand(subcommand, args = [], options = {}) {
   const projectId =
     process.env.RESHOT_PROJECT_ID ||
     settings?.projectId ||
-    docSyncConfig._metadata?.projectId;
+    reshotConfig._metadata?.projectId;
 
   if (!apiKey) {
     console.error(chalk.red("Error:"), "API key not found. Set RESHOT_API_KEY or run `reshot auth`.");
@@ -398,10 +350,6 @@ async function driftsCommand(subcommand, args = [], options = {}) {
       await batchDriftAction(apiKey, projectId, "reject", options);
       break;
 
-    case "validate":
-      await validateBindings(apiKey, projectId, options);
-      break;
-
     default:
       console.error(chalk.red("Error:"), `Unknown subcommand: ${subcommand}`);
       console.log(chalk.gray("\nAvailable subcommands:"));
@@ -413,7 +361,6 @@ async function driftsCommand(subcommand, args = [], options = {}) {
       console.log(chalk.white("  sync        ") + chalk.gray("Mark as manually synced"));
       console.log(chalk.white("  approve-all ") + chalk.gray("Approve all pending drifts"));
       console.log(chalk.white("  reject-all  ") + chalk.gray("Reject all pending drifts"));
-      console.log(chalk.white("  validate    ") + chalk.gray("Validate journey bindings"));
       process.exit(1);
   }