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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reshotdev/screenshot",
-  "version": "0.0.1-beta.6",
+  "version": "0.0.1-beta.7",
   "description": "CI/CD screenshot and video capture CLI",
   "author": "Reshot <hello@reshot.dev>",
   "license": "MIT",

package/src/commands/auth.js

@@ -217,7 +217,7 @@ async function authCommand() {
     await verifyApiKey(apiBaseUrl, status.project.apiKey);
 
     // Derive platformUrl from apiBaseUrl (remove /api suffix)
-    const platformUrl = apiBaseUrl.replace(/\/api\/?$/, '') || 'http://localhost:3000';
+    const platformUrl = apiBaseUrl.replace(/\/api\/?$/, '') || 'https://reshot.dev';
 
     writeSettings({
       projectId: status.project.id,

package/src/commands/publish.js

@@ -578,6 +578,7 @@ async function publishWithTransactionalFlow(
   docSyncConfig,
   gitInfo,
   diffManifests = null,
+  { autoApprove = false } = {},
 ) {
   console.log(
     chalk.cyan("  🚀 Using transactional upload (direct to R2)...\n"),
@@ -807,7 +808,10 @@ async function publishWithTransactionalFlow(
     });
   }
 
-  // Commit each group
+  // Build all commits for batch request
+  const MAX_BATCH_SIZE = 200;
+  const commits = [];
+
   for (const { group, scenarioConfig, assets } of groupMap.values()) {
     const contextObj = buildContextForVariation(
       scenarioConfig,
@@ -824,38 +828,58 @@ async function publishWithTransactionalFlow(
     });
 
     if (metadata.cli) {
-      metadata.cli.features = ["steps", "transactional"];
+      metadata.cli.features = ["steps", "transactional", "batch"];
     }
 
+    commits.push({ metadata, assets });
+  }
+
+  // Send in batches
+  console.log(
+    chalk.gray(`  Committing ${commits.length} scenario(s) to platform...`),
+  );
+
+  for (let i = 0; i < commits.length; i += MAX_BATCH_SIZE) {
+    const chunk = commits.slice(i, i + MAX_BATCH_SIZE);
+
     try {
-      const result = await apiClient.publishTransactional(apiKey, {
-        metadata,
-        assets,
+      const batchResult = await apiClient.publishBatch(apiKey, {
+        commits: chunk,
+        autoApprove: autoApprove || false,
       });
 
-      const processedCount = result?.assetsProcessed ?? assets.length;
-      console.log(
-        chalk.green(
-          `     ✔ Committed "${group.scenarioKey}" (${group.variationSlug}): ${processedCount} asset(s)`,
-        ),
-      );
-      successCount += processedCount;
+      for (const r of batchResult.results || []) {
+        if (r.status === "ok") {
+          const count = r.assetsProcessed || 0;
+          console.log(
+            chalk.green(
+              `     ✔ Committed "${r.scenario}" (${r.context}): ${count} asset(s)`,
+            ),
+          );
+          successCount += count;
 
-      // Handle skipped assets (visual limit)
-      if (result?.skippedAssets?.length > 0) {
-        for (const key of result.skippedAssets) {
-          console.log(chalk.yellow(`     ⚠ Skipped "${key}" (plan limit reached)`));
+          if (r.skippedAssets?.length > 0) {
+            for (const key of r.skippedAssets) {
+              console.log(chalk.yellow(`     ⚠ Skipped "${key}" (plan limit reached)`));
+            }
+            skippedCount += r.skippedAssets.length;
+          }
+        } else {
+          console.log(
+            chalk.red(
+              `     ✖ "${r.scenario}" (${r.context}): ${r.error || "Unknown error"}`,
+            ),
+          );
+          failCount++;
         }
-        skippedCount += result.skippedAssets.length;
       }
 
-      // Capture viewUrl from first successful response
-      if (!viewUrl && result?.viewUrl) {
-        viewUrl = result.viewUrl;
+      if (!viewUrl && batchResult.viewUrl) {
+        viewUrl = batchResult.viewUrl;
       }
     } catch (error) {
-      console.log(chalk.red(`     ✖ Commit failed: ${error.message}`));
-      failCount += assets.length;
+      console.log(chalk.red(`     ✖ Batch request failed: ${error.message}`));
+      failCount += chunk.length;
     }
   }
 
@@ -1204,7 +1228,7 @@ function parseFrontmatter(content) {
 }
 
 async function publishCommand(options = {}) {
-  const { tag, message, dryRun, force, video, outputJson } = options;
+  const { tag, message, dryRun, force, video, outputJson, autoApprove } = options;
 
   // Result tracking for --output-json and programmatic callers
   const publishResult = {
@@ -1230,6 +1254,10 @@ async function publishCommand(options = {}) {
     console.log(chalk.yellow("🔍 DRY RUN MODE - No assets will be uploaded\n"));
   }
 
+  if (autoApprove) {
+    console.log(chalk.cyan("  ✅ Auto-approve enabled: visuals will be approved immediately\n"));
+  }
+
   // Read config + settings (if available)
   const settings = readSettingsSafe();
   let docSyncConfig = null;
@@ -1413,6 +1441,7 @@ async function publishCommand(options = {}) {
               docSyncConfig,
               { commitHash, commitMessage, publishSessionId },
               diffManifests,
+              { autoApprove },
             );
             successCount = result.successCount;
             failCount = result.failCount;

package/src/index.js

@@ -221,12 +221,14 @@ program
   .option("--dry-run", "Preview without uploading")
   .option("-f, --force", "Skip confirmation prompts")
   .option("--output-json", "Write structured result to .reshot/output/publish-result.json")
+  .option("--auto-approve", "Automatically approve published visuals (skip review queue)")
   .action(async (options) => {
     try {
       const publishCommand = require("./commands/publish");
       await publishCommand({
         ...options,
         outputJson: options.outputJson,
+        autoApprove: options.autoApprove,
       });
     } catch (error) {
       console.error(chalk.red("Error:"), error.message);

package/src/lib/api-client.js

@@ -3,15 +3,35 @@ const axios = require("axios");
 const FormData = require("form-data");
 const fs = require("fs");
 
-const baseUrl =
-  process.env.RESHOT_API_BASE_URL ||
-  process.env.RESHOT_API_BASE_URL ||
-  "http://localhost:3000/api";
+const PRODUCTION_API_URL = "https://reshot.dev/api";
 
 function getApiBaseUrl() {
-  return baseUrl;
+  // 1. Explicit env var override (for CI or local dev)
+  if (process.env.RESHOT_API_BASE_URL) {
+    return process.env.RESHOT_API_BASE_URL;
+  }
+
+  // 2. Read from settings.json (set during auth/setup)
+  try {
+    const path = require("path");
+    const settingsPath = path.join(process.cwd(), ".reshot", "settings.json");
+    if (fs.existsSync(settingsPath)) {
+      const settings = JSON.parse(fs.readFileSync(settingsPath, "utf8"));
+      if (settings.platformUrl) {
+        return settings.platformUrl.replace(/\/+$/, "") + "/api";
+      }
+    }
+  } catch {
+    // Settings don't exist yet (first auth) — fall through to default
+  }
+
+  // 3. Default to production
+  return PRODUCTION_API_URL;
 }
 
+// Resolved once at module load — all API calls use this
+const baseUrl = getApiBaseUrl();
+
 /**
  * Sleep helper for retry delays
  */
@@ -586,6 +606,30 @@ async function publishTransactional(apiKey, payload) {
   return response.data;
 }
 
+/**
+ * Batch publish metadata for multiple scenarios in one request
+ * @param {string} apiKey - API key for authentication
+ * @param {Object} payload - { commits: Array<{ metadata, assets }> }
+ * @returns {Promise<Object>}
+ */
+async function publishBatch(apiKey, payload) {
+  if (!apiKey) {
+    throw new Error("API key is required to publish");
+  }
+
+  const response = await axios.post(`${baseUrl}/v1/publish/batch`, payload, {
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`,
+    },
+    timeout: 60000,
+    maxBodyLength: Infinity,
+    maxContentLength: Infinity,
+  });
+
+  return response.data;
+}
+
 /**
  * Check which hashes already exist in storage (for deduplication)
  * @param {string} apiKey - API key for authentication
@@ -800,6 +844,7 @@ module.exports = {
   signAssets,
   uploadToPresignedUrl,
   publishTransactional,
+  publishBatch,
   checkExistingHashes,
   // Diffing support
   getBaselines,

package/src/lib/capture-script-runner.js

@@ -1133,11 +1133,25 @@ async function runScenarioWithStepByStepCapture(scenario, options = {}) {
               `Page error detected: ${errMsg}. The page rendered an error UI instead of expected content.`
             );
           } else if (retryResult.status === "timeout") {
+            const currentUrl = engine.page.url();
             console.log(
               chalk.yellow(
-                `  ⚠ Ready selector not found after ${retryResult.attempts} attempt(s), proceeding with current state`
+                `  ⚠ Ready selector not found after ${retryResult.attempts} attempt(s): ${readySelector}`
+              )
+            );
+            console.log(
+              chalk.gray(`    URL: ${currentUrl}`)
+            );
+            console.log(
+              chalk.gray(
+                `    Hint: The page loaded but this selector does not exist. Check your readySelector in reshot.config.json.`
               )
             );
+            throw new Error(
+              `Scenario readySelector "${readySelector}" not found after ${retryResult.attempts} attempt(s). ` +
+              `The page loaded at ${currentUrl} but the selector does not exist. ` +
+              `Update readySelector in reshot.config.json or remove it to skip this check.`
+            );
           } else if (retryResult.attempts > 1) {
             console.log(
               chalk.green(
@@ -2185,8 +2199,16 @@ async function runScenarioWithVideoCapture(scenario, options = {}) {
           });
         } catch (e) {
           if (!isOptional) {
+            const currentUrl = page.url();
+            console.warn(
+              chalk.yellow(`    ⚠ Element not found: ${params.target}`)
+            );
+            console.warn(chalk.gray(`      URL: ${currentUrl}`));
+            console.warn(chalk.gray(`      Timeout: ${waitTimeout}ms`));
             console.warn(
-              chalk.yellow(`    ⚠ Wait for ${params.target} timed out`)
+              chalk.gray(
+                `      Hint: Verify the selector exists on the page. Run 'reshot record' to inspect.`
+              )
             );
           }
         }

package/src/lib/ui-api.js

@@ -43,17 +43,16 @@ const {
  * @returns {string} Platform URL
  */
 function getPlatformUrl(settings) {
-  // Priority: settings.platformUrl > env var > localhost default
+  // Priority: settings.platformUrl > env var > production default
   if (settings?.platformUrl) {
     return settings.platformUrl;
   }
-  const envUrl =
-    process.env.RESHOT_API_BASE_URL || process.env.RESHOT_API_BASE_URL;
+  const envUrl = process.env.RESHOT_API_BASE_URL;
   if (envUrl) {
     // Remove /api suffix if present to get platform URL
     return envUrl.replace(/\/api\/?$/, "");
   }
-  return "http://localhost:3000";
+  return "https://reshot.dev";
 }
 
 /**
@@ -2852,7 +2851,7 @@ function attachApiRoutes(app, context) {
         const apiBaseUrl = getApiBaseUrl();
         // Derive platformUrl from apiBaseUrl (remove /api suffix)
         const platformUrl =
-          apiBaseUrl.replace(/\/api\/?$/, "") || "http://localhost:3000";
+          apiBaseUrl.replace(/\/api\/?$/, "") || "https://reshot.dev";
 
         config.writeSettings({
           projectId: project.id,