@scrymore/scry-deployer 0.1.0 → 0.1.1

package/bin/cli.js

@@ -85,90 +85,46 @@ async function runDeployment(argv) {
     logger.debug(`Received arguments: ${JSON.stringify(argv)}`);
 
     const outPath = path.join(os.tmpdir(), `storybook-deployment-${Date.now()}.zip`);
+    let metadataZipPath = null;
 
     try {
-        const { coverageReport, coverageSummary } = await resolveCoverage(argv, logger);
+        const coverage = await resolveCoverage(argv, logger);
+        const coverageReport = coverage.coverageReport;
+        const coverageSummary = coverage.coverageSummary;
+        metadataZipPath = coverage.metadataZipPath;
 
         if (argv.withAnalysis) {
-            // Full deployment with analysis
             logger.info('Running deployment with analysis...');
+        }
 
-            // 1. Capture screenshots if storybook URL provided
-            if (argv.storybookUrl) {
-                logger.info(`1/5: Capturing screenshots from '${argv.storybookUrl}'...`);
-                await captureScreenshots(argv.storybookUrl, argv.storycapOptions || {});
-                logger.success('✅ Screenshots captured');
-            } else {
-                logger.info('1/5: Skipping screenshot capture (no Storybook URL provided)');
-            }
+        // 1. Archive only the static Storybook files.
+        logger.info(`1/3: Zipping directory '${argv.dir}'...`);
+        await zipDirectory(argv.dir, outPath);
+        logger.success(`✅ Archive created: ${outPath}`);
+        logger.debug(`Archive size: ${fs.statSync(outPath).size} bytes`);
 
-            // 2. Analyze stories and map screenshots
-            logger.info('2/5: Analyzing stories and mapping screenshots...');
-            const analysisResults = analyzeStorybook({
-                storiesDir: argv.storiesDir,
-                screenshotsDir: argv.screenshotsDir,
+        // 2. Upload Storybook ZIP + coverage + metadata ZIP (if present).
+        logger.info('2/3: Uploading to deployment service...');
+        const apiClient = getApiClient(argv.apiUrl, argv.apiKey);
+        const uploadResult = await uploadBuild(
+            apiClient,
+            {
                 project: argv.project,
-                version: argv.version
-            });
-            logger.success(`✅ Found ${analysisResults.summary.totalStories} stories (${analysisResults.summary.withScreenshots} with screenshots)`);
-
-            // 3. Create master ZIP with staticsite, images, and metadata
-            logger.info('3/5: Creating master archive with static site, images, and metadata...');
-            await createMasterZip({
-                outPath: outPath,
-                staticsiteDir: argv.dir,
-                screenshotsDir: argv.screenshotsDir,
-                metadata: analysisResults
-            });
-            logger.success(`✅ Master archive created: ${outPath}`);
-            logger.debug(`Archive size: ${fs.statSync(outPath).size} bytes`);
-
-            // 4. Upload archive (+ optional coverage)
-            logger.info('4/5: Uploading to deployment service...');
-            const apiClient = getApiClient(argv.apiUrl, argv.apiKey);
-            const uploadResult = await uploadBuild(
-                apiClient,
-                {
-                    project: argv.project,
-                    version: argv.version,
-                },
-                { zipPath: outPath, coverageReport }
-            );
-            logger.success('✅ Archive uploaded.');
-            logger.debug(`Upload result: ${JSON.stringify(uploadResult)}`);
-
-            await postPRComment(buildDeployResult(argv, coverageSummary, uploadResult), coverageSummary);
-
-            logger.success('\n🎉 Deployment with analysis successful! 🎉');
-            logUploadLinks(argv, coverageSummary, uploadResult, logger);
+                version: argv.version,
+            },
+            {
+                zipPath: outPath,
+                coverageReport,
+                metadataZipPath,
+            }
+        );
+        logger.success('✅ Archive uploaded.');
+        logger.debug(`Upload result: ${JSON.stringify(uploadResult)}`);
 
-        } else {
-            // Simple deployment without analysis
-            // 1. Archive the directory
-            logger.info(`1/3: Zipping directory '${argv.dir}'...`);
-            await zipDirectory(argv.dir, outPath);
-            logger.success(`✅ Archive created: ${outPath}`);
-            logger.debug(`Archive size: ${fs.statSync(outPath).size} bytes`);
-
-            // 2. Authenticate and upload directly (+ optional coverage)
-            logger.info('2/3: Uploading to deployment service...');
-            const apiClient = getApiClient(argv.apiUrl, argv.apiKey);
-            const uploadResult = await uploadBuild(
-                apiClient,
-                {
-                    project: argv.project,
-                    version: argv.version,
-                },
-                { zipPath: outPath, coverageReport }
-            );
-            logger.success('✅ Archive uploaded.');
-            logger.debug(`Upload result: ${JSON.stringify(uploadResult)}`);
-
-            await postPRComment(buildDeployResult(argv, coverageSummary, uploadResult), coverageSummary);
-
-            logger.success('\n🎉 Deployment successful! 🎉');
-            logUploadLinks(argv, coverageSummary, uploadResult, logger);
-        }
+        await postPRComment(buildDeployResult(argv, coverageSummary, uploadResult), coverageSummary);
+
+        logger.success('\n🎉 Deployment successful! 🎉');
+        logUploadLinks(argv, coverageSummary, uploadResult, logger);
 
     } finally {
         // 4. Clean up the local archive
@@ -176,6 +132,10 @@ async function runDeployment(argv) {
             fs.unlinkSync(outPath);
             logger.info(`🧹 Cleaned up temporary file: ${outPath}`);
         }
+        if (metadataZipPath && fs.existsSync(metadataZipPath)) {
+            fs.unlinkSync(metadataZipPath);
+            logger.info(`🧹 Cleaned up temporary file: ${metadataZipPath}`);
+        }
     }
 }
 
