@vizzly-testing/cli 0.1.0

package/dist/services/api-service.js

@@ -0,0 +1,215 @@
+/**
+ * API Service for Vizzly
+ * Handles HTTP requests to the Vizzly API
+ */
+
+import { URLSearchParams } from 'url';
+import { VizzlyError } from '../errors/vizzly-error.js';
+import crypto from 'crypto';
+import { getPackageVersion } from '../utils/package-info.js';
+import { getApiUrl, getApiToken, getUserAgent } from '../utils/environment-config.js';
+
+/**
+ * ApiService class for direct API communication
+ */
+export class ApiService {
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl || getApiUrl();
+    this.token = options.token || getApiToken();
+
+    // Build User-Agent string
+    const command = options.command || 'run'; // Default to 'run' for API service
+    const baseUserAgent = `vizzly-cli/${getPackageVersion()} (${command})`;
+    const sdkUserAgent = options.userAgent || getUserAgent();
+    this.userAgent = sdkUserAgent ? `${baseUserAgent} ${sdkUserAgent}` : baseUserAgent;
+    if (!this.token && !options.allowNoToken) {
+      throw new VizzlyError('No API token provided. Set VIZZLY_TOKEN environment variable.');
+    }
+  }
+
+  /**
+   * Make an API request
+   * @param {string} endpoint - API endpoint
+   * @param {Object} options - Fetch options
+   * @returns {Promise<Object>} Response data
+   */
+  async request(endpoint, options = {}) {
+    const url = `${this.baseUrl}${endpoint}`;
+    const headers = {
+      'User-Agent': this.userAgent,
+      ...options.headers
+    };
+    if (this.token) {
+      headers.Authorization = `Bearer ${this.token}`;
+    }
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+    if (!response.ok) {
+      let errorText = '';
+      try {
+        if (typeof response.text === 'function') {
+          errorText = await response.text();
+        } else {
+          errorText = response.statusText || '';
+        }
+      } catch {
+        // ignore
+      }
+      throw new VizzlyError(`API request failed: ${response.status}${errorText ? ` - ${errorText}` : ''} (URL: ${url})`);
+    }
+    return response.json();
+  }
+
+  /**
+   * Get build information
+   * @param {string} buildId - Build ID
+   * @param {string} include - Optional include parameter (e.g., 'screenshots')
+   * @returns {Promise<Object>} Build data
+   */
+  async getBuild(buildId, include = null) {
+    const endpoint = include ? `/api/sdk/builds/${buildId}?include=${include}` : `/api/sdk/builds/${buildId}`;
+    return this.request(endpoint);
+  }
+
+  /**
+   * Get comparison information
+   * @param {string} comparisonId - Comparison ID
+   * @returns {Promise<Object>} Comparison data
+   */
+  async getComparison(comparisonId) {
+    return this.request(`/api/sdk/comparisons/${comparisonId}`);
+  }
+
+  /**
+   * Get builds for a project
+   * @param {Object} filters - Filter options
+   * @returns {Promise<Array>} List of builds
+   */
+  async getBuilds(filters = {}) {
+    const queryParams = new URLSearchParams(filters).toString();
+    const endpoint = `/api/sdk/builds${queryParams ? `?${queryParams}` : ''}`;
+    return this.request(endpoint);
+  }
+
+  /**
+   * Create a new build
+   * @param {Object} metadata - Build metadata
+   * @returns {Promise<Object>} Created build data
+   */
+  async createBuild(metadata) {
+    return this.request('/api/sdk/builds', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(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
+   */
+  async checkShas(shas) {
+    try {
+      const response = await this.request('/api/sdk/check-shas', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          shas
+        })
+      });
+      return response.existing || [];
+    } catch (error) {
+      // Continue without deduplication on error
+      console.debug('SHA check failed, continuing without deduplication:', error.message);
+      return [];
+    }
+  }
+
+  /**
+   * Upload a screenshot with SHA checking
+   * @param {string} buildId - Build ID
+   * @param {string} name - Screenshot name
+   * @param {Buffer} buffer - Screenshot data
+   * @param {Object} metadata - Additional metadata
+   * @returns {Promise<Object>} Upload result
+   */
+  async uploadScreenshot(buildId, name, buffer, metadata = {}) {
+    // Calculate SHA256 of the image
+    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
+      return {
+        message: 'Screenshot already exists, skipped upload',
+        sha256,
+        skipped: true
+      };
+    }
+
+    // File doesn't exist, proceed with upload
+    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 ?? {},
+        sha256 // Include SHA for server-side deduplication
+      })
+    });
+  }
+
+  /**
+   * Update build status
+   * @param {string} buildId - Build ID
+   * @param {string} status - Build status (pending|running|completed|failed)
+   * @param {number} executionTimeMs - Execution time in milliseconds
+   * @returns {Promise<Object>} Updated build data
+   */
+  async updateBuildStatus(buildId, status, executionTimeMs = null) {
+    const body = {
+      status
+    };
+    if (executionTimeMs !== null) {
+      body.executionTimeMs = executionTimeMs;
+    }
+    return this.request(`/api/sdk/builds/${buildId}/status`, {
+      method: 'PUT',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(body)
+    });
+  }
+
+  /**
+   * Finalize a build (convenience method)
+   * @param {string} buildId - Build ID
+   * @param {boolean} success - Whether the build succeeded
+   * @param {number} executionTimeMs - Execution time in milliseconds
+   * @returns {Promise<Object>} Finalized build data
+   */
+  async finalizeBuild(buildId, success = true, executionTimeMs = null) {
+    const status = success ? 'completed' : 'failed';
+    return this.updateBuildStatus(buildId, status, executionTimeMs);
+  }
+
+  /**
+   * Get token context (organization and project info)
+   * @returns {Promise<Object>} Token context data
+   */
+  async getTokenContext() {
+    return this.request('/api/sdk/token/context');
+  }
+}

