@vizzly-testing/cli 0.17.0 → 0.19.0

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,25 +200,25 @@ 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) {
+    const threshold = parseFloat(options.threshold);
+    if (Number.isNaN(threshold) || threshold < 0) {
       errors.push('Threshold must be a non-negative number (CIEDE2000 Delta E)');
     }
   }

package/dist/commands/upload.js

@@ -1,8 +1,8 @@
-import { loadConfig } from '../utils/config-loader.js';
-import * as output from '../utils/output.js';
+import { ApiService } from '../services/api-service.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 { ApiService } from '../services/api-service.js';
+import * as output from '../utils/output.js';
 
 /**
  * Construct proper build URL with org/project context
@@ -13,13 +13,13 @@ import { ApiService } from '../services/api-service.js';
  */
 async function constructBuildUrl(buildId, apiUrl, apiToken) {
   try {
-    let apiService = new ApiService({
+    const apiService = new ApiService({
       baseUrl: apiUrl,
       token: apiToken,
       command: 'upload'
     });
-    let tokenContext = await apiService.getTokenContext();
-    let baseUrl = apiUrl.replace(/\/api.*$/, '');
+    const tokenContext = await apiService.getTokenContext();
+    const baseUrl = apiUrl.replace(/\/api.*$/, '');
     if (tokenContext.organization?.slug && tokenContext.project?.slug) {
       return `${baseUrl}/${tokenContext.organization.slug}/${tokenContext.project.slug}/builds/${buildId}`;
     }
@@ -31,7 +31,7 @@ async function constructBuildUrl(buildId, apiUrl, apiToken) {
   }
 
   // Fallback URL construction
-  let baseUrl = apiUrl.replace(/\/api.*$/, '');
+  const baseUrl = apiUrl.replace(/\/api.*$/, '');
   return `${baseUrl}/builds/${buildId}`;
 }
 
@@ -49,12 +49,12 @@ export async function uploadCommand(screenshotsPath, options = {}, globalOptions
   });
   let buildId = null;
   let config = null;
-  let uploadStartTime = Date.now();
+  const uploadStartTime = Date.now();
   try {
     output.info('Starting upload process...');
 
     // Load configuration with CLI overrides
-    let allOptions = {
+    const allOptions = {
       ...globalOptions,
       ...options
     };
@@ -67,11 +67,11 @@ export async function uploadCommand(screenshotsPath, options = {}, globalOptions
     }
 
     // Collect git metadata if not provided
-    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();
     output.info(`Uploading screenshots from: ${screenshotsPath}`);
     if (globalOptions.verbose) {
       output.info('Configuration loaded');
@@ -85,11 +85,11 @@ export async function uploadCommand(screenshotsPath, options = {}, globalOptions
 
     // Get uploader service
     output.startSpinner('Initializing uploader...');
-    let services = createServices(config, 'upload');
-    let uploader = services.uploader;
+    const services = createServices(config, 'upload');
+    const uploader = services.uploader;
 
     // Prepare upload options with progress callback
-    let uploadOptions = {
+    const uploadOptions = {
       screenshotsDir: screenshotsPath,
       buildName,
       branch,
@@ -102,7 +102,7 @@ export async function uploadCommand(screenshotsPath, options = {}, globalOptions
       pullRequestNumber,
       parallelId: config.parallelId,
       onProgress: progressData => {
-        let {
+        const {
           message: progressMessage,
           current,
           total,
@@ -128,19 +128,19 @@ export async function uploadCommand(screenshotsPath, options = {}, globalOptions
 
     // Start upload
     output.progress('Starting upload...');
-    let result = await uploader.upload(uploadOptions);
+    const result = await uploader.upload(uploadOptions);
     buildId = result.buildId; // Ensure we have the buildId
 
     // Mark build as completed
     if (result.buildId) {
       output.progress('Finalizing build...');
       try {
-        let apiService = new ApiService({
+        const apiService = new ApiService({
           baseUrl: config.apiUrl,
           token: config.apiKey,
           command: 'upload'
         });
-        let executionTime = Date.now() - uploadStartTime;
+        const executionTime = Date.now() - uploadStartTime;
         await apiService.finalizeBuild(result.buildId, true, executionTime);
       } catch (error) {
         output.warn(`Failed to finalize build: ${error.message}`);
@@ -152,7 +152,7 @@ export async function uploadCommand(screenshotsPath, options = {}, globalOptions
     if (result.buildId) {
       output.info(`🐻 Vizzly: Uploaded ${result.stats.uploaded} of ${result.stats.total} screenshots to build ${result.buildId}`);
       // Use API-provided URL or construct proper URL with org/project context
-      let buildUrl = result.url || (await constructBuildUrl(result.buildId, config.apiUrl, config.apiKey));
+      const buildUrl = result.url || (await constructBuildUrl(result.buildId, config.apiUrl, config.apiKey));
       output.info(`🔗 Vizzly: View results at ${buildUrl}`);
     }
 
@@ -160,7 +160,7 @@ export async function uploadCommand(screenshotsPath, options = {}, globalOptions
     if (options.wait && result.buildId) {
       output.info('Waiting for build completion...');
       output.startSpinner('Processing comparisons...');
-      let buildResult = await uploader.waitForBuild(result.buildId);
+      const buildResult = await uploader.waitForBuild(result.buildId);
       output.success('Build processing completed');
 
       // Show build processing results
@@ -170,7 +170,7 @@ export async function uploadCommand(screenshotsPath, options = {}, globalOptions
         output.success(`All ${buildResult.passedComparisons} visual comparisons passed`);
       }
       // Use API-provided URL or construct proper URL with org/project context
-      let buildUrl = buildResult.url || (await constructBuildUrl(result.buildId, config.apiUrl, config.apiKey));
+      const buildUrl = buildResult.url || (await constructBuildUrl(result.buildId, config.apiUrl, config.apiKey));
       output.info(`🔗 Vizzly: View results at ${buildUrl}`);
     }
     output.cleanup();
@@ -178,19 +178,19 @@ export async function uploadCommand(screenshotsPath, options = {}, globalOptions
     // Mark build as failed if we have a buildId and config
     if (buildId && config) {
       try {
-        let apiService = new ApiService({
+        const apiService = new ApiService({
           baseUrl: config.apiUrl,
           token: config.apiKey,
           command: 'upload'
         });
-        let executionTime = Date.now() - uploadStartTime;
+        const executionTime = Date.now() - uploadStartTime;
         await apiService.finalizeBuild(buildId, false, executionTime);
       } catch {
         // Silent fail on cleanup
       }
     }
     // Use user-friendly error message if available
-    let errorMessage = error?.getUserMessage ? error.getUserMessage() : error.message;
+    const errorMessage = error?.getUserMessage ? error.getUserMessage() : error.message;
     output.error(errorMessage || 'Upload failed', error);
     process.exit(1);
   }
@@ -202,7 +202,7 @@ export async function uploadCommand(screenshotsPath, options = {}, globalOptions
  * @param {Object} options - Command options
  */
 export function validateUploadOptions(screenshotsPath, options) {
-  let errors = [];
+  const errors = [];
   if (!screenshotsPath) {
     errors.push('Screenshots path is required');
   }
@@ -214,19 +214,19 @@ export function validateUploadOptions(screenshotsPath, options) {
     }
   }
   if (options.threshold !== undefined) {
-    let threshold = parseFloat(options.threshold);
-    if (isNaN(threshold) || threshold < 0) {
+    const threshold = parseFloat(options.threshold);
+    if (Number.isNaN(threshold) || threshold < 0) {
       errors.push('Threshold must be a non-negative number (CIEDE2000 Delta E)');
     }
   }
   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/whoami.js

@@ -3,10 +3,10 @@
  * Shows current user and authentication status
  */
 
-import * as output from '../utils/output.js';
 import { AuthService } from '../services/auth-service.js';
 import { getApiUrl } from '../utils/environment-config.js';
 import { getAuthTokens } from '../utils/global-config.js';
+import * as output from '../utils/output.js';
 
 /**
  * Whoami command implementation
@@ -21,7 +21,7 @@ export async function whoamiCommand(options = {}, globalOptions = {}) {
   });
   try {
     // Check if user is logged in
-    let auth = await getAuthTokens();
+    const auth = await getAuthTokens();
     if (!auth || !auth.accessToken) {
       if (globalOptions.json) {
         output.data({
@@ -38,10 +38,10 @@ export async function whoamiCommand(options = {}, globalOptions = {}) {
 
     // Get current user info
     output.startSpinner('Fetching user information...');
-    let authService = new AuthService({
+    const authService = new AuthService({
       baseUrl: options.apiUrl || getApiUrl()
     });
-    let response = await authService.whoami();
+    const response = await authService.whoami();
     output.stopSpinner();
 
     // Output in JSON mode
@@ -76,7 +76,7 @@ export async function whoamiCommand(options = {}, globalOptions = {}) {
     if (response.organizations && response.organizations.length > 0) {
       output.blank();
       output.info('Organizations:');
-      for (let org of response.organizations) {
+      for (const org of response.organizations) {
         let orgInfo = `  - ${org.name}`;
         if (org.slug) {
           orgInfo += ` (@${org.slug})`;
@@ -94,12 +94,12 @@ export async function whoamiCommand(options = {}, globalOptions = {}) {
     // Show token expiry info
     if (auth.expiresAt) {
       output.blank();
-      let expiresAt = new Date(auth.expiresAt);
-      let now = new Date();
-      let msUntilExpiry = expiresAt.getTime() - now.getTime();
-      let daysUntilExpiry = Math.floor(msUntilExpiry / (1000 * 60 * 60 * 24));
-      let hoursUntilExpiry = Math.floor(msUntilExpiry / (1000 * 60 * 60));
-      let minutesUntilExpiry = Math.floor(msUntilExpiry / (1000 * 60));
+      const expiresAt = new Date(auth.expiresAt);
+      const now = new Date();
+      const msUntilExpiry = expiresAt.getTime() - now.getTime();
+      const daysUntilExpiry = Math.floor(msUntilExpiry / (1000 * 60 * 60 * 24));
+      const hoursUntilExpiry = Math.floor(msUntilExpiry / (1000 * 60 * 60));
+      const minutesUntilExpiry = Math.floor(msUntilExpiry / (1000 * 60));
       if (msUntilExpiry <= 0) {
         output.warn('Token has expired');
         output.blank();
@@ -149,7 +149,7 @@ export async function whoamiCommand(options = {}, globalOptions = {}) {
  * @param {Object} options - Command options
  */
 export function validateWhoamiOptions() {
-  let errors = [];
+  const errors = [];
 
   // No specific validation needed for whoami command