@vizzly-testing/cli 0.20.0 → 0.20.1-beta.0

package/dist/commands/run.js

@@ -1,65 +1,118 @@
-import { createServices } from '../services/index.js';
-import { loadConfig } from '../utils/config-loader.js';
-import { detectBranch, detectCommit, detectCommitMessage, detectPullRequestNumber, generateBuildNameWithGit } from '../utils/git.js';
-import * as output from '../utils/output.js';
+/**
+ * Run command implementation
+ * Uses functional operations directly - no class wrappers needed
+ */
+
+import { spawn as defaultSpawn } from 'node:child_process';
+import { createBuild as defaultCreateApiBuild, createApiClient as defaultCreateApiClient, finalizeBuild as defaultFinalizeApiBuild, getBuild as defaultGetBuild } from '../api/index.js';
+import { VizzlyError } from '../errors/vizzly-error.js';
+import { createServerManager as defaultCreateServerManager } from '../server-manager/index.js';
+import { createBuildObject as defaultCreateBuildObject } from '../services/build-manager.js';
+import { createUploader as defaultCreateUploader } from '../services/uploader.js';
+import { finalizeBuild as defaultFinalizeBuild, runTests as defaultRunTests } from '../test-runner/index.js';
+import { loadConfig as defaultLoadConfig } from '../utils/config-loader.js';
+import { detectBranch as defaultDetectBranch, detectCommit as defaultDetectCommit, detectCommitMessage as defaultDetectCommitMessage, detectPullRequestNumber as defaultDetectPullRequestNumber, generateBuildNameWithGit as defaultGenerateBuildNameWithGit } from '../utils/git.js';
+import * as defaultOutput from '../utils/output.js';
 
 /**
  * Run command implementation
  * @param {string} testCommand - Test command to execute
  * @param {Object} options - Command options
  * @param {Object} globalOptions - Global CLI options
+ * @param {Object} deps - Dependencies for testing
  */
