@vizzly-testing/cli 0.10.3 → 0.11.1

package/dist/commands/run.js

@@ -57,8 +57,30 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
       ...globalOptions,
       ...options
     };
+
+    // Debug: Check options before loadConfig
+    if (process.env.DEBUG_CONFIG) {
+      console.log('[RUN] allOptions.token:', allOptions.token ? allOptions.token.substring(0, 8) + '***' : 'NONE');
+    }
     const config = await loadConfig(globalOptions.config, allOptions);
 
+    // Debug: Check config immediately after loadConfig
+    if (process.env.DEBUG_CONFIG) {
+      console.log('[RUN] Config after loadConfig:', {
+        hasApiKey: !!config.apiKey,
+        apiKeyPrefix: config.apiKey ? config.apiKey.substring(0, 8) + '***' : 'NONE'
+      });
+    }
+    if (globalOptions.verbose) {
+      ui.info('Token check:', {
+        hasApiKey: !!config.apiKey,
+        apiKeyType: typeof config.apiKey,
+        apiKeyPrefix: typeof config.apiKey === 'string' && config.apiKey ? config.apiKey.substring(0, 10) + '...' : 'none',
+        projectSlug: config.projectSlug || 'none',
+        organizationSlug: config.organizationSlug || 'none'
+      });
+    }
+
     // Validate API token (unless --allow-no-token is set)
     if (!config.apiKey && !config.allowNoToken) {
       ui.error('API token required. Use --token, set VIZZLY_TOKEN environment variable, or use --allow-no-token to run without uploading');
@@ -92,6 +114,14 @@ export async function runCommand(testCommand, options = {}, globalOptions = {})
       verbose: globalOptions.verbose,
       uploadAll: options.uploadAll || false
     };
+
+    // Debug: Check config before creating container
+    if (process.env.DEBUG_CONFIG) {
+      console.log('[RUN] Config before container:', {
+        hasApiKey: !!configWithVerbose.apiKey,
+        apiKeyPrefix: configWithVerbose.apiKey ? configWithVerbose.apiKey.substring(0, 8) + '***' : 'NONE'
+      });
+    }
     const command = 'run';
     const container = await createServiceContainer(configWithVerbose, command);
     testRunner = await container.get('testRunner'); // Assign to outer scope variable

package/dist/commands/whoami.js

