@vizzly-testing/cli 0.3.1 → 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,16 +105,19 @@ export class ApiService {
       headers: {
         'Content-Type': 'application/json'
       },
-      body: JSON.stringify(metadata)
+      body: JSON.stringify({
+        build: metadata
+      })
     });
   }
 
   /**
    * Check if SHAs already exist on the server
    * @param {string[]} shas - Array of SHA256 hashes to check
-   * @returns {Promise<string[]>} Array of existing SHAs
+   * @param {string} buildId - Build ID for screenshot record creation
+   * @returns {Promise<Object>} Response with existing SHAs and screenshot data
    */
-  async checkShas(shas) {
+  async checkShas(shas, buildId) {
     try {
       const response = await this.request('/api/sdk/check-shas', {
         method: 'POST',
@@ -121,14 +125,19 @@ export class ApiService {
           'Content-Type': 'application/json'
         },
         body: JSON.stringify({
-          shas
+          shas,
+          buildId
         })
       });
-      return response.existing || [];
+      return response;
     } catch (error) {
       // Continue without deduplication on error
       console.debug('SHA check failed, continuing without deduplication:', error.message);
-      return [];
+      return {
+        existing: [],
+        missing: shas,
+        screenshots: []
+      };
     }
   }
 
@@ -141,17 +150,37 @@ 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
-    const existingShas = await this.checkShas([sha256]);
-    if (existingShas.includes(sha256)) {
-      // File already exists, skip upload but still register the screenshot
+    const checkResult = await this.checkShas([sha256], buildId);
+    if (checkResult.existing && checkResult.existing.includes(sha256)) {
+      // File already exists, screenshot record was automatically created
+      const screenshot = checkResult.screenshots?.find(s => s.sha256 === sha256);
       return {
         message: 'Screenshot already exists, skipped upload',
         sha256,
-        skipped: true
+        skipped: true,
+        screenshot,
+        fromExisting: true
       };
     }
 

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) {