@vizzly-testing/cli 0.5.0 → 0.7.0

package/README.md

@@ -82,6 +82,7 @@ await vizzlyScreenshot('homepage', screenshot, {
 vizzly upload <directory>           # Upload screenshots from directory
 vizzly upload ./screenshots --wait  # Wait for processing
 vizzly upload ./screenshots --upload-all  # Upload all without deduplication
+vizzly upload ./screenshots --parallel-id "ci-run-123"  # For parallel CI builds
 ```
 
 ### Run Tests with Integration
@@ -90,6 +91,7 @@ vizzly run "npm test"               # Run with Vizzly integration
 vizzly run "pytest" --port 3002     # Custom port
 vizzly run "npm test" --wait        # Wait for build completion
 vizzly run "npm test" --allow-no-token  # Run without API token
+vizzly run "npm test" --parallel-id "ci-run-123"  # For parallel CI builds
 ```
 
 #### Run Command Options
@@ -111,6 +113,9 @@ vizzly run "npm test" --allow-no-token  # Run without API token
 - `--upload-timeout <ms>` - Upload wait timeout in ms
 - `--upload-all` - Upload all screenshots without SHA deduplication
 
+**Parallel Execution:**
+- `--parallel-id <id>` - Unique identifier for parallel test execution (also via `VIZZLY_PARALLEL_ID`)
+
 **Development & Testing:**
 - `--allow-no-token` - Allow running without API token (useful for local development)
 - `--token <token>` - API token override
@@ -123,13 +128,19 @@ For local visual testing with immediate feedback, use the dedicated `tdd` comman
 # First run - creates local baselines
 vizzly tdd "npm test"
 
-# Make changes and test - fails if visual differences detected  
+# Make changes and test - fails if visual differences detected
 vizzly tdd "npm test"
 
 # Accept changes as new baseline
 vizzly tdd "npm test" --set-baseline
 ```
 
+**Interactive HTML Report:** Each TDD run generates a detailed HTML report with visual comparison tools:
+- **Overlay mode** - Toggle between baseline and current screenshots
+- **Side-by-side mode** - Compare baseline and current images horizontally
+- **Onion skin mode** - Drag to reveal differences interactively
+- **Toggle mode** - Click to switch between baseline and current
+
 **TDD Command Options:**
 - `--set-baseline` - Accept current screenshots as new baseline
 - `--baseline-build <id>` - Use specific build as baseline (requires API token)
@@ -144,6 +155,7 @@ vizzly init                         # Create vizzly.config.js with defaults
 vizzly status <build-id>            # Check build progress and results
 vizzly status <build-id> --verbose  # Detailed build information
 vizzly status <build-id> --json     # Machine-readable output
+vizzly finalize <parallel-id>       # Finalize parallel build after all shards complete
 vizzly doctor                       # Fast local preflight (no network)
 vizzly doctor --api                 # Include API connectivity checks
 ```
@@ -203,25 +215,25 @@ export default {
   // API configuration
   // Set VIZZLY_TOKEN environment variable or uncomment and set here:
   // apiToken: 'your-token-here',
-  
+
   // Screenshot configuration
   screenshots: {
     directory: './screenshots',
     formats: ['png']
   },
-  
+
   // Server configuration
   server: {
     port: 47392,
     screenshotPath: '/screenshot'
   },
-  
+
   // Comparison configuration
   comparison: {
     threshold: 0.1,
     ignoreAntialiasing: true
   },
-  
+
   // Upload configuration
   upload: {
     concurrency: 5,
@@ -278,11 +290,42 @@ For CI/CD pipelines, use the `--wait` flag to wait for visual comparison results
   env:
     VIZZLY_TOKEN: ${{ secrets.VIZZLY_TOKEN }}
     # Optional: Provide correct git information from GitHub context
-    VIZZLY_COMMIT_MESSAGE: ${{ github.event.head_commit.message }}
-    VIZZLY_COMMIT_SHA: ${{ github.event.head_commit.id }}
+    VIZZLY_COMMIT_MESSAGE: ${{ github.event.pull_request.head.commit.message || github.event.head_commit.message }}
+    VIZZLY_COMMIT_SHA: ${{ github.event.pull_request.head.sha || github.event.head_commit.id }}
     VIZZLY_BRANCH: ${{ github.head_ref || github.ref_name }}
 ```
 
+### Parallel Builds in CI
+
+For parallel test execution, use `--parallel-id` to ensure all shards contribute to the same build:
+
+```yaml
+# GitHub Actions with parallel matrix
+jobs:
+  e2e-tests:
+    strategy:
+      matrix:
+        shard: [1/4, 2/4, 3/4, 4/4]
+    steps:
+      - name: Run tests with Vizzly
+        run: |
+          npx vizzly run "npm test -- --shard=${{ matrix.shard }}" \
+            --parallel-id="${{ github.run_id }}-${{ github.run_attempt }}"
+        env:
+          VIZZLY_TOKEN: ${{ secrets.VIZZLY_TOKEN }}
+
+  finalize-e2e:
+    needs: e2e-tests
+    runs-on: ubuntu-latest
+    if: always() && needs.e2e-tests.result == 'success'
+    steps:
+      - name: Finalize parallel build
+        run: |
+          npx vizzly finalize "${{ github.run_id }}-${{ github.run_attempt }}"
+        env:
+          VIZZLY_TOKEN: ${{ secrets.VIZZLY_TOKEN }}
+```
+
 ### GitLab CI
 ```yaml
 visual-tests:
@@ -328,6 +371,9 @@ Check if Vizzly is enabled in the current environment.
 - `VIZZLY_API_URL`: Override API base URL. Default: `https://vizzly.dev`.
 - `VIZZLY_LOG_LEVEL`: Logger level. One of `debug`, `info`, `warn`, `error`. Example: `export VIZZLY_LOG_LEVEL=debug`.
 
+### Parallel Builds
+- `VIZZLY_PARALLEL_ID`: Unique identifier for parallel test execution. Example: `export VIZZLY_PARALLEL_ID=ci-run-123`.
+
 ### Git Information Override
 For enhanced CI/CD integration, you can override git detection with these environment variables:
 
@@ -339,8 +385,8 @@ For enhanced CI/CD integration, you can override git detection with these enviro
 **Example for GitHub Actions:**
 ```yaml
 env:
-  VIZZLY_COMMIT_MESSAGE: ${{ github.event.head_commit.message }}
-  VIZZLY_COMMIT_SHA: ${{ github.event.head_commit.id }}
+  VIZZLY_COMMIT_MESSAGE: ${{ github.event.pull_request.head.commit.message || github.event.head_commit.message }}
+  VIZZLY_COMMIT_SHA: ${{ github.event.pull_request.head.sha || github.event.head_commit.id }}
   VIZZLY_BRANCH: ${{ github.head_ref || github.ref_name }}
   VIZZLY_PR_NUMBER: ${{ github.event.pull_request.number }}
 ```

package/dist/cli.js

@@ -6,6 +6,7 @@ import { uploadCommand, validateUploadOptions } from './commands/upload.js';
 import { runCommand, validateRunOptions } from './commands/run.js';
 import { tddCommand, validateTddOptions } from './commands/tdd.js';
 import { statusCommand, validateStatusOptions } from './commands/status.js';
+import { finalizeCommand, validateFinalizeOptions } from './commands/finalize.js';
 import { doctorCommand, validateDoctorOptions } from './commands/doctor.js';
 import { getPackageVersion } from './utils/package-info.js';
 program.name('vizzly').description('Vizzly CLI for visual regression testing').version(getPackageVersion()).option('-c, --config <path>', 'Config file path').option('--token <token>', 'Vizzly API token').option('-v, --verbose', 'Verbose output').option('--json', 'Machine-readable output').option('--no-color', 'Disable colored output');
@@ -16,7 +17,7 @@ program.command('init').description('Initialize Vizzly in your project').option(
     ...options
   });
 });
-program.command('upload').description('Upload screenshots to Vizzly').argument('<path>', 'Path to screenshots directory or file').option('-b, --build-name <name>', 'Build name for grouping').option('-m, --metadata <json>', 'Additional metadata as JSON').option('--batch-size <n>', 'Upload batch size', v => parseInt(v, 10)).option('--upload-timeout <ms>', 'Upload timeout in milliseconds', v => parseInt(v, 10)).option('--branch <branch>', 'Git branch').option('--commit <sha>', 'Git commit SHA').option('--message <msg>', 'Commit message').option('--environment <env>', 'Environment name', 'test').option('--threshold <number>', 'Comparison threshold', parseFloat).option('--token <token>', 'API token override').option('--wait', 'Wait for build completion').option('--upload-all', 'Upload all screenshots without SHA deduplication').action(async (path, options) => {
+program.command('upload').description('Upload screenshots to Vizzly').argument('<path>', 'Path to screenshots directory or file').option('-b, --build-name <name>', 'Build name for grouping').option('-m, --metadata <json>', 'Additional metadata as JSON').option('--batch-size <n>', 'Upload batch size', v => parseInt(v, 10)).option('--upload-timeout <ms>', 'Upload timeout in milliseconds', v => parseInt(v, 10)).option('--branch <branch>', 'Git branch').option('--commit <sha>', 'Git commit SHA').option('--message <msg>', 'Commit message').option('--environment <env>', 'Environment name', 'test').option('--threshold <number>', 'Comparison threshold', parseFloat).option('--token <token>', 'API token override').option('--wait', 'Wait for build completion').option('--upload-all', 'Upload all screenshots without SHA deduplication').option('--parallel-id <id>', 'Unique identifier for parallel test execution').action(async (path, options) => {
   const globalOptions = program.opts();
 
   // Validate options
@@ -59,7 +60,7 @@ program.command('tdd').description('Run tests in TDD mode with local visual comp
   }
   await cleanup();
 });
-program.command('run').description('Run tests with Vizzly integration').argument('<command>', 'Test command to run').option('--port <port>', 'Port for screenshot server', '47392').option('-b, --build-name <name>', 'Custom build name').option('--branch <branch>', 'Git branch override').option('--commit <sha>', 'Git commit SHA').option('--message <msg>', 'Commit message').option('--environment <env>', 'Environment name', 'test').option('--token <token>', 'API token override').option('--wait', 'Wait for build completion').option('--timeout <ms>', 'Server timeout in milliseconds', '30000').option('--allow-no-token', 'Allow running without API token').option('--upload-all', 'Upload all screenshots without SHA deduplication').action(async (command, options) => {
+program.command('run').description('Run tests with Vizzly integration').argument('<command>', 'Test command to run').option('--port <port>', 'Port for screenshot server', '47392').option('-b, --build-name <name>', 'Custom build name').option('--branch <branch>', 'Git branch override').option('--commit <sha>', 'Git commit SHA').option('--message <msg>', 'Commit message').option('--environment <env>', 'Environment name', 'test').option('--token <token>', 'API token override').option('--wait', 'Wait for build completion').option('--timeout <ms>', 'Server timeout in milliseconds', '30000').option('--allow-no-token', 'Allow running without API token').option('--upload-all', 'Upload all screenshots without SHA deduplication').option('--parallel-id <id>', 'Unique identifier for parallel test execution').action(async (command, options) => {
   const globalOptions = program.opts();
 
   // Validate options
@@ -94,6 +95,18 @@ program.command('status').description('Check the status of a build').argument('<
   }
   await statusCommand(buildId, options, globalOptions);
 });
+program.command('finalize').description('Finalize a parallel build after all shards complete').argument('<parallel-id>', 'Parallel ID to finalize').action(async (parallelId, options) => {
+  const globalOptions = program.opts();
+
+  // Validate options
+  const validationErrors = validateFinalizeOptions(parallelId, options);
+  if (validationErrors.length > 0) {
+    console.error('Validation errors:');
+    validationErrors.forEach(error => console.error(`  - ${error}`));
+    process.exit(1);
+  }
+  await finalizeCommand(parallelId, options, globalOptions);
+});
 program.command('doctor').description('Run diagnostics to check your environment and configuration').option('--api', 'Include API connectivity checks').action(async options => {
   const globalOptions = program.opts();
 

package/dist/commands/finalize.js

@@ -0,0 +1,72 @@
+import { loadConfig } from '../utils/config-loader.js';
+import { ConsoleUI } from '../utils/console-ui.js';
+import { createServiceContainer } from '../container/index.js';
+
+/**
+ * Finalize command implementation
+ * @param {string} parallelId - Parallel ID to finalize
+ * @param {Object} options - Command options
+ * @param {Object} globalOptions - Global CLI options
+ */
+export async function finalizeCommand(parallelId, options = {}, globalOptions = {}) {
+  // Create UI handler
+  const ui = new ConsoleUI({
+    json: globalOptions.json,
+    verbose: globalOptions.verbose,
+    color: !globalOptions.noColor
+  });
+  try {
+    // Load configuration with CLI overrides
+    const allOptions = {
+      ...globalOptions,
+      ...options
+    };
+    const config = await loadConfig(globalOptions.config, allOptions);
+
+    // Validate API token
+    if (!config.apiKey) {
+      ui.error('API token required. Use --token or set VIZZLY_TOKEN environment variable');
+      return;
+    }
+    if (globalOptions.verbose) {
+      ui.info('Configuration loaded', {
+        parallelId,
+        apiUrl: config.apiUrl
+      });
+    }
+
+    // Create service container and get API service
+    ui.startSpinner('Finalizing parallel build...');
+    const container = await createServiceContainer(config, 'finalize');
+    const apiService = await container.get('api');
+    ui.stopSpinner();
+
+    // Call finalize endpoint
+    const result = await apiService.finalizeParallelBuild(parallelId);
+    if (globalOptions.json) {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      ui.success(`Parallel build ${result.build.id} finalized successfully`);
+      ui.info(`Status: ${result.build.status}`);
+      ui.info(`Parallel ID: ${result.build.parallel_id}`);
+    }
+  } catch (error) {
+    ui.stopSpinner();
+    ui.error('Failed to finalize parallel build', error);
+  } finally {
+    ui.cleanup();
+  }
+}
+
+/**
+ * Validate finalize options
+ * @param {string} parallelId - Parallel ID to finalize
+ * @param {Object} options - Command options
+ */
+export function validateFinalizeOptions(parallelId, _options) {
+  const errors = [];
+  if (!parallelId || parallelId.trim() === '') {
+    errors.push('Parallel ID is required');
+  }
+  return errors;
+}

package/dist/commands/run.js

@@ -17,15 +17,28 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
     color: !globalOptions.noColor
   });
   let testRunner = null;
-  let runResult = null;
+  let buildId = null;
+  let startTime = null;
+  let isTddMode = false;
 
   // Ensure cleanup on exit
   const cleanup = async () => {
     ui.cleanup();
-    if (testRunner && runResult && runResult.buildId) {
+
+    // Cancel test runner (kills process and stops server)
+    if (testRunner) {
       try {
-        // Try to finalize build on interruption
-        await testRunner.finalizeBuild(runResult.buildId, false, false, Date.now() - (runResult.startTime || Date.now()));
+        await testRunner.cancel();
+      } catch {
+        // Silent fail
+      }
+    }
+
+    // Finalize build if we have one
+    if (testRunner && buildId) {
+      try {
+        const executionTime = Date.now() - (startTime || Date.now());
+        await testRunner.finalizeBuild(buildId, isTddMode, false, executionTime);
       } catch {
         // Silent fail on cleanup
       }
@@ -113,6 +126,7 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
     });
     testRunner.on('build-created', buildInfo => {
       buildUrl = buildInfo.url;
+      buildId = buildInfo.buildId;
       // Debug: Log build creation details
       if (globalOptions.verbose) {
         ui.info(`Build created: ${buildInfo.buildId} - ${buildInfo.name}`);
@@ -148,26 +162,52 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
       allowNoToken: config.allowNoToken || false,
       wait: config.wait || options.wait || false,
       uploadAll: options.uploadAll || false,
-      pullRequestNumber
+      pullRequestNumber,
+      parallelId: config.parallelId
     };
 
     // Start test run
     ui.info('Starting test execution...');
-    runResult = {
-      startTime: Date.now()
-    };
-    const result = await testRunner.run(runOptions);
-    runResult = {
-      ...runResult,
-      ...result
-    };
-    ui.success('Test run completed successfully');
+    startTime = Date.now();
+    isTddMode = runOptions.tdd || false;
+    let result;
+    try {
+      result = await testRunner.run(runOptions);
 
-    // Show Vizzly summary
-    if (result.buildId) {
-      console.log(`🐻 Vizzly: Captured ${result.screenshotsCaptured} screenshots in build ${result.buildId}`);
-      if (result.url) {
-        console.log(`🔗 Vizzly: View results at ${result.url}`);
+      // Store buildId for cleanup purposes
+      if (result.buildId) {
+        buildId = result.buildId;
+      }
+      ui.success('Test run completed successfully');
+
+      // Show Vizzly summary
+      if (result.buildId) {
+        console.log(`🐻 Vizzly: Captured ${result.screenshotsCaptured} screenshots in build ${result.buildId}`);
+        if (result.url) {
+          console.log(`🔗 Vizzly: View results at ${result.url}`);
+        }
+      }
+    } catch (error) {
+      // Test execution failed - build should already be finalized by test runner
+      ui.stopSpinner();
+
+      // Check if it's a test command failure (as opposed to setup failure)
+      if (error.code === 'TEST_COMMAND_FAILED' || error.code === 'TEST_COMMAND_INTERRUPTED') {
+        // Extract exit code from error message if available
+        const exitCodeMatch = error.message.match(/exited with code (\d+)/);
+        const exitCode = exitCodeMatch ? parseInt(exitCodeMatch[1], 10) : 1;
+        ui.error('Test run failed');
+        return {
+          success: false,
+          exitCode
+        };
+      } else {
+        // Setup or other error
+        ui.error('Test run failed', error);
+        return {
+          success: false,
+          exitCode: 1
+        };
       }
     }
 

package/dist/commands/tdd.js

@@ -11,7 +11,6 @@ import { detectBranch, detectCommit } from '../utils/git.js';
  * @returns {Promise<{result: Object, cleanup: Function}>} Result and cleanup function
  */
 export async function tddCommand(testCommand, options = {}, globalOptions = {}) {
-  // Create UI handler
   const ui = new ConsoleUI({
     json: globalOptions.json,
     verbose: globalOptions.verbose,
@@ -43,11 +42,6 @@ export async function tddCommand(testCommand, options = {}, globalOptions = {})
       ui.warning('No API token detected - running in local-only mode');
     }
 
-    // Handle --set-baseline flag
-    if (options.setBaseline) {
-      ui.info('🐻 Baseline update mode - current screenshots will become new baselines');
-    }
-
     // Collect git metadata
     const branch = await detectBranch(options.branch);
     const commit = await detectCommit(options.commit);
@@ -117,19 +111,20 @@ export async function tddCommand(testCommand, options = {}, globalOptions = {})
     });
 
     // Show informational messages about baseline behavior
-    if (config.apiKey) {
-      ui.info('API token available - will fetch baselines for local comparison');
+    if (options.setBaseline) {
+      ui.info('🐻 Baseline update mode - will ignore existing baselines and create new ones');
+    } else if (config.baselineBuildId || config.baselineComparisonId) {
+      ui.info('API token available - will fetch remote baselines for local comparison');
+    } else if (config.apiKey) {
+      ui.info('API token available - will use existing local baselines or create new ones');
     } else {
       ui.warning('Running without API token - all screenshots will be marked as new');
     }
-
-    // Prepare TDD run options (no uploads, local comparisons only)
     const runOptions = {
       testCommand,
       port: config.server.port,
       timeout: config.server.timeout,
       tdd: true,
-      // Enable TDD mode
       setBaseline: options.setBaseline || false,
       // Pass through baseline update mode
       branch,
@@ -142,8 +137,6 @@ export async function tddCommand(testCommand, options = {}, globalOptions = {})
       baselineComparisonId: config.baselineComparisonId,
       wait: false // No build to wait for in TDD mode
     };
-
-    // Start TDD test run (local comparisons only)
     ui.info('Starting TDD test execution...');
     const result = await testRunner.run(runOptions);
 

package/dist/commands/upload.js

@@ -101,6 +101,7 @@ export async function uploadCommand(screenshotsPath, options = {}, globalOptions
       uploadAll: options.uploadAll || false,
       metadata: options.metadata ? JSON.parse(options.metadata) : {},
       pullRequestNumber,
+      parallelId: config.parallelId,
       onProgress: progressData => {
         const {
           message: progressMessage,

package/dist/server/handlers/tdd-handler.js

@@ -2,17 +2,32 @@ import { Buffer } from 'buffer';
 import { createServiceLogger } from '../../utils/logger-factory.js';
 import { TddService } from '../../services/tdd-service.js';
 import { colors } from '../../utils/colors.js';
+import { sanitizeScreenshotName, validateScreenshotProperties } from '../../utils/security.js';
 const logger = createServiceLogger('TDD-HANDLER');
-export const createTddHandler = (config, workingDir, baselineBuild, baselineComparison) => {
-  const tddService = new TddService(config, workingDir);
+export const createTddHandler = (config, workingDir, baselineBuild, baselineComparison, setBaseline = false) => {
+  const tddService = new TddService(config, workingDir, setBaseline);
   const builds = new Map();
   const initialize = async () => {
     logger.info('🔄 TDD mode enabled - setting up local comparison...');
+
+    // In baseline update mode, skip all baseline loading/downloading
+    if (setBaseline) {
+      logger.info('📁 Ready for new baseline creation - all screenshots will be treated as new baselines');
+      return;
+    }
+
+    // Check if we have baseline override flags that should force a fresh download
+    const shouldForceDownload = (baselineBuild || baselineComparison) && config.apiKey;
+    if (shouldForceDownload) {
+      logger.info('📥 Baseline override specified, downloading fresh baselines from Vizzly...');
+      await tddService.downloadBaselines(config.build?.environment || 'test', config.build?.branch || null, baselineBuild, baselineComparison);
+      return;
+    }
     const baseline = await tddService.loadBaseline();
     if (!baseline) {
       if (config.apiKey) {
         logger.info('📥 No local baseline found, downloading from Vizzly...');
-        await tddService.downloadBaselines(baselineBuild, baselineComparison);
+        await tddService.downloadBaselines(config.build?.environment || 'test', config.build?.branch || null, baselineBuild, baselineComparison);
       } else {
         logger.info('📝 No local baseline found and no API token - all screenshots will be marked as new');
       }
@@ -36,15 +51,72 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
     if (!build) {
       throw new Error(`Build ${buildId} not found`);
     }
+
+    // Validate and sanitize screenshot name
+    let sanitizedName;
+    try {
+      sanitizedName = sanitizeScreenshotName(name);
+    } catch (error) {
+      return {
+        statusCode: 400,
+        body: {
+          error: 'Invalid screenshot name',
+          details: error.message,
+          tddMode: true
+        }
+      };
+    }
+
+    // Validate and sanitize properties
+    let validatedProperties;
+    try {
+      validatedProperties = validateScreenshotProperties(properties);
+    } catch (error) {
+      return {
+        statusCode: 400,
+        body: {
+          error: 'Invalid screenshot properties',
+          details: error.message,
+          tddMode: true
+        }
+      };
+    }
+
+    // Create unique screenshot name based on properties
+    let uniqueName = sanitizedName;
+    const relevantProps = [];
+
+    // Add browser to name if provided (already validated)
+    if (validatedProperties.browser) {
+      relevantProps.push(validatedProperties.browser);
+    }
+
+    // Add viewport info if provided (already validated)
+    if (validatedProperties.viewport && validatedProperties.viewport.width && validatedProperties.viewport.height) {
+      relevantProps.push(`${validatedProperties.viewport.width}x${validatedProperties.viewport.height}`);
+    }
+
+    // Combine base name with relevant properties and sanitize the result
+    if (relevantProps.length > 0) {
+      let proposedUniqueName = `${sanitizedName}-${relevantProps.join('-')}`;
+      try {
+        uniqueName = sanitizeScreenshotName(proposedUniqueName);
+      } catch (error) {
+        // If the combined name is invalid, fall back to the base sanitized name
+        uniqueName = sanitizedName;
+        logger.warn(`Combined screenshot name invalid (${error.message}), using base name: ${uniqueName}`);
+      }
+    }
     const screenshot = {
-      name,
+      name: uniqueName,
+      originalName: name,
       imageData: image,
-      properties,
+      properties: validatedProperties,
       timestamp: Date.now()
     };
     build.screenshots.push(screenshot);
     const imageBuffer = Buffer.from(image, 'base64');
-    const comparison = await tddService.compareScreenshot(name, imageBuffer, properties);
+    const comparison = await tddService.compareScreenshot(uniqueName, imageBuffer, validatedProperties);
     if (comparison.status === 'failed') {
       return {
         statusCode: 422,
@@ -56,7 +128,9 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
             status: comparison.status,
             baseline: comparison.baseline,
             current: comparison.current,
-            diff: comparison.diff
+            diff: comparison.diff,
+            diffPercentage: comparison.diffPercentage,
+            threshold: comparison.threshold
           },
           tddMode: true
         }
@@ -112,7 +186,7 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
     if (build.screenshots.length === 0) {
       throw new Error('No screenshots to process. Make sure your tests are calling the Vizzly screenshot function.');
     }
-    const results = tddService.printResults();
+    const results = await tddService.printResults();
     builds.delete(buildId);
     return {
       id: buildId,

package/dist/services/api-service.js

@@ -241,4 +241,18 @@ export class ApiService {
   async getTokenContext() {
     return this.request('/api/sdk/token/context');
   }
+
+  /**
+   * Finalize a parallel build
+   * @param {string} parallelId - Parallel ID to finalize
+   * @returns {Promise<Object>} Finalization result
+   */
+  async finalizeParallelBuild(parallelId) {
+    return this.request(`/api/sdk/parallel/${parallelId}/finalize`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+  }
 }