@@ -0,0 +1,162 @@
+/**
+ * Whoami command implementation
+ * Shows current user and authentication status
+ */
+
+import { ConsoleUI } from '../utils/console-ui.js';
+import { AuthService } from '../services/auth-service.js';
+import { getApiUrl } from '../utils/environment-config.js';
+import { getAuthTokens } from '../utils/global-config.js';
+
+/**
+ * Whoami command implementation
+ * @param {Object} options - Command options
+ * @param {Object} globalOptions - Global CLI options
+ */
+export async function whoamiCommand(options = {}, globalOptions = {}) {
+  // Create UI handler
+  let ui = new ConsoleUI({
+    json: globalOptions.json,
+    verbose: globalOptions.verbose,
+    color: !globalOptions.noColor
+  });
+  try {
+    // Check if user is logged in
+    let auth = await getAuthTokens();
+    if (!auth || !auth.accessToken) {
+      if (globalOptions.json) {
+        ui.data({
+          authenticated: false
+        });
+      } else {
+        ui.info('You are not logged in');
+        console.log(''); // Empty line for spacing
+        ui.info('Run "vizzly login" to authenticate');
+      }
+      ui.cleanup();
+      return;
+    }
+
+    // Get current user info
+    ui.startSpinner('Fetching user information...');
+    let authService = new AuthService({
+      baseUrl: options.apiUrl || getApiUrl()
+    });
+    let response = await authService.whoami();
+    ui.stopSpinner();
+
+    // Output in JSON mode
+    if (globalOptions.json) {
+      ui.data({
+        authenticated: true,
+        user: response.user,
+        organizations: response.organizations || [],
+        tokenExpiresAt: auth.expiresAt
+      });
+      ui.cleanup();
+      return;
+    }
+
+    // Human-readable output
+    ui.success('Authenticated');
+    console.log(''); // Empty line for spacing
+
+    // Show user info
+    if (response.user) {
+      ui.info(`User: ${response.user.name || response.user.username}`);
+      ui.info(`Email: ${response.user.email}`);
+      if (response.user.username) {
+        ui.info(`Username: ${response.user.username}`);
+      }
+      if (globalOptions.verbose && response.user.id) {
+        ui.info(`User ID: ${response.user.id}`);
+      }
+    }
+
+    // Show organizations
+    if (response.organizations && response.organizations.length > 0) {
+      console.log(''); // Empty line for spacing
+      ui.info('Organizations:');
+      for (let org of response.organizations) {
+        let orgInfo = `  - ${org.name}`;
+        if (org.slug) {
+          orgInfo += ` (@${org.slug})`;
+        }
+        if (org.role) {
+          orgInfo += ` [${org.role}]`;
+        }
+        console.log(orgInfo);
+        if (globalOptions.verbose && org.id) {
+          console.log(`    ID: ${org.id}`);
+        }
+      }
+    }
+
+    // Show token expiry info
+    if (auth.expiresAt) {
+      console.log(''); // Empty line for spacing
+      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));
+      if (msUntilExpiry <= 0) {
+        ui.warning('Token has expired');
+        console.log(''); // Empty line for spacing
+        ui.info('Run "vizzly login" to refresh your authentication');
+      } else if (daysUntilExpiry > 0) {
+        ui.info(`Token expires in ${daysUntilExpiry} day${daysUntilExpiry !== 1 ? 's' : ''} (${expiresAt.toLocaleDateString()})`);
+      } else if (hoursUntilExpiry > 0) {
+        ui.info(`Token expires in ${hoursUntilExpiry} hour${hoursUntilExpiry !== 1 ? 's' : ''} (${expiresAt.toLocaleString()})`);
+      } else if (minutesUntilExpiry > 0) {
+        ui.info(`Token expires in ${minutesUntilExpiry} minute${minutesUntilExpiry !== 1 ? 's' : ''}`);
+      } else {
+        ui.warning('Token expires in less than a minute');
+        console.log(''); // Empty line for spacing
+        ui.info('Run "vizzly login" to refresh your authentication');
+      }
+      if (globalOptions.verbose) {
+        ui.info(`Token expires at: ${expiresAt.toISOString()}`);
+      }
+    }
+    ui.cleanup();
+  } catch (error) {
+    ui.stopSpinner();
+
+    // Handle authentication errors with helpful messages
+    if (error.name === 'AuthError') {
+      if (globalOptions.json) {
+        ui.data({
+          authenticated: false,
+          error: error.message
+        });
+      } else {
+        ui.error('Authentication token is invalid or expired', error, 0);
+        console.log(''); // Empty line for spacing
+        ui.info('Run "vizzly login" to authenticate again');
+      }
+      ui.cleanup();
+      process.exit(1);
+    } else {
+      ui.error('Failed to get user information', error, 0);
+      if (globalOptions.verbose && error.stack) {
+        console.error(''); // Empty line for spacing
+        console.error(error.stack);
+      }
+      process.exit(1);
+    }
+  }
+}
+
+/**
+ * Validate whoami options
+ * @param {Object} options - Command options
+ */
+export function validateWhoamiOptions() {
+  let errors = [];
+
+  // No specific validation needed for whoami command
+
+  return errors;
+}

package/dist/plugin-loader.js

