@vizzly-testing/cli 0.30.0 → 0.31.0

package/dist/services/server-manager.js

@@ -1,81 +0,0 @@
-/**
- * Server Manager Service
- * Manages the HTTP server with functional handlers
- *
- * This class is a thin wrapper around the functional operations in
- * src/server-manager/. It maintains backwards compatibility while
- * delegating to pure functions for testability.
- */
-
-import { existsSync, mkdirSync, unlinkSync, writeFileSync } from 'node:fs';
-import { createApiClient } from '../api/index.js';
-import { createApiHandler } from '../server/handlers/api-handler.js';
-import { createTddHandler } from '../server/handlers/tdd-handler.js';
-import { createHttpServer } from '../server/http-server.js';
-import { buildServerInterface, getTddResults, startServer, stopServer } from '../server-manager/index.js';
-export class ServerManager {
-  constructor(config, options = {}) {
-    this.config = config;
-    this.httpServer = null;
-    this.handler = null;
-    this.services = options.services || {};
-    this.tddMode = false;
-
-    // Dependency injection for testing - defaults to real implementations
-    this.deps = options.deps || {
-      createHttpServer,
-      createTddHandler,
-      createApiHandler,
-      createApiClient,
-      fs: {
-        mkdirSync,
-        writeFileSync,
-        existsSync,
-        unlinkSync
-      }
-    };
-  }
-  async start(buildId = null, tddMode = false, setBaseline = false) {
-    this.buildId = buildId;
-    this.tddMode = tddMode;
-    this.setBaseline = setBaseline;
-    let result = await startServer({
-      config: this.config,
-      buildId,
-      tddMode,
-      setBaseline,
-      projectRoot: process.cwd(),
-      services: this.services,
-      deps: this.deps
-    });
-    this.httpServer = result.httpServer;
-    this.handler = result.handler;
-  }
-  async stop() {
-    await stopServer({
-      httpServer: this.httpServer,
-      handler: this.handler,
-      projectRoot: process.cwd(),
-      deps: this.deps
-    });
-  }
-
-  // Expose server interface for compatibility
-  get server() {
-    return buildServerInterface({
-      handler: this.handler,
-      httpServer: this.httpServer
-    });
-  }
-
-  /**
-   * Get TDD results (comparisons, screenshot count, etc.)
-   * Only available in TDD mode after tests have run
-   */
-  async getTddResults() {
-    return getTddResults({
-      tddMode: this.tddMode,
-      handler: this.handler
-    });
-  }
-}

package/dist/services/uploader.js

@@ -1,100 +0,0 @@
-/**
- * Vizzly Screenshot Uploader
- * Handles screenshot uploads to the Vizzly platform
- *
- * This module is a thin wrapper around the functional operations in
- * src/uploader/. It maintains backwards compatibility while
- * delegating to pure functions for testability.
- */
-
-import { readFile, stat } from 'node:fs/promises';
-import { glob } from 'glob';
-import { checkShas, createApiClient, createBuild } from '../api/index.js';
-import { TimeoutError, UploadError, ValidationError } from '../errors/vizzly-error.js';
-import { resolveBatchSize, resolveTimeout } from '../uploader/index.js';
-import { upload as uploadOperation, waitForBuild as waitForBuildOperation } from '../uploader/operations.js';
-import { getDefaultBranch } from '../utils/git.js';
-import * as output from '../utils/output.js';
-
-/**
- * Create a new uploader instance
- */
-export function createUploader({
-  apiKey,
-  apiUrl,
-  userAgent,
-  command,
-  upload: uploadConfig = {}
-} = {}, options = {}) {
-  let signal = options.signal || new AbortController().signal;
-  let client = createApiClient({
-    baseUrl: apiUrl,
-    token: apiKey,
-    command: command || 'upload',
-    sdkUserAgent: userAgent,
-    allowNoToken: true
-  });
-
-  // Resolve tunable parameters
-  let batchSize = resolveBatchSize(options, uploadConfig);
-  let timeout = resolveTimeout(options, uploadConfig);
-
-  // Dependency injection for testing
-  let deps = options.deps || {
-    client,
-    createBuild,
-    getDefaultBranch,
-    glob,
-    readFile,
-    stat,
-    checkShas,
-    createError: (message, code, context) => {
-      let error = new UploadError(message, context);
-      error.code = code;
-      return error;
-    },
-    createValidationError: (message, context) => new ValidationError(message, context),
-    createUploadError: (message, context) => new UploadError(message, context),
-    createTimeoutError: (message, context) => new TimeoutError(message, context),
-    output
-  };
-
-  /**
-   * Upload screenshots to Vizzly
-   */
-  async function upload(uploadOptions) {
-    return uploadOperation({
-      uploadOptions,
-      config: {
-        apiKey,
-        apiUrl
-      },
-      signal,
-      batchSize,
-      deps: {
-        ...deps,
-        client: deps.client || client
-      }
-    });
-  }
-
-  /**
-   * Wait for a build to complete
-   */
-  async function waitForBuild(buildId, waitTimeout = timeout) {
-    return waitForBuildOperation({
-      buildId,
-      timeout: waitTimeout,
-      signal,
-      client: deps.client || client,
-      deps: {
-        createError: deps.createError,
-        createTimeoutError: deps.createTimeoutError
-      }
-    });
-  }
-  return {
-    upload,
-    waitForBuild
-  };
-}