package/dist/services/base-service.js

@@ -0,0 +1,154 @@
+/**
+ * Base Service Class
+ * Provides common functionality for all services
+ */
+
+import { EventEmitter } from 'events';
+import { VizzlyError } from '../errors/vizzly-error.js';
+import { createStandardLogger } from '../utils/logger-factory.js';
+
+/**
+ * @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 {
+  /**
+   * @param {Object} config - Service configuration
+   * @param {ServiceOptions} options - Service options
+   */
+  constructor(config, options = {}) {
+    super();
+    this.config = config;
+    this.logger = options.logger || createStandardLogger({
+      level: 'info'
+    });
+    this.signal = options.signal;
+    this.started = false;
+    this.stopping = false;
+
+    // Setup signal handling
+    if (this.signal) {
+      this.signal.addEventListener('abort', () => this.stop());
+    }
+  }
+
+  /**
+   * Start the service
+   * @returns {Promise<void>}
+   */
+  async start() {
+    if (this.started) {
+      this.logger.warn(`${this.constructor.name} already started`);
+      return;
+    }
+    try {
+      this.emit('starting');
+      await this.onStart();
+      this.started = true;
+      this.emit('started');
+    } catch (error) {
+      this.emit('error', error);
+      throw new VizzlyError(`Failed to start ${this.constructor.name}`, 'SERVICE_START_FAILED', {
+        service: this.constructor.name,
+        error: error.message
+      });
+    }
+  }
+
+  /**
+   * Stop the service
+   * @returns {Promise<void>}
+   */
+  async stop() {
+    if (!this.started || this.stopping) {
+      return;
+    }
+    this.stopping = true;
+    try {
+      this.emit('stopping');
+      await this.onStop();
+      this.started = false;
+      this.emit('stopped');
+    } catch (error) {
+      this.emit('error', error);
+      throw new VizzlyError(`Failed to stop ${this.constructor.name}`, 'SERVICE_STOP_FAILED', {
+        service: this.constructor.name,
+        error: error.message
+      });
+    } finally {
+      this.stopping = false;
+    }
+  }
+
+  /**
+   * Hook for service-specific start logic
+   * @protected
+   * @returns {Promise<void>}
+   */
+  async onStart() {
+    // Override in subclasses
+  }
+
+  /**
+   * Hook for service-specific stop logic
+   * @protected
+   * @returns {Promise<void>}
+   */
+  async onStop() {
+    // Override in subclasses
+  }
+
+  /**
+   * Emit a progress event
+   * @param {string} phase - Progress phase
+   * @param {string} message - Progress message
+   * @param {Object} [data] - Additional data
+   */
+  emitProgress(phase, message, data = {}) {
+    this.emit('progress', {
+      phase,
+      message,
+      timestamp: new Date().toISOString(),
+      ...data
+    });
+  }
+
+  /**
+   * Check if service is running
+   * @returns {boolean}
+   */
+  isRunning() {
+    return this.started && !this.stopping;
+  }
+
+  /**
+   * Wait for service to be ready
+   * @param {number} [timeout=30000] - Timeout in milliseconds
+   * @returns {Promise<void>}
+   */
+  async waitForReady(timeout = 30000) {
+    if (this.started) return;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        reject(new VizzlyError('Service start timeout', 'SERVICE_TIMEOUT', {
+          service: this.constructor.name,
+          timeout
+        }));
+      }, timeout);
+      this.once('started', () => {
+        clearTimeout(timer);
+        resolve();
+      });
+      this.once('error', error => {
+        clearTimeout(timer);
+        reject(error);
+      });
+    });
+  }
+}

