@vizzly-testing/cli 0.3.2 → 0.4.0

package/dist/server/http-server.js

@@ -0,0 +1,132 @@
+import { createServer } from 'http';
+import { createServiceLogger } from '../utils/logger-factory.js';
+const logger = createServiceLogger('HTTP-SERVER');
+export const createHttpServer = (port, screenshotHandler, emitter = null) => {
+  let server = null;
+  const parseRequestBody = req => {
+    return new Promise((resolve, reject) => {
+      let body = '';
+      req.on('data', chunk => {
+        body += chunk.toString();
+      });
+      req.on('end', () => {
+        try {
+          const data = JSON.parse(body);
+          resolve(data);
+        } catch {
+          reject(new Error('Invalid JSON'));
+        }
+      });
+      req.on('error', reject);
+    });
+  };
+  const handleRequest = async (req, res) => {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+    res.setHeader('Content-Type', 'application/json');
+    if (req.method === 'OPTIONS') {
+      res.statusCode = 200;
+      res.end();
+      return;
+    }
+    if (req.method === 'GET' && req.url === '/health') {
+      res.statusCode = 200;
+      res.end(JSON.stringify({
+        status: 'ok',
+        port: port,
+        uptime: process.uptime()
+      }));
+      return;
+    }
+    if (req.method === 'POST' && req.url === '/screenshot') {
+      try {
+        const body = await parseRequestBody(req);
+        const {
+          buildId,
+          name,
+          properties,
+          image
+        } = body;
+        if (!buildId || !name || !image) {
+          res.statusCode = 400;
+          res.end(JSON.stringify({
+            error: 'buildId, name, and image are required'
+          }));
+          return;
+        }
+        const result = await screenshotHandler.handleScreenshot(buildId, name, image, properties);
+
+        // Emit screenshot captured event if emitter is available
+        if (emitter && result.statusCode === 200) {
+          emitter.emit('screenshot-captured', {
+            name,
+            count: screenshotHandler.getScreenshotCount?.(buildId) || 0,
+            skipped: result.body?.skipped
+          });
+        }
+        res.statusCode = result.statusCode;
+        res.end(JSON.stringify(result.body));
+      } catch (error) {
+        logger.error('Screenshot processing error:', error);
+        res.statusCode = 500;
+        res.end(JSON.stringify({
+          error: 'Failed to process screenshot'
+        }));
+      }
+      return;
+    }
+    res.statusCode = 404;
+    res.end(JSON.stringify({
+      error: 'Not found'
+    }));
+  };
+  const start = () => {
+    return new Promise((resolve, reject) => {
+      server = createServer(async (req, res) => {
+        try {
+          await handleRequest(req, res);
+        } catch (error) {
+          logger.error('Server error:', error);
+          res.statusCode = 500;
+          res.setHeader('Content-Type', 'application/json');
+          res.end(JSON.stringify({
+            error: 'Internal server error'
+          }));
+        }
+      });
+      server.listen(port, '127.0.0.1', error => {
+        if (error) {
+          reject(error);
+        } else {
+          logger.debug(`HTTP server listening on http://127.0.0.1:${port}`);
+          resolve();
+        }
+      });
+      server.on('error', error => {
+        if (error.code === 'EADDRINUSE') {
+          reject(new Error(`Port ${port} is already in use. Try a different port with --port.`));
+        } else {
+          reject(error);
+        }
+      });
+    });
+  };
+  const stop = () => {
+    if (server) {
+      return new Promise(resolve => {
+        server.close(() => {
+          server = null;
+          logger.debug('HTTP server stopped');
+          resolve();
+        });
+      });
+    }
+    return Promise.resolve();
+  };
+  return {
+    start,
+    stop,
+    getServer: () => server
+  };
+};

package/dist/services/api-service.js

@@ -16,6 +16,7 @@ export class ApiService {
   constructor(options = {}) {
     this.baseUrl = options.baseUrl || getApiUrl();
     this.token = options.token || getApiToken();
+    this.uploadAll = options.uploadAll || false;
 
     // Build User-Agent string
     const command = options.command || 'run'; // Default to 'run' for API service
@@ -104,7 +105,9 @@ export class ApiService {
       headers: {
         'Content-Type': 'application/json'
       },
-      body: JSON.stringify(metadata)
+      body: JSON.stringify({
+        build: metadata
+      })
     });
   }
 