@@ -131,19 +131,16 @@ async function loadPlugin(pluginPath) {
 
 /**
  * Zod schema for validating plugin structure
+ * Note: Using passthrough() to allow configSchema without validating its structure
+ * to avoid Zod version conflicts when plugins have nested config objects
  */
 const pluginSchema = z.object({
   name: z.string().min(1, 'Plugin name is required'),
   version: z.string().optional(),
-  register: z.function(z.tuple([z.any(), z.any()]), z.void()),
-  configSchema: z.record(z.any()).optional()
-});
-
-/**
- * Zod schema for validating plugin config values
- * Supports: string, number, boolean, null, arrays, and nested objects
- */
-const configValueSchema = z.lazy(() => z.union([z.string(), z.number(), z.boolean(), z.null(), z.array(configValueSchema), z.record(configValueSchema)]));
+  register: z.custom(val => typeof val === 'function', {
+    message: 'register must be a function'
+  })
+}).passthrough();
 
 /**
  * Validate plugin has required structure
@@ -155,14 +152,11 @@ function validatePluginStructure(plugin) {
     // Validate basic plugin structure
     pluginSchema.parse(plugin);
 
-    // If configSchema exists, validate it contains valid config values
-    if (plugin.configSchema) {
-      let configSchemaValidator = z.record(configValueSchema);
-      configSchemaValidator.parse(plugin.configSchema);
-    }
+    // Skip deep validation of configSchema to avoid Zod version conflicts
+    // configSchema is optional and primarily for documentation
   } catch (error) {
     if (error instanceof z.ZodError) {
-      let messages = error.errors.map(e => `${e.path.join('.')}: ${e.message}`);
+      let messages = error.issues.map(e => `${e.path.join('.')}: ${e.message}`);
       throw new Error(`Invalid plugin structure: ${messages.join(', ')}`);
     }
     throw error;

package/dist/sdk/index.js

@@ -11,6 +11,7 @@
  */
 
 import { EventEmitter } from 'events';
+import { resolveImageBuffer } from '../utils/file-helpers.js';
 import { createUploader } from '../services/uploader.js';
 import { createTDDService } from '../services/tdd-service.js';
 import { ScreenshotServer } from '../services/screenshot-server.js';