@@ -394,7 +354,7 @@ async function main() {
             }, async (argv) => {
                 const logger = createLogger(argv);
 
-                const report = await runCoverageAnalysis({
+                const result = await runCoverageAnalysis({
                     storybookDir: argv.dir,
                     baseBranch: argv.coverageBase || 'main',
                     failOnThreshold: Boolean(argv.coverageFailOnThreshold),
@@ -402,6 +362,7 @@ async function main() {
                     outputPath: argv.output,
                     keepReport: true,
                 });
+                const report = result.report;
 
                 if (!report) {
                     logger.error('Coverage: no report generated (tool failed or returned null)');
@@ -485,22 +446,32 @@ async function resolveCoverage(argv, logger) {
     const enabled = argv.coverage !== false;
     if (!enabled) {
         logger.info('Coverage: disabled (--no-coverage)');
-        return { coverageReport: null, coverageSummary: null };
+        return { coverageReport: null, coverageSummary: null, metadataZipPath: null };
     }
 
     try {
         let report = null;
+        let metadataZipPath = null;
 
         if (argv.coverageReport) {
             logger.info(`Coverage: using existing report at ${argv.coverageReport}`);
             report = loadCoverageReport(argv.coverageReport);
         } else {
-            report = await runCoverageAnalysis({
+            const needsScreenshots = Boolean(argv.withAnalysis);
+            const outputZipPath = needsScreenshots
+                ? path.join(os.tmpdir(), `scry-metadata-${Date.now()}.zip`)
+                : null;
+
+            const result = await runCoverageAnalysis({
                 storybookDir: argv.dir,
                 baseBranch: argv.coverageBase || 'main',
                 failOnThreshold: Boolean(argv.coverageFailOnThreshold),
-                execute: Boolean(argv.coverageExecute),
+                execute: Boolean(argv.coverageExecute) || needsScreenshots,
+                screenshots: needsScreenshots,
+                outputZipPath,
             });
+            report = result.report;
+            metadataZipPath = result.metadataZipPath;
         }
 
         const summary = extractCoverageSummary(report);
@@ -511,7 +482,7 @@ async function resolveCoverage(argv, logger) {
             logger.info('Coverage: no report generated (tool failed or report shape unexpected)');
         }
 
-        return { coverageReport: report, coverageSummary: summary };
+        return { coverageReport: report, coverageSummary: summary, metadataZipPath };
     } catch (err) {
         logger.error(`Coverage: failed (${err.message})`);
         throw err;

package/lib/apiClient.js

@@ -282,6 +282,50 @@ async function uploadCoverageReportDirectly(apiClient, target, coverageReport) {
   }
 }
 
+/**
+ * Upload metadata+screenshots ZIP.
+ * This triggers async build-processing through the upload service queue.
+ *
+ * @param {axios.AxiosInstance} apiClient
+ * @param {{project: string, version: string}} target
+ * @param {string} metadataZipPath
+ * @param {{info:Function,success:Function,warn:Function}} customLogger
+ * @returns {Promise<{success:boolean, status?:number, queued?:boolean, buildNumber?:number, zipKey?:string, error?:string}>}
+ */
+async function uploadMetadataZip(apiClient, target, metadataZipPath, customLogger = logger) {
+  const projectName = target.project || 'main';
+  const versionName = target.version || 'latest';
+  const url = `/upload/${projectName}/${versionName}/metadata`;
+
+  customLogger.info('Uploading metadata ZIP...');
+
+  try {
+    const fileBuffer = fs.readFileSync(metadataZipPath);
+    const response = await apiClient.post(url, fileBuffer, {
+      headers: { 'Content-Type': 'application/zip' },
+      maxContentLength: 100 * 1024 * 1024,
+      maxBodyLength: 100 * 1024 * 1024,
+    });
+
+    const data = response.data || {};
+    customLogger.success(
+      `Metadata ZIP uploaded (build #${data.buildNumber ?? 'n/a'}, queued: ${Boolean(data.queued)})`
+    );
+
+    return {
+      success: true,
+      status: response.status,
+      queued: Boolean(data.queued),
+      buildNumber: data.buildNumber,
+      zipKey: data.zipKey,
+    };
+  } catch (error) {
+    const message = error.response?.data?.error || error.message || 'Unknown error';
+    customLogger.warn(`Metadata ZIP upload failed: ${message}`);
+    return { success: false, error: message };
+  }
+}
+
 /**
  * Upload storybook zip plus optional coverage report.
  *
@@ -290,7 +334,7 @@ async function uploadCoverageReportDirectly(apiClient, target, coverageReport) {
  *
  * @param {axios.AxiosInstance} apiClient
  * @param {{project: string, version: string}} target
- * @param {{zipPath: string, coverageReport?: any|null}} options
+ * @param {{zipPath: string, coverageReport?: any|null, metadataZipPath?: string|null}} options
  */
 async function uploadBuild(apiClient, target, options) {
   logger.debug('uploadBuild orchestration started');
@@ -313,13 +357,19 @@ async function uploadBuild(apiClient, target, options) {
     }
   }
 
-  return { zipUpload, coverageUpload };
+  let metadataUpload = null;
+  if (options.metadataZipPath) {
+    metadataUpload = await uploadMetadataZip(apiClient, target, options.metadataZipPath, logger);
+  }
+
+  return { zipUpload, coverageUpload, metadataUpload };
 }
 
 module.exports = {
   getApiClient,
   uploadFileDirectly,
   uploadCoverageReportDirectly,
+  uploadMetadataZip,
   uploadBuild,
   requestPresignedUrl,
   putToPresignedUrl,

package/lib/coverage.js

@@ -10,6 +10,8 @@ const chalk = require('chalk');
  * @property {boolean} [failOnThreshold=false] If true, pass "--ci" to the coverage tool and rethrow errors
  * @property {string} [outputPath] If provided, write the report to this path (relative to cwd allowed)
  * @property {boolean} [keepReport=false] If true, do not delete the output file after reading
+ * @property {boolean} [screenshots=false] Enable passing-story screenshots in scry-sbcov
+ * @property {string|null} [outputZipPath=null] Where to write metadata+screenshots ZIP
  */
 
 /**
@@ -21,13 +23,23 @@ const chalk = require('chalk');
  * - Reads and returns the parsed JSON report
  * - Deletes the temporary report file
  *
- * If the underlying tool fails and `failOnThreshold` is false, returns `null`.
+ * If the underlying tool fails and `failOnThreshold` is false, returns
+ * `{ report: null, metadataZipPath: null }`.
  *
  * @param {RunCoverageOptions} options
- * @returns {Promise<any|null>} The full coverage report JSON, or null if skipped/failed (non-fatal)
+ * @returns {Promise<{report:any|null, metadataZipPath:string|null}>}
  */
 async function runCoverageAnalysis(options) {
-  const { storybookDir, baseBranch = 'main', failOnThreshold = false, execute = false, outputPath: providedOutputPath, keepReport = false } = options || {};
+  const {
+    storybookDir,
+    baseBranch = 'main',
+    failOnThreshold = false,
+    execute = false,
+    outputPath: providedOutputPath,
+    keepReport = false,
+    screenshots = false,
+    outputZipPath = null,
+  } = options || {};
 
   if (!storybookDir || typeof storybookDir !== 'string') {
     throw new Error('runCoverageAnalysis: options.storybookDir is required');
@@ -56,13 +68,21 @@ async function runCoverageAnalysis(options) {
     cliArgs.push('--ci');
   }
 
-  if (execute) {
+  if (execute || screenshots) {
     cliArgs.push('--execute');
   }
+  if (screenshots) {
+    cliArgs.push('--screenshots');
+    if (outputZipPath) {
+      cliArgs.push('--output-zip', outputZipPath);
+    }
+  }
 
-  // Use npx with the package name directly.
-  // This is more reliable than `npx -p` which can fail to find the binary in some environments.
-  const npxCommand = `npx -y @scrymore/scry-sbcov ${cliArgs.map(shellEscape).join(' ')}`;
+  // Allow local override for E2E testing before package publication.
+  // Example:
+  //   SCRY_SBCOV_CMD="node /abs/path/to/scry-sbcov/dist/cli/index.js"
+  const sbcovCommandPrefix = (process.env.SCRY_SBCOV_CMD || 'npx -y @scrymore/scry-sbcov').trim();
+  const npxCommand = `${sbcovCommandPrefix} ${cliArgs.map(shellEscape).join(' ')}`;
 
   // Debug logging to show the exact command being executed
   console.log(chalk.yellow('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
@@ -91,13 +111,16 @@ async function runCoverageAnalysis(options) {
 
     const raw = fs.readFileSync(outputPath, 'utf-8');
     const report = JSON.parse(raw);
+    const metadataZipPath = (screenshots && outputZipPath && fs.existsSync(outputZipPath))
+      ? outputZipPath
+      : null;
 
     if (!keepReport && !providedOutputPath) safeUnlink(outputPath);
-    return report;
+    return { report, metadataZipPath };
   } catch (error) {
     if (!keepReport && !providedOutputPath) safeUnlink(outputPath);
     if (failOnThreshold) throw error;
-    return null;
+    return { report: null, metadataZipPath: null };
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrymore/scry-deployer",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A CLI to automate the deployment of Storybook static builds.",
   "main": "index.js",
   "bin": {
@@ -37,7 +37,7 @@
   },
   "dependencies": {
     "@octokit/rest": "^20.0.0",
-    "@scrymore/scry-sbcov": "^0.2.2",
+    "@scrymore/scry-sbcov": "^0.3.0",
     "@sentry/node": "^10.33.0",
     "archiver": "^7.0.1",
     "axios": "^1.12.2",