@@ -147,7 +150,24 @@ export class ApiService {
    * @returns {Promise<Object>} Upload result
    */
   async uploadScreenshot(buildId, name, buffer, metadata = {}) {
-    // Calculate SHA256 of the image
+    // Skip SHA deduplication entirely if uploadAll flag is set
+    if (this.uploadAll) {
+      // Upload directly without SHA calculation or checking
+      return this.request(`/api/sdk/builds/${buildId}/screenshots`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          name,
+          image_data: buffer.toString('base64'),
+          properties: metadata ?? {}
+          // No SHA included when bypassing deduplication
+        })
+      });
+    }
+
+    // Normal flow with SHA deduplication
     const sha256 = crypto.createHash('sha256').update(buffer).digest('hex');
 
     // Check if this SHA already exists

package/dist/services/server-manager.js

@@ -1,44 +1,43 @@
 /**
  * Server Manager Service
- * Manages the Vizzly HTTP server
+ * Manages the HTTP server with functional handlers
  */
 
 import { BaseService } from './base-service.js';
-import { VizzlyServer } from '../server/index.js';
+import { createHttpServer } from '../server/http-server.js';
+import { createTddHandler } from '../server/handlers/tdd-handler.js';
+import { createApiHandler } from '../server/handlers/api-handler.js';
 import { EventEmitter } from 'events';
 export class ServerManager extends BaseService {
   constructor(config, logger) {
     super(config, {
       logger
     });
-    this.server = null;
+    this.httpServer = null;
+    this.handler = null;
+    this.emitter = null;
   }
-  async start(buildId = null, buildInfo = null, mode = 'lazy') {
-    if (this.started) {
-      this.logger.warn(`${this.constructor.name} already started`);
-      return;
-    }
-
-    // Create event emitter for server events
-    const emitter = new EventEmitter();
-    this.server = new VizzlyServer({
-      port: this.config?.server?.port || 47392,
-      config: this.config,
-      buildId,
-      buildInfo,
-      vizzlyApi: buildInfo || mode === 'eager' ? await this.createApiService() : null,
-      tddMode: mode === 'tdd',
-      // TDD mode only when explicitly set
-      baselineBuild: this.config?.baselineBuildId,
-      baselineComparison: this.config?.baselineComparisonId,
-      workingDir: process.cwd(),
-      emitter // Pass the emitter to the server
-    });
-    await super.start();
+  async start(buildId = null, tddMode = false) {
+    this.buildId = buildId;
+    this.tddMode = tddMode;
+    return super.start();
   }
   async onStart() {
-    if (this.server) {
-      await this.server.start();
+    this.emitter = new EventEmitter();
+    const port = this.config?.server?.port || 47392;
+    if (this.tddMode) {
+      this.handler = createTddHandler(this.config, process.cwd(), this.config?.baselineBuildId, this.config?.baselineComparisonId);
+      await this.handler.initialize();
+      if (this.buildId) {
+        this.handler.registerBuild(this.buildId);
+      }
+    } else {
+      const apiService = await this.createApiService();
+      this.handler = createApiHandler(apiService);
+    }
+    this.httpServer = createHttpServer(port, this.handler, this.emitter);
+    if (this.httpServer) {
+      await this.httpServer.start();
     }
   }
   async createApiService() {
@@ -54,8 +53,25 @@ export class ServerManager extends BaseService {
     });
   }
   async onStop() {
-    if (this.server) {
-      await this.server.stop();
+    if (this.httpServer) {
+      await this.httpServer.stop();
     }
+    if (this.handler?.cleanup) {
+      try {
+        this.handler.cleanup();
+      } catch (error) {
+        this.logger.debug('Handler cleanup error:', error.message);
+        // Don't throw - cleanup errors shouldn't fail the stop process
+      }
+    }
+  }
+
+  // Expose server interface for compatibility
+  get server() {
+    return {
+      emitter: this.emitter,
+      getScreenshotCount: buildId => this.handler?.getScreenshotCount?.(buildId) || 0,
+      finishBuild: buildId => this.handler?.finishBuild?.(buildId)
+    };
   }
 }

package/dist/services/test-runner.js

@@ -40,87 +40,47 @@ export class TestRunner extends BaseService {
       };
     }
     try {
-      let buildInfo = null;
       let buildUrl = null;
       let screenshotCount = 0;
-      if (tdd) {
-        // TDD mode: create local build for fast feedback
-        this.logger.debug('TDD mode: creating local build...');
-        const build = await this.buildManager.createBuild(options);
-        buildId = build.id;
-        this.logger.debug(`TDD build created with ID: ${build.id}`);
-      } else if (options.eager) {
-        // Eager mode: create build immediately via API
-        this.logger.debug('Eager mode: creating build via API...');
+
+      // Create build based on mode
+      buildId = await this.createBuild(options, tdd);
+      if (!tdd && buildId) {
+        // Get build URL for API mode
         const apiService = await this.createApiService();
         if (apiService) {
-          const buildResult = await apiService.createBuild({
-            build: {
-              name: options.buildName || `Test Run ${new Date().toISOString()}`,
-              branch: options.branch || 'main',
-              environment: options.environment || 'test',
-              commit_sha: options.commit,
-              commit_message: options.message
+          try {
+            const build = await apiService.getBuild(buildId);
+            buildUrl = build.url;
+            if (buildUrl) {
+              this.logger.info(`Build URL: ${buildUrl}`);
             }
-          });
-          buildId = buildResult.id;
-          buildUrl = buildResult.url;
-          this.logger.debug(`Eager build created with ID: ${buildId}`);
-          if (buildUrl) {
-            this.logger.info(`Build URL: ${buildUrl}`);
+          } catch (error) {
+            this.logger.debug('Could not retrieve build URL:', error.message);
           }
-
-          // Emit build created event for eager mode
-          this.emit('build-created', {
-            buildId: buildResult.id,
-            url: buildResult.url,
-            name: buildResult.name || options.buildName
-          });
-        } else {
-          this.logger.warn('No API key available for eager build creation, falling back to lazy mode');
         }
-      } else {
-        // Lazy mode: prepare build info for API creation on first screenshot
-        buildInfo = {
-          buildName: options.buildName || `Test Run ${new Date().toISOString()}`,
-          branch: options.branch || 'main',
-          environment: options.environment || 'test',
-          commitSha: options.commit,
-          commitMessage: options.message
-        };
       }
 
-      // Start server with appropriate configuration
-      const mode = tdd ? 'tdd' : options.eager ? 'eager' : 'lazy';
-      await this.serverManager.start(buildId, buildInfo, mode);
+      // Start server with appropriate handler
+      await this.serverManager.start(buildId, tdd);
 
       // Forward server events
-      if (this.serverManager.server && this.serverManager.server.emitter) {
-        this.serverManager.server.emitter.on('build-created', buildInfo => {
-          // Update local buildId and buildUrl from server
-          buildId = buildInfo.buildId;
-          buildUrl = buildInfo.url;
-          this.emit('build-created', buildInfo);
-        });
+      if (this.serverManager.server?.emitter) {
         this.serverManager.server.emitter.on('screenshot-captured', screenshotInfo => {
           screenshotCount++;
           this.emit('screenshot-captured', screenshotInfo);
         });
       }
-      if (tdd) {
-        this.logger.debug('TDD service ready for comparisons');
-      }
       const env = {
         ...process.env,
         VIZZLY_SERVER_URL: `http://localhost:${this.config.server.port}`,
-        VIZZLY_BUILD_ID: buildId || 'lazy',
-        // Use 'lazy' for API-driven builds
+        VIZZLY_BUILD_ID: buildId,
         VIZZLY_ENABLED: 'true',
         VIZZLY_SET_BASELINE: options.setBaseline || options['set-baseline'] ? 'true' : 'false'
       };
       await this.executeTestCommand(testCommand, env);
 
-      // Finalize builds based on mode
+      // Finalize build
       const executionTime = Date.now() - startTime;
       await this.finalizeBuild(buildId, tdd, true, executionTime);
       return {
@@ -133,14 +93,46 @@ export class TestRunner extends BaseService {
     } catch (error) {
       this.logger.error('Test run failed:', error);
 
-      // Finalize builds on failure too
+      // Finalize build on failure
       const executionTime = Date.now() - startTime;
       await this.finalizeBuild(buildId, tdd, false, executionTime);
       throw error;
     } finally {
       await this.serverManager.stop();
-      if (tdd && this.tddService && typeof this.tddService.stop === 'function') {
-        await this.tddService.stop();
+    }
+  }
+  async createBuild(options, tdd) {
+    if (tdd) {
+      // TDD mode: create local build
+      this.logger.debug('TDD mode: creating local build...');
+      const build = await this.buildManager.createBuild(options);
+      this.logger.debug(`TDD build created with ID: ${build.id}`);
+      return build.id;
+    } else {
+      // API mode: create build via API
+      this.logger.debug('Creating build via API...');
+      const apiService = await this.createApiService();
+      if (apiService) {
+        const buildResult = await apiService.createBuild({
+          build: {
+            name: options.buildName || `Test Run ${new Date().toISOString()}`,
+            branch: options.branch || 'main',
+            environment: options.environment || 'test',
+            commit_sha: options.commit,
+            commit_message: options.message
+          }
+        });
+        this.logger.debug(`Build created with ID: ${buildResult.id}`);
+
+        // Emit build created event
+        this.emit('build-created', {
+          buildId: buildResult.id,
+          url: buildResult.url,
+          name: buildResult.name || options.buildName
+        });
+        return buildResult.id;
+      } else {
+        throw new VizzlyError('No API key available for build creation', 'API_KEY_MISSING');
       }
     }
   }
@@ -151,9 +143,8 @@ export class TestRunner extends BaseService {
     } = await import('./api-service.js');
     return new ApiService({
       ...this.config,
-      command: 'run'
-    }, {
-      logger: this.logger
+      command: 'run',
+      uploadAll: this.config.uploadAll
     });
   }
   async finalizeBuild(buildId, isTddMode, success, executionTime) {
@@ -163,15 +154,13 @@ export class TestRunner extends BaseService {
     }
     try {
       if (isTddMode) {
-        // TDD mode: use buildManager for local builds
-        if (this.buildManager.getCurrentBuild()) {
-          await this.buildManager.finalizeBuild(buildId, {
-            success
-          });
+        // TDD mode: use server handler to finalize
+        if (this.serverManager.server?.finishBuild) {
+          await this.serverManager.server.finishBuild(buildId);
           this.logger.debug(`TDD build ${buildId} finalized with success: ${success}`);
         }
       } else {
-        // API mode (eager/lazy): use API service to update build status
+        // API mode: use API service to update build status
         const apiService = await this.createApiService();
         if (apiService) {
           await apiService.finalizeBuild(buildId, success, executionTime);
@@ -180,6 +169,12 @@ export class TestRunner extends BaseService {
     } catch (error) {
       // Don't fail the entire run if build finalization fails
       this.logger.warn(`Failed to finalize build ${buildId}:`, error.message);
+      // Emit event for UI handling
+      this.emit('build-finalize-failed', {
+        buildId,
+        error: error.message,
+        stack: error.stack
+      });
     }
   }
   async executeTestCommand(testCommand, env) {

package/dist/services/uploader.js

@@ -11,7 +11,7 @@ import { createUploaderLogger } from '../utils/logger-factory.js';
 import { ApiService } from './api-service.js';
 import { getDefaultBranch } from '../utils/git.js';
 import { UploadError, TimeoutError, ValidationError } from '../errors/vizzly-error.js';
-const DEFAULT_BATCH_SIZE = 10;
+const DEFAULT_BATCH_SIZE = 50;
 const DEFAULT_SHA_CHECK_BATCH_SIZE = 100;
 const DEFAULT_TIMEOUT = 30000; // 30 seconds
 
@@ -80,12 +80,14 @@ export function createUploader({
       }
       onProgress({
         phase: 'scanning',
+        message: `Found ${files.length} screenshots`,
         total: files.length
       });
 
       // Process files to get metadata
       const fileMetadata = await processFiles(files, signal, current => onProgress({
         phase: 'processing',
+        message: `Processing files`,
         current,
         total: files.length
       }));
@@ -110,6 +112,7 @@ export function createUploader({
       } = await checkExistingFiles(fileMetadata, api, signal, buildId);
       onProgress({
         phase: 'deduplication',
+        message: `Checking for duplicates (${toUpload.length} to upload, ${existing.length} existing)`,
         toUpload: toUpload.length,
         existing: existing.length,
         total: files.length
@@ -127,12 +130,14 @@ export function createUploader({
         batchSize: batchSize,
         onProgress: current => onProgress({
           phase: 'uploading',
+          message: `Uploading screenshots`,
           current,
           total: toUpload.length
         })
       });
       onProgress({
         phase: 'completed',
+        message: `Upload completed`,
         buildId: result.buildId,
         url: result.url
       });

package/dist/types/commands/run.d.ts

@@ -4,7 +4,10 @@
  * @param {Object} options - Command options
  * @param {Object} globalOptions - Global CLI options
  */
-export function runCommand(testCommand: string, options?: any, globalOptions?: any): Promise<void>;
+export function runCommand(testCommand: string, options?: any, globalOptions?: any): Promise<{
+    success: boolean;
+    exitCode: number;
+}>;
 /**
  * Validate run options
  * @param {string} testCommand - Test command to execute

package/dist/types/commands/tdd.d.ts

@@ -4,7 +4,10 @@
  * @param {Object} options - Command options
  * @param {Object} globalOptions - Global CLI options
  */
-export function tddCommand(testCommand: string, options?: any, globalOptions?: any): Promise<void>;
+export function tddCommand(testCommand: string, options?: any, globalOptions?: any): Promise<{
+    success: boolean;
+    exitCode: number;
+}>;
 /**
  * Validate TDD options
  * @param {string} testCommand - Test command to execute

package/dist/types/sdk/index.d.ts

@@ -31,7 +31,7 @@
  * // Cleanup
  * await vizzly.stop();
  */
-export function createVizzly(config?: import("../types").VizzlyConfig, options?: {}): Promise<VizzlySDK>;
+export function createVizzly(config?: any, options?: {}): Promise<VizzlySDK>;
 /**
  * @typedef {Object} VizzlySDK
  * @property {Function} start - Start the Vizzly server
@@ -54,8 +54,8 @@ export class VizzlySDK extends EventEmitter<[never]> {
      * @param {import('../utils/logger').Logger} logger - Logger instance
      * @param {Object} services - Service instances
      */
-    constructor(config: import("../types").VizzlyConfig, logger: import("../utils/logger").Logger, services: any);
-    config: import("../types").VizzlyConfig;
+    constructor(config: any, logger: import("../utils/logger").Logger, services: any);
+    config: any;
     logger: import("../utils/logger.js").Logger;
     services: any;
     server: ScreenshotServer;
@@ -85,20 +85,20 @@ export class VizzlySDK extends EventEmitter<[never]> {
      * @param {import('../types').ScreenshotOptions} [options] - Options
      * @returns {Promise<void>}
      */
-    screenshot(name: string, imageBuffer: Buffer, options?: import("../types").ScreenshotOptions): Promise<void>;
+    screenshot(name: string, imageBuffer: Buffer, options?: any): Promise<void>;
     /**
      * Upload all captured screenshots
      * @param {import('../types').UploadOptions} [options] - Upload options
      * @returns {Promise<import('../types').UploadResult>} Upload result
      */
-    upload(options?: import("../types").UploadOptions): Promise<import("../types").UploadResult>;
+    upload(options?: any): Promise<any>;
     /**
      * Run local comparison in TDD mode
      * @param {string} name - Screenshot name
      * @param {Buffer} imageBuffer - Current image
      * @returns {Promise<import('../types').ComparisonResult>} Comparison result
      */
-    compare(name: string, imageBuffer: Buffer): Promise<import("../types").ComparisonResult>;
+    compare(name: string, imageBuffer: Buffer): Promise<any>;
 }
 export { loadConfig } from "../utils/config-loader.js";
 export { createLogger } from "../utils/logger.js";

package/dist/types/server/handlers/api-handler.d.ts

@@ -0,0 +1,49 @@
+export function createApiHandler(apiService: any): {
+    handleScreenshot: (buildId: any, name: any, image: any, properties?: {}) => Promise<{
+        statusCode: number;
+        body: {
+            success: boolean;
+            disabled: boolean;
+            count: number;
+            message: string;
+            error?: undefined;
+            name?: undefined;
+            skipped?: undefined;
+        };
+    } | {
+        statusCode: number;
+        body: {
+            error: string;
+            success?: undefined;
+            disabled?: undefined;
+            count?: undefined;
+            message?: undefined;
+            name?: undefined;
+            skipped?: undefined;
+        };
+    } | {
+        statusCode: number;
+        body: {
+            success: boolean;
+            name: any;
+            skipped: any;
+            count: number;
+            disabled?: undefined;
+            message?: undefined;
+            error?: undefined;
+        };
+    } | {
+        statusCode: number;
+        body: {
+            success: boolean;
+            name: any;
+            disabled: boolean;
+            message: string;
+            count?: undefined;
+            error?: undefined;
+            skipped?: undefined;
+        };
+    }>;
+    getScreenshotCount: () => number;
+    cleanup: () => void;
+};