@vizzly-testing/cli 0.1.0

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

@@ -0,0 +1,72 @@
+/**
+ * @typedef {Object} ServiceOptions
+ * @property {Object} logger - Logger instance
+ * @property {AbortSignal} [signal] - Abort signal for cancellation
+ */
+/**
+ * Base class for all services
+ * @extends EventEmitter
+ */
+export class BaseService extends EventEmitter<[never]> {
+    /**
+     * @param {Object} config - Service configuration
+     * @param {ServiceOptions} options - Service options
+     */
+    constructor(config: any, options?: ServiceOptions);
+    config: any;
+    logger: any;
+    signal: AbortSignal;
+    started: boolean;
+    stopping: boolean;
+    /**
+     * Start the service
+     * @returns {Promise<void>}
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the service
+     * @returns {Promise<void>}
+     */
+    stop(): Promise<void>;
+    /**
+     * Hook for service-specific start logic
+     * @protected
+     * @returns {Promise<void>}
+     */
+    protected onStart(): Promise<void>;
+    /**
+     * Hook for service-specific stop logic
+     * @protected
+     * @returns {Promise<void>}
+     */
+    protected onStop(): Promise<void>;
+    /**
+     * Emit a progress event
+     * @param {string} phase - Progress phase
+     * @param {string} message - Progress message
+     * @param {Object} [data] - Additional data
+     */
+    emitProgress(phase: string, message: string, data?: any): void;
+    /**
+     * Check if service is running
+     * @returns {boolean}
+     */
+    isRunning(): boolean;
+    /**
+     * Wait for service to be ready
+     * @param {number} [timeout=30000] - Timeout in milliseconds
+     * @returns {Promise<void>}
+     */
+    waitForReady(timeout?: number): Promise<void>;
+}
+export type ServiceOptions = {
+    /**
+     * - Logger instance
+     */
+    logger: any;
+    /**
+     * - Abort signal for cancellation
+     */
+    signal?: AbortSignal;
+};
+import { EventEmitter } from 'events';

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

@@ -0,0 +1,68 @@
+/**
+ * Generate unique build ID for local build management only.
+ * Note: The API generates its own UUIDs for actual builds - this local ID
+ * is only used for CLI internal tracking and is not sent to the API.
+ * @returns {string} Build ID
+ */
+export function generateBuildId(): string;
+/**
+ * Create build object
+ * @param {Object} buildOptions - Build configuration
+ * @returns {Object} Build object
+ */
+export function createBuildObject(buildOptions: any): any;
+/**
+ * Update build with new status and data
+ * @param {Object} build - Current build
+ * @param {string} status - New status
+ * @param {Object} updates - Additional updates
+ * @returns {Object} Updated build
+ */
+export function updateBuild(build: any, status: string, updates?: any): any;
+/**
+ * Add screenshot to build
+ * @param {Object} build - Current build
+ * @param {Object} screenshot - Screenshot data
+ * @returns {Object} Updated build
+ */
+export function addScreenshotToBuild(build: any, screenshot: any): any;
+/**
+ * Finalize build with result
+ * @param {Object} build - Current build
+ * @param {Object} result - Build result
+ * @returns {Object} Finalized build
+ */
+export function finalizeBuildObject(build: any, result?: any): any;
+/**
+ * Create queued build item
+ * @param {Object} buildOptions - Build options
+ * @returns {Object} Queued build item
+ */
+export function createQueuedBuild(buildOptions: any): any;
+/**
+ * Validate build options
+ * @param {Object} buildOptions - Build options to validate
+ * @returns {Object} Validation result
+ */
+export function validateBuildOptions(buildOptions: any): any;
+export class BuildManager extends BaseService {
+    constructor(config: any, logger: any);
+    currentBuild: any;
+    buildQueue: any[];
+    createBuild(buildOptions: any): Promise<any>;
+    updateBuildStatus(buildId: any, status: any, updates?: {}): Promise<any>;
+    addScreenshot(buildId: any, screenshot: any): Promise<any>;
+    finalizeBuild(buildId: any, result?: {}): Promise<any>;
+    getCurrentBuild(): any;
+    queueBuild(buildOptions: any): void;
+    processNextBuild(): Promise<any>;
+    getQueueStatus(): {
+        length: number;
+        items: {
+            name: any;
+            branch: any;
+            queuedAt: any;
+        }[];
+    };
+}
+import { BaseService } from './base-service.js';

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

