@vizzly-testing/cli 0.16.4 → 0.18.0

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 || 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)');
     }
   }
   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
 

package/dist/index.js

@@ -8,23 +8,18 @@ import 'dotenv/config';
  * - Custom integrations: import from '@vizzly-testing/cli/sdk'
  */
 
+// Client exports for convenience
+export { configure, setEnabled, vizzlyScreenshot } from './client/index.js';
+// Errors
+export { UploadError } from './errors/vizzly-error.js';
 // Primary SDK export
 export { createVizzly } from './sdk/index.js';
-
-// Client exports for convenience
-export { vizzlyScreenshot, configure, setEnabled } from './client/index.js';
-
+export { createServices } from './services/index.js';
+export { createTDDService } from './services/tdd-service.js';
 // Core services (for advanced usage)
 export { createUploader } from './services/uploader.js';
-export { createTDDService } from './services/tdd-service.js';
-export { createServices } from './services/index.js';
-
-// Utilities
-export { loadConfig } from './utils/config-loader.js';
-export * as output from './utils/output.js';
-
 // Configuration helper
 export { defineConfig } from './utils/config-helpers.js';
-
-// Errors
-export { UploadError } from './errors/vizzly-error.js';
+// Utilities
+export { loadConfig } from './utils/config-loader.js';
+export * as output from './utils/output.js';

package/dist/plugin-loader.js

@@ -1,7 +1,7 @@
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
 import { glob } from 'glob';
-import { readFileSync } from 'fs';
-import { resolve, dirname } from 'path';
-import { pathToFileURL } from 'url';
 import { z } from 'zod';
 import * as output from './utils/output.js';
 