-export async function runCommand(testCommand, options = {}, globalOptions = {}) {
+export async function runCommand(testCommand, options = {}, globalOptions = {}, deps = {}) {
+  let {
+    loadConfig = defaultLoadConfig,
+    createApiClient = defaultCreateApiClient,
+    createApiBuild = defaultCreateApiBuild,
+    finalizeApiBuild = defaultFinalizeApiBuild,
+    getBuild = defaultGetBuild,
+    createServerManager = defaultCreateServerManager,
+    createBuildObject = defaultCreateBuildObject,
+    createUploader = defaultCreateUploader,
+    finalizeBuild = defaultFinalizeBuild,
+    runTests = defaultRunTests,
+    detectBranch = defaultDetectBranch,
+    detectCommit = defaultDetectCommit,
+    detectCommitMessage = defaultDetectCommitMessage,
+    detectPullRequestNumber = defaultDetectPullRequestNumber,
+    generateBuildNameWithGit = defaultGenerateBuildNameWithGit,
+    spawn = defaultSpawn,
+    output = defaultOutput,
+    exit = code => process.exit(code),
+    processOn = (event, handler) => process.on(event, handler),
+    processRemoveListener = (event, handler) => process.removeListener(event, handler)
+  } = deps;
   output.configure({
     json: globalOptions.json,
     verbose: globalOptions.verbose,
     color: !globalOptions.noColor
   });
-  let testRunner = null;
+  let serverManager = null;
+  let testProcess = null;
   let buildId = null;
   let startTime = null;
   let isTddMode = false;
+  let config = null;
 
   // Ensure cleanup on exit
-  const cleanup = async () => {
+  let cleanup = async () => {
     output.cleanup();
 
-    // Cancel test runner (kills process and stops server)
-    if (testRunner) {
+    // Kill test process if running
+    if (testProcess && !testProcess.killed) {
+      testProcess.kill('SIGKILL');
+    }
+
+    // Stop server
+    if (serverManager) {
       try {
-        await testRunner.cancel();
+        await serverManager.stop();
       } catch {
         // Silent fail
       }
     }
 
     // Finalize build if we have one
-    if (testRunner && buildId) {
+    if (buildId && config) {
       try {
-        const executionTime = Date.now() - (startTime || Date.now());
-        await testRunner.finalizeBuild(buildId, isTddMode, false, executionTime);
+        let executionTime = Date.now() - (startTime || Date.now());
+        await finalizeBuild({
+          buildId,
+          tdd: isTddMode,
+          success: false,
+          executionTime,
+          config,
+          deps: {
+            serverManager,
+            createApiClient,
+            finalizeApiBuild,
+            output
+          }
+        });
       } catch {
         // Silent fail on cleanup
       }
     }
   };
-  const sigintHandler = async () => {
+  let sigintHandler = async () => {
     await cleanup();
-    process.exit(1);
+    exit(1);
   };
-  const exitHandler = () => output.cleanup();
-  process.on('SIGINT', sigintHandler);
-  process.on('exit', exitHandler);
+  let exitHandler = () => output.cleanup();
+  processOn('SIGINT', sigintHandler);
+  processOn('exit', exitHandler);
   try {
     // Load configuration with CLI overrides
-    const allOptions = {
+    let allOptions = {
       ...globalOptions,
       ...options
     };
     output.debug('[RUN] Loading config', {
       hasToken: !!allOptions.token
     });
-    const config = await loadConfig(globalOptions.config, allOptions);
+    config = await loadConfig(globalOptions.config, allOptions);
     output.debug('[RUN] Config loaded', {
       hasApiKey: !!config.apiKey,
       apiKeyPrefix: config.apiKey ? `${config.apiKey.substring(0, 8)}***` : 'NONE'
@@ -78,15 +131,19 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
     // Validate API token (unless --allow-no-token is set)
     if (!config.apiKey && !config.allowNoToken) {
       output.error('API token required. Use --token, set VIZZLY_TOKEN environment variable, or use --allow-no-token to run without uploading');
-      process.exit(1);
+      exit(1);
+      return {
+        success: false,
+        reason: 'no-api-key'
+      };
     }
 
     // Collect git metadata and build info
-    const branch = await detectBranch(options.branch);
-    const commit = await detectCommit(options.commit);
-    const message = options.message || (await detectCommitMessage());
-    const buildName = await generateBuildNameWithGit(options.buildName);
-    const pullRequestNumber = detectPullRequestNumber();
+    let branch = await detectBranch(options.branch);
+    let commit = await detectCommit(options.commit);
+    let message = options.message || (await detectCommitMessage());
+    let buildName = await generateBuildNameWithGit(options.buildName);
+    let pullRequestNumber = detectPullRequestNumber();
     if (globalOptions.verbose) {
       output.info('Configuration loaded');
       output.debug('Config details', {
@@ -102,9 +159,9 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
       });
     }
 
-    // Create service container and get test runner service
+    // Create functional dependencies
     output.startSpinner('Initializing test runner...');
-    const configWithVerbose = {
+    let configWithVerbose = {
       ...config,
       verbose: globalOptions.verbose,
       uploadAll: options.uploadAll || false
@@ -112,59 +169,29 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
     output.debug('[RUN] Creating services', {
       hasApiKey: !!configWithVerbose.apiKey
     });
-    const services = createServices(configWithVerbose, 'run');
-    testRunner = services.testRunner;
-    output.stopSpinner();
 
-    // Track build URL for display
-    let buildUrl = null;
+    // Create server manager (functional object)
+    serverManager = createServerManager(configWithVerbose, {});
 
-    // Set up event handlers
-    testRunner.on('progress', progressData => {
-      const {
-        message: progressMessage
-      } = progressData;
-      output.progress(progressMessage || 'Running tests...');
-    });
-    testRunner.on('test-output', data => {
-      // In non-JSON mode, show test output directly
-      if (!globalOptions.json) {
-        output.stopSpinner();
-        output.print(data.data);
-      }
-    });
-    testRunner.on('server-ready', serverInfo => {
-      if (globalOptions.verbose) {
-        output.info(`Screenshot server running on port ${serverInfo.port}`);
-        output.debug('Server details', serverInfo);
-      }
-    });
-    testRunner.on('screenshot-captured', screenshotInfo => {
-      output.info(`Vizzly: Screenshot captured - ${screenshotInfo.name}`);
-    });
-    testRunner.on('build-created', buildInfo => {
-      buildUrl = buildInfo.url;
-      buildId = buildInfo.buildId;
-      if (globalOptions.verbose) {
-        output.info(`Build created: ${buildInfo.buildId} - ${buildInfo.name}`);
+    // Create build manager (functional object)
+    let buildManager = {
+      async createBuild(buildOptions) {
+        return createBuildObject(buildOptions);
       }
-      if (buildUrl) {
-        output.info(`Vizzly: ${buildUrl}`);
-      }
-    });
-    testRunner.on('build-failed', buildError => {
-      output.error('Failed to create build', buildError);
-    });
-    testRunner.on('error', error => {
-      output.stopSpinner();
-      output.error('Test runner error occurred', error);
-    });
-    testRunner.on('build-finalize-failed', errorInfo => {
-      output.warn(`Failed to finalize build ${errorInfo.buildId}: ${errorInfo.error}`);
+    };
+
+    // Create uploader for --wait functionality
+    let uploader = createUploader({
+      ...configWithVerbose,
+      command: 'run'
     });
+    output.stopSpinner();
+
+    // Track build URL for display
+    let buildUrl = null;
 
     // Prepare run options
-    const runOptions = {
+    let runOptions = {
       testCommand,
       port: config.server.port,
       timeout: config.server.timeout,
@@ -188,7 +215,43 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
     isTddMode = runOptions.tdd || false;
     let result;
     try {
-      result = await testRunner.run(runOptions);
+      result = await runTests({
+        runOptions,
+        config: configWithVerbose,
+        deps: {
+          serverManager,
+          buildManager,
+          spawn: (command, spawnOptions) => {
+            let proc = spawn(command, spawnOptions);
+            testProcess = proc;
+            return proc;
+          },
+          createApiClient,
+          createApiBuild,
+          getBuild,
+          finalizeApiBuild,
+          createError: (msg, code) => new VizzlyError(msg, code),
+          output,
+          onBuildCreated: data => {
+            buildUrl = data.url;
+            buildId = data.buildId;
+            if (globalOptions.verbose) {
+              output.info(`Build created: ${data.buildId}`);
+            }
+            if (buildUrl) {
+              output.info(`Vizzly: ${buildUrl}`);
+            }
+          },
+          onServerReady: data => {
+            if (globalOptions.verbose) {
+              output.info(`Screenshot server running on port ${data.port}`);
+            }
+          },
+          onFinalizeFailed: data => {
+            output.warn(`Failed to finalize build ${data.buildId}: ${data.error}`);
+          }
+        }
+      });
 
       // Store buildId for cleanup purposes
       if (result.buildId) {
@@ -210,8 +273,8 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
       // Check if it's a test command failure (as opposed to setup failure)
       if (error.code === 'TEST_COMMAND_FAILED' || error.code === 'TEST_COMMAND_INTERRUPTED') {
         // Extract exit code from error message if available
-        const exitCodeMatch = error.message.match(/exited with code (\d+)/);
-        const exitCode = exitCodeMatch ? parseInt(exitCodeMatch[1], 10) : 1;
+        let exitCodeMatch = error.message.match(/exited with code (\d+)/);
+        let exitCode = exitCodeMatch ? parseInt(exitCodeMatch[1], 10) : 1;
         output.error('Test run failed');
         return {
           success: false,
@@ -233,10 +296,7 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
       if (runOptions.wait) {
         output.info('Waiting for build completion...');
         output.startSpinner('Processing comparisons...');
-        const {
-          uploader
-        } = services;
-        const buildResult = await uploader.waitForBuild(result.buildId);
+        let buildResult = await uploader.waitForBuild(result.buildId);
         output.success('Build processing completed');
 
         // Exit with appropriate code based on comparison results
@@ -250,6 +310,10 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
       }
     }
     output.cleanup();
+    return {
+      success: true,
+      result
+    };
   } catch (error) {
     output.stopSpinner();
 
@@ -263,11 +327,15 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
       errorContext = 'Server startup failed';
     }
     output.error(errorContext, error);
-    process.exit(1);
+    exit(1);
+    return {
+      success: false,
+      error
+    };
   } finally {
     // Remove event listeners to prevent memory leaks
-    process.removeListener('SIGINT', sigintHandler);
-    process.removeListener('exit', exitHandler);
+    processRemoveListener('SIGINT', sigintHandler);
+    processRemoveListener('exit', exitHandler);
   }
 }
 
@@ -277,30 +345,30 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
  * @param {Object} options - Command options
  */
 export function validateRunOptions(testCommand, options) {
-  const errors = [];
+  let errors = [];
   if (!testCommand || testCommand.trim() === '') {
     errors.push('Test command is required');
   }
   if (options.port) {
-    const port = parseInt(options.port, 10);
+    let port = parseInt(options.port, 10);
     if (Number.isNaN(port) || port < 1 || port > 65535) {
       errors.push('Port must be a valid number between 1 and 65535');
     }
   }
   if (options.timeout) {
-    const timeout = parseInt(options.timeout, 10);
+    let timeout = parseInt(options.timeout, 10);
     if (Number.isNaN(timeout) || timeout < 1000) {
       errors.push('Timeout must be at least 1000 milliseconds');
     }
   }
   if (options.batchSize !== undefined) {
-    const n = parseInt(options.batchSize, 10);
+    let n = parseInt(options.batchSize, 10);
     if (!Number.isFinite(n) || n <= 0) {
       errors.push('Batch size must be a positive integer');
     }
   }
   if (options.uploadTimeout !== undefined) {
-    const n = parseInt(options.uploadTimeout, 10);
+    let n = parseInt(options.uploadTimeout, 10);
     if (!Number.isFinite(n) || n <= 0) {
       errors.push('Upload timeout must be a positive integer (milliseconds)');
     }

package/dist/commands/status.js

@@ -1,4 +1,9 @@
-import { createServices } from '../services/index.js';
+/**
+ * Status command implementation
+ * Uses functional API operations directly
+ */
+
+import { createApiClient, getBuild } from '../api/index.js';
 import { loadConfig } from '../utils/config-loader.js';
 import { getApiUrl } from '../utils/environment-config.js';
 import * as output from '../utils/output.js';
@@ -19,11 +24,11 @@ export async function statusCommand(buildId, options = {}, globalOptions = {}) {
     output.info(`Checking status for build: ${buildId}`);
 
     // Load configuration with CLI overrides
-    const allOptions = {
+    let allOptions = {
       ...globalOptions,
       ...options
     };
-    const config = await loadConfig(globalOptions.config, allOptions);
+    let config = await loadConfig(globalOptions.config, allOptions);
 
     // Validate API token
     if (!config.apiKey) {
@@ -31,19 +36,18 @@ export async function statusCommand(buildId, options = {}, globalOptions = {}) {
       process.exit(1);
     }
 
-    // Get API service
+    // Get build details via functional API
     output.startSpinner('Fetching build status...');
-    const services = createServices(config, 'status');
-    const {
-      apiService
-    } = services;
-
-    // Get build details via unified ApiService
-    const buildStatus = await apiService.getBuild(buildId);
+    let client = createApiClient({
+      baseUrl: config.apiUrl,
+      token: config.apiKey,
+      command: 'status'
+    });
+    let buildStatus = await getBuild(client, buildId);
     output.stopSpinner();
 
     // Extract build data from API response
-    const build = buildStatus.build || buildStatus;
+    let build = buildStatus.build || buildStatus;
 
     // Display build summary
     output.success(`Build: ${build.name || build.id}`);
@@ -77,15 +81,15 @@ export async function statusCommand(buildId, options = {}, globalOptions = {}) {
     }
 
     // Show build URL if we can construct it
-    const baseUrl = config.baseUrl || getApiUrl();
+    let baseUrl = config.baseUrl || getApiUrl();
     if (baseUrl && build.project_id) {
-      const buildUrl = baseUrl.replace('/api', '') + `/projects/${build.project_id}/builds/${build.id}`;
+      let buildUrl = baseUrl.replace('/api', '') + `/projects/${build.project_id}/builds/${build.id}`;
       output.info(`View Build: ${buildUrl}`);
     }
 
     // Output JSON data for --json mode
     if (globalOptions.json) {
-      const statusData = {
+      let statusData = {
         buildId: build.id,
         status: build.status,
         name: build.name,
@@ -131,9 +135,9 @@ export async function statusCommand(buildId, options = {}, globalOptions = {}) {
 
     // Show progress if build is still processing
     if (build.status === 'processing' || build.status === 'pending') {
-      const totalJobs = build.completed_jobs + build.failed_jobs + build.processing_screenshots;
+      let totalJobs = build.completed_jobs + build.failed_jobs + build.processing_screenshots;
       if (totalJobs > 0) {
-        const progress = (build.completed_jobs + build.failed_jobs) / totalJobs;
+        let progress = (build.completed_jobs + build.failed_jobs) / totalJobs;
         output.info(`Progress: ${Math.round(progress * 100)}% complete`);
       }
     }
@@ -155,7 +159,7 @@ export async function statusCommand(buildId, options = {}, globalOptions = {}) {
  * @param {Object} options - Command options
  */
 export function validateStatusOptions(buildId) {
-  const errors = [];
+  let errors = [];
   if (!buildId || buildId.trim() === '') {
     errors.push('Build ID is required');
   }