@vizzly-testing/cli 0.3.2 → 0.5.0

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

@@ -3,8 +3,12 @@
  * @param {string} testCommand - Test command to execute
  * @param {Object} options - Command options
  * @param {Object} globalOptions - Global CLI options
+ * @returns {Promise<{result: Object, cleanup: Function}>} Result and cleanup function
  */
-export function tddCommand(testCommand: string, options?: any, globalOptions?: any): Promise<void>;
+export function tddCommand(testCommand: string, options?: any, globalOptions?: any): Promise<{
+    result: any;
+    cleanup: Function;
+}>;
 /**
  * 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

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/services/uploader.d.ts

@@ -8,7 +8,7 @@ export function createUploader({ apiKey, apiUrl, userAgent, command, upload: upl
     command: any;
     upload?: {};
 }, options?: {}): {
-    upload: ({ screenshotsDir, buildName, branch, commit, message, environment, threshold, onProgress, }: {
+    upload: ({ screenshotsDir, buildName, branch, commit, message, environment, threshold, pullRequestNumber, onProgress, }: {
         screenshotsDir: any;
         buildName: any;
         branch: any;
@@ -16,6 +16,7 @@ export function createUploader({ apiKey, apiUrl, userAgent, command, upload: upl
         message: any;
         environment?: string;
         threshold: any;
+        pullRequestNumber: any;
         onProgress?: () => void;
     }) => Promise<{
         success: boolean;

package/dist/types/utils/ci-env.d.ts

@@ -0,0 +1,55 @@
+/**
+ * CI Environment Detection
+ *
+ * Generic functions to extract git and PR information from any CI provider
+ */
+/**
+ * Get the branch name from CI environment variables
+ * @returns {string|null} Branch name or null if not available
+ */
+export function getBranch(): string | null;
+/**
+ * Get the commit SHA from CI environment variables
+ * @returns {string|null} Commit SHA or null if not available
+ */
+export function getCommit(): string | null;
+/**
+ * Get the commit message from CI environment variables
+ * @returns {string|null} Commit message or null if not available
+ */
+export function getCommitMessage(): string | null;
+/**
+ * Get the pull request number from CI environment variables
+ * @returns {number|null} PR number or null if not available/not a PR
+ */
+export function getPullRequestNumber(): number | null;
+/**
+ * Get the PR head SHA from CI environment variables
+ * @returns {string|null} PR head SHA or null if not available
+ */
+export function getPullRequestHeadSha(): string | null;
+/**
+ * Get the PR base SHA from CI environment variables
+ * @returns {string|null} PR base SHA or null if not available
+ */
+export function getPullRequestBaseSha(): string | null;
+/**
+ * Get the PR head ref (branch) from CI environment variables
+ * @returns {string|null} PR head ref or null if not available
+ */
+export function getPullRequestHeadRef(): string | null;
+/**
+ * Get the PR base ref (target branch) from CI environment variables
+ * @returns {string|null} PR base ref or null if not available
+ */
+export function getPullRequestBaseRef(): string | null;
+/**
+ * Check if we're currently in a pull request context
+ * @returns {boolean} True if in a PR context
+ */
+export function isPullRequest(): boolean;
+/**
+ * Get the CI provider name
+ * @returns {string} CI provider name or 'unknown'
+ */
+export function getCIProvider(): string;

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
      */

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

@@ -9,6 +9,13 @@ export function generateBuildName(): string;
  * @returns {Promise<string|null>} Commit message or null if not available
  */
 export function getCommitMessage(cwd?: string): Promise<string | null>;
+/**
+ * Detect commit message with override and environment variable support
+ * @param {string} override - Commit message override from CLI
+ * @param {string} cwd - Working directory
+ * @returns {Promise<string|null>} Commit message or null if not available
+ */
+export function detectCommitMessage(override?: string, cwd?: string): Promise<string | null>;
 /**
  * Check if the working directory is a git repository
  * @param {string} cwd - Working directory
@@ -42,3 +49,8 @@ export function detectCommit(override?: string, cwd?: string): Promise<string |
  * @returns {Promise<string>}
  */
 export function generateBuildNameWithGit(override?: string, cwd?: string): Promise<string>;
+/**
+ * Detect pull request number from CI environment
+ * @returns {number|null} Pull request number or null if not in PR context
+ */
+export function detectPullRequestNumber(): number | null;