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

package/dist/commands/run.js

@@ -1,65 +1,119 @@
-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, getTokenContext as defaultGetTokenContext } 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,
+    getTokenContext = defaultGetTokenContext,
+    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 +132,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 +160,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 +170,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}`);
-      }
-      if (buildUrl) {
-        output.info(`Vizzly: ${buildUrl}`);
+    // Create build manager (functional object)
+    let buildManager = {
+      async createBuild(buildOptions) {
+        return createBuildObject(buildOptions);
       }
+    };
+
+    // Create uploader for --wait functionality
+    let uploader = createUploader({
+      ...configWithVerbose,
+      command: 'run'
     });
-    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}`);
-    });
+    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,19 +216,80 @@ 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) {
         buildId = result.buildId;
       }
-      output.success('Test run completed successfully');
+      output.complete('Test run completed');
 
-      // Show Vizzly summary
+      // Show Vizzly summary with link to results
       if (result.buildId) {
-        output.print(`🐻 Vizzly: Captured ${result.screenshotsCaptured} screenshots in build ${result.buildId}`);
-        if (result.url) {
-          output.print(`🔗 Vizzly: View results at ${result.url}`);
+        output.blank();
+        let colors = output.getColors();
+        output.print(`  ${colors.brand.textTertiary('Screenshots')}  ${colors.white(result.screenshotsCaptured)}`);
+
+        // Get URL from result, or construct one as fallback
+        let displayUrl = result.url;
+        if (!displayUrl && config.apiKey) {
+          try {
+            let client = createApiClient({
+              baseUrl: config.apiUrl,
+              token: config.apiKey,
+              command: 'run'
+            });
+            let tokenContext = await getTokenContext(client);
+            let baseUrl = config.apiUrl.replace(/\/api.*$/, '');
+            if (tokenContext.organization?.slug && tokenContext.project?.slug) {
+              displayUrl = `${baseUrl}/${tokenContext.organization.slug}/${tokenContext.project.slug}/builds/${result.buildId}`;
+            }
+          } catch {
+            // Fallback to simple URL if context fetch fails
+            let baseUrl = config.apiUrl.replace(/\/api.*$/, '');
+            displayUrl = `${baseUrl}/builds/${result.buildId}`;
+          }
+        }
+        if (displayUrl) {
+          output.print(`  ${colors.brand.textTertiary('Results')}      ${colors.cyan(colors.underline(displayUrl))}`);
+        } else {
+          output.print(`  ${colors.brand.textTertiary('Build')}        ${colors.dim(result.buildId)}`);
         }
       }
     } catch (error) {
@@ -210,8 +299,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 +322,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 +336,10 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
       }
     }
     output.cleanup();
