@vizzly-testing/cli 0.16.4 → 0.18.0

package/dist/commands/run.js

@@ -1,7 +1,7 @@
-import { loadConfig } from '../utils/config-loader.js';
-import * as output from '../utils/output.js';
 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
@@ -21,7 +21,7 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
   let isTddMode = false;
 
   // Ensure cleanup on exit
-  let cleanup = async () => {
+  const cleanup = async () => {
     output.cleanup();
 
     // Cancel test runner (kills process and stops server)
@@ -36,40 +36,40 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
     // Finalize build if we have one
     if (testRunner && buildId) {
       try {
-        let executionTime = Date.now() - (startTime || Date.now());
+        const executionTime = Date.now() - (startTime || Date.now());
         await testRunner.finalizeBuild(buildId, isTddMode, false, executionTime);
       } catch {
         // Silent fail on cleanup
       }
     }
   };
-  let sigintHandler = async () => {
+  const sigintHandler = async () => {
     await cleanup();
     process.exit(1);
   };
-  let exitHandler = () => output.cleanup();
+  const exitHandler = () => output.cleanup();
   process.on('SIGINT', sigintHandler);
   process.on('exit', exitHandler);
   try {
     // Load configuration with CLI overrides
-    let allOptions = {
+    const allOptions = {
       ...globalOptions,
       ...options
     };
     output.debug('[RUN] Loading config', {
       hasToken: !!allOptions.token
     });
-    let config = await loadConfig(globalOptions.config, allOptions);
+    const config = await loadConfig(globalOptions.config, allOptions);
     output.debug('[RUN] Config loaded', {
       hasApiKey: !!config.apiKey,
-      apiKeyPrefix: config.apiKey ? config.apiKey.substring(0, 8) + '***' : 'NONE'
+      apiKeyPrefix: config.apiKey ? `${config.apiKey.substring(0, 8)}***` : 'NONE'
     });
     if (globalOptions.verbose) {
       output.info('Token check:');
       output.debug('Token details', {
         hasApiKey: !!config.apiKey,
         apiKeyType: typeof config.apiKey,
-        apiKeyPrefix: typeof config.apiKey === 'string' && config.apiKey ? config.apiKey.substring(0, 10) + '...' : 'none',
+        apiKeyPrefix: typeof config.apiKey === 'string' && config.apiKey ? `${config.apiKey.substring(0, 10)}...` : 'none',
         projectSlug: config.projectSlug || 'none',
         organizationSlug: config.organizationSlug || 'none'
       });
@@ -82,11 +82,11 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
     }
 
     // Collect git metadata and build info
-    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();
+    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();
     if (globalOptions.verbose) {
       output.info('Configuration loaded');
       output.debug('Config details', {
@@ -104,7 +104,7 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
 
     // Create service container and get test runner service
     output.startSpinner('Initializing test runner...');
-    let configWithVerbose = {
+    const configWithVerbose = {
       ...config,
       verbose: globalOptions.verbose,
       uploadAll: options.uploadAll || false
@@ -112,7 +112,7 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
     output.debug('[RUN] Creating services', {
       hasApiKey: !!configWithVerbose.apiKey
     });
-    let services = createServices(configWithVerbose, 'run');
+    const services = createServices(configWithVerbose, 'run');
     testRunner = services.testRunner;
     output.stopSpinner();
 
@@ -121,7 +121,7 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
 
     // Set up event handlers
     testRunner.on('progress', progressData => {
-      let {
+      const {
         message: progressMessage
       } = progressData;
       output.progress(progressMessage || 'Running tests...');
@@ -164,7 +164,7 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
     });
 
     // Prepare run options
-    let runOptions = {
+    const runOptions = {
       testCommand,
       port: config.server.port,
       timeout: config.server.timeout,
@@ -210,8 +210,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
-        let exitCodeMatch = error.message.match(/exited with code (\d+)/);
-        let exitCode = exitCodeMatch ? parseInt(exitCodeMatch[1], 10) : 1;
+        const exitCodeMatch = error.message.match(/exited with code (\d+)/);
+        const exitCode = exitCodeMatch ? parseInt(exitCodeMatch[1], 10) : 1;
         output.error('Test run failed');
         return {
           success: false,
@@ -233,10 +233,10 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
       if (runOptions.wait) {
         output.info('Waiting for build completion...');
         output.startSpinner('Processing comparisons...');
-        let {
+        const {
           uploader
         } = services;
-        let buildResult = await uploader.waitForBuild(result.buildId);
+        const buildResult = await uploader.waitForBuild(result.buildId);
         output.success('Build processing completed');
 
         // Exit with appropriate code based on comparison results
@@ -255,11 +255,11 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
 
     // Provide more context about where the error occurred
     let errorContext = 'Test run failed';
-    if (error.message && error.message.includes('build')) {
+    if (error.message?.includes('build')) {
       errorContext = 'Build creation failed';
-    } else if (error.message && error.message.includes('screenshot')) {
+    } else if (error.message?.includes('screenshot')) {
       errorContext = 'Screenshot processing failed';
-    } else if (error.message && error.message.includes('server')) {
+    } else if (error.message?.includes('server')) {
       errorContext = 'Server startup failed';
     }
     output.error(errorContext, error);
@@ -277,30 +277,30 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
  * @param {Object} options - Command options
  */
 export function validateRunOptions(testCommand, options) {
-  let errors = [];
+  const errors = [];
   if (!testCommand || testCommand.trim() === '') {
     errors.push('Test command is required');
   }
   if (options.port) {
-    let port = parseInt(options.port, 10);
-    if (isNaN(port) || port < 1 || port > 65535) {
+    const 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) {
-    let timeout = parseInt(options.timeout, 10);
-    if (isNaN(timeout) || timeout < 1000) {
+    const timeout = parseInt(options.timeout, 10);
+    if (Number.isNaN(timeout) || timeout < 1000) {
       errors.push('Timeout must be at least 1000 milliseconds');
     }
   }
   if (options.batchSize !== undefined) {
-    let n = parseInt(options.batchSize, 10);
+    const n = parseInt(options.batchSize, 10);
     if (!Number.isFinite(n) || n <= 0) {
       errors.push('Batch size must be a positive integer');
     }
   }
   if (options.uploadTimeout !== undefined) {
-    let n = parseInt(options.uploadTimeout, 10);
+    const 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,7 +1,7 @@
-import { loadConfig } from '../utils/config-loader.js';
-import * as output from '../utils/output.js';
 import { createServices } from '../services/index.js';
+import { loadConfig } from '../utils/config-loader.js';
 import { getApiUrl } from '../utils/environment-config.js';
+import * as output from '../utils/output.js';
 
 /**
  * Status command implementation
@@ -19,11 +19,11 @@ export async function statusCommand(buildId, options = {}, globalOptions = {}) {
     output.info(`Checking status for build: ${buildId}`);
 
     // Load configuration with CLI overrides
-    let allOptions = {
+    const allOptions = {
       ...globalOptions,
       ...options
     };
-    let config = await loadConfig(globalOptions.config, allOptions);
+    const config = await loadConfig(globalOptions.config, allOptions);
 
     // Validate API token
     if (!config.apiKey) {
@@ -33,17 +33,17 @@ export async function statusCommand(buildId, options = {}, globalOptions = {}) {
 
     // Get API service
     output.startSpinner('Fetching build status...');
-    let services = createServices(config, 'status');
-    let {
+    const services = createServices(config, 'status');
+    const {
       apiService
     } = services;
 
     // Get build details via unified ApiService
-    let buildStatus = await apiService.getBuild(buildId);
+    const buildStatus = await apiService.getBuild(buildId);
     output.stopSpinner();
 
     // Extract build data from API response
-    let build = buildStatus.build || buildStatus;
+    const build = buildStatus.build || buildStatus;
 
     // Display build summary
     output.success(`Build: ${build.name || build.id}`);
@@ -77,15 +77,15 @@ export async function statusCommand(buildId, options = {}, globalOptions = {}) {
     }
 
     // Show build URL if we can construct it
-    let baseUrl = config.baseUrl || getApiUrl();
+    const baseUrl = config.baseUrl || getApiUrl();
     if (baseUrl && build.project_id) {
-      let buildUrl = baseUrl.replace('/api', '') + `/projects/${build.project_id}/builds/${build.id}`;
+      const 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) {
-      let statusData = {
+      const statusData = {
         buildId: build.id,
         status: build.status,
         name: build.name,
@@ -131,9 +131,9 @@ export async function statusCommand(buildId, options = {}, globalOptions = {}) {
 
     // Show progress if build is still processing
     if (build.status === 'processing' || build.status === 'pending') {
-      let totalJobs = build.completed_jobs + build.failed_jobs + build.processing_screenshots;
+      const totalJobs = build.completed_jobs + build.failed_jobs + build.processing_screenshots;
       if (totalJobs > 0) {
-        let progress = (build.completed_jobs + build.failed_jobs) / totalJobs;
+        const progress = (build.completed_jobs + build.failed_jobs) / totalJobs;
         output.info(`Progress: ${Math.round(progress * 100)}% complete`);
       }
     }
@@ -155,7 +155,7 @@ export async function statusCommand(buildId, options = {}, globalOptions = {}) {
  * @param {Object} options - Command options
  */
 export function validateStatusOptions(buildId) {
-  let errors = [];
+  const errors = [];
   if (!buildId || buildId.trim() === '') {
     errors.push('Build ID is required');
   }

package/dist/commands/tdd-daemon.js

@@ -1,7 +1,7 @@
-import { writeFileSync, readFileSync, existsSync, unlinkSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { homedir } from 'os';
-import { spawn } from 'child_process';
+import { spawn } from 'node:child_process';
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 import * as output from '../utils/output.js';
 import { tddCommand } from './tdd.js';
 
@@ -19,7 +19,7 @@ export async function tddStartCommand(options = {}, globalOptions = {}) {
 
   // Check if server already running
   if (await isServerRunning(options.port || 47392)) {
-    let port = options.port || 47392;
+    const port = options.port || 47392;
     output.info(`TDD server already running at http://localhost:${port}`);
     output.info(`Dashboard: http://localhost:${port}/dashboard`);
     if (options.open) {
@@ -29,13 +29,13 @@ export async function tddStartCommand(options = {}, globalOptions = {}) {
   }
   try {
     // Ensure .vizzly directory exists
-    let vizzlyDir = join(process.cwd(), '.vizzly');
+    const vizzlyDir = join(process.cwd(), '.vizzly');
     if (!existsSync(vizzlyDir)) {
       mkdirSync(vizzlyDir, {
         recursive: true
       });
     }
-    let port = options.port || 47392;
+    const port = options.port || 47392;
 
     // Show loading indicator if downloading baselines (but not in verbose mode since child shows progress)
     if (options.baselineBuild && !globalOptions.verbose) {
@@ -43,7 +43,7 @@ export async function tddStartCommand(options = {}, globalOptions = {}) {
     }
 
     // Spawn child process with stdio inherited during init for direct error visibility
-    let child = spawn(process.execPath, [process.argv[1],
+    const child = spawn(process.execPath, [process.argv[1],
     // CLI entry point
     'tdd', 'start', '--daemon-child',
     // Special flag for child process
@@ -72,7 +72,7 @@ export async function tddStartCommand(options = {}, globalOptions = {}) {
       });
 
       // Timeout after 30 seconds to prevent indefinite wait
-      let timeoutId = setTimeout(() => {
+      const timeoutId = setTimeout(() => {
         if (!initComplete && !initFailed) {
           initFailed = true;
           resolve();
@@ -95,8 +95,8 @@ export async function tddStartCommand(options = {}, globalOptions = {}) {
     child.unref();
 
     // Verify server started with retries
-    let maxRetries = 10;
-    let retryDelay = 200; // Start with 200ms
+    const maxRetries = 10;
+    const retryDelay = 200; // Start with 200ms
     let running = false;
     for (let i = 0; i < maxRetries && !running; i++) {
       await new Promise(resolve => setTimeout(resolve, retryDelay * (i + 1)));
@@ -113,14 +113,14 @@ export async function tddStartCommand(options = {}, globalOptions = {}) {
 
     // Write server info to global location for SDK discovery (iOS/Swift can read this)
     try {
-      let globalVizzlyDir = join(homedir(), '.vizzly');
+      const globalVizzlyDir = join(homedir(), '.vizzly');
       if (!existsSync(globalVizzlyDir)) {
         mkdirSync(globalVizzlyDir, {
           recursive: true
         });
       }
-      let globalServerFile = join(globalVizzlyDir, 'server.json');
-      let serverInfo = {
+      const globalServerFile = join(globalVizzlyDir, 'server.json');
+      const serverInfo = {
         pid: child.pid,
         port: port.toString(),
         startTime: Date.now()
@@ -160,11 +160,11 @@ export async function tddStartCommand(options = {}, globalOptions = {}) {
  * @private
  */
 export async function runDaemonChild(options = {}, globalOptions = {}) {
-  let vizzlyDir = join(process.cwd(), '.vizzly');
-  let port = options.port || 47392;
+  const vizzlyDir = join(process.cwd(), '.vizzly');
+  const port = options.port || 47392;
   try {
     // Use existing tddCommand but with daemon mode
-    let {
+    const {
       cleanup
     } = await tddCommand(null,
     // No test command - server only
@@ -179,9 +179,9 @@ export async function runDaemonChild(options = {}, globalOptions = {}) {
     }
 
     // Store our PID for the stop command
-    let pidFile = join(vizzlyDir, 'server.pid');
+    const pidFile = join(vizzlyDir, 'server.pid');
     writeFileSync(pidFile, process.pid.toString());
-    let serverInfo = {
+    const serverInfo = {
       pid: process.pid,
       port: port,
       startTime: Date.now()
@@ -189,16 +189,16 @@ export async function runDaemonChild(options = {}, globalOptions = {}) {
     writeFileSync(join(vizzlyDir, 'server.json'), JSON.stringify(serverInfo, null, 2));
 
     // Set up graceful shutdown
-    let handleShutdown = async () => {
+    const handleShutdown = async () => {
       try {
         // Clean up PID files
         if (existsSync(pidFile)) unlinkSync(pidFile);
-        let serverFile = join(vizzlyDir, 'server.json');
+        const serverFile = join(vizzlyDir, 'server.json');
         if (existsSync(serverFile)) unlinkSync(serverFile);
 
         // Clean up global server file
         try {
-          let globalServerFile = join(homedir(), '.vizzly', 'server.json');
+          const globalServerFile = join(homedir(), '.vizzly', 'server.json');
           if (existsSync(globalServerFile)) unlinkSync(globalServerFile);
         } catch {
           // Non-fatal
@@ -236,9 +236,9 @@ export async function tddStopCommand(options = {}, globalOptions = {}) {
     verbose: globalOptions.verbose,
     color: !globalOptions.noColor
   });
-  let vizzlyDir = join(process.cwd(), '.vizzly');
-  let pidFile = join(vizzlyDir, 'server.pid');
-  let serverFile = join(vizzlyDir, 'server.json');
+  const vizzlyDir = join(process.cwd(), '.vizzly');
+  const pidFile = join(vizzlyDir, 'server.pid');
+  const serverFile = join(vizzlyDir, 'server.json');
 
   // First try to find process by PID file
   let pid = null;
@@ -251,10 +251,10 @@ export async function tddStopCommand(options = {}, globalOptions = {}) {
   }
 
   // If no PID file or invalid, try to find by port using lsof
-  let port = options.port || 47392;
+  const port = options.port || 47392;
   if (!pid) {
     try {
-      let lsofProcess = spawn('lsof', ['-ti', `:${port}`], {
+      const lsofProcess = spawn('lsof', ['-ti', `:${port}`], {
         stdio: 'pipe'
       });
       let lsofOutput = '';
@@ -264,8 +264,8 @@ export async function tddStopCommand(options = {}, globalOptions = {}) {
       await new Promise(resolve => {
         lsofProcess.on('close', code => {
           if (code === 0 && lsofOutput.trim()) {
-            let foundPid = parseInt(lsofOutput.trim().split('\n')[0], 10);
-            if (foundPid && !isNaN(foundPid)) {
+            const foundPid = parseInt(lsofOutput.trim().split('\n')[0], 10);
+            if (foundPid && !Number.isNaN(foundPid)) {
               pid = foundPid;
             }
           }
@@ -327,21 +327,21 @@ export async function tddStopCommand(options = {}, globalOptions = {}) {
  * @param {Object} options - Command options
  * @param {Object} globalOptions - Global CLI options
  */
-export async function tddStatusCommand(options, globalOptions = {}) {
+export async function tddStatusCommand(_options, globalOptions = {}) {
   output.configure({
     json: globalOptions.json,
     verbose: globalOptions.verbose,
     color: !globalOptions.noColor
   });
-  let vizzlyDir = join(process.cwd(), '.vizzly');
-  let pidFile = join(vizzlyDir, 'server.pid');
-  let serverFile = join(vizzlyDir, 'server.json');
+  const vizzlyDir = join(process.cwd(), '.vizzly');
+  const pidFile = join(vizzlyDir, 'server.pid');
+  const serverFile = join(vizzlyDir, 'server.json');
   if (!existsSync(pidFile)) {
     output.info('TDD server not running');
     return;
   }
   try {
-    let pid = parseInt(readFileSync(pidFile, 'utf8').trim(), 10);
+    const pid = parseInt(readFileSync(pidFile, 'utf8').trim(), 10);
 
     // Check if process is actually running
     process.kill(pid, 0); // Signal 0 just checks if process exists
@@ -354,7 +354,7 @@ export async function tddStatusCommand(options, globalOptions = {}) {
     }
 
     // Try to check health endpoint
-    let health = await checkServerHealth(serverInfo.port);
+    const health = await checkServerHealth(serverInfo.port);
     if (health.running) {
       output.success(`TDD server running (PID: ${pid})`);
       output.info(`Dashboard: http://localhost:${serverInfo.port}/`);
@@ -365,10 +365,10 @@ export async function tddStatusCommand(options, globalOptions = {}) {
       output.info(`  Settings:    http://localhost:${serverInfo.port}/settings`);
       output.info(`  Projects:    http://localhost:${serverInfo.port}/projects`);
       if (serverInfo.startTime) {
-        let uptime = Math.floor((Date.now() - serverInfo.startTime) / 1000);
-        let hours = Math.floor(uptime / 3600);
-        let minutes = Math.floor(uptime % 3600 / 60);
-        let seconds = uptime % 60;
+        const uptime = Math.floor((Date.now() - serverInfo.startTime) / 1000);
+        const hours = Math.floor(uptime / 3600);
+        const minutes = Math.floor(uptime % 3600 / 60);
+        const seconds = uptime % 60;
         let uptimeStr = '';
         if (hours > 0) uptimeStr += `${hours}h `;
         if (minutes > 0 || hours > 0) uptimeStr += `${minutes}m `;
@@ -398,7 +398,7 @@ export async function tddStatusCommand(options, globalOptions = {}) {
  */
 async function isServerRunning(port = 47392) {
   try {
-    let health = await checkServerHealth(port);
+    const health = await checkServerHealth(port);
     return health.running;
   } catch {
     return false;
@@ -411,8 +411,8 @@ async function isServerRunning(port = 47392) {
  */
 async function checkServerHealth(port = 47392) {
   try {
-    let response = await fetch(`http://localhost:${port}/health`);
-    let data = await response.json();
+    const response = await fetch(`http://localhost:${port}/health`);
+    const data = await response.json();
     return {
       running: response.ok,
       port: data.port,
@@ -430,7 +430,7 @@ async function checkServerHealth(port = 47392) {
  * @private
  */
 function openDashboard(port = 47392) {
-  let url = `http://localhost:${port}/dashboard`;
+  const url = `http://localhost:${port}/dashboard`;
 
   // Cross-platform open command
   let openCmd;

package/dist/commands/tdd.js

@@ -1,7 +1,7 @@
-import { loadConfig } from '../utils/config-loader.js';
-import * as output from '../utils/output.js';
 import { createServices } from '../services/index.js';
+import { loadConfig } from '../utils/config-loader.js';
 import { detectBranch, detectCommit } from '../utils/git.js';
+import * as output from '../utils/output.js';
 
 /**
  * TDD command implementation
@@ -20,7 +20,7 @@ export async function tddCommand(testCommand, options = {}, globalOptions = {})
   let isCleanedUp = false;
 
   // Create cleanup function that can be called by the caller
-  let cleanup = async () => {
+  const cleanup = async () => {
     if (isCleanedUp) return;
     isCleanedUp = true;
     output.cleanup();
@@ -30,14 +30,14 @@ export async function tddCommand(testCommand, options = {}, globalOptions = {})
   };
   try {
     // Load configuration with CLI overrides
-    let allOptions = {
+    const allOptions = {
       ...globalOptions,
       ...options
     };
-    let config = await loadConfig(globalOptions.config, allOptions);
+    const config = await loadConfig(globalOptions.config, allOptions);
 
     // Dev mode works locally by default - only needs token for baseline download
-    let needsToken = options.baselineBuild || options.baselineComparison;
+    const needsToken = options.baselineBuild || options.baselineComparison;
     if (!config.apiKey && needsToken) {
       throw new Error('API token required when using --baseline-build or --baseline-comparison flags');
     }
@@ -46,12 +46,12 @@ export async function tddCommand(testCommand, options = {}, globalOptions = {})
     config.allowNoToken = true;
 
     // Collect git metadata
-    let branch = await detectBranch(options.branch);
-    let commit = await detectCommit(options.commit);
+    const branch = await detectBranch(options.branch);
+    const commit = await detectCommit(options.commit);
 
     // Show header (skip in daemon mode)
     if (!options.daemon) {
-      let mode = config.apiKey ? 'local' : 'local';
+      const mode = config.apiKey ? 'local' : 'local';
       output.header('tdd', mode);
 
       // Show config in verbose mode
@@ -64,17 +64,17 @@ export async function tddCommand(testCommand, options = {}, globalOptions = {})
 
     // Create services
     output.startSpinner('Initializing TDD server...');
-    let configWithVerbose = {
+    const configWithVerbose = {
       ...config,
       verbose: globalOptions.verbose
     };
-    let services = createServices(configWithVerbose, 'tdd');
+    const services = createServices(configWithVerbose, 'tdd');
     testRunner = services.testRunner;
     output.stopSpinner();
 
     // Set up event handlers for user feedback
     testRunner.on('progress', progressData => {
-      let {
+      const {
         message: progressMessage
       } = progressData;
       output.progress(progressMessage || 'Running tests...');
@@ -96,7 +96,7 @@ export async function tddCommand(testCommand, options = {}, globalOptions = {})
       output.debug('capture', screenshotInfo.name);
     });
     testRunner.on('comparison-result', comparisonInfo => {
-      let {
+      const {
         name,
         status,
         pixelDifference
@@ -112,7 +112,7 @@ export async function tddCommand(testCommand, options = {}, globalOptions = {})
     testRunner.on('error', error => {
       output.error('Test runner error', error);
     });
-    let runOptions = {
+    const runOptions = {
       testCommand,
       port: config.server.port,
       timeout: config.server.timeout,
@@ -149,19 +149,19 @@ export async function tddCommand(testCommand, options = {}, globalOptions = {})
 
     // Normal dev mode - run tests
     output.debug('run', testCommand);
-    let runResult = await testRunner.run(runOptions);
+    const runResult = await testRunner.run(runOptions);
 
     // Show summary
-    let {
+    const {
       screenshotsCaptured,
       comparisons
     } = runResult;
 
     // Determine success based on comparison results
-    let hasFailures = runResult.failed || runResult.comparisons && runResult.comparisons.some(c => c.status === 'failed');
+    const hasFailures = runResult.failed || runResult.comparisons?.some(c => c.status === 'failed');
     if (comparisons && comparisons.length > 0) {
-      let passed = comparisons.filter(c => c.status === 'passed').length;
-      let failed = comparisons.filter(c => c.status === 'failed').length;
+      const passed = comparisons.filter(c => c.status === 'passed').length;
+      const failed = comparisons.filter(c => c.status === 'failed').length;
       if (hasFailures) {
         output.error(`${failed} visual difference${failed !== 1 ? 's' : ''} detected`);
         output.info(`Check .vizzly/diffs/ for diff images`);
@@ -200,26 +200,26 @@ export async function tddCommand(testCommand, options = {}, globalOptions = {})
  * @param {Object} options - Command options
  */
 export function validateTddOptions(testCommand, options) {
-  let errors = [];
+  const errors = [];
   if (!testCommand || testCommand.trim() === '') {
     errors.push('Test command is required');
   }
   if (options.port) {
-    let port = parseInt(options.port, 10);
-    if (isNaN(port) || port < 1 || port > 65535) {
+    const 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) {
-    let timeout = parseInt(options.timeout, 10);
-    if (isNaN(timeout) || timeout < 1000) {
+    const timeout = parseInt(options.timeout, 10);
+    if (Number.isNaN(timeout) || timeout < 1000) {
       errors.push('Timeout must be at least 1000 milliseconds');
     }
   }
   if (options.threshold !== undefined) {
-    let threshold = parseFloat(options.threshold);
-    if (isNaN(threshold) || threshold < 0 || threshold > 1) {
-      errors.push('Threshold must be a number between 0 and 1');
+    const threshold = parseFloat(options.threshold);
+    if (Number.isNaN(threshold) || threshold < 0) {
+      errors.push('Threshold must be a non-negative number (CIEDE2000 Delta E)');
     }
   }
   return errors;