@@ -226,21 +227,27 @@ export class VizzlySDK extends EventEmitter {
   /**
    * Capture a screenshot
    * @param {string} name - Screenshot name
-   * @param {Buffer} imageBuffer - Image data
+   * @param {Buffer|string} imageBuffer - Image data as a Buffer, or a file path to an image
    * @param {import('../types').ScreenshotOptions} [options] - Options
    * @returns {Promise<void>}
+   * @throws {VizzlyError} When server is not running
+   * @throws {VizzlyError} When file path is provided but file doesn't exist
+   * @throws {VizzlyError} When file cannot be read due to permissions or I/O errors
    */
   async screenshot(name, imageBuffer, options = {}) {
     if (!this.server || !this.server.isRunning()) {
       throw new VizzlyError('Server not running. Call start() first.', 'SERVER_NOT_RUNNING');
     }
 
+    // Resolve Buffer or file path using shared utility
+    const buffer = resolveImageBuffer(imageBuffer, 'screenshot');
+
     // Generate or use provided build ID
     const buildId = options.buildId || this.currentBuildId || 'default';
     this.currentBuildId = buildId;
 
     // Convert Buffer to base64 for JSON transport
-    const imageBase64 = imageBuffer.toString('base64');
+    const imageBase64 = buffer.toString('base64');
     const screenshotData = {
       buildId,
       name,
@@ -331,8 +338,10 @@ export class VizzlySDK extends EventEmitter {
   /**
    * Run local comparison in TDD mode
    * @param {string} name - Screenshot name
-   * @param {Buffer} imageBuffer - Current image
+   * @param {Buffer|string} imageBuffer - Current image as a Buffer, or a file path to an image
    * @returns {Promise<import('../types').ComparisonResult>} Comparison result
+   * @throws {VizzlyError} When file path is provided but file doesn't exist
+   * @throws {VizzlyError} When file cannot be read due to permissions or I/O errors
    */
   async compare(name, imageBuffer) {
     if (!this.services?.tddService) {
@@ -341,8 +350,11 @@ export class VizzlySDK extends EventEmitter {
         logger: this.logger
       });
     }
+
+    // Resolve Buffer or file path using shared utility
+    const buffer = resolveImageBuffer(imageBuffer, 'compare');
     try {
-      const result = await this.services.tddService.compareScreenshot(name, imageBuffer);
+      const result = await this.services.tddService.compareScreenshot(name, buffer);
       this.emit('comparison:completed', result);
       return result;
     } catch (error) {

package/dist/services/api-service.js

@@ -8,23 +8,26 @@ import { VizzlyError, AuthError } from '../errors/vizzly-error.js';
 import crypto from 'crypto';
 import { getPackageVersion } from '../utils/package-info.js';
 import { getApiUrl, getApiToken, getUserAgent } from '../utils/environment-config.js';
+import { getAuthTokens, saveAuthTokens } from '../utils/global-config.js';
 
 /**
  * ApiService class for direct API communication
  */
 export class ApiService {
   constructor(options = {}) {
-    this.baseUrl = options.baseUrl || getApiUrl();
-    this.token = options.token || getApiToken();
+    // Accept config as-is, no fallbacks to environment
+    // Config-loader handles all env/file resolution
+    this.baseUrl = options.apiUrl || options.baseUrl || getApiUrl();
+    this.token = options.apiKey || options.token || getApiToken(); // Accept both apiKey and token
     this.uploadAll = options.uploadAll || false;
 
     // Build User-Agent string
-    const command = options.command || 'run'; // Default to 'run' for API service
+    const command = options.command || 'run';
     const baseUserAgent = `vizzly-cli/${getPackageVersion()} (${command})`;
     const sdkUserAgent = options.userAgent || getUserAgent();
     this.userAgent = sdkUserAgent ? `${baseUserAgent} ${sdkUserAgent}` : baseUserAgent;
     if (!this.token && !options.allowNoToken) {
-      throw new VizzlyError('No API token provided. Set VIZZLY_TOKEN environment variable.');
+      throw new VizzlyError('No API token provided. Set VIZZLY_TOKEN environment variable or run "vizzly login".');
     }
   }
 
@@ -32,9 +35,10 @@ export class ApiService {
    * Make an API request
    * @param {string} endpoint - API endpoint
    * @param {Object} options - Fetch options
+   * @param {boolean} isRetry - Internal flag to prevent infinite retry loops
    * @returns {Promise<Object>} Response data
    */
-  async request(endpoint, options = {}) {
+  async request(endpoint, options = {}, isRetry = false) {
     const url = `${this.baseUrl}${endpoint}`;
     const headers = {
       'User-Agent': this.userAgent,
@@ -59,9 +63,48 @@ export class ApiService {
         // ignore
       }
 
-      // Handle authentication errors with user-friendly messages
+      // Handle authentication errors with automatic token refresh
+      if (response.status === 401 && !isRetry) {
+        // Attempt to refresh token if we have refresh token in global config
+        let auth = await getAuthTokens();
+        if (auth && auth.refreshToken) {
+          try {
+            // Attempt token refresh
+            let refreshResponse = await fetch(`${this.baseUrl}/api/auth/cli/refresh`, {
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
+                'User-Agent': this.userAgent
+              },
+              body: JSON.stringify({
+                refreshToken: auth.refreshToken
+              })
+            });
+            if (refreshResponse.ok) {
+              let refreshData = await refreshResponse.json();
+
+              // Save new tokens to global config
+              await saveAuthTokens({
+                accessToken: refreshData.accessToken,
+                refreshToken: refreshData.refreshToken,
+                expiresAt: refreshData.expiresAt,
+                user: auth.user // Keep existing user data
+              });
+
+              // Update token for this service instance
+              this.token = refreshData.accessToken;
+
+              // Retry the original request with new token
+              return this.request(endpoint, options, true);
+            }
+          } catch {
+            // Token refresh failed, fall through to auth error
+          }
+        }
+        throw new AuthError('Invalid or expired API token. Please run "vizzly login" to authenticate.');
+      }
       if (response.status === 401) {
-        throw new AuthError('Invalid or expired API token. Please check your VIZZLY_TOKEN environment variable and ensure it is valid.');
+        throw new AuthError('Invalid or expired API token. Please run "vizzly login" to authenticate.');
       }
       throw new VizzlyError(`API request failed: ${response.status}${errorText ? ` - ${errorText}` : ''} (URL: ${url})`);
     }

package/dist/services/auth-service.js

@@ -0,0 +1,226 @@
+/**
+ * Authentication Service for Vizzly CLI
+ * Handles authentication flows with the Vizzly API
+ */
+
+import { AuthError, VizzlyError } from '../errors/vizzly-error.js';
+import { getApiUrl } from '../utils/environment-config.js';
+import { getPackageVersion } from '../utils/package-info.js';
+import { saveAuthTokens, clearAuthTokens, getAuthTokens } from '../utils/global-config.js';
+
+/**
+ * AuthService class for CLI authentication
+ */
+export class AuthService {
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl || getApiUrl();
+    this.userAgent = `vizzly-cli/${getPackageVersion()} (auth)`;
+  }
+
+  /**
+   * Make an unauthenticated API request
+   * @param {string} endpoint - API endpoint
+   * @param {Object} options - Fetch options
+   * @returns {Promise<Object>} Response data
+   */
+  async request(endpoint, options = {}) {
+    let url = `${this.baseUrl}${endpoint}`;
+    let headers = {
+      'User-Agent': this.userAgent,
+      ...options.headers
+    };
+    let response = await fetch(url, {
+      ...options,
+      headers
+    });
+    if (!response.ok) {
+      let errorText = '';
+      let errorData = null;
+      try {
+        let contentType = response.headers.get('content-type');
+        if (contentType && contentType.includes('application/json')) {
+          errorData = await response.json();
+          errorText = errorData.error || errorData.message || '';
+        } else {
+          errorText = await response.text();
+        }
+      } catch {
+        errorText = response.statusText || '';
+      }
+      if (response.status === 401) {
+        throw new AuthError(errorText || 'Invalid credentials. Please check your email/username and password.');
+      }
+      if (response.status === 429) {
+        throw new VizzlyError('Too many login attempts. Please try again later.', 'RATE_LIMIT_ERROR');
+      }
+      throw new VizzlyError(`Authentication request failed: ${response.status}${errorText ? ` - ${errorText}` : ''}`, 'AUTH_REQUEST_ERROR');
+    }
+    return response.json();
+  }
+
+  /**
+   * Make an authenticated API request
+   * @param {string} endpoint - API endpoint
+   * @param {Object} options - Fetch options
+   * @returns {Promise<Object>} Response data
+   */
+  async authenticatedRequest(endpoint, options = {}) {
+    let auth = await getAuthTokens();
+    if (!auth || !auth.accessToken) {
+      throw new AuthError('No authentication token found. Please run "vizzly login" first.');
+    }
+    let url = `${this.baseUrl}${endpoint}`;
+    let headers = {
+      'User-Agent': this.userAgent,
+      Authorization: `Bearer ${auth.accessToken}`,
+      ...options.headers
+    };
+    let response = await fetch(url, {
+      ...options,
+      headers
+    });
+    if (!response.ok) {
+      let errorText = '';
+      try {
+        let contentType = response.headers.get('content-type');
+        if (contentType && contentType.includes('application/json')) {
+          let errorData = await response.json();
+          errorText = errorData.error || errorData.message || '';
+        } else {
+          errorText = await response.text();
+        }
+      } catch {
+        errorText = response.statusText || '';
+      }
+      if (response.status === 401) {
+        throw new AuthError('Authentication token is invalid or expired. Please run "vizzly login" again.');
+      }
+      throw new VizzlyError(`API request failed: ${response.status}${errorText ? ` - ${errorText}` : ''}`, 'API_REQUEST_ERROR');
+    }
+    return response.json();
+  }
+
+  /**
+   * Initiate OAuth device flow
+   * @returns {Promise<Object>} Device code, user code, verification URL
+   */
+  async initiateDeviceFlow() {
+    return this.request('/api/auth/cli/device/initiate', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      }
+    });
+  }
+
+  /**
+   * Poll for device authorization
+   * @param {string} deviceCode - Device code from initiate
+   * @returns {Promise<Object>} Token data or pending status
+   */
+  async pollDeviceAuthorization(deviceCode) {
+    return this.request('/api/auth/cli/device/poll', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        device_code: deviceCode
+      })
+    });
+  }
+
+  /**
+   * Complete device flow and save tokens
+   * @param {Object} tokenData - Token response from poll
+   * @returns {Promise<Object>} Token data with user info
+   */
+  async completeDeviceFlow(tokenData) {
+    // Save tokens to global config
+    await saveAuthTokens({
+      accessToken: tokenData.accessToken,
+      refreshToken: tokenData.refreshToken,
+      expiresAt: tokenData.expiresAt,
+      user: tokenData.user
+    });
+    return tokenData;
+  }
+
+  /**
+   * Refresh access token using refresh token
+   * @returns {Promise<Object>} New tokens
+   */
+  async refresh() {
+    let auth = await getAuthTokens();
+    if (!auth || !auth.refreshToken) {
+      throw new AuthError('No refresh token found. Please run "vizzly login" first.');
+    }
+    let response = await this.request('/api/auth/cli/refresh', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify({
+        refreshToken: auth.refreshToken
+      })
+    });
+
+    // Update tokens in global config
+    await saveAuthTokens({
+      accessToken: response.accessToken,
+      refreshToken: response.refreshToken,
+      expiresAt: response.expiresAt,
+      user: auth.user // Keep existing user data
+    });
+    return response;
+  }
+
+  /**
+   * Logout and revoke tokens
+   * @returns {Promise<void>}
+   */
+  async logout() {
+    let auth = await getAuthTokens();
+    if (auth && auth.refreshToken) {
+      try {
+        // Attempt to revoke tokens on server
+        await this.request('/api/auth/cli/logout', {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json'
+          },
+          body: JSON.stringify({
+            refreshToken: auth.refreshToken
+          })
+        });
+      } catch (error) {
+        // If server request fails, still clear local tokens
+        console.warn('Warning: Failed to revoke tokens on server:', error.message);
+      }
+    }
+
+    // Clear tokens from global config
+    await clearAuthTokens();
+  }
+
+  /**
+   * Get current user information
+   * @returns {Promise<Object>} User and organization data
+   */
+  async whoami() {
+    return this.authenticatedRequest('/api/auth/cli/whoami');
+  }
+
+  /**
+   * Check if user is authenticated
+   * @returns {Promise<boolean>} True if authenticated
+   */
+  async isAuthenticated() {
+    try {
+      await this.whoami();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}

package/dist/types/client/index.d.ts

@@ -2,7 +2,7 @@
  * Take a screenshot for visual regression testing
  *
  * @param {string} name - Unique name for the screenshot
- * @param {Buffer} imageBuffer - PNG image data as a Buffer
+ * @param {Buffer|string} imageBuffer - PNG image data as a Buffer, or a file path to an image
  * @param {Object} [options] - Optional configuration
  * @param {Record<string, any>} [options.properties] - Additional properties to attach to the screenshot
  * @param {number} [options.threshold=0] - Pixel difference threshold (0-100)
@@ -11,13 +11,17 @@
  * @returns {Promise<void>}
  *
  * @example
- * // Basic usage
+ * // Basic usage with Buffer
  * import { vizzlyScreenshot } from '@vizzly-testing/cli/client';
  *
  * const screenshot = await page.screenshot();
  * await vizzlyScreenshot('homepage', screenshot);
  *
  * @example
+ * // Basic usage with file path
+ * await vizzlyScreenshot('homepage', './screenshots/homepage.png');
+ *
+ * @example
  * // With properties and threshold
  * await vizzlyScreenshot('checkout-form', screenshot, {
  *   properties: {
@@ -28,8 +32,10 @@
  * });
  *
  * @throws {VizzlyError} When screenshot capture fails or client is not initialized
+ * @throws {VizzlyError} When file path is provided but file doesn't exist
+ * @throws {VizzlyError} When file cannot be read due to permissions or I/O errors
  */
-export function vizzlyScreenshot(name: string, imageBuffer: Buffer, options?: {
+export function vizzlyScreenshot(name: string, imageBuffer: Buffer | string, options?: {
     properties?: Record<string, any>;
     threshold?: number;
     fullPage?: boolean;

package/dist/types/commands/login.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Login command implementation using OAuth device flow
+ * @param {Object} options - Command options
+ * @param {Object} globalOptions - Global CLI options
+ */
+export function loginCommand(options?: any, globalOptions?: any): Promise<void>;
+/**
+ * Validate login options
+ * @param {Object} options - Command options
+ */
+export function validateLoginOptions(): any[];