@@ -12,14 +12,14 @@ import * as output from './utils/output.js';
  * @returns {Promise<Array>} Array of loaded plugins
  */
 export async function loadPlugins(configPath, config) {
-  let plugins = [];
-  let loadedNames = new Set();
+  const plugins = [];
+  const loadedNames = new Set();
 
   // 1. Auto-discover plugins from @vizzly-testing/* packages
-  let discoveredPlugins = await discoverInstalledPlugins();
-  for (let pluginInfo of discoveredPlugins) {
+  const discoveredPlugins = await discoverInstalledPlugins();
+  for (const pluginInfo of discoveredPlugins) {
     try {
-      let plugin = await loadPlugin(pluginInfo.path);
+      const plugin = await loadPlugin(pluginInfo.path);
       if (plugin && !loadedNames.has(plugin.name)) {
         plugins.push(plugin);
         loadedNames.add(plugin.name);
@@ -32,15 +32,15 @@ export async function loadPlugins(configPath, config) {
 
   // 2. Load explicit plugins from config
   if (config?.plugins && Array.isArray(config.plugins)) {
-    for (let pluginSpec of config.plugins) {
+    for (const pluginSpec of config.plugins) {
       try {
-        let pluginPath = resolvePluginPath(pluginSpec, configPath);
-        let plugin = await loadPlugin(pluginPath);
+        const pluginPath = resolvePluginPath(pluginSpec, configPath);
+        const plugin = await loadPlugin(pluginPath);
         if (plugin && !loadedNames.has(plugin.name)) {
           plugins.push(plugin);
           loadedNames.add(plugin.name);
         } else if (plugin && loadedNames.has(plugin.name)) {
-          let existingPlugin = plugins.find(p => p.name === plugin.name);
+          const existingPlugin = plugins.find(p => p.name === plugin.name);
           output.warn(`Plugin ${plugin.name} already loaded (v${existingPlugin.version || 'unknown'}), ` + `skipping v${plugin.version || 'unknown'} from config`);
         }
       } catch (error) {
@@ -56,20 +56,20 @@ export async function loadPlugins(configPath, config) {
  * @returns {Promise<Array>} Array of plugin info objects
  */
 async function discoverInstalledPlugins() {
-  let plugins = [];
+  const plugins = [];
   try {
     // Find all @vizzly-testing packages
-    let packageJsonPaths = await glob('node_modules/@vizzly-testing/*/package.json', {
+    const packageJsonPaths = await glob('node_modules/@vizzly-testing/*/package.json', {
       cwd: process.cwd(),
       absolute: true
     });
-    for (let pkgPath of packageJsonPaths) {
+    for (const pkgPath of packageJsonPaths) {
       try {
-        let packageJson = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        const packageJson = JSON.parse(readFileSync(pkgPath, 'utf-8'));
 
         // Check if package has a plugin field
         if (packageJson.vizzly?.plugin) {
-          let pluginRelativePath = packageJson.vizzly.plugin;
+          const pluginRelativePath = packageJson.vizzly.plugin;
 
           // Security: Ensure plugin path is relative and doesn't traverse up
           if (pluginRelativePath.startsWith('/') || pluginRelativePath.includes('..')) {
@@ -78,8 +78,8 @@ async function discoverInstalledPlugins() {
           }
 
           // Resolve plugin path relative to package directory
-          let packageDir = dirname(pkgPath);
-          let pluginPath = resolve(packageDir, pluginRelativePath);
+          const packageDir = dirname(pkgPath);
+          const pluginPath = resolve(packageDir, pluginRelativePath);
 
           // Additional security: Ensure resolved path is still within package directory
           if (!pluginPath.startsWith(packageDir)) {
@@ -109,19 +109,19 @@ async function discoverInstalledPlugins() {
 async function loadPlugin(pluginPath) {
   try {
     // Convert to file URL for ESM import
-    let pluginUrl = pathToFileURL(pluginPath).href;
+    const pluginUrl = pathToFileURL(pluginPath).href;
 
     // Dynamic import
-    let pluginModule = await import(pluginUrl);
+    const pluginModule = await import(pluginUrl);
 
     // Get the default export
-    let plugin = pluginModule.default || pluginModule;
+    const plugin = pluginModule.default || pluginModule;
 
     // Validate plugin structure
     validatePluginStructure(plugin);
     return plugin;
   } catch (error) {
-    let newError = new Error(`Failed to load plugin from ${pluginPath}: ${error.message}`);
+    const newError = new Error(`Failed to load plugin from ${pluginPath}: ${error.message}`);
     newError.cause = error;
     throw newError;
   }
@@ -154,7 +154,7 @@ function validatePluginStructure(plugin) {
     // configSchema is optional and primarily for documentation
   } catch (error) {
     if (error instanceof z.ZodError) {
-      let messages = error.issues.map(e => `${e.path.join('.')}: ${e.message}`);
+      const messages = error.issues.map(e => `${e.path.join('.')}: ${e.message}`);
       throw new Error(`Invalid plugin structure: ${messages.join(', ')}`);
     }
     throw error;
@@ -172,10 +172,10 @@ function resolvePluginPath(pluginSpec, configPath) {
   if (pluginSpec.startsWith('@') || /^[a-zA-Z0-9-]+$/.test(pluginSpec)) {
     // Try to resolve as a package
     try {
-      let packageJsonPath = resolve(process.cwd(), 'node_modules', pluginSpec, 'package.json');
-      let packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+      const packageJsonPath = resolve(process.cwd(), 'node_modules', pluginSpec, 'package.json');
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
       if (packageJson.vizzly?.plugin) {
-        let packageDir = dirname(packageJsonPath);
+        const packageDir = dirname(packageJsonPath);
         return resolve(packageDir, packageJson.vizzly.plugin);
       }
       throw new Error('Package does not specify a vizzly.plugin field');
@@ -187,7 +187,7 @@ function resolvePluginPath(pluginSpec, configPath) {
   // Otherwise treat as a file path
   if (configPath) {
     // Resolve relative to config file
-    let configDir = dirname(configPath);
+    const configDir = dirname(configPath);
     return resolve(configDir, pluginSpec);
   } else {
     // Resolve relative to cwd