@vizzly-testing/cli 0.14.0 → 0.15.1

package/dist/cli.js

@@ -16,8 +16,8 @@ import { projectSelectCommand, projectListCommand, projectTokenCommand, projectR
 import { getPackageVersion } from './utils/package-info.js';
 import { loadPlugins } from './plugin-loader.js';
 import { loadConfig } from './utils/config-loader.js';
-import { createComponentLogger } from './utils/logger-factory.js';
-import { createServiceContainer } from './container/index.js';
+import { createServices } from './services/index.js';
+import * as output from './utils/output.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');
 
 // Load plugins before defining commands
@@ -32,35 +32,40 @@ for (let i = 0; i < process.argv.length; i++) {
     verboseMode = true;
   }
 }
-let config = await loadConfig(configPath, {});
-let logger = createComponentLogger('CLI', {
-  level: config.logLevel || (verboseMode ? 'debug' : 'warn'),
-  verbose: verboseMode || false
+
+// Configure output early
+output.configure({
+  verbose: verboseMode,
+  color: !process.argv.includes('--no-color'),
+  json: process.argv.includes('--json')
 });
-let container = await createServiceContainer(config);
+let config = await loadConfig(configPath, {});
+let services = createServices(config);
 let plugins = [];
 try {
-  plugins = await loadPlugins(configPath, config, logger);
+  plugins = await loadPlugins(configPath, config);
   for (let plugin of plugins) {
     try {
       // Add timeout protection for plugin registration (5 seconds)
       let registerPromise = plugin.register(program, {
         config,
-        logger,
-        services: container
+        services,
+        output,
+        // Backwards compatibility alias for plugins using old API
+        logger: output
       });
       let timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Plugin registration timeout (5s)')), 5000));
       await Promise.race([registerPromise, timeoutPromise]);
-      logger.debug(`Registered plugin: ${plugin.name}`);
+      output.debug(`Registered plugin: ${plugin.name}`);
     } catch (error) {
-      logger.warn(`Failed to register plugin ${plugin.name}: ${error.message}`);
+      output.warn(`Failed to register plugin ${plugin.name}: ${error.message}`);
     }
   }
 } catch (error) {
-  logger.debug(`Plugin loading failed: ${error.message}`);
+  output.debug(`Plugin loading failed: ${error.message}`);
 }
 program.command('init').description('Initialize Vizzly in your project').option('--force', 'Overwrite existing configuration').action(async options => {
-  const globalOptions = program.opts();
+  let globalOptions = program.opts();
   await init({
     ...globalOptions,
     ...options,
@@ -68,24 +73,24 @@ program.command('init').description('Initialize Vizzly in your project').option(
   });
 });
 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();
+  let globalOptions = program.opts();
 
   // Validate options
-  const validationErrors = validateUploadOptions(path, options);
+  let validationErrors = validateUploadOptions(path, options);
   if (validationErrors.length > 0) {
-    console.error('Validation errors:');
-    validationErrors.forEach(error => console.error(`  - ${error}`));
+    output.error('Validation errors:');
+    validationErrors.forEach(error => output.printErr(`  - ${error}`));
     process.exit(1);
   }
   await uploadCommand(path, options, globalOptions);
 });
 
 // TDD command with subcommands - Local visual testing with interactive dashboard
-const tddCmd = program.command('tdd').description('Run tests in TDD mode with local visual comparisons');
+let tddCmd = program.command('tdd').description('Run tests in TDD mode with local visual comparisons');
 
 // TDD Start - Background server
 tddCmd.command('start').description('Start background TDD server with dashboard').option('--port <port>', 'Port for TDD server', '47392').option('--open', 'Open dashboard in browser').option('--baseline-build <id>', 'Use specific build as baseline').option('--baseline-comparison <id>', 'Use specific comparison as baseline').option('--environment <env>', 'Environment name', 'test').option('--threshold <number>', 'Comparison threshold', parseFloat).option('--timeout <ms>', 'Server timeout in milliseconds', '30000').option('--token <token>', 'API token override').option('--daemon-child', 'Internal: run as daemon child process').action(async options => {
-  const globalOptions = program.opts();
+  let globalOptions = program.opts();
 
   // If this is a daemon child process, run the server directly
   if (options.daemonChild) {
@@ -97,34 +102,34 @@ tddCmd.command('start').description('Start background TDD server with dashboard'
 
 // TDD Stop - Kill background server
 tddCmd.command('stop').description('Stop background TDD server').action(async options => {
-  const globalOptions = program.opts();
+  let globalOptions = program.opts();
   await tddStopCommand(options, globalOptions);
 });
 
 // TDD Status - Check server status
 tddCmd.command('status').description('Check TDD server status').action(async options => {
-  const globalOptions = program.opts();
+  let globalOptions = program.opts();
   await tddStatusCommand(options, globalOptions);
 });
 
 // TDD Run - One-off test run with ephemeral server (generates static report)
 tddCmd.command('run <command>').description('Run tests once in TDD mode with local visual comparisons').option('--port <port>', 'Port for TDD server', '47392').option('--branch <branch>', 'Git branch override').option('--environment <env>', 'Environment name', 'test').option('--threshold <number>', 'Comparison threshold', parseFloat).option('--token <token>', 'API token override').option('--timeout <ms>', 'Server timeout in milliseconds', '30000').option('--baseline-build <id>', 'Use specific build as baseline').option('--baseline-comparison <id>', 'Use specific comparison as baseline').option('--set-baseline', 'Accept current screenshots as new baseline (overwrites existing)').action(async (command, options) => {
-  const globalOptions = program.opts();
+  let globalOptions = program.opts();
 
   // Validate options
-  const validationErrors = validateTddOptions(command, options);
+  let validationErrors = validateTddOptions(command, options);
   if (validationErrors.length > 0) {
-    console.error('Validation errors:');
-    validationErrors.forEach(error => console.error(`  - ${error}`));
+    output.error('Validation errors:');
+    validationErrors.forEach(error => output.printErr(`  - ${error}`));
     process.exit(1);
   }
-  const {
+  let {
     result,
     cleanup
   } = await tddCommand(command, options, globalOptions);
 
   // Set up cleanup on process signals
-  const handleCleanup = async () => {
+  let handleCleanup = async () => {
     await cleanup();
   };
   process.once('SIGINT', () => {
@@ -140,122 +145,119 @@ tddCmd.command('run <command>').description('Run tests once in TDD mode with loc
   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').option('--parallel-id <id>', 'Unique identifier for parallel test execution').action(async (command, options) => {
-  const globalOptions = program.opts();
+  let globalOptions = program.opts();
 
   // Validate options
-  const validationErrors = validateRunOptions(command, options);
+  let validationErrors = validateRunOptions(command, options);
   if (validationErrors.length > 0) {
-    console.error('Validation errors:');
-    validationErrors.forEach(error => console.error(`  - ${error}`));
+    output.error('Validation errors:');
+    validationErrors.forEach(error => output.printErr(`  - ${error}`));
     process.exit(1);
   }
   try {
-    const result = await runCommand(command, options, globalOptions);
+    let result = await runCommand(command, options, globalOptions);
     if (result && !result.success && result.exitCode > 0) {
       process.exit(result.exitCode);
     }
   } catch (error) {
-    console.error('Command failed:', error.message);
-    if (globalOptions.verbose) {
-      console.error('Stack trace:', error.stack);
-    }
+    output.error('Command failed', error);
     process.exit(1);
   }
 });
 program.command('status').description('Check the status of a build').argument('<build-id>', 'Build ID to check status for').action(async (buildId, options) => {
-  const globalOptions = program.opts();
+  let globalOptions = program.opts();
 
   // Validate options
-  const validationErrors = validateStatusOptions(buildId, options);
+  let validationErrors = validateStatusOptions(buildId, options);
   if (validationErrors.length > 0) {
-    console.error('Validation errors:');
-    validationErrors.forEach(error => console.error(`  - ${error}`));
+    output.error('Validation errors:');
+    validationErrors.forEach(error => output.printErr(`  - ${error}`));
     process.exit(1);
   }
   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();
+  let globalOptions = program.opts();
 
   // Validate options
-  const validationErrors = validateFinalizeOptions(parallelId, options);
+  let validationErrors = validateFinalizeOptions(parallelId, options);
   if (validationErrors.length > 0) {
-    console.error('Validation errors:');
-    validationErrors.forEach(error => console.error(`  - ${error}`));
+    output.error('Validation errors:');
+    validationErrors.forEach(error => output.printErr(`  - ${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();
+  let globalOptions = program.opts();
 
   // Validate options
-  const validationErrors = validateDoctorOptions(options);
+  let validationErrors = validateDoctorOptions(options);
   if (validationErrors.length > 0) {
-    console.error('Validation errors:');
-    validationErrors.forEach(error => console.error(`  - ${error}`));
+    output.error('Validation errors:');
+    validationErrors.forEach(error => output.printErr(`  - ${error}`));
     process.exit(1);
   }
   await doctorCommand(options, globalOptions);
 });
 program.command('login').description('Authenticate with your Vizzly account').option('--api-url <url>', 'API URL override').action(async options => {
-  const globalOptions = program.opts();
+  let globalOptions = program.opts();
 
   // Validate options
-  const validationErrors = validateLoginOptions(options);
+  let validationErrors = validateLoginOptions(options);
   if (validationErrors.length > 0) {
-    console.error('Validation errors:');
-    validationErrors.forEach(error => console.error(`  - ${error}`));
+    output.error('Validation errors:');
+    validationErrors.forEach(error => output.printErr(`  - ${error}`));
     process.exit(1);
   }
   await loginCommand(options, globalOptions);
 });
 program.command('logout').description('Clear stored authentication tokens').option('--api-url <url>', 'API URL override').action(async options => {
-  const globalOptions = program.opts();
+  let globalOptions = program.opts();
 
   // Validate options
-  const validationErrors = validateLogoutOptions(options);
+  let validationErrors = validateLogoutOptions(options);
   if (validationErrors.length > 0) {
-    console.error('Validation errors:');
-    validationErrors.forEach(error => console.error(`  - ${error}`));
+    output.error('Validation errors:');
+    validationErrors.forEach(error => output.printErr(`  - ${error}`));
     process.exit(1);
   }
   await logoutCommand(options, globalOptions);
 });
 program.command('whoami').description('Show current authentication status and user information').option('--api-url <url>', 'API URL override').action(async options => {
-  const globalOptions = program.opts();
+  let globalOptions = program.opts();
 
   // Validate options
-  const validationErrors = validateWhoamiOptions(options);
+  let validationErrors = validateWhoamiOptions(options);
   if (validationErrors.length > 0) {
-    console.error('Validation errors:');
-    validationErrors.forEach(error => console.error(`  - ${error}`));
+    output.error('Validation errors:');
+    validationErrors.forEach(error => output.printErr(`  - ${error}`));
     process.exit(1);
   }
   await whoamiCommand(options, globalOptions);
 });
 program.command('project:select').description('Configure project for current directory').option('--api-url <url>', 'API URL override').action(async options => {
-  const globalOptions = program.opts();
+  let globalOptions = program.opts();
 
   // Validate options
-  const validationErrors = validateProjectOptions(options);
+  let validationErrors = validateProjectOptions(options);
   if (validationErrors.length > 0) {
-    console.error('Validation errors:');
-    validationErrors.forEach(error => console.error(`  - ${error}`));
+    output.error('Validation errors:');
+    validationErrors.forEach(error => output.printErr(`  - ${error}`));
     process.exit(1);
   }
   await projectSelectCommand(options, globalOptions);
 });
 program.command('project:list').description('Show all configured projects').action(async options => {
-  const globalOptions = program.opts();
+  let globalOptions = program.opts();
   await projectListCommand(options, globalOptions);
 });
 program.command('project:token').description('Show project token for current directory').action(async options => {
-  const globalOptions = program.opts();
+  let globalOptions = program.opts();
   await projectTokenCommand(options, globalOptions);
 });
 program.command('project:remove').description('Remove project configuration for current directory').action(async options => {
-  const globalOptions = program.opts();
+  let globalOptions = program.opts();
   await projectRemoveCommand(options, globalOptions);
 });
 program.parse();

package/dist/commands/doctor.js

@@ -1,6 +1,6 @@
 import { URL } from 'url';
 import { loadConfig } from '../utils/config-loader.js';
-import { ConsoleUI } from '../utils/console-ui.js';
+import * as output from '../utils/output.js';
 import { ApiService } from '../services/api-service.js';
 import { ConfigError } from '../errors/vizzly-error.js';
 import { getApiToken } from '../utils/environment-config.js';
@@ -11,16 +11,12 @@ import { getApiToken } from '../utils/environment-config.js';
  * @param {Object} globalOptions - Global CLI options
  */
 export async function doctorCommand(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
-
-  const diagnostics = {
+  let diagnostics = {
     environment: {
       nodeVersion: null,
       nodeVersionValid: null
@@ -41,71 +37,71 @@ export async function doctorCommand(options = {}, globalOptions = {}) {
   let hasErrors = false;
   try {
     // Determine if we'll attempt remote checks (API connectivity)
-    const willCheckConnectivity = Boolean(options.api || getApiToken());
+    let willCheckConnectivity = Boolean(options.api || getApiToken());
 
     // Announce preflight, indicating local-only when no token/connectivity is planned
-    ui.info(`Running Vizzly preflight${willCheckConnectivity ? '' : ' (local checks only)'}...`);
+    output.info(`Running Vizzly preflight${willCheckConnectivity ? '' : ' (local checks only)'}...`);
 
     // Node.js version check (require >= 20)
-    const nodeVersion = process.version;
-    const nodeMajor = parseInt(nodeVersion.slice(1).split('.')[0], 10);
+    let nodeVersion = process.version;
+    let nodeMajor = parseInt(nodeVersion.slice(1).split('.')[0], 10);
     diagnostics.environment.nodeVersion = nodeVersion;
     diagnostics.environment.nodeVersionValid = nodeMajor >= 20;
     if (nodeMajor >= 20) {
-      ui.success(`Node.js version: ${nodeVersion} (supported)`);
+      output.success(`Node.js version: ${nodeVersion} (supported)`);
     } else {
       hasErrors = true;
-      ui.error('Node.js version must be >= 20', {}, 0);
+      output.error('Node.js version must be >= 20');
     }
 
     // Load configuration (apply global CLI overrides like --config only)
-    const config = await loadConfig(globalOptions.config);
+    let config = await loadConfig(globalOptions.config);
 
     // Validate apiUrl
     diagnostics.configuration.apiUrl = config.apiUrl;
     try {
-      const url = new URL(config.apiUrl);
+      let url = new URL(config.apiUrl);
       if (!['http:', 'https:'].includes(url.protocol)) {
         throw new ConfigError('URL must use http or https');
       }
       diagnostics.configuration.apiUrlValid = true;
-      ui.success(`API URL: ${config.apiUrl}`);
+      output.success(`API URL: ${config.apiUrl}`);
     } catch (e) {
       diagnostics.configuration.apiUrlValid = false;
       hasErrors = true;
-      ui.error('Invalid apiUrl in configuration (set VIZZLY_API_URL or config file)', e, 0);
+      output.error('Invalid apiUrl in configuration (set VIZZLY_API_URL or config file)', e);
     }
 
     // Validate threshold (0..1 inclusive)
-    const threshold = Number(config?.comparison?.threshold);
+    let threshold = Number(config?.comparison?.threshold);
     diagnostics.configuration.threshold = threshold;
-    const thresholdValid = Number.isFinite(threshold) && threshold >= 0 && threshold <= 1;
+    let thresholdValid = Number.isFinite(threshold) && threshold >= 0 && threshold <= 1;
     diagnostics.configuration.thresholdValid = thresholdValid;
     if (thresholdValid) {
-      ui.success(`Threshold: ${threshold}`);
+      output.success(`Threshold: ${threshold}`);
     } else {
       hasErrors = true;
-      ui.error('Invalid threshold (expected number between 0 and 1)', {}, 0);
+      output.error('Invalid threshold (expected number between 0 and 1)');
     }
 
     // Report effective port without binding
-    const port = config?.server?.port ?? 47392;
+    let port = config?.server?.port ?? 47392;
     diagnostics.configuration.port = port;
-    ui.info(`Effective port: ${port}`);
+    output.info(`Effective port: ${port}`);
 
     // Optional: API connectivity check when --api is provided or VIZZLY_TOKEN is present
-    const autoApi = Boolean(getApiToken());
+    let autoApi = Boolean(getApiToken());
     if (options.api || autoApi) {
       diagnostics.connectivity.checked = true;
       if (!config.apiKey) {
         diagnostics.connectivity.ok = false;
         diagnostics.connectivity.error = 'Missing API token (VIZZLY_TOKEN)';
         hasErrors = true;
-        ui.error('Missing API token for connectivity check', {}, 0);
+        output.error('Missing API token for connectivity check');
       } else {
-        ui.progress('Checking API connectivity...');
+        output.progress('Checking API connectivity...');
         try {
-          const api = new ApiService({
+          let api = new ApiService({
             baseUrl: config.apiUrl,
             token: config.apiKey,
             command: 'doctor'
@@ -115,26 +111,26 @@ export async function doctorCommand(options = {}, globalOptions = {}) {
             limit: 1
           });
           diagnostics.connectivity.ok = true;
-          ui.success('API connectivity OK');
+          output.success('API connectivity OK');
         } catch (err) {
           diagnostics.connectivity.ok = false;
           diagnostics.connectivity.error = err?.message || String(err);
           hasErrors = true;
-          ui.error('API connectivity failed', err, 0);
+          output.error('API connectivity failed', err);
         }
       }
     }
 
     // Summary
     if (hasErrors) {
-      ui.warning('Preflight completed with issues.');
+      output.warn('Preflight completed with issues.');
     } else {
-      ui.success('Preflight passed.');
+      output.success('Preflight passed.');
     }
 
     // Emit structured data in json/verbose modes
     if (globalOptions.json || globalOptions.verbose) {
-      ui.data({
+      output.data({
         passed: !hasErrors,
         diagnostics,
         timestamp: new Date().toISOString()
@@ -142,9 +138,9 @@ export async function doctorCommand(options = {}, globalOptions = {}) {
     }
   } catch (error) {
     hasErrors = true;
-    ui.error('Failed to run preflight', error, 0);
+    output.error('Failed to run preflight', error);
   } finally {
-    ui.cleanup();
+    output.cleanup();
     if (hasErrors) process.exit(1);
   }
 }

package/dist/commands/finalize.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';
 
 /**
  * Finalize command implementation
@@ -9,52 +9,53 @@ import { createServiceContainer } from '../container/index.js';
  * @param {Object} globalOptions - Global CLI options
  */
 export async function finalizeCommand(parallelId, options = {}, globalOptions = {}) {
-  // Create UI handler
-  const ui = new ConsoleUI({
+  output.configure({
     json: globalOptions.json,
     verbose: globalOptions.verbose,
     color: !globalOptions.noColor
   });
   try {
     // 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);
     }
     if (globalOptions.verbose) {
-      ui.info('Configuration loaded', {
+      output.info('Configuration loaded');
+      output.debug('Config details', {
         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('apiService');
-    ui.stopSpinner();
+    // Create services and get API service
+    output.startSpinner('Finalizing parallel build...');
+    let services = createServices(config, 'finalize');
+    let apiService = services.apiService;
+    output.stopSpinner();
 
     // Call finalize endpoint
-    const result = await apiService.finalizeParallelBuild(parallelId);
+    let result = await apiService.finalizeParallelBuild(parallelId);
     if (globalOptions.json) {
-      console.log(JSON.stringify(result, null, 2));
+      output.data(result);
     } else {
-      ui.success(`Parallel build ${result.build.id} finalized successfully`);
-      ui.info(`Status: ${result.build.status}`);
-      ui.info(`Parallel ID: ${result.build.parallel_id}`);
+      output.success(`Parallel build ${result.build.id} finalized successfully`);
+      output.info(`Status: ${result.build.status}`);
+      output.info(`Parallel ID: ${result.build.parallel_id}`);
     }
   } catch (error) {
-    ui.stopSpinner();
-    ui.error('Failed to finalize parallel build', error);
+    output.stopSpinner();
+    output.error('Failed to finalize parallel build', error);
+    process.exit(1);
   } finally {
-    ui.cleanup();
+    output.cleanup();
   }
 }
 
@@ -64,7 +65,7 @@ export async function finalizeCommand(parallelId, options = {}, globalOptions =
  * @param {Object} options - Command options
  */
 export function validateFinalizeOptions(parallelId, _options) {
-  const errors = [];
+  let errors = [];
   if (!parallelId || parallelId.trim() === '') {
     errors.push('Parallel ID is required');
   }