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

package/src/commands/pull.js

@@ -16,6 +16,137 @@ function toCamelCase(str) {
     .replace(/^[A-Z]/, (chr) => chr.toLowerCase());
 }
 
+function normalizeHostedAssetUrl(urlString) {
+  if (!urlString || typeof urlString !== "string") {
+    return urlString;
+  }
+
+  let normalized = urlString;
+  if (!normalized.includes("?") && normalized.includes("&")) {
+    const firstAmp = normalized.indexOf("&");
+    normalized = `${normalized.slice(0, firstAmp)}?${normalized.slice(firstAmp + 1)}`;
+  }
+
+  const parsed = new URL(normalized);
+  const capture = parsed.searchParams.get("capture");
+  if (capture && !parsed.searchParams.get("step")) {
+    parsed.searchParams.set("step", capture);
+  }
+  parsed.searchParams.delete("capture");
+
+  return parsed.toString();
+}
+
+function normalizeHostedAssetUrlWithMeta(urlString) {
+  const normalized = normalizeHostedAssetUrl(urlString);
+  return {
+    url: normalized,
+    repaired: normalized !== urlString,
+  };
+}
+
+function normalizeAssetEntry(entry) {
+  if (!entry || typeof entry !== "object") {
+    return { entry, repairs: 0 };
+  }
+
+  if (Array.isArray(entry.steps)) {
+    return {
+      entry: {
+        ...entry,
+        steps: entry.steps.map((step) => {
+          const src = normalizeHostedAssetUrlWithMeta(step.src);
+          const poster = step.poster
+            ? normalizeHostedAssetUrlWithMeta(step.poster)
+            : null;
+          return {
+            ...step,
+            src: src.url,
+            poster: poster ? poster.url : step.poster,
+          };
+        }),
+      },
+      repairs: entry.steps.reduce((count, step) => {
+        const src = normalizeHostedAssetUrlWithMeta(step.src);
+        const poster = step.poster
+          ? normalizeHostedAssetUrlWithMeta(step.poster)
+          : null;
+        return count + (src.repaired ? 1 : 0) + (poster?.repaired ? 1 : 0);
+      }, 0),
+    };
+  }
+
+  return {
+    entry: {
+      ...entry,
+      src: entry.src ? normalizeHostedAssetUrl(entry.src) : entry.src,
+      poster: entry.poster ? normalizeHostedAssetUrl(entry.poster) : entry.poster,
+    },
+    repairs:
+      (entry.src && normalizeHostedAssetUrlWithMeta(entry.src).repaired ? 1 : 0) +
+      (entry.poster && normalizeHostedAssetUrlWithMeta(entry.poster).repaired ? 1 : 0),
+  };
+}
+
+function normalizeAssetMap(assets) {
+  const normalized = {};
+  let repairs = 0;
+
+  for (const [group, visuals] of Object.entries(assets || {})) {
+    normalized[group] = {};
+
+    for (const [visualKey, variants] of Object.entries(visuals || {})) {
+      normalized[group][visualKey] = {};
+
+      for (const [variant, entry] of Object.entries(variants || {})) {
+        const normalizedEntry = normalizeAssetEntry(entry);
+        normalized[group][visualKey][variant] = normalizedEntry.entry;
+        repairs += normalizedEntry.repairs;
+      }
+    }
+  }
+
+  return { assets: normalized, repairs };
+}
+
+function validateHostedAssetUrl(urlString) {
+  if (!urlString || typeof urlString !== "string") {
+    return;
+  }
+
+  if (!urlString.includes("?") && (urlString.includes("&step=") || urlString.includes("&poster="))) {
+    throw new Error(`Malformed asset URL emitted without query delimiter: ${urlString}`);
+  }
+
+  const parsed = new URL(urlString);
+  if (parsed.searchParams.has("capture")) {
+    throw new Error(`Legacy capture param emitted in normalized output: ${urlString}`);
+  }
+}
+
+function validateAssetMap(assets) {
+  for (const visuals of Object.values(assets || {})) {
+    for (const variants of Object.values(visuals || {})) {
+      for (const entry of Object.values(variants || {})) {
+        if (entry && typeof entry === "object" && Array.isArray(entry.steps)) {
+          for (const step of entry.steps) {
+            validateHostedAssetUrl(step.src);
+            if (step.poster) {
+              validateHostedAssetUrl(step.poster);
+            }
+          }
+          continue;
+        }
+
+        validateHostedAssetUrl(entry?.src);
+        if (entry?.poster) {
+          validateHostedAssetUrl(entry.poster);
+        }
+      }
+    }
+  }
+}
+
 /**
  * Generate TypeScript code from the assets object
  * This provides type safety - if a visual is deleted, the build will fail
@@ -39,12 +170,27 @@ function generateTypeScript(assets, includeMetadata = false) {
         
         for (const [variant, asset] of Object.entries(variants)) {
           lines.push(`      ${variant}: {`);
-          lines.push(`        src: "${asset.src}",`);
           lines.push(`        type: "${asset.type}",`);
-          if (asset.width) lines.push(`        width: ${asset.width},`);
-          if (asset.height) lines.push(`        height: ${asset.height},`);
           lines.push(`        alt: "${asset.alt.replace(/"/g, '\\"')}",`);
-          if (asset.poster) lines.push(`        poster: "${asset.poster}",`);
+          if (Array.isArray(asset.steps)) {
+            lines.push(`        steps: [`);
+            for (const step of asset.steps) {
+              lines.push("          {");
+              lines.push(`            step: "${step.step}",`);
+              lines.push(`            src: "${step.src}",`);
+              lines.push(`            type: "${step.type}",`);
+              if (step.width) lines.push(`            width: ${step.width},`);
+              if (step.height) lines.push(`            height: ${step.height},`);
+              if (step.poster) lines.push(`            poster: "${step.poster}",`);
+              lines.push("          },");
+            }
+            lines.push("        ],");
+          } else {
+            lines.push(`        src: "${asset.src}",`);
+            if (asset.width) lines.push(`        width: ${asset.width},`);
+            if (asset.height) lines.push(`        height: ${asset.height},`);
+            if (asset.poster) lines.push(`        poster: "${asset.poster}",`);
+          }
           lines.push(`      },`);
         }
         
@@ -67,11 +213,19 @@ function generateTypeScript(assets, includeMetadata = false) {
       for (const [visualKey, variants] of Object.entries(visuals)) {
         // If there's only a default variant, flatten it
         if (Object.keys(variants).length === 1 && variants.default) {
-          lines.push(`    ${visualKey}: "${variants.default.src}",`);
+          if (Array.isArray(variants.default.steps)) {
+            lines.push(`    ${visualKey}: ${JSON.stringify(variants.default.steps)},`);
+          } else {
+            lines.push(`    ${visualKey}: "${variants.default.src}",`);
+          }
         } else {
           lines.push(`    ${visualKey}: {`);
           for (const [variant, asset] of Object.entries(variants)) {
-            lines.push(`      ${variant}: "${asset.src}",`);
+            if (Array.isArray(asset.steps)) {
+              lines.push(`      ${variant}: ${JSON.stringify(asset.steps)},`);
+            } else {
+              lines.push(`      ${variant}: "${asset.src}",`);
+            }
           }
           lines.push(`    },`);
         }
@@ -102,6 +256,7 @@ async function pullCommand(options = {}) {
     output = null,
     full = false,
     status = "approved",
+    noExit = false,
   } = options;
 
   console.log(chalk.blue("⬇ Pulling asset map from Reshot...\n"));
@@ -114,15 +269,28 @@ async function pullCommand(options = {}) {
     console.error(
       chalk.red("Error: No reshot.config.json found. Run 'reshot init' first.")
     );
-    process.exit(1);
+    if (!noExit) process.exit(1);
+    return { success: false, error: "No reshot.config.json found" };
   }
 
-  const projectId = projectConfig._metadata?.projectId || projectConfig.projectId;
+  let projectId = projectConfig._metadata?.projectId || projectConfig.projectId;
   if (!projectId) {
-    console.error(
-      chalk.red("Error: No projectId found in reshot.config.json")
-    );
-    process.exit(1);
+    // Fall back to reading projectId from .reshot/settings.json (written by `reshot auth`)
+    try {
+      const settings = config.readSettings();
+      if (settings?.projectId) {
+        projectId = settings.projectId;
+      }
+    } catch (e) {
+      // No settings file either
+    }
+  }
+  if (!projectId) {
+      console.error(
+        chalk.red("Error: No projectId found. Add it to reshot.config.json or run 'reshot auth' first.")
+      );
+    if (!noExit) process.exit(1);
+    return { success: false, error: "No projectId found" };
   }
 
   // Check authentication
@@ -133,13 +301,15 @@ async function pullCommand(options = {}) {
     console.error(
       chalk.red("Error: Not authenticated. Run 'reshot auth' first.")
     );
-    process.exit(1);
+    if (!noExit) process.exit(1);
+    return { success: false, error: "Not authenticated" };
   }
   if (!settings?.apiKey) {
     console.error(
       chalk.red("Error: Not authenticated. Run 'reshot auth' first.")
     );
-    process.exit(1);
+    if (!noExit) process.exit(1);
+    return { success: false, error: "Not authenticated" };
   }
 
   if (settings.projectId && projectId !== settings.projectId) {
@@ -167,11 +337,16 @@ async function pullCommand(options = {}) {
 
     if (!response || !response.assets) {
       console.error(chalk.red("Error: Invalid response from API"));
-      process.exit(1);
+      if (!noExit) process.exit(1);
+      return { success: false, error: "Invalid response from API" };
     }
 
-    const { meta, assets } = response;
-    const assetCount = Object.values(assets).reduce(
+    const normalization = normalizeAssetMap(response.assets);
+    const normalizedAssets = normalization.assets;
+    validateAssetMap(normalizedAssets);
+
+    const { meta } = response;
+    const assetCount = Object.values(normalizedAssets).reduce(
       (count, group) => count + Object.keys(group).length,
       0
     );
@@ -211,7 +386,7 @@ async function pullCommand(options = {}) {
 
     switch (format) {
       case "ts":
-        content = generateTypeScript(assets, full);
+        content = generateTypeScript(normalizedAssets, full);
         contentType = "TypeScript";
         break;
 
@@ -220,9 +395,28 @@ async function pullCommand(options = {}) {
         const headers = ["Key", "Group", "Name", "Context", "Type", "Unbreakable_URL", "Width", "Height"];
         const rows = [headers.join(",")];
         
-        for (const [group, visuals] of Object.entries(assets)) {
+        for (const [group, visuals] of Object.entries(normalizedAssets)) {
           for (const [visualKey, variants] of Object.entries(visuals)) {
             for (const [variant, asset] of Object.entries(variants)) {
+              if (Array.isArray(asset.steps)) {
+                for (const step of asset.steps) {
+                  const type = step.type.split("/")[0];
+                  rows.push(
+                    [
+                      `${group}/${visualKey}/${step.step}`,
+                      group,
+                      visualKey,
+                      variant,
+                      type,
+                      step.src,
+                      step.width || "",
+                      step.height || "",
+                    ].join(",")
+                  );
+                }
+                continue;
+              }
+
               const type = asset.type.split("/")[0]; // 'image' or 'video'
               rows.push(
                 [
@@ -246,7 +440,7 @@ async function pullCommand(options = {}) {
 
       case "json":
       default:
-        content = JSON.stringify({ meta, assets }, null, 2);
+        content = JSON.stringify({ meta, assets: normalizedAssets }, null, 2);
         contentType = "JSON";
         break;
     }
@@ -309,6 +503,15 @@ async function pullCommand(options = {}) {
     console.log(chalk.gray("  This ensures your build always uses the latest approved visuals."));
     console.log(chalk.gray("  If a visual is deleted, your build will fail (preventing broken images).\n"));
 
+    return {
+      success: true,
+      assetCount,
+      outputPath: path.resolve(outputPath),
+      normalizedAssets,
+      normalizationRepairs: normalization.repairs,
+      meta,
+    };
+
   } catch (error) {
     if (config.isAuthError(error)) {
       console.error(
@@ -320,7 +523,10 @@ async function pullCommand(options = {}) {
         console.error(chalk.gray(error.stack));
       }
     }
-    process.exit(1);
+    if (!noExit) {
+      process.exit(1);
+    }
+    return { success: false, error: error.message };
   }
 }
 

package/src/commands/setup-wizard.js

@@ -6,6 +6,7 @@ const chalk = require("chalk");
 const fs = require("fs-extra");
 const path = require("path");
 const config = require("../lib/config");
+const { normalizeConfigContract } = require("../lib/target-contract");
 
 /**
  * Detect if this is a Git repository and if it's GitHub
@@ -60,6 +61,94 @@ function detectPlaywright() {
   return { hasPlaywright: false, configFile: null };
 }
 
+function detectSetupMode(projectConfig, useCloud) {
+  const normalizedConfig =
+    projectConfig && typeof projectConfig === "object"
+      ? normalizeConfigContract(projectConfig)
+      : null;
+  const targetTier = normalizedConfig?.target?.tier || null;
+
+  if (targetTier === "certified") {
+    return "certified-target";
+  }
+
+  if (targetTier === "candidate") {
+    return "candidate-target";
+  }
+
+  return useCloud ? "cloud-connected" : "local-only";
+}
+
+function getRecommendedLocalServerCommand(normalizedConfig) {
+  const explicitCommand = normalizedConfig?.target?.supportedLocalCommand;
+  if (explicitCommand) {
+    return explicitCommand;
+  }
+
+  if (normalizedConfig?.target?.tier === "certified") {
+    return "npm run build && npm run start";
+  }
+
+  return null;
+}
+
+function getNextRecommendedCommand(mode, useCloud) {
+  if (mode === "certified-target" || mode === "candidate-target") {
+    return "reshot doctor target";
+  }
+
+  return useCloud ? "reshot publish" : "reshot run";
+}
+
+function writeSetupReport({
+  mode,
+  useCloud,
+  projectId,
+  projectName,
+  configCreated,
+  playwrightDetected,
+  supportedLocalCommand,
+}) {
+  const reportPath = path.join(
+    process.cwd(),
+    ".reshot",
+    "reports",
+    "self-serve-setup.json",
+  );
+
+  fs.ensureDirSync(path.dirname(reportPath));
+  fs.writeJSONSync(
+    reportPath,
+    {
+      generatedAt: new Date().toISOString(),
+      mode,
+      nextRecommendedCommand: getNextRecommendedCommand(mode, useCloud),
+      useCloud,
+      projectId: projectId || null,
+      projectName: projectName || null,
+      configCreated,
+      playwrightDetected,
+      supportedEnvironment: {
+        launchSupported: "production-like localhost",
+        launchUnsupported: ["next dev"],
+        supportedLocalCommand: supportedLocalCommand || null,
+      },
+      blockingIssues: [],
+      advisories: [
+        "Run your target app with a production-like local server for launch-grade captures.",
+      ],
+      nextMilestones: [
+        "reshot setup",
+        "reshot run",
+        ...(useCloud ? ["reshot publish"] : []),
+      ],
+    },
+    { spaces: 2 },
+  );
+
+  return reportPath;
+}
+
 /**
  * Main setup wizard
  */
