@scrymore/scry-deployer 0.0.4 → 0.0.6

package/README.md

@@ -50,6 +50,7 @@ This tool is designed for execution within a CI/CD pipeline (such as GitHub Acti
 - 🔍 Auto-detection of `.stories.*` files
 - 📊 Story metadata extraction and analysis
 - 📸 Automated screenshot capture with storycap
+- 🧪 Storybook coverage analysis + PR summary comments (see `docs/COVERAGE.md`)
 - 📦 Organized master ZIP packaging (staticsite, images, metadata)
 - ⚙️ Flexible configuration (CLI, env vars, config file)
 - 🔒 Secure presigned URL uploads

package/bin/cli.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+const Sentry = require('@sentry/node');
 const yargs = require('yargs/yargs');
 const { hideBin } = require('yargs/helpers');
 const fs = require('fs');
@@ -7,12 +8,14 @@ const path = require('path');
 const os = require('os');
 const { zipDirectory } = require('../lib/archive.js');
 const { createMasterZip } = require('../lib/archiveUtils.js');
-const { getApiClient, uploadFileDirectly } = require('../lib/apiClient.js');
+const { getApiClient, uploadBuild } = require('../lib/apiClient.js');
 const { createLogger } = require('../lib/logger.js');
 const { AppError, ApiError } = require('../lib/errors.js');
 const { loadConfig } = require('../lib/config.js');
 const { captureScreenshots } = require('../lib/screencap.js');
 const { analyzeStorybook } = require('../lib/analysis.js');
+const { runCoverageAnalysis, loadCoverageReport, extractCoverageSummary } = require('../lib/coverage.js');
+const { postPRComment } = require('../lib/pr-comment.js');
 const { runInit } = require('../lib/init.js');
 
 async function runAnalysis(argv) {
@@ -83,6 +86,8 @@ async function runDeployment(argv) {
     const outPath = path.join(os.tmpdir(), `storybook-deployment-${Date.now()}.zip`);
 
     try {
+        const { coverageReport, coverageSummary } = await resolveCoverage(argv, logger);
+
         if (argv.withAnalysis) {
             // Full deployment with analysis
             logger.info('Running deployment with analysis...');
@@ -117,16 +122,22 @@ async function runDeployment(argv) {
             logger.success(`✅ Master archive created: ${outPath}`);
             logger.debug(`Archive size: ${fs.statSync(outPath).size} bytes`);
 
-            // 4. Upload archive
+            // 4. Upload archive (+ optional coverage)
             logger.info('4/5: Uploading to deployment service...');
             const apiClient = getApiClient(argv.apiUrl, argv.apiKey);
-            const uploadResult = await uploadFileDirectly(apiClient, {
-                project: argv.project,
-                version: argv.version,
-            }, outPath);
+            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), coverageSummary);
+
             logger.success('\n🎉 Deployment with analysis successful! 🎉');
 
         } else {
@@ -137,16 +148,22 @@ async function runDeployment(argv) {
             logger.success(`✅ Archive created: ${outPath}`);
             logger.debug(`Archive size: ${fs.statSync(outPath).size} bytes`);
 
-            // 2. Authenticate and upload directly
+            // 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 uploadFileDirectly(apiClient, {
-                project: argv.project,
-                version: argv.version,
-            }, outPath);
+            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), coverageSummary);
+
             logger.success('\n🎉 Deployment successful! 🎉');
         }
 
@@ -159,10 +176,26 @@ async function runDeployment(argv) {
     }
 }
 