@@ -0,0 +1,10 @@
+export class ScreenshotServer extends BaseService {
+    constructor(config: any, logger: any, buildManager: any);
+    buildManager: any;
+    server: import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
+    onStart(): Promise<any>;
+    onStop(): Promise<any>;
+    handleRequest(req: any, res: any): Promise<void>;
+    parseRequestBody(req: any): Promise<any>;
+}
+import { BaseService } from './base-service.js';

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

@@ -0,0 +1,8 @@
+export class ServerManager extends BaseService {
+    constructor(config: any, logger: any);
+    server: VizzlyServer;
+    start(buildId?: any, buildInfo?: any, mode?: string): Promise<void>;
+    createApiService(): Promise<import("./api-service.js").ApiService>;
+}
+import { BaseService } from './base-service.js';
+import { VizzlyServer } from '../server/index.js';

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

@@ -0,0 +1,45 @@
+/**
+ * Create an event emitter with enhanced functionality
+ * @returns {EventEmitter} Enhanced event emitter
+ */
+export function createEventEmitter(): EventEmitter;
+/**
+ * Create a cleanup manager
+ * @returns {Object} Cleanup manager with add/execute methods
+ */
+export function createCleanupManager(): any;
+/**
+ * Create signal handlers for graceful shutdown
+ * @param {Function} onSignal - Function to call on signal
+ * @returns {Function} Cleanup function to remove handlers
+ */
+export function createSignalHandlers(onSignal: Function): Function;
+/**
+ * Higher-order function to add error handling to any function
+ * @param {Function} fn - Function to wrap
+ * @param {Object} options - Error handling options
+ * @returns {Function} Wrapped function with error handling
+ */
+export function withErrorHandling(fn: Function, options?: any): Function;
+/**
+ * Higher-order function to add logging to any function
+ * @param {Function} fn - Function to wrap
+ * @param {Object} logger - Logger instance
+ * @param {string} operation - Operation name for logging
+ * @returns {Function} Wrapped function with logging
+ */
+export function withLogging(fn: Function, logger: any, operation: string): Function;
+/**
+ * Compose multiple functions together
+ * @param {...Function} fns - Functions to compose
+ * @returns {Function} Composed function
+ */
+export function compose(...fns: Function[]): Function;
+/**
+ * Create a service context with shared functionality
+ * @param {Object} config - Service configuration
+ * @param {Object} options - Service options
+ * @returns {Object} Service context
+ */
+export function createServiceContext(config: any, options?: any): any;
+import { EventEmitter } from 'events';

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

@@ -0,0 +1,55 @@
+/**
+ * Create a new TDD service instance
+ */
+export function createTDDService(config: any, options?: {}): TddService;
+export class TddService {
+    constructor(config: any, workingDir?: string);
+    config: any;
+    api: ApiService;
+    workingDir: string;
+    baselinePath: string;
+    currentPath: string;
+    diffPath: string;
+    baselineData: any;
+    comparisons: any[];
+    threshold: any;
+    downloadBaselines(environment?: string, branch?: any, buildId?: any, comparisonId?: any): Promise<any>;
+    loadBaseline(): Promise<any>;
+    compareScreenshot(name: any, imageBuffer: any, properties?: {}): Promise<{
+        name: any;
+        status: string;
+        baseline: any;
+        current: any;
+        diff: any;
+        properties: any;
+    }>;
+    getResults(): {
+        total: number;
+        passed: number;
+        failed: number;
+        new: number;
+        errors: number;
+        comparisons: any[];
+        baseline: any;
+    };
+    printResults(): {
+        total: number;
+        passed: number;
+        failed: number;
+        new: number;
+        errors: number;
+        comparisons: any[];
+        baseline: any;
+    };
+    /**
+     * Update baselines with current screenshots (accept changes)
+     * @returns {number} Number of baselines updated
+     */
+    updateBaselines(): number;
+    /**
+     * Update a single baseline with current screenshot
+     * @private
+     */
+    private updateSingleBaseline;
+}
+import { ApiService } from '../services/api-service.js';

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

@@ -0,0 +1,25 @@
+export class TestRunner extends BaseService {
+    constructor(config: any, logger: any, buildManager: any, serverManager: any, tddService: any);
+    buildManager: any;
+    serverManager: any;
+    tddService: any;
+    testProcess: import("child_process").ChildProcess;
+    run(options: any): Promise<{
+        testsPassed: number;
+        testsFailed: number;
+        screenshotsCaptured: number;
+        buildId?: undefined;
+        url?: undefined;
+    } | {
+        buildId: any;
+        url: any;
+        testsPassed: number;
+        testsFailed: number;
+        screenshotsCaptured: number;
+    }>;
+    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>;
+    cancel(): Promise<void>;
+}
+import { BaseService } from './base-service.js';

