@reshotdev/screenshot 0.0.1-beta.7 → 0.0.1-beta.9

package/src/commands/setup.js

@@ -2,6 +2,7 @@
 const chalk = require("chalk");
 const oraModule = require("ora");
 const ora = oraModule.default || oraModule;
+const { execSync } = require("child_process");
 
 const {
   writeSettings,
@@ -100,10 +101,14 @@ async function setupCommand(options = {}) {
   if (hasConfig && !force) {
     console.log(chalk.green("✔ Configuration found:"), chalk.cyan("reshot.config.json"));
   } else if (hasConfig && force) {
-    console.log(chalk.yellow("⚠ Overwriting existing reshot.config.json..."));
-    const newConfig = createDefaultConfig(existingSettings);
-    writeConfig(newConfig);
-    console.log(chalk.green("✔ Configuration updated"));
+    // Patch projectId in existing config instead of wiping scenarios
+    const fs = require("fs");
+    const path = require("path");
+    const configPath = path.join(process.cwd(), "reshot.config.json");
+    const existingConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+    existingConfig.projectId = existingSettings.projectId;
+    fs.writeFileSync(configPath, JSON.stringify(existingConfig, null, 2) + "\n");
+    console.log(chalk.green("✔ Configuration updated (projectId synced)"));
   } else {
     // No config - create it
     console.log(chalk.gray("Creating reshot.config.json..."));
@@ -112,6 +117,29 @@ async function setupCommand(options = {}) {
     console.log(chalk.green("✔ Configuration created:"), chalk.cyan("reshot.config.json"));
   }
 
+  // Step 3.5: Ensure @reshotdev/screenshot is in devDependencies
+  const fs = require("fs");
+  const path = require("path");
+  const pkgJsonPath = path.join(process.cwd(), "package.json");
+  if (fs.existsSync(pkgJsonPath)) {
+    const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+    const hasDep =
+      pkgJson.devDependencies?.["@reshotdev/screenshot"] ||
+      pkgJson.dependencies?.["@reshotdev/screenshot"];
+    if (!hasDep) {
+      console.log(chalk.gray("  Adding @reshotdev/screenshot to devDependencies..."));
+      const usePnpm = fs.existsSync(path.join(process.cwd(), "pnpm-lock.yaml"));
+      const useYarn = fs.existsSync(path.join(process.cwd(), "yarn.lock"));
+      const cmd = usePnpm ? "pnpm add -D" : useYarn ? "yarn add -D" : "npm install -D";
+      try {
+        execSync(`${cmd} @reshotdev/screenshot`, { stdio: "inherit" });
+        console.log(chalk.green("  ✔ Added @reshotdev/screenshot to devDependencies"));
+      } catch {
+        console.log(chalk.yellow("  ⚠ Could not auto-install. Run manually: " + cmd + " @reshotdev/screenshot"));
+      }
+    }
+  }
+
   // Step 4: Success summary
   console.log(chalk.green("\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"));
   console.log(chalk.green.bold("✔ Project initialized successfully!"));
@@ -128,9 +156,9 @@ async function setupCommand(options = {}) {
     await uiCommand({ open: true });
   } else {
     console.log(chalk.gray("Next steps:"));
-    console.log(chalk.gray("  • Run"), chalk.cyan("reshot studio"), chalk.gray("to open the management UI"));
-    console.log(chalk.gray("  • Run"), chalk.cyan("reshot record"), chalk.gray("to capture your first visual"));
-    console.log(chalk.gray("  • Run"), chalk.cyan("reshot run"), chalk.gray("to execute scenarios\n"));
+    console.log(chalk.gray("  • Run"), chalk.cyan("reshot run"), chalk.gray("to generate your first local capture"));
+    console.log(chalk.gray("  • Run"), chalk.cyan("reshot publish"), chalk.gray("when you are ready for hosted assets and review workflows"));
+    console.log(chalk.gray("  • Run"), chalk.cyan("reshot studio"), chalk.gray("to inspect output locally\n"));
   }
 }
 

package/src/commands/verify-publish.js

@@ -0,0 +1,46 @@
+"use strict";
+
+const chalk = require("chalk");
+const { runVerifyPublish } = require("../lib/certification");
+
+async function verifyPublishCommand(options = {}) {
+  const scenarioKeys = options.scenarios
+    ? String(options.scenarios)
+        .split(",")
+        .map((value) => value.trim())
+        .filter(Boolean)
+    : null;
+
+  const report = await runVerifyPublish({
+    scenarioKeys,
+    tag: options.tag,
+    message: options.message,
+  });
+
+  if (options.json) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(chalk.cyan("\n📦 Publish Verification\n"));
+    console.log(
+      report.ok
+        ? chalk.green("  ✔ Publish, pull, and hosted delivery verified")
+        : chalk.red("  ✖ Publish verification failed"),
+    );
+    console.log(chalk.gray(`  Published: ${report.publishResult.assetsProcessed || 0}`));
+    console.log(chalk.gray(`  Pull repairs: ${report.pullResult.normalizationRepairs || 0}`));
+    const failedChecks = (report.deliveryChecks || []).filter((check) => !check.ok);
+    if (failedChecks.length > 0) {
+      for (const check of failedChecks.slice(0, 10)) {
+        console.log(chalk.red(`  ✖ ${check.scenario}/${check.assetKey}: ${check.reason}`));
+      }
+    }
+  }
+
+  if (!report.ok) {
+    process.exitCode = 1;
+  }
+
+  return report;
+}
+
+module.exports = verifyPublishCommand;

package/src/index.js

@@ -153,19 +153,96 @@ program
     }
   });
 