@@ -152,7 +241,7 @@ async function setupWizard(options = {}) {
     if (action === "reauth") {
       console.log(chalk.gray("\nOpening browser for authentication...\n"));
       const authCommand = require("./auth");
-      await authCommand();
+      const authResult = await authCommand();
 
       // Re-read settings after auth
       try {
@@ -172,6 +261,9 @@ async function setupWizard(options = {}) {
         chalk.green("\n✔ Connected to"),
         chalk.cyan(existingSettings.projectName || existingSettings.projectId),
       );
+      if (authResult?.mode) {
+        console.log(chalk.gray(`  Mode: ${authResult.mode}`));
+      }
       console.log(
         chalk.gray("\nRun"),
         chalk.cyan("reshot studio"),
@@ -187,7 +279,7 @@ async function setupWizard(options = {}) {
   // STEP 1: Platform Connection
   // ========================================
   if (!isAlreadyAuthed && !offline) {
-    console.log(chalk.cyan("\n━━━ Step 1: Platform Connection ━━━\n"));
+  console.log(chalk.cyan("\n━━━ Step 1: Choose Your Lane ━━━\n"));
 
     const { connectToCloud } = await inquirer.prompt([
       {
@@ -196,11 +288,11 @@ async function setupWizard(options = {}) {
         message: "How would you like to use Reshot?",
         choices: [
           {
-            name: `${chalk.cyan("Connect to Reshot Cloud")} - Governance, CDN hosting, team collaboration`,
+            name: `${chalk.cyan("Set up hosted pipeline")} - Connect to Reshot Cloud for hosted assets, review workflows, and team collaboration`,
             value: true,
           },
           {
-            name: `${chalk.gray("Offline mode")} - Local-only visuals (no cloud sync)`,
+            name: `${chalk.gray("Start locally")} - Get a first capture working on your machine before you add hosted delivery`,
             value: false,
           },
         ],
@@ -211,7 +303,7 @@ async function setupWizard(options = {}) {
       console.log(chalk.gray("\nOpening browser for authentication...\n"));
 
       const authCommand = require("./auth");
-      await authCommand();
+      const authResult = await authCommand();
 
       // Re-read settings after auth
       try {
@@ -231,6 +323,9 @@ async function setupWizard(options = {}) {
         chalk.green("\n✔ Connected to"),
         chalk.cyan(existingSettings.projectName || existingSettings.projectId),
       );
+      if (authResult?.mode) {
+        console.log(chalk.gray(`  Mode: ${authResult.mode}`));
+      }
     } else {
       console.log(chalk.gray("Running in offline mode — no cloud sync."));
     }
@@ -240,11 +335,16 @@ async function setupWizard(options = {}) {
 
   const useCloud = isAlreadyAuthed;
   const projectId = existingSettings?.projectId;
+  const normalizedSetupConfig = normalizeConfigContract(
+    existingConfig && typeof existingConfig === "object" ? existingConfig : {},
+  );
+  const supportedLocalCommand =
+    getRecommendedLocalServerCommand(normalizedSetupConfig);
 
   // ========================================
-  // STEP 2: Visual Capture Configuration
+  // STEP 2: Project Defaults
   // ========================================
-  console.log(chalk.cyan("\n━━━ Visual Capture ━━━\n"));
+  console.log(chalk.cyan("\n━━━ Step 2: Project Defaults ━━━\n"));
 
   let traceDir = "./test-results";
 
@@ -253,24 +353,25 @@ async function setupWizard(options = {}) {
     if (playwrightInfo.configFile) {
       console.log(chalk.gray(`  Config: ${playwrightInfo.configFile}`));
     }
+    const { customTraceDir } = await inquirer.prompt([
+      {
+        type: "input",
+        name: "customTraceDir",
+        message: "Playwright test-results directory:",
+        default: "./test-results",
+      },
+    ]);
+
+    traceDir = customTraceDir;
   } else {
-    console.log(chalk.yellow("⚠ Playwright not detected"));
+    console.log(chalk.green("✔ No Playwright setup detected"));
     console.log(
-      chalk.gray("  Install with: npm install -D @playwright/test"),
+      chalk.gray(
+        "  That is okay for the local-first workflow. You can define or record scenarios and run them directly.",
+      ),
     );
   }
 
-  const { customTraceDir } = await inquirer.prompt([
-    {
-      type: "input",
-      name: "customTraceDir",
-      message: "Playwright test-results directory:",
-      default: "./test-results",
-    },
-  ]);
-
-  traceDir = customTraceDir;
-
   // ========================================
   // Generate Configuration
   // ========================================
@@ -311,6 +412,25 @@ async function setupWizard(options = {}) {
   config.writeConfig(newConfig);
   console.log(chalk.green("✔ Created reshot.config.json"));
 
+  const combinedConfig =
+    existingConfig && typeof existingConfig === "object"
+      ? { ...existingConfig, ...newConfig }
+      : newConfig;
+  const normalizedCombinedConfig = normalizeConfigContract(combinedConfig);
+  const setupMode = detectSetupMode(combinedConfig, useCloud);
+  const finalSupportedLocalCommand =
+    getRecommendedLocalServerCommand(normalizedCombinedConfig) ||
+    supportedLocalCommand;
+  const reportPath = writeSetupReport({
+    mode: setupMode,
+    useCloud,
+    projectId,
+    projectName: existingSettings?.projectName,
+    configCreated: true,
+    playwrightDetected: playwrightInfo.hasPlaywright,
+    supportedLocalCommand: finalSupportedLocalCommand,
+  });
+
   // ========================================
   // Success & Next Steps
   // ========================================
@@ -318,21 +438,59 @@ async function setupWizard(options = {}) {
   console.log(chalk.green.bold("✔ Reshot setup complete!"));
   console.log(chalk.green("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n"));
 
-  console.log(chalk.cyan("Next steps:\n"));
+  console.log(chalk.cyan("Supported launch path:\n"));
+  console.log(
+    `  ${chalk.gray("Run your target app with a production-like local server before capture.")}`,
+  );
+  console.log(
+    `     ${chalk.cyan(finalSupportedLocalCommand || "npm run build && npm run start")}`,
+  );
+  console.log(
+    `  ${chalk.gray("Unsupported for launch reliability:")} ${chalk.yellow("next dev")}\n`,
+  );
+
+  console.log(chalk.cyan("Setup mode:\n"));
+  console.log(`  ${chalk.green(setupMode)}\n`);
 
+  console.log(chalk.cyan("Next steps:\n"));
+  console.log(
+    `  1. ${chalk.gray("Review")} ${chalk.cyan("reshot.config.json")} ${chalk.gray("and add your first scenario or recording")}`,
+  );
   console.log(
-    `  1. ${chalk.gray("Review")} ${chalk.cyan("reshot.config.json")} ${chalk.gray("and commit to your repo")}`,
+    `  2. ${chalk.gray("Start your app in the supported environment:")}`,
   );
   console.log(
-    `  2. ${chalk.gray("Run Playwright tests to generate traces:")}`,
+    `     ${chalk.cyan(finalSupportedLocalCommand || "npm run build && npm run start")}`,
   );
-  console.log(`     ${chalk.cyan("npx playwright test")}`);
+  console.log(`  3. ${chalk.gray("Generate your first local capture:")}`);
+  console.log(`     ${chalk.cyan("reshot run")}`);
 
-  console.log(`\n  ${chalk.gray("Sync visuals to Reshot:")}`);
-  console.log(`     ${chalk.cyan("reshot sync")}`);
+  if (useCloud) {
+    console.log(
+      `\n  4. ${chalk.gray("Upgrade to hosted assets when you are ready:")}`,
+    );
+    console.log(`     ${chalk.cyan("reshot publish")}`);
+  }
 
-  console.log(`\n  ${chalk.gray("Launch the visual management UI:")}`);
-  console.log(`     ${chalk.cyan("reshot studio")}\n`);
+  if (setupMode === "certified-target" || setupMode === "candidate-target") {
+    console.log(
+      `\n  5. ${chalk.gray("Use advanced target checks when you need them:")}`,
+    );
+    console.log(`     ${chalk.cyan("reshot doctor target")}`);
+    console.log(`     ${chalk.cyan("reshot verify publish")}`);
+    if (setupMode === "certified-target") {
+      console.log(`     ${chalk.cyan("reshot certify")}`);
+    }
+  }
+
+  console.log(`\n  ${chalk.gray("Open Studio to inspect output locally:")}`);
+  console.log(`     ${chalk.cyan("reshot studio")}`);
+  console.log(
+    `\n  ${chalk.gray("Supported environments guide:")} ${chalk.cyan("https://reshot.dev/docs/cli/getting-started/supported-environments")}`,
+  );
+  console.log(
+    `\n  ${chalk.gray("Setup report written to:")} ${chalk.cyan(path.relative(process.cwd(), reportPath))}\n`,
+  );
 
   // Offer to launch studio
   const { launchStudio } = await inquirer.prompt([
@@ -340,7 +498,7 @@ async function setupWizard(options = {}) {
       type: "confirm",
       name: "launchStudio",
       message: "Launch Reshot Studio now?",
-      default: true,
+      default: false,
     },
   ]);
 

package/src/commands/setup.js

@@ -156,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"));
   }
 }