-function handleError(error, argv) {
+async function handleError(error, argv) {
     const logger = createLogger(argv || {});
     logger.error(`\n❌ Error: ${error.message}`);
 
+    // Capture error in Sentry with additional context
+    Sentry.withScope((scope) => {
+        if (argv) {
+            scope.setTags({
+                project: argv.project,
+                version: argv.version,
+                command: argv._ ? argv._[0] : 'unknown',
+            });
+            scope.setExtra('argv', argv);
+        }
+        Sentry.captureException(error);
+    });
+    
+    // Ensure the event is sent before the process exits
+    await Sentry.close(2000);
+
     if (error instanceof ApiError) {
         if (error.statusCode === 401) {
             logger.error('Suggestion: Check that your API key is correct and has not expired.');
@@ -179,6 +212,13 @@ function handleError(error, argv) {
 }
 
 async function main() {
+    // Initialize Sentry
+    Sentry.init({
+        dsn: "https://c66ce229a1db2289f145eebd02436d9c@o4507889391828992.ingest.us.sentry.io/4510699330732032", // Fallback to hardcoded DSN for user reporting
+        tracesSampleRate: 1.0,
+        environment: process.env.NODE_ENV || 'production',
+    });
+
     let config;
     try {
         const args = await yargs(hideBin(process.argv))
@@ -201,10 +241,35 @@ async function main() {
                         type: 'string',
                     })
                     .option('deploy-version', {
-                        alias: 'v',
+                        alias: ['v', 'version'],
                         describe: 'Version identifier for the deployment',
                         type: 'string',
                     })
+                    // Coverage options (enabled by default)
+                    .option('coverage', {
+                        describe: 'Run coverage analysis and upload report',
+                        type: 'boolean',
+                        default: true,
+                    })
+                    .option('coverage-report', {
+                        describe: 'Path to coverage report JSON file (skip analysis and upload this report)',
+                        type: 'string',
+                    })
+                    .option('coverage-fail-on-threshold', {
+                        describe: 'Fail if coverage thresholds are not met',
+                        type: 'boolean',
+                        default: false,
+                    })
+                    .option('coverage-base', {
+                        describe: 'Base branch for new code analysis',
+                        type: 'string',
+                        default: 'main',
+                    })
+                    .option('coverage-execute', {
+                        describe: 'Execute stories during coverage analysis',
+                        type: 'boolean',
+                        default: false,
+                    })
                     .option('with-analysis', {
                         describe: 'Include Storybook analysis (screenshots, metadata)',
                         type: 'boolean',
@@ -337,6 +402,9 @@ async function main() {
 
                 await runInit(initConfig);
             })
+            .command('debug-sentry', 'Test Sentry integration by throwing an error', () => {}, () => {
+                throw new Error('Sentry debug error from scry-node CLI');
+            })
             .env('STORYBOOK_DEPLOYER')
             .help()
             .alias('help', 'h')
@@ -344,8 +412,87 @@ async function main() {
             .parse();
 
     } catch (error) {
-        handleError(error, config);
+        await handleError(error, config);
+    }
+}
+
+/**
+ * Resolve coverage settings into a report and a summary.
+ *
+ * @param {any} argv
+ * @param {{info:Function,debug:Function,success:Function,error:Function}} logger
+ */
+async function resolveCoverage(argv, logger) {
+    const enabled = argv.coverage !== false;
+    if (!enabled) {
+        logger.info('Coverage: disabled (--no-coverage)');
+        return { coverageReport: null, coverageSummary: null };
     }
+
+    try {
+        let report = null;
+
+        if (argv.coverageReport) {
+            logger.info(`Coverage: using existing report at ${argv.coverageReport}`);
+            report = loadCoverageReport(argv.coverageReport);
+        } else {
+            report = await runCoverageAnalysis({
+                storybookDir: argv.dir,
+                baseBranch: argv.coverageBase || 'main',
+                failOnThreshold: Boolean(argv.coverageFailOnThreshold),
+                execute: Boolean(argv.coverageExecute),
+            });
+        }
+
+        const summary = extractCoverageSummary(report);
+        if (summary) {
+            logger.success('✅ Coverage report ready');
+            logger.debug(`Coverage summary: ${JSON.stringify(summary.summary)}`);
+        } else {
+            logger.info('Coverage: no report generated (tool failed or report shape unexpected)');
+        }
+
+        return { coverageReport: report, coverageSummary: summary };
+    } catch (err) {
+        logger.error(`Coverage: failed (${err.message})`);
+        throw err;
+    }
+}
+
+/**
+ * Construct public URLs for view and coverage assets.
+ *
+ * @param {any} argv
+ * @param {any|null} coverageSummary
+ */
+function buildDeployResult(argv, coverageSummary) {
+    const project = argv.project || 'main';
+    const version = argv.version || 'latest';
+    const viewBaseUrl = process.env.SCRY_VIEW_URL || 'https://view.scrymore.com';
+
+    const viewUrl = `${viewBaseUrl.replace(/\/$/, '')}/${project}/${version}/`;
+
+    const coverageUrl = coverageSummary
+        ? `${viewBaseUrl.replace(/\/$/, '')}/${project}/${version}/coverage-report.json`
+        : null;
+
+    return {
+        project,
+        version,
+        viewUrl,
+        coverageUrl,
+        coveragePageUrl: coverageUrl,
+    };
+}
+
+if (require.main === module) {
+    main();
 }
 
-main();
+module.exports = {
+    main,
+    runDeployment,
+    runAnalysis,
+    resolveCoverage,
+    buildDeployResult,
+};

package/lib/apiClient.js

@@ -1,6 +1,6 @@
 const axios = require('axios');
 const fs = require('fs');
-const { ApiError, UploadError } = require('./errors.js');
+const { ApiError } = require('./errors.js');
 
 /**
  * Creates a pre-configured axios instance for making API calls.
@@ -30,101 +30,176 @@ function getApiClient(apiUrl, apiKey) {
   });
 }
 
+/**
+ * Request a presigned URL from the backend.
+ *
+ * @param {axios.AxiosInstance} apiClient
+ * @param {{project: string, version: string}} target
+ * @param {{fileName: string, contentType: string}} file
+ * @returns {Promise<string>} presigned URL
+ */
+async function requestPresignedUrl(apiClient, target, file) {
+  const projectName = target.project || 'main';
+  const versionName = target.version || 'latest';
+
+  const presignedResponse = await apiClient.post(
+    `/presigned-url/${projectName}/${versionName}/${file.fileName}`,
+    { contentType: file.contentType },
+    {
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    }
+  );
+
+  const presignedUrl = presignedResponse.data?.url;
+  if (!presignedUrl || typeof presignedUrl !== 'string' || presignedUrl.trim() === '') {
+    throw new ApiError(
+      `Failed to get valid presigned URL from server response. Received: ${JSON.stringify(presignedResponse.data)}`
+    );
+  }
+
+  // Validate URL format
+  try {
+    new URL(presignedUrl);
+  } catch (urlError) {
+    throw new ApiError(`Received invalid URL format from server: "${presignedUrl}". URL validation error: ${urlError.message}`);
+  }
+
+  return presignedUrl;
+}
+
+/**
+ * Upload a buffer to a presigned URL.
+ *
+ * @param {string} presignedUrl
+ * @param {Buffer} buffer
+ * @param {string} contentType
+ * @returns {Promise<{status:number}>}
+ */
+async function putToPresignedUrl(presignedUrl, buffer, contentType) {
+  const uploadResponse = await axios.put(presignedUrl, buffer, {
+    headers: {
+      'Content-Type': contentType,
+    },
+    maxContentLength: Infinity,
+    maxBodyLength: Infinity,
+  });
+
+  return { status: uploadResponse.status };
+}
+
 /**
  * Uploads a file using a presigned URL workflow.
+ *
  * @param {axios.AxiosInstance} apiClient The configured axios instance.
  * @param {object} payload The metadata for the deployment.
  * @param {string} payload.project The project name/identifier.
  * @param {string} payload.version The version identifier.
  * @param {string} filePath The local path to the file to upload.
+ * @param {{fileName?: string, contentType?: string}} [file] Optional overrides
  * @returns {Promise<object>} A promise that resolves to the upload result.
  */
-async function uploadFileDirectly(apiClient, { project, version }, filePath) {
+async function uploadFileDirectly(apiClient, { project, version }, filePath, file = {}) {
   // This is a mock check to allow testing of a 500 server error.
   if (project === 'fail-me-500') {
     throw new ApiError('The deployment service encountered an internal error.', 500);
   }
 
-  // Default to 'main' and 'latest' if not provided
-  const projectName = project || 'main';
-  const versionName = version || 'latest';
-
   const fileBuffer = fs.readFileSync(filePath);
-  const fileName = 'storybook.zip';
+  const fileName = file.fileName || 'storybook.zip';
+  const contentType = file.contentType || 'application/zip';
 
   try {
-    // Step 1: Request a presigned URL
-    const presignedUrlStartTime = Date.now();
-    console.log(`[DEBUG] Requesting presigned URL for /presigned-url/${projectName}/${versionName}/${fileName}`);
-    console.log(`[DEBUG] API Base URL: ${apiClient.defaults.baseURL}`);
-    
-    // The server expects contentType in the JSON body, NOT as a header
-    // This contentType must match the Content-Type header used during the actual upload
-    const presignedResponse = await apiClient.post(
-      `/presigned-url/${projectName}/${versionName}/${fileName}`,
-      { contentType: 'application/zip' },  // Send contentType in the body
-      {
-        headers: {
-          'Content-Type': 'application/json',  // Request body is JSON
-        },
-      }
-    );
-
-    const presignedUrlDuration = Date.now() - presignedUrlStartTime;
-    console.log(`[TIMING] Presigned URL request: ${presignedUrlDuration}ms`);
-    console.log(`[DEBUG] Presigned URL response status: ${presignedResponse.status}`);
-    console.log(`[DEBUG] Presigned URL response data: ${JSON.stringify(presignedResponse.data)}`);
-
-    const presignedUrl = presignedResponse.data.url;
-    if (!presignedUrl || typeof presignedUrl !== 'string' || presignedUrl.trim() === '') {
+    const presignedUrl = await requestPresignedUrl(apiClient, { project, version }, { fileName, contentType });
+    const upload = await putToPresignedUrl(presignedUrl, fileBuffer, contentType);
+    return { success: true, url: presignedUrl, status: upload.status };
+  } catch (error) {
+    if (error.response) {
       throw new ApiError(
-        `Failed to get valid presigned URL from server response. ` +
-        `Received: ${JSON.stringify(presignedResponse.data)}`
+        `Failed to upload file: ${error.response.status} ${error.response.statusText}${error.response.data ? ` - ${JSON.stringify(error.response.data)}` : ''}`,
+        error.response.status
       );
+    } else if (error.request) {
+      throw new ApiError(`Failed to upload file: No response from server at ${apiClient.defaults.baseURL}`);
+    } else {
+      throw new ApiError(`Failed to upload file: ${error.message}`);
     }
+  }
+}
 
-    // Validate URL format
-    try {
-      new URL(presignedUrl);
-    } catch (urlError) {
-      throw new ApiError(
-        `Received invalid URL format from server: "${presignedUrl}". ` +
-        `URL validation error: ${urlError.message}`
-      );
-    }
+/**
+ * Upload coverage report via the coverage attach endpoint.
+ * This uploads the JSON to R2 and attaches normalized coverage to the build.
+ *
+ * @param {axios.AxiosInstance} apiClient
+ * @param {{project: string, version: string}} target
+ * @param {any} coverageReport
+ * @returns {Promise<{success: boolean, buildId?: string, coverageUrl?: string}>}
+ */
+async function uploadCoverageReportDirectly(apiClient, target, coverageReport) {
+  const projectName = target.project || 'main';
+  const versionName = target.version || 'latest';
 
-    console.log(`[DEBUG] Received presigned URL, uploading file...`);
-    console.log(`[DEBUG] Presigned URL: ${presignedUrl.substring(0, 100)}...`);
-    console.log(`[DEBUG] File size: ${(fileBuffer.length / 1024 / 1024).toFixed(2)} MB`);
+  try {
+    const response = await apiClient.post(
+      `/upload/${projectName}/${versionName}/coverage`,
+      coverageReport,
+      {
+        headers: {
+          'Content-Type': 'application/json',
+        },
+      }
+    );
 
-    // Step 2: Upload the file to the presigned URL using PUT
-    const uploadStartTime = Date.now();
-    const uploadResponse = await axios.put(presignedUrl, fileBuffer, {
-      headers: {
-        'Content-Type': 'application/zip',
-      },
-      maxContentLength: Infinity,
-      maxBodyLength: Infinity,
-    });
-
-    const uploadDuration = Date.now() - uploadStartTime;
-    const uploadSpeedMbps = ((fileBuffer.length / 1024 / 1024) / (uploadDuration / 1000)).toFixed(2);
-    console.log(`[TIMING] File upload: ${uploadDuration}ms (${uploadSpeedMbps} MB/s)`);
-    console.log(`[DEBUG] File uploaded successfully`);
-    
-    return { success: true, url: presignedUrl, status: uploadResponse.status };
+    return {
+      success: response.data?.success ?? true,
+      buildId: response.data?.buildId,
+      coverageUrl: response.data?.coverageUrl,
+    };
   } catch (error) {
     if (error.response) {
-      throw new ApiError(`Failed to upload file: ${error.response.status} ${error.response.statusText}${error.response.data ? ` - ${JSON.stringify(error.response.data)}` : ''}`, error.response.status);
+      throw new ApiError(
+        `Failed to upload coverage: ${error.response.status} ${error.response.statusText}${error.response.data ? ` - ${JSON.stringify(error.response.data)}` : ''}`,
+        error.response.status
+      );
     } else if (error.request) {
-      throw new ApiError(`Failed to upload file: No response from server at ${apiClient.defaults.baseURL}`);
+      throw new ApiError(`Failed to upload coverage: No response from server at ${apiClient.defaults.baseURL}`);
     } else {
-      throw new ApiError(`Failed to upload file: ${error.message}`);
+      throw new ApiError(`Failed to upload coverage: ${error.message}`);
     }
   }
 }
 
+/**
+ * Upload storybook zip plus optional coverage report.
+ *
+ * NOTE: The backend currently supports uploads via presigned URLs only.
+ * This helper keeps the orchestration in one place.
+ *
+ * @param {axios.AxiosInstance} apiClient
+ * @param {{project: string, version: string}} target
+ * @param {{zipPath: string, coverageReport?: any|null}} options
+ */
+async function uploadBuild(apiClient, target, options) {
+  const zipUpload = await uploadFileDirectly(apiClient, target, options.zipPath, {
+    fileName: 'storybook.zip',
+    contentType: 'application/zip',
+  });
+
+  let coverageUpload = null;
+  if (options.coverageReport) {
+    coverageUpload = await uploadCoverageReportDirectly(apiClient, target, options.coverageReport);
+  }
+
+  return { zipUpload, coverageUpload };
+}
+
 module.exports = {
   getApiClient,
   uploadFileDirectly,
+  uploadCoverageReportDirectly,
+  uploadBuild,
+  requestPresignedUrl,
+  putToPresignedUrl,
 };

package/lib/config.js

@@ -27,7 +27,12 @@ const DEFAULT_CONFIG = {
     include: undefined,
     exclude: undefined,
     omitBackground: true
-  }
+  },
+  // Coverage options (enabled by default)
+  coverage: true,
+  coverageReport: null,
+  coverageFailOnThreshold: false,
+  coverageBase: 'main'
 };
 
 /**
@@ -102,7 +107,7 @@ function detectGitHubActionsContext() {
  */
 function loadEnvConfig() {
   const envConfig = {};
-  
+
   // Map environment variable names to config keys
   const envMapping = {
     'API_URL': 'apiUrl',
@@ -116,14 +121,14 @@ function loadEnvConfig() {
     'SCREENSHOTS_DIR': 'screenshotsDir',
     'STORYBOOK_URL': 'storybookUrl'
   };
-  
+
   Object.keys(envMapping).forEach(envKey => {
     const configKey = envMapping[envKey];
-    
+
     // Check SCRY_ prefix first (new standard), then fall back to STORYBOOK_DEPLOYER_ for backward compatibility
     const scryEnvKey = 'SCRY_' + envKey;
     const legacyEnvKey = 'STORYBOOK_DEPLOYER_' + envKey;
-    
+
     // Handle special case for PROJECT_ID vs PROJECT
     let envValue = process.env[scryEnvKey];
     if (!envValue && envKey === 'PROJECT') {
@@ -132,7 +137,7 @@ function loadEnvConfig() {
     if (!envValue) {
       envValue = process.env[legacyEnvKey];
     }
-    
+
     // Filter out undefined and empty string values to prevent overriding CLI args
     if (envValue !== undefined && envValue !== '') {
       // Convert string values to appropriate types
@@ -143,7 +148,27 @@ function loadEnvConfig() {
       }
     }
   });
-  
+
+  // Coverage env vars (spec names)
+  if (process.env.SCRY_COVERAGE_ENABLED !== undefined && process.env.SCRY_COVERAGE_ENABLED !== '') {
+    envConfig.coverage = process.env.SCRY_COVERAGE_ENABLED.toLowerCase() !== 'false';
+  }
+
+  if (process.env.SCRY_COVERAGE_REPORT !== undefined && process.env.SCRY_COVERAGE_REPORT !== '') {
+    envConfig.coverageReport = process.env.SCRY_COVERAGE_REPORT;
+  }
+
+  if (
+    process.env.SCRY_COVERAGE_FAIL_ON_THRESHOLD !== undefined &&
+    process.env.SCRY_COVERAGE_FAIL_ON_THRESHOLD !== ''
+  ) {
+    envConfig.coverageFailOnThreshold = process.env.SCRY_COVERAGE_FAIL_ON_THRESHOLD.toLowerCase() === 'true';
+  }
+
+  if (process.env.SCRY_COVERAGE_BASE !== undefined && process.env.SCRY_COVERAGE_BASE !== '') {
+    envConfig.coverageBase = process.env.SCRY_COVERAGE_BASE;
+  }
+
   return envConfig;
 }
 
@@ -153,7 +178,7 @@ function loadEnvConfig() {
 function loadConfig(cliArgs = {}) {
   const configPath = getConfigPath();
   let fileConfig = {};
-  
+
   if (fs.existsSync(configPath)) {
     try {
       const configContent = fs.readFileSync(configPath, 'utf8');
@@ -162,31 +187,23 @@ function loadConfig(cliArgs = {}) {
       console.warn(`⚠️  Could not read config file at ${configPath}: ${error.message}`);
     }
   }
-  
+
   // Load environment variables
   const envConfig = loadEnvConfig();
-  
+
   // Detect GitHub Actions context
   const githubContext = detectGitHubActionsContext();
-  
-  // Log configuration sources for debugging
-  console.log('[CONFIG] Configuration sources:');
-  console.log(`[CONFIG] - Default apiUrl: ${DEFAULT_CONFIG.apiUrl}`);
-  console.log(`[CONFIG] - File config apiUrl: ${fileConfig.apiUrl || 'not set'}`);
-  console.log(`[CONFIG] - Env SCRY_API_URL: ${process.env.SCRY_API_URL || 'not set'}`);
-  console.log(`[CONFIG] - Env STORYBOOK_DEPLOYER_API_URL: ${process.env.STORYBOOK_DEPLOYER_API_URL || 'not set'}`);
-  console.log(`[CONFIG] - CLI args apiUrl: ${cliArgs.apiUrl || 'not set'}`);
-  
+
   // Precedence: CLI arguments > GitHub Actions context > environment variables > file config > defaults
   // This ensures GitHub Actions auto-detection works even if env vars are set to empty strings
-  
+
   // Map 'deployVersion' (from yargs --deploy-version) to 'version' for internal use
   const normalizedCliArgs = { ...cliArgs };
   if (normalizedCliArgs.deployVersion) {
     normalizedCliArgs.version = normalizedCliArgs.deployVersion;
     delete normalizedCliArgs.deployVersion;
   }
-  
+
   const finalConfig = {
     ...DEFAULT_CONFIG,
     ...fileConfig,
@@ -194,11 +211,22 @@ function loadConfig(cliArgs = {}) {
     ...githubContext,
     ...normalizedCliArgs
   };
-  
-  console.log(`[CONFIG] Final apiUrl: ${finalConfig.apiUrl}`);
-  console.log(`[CONFIG] Final project: ${finalConfig.project}`);
-  console.log(`[CONFIG] Final version: ${finalConfig.version}`);
-  
+
+  const debugConfig = Boolean(finalConfig.verbose);
+  if (debugConfig) {
+    // Log configuration sources for debugging
+    console.log('[CONFIG] Configuration sources:');
+    console.log(`[CONFIG] - Default apiUrl: ${DEFAULT_CONFIG.apiUrl}`);
+    console.log(`[CONFIG] - File config apiUrl: ${fileConfig.apiUrl || 'not set'}`);
+    console.log(`[CONFIG] - Env SCRY_API_URL: ${process.env.SCRY_API_URL || 'not set'}`);
+    console.log(`[CONFIG] - Env STORYBOOK_DEPLOYER_API_URL: ${process.env.STORYBOOK_DEPLOYER_API_URL || 'not set'}`);
+    console.log(`[CONFIG] - CLI args apiUrl: ${cliArgs.apiUrl || 'not set'}`);
+    console.log(`[CONFIG] Final apiUrl: ${finalConfig.apiUrl}`);
+    console.log(`[CONFIG] Final project: ${finalConfig.project}`);
+    console.log(`[CONFIG] Final version: ${finalConfig.version}`);
+    console.log(`[CONFIG] Final coverage: ${finalConfig.coverage}`);
+  }
+
   return finalConfig;
 }
 

package/lib/coverage.js

@@ -0,0 +1,188 @@
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+
+/**
+ * @typedef {Object} RunCoverageOptions
+ * @property {string} storybookDir Path to a built Storybook static directory (e.g. ./storybook-static)
+ * @property {string} [baseBranch='main'] Base branch name to compare for "new code" analysis
+ * @property {boolean} [failOnThreshold=false] If true, pass "--ci" to the coverage tool and rethrow errors
+ */
+
+/**
+ * Run Storybook coverage analysis via `@scrymore/scry-sbcov`.
+ *
+ * Behavior:
+ * - Writes a temporary report file in the current working directory
+ * - Executes the `@scrymore/scry-sbcov` CLI
+ * - Reads and returns the parsed JSON report
+ * - Deletes the temporary report file
+ *
+ * If the underlying tool fails and `failOnThreshold` is false, returns `null`.
+ *
+ * @param {RunCoverageOptions} options
+ * @returns {Promise<any|null>} The full coverage report JSON, or null if skipped/failed (non-fatal)
+ */
+async function runCoverageAnalysis(options) {
+  const { storybookDir, baseBranch = 'main', failOnThreshold = false, execute = false } = options || {};
+
+  if (!storybookDir || typeof storybookDir !== 'string') {
+    throw new Error('runCoverageAnalysis: options.storybookDir is required');
+  }
+
+  console.log(chalk.blue('Running Storybook coverage analysis...'));
+
+  const outputPath = path.join(process.cwd(), `.scry-coverage-report-${Date.now()}.json`);
+
+  /** @type {string[]} */
+  const cliArgs = [
+    '--storybook-static',
+    storybookDir,
+    '--output',
+    outputPath,
+    '--base',
+    `origin/${baseBranch}`,
+    '--verbose', // Enable verbose logging to debug component detection
+  ];
+
+  if (failOnThreshold) {
+    cliArgs.push('--ci');
+  }
+
+  if (execute) {
+    cliArgs.push('--execute');
+  }
+
+  // Use npx with -p flag to ensure package is installed, then run the binary
+  // This is more reliable than `npx @scrymore/scry-sbcov` which can fail to find the binary
+  const npxCommand = `npx -y -p @scrymore/scry-sbcov scry-sbcov ${cliArgs.map(shellEscape).join(' ')}`;
+
+  // Debug logging to show the exact command being executed
+  console.log(chalk.yellow('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log(chalk.yellow('DEBUG: Executing coverage command:'));
+  console.log(chalk.gray(npxCommand));
+  console.log(chalk.yellow('Working directory: ' + process.cwd()));
+  console.log(chalk.yellow('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+
+  try {
+    // Determine the correct working directory
+    // If storybookDir is relative, resolve it from cwd
+    // Then use its parent directory as the project root
+    const absoluteStorybookDir = path.isAbsolute(storybookDir)
+      ? storybookDir
+      : path.resolve(process.cwd(), storybookDir);
+    
+    const projectRoot = path.dirname(absoluteStorybookDir);
+    
+    console.log(chalk.yellow('Project root: ' + projectRoot));
+    console.log(chalk.yellow('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n'));
+
+    execSync(npxCommand, {
+      stdio: 'inherit',
+      cwd: projectRoot // Run from the project root, not scry-node directory
+    });
+
+    const raw = fs.readFileSync(outputPath, 'utf-8');
+    const report = JSON.parse(raw);
+
+    safeUnlink(outputPath);
+    return report;
+  } catch (error) {
+    safeUnlink(outputPath);
+    if (failOnThreshold) throw error;
+    return null;
+  }
+}
+
+/**
+ * Load a coverage report from disk.
+ *
+ * @param {string} reportPath
+ * @returns {any}
+ */
+function loadCoverageReport(reportPath) {
+  if (!reportPath || typeof reportPath !== 'string') {
+    throw new Error('loadCoverageReport: reportPath is required');
+  }
+  const raw = fs.readFileSync(reportPath, 'utf-8');
+  return JSON.parse(raw);
+}
+
+/**
+ * Extracts a stable, API-friendly subset of the full report.
+ *
+ * NOTE: This function is intentionally defensive: if the report shape changes,
+ * we return `null` instead of throwing to avoid breaking deployments.
+ *
+ * @param {any|null} report
+ * @returns {null|{
+ *   reportUrl: string|null,
+ *   summary: {
+ *     componentCoverage: number,
+ *     propCoverage: number,
+ *     variantCoverage: number,
+ *     passRate: number,
+ *     totalComponents: number,
+ *     componentsWithStories: number,
+ *     failingStories: number
+ *   },
+ *   qualityGate: any,
+ *   generatedAt: string
+ * }}
+ */
+function extractCoverageSummary(report) {
+  if (!report) return null;
+
+  try {
+    return {
+      reportUrl: null,
+      summary: {
+        componentCoverage: report.summary.metrics.componentCoverage,
+        propCoverage: report.summary.metrics.propCoverage,
+        variantCoverage: report.summary.metrics.variantCoverage,
+        passRate: report.summary.health.passRate,
+        totalComponents: report.summary.totalComponents,
+        componentsWithStories: report.summary.componentsWithStories,
+        failingStories: report.summary.health.failingStories,
+      },
+      qualityGate: report.qualityGate,
+      generatedAt: report.generatedAt,
+    };
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Best-effort deletion: ignore ENOENT and other fs errors.
+ *
+ * @param {string} filePath
+ */
+function safeUnlink(filePath) {
+  try {
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+    }
+  } catch (_) {
+    // ignore
+  }
+}
+
+/**
+ * Minimal shell escaping for arguments.
+ *
+ * @param {string} value
+ * @returns {string}
+ */
+function shellEscape(value) {
+  if (typeof value !== 'string') return '';
+  if (/^[a-zA-Z0-9_\-./:@]+$/.test(value)) return value;
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+
+module.exports = {
+  runCoverageAnalysis,
+  loadCoverageReport,
+  extractCoverageSummary,
+};

package/lib/logger.js

@@ -8,6 +8,7 @@ const chalk = require('chalk');
  * @returns {{info: Function, error: Function, debug: Function, success: Function}}
  */
 function createLogger({ verbose = false }) {
+  const Sentry = require('@sentry/node');
   return {
     /**
      * Logs an informational message.
@@ -15,6 +16,11 @@ function createLogger({ verbose = false }) {
      */
     info: (message) => {
       console.log(message);
+      Sentry.addBreadcrumb({
+        category: 'log',
+        message: message,
+        level: 'info',
+      });
     },
 
     /**
@@ -31,6 +37,11 @@ function createLogger({ verbose = false }) {
      */
     error: (message) => {
       console.error(chalk.red(message));
+      Sentry.addBreadcrumb({
+        category: 'log',
+        message: message,
+        level: 'error',
+      });
     },
 
     /**
@@ -41,6 +52,11 @@ function createLogger({ verbose = false }) {
       if (verbose) {
         console.log(chalk.dim(`[debug] ${message}`));
       }
+      Sentry.addBreadcrumb({
+        category: 'log',
+        message: message,
+        level: 'debug',
+      });
     },
   };
 }

package/lib/pr-comment.js

@@ -0,0 +1,136 @@
+const { Octokit } = require('@octokit/rest');
+
+const COMMENT_MARKER = '<!-- scry-deployer -->';
+
+/**
+ * Post (create or update) a PR comment with deployment and optional coverage info.
+ *
+ * This function is no-op unless:
+ * - `GITHUB_TOKEN` is set
+ * - The workflow context includes a pull request number
+ *
+ * @param {object} deployResult
+ * @param {any|null} coverageSummary Coverage summary (typically from extractCoverageSummary())
+ * @returns {Promise<void>}
+ */
+async function postPRComment(deployResult, coverageSummary) {
+  const token = process.env.GITHUB_TOKEN;
+  if (!token) return;
+
+  const eventPath = process.env.GITHUB_EVENT_PATH;
+  if (!eventPath) return;
+
+  // eslint-disable-next-line import/no-dynamic-require, global-require
+  const event = require(eventPath);
+  const prNumber = event.pull_request?.number;
+  if (!prNumber) return;
+
+  const repoFull = process.env.GITHUB_REPOSITORY;
+  if (!repoFull || !repoFull.includes('/')) return;
+
+  const [owner, repo] = repoFull.split('/');
+  const octokit = new Octokit({ auth: token });
+
+  const body = formatPRComment(deployResult, coverageSummary);
+
+  // Upsert: update existing marker comment if present, else create new
+  const existing = await findExistingMarkerComment(octokit, owner, repo, prNumber);
+
+  if (existing) {
+    await octokit.rest.issues.updateComment({
+      owner,
+      repo,
+      comment_id: existing.id,
+      body,
+    });
+  } else {
+    await octokit.rest.issues.createComment({
+      owner,
+      repo,
+      issue_number: prNumber,
+      body,
+    });
+  }
+}
+
+/**
+ * Build a deterministic markdown comment body.
+ *
+ * @param {object} deployResult
+ * @param {any|null} coverageSummary
+ * @returns {string}
+ */
+function formatPRComment(deployResult, coverageSummary) {
+  const viewUrl = deployResult?.viewUrl;
+  const coveragePageUrl = deployResult?.coveragePageUrl || deployResult?.coverageUrl;
+
+  let body = `${COMMENT_MARKER}
+## Storybook Deployed
+
+${viewUrl ? `[View Storybook](${viewUrl})` : 'Storybook deployed successfully.'}`;
+
+  if (coverageSummary) {
+    const qualityGate = coverageSummary.qualityGate;
+    const passed = Boolean(qualityGate?.passed);
+    const statusIcon = passed ? '✅' : '❌';
+
+    const m = coverageSummary.summary;
+
+    body += `
+
+---
+
+## Coverage Report
+
+| Metric | Value |
+|--------|-------|
+| Component Coverage | ${formatPercent(m?.componentCoverage)} |
+| Prop Coverage | ${formatPercent(m?.propCoverage)} |
+| Variant Coverage | ${formatPercent(m?.variantCoverage)} |
+| Pass Rate | ${formatPercent(m?.passRate)} |
+
+**Quality Gate:** ${statusIcon} ${passed ? 'PASSED' : 'FAILED'}`;
+
+    if (coveragePageUrl) {
+      body += `
+
+[View Coverage Report](${coveragePageUrl})`;
+    }
+  }
+
+  return body;
+}
+
+/**
+ * Find a previously-posted comment containing our marker.
+ *
+ * @param {import('@octokit/rest').Octokit} octokit
+ * @param {string} owner
+ * @param {string} repo
+ * @param {number} prNumber
+ */
+async function findExistingMarkerComment(octokit, owner, repo, prNumber) {
+  const { data: comments } = await octokit.rest.issues.listComments({
+    owner,
+    repo,
+    issue_number: prNumber,
+    per_page: 100,
+  });
+
+  return comments.find((c) => typeof c.body === 'string' && c.body.includes(COMMENT_MARKER)) || null;
+}
+
+/**
+ * @param {number|undefined|null} value
+ */
+function formatPercent(value) {
+  if (typeof value !== 'number' || Number.isNaN(value)) return 'n/a';
+  return `${value.toFixed(1)}%`;
+}
+
+module.exports = {
+  postPRComment,
+  formatPRComment,
+  findExistingMarkerComment,
+  COMMENT_MARKER,
+};

package/lib/templates.js

@@ -81,7 +81,9 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
-
+        with:
+          fetch-depth: 0  # Required for coverage new-code analysis
+ 
 ${pmSetup}      - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
@@ -95,11 +97,17 @@ ${cache}
         run: ${runCmd}
 
       - name: Deploy to Scry
-        run: npx @scrymore/scry-deployer --dir ./storybook-static
+        run: |
+          npx @scrymore/scry-deployer \\
+            --dir ./storybook-static \\
+            \${{ vars.SCRY_COVERAGE_ENABLED == 'false' && '--no-coverage' || '' }} \\
+            \${{ vars.SCRY_COVERAGE_FAIL_ON_THRESHOLD == 'true' && '--coverage-fail-on-threshold' || '' }} \\
+            --coverage-base \${{ vars.SCRY_COVERAGE_BASE || 'main' }}
         env:
           STORYBOOK_DEPLOYER_API_URL: \${{ vars.SCRY_API_URL }}
           STORYBOOK_DEPLOYER_PROJECT: \${{ vars.SCRY_PROJECT_ID }}
           STORYBOOK_DEPLOYER_API_KEY: \${{ secrets.SCRY_API_KEY }}
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
 `;
 }
 
@@ -132,7 +140,9 @@ jobs:
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
-
+        with:
+          fetch-depth: 0  # Required for coverage new-code analysis
+ 
 ${pmSetup}      - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
@@ -151,8 +161,12 @@ ${cache}
           # Deploy with PR-specific version
           npx @scrymore/scry-deployer \\
             --dir ./storybook-static \\
-            --version pr-\${{ github.event.pull_request.number }}
-
+            --version pr-\${{ github.event.pull_request.number }} \\
+            \${{ github.event.pull_request.draft == true && '--no-coverage' || '' }} \\
+            \${{ vars.SCRY_COVERAGE_ENABLED == 'false' && '--no-coverage' || '' }} \\
+            \${{ vars.SCRY_COVERAGE_FAIL_ON_THRESHOLD == 'true' && '--coverage-fail-on-threshold' || '' }} \\
+            --coverage-base \${{ vars.SCRY_COVERAGE_BASE || 'main' }}
+ 
           # Construct deployment URL using VIEW_URL (where users access the deployed Storybook)
           # Defaults to https://view.scrymore.com if SCRY_VIEW_URL is not set
           PROJECT_ID="\${{ vars.SCRY_PROJECT_ID }}"
@@ -163,61 +177,7 @@ ${cache}
           STORYBOOK_DEPLOYER_API_URL: \${{ vars.SCRY_API_URL }}
           STORYBOOK_DEPLOYER_PROJECT: \${{ vars.SCRY_PROJECT_ID }}
           STORYBOOK_DEPLOYER_API_KEY: \${{ secrets.SCRY_API_KEY }}
-
-      - name: Comment on PR
-        uses: actions/github-script@v7
-        with:
-          script: |
-            const deploymentUrl = '\${{ steps.deploy.outputs.deployment_url }}';
-            const prNumber = context.issue.number;
-            const commitSha = context.payload.pull_request.head.sha.substring(0, 7);
-            const branch = '\${{ github.event.pull_request.head.ref }}';
-            const deployedAt = new Date().toUTCString();
-
-            const commentBody = [
-              '## 🚀 Storybook Preview Deployed',
-              '',
-              '**Preview URL:** ' + deploymentUrl,
-              '',
-              '📌 **Details:**',
-              '- **Commit:** ' + commitSha,
-              '- **Branch:** ' + branch,
-              '- **Deployed at:** ' + deployedAt,
-              '',
-              '> This preview updates automatically on each commit to this PR.'
-            ].join('\\n');
-
-            // Check if a comment from this bot already exists
-            const { data: comments } = await github.rest.issues.listComments({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: prNumber,
-            });
-
-            const botComment = comments.find(comment =>
-              comment.user.type === 'Bot' &&
-              comment.body.includes('🚀 Storybook Preview Deployed')
-            );
-
-            if (botComment) {
-              // Update existing comment
-              await github.rest.issues.updateComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                comment_id: botComment.id,
-                body: commentBody
-              });
-              console.log('Updated existing PR comment');
-            } else {
-              // Create new comment
-              await github.rest.issues.createComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: prNumber,
-                body: commentBody
-              });
-              console.log('Created new PR comment');
-            }
+          GITHUB_TOKEN: \${{ secrets.GITHUB_TOKEN }}
 `;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrymore/scry-deployer",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "A CLI to automate the deployment of Storybook static builds.",
   "main": "index.js",
   "bin": {
@@ -36,6 +36,9 @@
     "node": ">=18"
   },
   "dependencies": {
+    "@octokit/rest": "^20.0.0",
+    "@scrymore/scry-sbcov": "^0.2.1",
+    "@sentry/node": "^10.33.0",
     "archiver": "^7.0.1",
     "axios": "^1.12.2",
     "chalk": "^4.1.2",
@@ -49,10 +52,13 @@
   "devDependencies": {
     "@changesets/changelog-github": "^0.5.2",
     "@changesets/cli": "^2.29.8",
-    "dotenv": "^17.2.2"
+    "dotenv": "^17.2.2",
+    "jest": "^29.7.0"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
     "postinstall": "node scripts/postinstall.js",
     "changeset": "changeset",
     "version": "changeset version",