+// Capture: Compatibility alias for older docs and snippets
+program
+  .command("capture")
+  .description("Compatibility alias for `reshot run` (prefer `reshot run` and `reshot publish`)")
+  .option("-s, --scenarios <keys>", "Comma-separated list of scenario keys")
+  .option("--mode <mode>", "Compatibility mode: preview | publish", "preview")
+  .option("--config <path>", "Compatibility config path (defaults to reshot.config.json)")
+  .option("--base-url <url>", "Temporary base URL override for compatibility flows")
+  .option("--tag <tag>", "Version tag when mode=publish")
+  .option("-m, --message <message>", "Publish message when mode=publish")
+  .option("--no-headless", "Run browser in visible mode")
+  .option("-c, --concurrency <n>", "Number of parallel browser workers", parseInt)
+  .option("--debug", "Enable verbose debug logging")
+  .action(async (options) => {
+    if (options.debug) {
+      process.env.RESHOT_DEBUG = "1";
+    }
+    if (options.config && options.config !== "reshot.config.json") {
+      console.log(
+        chalk.yellow(
+          "Compatibility mode currently uses reshot.config.json from the working directory.",
+        ),
+      );
+    }
+    if (options.baseUrl) {
+      process.env.RESHOT_BASE_URL = options.baseUrl;
+      console.log(
+        chalk.gray(
+          `Using temporary base URL override for this run: ${options.baseUrl}`,
+        ),
+      );
+    }
+    try {
+      const runCommand = require("./commands/run");
+      const scenarioKeys = options.scenarios
+        ? options.scenarios.split(",").map((s) => s.trim())
+        : null;
+      await runCommand({
+        scenarioKeys,
+        headless: options.headless,
+        concurrency: options.concurrency,
+      });
+
+      if (String(options.mode || "preview").toLowerCase() === "publish") {
+        const publishCommand = require("./commands/publish");
+        await publishCommand({
+          tag: options.tag,
+          message: options.message,
+        });
+      }
+    } catch (error) {
+      console.error(chalk.red("Error:"), error.message);
+      if (options.debug && error.stack) {
+        console.error(chalk.gray(error.stack));
+      }
+      process.exit(1);
+    }
+  });
+
 // Record: Interactive visual recording from live browser
 program
   .command("record [title]")
   .description("Interactively record visuals from a live browser session")
+  .option("--name <title>", "Compatibility alias for the scenario title")
   .option("--browser", "Launch Chrome with remote debugging before recording")
   .option("-p, --port <port>", "Chrome debugging port (default: 9222)")
   .option("--url <url>", "URL to open when launching browser")