package/dist/types/services/uploader.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Create a new uploader instance
+ */
+export function createUploader({ apiKey, apiUrl, userAgent, command, upload: uploadConfig }: {
+    apiKey: any;
+    apiUrl: any;
+    userAgent: any;
+    command: any;
+    upload?: {};
+}, options?: {}): {
+    upload: ({ screenshotsDir, buildName, branch, commit, message, environment, threshold, onProgress, }: {
+        screenshotsDir: any;
+        buildName: any;
+        branch: any;
+        commit: any;
+        message: any;
+        environment?: string;
+        threshold: any;
+        onProgress?: () => void;
+    }) => Promise<{
+        success: boolean;
+        buildId: any;
+        url: any;
+        stats: {
+            total: number;
+            uploaded: any;
+            skipped: any;
+        };
+    }>;
+    waitForBuild: (buildId: any, timeout?: number) => Promise<{
+        status: string;
+        build: any;
+    }>;
+};

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

@@ -0,0 +1,373 @@
+declare const _default: {};
+export default _default;
+export type VizzlyConfig = {
+    /**
+     * - API key for authentication
+     */
+    apiKey?: string;
+    /**
+     * - API base URL
+     */
+    apiUrl?: string;
+    /**
+     * - Server configuration
+     */
+    server?: ServerConfig;
+    /**
+     * - Build configuration
+     */
+    build?: BuildConfig;
+    /**
+     * - Upload configuration
+     */
+    upload?: UploadConfig;
+    /**
+     * - Comparison configuration
+     */
+    comparison?: ComparisonConfig;
+};
+export type ServerConfig = {
+    /**
+     * - Server port
+     */
+    port?: number;
+    /**
+     * - Server host
+     */
+    host?: string;
+    /**
+     * - Use HTTPS
+     */
+    https?: boolean;
+    /**
+     * - Path to SSL certificate
+     */
+    certPath?: string;
+    /**
+     * - Path to SSL key
+     */
+    keyPath?: string;
+    /**
+     * - Screenshot POST endpoint path
+     */
+    screenshotPath?: string;
+};
+export type BuildConfig = {
+    /**
+     * - Build name
+     */
+    name?: string;
+    /**
+     * - Git branch
+     */
+    branch?: string;
+    /**
+     * - Git commit SHA
+     */
+    commit?: string;
+    /**
+     * - Commit message
+     */
+    message?: string;
+    /**
+     * - Environment name
+     */
+    environment?: string;
+    /**
+     * - Additional metadata
+     */
+    metadata?: {
+        [x: string]: any;
+    };
+};
+export type UploadConfig = {
+    /**
+     * - Directory containing screenshots
+     */
+    screenshotsDir?: string;
+    /**
+     * - Upload batch size
+     */
+    batchSize?: number;
+    /**
+     * - Upload timeout in ms
+     */
+    timeout?: number;
+    /**
+     * - Number of retries
+     */
+    retries?: number;
+    /**
+     * - Enable deduplication
+     */
+    deduplication?: boolean;
+};
+export type ComparisonConfig = {
+    /**
+     * - Default comparison threshold (0-1)
+     */
+    threshold?: number;
+    /**
+     * - Ignore antialiasing differences
+     */
+    ignoreAntialiasing?: boolean;
+    /**
+     * - Ignore color differences
+     */
+    ignoreColors?: boolean;
+    /**
+     * - Color for diff highlighting
+     */
+    diffColor?: string;
+};
+export type Screenshot = {
+    /**
+     * - Screenshot name
+     */
+    name: string;
+    /**
+     * - Image buffer data
+     */
+    image: Buffer;
+    /**
+     * - Additional properties
+     */
+    properties?: {
+        [x: string]: any;
+    };
+    /**
+     * - Comparison threshold override
+     */
+    threshold?: number;
+    /**
+     * - Screenshot group/category
+     */
+    group?: string;
+    /**
+     * - Screenshot tags
+     */
+    tags?: string[];
+};
+export type UploadOptions = {
+    /**
+     * - Directory containing screenshots
+     */
+    screenshotsDir: string;
+    /**
+     * - Name for this build
+     */
+    buildName?: string;
+    /**
+     * - Git branch name
+     */
+    branch?: string;
+    /**
+     * - Git commit SHA
+     */
+    commit?: string;
+    /**
+     * - Commit message
+     */
+    message?: string;
+    /**
+     * - Environment name
+     */
+    environment?: string;
+    /**
+     * - Default comparison threshold
+     */
+    threshold?: number;
+    /**
+     * - Progress callback
+     */
+    onProgress?: ProgressCallback;
+};
+export type UploadResult = {
+    /**
+     * - Whether upload succeeded
+     */
+    success: boolean;
+    /**
+     * - Build ID if successful
+     */
+    buildId?: string;
+    /**
+     * - Build URL if available
+     */
+    url?: string;
+    /**
+     * - Upload statistics
+     */
+    stats: UploadStats;
+    /**
+     * - Error message if failed
+     */
+    error?: string;
+};
+export type UploadStats = {
+    /**
+     * - Total files found
+     */
+    total: number;
+    /**
+     * - Files uploaded
+     */
+    uploaded: number;
+    /**
+     * - Files skipped (duplicates)
+     */
+    skipped: number;
+    /**
+     * - Files failed to upload
+     */
+    failed: number;
+};
+export type ProgressEvent = {
+    /**
+     * - Current phase
+     */
+    phase: "scanning" | "processing" | "deduplication" | "uploading" | "completed" | "error";
+    /**
+     * - Current item being processed
+     */
+    current?: number;
+    /**
+     * - Total items to process
+     */
+    total?: number;
+    /**
+     * - Progress message
+     */
+    message?: string;
+    /**
+     * - Files to upload (deduplication phase)
+     */
+    toUpload?: number;
+    /**
+     * - Existing files (deduplication phase)
+     */
+    existing?: number;
+    /**
+     * - Build ID (completed phase)
+     */
+    buildId?: string;
+    /**
+     * - Build URL (completed phase)
+     */
+    url?: string;
+};
+export type ProgressCallback = (event: ProgressEvent) => void;
+export type TDDOptions = {
+    /**
+     * - Baseline screenshots directory
+     */
+    baselineDir?: string;
+    /**
+     * - Current screenshots directory
+     */
+    currentDir?: string;
+    /**
+     * - Diff output directory
+     */
+    diffDir?: string;
+    /**
+     * - Comparison threshold
+     */
+    threshold?: number;
+    /**
+     * - Fail on any difference
+     */
+    failOnDifference?: boolean;
+    /**
+     * - Update baseline on difference
+     */
+    updateBaseline?: boolean;
+};
+export type ComparisonResult = {
+    /**
+     * - Screenshot name
+     */
+    name: string;
+    /**
+     * - Whether comparison passed
+     */
+    passed: boolean;
+    /**
+     * - Difference percentage (0-1)
+     */
+    difference?: number;
+    /**
+     * - Path to diff image
+     */
+    diffPath?: string;
+    /**
+     * - Error message if comparison failed
+     */
+    error?: string;
+};
+export type BuildInfo = {
+    /**
+     * - Build ID
+     */
+    id: string;
+    /**
+     * - Build name
+     */
+    name: string;
+    /**
+     * - Build status
+     */
+    status: "pending" | "processing" | "completed" | "failed";
+    /**
+     * - Git branch
+     */
+    branch: string;
+    /**
+     * - Git commit SHA
+     */
+    commit?: string;
+    /**
+     * - Environment name
+     */
+    environment: string;
+    /**
+     * - Creation timestamp
+     */
+    createdAt: Date;
+    /**
+     * - Completion timestamp
+     */
+    completedAt?: Date;
+    /**
+     * - Number of screenshots
+     */
+    screenshotCount: number;
+    /**
+     * - Additional metadata
+     */
+    metadata?: {
+        [x: string]: any;
+    };
+};
+export type CLIOptions = {
+    /**
+     * - Enable verbose logging
+     */
+    verbose?: boolean;
+    /**
+     * - Log level
+     */
+    logLevel?: string;
+    /**
+     * - Suppress all output
+     */
+    quiet?: boolean;
+    /**
+     * - Output JSON instead of text
+     */
+    json?: boolean;
+    /**
+     * - Path to config file
+     */
+    config?: string;
+};

package/dist/types/utils/colors.d.ts

@@ -0,0 +1,12 @@
+export function createColors(options?: {}): {
+    success: any;
+    error: any;
+    warning: any;
+    info: any;
+};
+export namespace colors {
+    let success: any;
+    let error: any;
+    let warning: any;
+    let info: any;
+}