@vizzly-testing/cli 0.3.1 → 0.4.0

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,51 +80,64 @@ 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
       }));
 
-      // Check which files need uploading
+      // Create build first to get buildId for SHA checking
+      const buildInfo = {
+        name: buildName || `Upload ${new Date().toISOString()}`,
+        branch: branch || (await getDefaultBranch()) || 'main',
+        commitSha: commit,
+        commitMessage: message,
+        environment,
+        threshold
+      };
+      const build = await api.createBuild(buildInfo);
+      const buildId = build.id;
+
+      // Check which files need uploading (now with buildId)
       const {
         toUpload,
-        existing
-      } = await checkExistingFiles(fileMetadata, api, signal);
+        existing,
+        screenshots
+      } = 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
       });
 
-      // Create build and upload files
+      // Upload remaining files
       const result = await uploadFiles({
         toUpload,
         existing,
-        buildInfo: {
-          name: buildName || `Upload ${new Date().toISOString()}`,
-          branch: branch || (await getDefaultBranch()) || 'main',
-          commitSha: commit,
-          commitMessage: message,
-          environment,
-          threshold
-        },
+        screenshots,
+        buildId,
+        buildInfo,
         api,
         signal,
         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
       });
@@ -260,9 +273,10 @@ async function processFiles(files, signal, onProgress) {
 /**
  * Check which files already exist on the server
  */
-async function checkExistingFiles(fileMetadata, api, signal) {
+async function checkExistingFiles(fileMetadata, api, signal, buildId) {
   const allShas = fileMetadata.map(f => f.sha256);
   const existingShas = new Set();
+  const allScreenshots = [];
 
   // Check in batches
   for (let i = 0; i < allShas.length; i += DEFAULT_SHA_CHECK_BATCH_SIZE) {
@@ -275,14 +289,17 @@ async function checkExistingFiles(fileMetadata, api, signal) {
           'Content-Type': 'application/json'
         },
         body: JSON.stringify({
-          shas: batch
+          shas: batch,
+          buildId
         }),
         signal
       });
       const {
-        existing = []
+        existing = [],
+        screenshots = []
       } = res || {};
       existing.forEach(sha => existingShas.add(sha));
+      allScreenshots.push(...screenshots);
     } catch (error) {
       // Continue without deduplication on error
       console.debug('SHA check failed, continuing without deduplication:', error.message);
@@ -290,7 +307,8 @@ async function checkExistingFiles(fileMetadata, api, signal) {
   }
   return {
     toUpload: fileMetadata.filter(f => !existingShas.has(f.sha256)),
-    existing: fileMetadata.filter(f => existingShas.has(f.sha256))
+    existing: fileMetadata.filter(f => existingShas.has(f.sha256)),
+    screenshots: allScreenshots
   };
 }
 
@@ -299,49 +317,30 @@ async function checkExistingFiles(fileMetadata, api, signal) {
  */
 async function uploadFiles({
   toUpload,
-  existing,
-  buildInfo,
+  buildId,
   api,
   signal,
   batchSize,
   onProgress
 }) {
-  let buildId = null;
   let result = null;
 
-  // If all files exist, just create a build
+  // If all files exist, screenshot records were already created during SHA check
   if (toUpload.length === 0) {
-    return createBuildWithExisting({
-      existing,
-      buildInfo,
-      api,
-      signal
-    });
+    return {
+      buildId,
+      url: null
+    }; // Build was already created
   }
 
   // Upload in batches
   for (let i = 0; i < toUpload.length; i += batchSize) {
     if (signal.aborted) throw new UploadError('Operation cancelled');
     const batch = toUpload.slice(i, i + batchSize);
-    const isFirstBatch = i === 0;
     const form = new FormData();
-    if (isFirstBatch) {
-      // First batch creates the build
-      form.append('build_name', buildInfo.name);
-      form.append('branch', buildInfo.branch);
-      form.append('environment', buildInfo.environment);
-      if (buildInfo.commitSha) form.append('commit_sha', buildInfo.commitSha);
-      if (buildInfo.commitMessage) form.append('commit_message', buildInfo.commitMessage);
-      if (buildInfo.threshold !== undefined) form.append('threshold', buildInfo.threshold.toString());
 
-      // Include existing SHAs
-      if (existing.length > 0) {
-        form.append('existing_shas', JSON.stringify(existing.map(f => f.sha256)));
-      }
-    } else {
-      // Subsequent batches add to existing build
-      form.append('build_id', buildId);
-    }
+    // All batches add to existing build (build was created earlier)
+    form.append('build_id', buildId);
 
     // Add files
     for (const file of batch) {
@@ -362,50 +361,16 @@ async function uploadFiles({
         batch: i / batchSize + 1
       });
     }
-    if (isFirstBatch && result.build?.id) {
-      buildId = result.build.id;
-    }
     onProgress(i + batch.length);
   }
   return {
-    buildId: result.build?.id || buildId,
-    url: result.build?.url || result.url
+    buildId,
+    url: result?.build?.url || result?.url
   };
 }
 
-/**
- * Create a build with only existing files
- */
-async function createBuildWithExisting({
-  existing,
-  buildInfo,
-  api,
-  signal
-}) {
-  const form = new FormData();
-  form.append('build_name', buildInfo.name);
-  form.append('branch', buildInfo.branch);
-  form.append('environment', buildInfo.environment);
-  form.append('existing_shas', JSON.stringify(existing.map(f => f.sha256)));
-  if (buildInfo.commitSha) form.append('commit_sha', buildInfo.commitSha);
-  if (buildInfo.commitMessage) form.append('commit_message', buildInfo.commitMessage);
-  if (buildInfo.threshold !== undefined) form.append('threshold', buildInfo.threshold.toString());
-  let result;
-  try {
-    result = await api.request('/api/sdk/upload', {
-      method: 'POST',
-      body: form,
-      signal,
-      headers: {}
-    });
-  } catch (err) {
-    throw new UploadError(`Failed to create build: ${err.message}`);
-  }
-  return {
-    buildId: result.build?.id,
-    url: result.build?.url || result.url
-  };
-}
+// createBuildWithExisting function removed - no longer needed since
+// builds are created first and /check-shas automatically creates screenshot records
 
 /**
  * Uploader class for handling screenshot uploads

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;
+};

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

@@ -0,0 +1,85 @@
+export function createTddHandler(config: any, workingDir: any, baselineBuild: any, baselineComparison: any): {
+    initialize: () => Promise<void>;
+    registerBuild: (buildId: any) => void;
+    handleScreenshot: (buildId: any, name: any, image: any, properties?: {}) => Promise<{
+        statusCode: number;
+        body: {
+            error: string;
+            details: string;
+            comparison: {
+                name: any;
+                status: string;
+                baseline: any;
+                current: any;
+                diff: any;
+            };
+            tddMode: boolean;
+            status?: undefined;
+            message?: undefined;
+            success?: undefined;
+        };
+    } | {
+        statusCode: number;
+        body: {
+            status: string;
+            message: string;
+            comparison: {
+                name: any;
+                status: string;
+                baseline: any;
+                current: any;
+                diff?: undefined;
+            };
+            tddMode: boolean;
+            error?: undefined;
+            details?: undefined;
+            success?: undefined;
+        };
+    } | {
+        statusCode: number;
+        body: {
+            error: string;
+            tddMode: boolean;
+            details?: undefined;
+            comparison?: undefined;
+            status?: undefined;
+            message?: undefined;
+            success?: undefined;
+        };
+    } | {
+        statusCode: number;
+        body: {
+            success: boolean;
+            comparison: {
+                name: any;
+                status: string;
+                baseline?: undefined;
+                current?: undefined;
+                diff?: undefined;
+            };
+            tddMode: boolean;
+            error?: undefined;
+            details?: undefined;
+            status?: undefined;
+            message?: undefined;
+        };
+    }>;
+    getScreenshotCount: (buildId: any) => any;
+    finishBuild: (buildId: any) => Promise<{
+        id: any;
+        name: any;
+        tddMode: boolean;
+        results: {
+            total: number;
+            passed: number;
+            failed: number;
+            new: number;
+            errors: number;
+            comparisons: any[];
+            baseline: any;
+        };
+        url: any;
+        passed: boolean;
+    }>;
+    cleanup: () => void;
+};

package/dist/types/server/http-server.d.ts

@@ -0,0 +1,5 @@
+export function createHttpServer(port: any, screenshotHandler: any, emitter?: any): {
+    start: () => Promise<any>;
+    stop: () => Promise<any>;
+    getServer: () => any;
+};

package/dist/types/services/api-service.d.ts

@@ -5,6 +5,7 @@ export class ApiService {
     constructor(options?: {});
     baseUrl: any;
     token: any;
+    uploadAll: any;
     userAgent: string;
     /**
      * Make an API request
@@ -41,9 +42,10 @@ export class ApiService {
     /**
      * 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
      */
-    checkShas(shas: string[]): Promise<string[]>;
+    checkShas(shas: string[], buildId: string): Promise<any>;
     /**
      * Upload a screenshot with SHA checking
      * @param {string} buildId - Build ID

package/dist/types/services/server-manager.d.ts

@@ -1,8 +1,153 @@
 export class ServerManager extends BaseService {
     constructor(config: any, logger: any);
-    server: VizzlyServer;
-    start(buildId?: any, buildInfo?: any, mode?: string): Promise<void>;
+    httpServer: {
+        start: () => Promise<any>;
+        stop: () => Promise<any>;
+        getServer: () => any;
+    };
+    handler: {
+        initialize: () => Promise<void>;
+        registerBuild: (buildId: any) => void;
+        handleScreenshot: (buildId: any, name: any, image: any, properties?: {}) => Promise<{
+            statusCode: number;
+            body: {
+                error: string;
+                details: string;
+                comparison: {
+                    name: any;
+                    status: string;
+                    baseline: any;
+                    current: any;
+                    diff: any;
+                };
+                tddMode: boolean;
+                status?: undefined;
+                message?: undefined;
+                success?: undefined;
+            };
+        } | {
+            statusCode: number;
+            body: {
+                status: string;
+                message: string;
+                comparison: {
+                    name: any;
+                    status: string;
+                    baseline: any;
+                    current: any;
+                    diff?: undefined;
+                };
+                tddMode: boolean;
+                error?: undefined;
+                details?: undefined;
+                success?: undefined;
+            };
+        } | {
+            statusCode: number;
+            body: {
+                error: string;
+                tddMode: boolean;
+                details?: undefined;
+                comparison?: undefined;
+                status?: undefined;
+                message?: undefined;
+                success?: undefined;
+            };
+        } | {
+            statusCode: number;
+            body: {
+                success: boolean;
+                comparison: {
+                    name: any;
+                    status: string;
+                    baseline?: undefined;
+                    current?: undefined;
+                    diff?: undefined;
+                };
+                tddMode: boolean;
+                error?: undefined;
+                details?: undefined;
+                status?: undefined;
+                message?: undefined;
+            };
+        }>;
+        getScreenshotCount: (buildId: any) => any;
+        finishBuild: (buildId: any) => Promise<{
+            id: any;
+            name: any;
+            tddMode: boolean;
+            results: {
+                total: number;
+                passed: number;
+                failed: number;
+                new: number;
+                errors: number;
+                comparisons: any[];
+                baseline: any;
+            };
+            url: any;
+            passed: boolean;
+        }>;
+        cleanup: () => void;
+    } | {
+        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;
+    };
+    emitter: EventEmitter<[never]>;
+    start(buildId?: any, tddMode?: boolean): Promise<void>;
+    buildId: any;
+    tddMode: boolean;
     createApiService(): Promise<import("./api-service.js").ApiService>;
+    get server(): {
+        emitter: EventEmitter<[never]>;
+        getScreenshotCount: (buildId: any) => any;
+        finishBuild: (buildId: any) => any;
+    };
 }
 import { BaseService } from './base-service.js';
-import { VizzlyServer } from '../server/index.js';
+import { EventEmitter } from 'events';

package/dist/types/services/test-runner.d.ts

@@ -17,6 +17,7 @@ export class TestRunner extends BaseService {
         testsFailed: number;
         screenshotsCaptured: number;
     }>;
+    createBuild(options: any, tdd: any): Promise<any>;
     createApiService(): Promise<import("./api-service.js").ApiService>;
     finalizeBuild(buildId: any, isTddMode: any, success: any, executionTime: any): Promise<void>;
     executeTestCommand(testCommand: any, env: any): Promise<any>;

package/dist/types/utils/config-helpers.d.ts

@@ -3,4 +3,4 @@
  * @param {import('../types/index.js').VizzlyConfig} config
  * @returns {import('../types/index.js').VizzlyConfig}
  */
-export function defineConfig(config: import("../types/index.js").VizzlyConfig): import("../types/index.js").VizzlyConfig;
+export function defineConfig(config: any): any;

package/dist/types/utils/console-ui.d.ts

@@ -45,11 +45,11 @@ export class ConsoleUI {
      * Start a spinner with message
      */
     startSpinner(message: any): void;
+    currentMessage: any;
     /**
      * Update spinner message and progress
      */
     updateSpinner(message: any, current?: number, total?: number): void;
-    currentMessage: string;
     /**
      * Stop the spinner
      */