package/dist/tdd/services/region-service.js

@@ -1,75 +0,0 @@
-/**
- * Region Service
- *
- * Functions for downloading and managing user-defined hotspot regions from the cloud.
- * Regions are 2D bounding boxes that users have confirmed as dynamic content areas.
- */
-
-import { saveRegionMetadata } from '../metadata/region-metadata.js';
-
-/**
- * Download user-defined regions from cloud API
- *
- * @param {Object} options
- * @param {Object} options.api - ApiService instance
- * @param {string} options.workingDir - Working directory
- * @param {string[]} options.screenshotNames - Names of screenshots to get regions for
- * @param {boolean} options.includeCandidates - Include candidate regions (default: false)
- * @returns {Promise<{ success: boolean, count: number, regionCount: number, error?: string }>}
- */
-export async function downloadRegions(options) {
-  let {
-    api,
-    workingDir,
-    screenshotNames,
-    includeCandidates = false
-  } = options;
-  if (!screenshotNames || screenshotNames.length === 0) {
-    return {
-      success: true,
-      count: 0,
-      regionCount: 0
-    };
-  }
-  try {
-    let response = await api.getRegions(screenshotNames, {
-      includeCandidates
-    });
-    if (!response?.regions) {
-      return {
-        success: false,
-        error: 'API returned no region data'
-      };
-    }
-
-    // Save regions to disk
-    saveRegionMetadata(workingDir, response.regions, response.summary);
-
-    // Calculate stats
-    let count = Object.keys(response.regions).length;
-    let regionCount = response.summary?.total_regions || 0;
-    return {
-      success: true,
-      count,
-      regionCount
-    };
-  } catch (error) {
-    return {
-      success: false,
-      error: error.message
-    };
-  }
-}
-
-/**
- * Extract screenshot names from a list of screenshots
- *
- * @param {Array} screenshots - Screenshots with name property
- * @returns {string[]}
- */
-export function extractScreenshotNames(screenshots) {
-  if (!screenshots || !Array.isArray(screenshots)) {
-    return [];
-  }
-  return screenshots.map(s => s.name).filter(Boolean);
-}

package/dist/utils/build-history.js

@@ -1,103 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-
-/**
- * Archive a build to history directory
- * @param {string} workingDir - Working directory
- * @param {string} buildId - Build ID to archive
- * @param {Array} builds - Build data
- * @param {Array} comparisons - Comparison data
- * @param {Object} summary - Summary stats
- * @param {number} maxHistory - Maximum number of builds to keep (default: 3)
- */
-export function archiveBuild(workingDir, buildId, builds, comparisons, summary, maxHistory = 3) {
-  const historyDir = join(workingDir, '.vizzly', 'history');
-
-  // Create history directory if it doesn't exist
-  if (!existsSync(historyDir)) {
-    mkdirSync(historyDir, {
-      recursive: true
-    });
-  }
-
-  // Save current build to history
-  const buildDir = join(historyDir, buildId);
-  if (!existsSync(buildDir)) {
-    mkdirSync(buildDir, {
-      recursive: true
-    });
-  }
-  const buildData = {
-    buildId,
-    timestamp: Date.now(),
-    builds,
-    comparisons,
-    summary
-  };
-  writeFileSync(join(buildDir, 'report.json'), JSON.stringify(buildData, null, 2));
-
-  // Clean up old builds (keep last N)
-  cleanupOldBuilds(historyDir, maxHistory);
-}
-
-/**
- * Get list of archived builds
- * @param {string} workingDir - Working directory
- * @returns {Array} Array of build metadata
- */
-export function getArchivedBuilds(workingDir) {
-  const historyDir = join(workingDir, '.vizzly', 'history');
-  if (!existsSync(historyDir)) {
-    return [];
-  }
-  try {
-    const buildDirs = readdirSync(historyDir, {
-      withFileTypes: true
-    }).filter(dirent => dirent.isDirectory()).map(dirent => dirent.name).sort().reverse(); // Newest first
-
-    return buildDirs.map(buildId => {
-      const reportPath = join(historyDir, buildId, 'report.json');
-      if (existsSync(reportPath)) {
-        try {
-          const data = JSON.parse(require('node:fs').readFileSync(reportPath, 'utf8'));
-          return {
-            buildId: data.buildId,
-            timestamp: data.timestamp,
-            summary: data.summary
-          };
-        } catch {
-          return null;
-        }
-      }
-      return null;
-    }).filter(Boolean);
-  } catch {
-    return [];
-  }
-}
-
-/**
- * Remove old builds, keeping only the last N
- * @private
- */
-function cleanupOldBuilds(historyDir, maxHistory) {
-  try {
-    const buildDirs = readdirSync(historyDir, {
-      withFileTypes: true
-    }).filter(dirent => dirent.isDirectory()).map(dirent => dirent.name).sort().reverse(); // Newest first
-
-    // Remove builds beyond maxHistory
-    if (buildDirs.length > maxHistory) {
-      const toRemove = buildDirs.slice(maxHistory);
-      toRemove.forEach(buildId => {
-        const buildDir = join(historyDir, buildId);
-        rmSync(buildDir, {
-          recursive: true,
-          force: true
-        });
-      });
-    }
-  } catch {
-    // Ignore cleanup errors
-  }
-}