@vizzly-testing/cli 0.14.0 → 0.15.1

package/dist/sdk/index.js

@@ -16,7 +16,7 @@ import { createUploader } from '../services/uploader.js';
 import { createTDDService } from '../services/tdd-service.js';
 import { ScreenshotServer } from '../services/screenshot-server.js';
 import { loadConfig } from '../utils/config-loader.js';
-import { createComponentLogger } from '../utils/logger-factory.js';
+import * as output from '../utils/output.js';
 import { VizzlyError } from '../errors/vizzly-error.js';
 
 /**
@@ -53,21 +53,21 @@ import { VizzlyError } from '../errors/vizzly-error.js';
  * await vizzly.stop();
  */
 export function createVizzly(config = {}, options = {}) {
-  const logger = options.logger || createComponentLogger('SDK', {
-    level: options.logLevel || 'info',
+  // Configure output based on options
+  output.configure({
     verbose: options.verbose || false
   });
 
   // Merge with loaded config
-  const resolvedConfig = {
+  let resolvedConfig = {
     ...config
   };
 
   /**
    * Initialize SDK with config loading
    */
-  const init = async () => {
-    const fileConfig = await loadConfig();
+  let init = async () => {
+    let fileConfig = await loadConfig();
     Object.assign(resolvedConfig, fileConfig, config); // CLI config takes precedence
     return resolvedConfig;
   };
@@ -75,41 +75,39 @@ export function createVizzly(config = {}, options = {}) {
   /**
    * Create uploader service
    */
-  const createUploaderService = (uploaderOptions = {}) => {
+  let createUploaderService = (uploaderOptions = {}) => {
     return createUploader({
       apiKey: resolvedConfig.apiKey,
       apiUrl: resolvedConfig.apiUrl
     }, {
       ...options,
-      ...uploaderOptions,
-      logger
+      ...uploaderOptions
     });
   };
 
   /**
    * Create TDD service
    */
-  const createTDDServiceInstance = (tddOptions = {}) => {
+  let createTDDServiceInstance = (tddOptions = {}) => {
     return createTDDService(resolvedConfig, {
       ...options,
-      ...tddOptions,
-      logger
+      ...tddOptions
     });
   };
 
   /**
    * Upload screenshots (convenience method)
    */
-  const upload = async uploadOptions => {
-    const uploader = createUploaderService();
+  let upload = async uploadOptions => {
+    let uploader = createUploaderService();
     return uploader.upload(uploadOptions);
   };
 
   /**
    * Start TDD mode (convenience method)
    */
-  const startTDD = async (tddOptions = {}) => {
-    const tddService = createTDDServiceInstance();
+  let startTDD = async (tddOptions = {}) => {
+    let tddService = createTDDServiceInstance();
     return tddService.start(tddOptions);
   };
   return {
@@ -122,7 +120,6 @@ export function createVizzly(config = {}, options = {}) {
     createTDDService: createTDDServiceInstance,
     // Utilities
     loadConfig: () => loadConfig(),
-    createLogger: loggerOptions => createComponentLogger('USER', loggerOptions),
     // Config access
     getConfig: () => ({
       ...resolvedConfig
@@ -151,13 +148,11 @@ export function createVizzly(config = {}, options = {}) {
 export class VizzlySDK extends EventEmitter {
   /**
    * @param {import('../types').VizzlyConfig} config - Configuration
-   * @param {import('../utils/logger').Logger} logger - Logger instance
    * @param {Object} services - Service instances
    */
-  constructor(config, logger, services) {
+  constructor(config, services) {
     super();
     this.config = config;
-    this.logger = logger;
     this.services = services;
     this.server = null;
     this.currentBuildId = null;
@@ -172,7 +167,7 @@ export class VizzlySDK extends EventEmitter {
       await this.server.stop();
       this.server = null;
       this.emit('server:stopped');
-      this.logger.info('Vizzly server stopped');
+      output.debug('Vizzly server stopped');
     }
   }
 
@@ -192,7 +187,7 @@ export class VizzlySDK extends EventEmitter {
    */
   async start() {
     if (this.server) {
-      this.logger.warn('Server already running');
+      output.warn('Server already running');
       return {
         port: this.config.server?.port || 3000,
         url: `http://localhost:${this.config.server?.port || 3000}`
@@ -200,7 +195,7 @@ export class VizzlySDK extends EventEmitter {
     }
 
     // Create a simple build manager for screenshot collection
-    const buildManager = {
+    let buildManager = {
       screenshots: new Map(),
       currentBuildId: null,
       async addScreenshot(buildId, screenshot) {
@@ -213,10 +208,10 @@ export class VizzlySDK extends EventEmitter {
         return this.screenshots.get(buildId) || [];
       }
     };
-    this.server = new ScreenshotServer(this.config, this.logger, buildManager);
+    this.server = new ScreenshotServer(this.config, buildManager);
     await this.server.start();
-    const port = this.config.server?.port || 3000;
-    const serverInfo = {
+    let port = this.config.server?.port || 3000;
+    let serverInfo = {
       port,
       url: `http://localhost:${port}`
     };
@@ -240,15 +235,15 @@ export class VizzlySDK extends EventEmitter {
     }
 
     // Resolve Buffer or file path using shared utility
-    const buffer = resolveImageBuffer(imageBuffer, 'screenshot');
+    let buffer = resolveImageBuffer(imageBuffer, 'screenshot');
 
     // Generate or use provided build ID
-    const buildId = options.buildId || this.currentBuildId || 'default';
+    let buildId = options.buildId || this.currentBuildId || 'default';
     this.currentBuildId = buildId;
 
     // Convert Buffer to base64 for JSON transport
-    const imageBase64 = buffer.toString('base64');
-    const screenshotData = {
+    let imageBase64 = buffer.toString('base64');
+    let screenshotData = {
       buildId,
       name,
       image: imageBase64,
@@ -256,9 +251,9 @@ export class VizzlySDK extends EventEmitter {
     };
 
     // POST to the local screenshot server
-    const serverUrl = `http://localhost:${this.config.server?.port || 3000}`;
+    let serverUrl = `http://localhost:${this.config.server?.port || 3000}`;
     try {
-      const response = await fetch(`${serverUrl}/screenshot`, {
+      let response = await fetch(`${serverUrl}/screenshot`, {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json'
@@ -266,7 +261,7 @@ export class VizzlySDK extends EventEmitter {
         body: JSON.stringify(screenshotData)
       });
       if (!response.ok) {
-        const errorData = await response.json().catch(() => ({
+        let errorData = await response.json().catch(() => ({
           error: 'Unknown error'
         }));
         throw new VizzlyError(`Screenshot capture failed: ${errorData.error}`, 'SCREENSHOT_FAILED', {
@@ -280,7 +275,7 @@ export class VizzlySDK extends EventEmitter {
         buildId,
         options
       });
-      this.logger.debug(`Screenshot captured: ${name}`);
+      output.debug(`Screenshot captured: ${name}`);
     } catch (error) {
       if (error instanceof VizzlyError) throw error;
       throw new VizzlyError(`Failed to send screenshot to server: ${error.message}`, 'SCREENSHOT_TRANSPORT_ERROR', {
@@ -303,14 +298,12 @@ export class VizzlySDK extends EventEmitter {
         apiKey: this.config.apiKey,
         apiUrl: this.config.apiUrl,
         upload: this.config.upload
-      }, {
-        logger: this.logger
       });
     }
 
     // Get the screenshots directory from config or default
-    const screenshotsDir = options.screenshotsDir || this.config?.upload?.screenshotsDir || './screenshots';
-    const uploadOptions = {
+    let screenshotsDir = options.screenshotsDir || this.config?.upload?.screenshotsDir || './screenshots';
+    let uploadOptions = {
       screenshotsDir,
       buildName: options.buildName || this.config.buildName,
       branch: options.branch || this.config.branch,
@@ -326,7 +319,7 @@ export class VizzlySDK extends EventEmitter {
       }
     };
     try {
-      const result = await this.services.uploader.upload(uploadOptions);
+      let result = await this.services.uploader.upload(uploadOptions);
       this.emit('upload:completed', result);
       return result;
     } catch (error) {
@@ -346,15 +339,13 @@ export class VizzlySDK extends EventEmitter {
   async compare(name, imageBuffer) {
     if (!this.services?.tddService) {
       this.services = this.services || {};
-      this.services.tddService = createTDDService(this.config, {
-        logger: this.logger
-      });
+      this.services.tddService = createTDDService(this.config);
     }
 
     // Resolve Buffer or file path using shared utility
-    const buffer = resolveImageBuffer(imageBuffer, 'compare');
+    let buffer = resolveImageBuffer(imageBuffer, 'compare');
     try {
-      const result = await this.services.tddService.compareScreenshot(name, buffer);
+      let result = await this.services.tddService.compareScreenshot(name, buffer);
       this.emit('comparison:completed', result);
       return result;
     } catch (error) {
@@ -369,7 +360,7 @@ export class VizzlySDK extends EventEmitter {
 
 // Re-export key utilities and errors
 export { loadConfig } from '../utils/config-loader.js';
-export { createLogger } from '../utils/logger.js';
+export * as output from '../utils/output.js';
 
 // Export service creators for advanced usage
 export { createUploader } from '../services/uploader.js';

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

@@ -1,9 +1,8 @@
 import { Buffer } from 'buffer';
 import { existsSync, readFileSync } from 'fs';
 import { resolve } from 'path';
-import { createServiceLogger } from '../../utils/logger-factory.js';
+import * as output from '../../utils/output.js';
 import { detectImageInputType } from '../../utils/image-input-detector.js';
-const logger = createServiceLogger('API-HANDLER');
 
 /**
  * API Handler - Non-blocking screenshot upload
@@ -41,7 +40,7 @@ export const createApiHandler = apiService => {
   let uploadPromises = [];
   const handleScreenshot = async (buildId, name, image, properties = {}) => {
     if (vizzlyDisabled) {
-      logger.debug(`Screenshot captured (Vizzly disabled): ${name}`);
+      output.debug('upload', `${name} (disabled)`);
       return {
         statusCode: 200,
         body: {
@@ -81,7 +80,6 @@ export const createApiHandler = apiService => {
       }
       try {
         imageBuffer = readFileSync(filePath);
-        logger.debug(`Loaded screenshot from file: ${filePath}`);
       } catch (error) {
         return {
           statusCode: 500,
@@ -117,10 +115,8 @@ export const createApiHandler = apiService => {
 
     // Fire upload in background - DON'T AWAIT!
     const uploadPromise = apiService.uploadScreenshot(buildId, name, imageBuffer, properties ?? {}).then(result => {
-      if (result.skipped) {
-        logger.debug(`Screenshot already exists, skipped: ${name}`);
-      } else {
-        logger.debug(`Screenshot uploaded: ${name}`);
+      if (!result.skipped) {
+        output.debug('upload', name);
       }
       return {
         success: true,
@@ -128,10 +124,11 @@ export const createApiHandler = apiService => {
         result
       };
     }).catch(uploadError => {
-      logger.error(`❌ Failed to upload screenshot ${name}:`, uploadError.message);
+      output.debug('upload', `${name} failed`, {
+        error: uploadError.message
+      });
       vizzlyDisabled = true;
-      const disabledMessage = '⚠️  Vizzly disabled due to upload error - continuing tests without visual testing';
-      logger.warn(disabledMessage);
+      output.warn('Vizzly disabled due to upload error - continuing tests without visual testing');
       return {
         success: false,
         name,
@@ -160,14 +157,13 @@ export const createApiHandler = apiService => {
    */
   const flush = async () => {
     if (uploadPromises.length === 0) {
-      logger.debug('No uploads to flush');
       return {
         uploaded: 0,
         failed: 0,
         total: 0
       };
     }
-    logger.debug(`Flushing ${uploadPromises.length} background uploads...`);
+    output.debug('upload', `flushing ${uploadPromises.length} uploads`);
     const results = await Promise.allSettled(uploadPromises);
     let uploaded = 0;
     let failed = 0;
@@ -178,7 +174,10 @@ export const createApiHandler = apiService => {
         failed++;
       }
     });
-    logger.debug(`Upload flush complete: ${uploaded} uploaded, ${failed} failed`);
+    output.debug('upload', 'flush complete', {
+      uploaded,
+      failed
+    });
 
     // Clear promises array
     uploadPromises = [];
@@ -192,7 +191,7 @@ export const createApiHandler = apiService => {
     vizzlyDisabled = false;
     screenshotCount = 0;
     uploadPromises = [];
-    logger.debug('API handler cleanup completed');
+    // Silent cleanup
   };
   return {
     handleScreenshot,

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

@@ -2,14 +2,13 @@ import { Buffer } from 'buffer';
 import { writeFileSync, readFileSync, existsSync } from 'fs';
 import { join, resolve } from 'path';
 import honeydiff from '@vizzly-testing/honeydiff';
-import { createServiceLogger } from '../../utils/logger-factory.js';
+import * as output from '../../utils/output.js';
 import { TddService } from '../../services/tdd-service.js';
 import { sanitizeScreenshotName, validateScreenshotProperties } from '../../utils/security.js';
 import { detectImageInputType } from '../../utils/image-input-detector.js';
 let {
   getDimensionsSync
 } = honeydiff;
-const logger = createServiceLogger('TDD-HANDLER');
 
 /**
  * Group comparisons by screenshot name with variant structure
@@ -115,7 +114,7 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
       const data = readFileSync(reportPath, 'utf8');
       return JSON.parse(data);
     } catch (error) {
-      logger.error('Failed to read report data:', error);
+      output.error('Failed to read report data:', error);
       return {
         timestamp: Date.now(),
         comparisons: [],
@@ -144,10 +143,8 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
       const existingIndex = reportData.comparisons.findIndex(c => c.id === newComparison.id);
       if (existingIndex >= 0) {
         reportData.comparisons[existingIndex] = newComparison;
-        logger.debug(`Updated comparison for ${newComparison.name} (${newComparison.properties?.viewport_width}x${newComparison.properties?.viewport_height})`);
       } else {
         reportData.comparisons.push(newComparison);
-        logger.debug(`Added new comparison for ${newComparison.name} (${newComparison.properties?.viewport_width}x${newComparison.properties?.viewport_height})`);
       }
 
       // Generate grouped structure from flat comparisons
@@ -163,24 +160,23 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
         errors: reportData.comparisons.filter(c => c.status === 'error').length
       };
       writeFileSync(reportPath, JSON.stringify(reportData, null, 2));
-      logger.debug('Report data saved with grouped structure');
     } catch (error) {
-      logger.error('Failed to update comparison:', error);
+      output.error('Failed to update comparison:', error);
     }
   };
   const initialize = async () => {
-    logger.debug('TDD mode enabled - setting up local comparison');
+    output.debug('tdd', 'setting up local comparison');
 
     // In baseline update mode, skip all baseline loading/downloading
     if (setBaseline) {
-      logger.debug('Ready for new baseline creation - all screenshots will be treated as new baselines');
+      output.debug('tdd', 'baseline update mode');
       return;
     }
 
     // Check if we have baseline override flags that should force a fresh download
     const shouldForceDownload = (baselineBuild || baselineComparison) && config.apiKey;
     if (shouldForceDownload) {
-      logger.debug('Baseline override specified, downloading fresh baselines from Vizzly');
+      output.debug('tdd', 'downloading baselines from cloud');
       await tddService.downloadBaselines(config.build?.environment || 'test', config.build?.branch || null, baselineBuild, baselineComparison);
       return;
     }
@@ -188,13 +184,13 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
     if (!baseline) {
       // Only download baselines if explicitly requested via baseline flags
       if ((baselineBuild || baselineComparison) && config.apiKey) {
-        logger.debug('No local baseline found, downloading from Vizzly');
+        output.debug('tdd', 'downloading baselines from cloud');
         await tddService.downloadBaselines(config.build?.environment || 'test', config.build?.branch || null, baselineBuild, baselineComparison);
       } else {
-        logger.debug('No local baseline found - will create new baselines from first screenshots');
+        output.debug('tdd', 'no baselines found, will create on first run');
       }
     } else {
-      logger.debug(`Using existing baseline: ${baseline.buildName}`);
+      output.debug('tdd', `using baseline: ${baseline.buildName}`);
     }
   };
   const handleScreenshot = async (buildId, name, image, properties = {}) => {
@@ -275,7 +271,6 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
       }
       try {
         imageBuffer = readFileSync(filePath);
-        logger.debug(`Loaded screenshot from file: ${filePath}`);
       } catch (error) {
         return {
           statusCode: 500,
@@ -321,16 +316,16 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
         if (!extractedProperties.viewport_height) {
           extractedProperties.viewport_height = dimensions.height;
         }
-        logger.debug(`Auto-detected dimensions: ${dimensions.width}x${dimensions.height}`);
-      } catch (err) {
-        logger.debug(`Failed to auto-detect dimensions: ${err.message}`);
+      } catch {
+        // Dimensions will use defaults
       }
     }
 
     // Use the sanitized name as-is (no modification with browser/viewport)
     // Baseline matching uses signature logic (name + viewport_width + browser)
     const comparison = await tddService.compareScreenshot(sanitizedName, imageBuffer, extractedProperties);
-    logger.debug(`Comparison result: ${comparison.status}`);
+
+    // Comparison tracked by tdd.js event handler
 
     // Convert absolute file paths to web-accessible URLs
     const convertPathToUrl = filePath => {
@@ -409,7 +404,8 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
         }
       };
     }
-    logger.debug(`✅ TDD: ${comparison.status.toUpperCase()} ${name}`);
+
+    // Debug output handled by tdd.js event handler
     return {
       statusCode: 200,
       body: {
@@ -445,16 +441,16 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
         diff: null
       };
       updateComparison(updatedComparison);
-      logger.info(`Baseline accepted for comparison ${comparisonId}`);
+      output.info(`Baseline accepted for comparison ${comparisonId}`);
       return result;
     } catch (error) {
-      logger.error(`Failed to accept baseline for ${comparisonId}:`, error);
+      output.error(`Failed to accept baseline for ${comparisonId}:`, error);
       throw error;
     }
   };
   const acceptAllBaselines = async () => {
     try {
-      logger.debug('Accepting all baselines');
+      output.debug('tdd', 'accepting all baselines');
       const reportData = readReportData();
       let acceptedCount = 0;
 
@@ -475,18 +471,18 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
           acceptedCount++;
         }
       }
-      logger.info(`Accepted ${acceptedCount} baselines`);
+      output.info(`Accepted ${acceptedCount} baselines`);
       return {
         count: acceptedCount
       };
     } catch (error) {
-      logger.error('Failed to accept all baselines:', error);
+      output.error('Failed to accept all baselines:', error);
       throw error;
     }
   };
   const resetBaselines = async () => {
     try {
-      logger.debug('Resetting baselines');
+      output.debug('tdd', 'resetting baselines');
       const reportData = readReportData();
       let deletedBaselines = 0;
       let deletedCurrents = 0;
@@ -504,9 +500,9 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
               } = await import('fs');
               unlinkSync(baselinePath);
               deletedBaselines++;
-              logger.debug(`Deleted baseline for ${comparison.name}`);
+              // Silent deletion
             } catch (error) {
-              logger.warn(`Failed to delete baseline for ${comparison.name}: ${error.message}`);
+              output.warn(`Failed to delete baseline for ${comparison.name}: ${error.message}`);
             }
           }
         }
@@ -521,9 +517,9 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
               } = await import('fs');
               unlinkSync(currentPath);
               deletedCurrents++;
-              logger.debug(`Deleted current screenshot for ${comparison.name}`);
+              // Silent deletion
             } catch (error) {
-              logger.warn(`Failed to delete current screenshot for ${comparison.name}: ${error.message}`);
+              output.warn(`Failed to delete current screenshot for ${comparison.name}: ${error.message}`);
             }
           }
         }
@@ -538,9 +534,9 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
               } = await import('fs');
               unlinkSync(diffPath);
               deletedDiffs++;
-              logger.debug(`Deleted diff for ${comparison.name}`);
+              output.debug(`Deleted diff for ${comparison.name}`);
             } catch (error) {
-              logger.warn(`Failed to delete diff for ${comparison.name}: ${error.message}`);
+              output.warn(`Failed to delete diff for ${comparison.name}: ${error.message}`);
             }
           }
         }
@@ -554,9 +550,9 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
             unlinkSync
           } = await import('fs');
           unlinkSync(metadataPath);
-          logger.debug('Deleted baseline metadata');
+          output.debug('Deleted baseline metadata');
         } catch (error) {
-          logger.warn(`Failed to delete baseline metadata: ${error.message}`);
+          output.warn(`Failed to delete baseline metadata: ${error.message}`);
         }
       }
 
@@ -574,7 +570,7 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
         }
       };
       writeFileSync(reportPath, JSON.stringify(freshReportData, null, 2));
-      logger.info(`Baselines reset - ${deletedBaselines} baselines deleted, ${deletedCurrents} current screenshots deleted, ${deletedDiffs} diffs deleted`);
+      output.info(`Baselines reset - ${deletedBaselines} baselines deleted, ${deletedCurrents} current screenshots deleted, ${deletedDiffs} diffs deleted`);
       return {
         success: true,
         deletedBaselines,
@@ -582,13 +578,12 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
         deletedDiffs
       };
     } catch (error) {
-      logger.error('Failed to reset baselines:', error);
+      output.error('Failed to reset baselines:', error);
       throw error;
     }
   };
   const cleanup = () => {
     // Report data is persisted to file, no in-memory cleanup needed
-    logger.debug('TDD handler cleanup completed');
   };
   return {
     initialize,
@@ -597,6 +592,8 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
     acceptBaseline,
     acceptAllBaselines,
     resetBaselines,
-    cleanup
+    cleanup,
+    // Expose tddService for baseline download operations
+    tddService
   };
 };