@reshotdev/screenshot 0.0.1-beta.1 → 0.0.1-beta.10

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"));
@@ -112,17 +267,30 @@ async function pullCommand(options = {}) {
     projectConfig = config.readConfig();
   } catch (e) {
     console.error(
-      chalk.red("Error: No docsync.config.json found. Run 'reshot init' first.")
+      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 docsync.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,28 @@ 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) {
+    console.warn(
+      chalk.yellow(
+        `  ⚠ Project ID mismatch: config uses ${projectId}, but authenticated project is ${settings.projectId}.`
+      )
+    );
+    console.warn(
+      chalk.yellow(
+        `    This will cause auth failures. Run 'reshot setup --force' to re-link.\n`
+      )
+    );
   }
 
   try {
@@ -154,16 +337,32 @@ 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
     );
 
-    console.log(chalk.green(`  ✓ Fetched ${assetCount} visuals\n`));
+    if (assetCount === 0) {
+      console.log(chalk.yellow(`  ⚠ Fetched 0 visuals.\n`));
+      console.log(chalk.gray(`  Possible reasons:`));
+      if (status === "approved") {
+        console.log(chalk.gray(`    • No visuals approved yet. Try: reshot pull --status all`));
+      }
+      console.log(chalk.gray(`    • No visuals published. Run: reshot publish`));
+      console.log(chalk.gray(`    • Wrong project. Config uses: ${projectId}`));
+      console.log(chalk.gray(`    • Check: ${settings.platformUrl || "https://reshot.dev"}\n`));
+    } else {
+      console.log(chalk.green(`  ✓ Fetched ${assetCount} visuals\n`));
+    }
 
     // Determine output path
     let outputPath = output;
@@ -187,7 +386,7 @@ async function pullCommand(options = {}) {
 
     switch (format) {
       case "ts":
-        content = generateTypeScript(assets, full);
+        content = generateTypeScript(normalizedAssets, full);
         contentType = "TypeScript";
         break;
 
@@ -196,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(
                 [
@@ -222,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;
     }
@@ -285,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(
@@ -296,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 };
   }
 }