+  .option("--refresh-session", "Only refresh the auth session (no recording prompts)")
   .option("--debug", "Enable verbose debug logging")
   .action(async (title, options) => {
     if (options.debug) {
       process.env.RESHOT_DEBUG = "1";
     }
+    const resolvedTitle = title || options.name;
     try {
+      // If --refresh-session, just sync the session and exit
+      if (options.refreshSession) {
+        const { autoSyncSessionFromCDP, getDefaultSessionPath } = require("./lib/record-cdp");
+        const sessionPath = getDefaultSessionPath();
+        console.log(chalk.gray("  Syncing session from active browser..."));
+        const result = await autoSyncSessionFromCDP(sessionPath);
+        if (result.synced) {
+          console.log(chalk.green("  ✔ Session refreshed at " + sessionPath));
+        } else {
+          console.log(chalk.yellow("  ⚠ No active CDP browser found. Launch Chrome with remote debugging first:"));
+          console.log(chalk.gray("    reshot record --browser --refresh-session"));
+        }
+        return;
+      }
+
       // If --browser flag, launch Chrome first
       if (options.browser) {
         const chromeCommand = require("./commands/chrome");
@@ -178,7 +255,7 @@ program
       }
 
       const recordCommand = require("./commands/record");
-      await recordCommand(title);
+      await recordCommand(resolvedTitle);
     } catch (error) {
       console.error(chalk.red("Error:"), error.message);
       if (options.debug && error.stack) {
@@ -259,6 +336,62 @@ program
     }
   });
 
+// Doctor: Validate target contract and readiness
+const doctor = program.command("doctor").description("Validate target configuration and readiness");
+
+doctor
+  .command("target")
+  .description("Audit the certified target contract before capture")
+  .option("-s, --scenarios <keys>", "Comma-separated list of scenario keys")
+  .option("--json", "Output JSON report")
+  .action(async (options) => {
+    try {
+      const doctorTargetCommand = require("./commands/doctor-target");
+      await doctorTargetCommand(options);
+    } catch (error) {
+      console.error(chalk.red("Error:"), error.message);
+      process.exit(1);
+    }
+  });
+
+// Verify: Publish/pull/hosted delivery verification
+const verify = program.command("verify").description("Verify publish and delivery flows");
+
+verify
+  .command("publish")
+  .description("Verify publish, pull, and hosted asset delivery")
+  .option("-s, --scenarios <keys>", "Comma-separated list of scenario keys")
+  .option("--tag <tag>", "Version tag for verification publish")
+  .option("-m, --message <message>", "Publish message override")
+  .option("--json", "Output JSON report")
+  .action(async (options) => {
+    try {
+      const verifyPublishCommand = require("./commands/verify-publish");
+      await verifyPublishCommand(options);
+    } catch (error) {
+      console.error(chalk.red("Error:"), error.message);
+      process.exit(1);
+    }
+  });
+
+// Certify: full certified-target release gate
+program
+  .command("certify")
+  .description("Run the full certified target pipeline")
+  .option("-s, --scenarios <keys>", "Comma-separated list of scenario keys")
+  .option("--tag <tag>", "Version tag for certification publish")
+  .option("-m, --message <message>", "Publish message override")
+  .option("--json", "Output JSON report")
+  .action(async (options) => {
+    try {
+      const certifyCommand = require("./commands/certify");
+      await certifyCommand(options);
+    } catch (error) {
+      console.error(chalk.red("Error:"), error.message);
+      process.exit(1);
+    }
+  });
+
 // CI: CI/CD integration commands
 const ciCommand = program
   .command("ci")
@@ -337,9 +470,22 @@ Actions:
 // ============================================================================
 
 // Auth: Standalone authentication (for re-auth scenarios)
-program
+const auth = program
   .command("auth")
-  .description("Authenticate with Reshot Cloud")
+  .description("Authenticate with Reshot Cloud (or set RESHOT_API_KEY + RESHOT_PROJECT_ID env vars)")
+  .action(async () => {
+    try {
+      const authCommand = require("./commands/auth");
+      await authCommand();
+    } catch (error) {
+      console.error(chalk.red("Error:"), error.message);
+      process.exit(1);
+    }
+  });
+
+auth
+  .command("login")
+  .description("Compatibility alias for `reshot auth`")
   .action(async () => {
     try {
       const authCommand = require("./commands/auth");

package/src/lib/api-client.js

@@ -5,6 +5,51 @@ const fs = require("fs");
 
 const PRODUCTION_API_URL = "https://reshot.dev/api";
 
+function summarizeApiBody(body) {
+  if (body == null) return "";
+  if (typeof body === "string") return body.trim();
+  if (typeof body !== "object") return String(body);
+
+  const candidates = [
+    body.message,
+    body.error?.message,
+    body.error,
+    body.reason,
+    body.details,
+  ].filter(Boolean);
+
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim()) {
+      return candidate.trim();
+    }
+  }
+
+  try {
+    return JSON.stringify(body);
+  } catch {
+    return String(body);
+  }
+}
+
+function createApiError(kind, endpoint, error) {
+  const status = error.response?.status || null;
+  const statusText = error.response?.statusText || "";
+  const bodySummary = summarizeApiBody(error.response?.data);
+  const baseMessage = bodySummary || error.message || "Unknown API error";
+  const statusLabel = status ? `${status}${statusText ? ` ${statusText}` : ""}` : "request failed";
+  const wrapped = new Error(`${kind} (${statusLabel}) at ${endpoint}: ${baseMessage}`);
+  wrapped.response = error.response;
+  wrapped.code = error.code;
+  wrapped.reshot = {
+    kind,
+    endpoint,
+    status,
+    statusText,
+    bodySummary,
+  };
+  return wrapped;
+}
+
 function getApiBaseUrl() {
   // 1. Explicit env var override (for CI or local dev)
   if (process.env.RESHOT_API_BASE_URL) {
@@ -210,20 +255,7 @@ async function publishAssetsV1(apiKey, metadata, assets) {
     });
     return response.data;
   } catch (error) {
-    if (error.response) {
-      const status = error.response.status;
-      const errorMsg = error.response.data?.error || error.message;
-
-      // Create an error that preserves the response for auth detection
-      const err = new Error(
-        status === 401 || status === 403
-          ? `Authentication failed: ${errorMsg}`
-          : `Failed to publish assets: ${errorMsg}`,
-      );
-      err.response = error.response;
-      throw err;
-    }
-    throw new Error(`Failed to publish assets: ${error.message}`);
+    throw createApiError("publish_ingest_failure", `${baseUrl}/v1/publish`, error);
   }
 }
 
@@ -700,15 +732,23 @@ async function exportVisuals(projectId, options = {}) {
   }
 
   return withRetry(async () => {
-    const response = await axios.get(
-      `${baseUrl}/projects/${projectId}/visuals/export`,
-      {
-        params: { format, status },
-        headers: { Authorization: `Bearer ${apiKey}` },
-        timeout: 60000,
-      },
-    );
-    return response.data;
+    try {
+      const response = await axios.get(
+        `${baseUrl}/projects/${projectId}/visuals/export`,
+        {
+          params: { format, status },
+          headers: { Authorization: `Bearer ${apiKey}` },
+          timeout: 60000,
+        },
+      );
+      return response.data;
+    } catch (error) {
+      throw createApiError(
+        "export_visuals_failure",
+        `${baseUrl}/projects/${projectId}/visuals/export`,
+        error,
+      );
+    }
   });
 }
 