package/dist/services/build-manager.js

@@ -0,0 +1,214 @@
+/**
+ * Build Manager Service
+ * Manages the build lifecycle and coordinates test execution
+ */
+
+import crypto from 'crypto';
+import { VizzlyError } from '../errors/vizzly-error.js';
+import { BaseService } from './base-service.js';
+
+/**
+ * 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() {
+  return `build-${crypto.randomUUID()}`;
+}
+
+/**
+ * Create build object
+ * @param {Object} buildOptions - Build configuration
+ * @returns {Object} Build object
+ */
+export function createBuildObject(buildOptions) {
+  const {
+    name,
+    branch,
+    commit,
+    environment = 'test',
+    metadata = {}
+  } = buildOptions;
+  return {
+    id: generateBuildId(),
+    name: name || `build-${Date.now()}`,
+    branch,
+    commit,
+    environment,
+    metadata,
+    status: 'pending',
+    createdAt: new Date().toISOString(),
+    screenshots: []
+  };
+}
+
+/**
+ * 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, status, updates = {}) {
+  return {
+    ...build,
+    status,
+    updatedAt: new Date().toISOString(),
+    ...updates
+  };
+}
+
+/**
+ * Add screenshot to build
+ * @param {Object} build - Current build
+ * @param {Object} screenshot - Screenshot data
+ * @returns {Object} Updated build
+ */
+export function addScreenshotToBuild(build, screenshot) {
+  return {
+    ...build,
+    screenshots: [...build.screenshots, {
+      ...screenshot,
+      addedAt: new Date().toISOString()
+    }]
+  };
+}
+
+/**
+ * Finalize build with result
+ * @param {Object} build - Current build
+ * @param {Object} result - Build result
+ * @returns {Object} Finalized build
+ */
+export function finalizeBuildObject(build, result = {}) {
+  const finalStatus = result.success ? 'completed' : 'failed';
+  return {
+    ...build,
+    status: finalStatus,
+    completedAt: new Date().toISOString(),
+    result
+  };
+}
+
+/**
+ * Create queued build item
+ * @param {Object} buildOptions - Build options
+ * @returns {Object} Queued build item
+ */
+export function createQueuedBuild(buildOptions) {
+  return {
+    ...buildOptions,
+    queuedAt: new Date().toISOString()
+  };
+}
+
+/**
+ * Validate build options
+ * @param {Object} buildOptions - Build options to validate
+ * @returns {Object} Validation result
+ */
+export function validateBuildOptions(buildOptions) {
+  const errors = [];
+  if (!buildOptions.name && !buildOptions.branch) {
+    errors.push('Either name or branch is required');
+  }
+  if (buildOptions.environment && !['test', 'staging', 'production'].includes(buildOptions.environment)) {
+    errors.push('Environment must be one of: test, staging, production');
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+export class BuildManager extends BaseService {
+  constructor(config, logger) {
+    super(config, {
+      logger
+    });
+    this.currentBuild = null;
+    this.buildQueue = [];
+  }
+  async onStart() {
+    this.emitProgress('initializing', 0);
+  }
+  async onStop() {
+    if (this.currentBuild && this.currentBuild.status === 'pending') {
+      await this.updateBuildStatus(this.currentBuild.id, 'cancelled');
+    }
+    this.buildQueue.length = 0;
+    this.currentBuild = null;
+  }
+  async createBuild(buildOptions) {
+    this.emitProgress('creating', 'Creating new build...');
+    const build = createBuildObject(buildOptions);
+    this.currentBuild = build;
+    this.emitProgress('created', `Build created: ${build.name}`, {
+      build
+    });
+    return build;
+  }
+  async updateBuildStatus(buildId, status, updates = {}) {
+    if (!this.currentBuild || this.currentBuild.id !== buildId) {
+      throw new VizzlyError(`Build ${buildId} not found`, 'BUILD_NOT_FOUND');
+    }
+    this.currentBuild = updateBuild(this.currentBuild, status, updates);
+    this.emitProgress('updated', `Build status: ${status}`, {
+      buildId,
+      status,
+      build: this.currentBuild
+    });
+    return this.currentBuild;
+  }
+  async addScreenshot(buildId, screenshot) {
+    if (!this.currentBuild || this.currentBuild.id !== buildId) {
+      throw new VizzlyError(`Build ${buildId} not found`, 'BUILD_NOT_FOUND');
+    }
+    this.currentBuild = addScreenshotToBuild(this.currentBuild, screenshot);
+    this.emitProgress('screenshot-added', 'Screenshot added to build', {
+      buildId,
+      screenshotCount: this.currentBuild.screenshots.length,
+      screenshot
+    });
+    return this.currentBuild;
+  }
+  async finalizeBuild(buildId, result = {}) {
+    if (!this.currentBuild || this.currentBuild.id !== buildId) {
+      throw new VizzlyError(`Build ${buildId} not found`, 'BUILD_NOT_FOUND');
+    }
+    this.currentBuild = finalizeBuildObject(this.currentBuild, result);
+    this.emitProgress('finalized', `Build ${this.currentBuild.status}`, {
+      buildId,
+      build: this.currentBuild,
+      result
+    });
+    return this.currentBuild;
+  }
+  getCurrentBuild() {
+    return this.currentBuild;
+  }
+  queueBuild(buildOptions) {
+    const queuedBuild = createQueuedBuild(buildOptions);
+    this.buildQueue.push(queuedBuild);
+    this.emitProgress('queued', 'Build queued for processing', {
+      queueLength: this.buildQueue.length
+    });
+  }
+  async processNextBuild() {
+    if (this.buildQueue.length === 0) {
+      return null;
+    }
+    const buildOptions = this.buildQueue.shift();
+    return await this.createBuild(buildOptions);
+  }
+  getQueueStatus() {
+    return {
+      length: this.buildQueue.length,
+      items: this.buildQueue.map(item => ({
+        name: item.name,
+        branch: item.branch,
+        queuedAt: item.queuedAt
+      }))
+    };
+  }
+}

package/dist/services/screenshot-server.js

@@ -0,0 +1,96 @@
+/**
+ * Screenshot Server Service
+ * Listens for and processes screenshots from the test runner
+ */
+
+import { createServer } from 'http';
+import { BaseService } from './base-service.js';
+import { VizzlyError } from '../errors/vizzly-error.js';
+export class ScreenshotServer extends BaseService {
+  constructor(config, logger, buildManager) {
+    super(config, logger);
+    this.buildManager = buildManager;
+    this.server = null;
+  }
+  async onStart() {
+    this.server = createServer(this.handleRequest.bind(this));
+    return new Promise((resolve, reject) => {
+      this.server.listen(this.config.server.port, '127.0.0.1', error => {
+        if (error) {
+          reject(new VizzlyError(`Failed to start screenshot server: ${error.message}`, 'SERVER_ERROR'));
+        } else {
+          this.logger.info(`Screenshot server listening on http://127.0.0.1:${this.config.server.port}`);
+          resolve();
+        }
+      });
+    });
+  }
+  async onStop() {
+    if (this.server) {
+      return new Promise(resolve => {
+        this.server.close(() => {
+          this.logger.info('Screenshot server stopped');
+          resolve();
+        });
+      });
+    }
+  }
+  async handleRequest(req, res) {
+    if (req.method === 'POST' && req.url === '/screenshot') {
+      try {
+        const body = await this.parseRequestBody(req);
+        const {
+          buildId,
+          name,
+          image,
+          properties
+        } = body;
+        if (!buildId || !name || !image) {
+          res.statusCode = 400;
+          res.end(JSON.stringify({
+            error: 'buildId, name, and image are required'
+          }));
+          return;
+        }
+        await this.buildManager.addScreenshot(buildId, {
+          name,
+          image,
+          properties
+        });
+        res.statusCode = 200;
+        res.end(JSON.stringify({
+          success: true
+        }));
+      } catch (error) {
+        this.logger.error('Failed to process screenshot:', error);
+        res.statusCode = 500;
+        res.end(JSON.stringify({
+          error: 'Internal server error'
+        }));
+      }
+    } else {
+      res.statusCode = 404;
+      res.end(JSON.stringify({
+        error: 'Not found'
+      }));
+    }
+  }
+  async parseRequestBody(req) {
+    return new Promise((resolve, reject) => {
+      let body = '';
+      req.on('data', chunk => {
+        body += chunk.toString();
+      });
+      req.on('end', () => {
+        try {
+          resolve(JSON.parse(body));
+        } catch {
+          reject(new VizzlyError('Invalid JSON in request body', 'INVALID_JSON'));
+        }
+      });
+      req.on('error', error => {
+        reject(new VizzlyError(`Request error: ${error.message}`, 'REQUEST_ERROR'));
+      });
+    });
+  }
+}