+    return {
+      success: true,
+      result
+    };
   } catch (error) {
     output.stopSpinner();
 
@@ -263,11 +353,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 +371,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';
@@ -16,14 +21,12 @@ export async function statusCommand(buildId, options = {}, globalOptions = {}) {
     color: !globalOptions.noColor
   });
   try {
-    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,61 +34,22 @@ 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;
-
-    // Display build summary
-    output.success(`Build: ${build.name || build.id}`);
-    output.info(`Status: ${build.status.toUpperCase()}`);
-    output.info(`Environment: ${build.environment}`);
-    if (build.branch) {
-      output.info(`Branch: ${build.branch}`);
-    }
-    if (build.commit_sha) {
-      output.info(`Commit: ${build.commit_sha.substring(0, 8)} - ${build.commit_message || 'No message'}`);
-    }
-
-    // Show screenshot and comparison stats
-    output.info(`Screenshots: ${build.screenshot_count || 0} total`);
-    output.info(`Comparisons: ${build.total_comparisons || 0} total (${build.new_comparisons || 0} new, ${build.changed_comparisons || 0} changed, ${build.identical_comparisons || 0} identical)`);
-    if (build.approval_status) {
-      output.info(`Approval Status: ${build.approval_status}`);
-    }
-
-    // Show timing information
-    if (build.created_at) {
-      output.info(`Created: ${new Date(build.created_at).toLocaleString()}`);
-    }
-    if (build.completed_at) {
-      output.info(`Completed: ${new Date(build.completed_at).toLocaleString()}`);
-    } else if (build.status !== 'completed' && build.status !== 'failed') {
-      output.info(`Started: ${new Date(build.started_at || build.created_at).toLocaleString()}`);
-    }
-    if (build.execution_time_ms) {
-      output.info(`Execution Time: ${Math.round(build.execution_time_ms / 1000)}s`);
-    }
-
-    // Show build URL if we can construct it
-    const baseUrl = config.baseUrl || getApiUrl();
-    if (baseUrl && build.project_id) {
-      const buildUrl = baseUrl.replace('/api', '') + `/projects/${build.project_id}/builds/${build.id}`;
-      output.info(`View Build: ${buildUrl}`);
-    }
+    let build = buildStatus.build || buildStatus;
 
-    // Output JSON data for --json mode
+    // Output in JSON mode
     if (globalOptions.json) {
-      const statusData = {
+      let statusData = {
         buildId: build.id,
         status: build.status,
         name: build.name,
@@ -107,34 +71,105 @@ export async function statusCommand(buildId, options = {}, globalOptions = {}) {
         userAgent: build.user_agent
       };
       output.data(statusData);
+      output.cleanup();
+      return;
+    }
+
+    // Human-readable output
+    output.header('status', build.status);
+
+    // Build info section
+    let buildInfo = {
+      Name: build.name || build.id,
+      Status: build.status.toUpperCase(),
+      Environment: build.environment
+    };
+    if (build.branch) {
+      buildInfo.Branch = build.branch;
+    }
+    if (build.commit_sha) {
+      buildInfo.Commit = `${build.commit_sha.substring(0, 8)} - ${build.commit_message || 'No message'}`;
+    }
+    output.keyValue(buildInfo);
+    output.blank();
+
+    // Comparison stats with visual indicators
+    let colors = output.getColors();
+    let stats = [];
+    let newCount = build.new_comparisons || 0;
+    let changedCount = build.changed_comparisons || 0;
+    let identicalCount = build.identical_comparisons || 0;
+    let screenshotCount = build.screenshot_count || 0;
+    output.labelValue('Screenshots', String(screenshotCount));
+    if (newCount > 0) {
+      stats.push(`${colors.brand.info(newCount)} new`);
+    }
+    if (changedCount > 0) {
+      stats.push(`${colors.brand.warning(changedCount)} changed`);
+    }
+    if (identicalCount > 0) {
+      stats.push(`${colors.brand.success(identicalCount)} identical`);
+    }
+    if (stats.length > 0) {
+      output.labelValue('Comparisons', stats.join(colors.brand.textMuted(' · ')));
+    }
+    if (build.approval_status) {
+      output.labelValue('Approval', build.approval_status);
+    }
+    output.blank();
+
+    // Timing info
+    if (build.created_at) {
+      output.hint(`Created ${new Date(build.created_at).toLocaleString()}`);
+    }
+    if (build.completed_at) {
+      output.hint(`Completed ${new Date(build.completed_at).toLocaleString()}`);
+    } else if (build.status !== 'completed' && build.status !== 'failed') {
+      output.hint(`Started ${new Date(build.started_at || build.created_at).toLocaleString()}`);
+    }
+    if (build.execution_time_ms) {
+      output.hint(`Took ${Math.round(build.execution_time_ms / 1000)}s`);
+    }
+
+    // Show build URL if we can construct it
+    let baseUrl = config.baseUrl || getApiUrl();
+    if (baseUrl && build.project_id) {
+      let buildUrl = baseUrl.replace('/api', '') + `/projects/${build.project_id}/builds/${build.id}`;
+      output.blank();
+      output.labelValue('View', output.link('Build', buildUrl));
     }
 
     // Show additional info in verbose mode
     if (globalOptions.verbose) {
-      output.info('\n--- Additional Details ---');
+      output.blank();
+      output.divider();
+      output.blank();
+      let verboseInfo = {};
       if (build.approved_screenshots > 0 || build.rejected_screenshots > 0 || build.pending_screenshots > 0) {
-        output.info(`Screenshot Approvals: ${build.approved_screenshots || 0} approved, ${build.rejected_screenshots || 0} rejected, ${build.pending_screenshots || 0} pending`);
+        verboseInfo.Approvals = `${build.approved_screenshots || 0} approved, ${build.rejected_screenshots || 0} rejected, ${build.pending_screenshots || 0} pending`;
       }
       if (build.avg_diff_percentage !== null) {
-        output.info(`Average Diff: ${(build.avg_diff_percentage * 100).toFixed(2)}%`);
+        verboseInfo['Avg Diff'] = `${(build.avg_diff_percentage * 100).toFixed(2)}%`;
       }
       if (build.github_pull_request_number) {
-        output.info(`GitHub PR: #${build.github_pull_request_number}`);
+        verboseInfo['GitHub PR'] = `#${build.github_pull_request_number}`;
       }
       if (build.is_baseline) {
-        output.info('This build is marked as a baseline');
+        verboseInfo.Baseline = 'Yes';
       }
-      output.info(`User Agent: ${build.user_agent || 'Unknown'}`);
-      output.info(`Build ID: ${build.id}`);
-      output.info(`Project ID: ${build.project_id}`);
+      verboseInfo['User Agent'] = build.user_agent || 'Unknown';
+      verboseInfo['Build ID'] = build.id;
+      verboseInfo['Project ID'] = build.project_id;
+      output.keyValue(verboseInfo);
     }
 
     // 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;
-        output.info(`Progress: ${Math.round(progress * 100)}% complete`);
+        let progress = (build.completed_jobs + build.failed_jobs) / totalJobs;
+        output.blank();
+        output.print(`  ${output.progressBar(progress * 100, 100)} ${Math.round(progress * 100)}%`);
       }
     }
     output.cleanup();
@@ -155,7 +190,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');
   }