@@ -838,6 +878,7 @@ module.exports = {
   getProjectConfig,
   postChangelogDrafts,
   getApiBaseUrl,
+  createApiError,
   syncPushAssets,
   getSyncStatus,
   // New transactional flow

package/src/lib/capture-engine.js

@@ -98,6 +98,8 @@ class CaptureEngine {
     this.capturedAssets = [];
     this.logger = options.logger || console.log;
     this.headless = options.headless !== false; // Default to headless
+    this.injectWorkspaceStore = options.injectWorkspaceStore !== false;
+    this.diagnostics = [];
 
     // Storage state path for authenticated sessions
     // If provided, loads cookies/localStorage from file to preserve auth state
@@ -289,7 +291,9 @@ class CaptureEngine {
       logVariantSummary(this.variantConfig, this.logger);
     }
 
-    await this._injectWorkspaceStore();
+    if (this.injectWorkspaceStore) {
+      await this._injectWorkspaceStore();
+    }
 
     // Inject privacy masking CSS (after variant injection, before captures)
     this._privacyInjectionOk = true;
@@ -306,24 +310,76 @@ class CaptureEngine {
     this._authResponseDetected = false;
     this.page.on("response", (response) => {
       const status = response.status();
+      const url = response.url();
       if (
         (status === 401 || status === 403) &&
         response.request().resourceType() === "document"
       ) {
         this._authResponseDetected = true;
       }
+
+      if (status >= 400 && response.request().resourceType() === "document") {
+        this._recordDiagnostic("response_error", "error", {
+          url,
+          status,
+          resourceType: response.request().resourceType(),
+        });
+      }
     });
 
     // Set up error handling
     this.page.on("pageerror", (err) => {
       const firstLine = (err.message || '').split('\n')[0].slice(0, 200);
+      this._recordDiagnostic("pageerror", "error", {
+        message: err.message || String(err),
+      });
       this.logger(chalk.yellow(`  [Page Error] ${firstLine}`));
     });
+    this.page.on("console", (message) => {
+      const type = message.type();
+      const text = message.text();
+      const severity =
+        type === "error"
+          ? "error"
+          : type === "warning"
+            ? "warning"
+            : "info";
+
+      if (severity === "error" || severity === "warning") {
+        this._recordDiagnostic("console", severity, {
+          message: text,
+          consoleType: type,
+          cspViolation: /content security policy|csp/i.test(text),
+        });
+      }
+    });
+    this.page.on("requestfailed", (request) => {
+      this._recordDiagnostic("requestfailed", "error", {
+        url: request.url(),
+        method: request.method(),
+        resourceType: request.resourceType(),
+        message: request.failure()?.errorText || "Request failed",
+      });
+    });
 
     this.logger(chalk.green("  ✔ Browser initialized"));
     return this;
   }
 
+  _recordDiagnostic(kind, severity, details = {}) {
+    this.diagnostics.push({
+      id: `${Date.now()}-${this.diagnostics.length + 1}`,
+      kind,
+      severity,
+      ...details,
+      capturedAt: new Date().toISOString(),
+    });
+  }
+
+  getDiagnostics() {
+    return [...this.diagnostics];
+  }
+
   /**
    * Hide development overlays (Next.js devtools, Vercel toolbar, etc.)
    * Injects CSS to hide common development UI elements before each navigation
@@ -512,10 +568,15 @@ class CaptureEngine {
     }
 
     // Check for auth redirect after navigation (URL patterns + HTTP 401/403)
+    // Skip the check if the scenario explicitly targeted this URL (e.g. capturing /login)
     const currentUrl = this.page.url();
+    const targetPath = url.startsWith("http") ? new URL(url).pathname : url;
+    const currentPath = (() => { try { return new URL(currentUrl).pathname; } catch { return currentUrl; } })();
+    const isIntentionalTarget = currentPath === targetPath;
     const isAuthRedirect =
-      isAuthRedirectUrl(currentUrl, this._customAuthPatterns) ||
-      this._authResponseDetected;
+      !isIntentionalTarget &&
+      (isAuthRedirectUrl(currentUrl, this._customAuthPatterns) ||
+      this._authResponseDetected);
     if (isAuthRedirect) {
       const errorMsg = `Auth redirect detected: navigated to ${currentUrl}. Session may be expired. Re-run \`reshot record\` to refresh session, or export a fresh Playwright storage state to .reshot/auth-state.json.`;
       this.logger(chalk.red(`  ✖ ${errorMsg}`));