@vizzly-testing/cli 0.13.4 → 0.15.0

package/dist/commands/run.js

@@ -1,6 +1,6 @@
 import { loadConfig } from '../utils/config-loader.js';
-import { ConsoleUI } from '../utils/console-ui.js';
-import { createServiceContainer } from '../container/index.js';
+import * as output from '../utils/output.js';
+import { createServices } from '../services/index.js';
 import { detectBranch, detectCommit, detectCommitMessage, detectPullRequestNumber, generateBuildNameWithGit } from '../utils/git.js';
 
 /**
@@ -10,8 +10,7 @@ import { detectBranch, detectCommit, detectCommitMessage, detectPullRequestNumbe
  * @param {Object} globalOptions - Global CLI options
  */
 export async function runCommand(testCommand, options = {}, globalOptions = {}) {
-  // Create UI handler
-  const ui = new ConsoleUI({
+  output.configure({
     json: globalOptions.json,
     verbose: globalOptions.verbose,
     color: !globalOptions.noColor
@@ -22,8 +21,8 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
   let isTddMode = false;
 
   // Ensure cleanup on exit
-  const cleanup = async () => {
-    ui.cleanup();
+  let cleanup = async () => {
+    output.cleanup();
 
     // Cancel test runner (kills process and stops server)
     if (testRunner) {
@@ -37,42 +36,37 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
     // Finalize build if we have one
     if (testRunner && buildId) {
       try {
-        const executionTime = Date.now() - (startTime || Date.now());
+        let executionTime = Date.now() - (startTime || Date.now());
         await testRunner.finalizeBuild(buildId, isTddMode, false, executionTime);
       } catch {
         // Silent fail on cleanup
       }
     }
   };
-  const sigintHandler = async () => {
+  let sigintHandler = async () => {
     await cleanup();
     process.exit(1);
   };
-  const exitHandler = () => ui.cleanup();
+  let exitHandler = () => output.cleanup();
   process.on('SIGINT', sigintHandler);
   process.on('exit', exitHandler);
   try {
     // Load configuration with CLI overrides
-    const allOptions = {
+    let allOptions = {
       ...globalOptions,
       ...options
     };
-
-    // Debug: Check options before loadConfig
-    if (process.env.DEBUG_CONFIG) {
-      console.log('[RUN] allOptions.token:', allOptions.token ? allOptions.token.substring(0, 8) + '***' : 'NONE');
-    }
-    const config = await loadConfig(globalOptions.config, allOptions);
-
-    // Debug: Check config immediately after loadConfig
-    if (process.env.DEBUG_CONFIG) {
-      console.log('[RUN] Config after loadConfig:', {
-        hasApiKey: !!config.apiKey,
-        apiKeyPrefix: config.apiKey ? config.apiKey.substring(0, 8) + '***' : 'NONE'
-      });
-    }
+    output.debug('[RUN] Loading config', {
+      hasToken: !!allOptions.token
+    });
+    let config = await loadConfig(globalOptions.config, allOptions);
+    output.debug('[RUN] Config loaded', {
+      hasApiKey: !!config.apiKey,
+      apiKeyPrefix: config.apiKey ? config.apiKey.substring(0, 8) + '***' : 'NONE'
+    });
     if (globalOptions.verbose) {
-      ui.info('Token check:', {
+      output.info('Token check:');
+      output.debug('Token details', {
         hasApiKey: !!config.apiKey,
         apiKeyType: typeof config.apiKey,
         apiKeyPrefix: typeof config.apiKey === 'string' && config.apiKey ? config.apiKey.substring(0, 10) + '...' : 'none',
@@ -83,18 +77,19 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
 
     // Validate API token (unless --allow-no-token is set)
     if (!config.apiKey && !config.allowNoToken) {
-      ui.error('API token required. Use --token, set VIZZLY_TOKEN environment variable, or use --allow-no-token to run without uploading');
-      return;
+      output.error('API token required. Use --token, set VIZZLY_TOKEN environment variable, or use --allow-no-token to run without uploading');
+      process.exit(1);
     }
 
     // Collect git metadata and build info
-    const branch = await detectBranch(options.branch);
-    const commit = await detectCommit(options.commit);
-    const message = options.message || (await detectCommitMessage());
-    const buildName = await generateBuildNameWithGit(options.buildName);
-    const pullRequestNumber = detectPullRequestNumber();
+    let branch = await detectBranch(options.branch);
+    let commit = await detectCommit(options.commit);
+    let message = options.message || (await detectCommitMessage());
+    let buildName = await generateBuildNameWithGit(options.buildName);
+    let pullRequestNumber = detectPullRequestNumber();
     if (globalOptions.verbose) {
-      ui.info('Configuration loaded', {
+      output.info('Configuration loaded');
+      output.debug('Config details', {
         testCommand,
         port: config.server.port,
         timeout: config.server.timeout,
@@ -108,77 +103,68 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
     }
 
     // Create service container and get test runner service
-    ui.startSpinner('Initializing test runner...');
-    const configWithVerbose = {
+    output.startSpinner('Initializing test runner...');
+    let configWithVerbose = {
       ...config,
       verbose: globalOptions.verbose,
       uploadAll: options.uploadAll || false
     };
-
-    // Debug: Check config before creating container
-    if (process.env.DEBUG_CONFIG) {
-      console.log('[RUN] Config before container:', {
-        hasApiKey: !!configWithVerbose.apiKey,
-        apiKeyPrefix: configWithVerbose.apiKey ? configWithVerbose.apiKey.substring(0, 8) + '***' : 'NONE'
-      });
-    }
-    const command = 'run';
-    const container = await createServiceContainer(configWithVerbose, command);
-    testRunner = await container.get('testRunner'); // Assign to outer scope variable
-    ui.stopSpinner();
+    output.debug('[RUN] Creating services', {
+      hasApiKey: !!configWithVerbose.apiKey
+    });
+    let services = createServices(configWithVerbose, 'run');
+    testRunner = services.testRunner;
+    output.stopSpinner();
 
     // Track build URL for display
     let buildUrl = null;
 
     // Set up event handlers
     testRunner.on('progress', progressData => {
-      const {
+      let {
         message: progressMessage
       } = progressData;
-      ui.progress(progressMessage || 'Running tests...');
+      output.progress(progressMessage || 'Running tests...');
     });
-    testRunner.on('test-output', output => {
+    testRunner.on('test-output', data => {
       // In non-JSON mode, show test output directly
       if (!globalOptions.json) {
-        ui.stopSpinner();
-        console.log(output.data);
+        output.stopSpinner();
+        output.print(data.data);
       }
     });
     testRunner.on('server-ready', serverInfo => {
       if (globalOptions.verbose) {
-        ui.info(`Screenshot server running on port ${serverInfo.port}`);
-        ui.info('Server details', serverInfo);
+        output.info(`Screenshot server running on port ${serverInfo.port}`);
+        output.debug('Server details', serverInfo);
       }
     });
     testRunner.on('screenshot-captured', screenshotInfo => {
-      // Use UI for consistent formatting
-      ui.info(`Vizzly: Screenshot captured - ${screenshotInfo.name}`);
+      output.info(`Vizzly: Screenshot captured - ${screenshotInfo.name}`);
     });
     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}`);
+        output.info(`Build created: ${buildInfo.buildId} - ${buildInfo.name}`);
       }
-      // Use UI for consistent formatting
       if (buildUrl) {
-        ui.info(`Vizzly: ${buildUrl}`);
+        output.info(`Vizzly: ${buildUrl}`);
       }
     });
     testRunner.on('build-failed', buildError => {
-      ui.error('Failed to create build', buildError);
+      output.error('Failed to create build', buildError);
     });
     testRunner.on('error', error => {
-      ui.stopSpinner(); // Stop spinner to ensure error is visible
-      ui.error('Test runner error occurred', error, 0); // Don't exit immediately, let runner handle it
+      output.stopSpinner();
+      output.error('Test runner error occurred', error);
     });
     testRunner.on('build-finalize-failed', errorInfo => {
-      ui.warning(`Failed to finalize build ${errorInfo.buildId}: ${errorInfo.error}`);
+      output.warn(`Failed to finalize build ${errorInfo.buildId}: ${errorInfo.error}`);
     });
 
     // Prepare run options
-    const runOptions = {
+    let runOptions = {
       testCommand,
       port: config.server.port,
       timeout: config.server.timeout,
@@ -197,7 +183,7 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
     };
 
     // Start test run
-    ui.info('Starting test execution...');
+    output.info('Starting test execution...');
     startTime = Date.now();
     isTddMode = runOptions.tdd || false;
     let result;
@@ -208,32 +194,32 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
       if (result.buildId) {
         buildId = result.buildId;
       }
-      ui.success('Test run completed successfully');
+      output.success('Test run completed successfully');
 
       // Show Vizzly summary
       if (result.buildId) {
-        console.log(`🐻 Vizzly: Captured ${result.screenshotsCaptured} screenshots in build ${result.buildId}`);
+        output.print(`🐻 Vizzly: Captured ${result.screenshotsCaptured} screenshots in build ${result.buildId}`);
         if (result.url) {
-          console.log(`🔗 Vizzly: View results at ${result.url}`);
+          output.print(`🔗 Vizzly: View results at ${result.url}`);
         }
       }
     } catch (error) {
       // Test execution failed - build should already be finalized by test runner
-      ui.stopSpinner();
+      output.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');
+        let exitCodeMatch = error.message.match(/exited with code (\d+)/);
+        let exitCode = exitCodeMatch ? parseInt(exitCodeMatch[1], 10) : 1;
+        output.error('Test run failed');
         return {
           success: false,
           exitCode
         };
       } else {
         // Setup or other error - VizzlyError.getUserMessage() provides context
-        ui.error('Test run failed', error);
+        output.error('Test run failed', error);
         return {
           success: false,
           exitCode: 1
@@ -245,16 +231,17 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
     if (result.buildId) {
       // Wait for build completion if requested
       if (runOptions.wait) {
-        ui.info('Waiting for build completion...');
-        ui.startSpinner('Processing comparisons...');
-        const uploader = await container.get('uploader');
-        const buildResult = await uploader.waitForBuild(result.buildId);
-        ui.success('Build processing completed');
+        output.info('Waiting for build completion...');
+        output.startSpinner('Processing comparisons...');
+        let {
+          uploader
+        } = services;
+        let buildResult = await uploader.waitForBuild(result.buildId);
+        output.success('Build processing completed');
 
         // Exit with appropriate code based on comparison results
         if (buildResult.failedComparisons > 0) {
-          ui.error(`${buildResult.failedComparisons} visual comparisons failed`, {}, 0);
-          // Return error status without calling process.exit in tests
+          output.error(`${buildResult.failedComparisons} visual comparisons failed`);
           return {
             success: false,
             exitCode: 1
@@ -262,9 +249,9 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
         }
       }
     }
-    ui.cleanup();
+    output.cleanup();
   } catch (error) {
-    ui.stopSpinner(); // Ensure spinner is stopped before showing error
+    output.stopSpinner();
 
     // Provide more context about where the error occurred
     let errorContext = 'Test run failed';
@@ -275,7 +262,8 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
     } else if (error.message && error.message.includes('server')) {
       errorContext = 'Server startup failed';
     }
-    ui.error(errorContext, error);
+    output.error(errorContext, error);
+    process.exit(1);
   } finally {
     // Remove event listeners to prevent memory leaks
     process.removeListener('SIGINT', sigintHandler);
@@ -289,30 +277,30 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
  * @param {Object} options - Command options
  */
 export function validateRunOptions(testCommand, options) {
-  const errors = [];
+  let errors = [];
   if (!testCommand || testCommand.trim() === '') {
     errors.push('Test command is required');
   }
   if (options.port) {
-    const port = parseInt(options.port, 10);
+    let port = parseInt(options.port, 10);
     if (isNaN(port) || port < 1 || port > 65535) {
       errors.push('Port must be a valid number between 1 and 65535');
     }
   }
   if (options.timeout) {
-    const timeout = parseInt(options.timeout, 10);
+    let timeout = parseInt(options.timeout, 10);
     if (isNaN(timeout) || timeout < 1000) {
       errors.push('Timeout must be at least 1000 milliseconds');
     }
   }
   if (options.batchSize !== undefined) {
-    const n = parseInt(options.batchSize, 10);
+    let n = parseInt(options.batchSize, 10);
     if (!Number.isFinite(n) || n <= 0) {
       errors.push('Batch size must be a positive integer');
     }
   }
   if (options.uploadTimeout !== undefined) {
-    const n = parseInt(options.uploadTimeout, 10);
+    let n = parseInt(options.uploadTimeout, 10);
     if (!Number.isFinite(n) || n <= 0) {
       errors.push('Upload timeout must be a positive integer (milliseconds)');
     }

package/dist/commands/status.js

@@ -1,6 +1,6 @@
 import { loadConfig } from '../utils/config-loader.js';
-import { ConsoleUI } from '../utils/console-ui.js';
-import { createServiceContainer } from '../container/index.js';
+import * as output from '../utils/output.js';
+import { createServices } from '../services/index.js';
 import { getApiUrl } from '../utils/environment-config.js';
 
 /**
@@ -10,84 +10,82 @@ import { getApiUrl } from '../utils/environment-config.js';
  * @param {Object} globalOptions - Global CLI options
  */
 export async function statusCommand(buildId, options = {}, globalOptions = {}) {
-  // Create UI handler
-  const ui = new ConsoleUI({
+  output.configure({
     json: globalOptions.json,
     verbose: globalOptions.verbose,
     color: !globalOptions.noColor
   });
-
-  // Note: ConsoleUI handles cleanup via global process listeners
-
   try {
-    ui.info(`Checking status for build: ${buildId}`);
+    output.info(`Checking status for build: ${buildId}`);
 
     // Load configuration with CLI overrides
-    const allOptions = {
+    let allOptions = {
       ...globalOptions,
       ...options
     };
-    const config = await loadConfig(globalOptions.config, allOptions);
+    let 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;
+      output.error('API token required. Use --token or set VIZZLY_TOKEN environment variable');
+      process.exit(1);
     }
 
     // Get API service
-    ui.startSpinner('Fetching build status...');
-    const container = await createServiceContainer(config, 'status');
-    const apiService = await container.get('apiService');
+    output.startSpinner('Fetching build status...');
+    let services = createServices(config, 'status');
+    let {
+      apiService
+    } = services;
 
     // Get build details via unified ApiService
-    const buildStatus = await apiService.getBuild(buildId);
-    ui.stopSpinner();
+    let buildStatus = await apiService.getBuild(buildId);
+    output.stopSpinner();
 
     // Extract build data from API response
-    const build = buildStatus.build || buildStatus;
+    let build = buildStatus.build || buildStatus;
 
     // Display build summary
-    ui.success(`Build: ${build.name || build.id}`);
-    ui.info(`Status: ${build.status.toUpperCase()}`);
-    ui.info(`Environment: ${build.environment}`);
+    output.success(`Build: ${build.name || build.id}`);
+    output.info(`Status: ${build.status.toUpperCase()}`);
+    output.info(`Environment: ${build.environment}`);
     if (build.branch) {
-      ui.info(`Branch: ${build.branch}`);
+      output.info(`Branch: ${build.branch}`);
     }
     if (build.commit_sha) {
-      ui.info(`Commit: ${build.commit_sha.substring(0, 8)} - ${build.commit_message || 'No message'}`);
+      output.info(`Commit: ${build.commit_sha.substring(0, 8)} - ${build.commit_message || 'No message'}`);
     }
 
     // Show screenshot and comparison stats
-    ui.info(`Screenshots: ${build.screenshot_count || 0} total`);
-    ui.info(`Comparisons: ${build.total_comparisons || 0} total (${build.new_comparisons || 0} new, ${build.changed_comparisons || 0} changed, ${build.identical_comparisons || 0} identical)`);
+    output.info(`Screenshots: ${build.screenshot_count || 0} total`);
+    output.info(`Comparisons: ${build.total_comparisons || 0} total (${build.new_comparisons || 0} new, ${build.changed_comparisons || 0} changed, ${build.identical_comparisons || 0} identical)`);
     if (build.approval_status) {
-      ui.info(`Approval Status: ${build.approval_status}`);
+      output.info(`Approval Status: ${build.approval_status}`);
     }
 
     // Show timing information
     if (build.created_at) {
-      ui.info(`Created: ${new Date(build.created_at).toLocaleString()}`);
+      output.info(`Created: ${new Date(build.created_at).toLocaleString()}`);
     }
     if (build.completed_at) {
-      ui.info(`Completed: ${new Date(build.completed_at).toLocaleString()}`);
+      output.info(`Completed: ${new Date(build.completed_at).toLocaleString()}`);
     } else if (build.status !== 'completed' && build.status !== 'failed') {
-      ui.info(`Started: ${new Date(build.started_at || build.created_at).toLocaleString()}`);
+      output.info(`Started: ${new Date(build.started_at || build.created_at).toLocaleString()}`);
     }
     if (build.execution_time_ms) {
-      ui.info(`Execution Time: ${Math.round(build.execution_time_ms / 1000)}s`);
+      output.info(`Execution Time: ${Math.round(build.execution_time_ms / 1000)}s`);
     }
 
     // Show build URL if we can construct it
-    const baseUrl = config.baseUrl || getApiUrl();
+    let baseUrl = config.baseUrl || getApiUrl();
     if (baseUrl && build.project_id) {
-      const buildUrl = baseUrl.replace('/api', '') + `/projects/${build.project_id}/builds/${build.id}`;
-      ui.info(`View Build: ${buildUrl}`);
+      let buildUrl = baseUrl.replace('/api', '') + `/projects/${build.project_id}/builds/${build.id}`;
+      output.info(`View Build: ${buildUrl}`);
     }
 
     // Output JSON data for --json mode
     if (globalOptions.json) {
-      const statusData = {
+      let statusData = {
         buildId: build.id,
         status: build.status,
         name: build.name,
@@ -108,45 +106,46 @@ export async function statusCommand(buildId, options = {}, globalOptions = {}) {
         isBaseline: build.is_baseline,
         userAgent: build.user_agent
       };
-      ui.data(statusData);
+      output.data(statusData);
     }
 
     // Show additional info in verbose mode
     if (globalOptions.verbose) {
-      ui.info('\n--- Additional Details ---');
+      output.info('\n--- Additional Details ---');
       if (build.approved_screenshots > 0 || build.rejected_screenshots > 0 || build.pending_screenshots > 0) {
-        ui.info(`Screenshot Approvals: ${build.approved_screenshots || 0} approved, ${build.rejected_screenshots || 0} rejected, ${build.pending_screenshots || 0} pending`);
+        output.info(`Screenshot Approvals: ${build.approved_screenshots || 0} approved, ${build.rejected_screenshots || 0} rejected, ${build.pending_screenshots || 0} pending`);
       }
       if (build.avg_diff_percentage !== null) {
-        ui.info(`Average Diff: ${(build.avg_diff_percentage * 100).toFixed(2)}%`);
+        output.info(`Average Diff: ${(build.avg_diff_percentage * 100).toFixed(2)}%`);
       }
       if (build.github_pull_request_number) {
-        ui.info(`GitHub PR: #${build.github_pull_request_number}`);
+        output.info(`GitHub PR: #${build.github_pull_request_number}`);
       }
       if (build.is_baseline) {
-        ui.info('This build is marked as a baseline');
+        output.info('This build is marked as a baseline');
       }
-      ui.info(`User Agent: ${build.user_agent || 'Unknown'}`);
-      ui.info(`Build ID: ${build.id}`);
-      ui.info(`Project ID: ${build.project_id}`);
+      output.info(`User Agent: ${build.user_agent || 'Unknown'}`);
+      output.info(`Build ID: ${build.id}`);
+      output.info(`Project ID: ${build.project_id}`);
     }
 
     // Show progress if build is still processing
     if (build.status === 'processing' || build.status === 'pending') {
-      const totalJobs = build.completed_jobs + build.failed_jobs + build.processing_screenshots;
+      let totalJobs = build.completed_jobs + build.failed_jobs + build.processing_screenshots;
       if (totalJobs > 0) {
-        const progress = (build.completed_jobs + build.failed_jobs) / totalJobs;
-        ui.info(`Progress: ${Math.round(progress * 100)}% complete`);
+        let progress = (build.completed_jobs + build.failed_jobs) / totalJobs;
+        output.info(`Progress: ${Math.round(progress * 100)}% complete`);
       }
     }
-    ui.cleanup();
+    output.cleanup();
 
     // Exit with appropriate code based on build status
     if (build.status === 'failed' || build.failed_jobs > 0) {
       process.exit(1);
     }
   } catch (error) {
-    ui.error('Failed to get build status', error);
+    output.error('Failed to get build status', error);
+    process.exit(1);
   }
 }
 
@@ -156,7 +155,7 @@ export async function statusCommand(buildId, options = {}, globalOptions = {}) {
  * @param {Object} options - Command options
  */
 export function validateStatusOptions(buildId) {
-  const errors = [];
+  let errors = [];
   if (!buildId || buildId.trim() === '') {
     errors.push('Build ID is required');
   }