@vizzly-testing/cli 0.13.1 → 0.13.3

package/dist/services/config-service.js

@@ -0,0 +1,371 @@
+/**
+ * Configuration Service
+ * Manages reading and writing Vizzly configuration files
+ */
+
+import { BaseService } from './base-service.js';
+import { cosmiconfigSync } from 'cosmiconfig';
+import { writeFile, readFile } from 'fs/promises';
+import { join } from 'path';
+import { VizzlyError } from '../errors/vizzly-error.js';
+import { validateVizzlyConfigWithDefaults } from '../utils/config-schema.js';
+import { loadGlobalConfig, saveGlobalConfig, getGlobalConfigPath } from '../utils/global-config.js';
+
+/**
+ * ConfigService for reading and writing configuration
+ * @extends BaseService
+ */
+export class ConfigService extends BaseService {
+  constructor(config, options = {}) {
+    super(config, options);
+    this.projectRoot = options.projectRoot || process.cwd();
+    this.explorer = cosmiconfigSync('vizzly');
+  }
+
+  /**
+   * Get configuration with source information
+   * @param {string} scope - 'project', 'global', or 'merged'
+   * @returns {Promise<Object>} Config object with metadata
+   */
+  async getConfig(scope = 'merged') {
+    if (scope === 'project') {
+      return this._getProjectConfig();
+    }
+    if (scope === 'global') {
+      return this._getGlobalConfig();
+    }
+    if (scope === 'merged') {
+      return this._getMergedConfig();
+    }
+    throw new VizzlyError(`Invalid config scope: ${scope}. Must be 'project', 'global', or 'merged'`, 'INVALID_CONFIG_SCOPE');
+  }
+
+  /**
+   * Get project-level config from vizzly.config.js or similar
+   * @private
+   * @returns {Promise<Object>}
+   */
+  async _getProjectConfig() {
+    let result = this.explorer.search(this.projectRoot);
+    if (!result || !result.config) {
+      return {
+        config: {},
+        filepath: null,
+        isEmpty: true
+      };
+    }
+    let config = result.config.default || result.config;
+    return {
+      config,
+      filepath: result.filepath,
+      isEmpty: Object.keys(config).length === 0
+    };
+  }
+
+  /**
+   * Get global config from ~/.vizzly/config.json
+   * @private
+   * @returns {Promise<Object>}
+   */
+  async _getGlobalConfig() {
+    let globalConfig = await loadGlobalConfig();
+    return {
+      config: globalConfig,
+      filepath: getGlobalConfigPath(),
+      isEmpty: Object.keys(globalConfig).length === 0
+    };
+  }
+
+  /**
+   * Get merged config showing source for each setting
+   * @private
+   * @returns {Promise<Object>}
+   */
+  async _getMergedConfig() {
+    let projectConfigData = await this._getProjectConfig();
+    let globalConfigData = await this._getGlobalConfig();
+
+    // Build config with source tracking
+    let mergedConfig = {};
+    let sources = {};
+
+    // Layer 1: Defaults
+    let defaults = {
+      apiUrl: 'https://app.vizzly.dev',
+      server: {
+        port: 47392,
+        timeout: 30000
+      },
+      build: {
+        name: 'Build {timestamp}',
+        environment: 'test'
+      },
+      upload: {
+        screenshotsDir: './screenshots',
+        batchSize: 10,
+        timeout: 30000
+      },
+      comparison: {
+        threshold: 0.1
+      },
+      tdd: {
+        openReport: false
+      },
+      plugins: []
+    };
+    Object.keys(defaults).forEach(key => {
+      mergedConfig[key] = defaults[key];
+      sources[key] = 'default';
+    });
+
+    // Layer 2: Global config (auth, project mappings, user preferences)
+    if (globalConfigData.config.auth) {
+      mergedConfig.auth = globalConfigData.config.auth;
+      sources.auth = 'global';
+    }
+    if (globalConfigData.config.projects) {
+      mergedConfig.projects = globalConfigData.config.projects;
+      sources.projects = 'global';
+    }
+
+    // Layer 3: Project config file
+    Object.keys(projectConfigData.config).forEach(key => {
+      mergedConfig[key] = projectConfigData.config[key];
+      sources[key] = 'project';
+    });
+
+    // Layer 4: Environment variables (tracked separately)
+    let envOverrides = {};
+    if (process.env.VIZZLY_TOKEN) {
+      envOverrides.apiKey = process.env.VIZZLY_TOKEN;
+      sources.apiKey = 'env';
+    }
+    if (process.env.VIZZLY_API_URL) {
+      envOverrides.apiUrl = process.env.VIZZLY_API_URL;
+      sources.apiUrl = 'env';
+    }
+    return {
+      config: {
+        ...mergedConfig,
+        ...envOverrides
+      },
+      sources,
+      projectFilepath: projectConfigData.filepath,
+      globalFilepath: globalConfigData.filepath
+    };
+  }
+
+  /**
+   * Update configuration
+   * @param {string} scope - 'project' or 'global'
+   * @param {Object} updates - Configuration updates to apply
+   * @returns {Promise<Object>} Updated config
+   */
+  async updateConfig(scope, updates) {
+    if (scope === 'project') {
+      return this._updateProjectConfig(updates);
+    }
+    if (scope === 'global') {
+      return this._updateGlobalConfig(updates);
+    }
+    throw new VizzlyError(`Invalid config scope for update: ${scope}. Must be 'project' or 'global'`, 'INVALID_CONFIG_SCOPE');
+  }
+
+  /**
+   * Update project-level config
+   * @private
+   * @param {Object} updates - Config updates
+   * @returns {Promise<Object>} Updated config
+   */
+  async _updateProjectConfig(updates) {
+    let result = this.explorer.search(this.projectRoot);
+
+    // Determine config file path
+    let configPath;
+    let currentConfig = {};
+    if (result && result.filepath) {
+      configPath = result.filepath;
+      currentConfig = result.config.default || result.config;
+    } else {
+      // Create new config file - prefer vizzly.config.js
+      configPath = join(this.projectRoot, 'vizzly.config.js');
+    }
+
+    // Merge updates with current config
+    let newConfig = this._deepMerge(currentConfig, updates);
+
+    // Validate before writing
+    try {
+      validateVizzlyConfigWithDefaults(newConfig);
+    } catch (error) {
+      throw new VizzlyError(`Invalid configuration: ${error.message}`, 'CONFIG_VALIDATION_ERROR', {
+        errors: error.errors
+      });
+    }
+
+    // Write config file
+    await this._writeProjectConfigFile(configPath, newConfig);
+
+    // Clear cosmiconfig cache
+    this.explorer.clearCaches();
+    return {
+      config: newConfig,
+      filepath: configPath
+    };
+  }
+
+  /**
+   * Update global config
+   * @private
+   * @param {Object} updates - Config updates
+   * @returns {Promise<Object>} Updated config
+   */
+  async _updateGlobalConfig(updates) {
+    let currentConfig = await loadGlobalConfig();
+    let newConfig = this._deepMerge(currentConfig, updates);
+    await saveGlobalConfig(newConfig);
+    return {
+      config: newConfig,
+      filepath: getGlobalConfigPath()
+    };
+  }
+
+  /**
+   * Write project config file (JavaScript format)
+   * @private
+   * @param {string} filepath - Path to write to
+   * @param {Object} config - Config object
+   * @returns {Promise<void>}
+   */
+  async _writeProjectConfigFile(filepath, config) {
+    // For .js files, export as ES module
+    if (filepath.endsWith('.js') || filepath.endsWith('.mjs')) {
+      let content = this._serializeToJavaScript(config);
+      await writeFile(filepath, content, 'utf-8');
+      return;
+    }
+
+    // For .json files
+    if (filepath.endsWith('.json')) {
+      let content = JSON.stringify(config, null, 2);
+      await writeFile(filepath, content, 'utf-8');
+      return;
+    }
+
+    // For package.json, merge into existing
+    if (filepath.endsWith('package.json')) {
+      let pkgContent = await readFile(filepath, 'utf-8');
+      let pkg = JSON.parse(pkgContent);
+      pkg.vizzly = config;
+      await writeFile(filepath, JSON.stringify(pkg, null, 2), 'utf-8');
+      return;
+    }
+    throw new VizzlyError(`Unsupported config file format: ${filepath}`, 'UNSUPPORTED_CONFIG_FORMAT');
+  }
+
+  /**
+   * Serialize config object to JavaScript module
+   * @private
+   * @param {Object} config - Config object
+   * @returns {string} JavaScript source code
+   */
+  _serializeToJavaScript(config) {
+    let lines = ['/**', ' * Vizzly Configuration', ' * @see https://docs.vizzly.dev/cli/configuration', ' */', '', "import { defineConfig } from '@vizzly-testing/cli/config';", '', 'export default defineConfig(', this._stringifyWithIndent(config, 1), ');', ''];
+    return lines.join('\n');
+  }
+
+  /**
+   * Stringify object with proper indentation (2 spaces)
+   * @private
+   * @param {*} value - Value to stringify
+   * @param {number} depth - Current depth
+   * @returns {string}
+   */
+  _stringifyWithIndent(value, depth = 0) {
+    let indent = '  '.repeat(depth);
+    let prevIndent = '  '.repeat(depth - 1);
+    if (value === null || value === undefined) {
+      return String(value);
+    }
+    if (typeof value === 'string') {
+      return `'${value.replace(/'/g, "\\'")}'`;
+    }
+    if (typeof value === 'number' || typeof value === 'boolean') {
+      return String(value);
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) return '[]';
+      let items = value.map(item => `${indent}${this._stringifyWithIndent(item, depth + 1)}`);
+      return `[\n${items.join(',\n')}\n${prevIndent}]`;
+    }
+    if (typeof value === 'object') {
+      let keys = Object.keys(value);
+      if (keys.length === 0) return '{}';
+      let items = keys.map(key => {
+        let val = this._stringifyWithIndent(value[key], depth + 1);
+        return `${indent}${key}: ${val}`;
+      });
+      return `{\n${items.join(',\n')}\n${prevIndent}}`;
+    }
+    return String(value);
+  }
+
+  /**
+   * Validate configuration object
+   * @param {Object} config - Config to validate
+   * @returns {Promise<Object>} Validation result
+   */
+  async validateConfig(config) {
+    try {
+      let validated = validateVizzlyConfigWithDefaults(config);
+      return {
+        valid: true,
+        config: validated,
+        errors: []
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        config: null,
+        errors: error.errors || [{
+          message: error.message
+        }]
+      };
+    }
+  }
+
+  /**
+   * Get the source of a specific config key
+   * @param {string} key - Config key
+   * @returns {Promise<string>} Source ('default', 'global', 'project', 'env', 'cli')
+   */
+  async getConfigSource(key) {
+    let merged = await this._getMergedConfig();
+    return merged.sources[key] || 'unknown';
+  }
+
+  /**
+   * Deep merge two objects
+   * @private
+   * @param {Object} target - Target object
+   * @param {Object} source - Source object
+   * @returns {Object} Merged object
+   */
+  _deepMerge(target, source) {
+    let output = {
+      ...target
+    };
+    for (let key in source) {
+      if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
+        if (target[key] && typeof target[key] === 'object' && !Array.isArray(target[key])) {
+          output[key] = this._deepMerge(target[key], source[key]);
+        } else {
+          output[key] = source[key];
+        }
+      } else {
+        output[key] = source[key];
+      }
+    }
+    return output;
+  }
+}

package/dist/services/project-service.js

@@ -0,0 +1,245 @@
+/**
+ * Project Service
+ * Manages project mappings and project-related operations
+ */
+
+import { BaseService } from './base-service.js';
+import { VizzlyError } from '../errors/vizzly-error.js';
+import { getProjectMappings, saveProjectMapping, deleteProjectMapping, getProjectMapping } from '../utils/global-config.js';
+
+/**
+ * ProjectService for managing project mappings and operations
+ * @extends BaseService
+ */
+export class ProjectService extends BaseService {
+  constructor(config, options = {}) {
+    super(config, options);
+    this.apiService = options.apiService;
+  }
+
+  /**
+   * List all project mappings
+   * @returns {Promise<Array>} Array of project mappings
+   */
+  async listMappings() {
+    let mappings = await getProjectMappings();
+
+    // Convert object to array with directory path included
+    return Object.entries(mappings).map(([directory, data]) => ({
+      directory,
+      ...data
+    }));
+  }
+
+  /**
+   * Get project mapping for a specific directory
+   * @param {string} directory - Directory path
+   * @returns {Promise<Object|null>} Project mapping or null
+   */
+  async getMapping(directory) {
+    return getProjectMapping(directory);
+  }
+
+  /**
+   * Create or update project mapping
+   * @param {string} directory - Directory path
+   * @param {Object} projectData - Project data
+   * @param {string} projectData.projectSlug - Project slug
+   * @param {string} projectData.organizationSlug - Organization slug
+   * @param {string} projectData.token - Project API token
+   * @param {string} [projectData.projectName] - Optional project name
+   * @returns {Promise<Object>} Created mapping
+   */
+  async createMapping(directory, projectData) {
+    if (!directory) {
+      throw new VizzlyError('Directory path is required', 'INVALID_DIRECTORY');
+    }
+    if (!projectData.projectSlug) {
+      throw new VizzlyError('Project slug is required', 'INVALID_PROJECT_DATA');
+    }
+    if (!projectData.organizationSlug) {
+      throw new VizzlyError('Organization slug is required', 'INVALID_PROJECT_DATA');
+    }
+    if (!projectData.token) {
+      throw new VizzlyError('Project token is required', 'INVALID_PROJECT_DATA');
+    }
+    await saveProjectMapping(directory, projectData);
+    return {
+      directory,
+      ...projectData
+    };
+  }
+
+  /**
+   * Remove project mapping
+   * @param {string} directory - Directory path
+   * @returns {Promise<void>}
+   */
+  async removeMapping(directory) {
+    if (!directory) {
+      throw new VizzlyError('Directory path is required', 'INVALID_DIRECTORY');
+    }
+    await deleteProjectMapping(directory);
+  }
+
+  /**
+   * Switch project for current directory
+   * @param {string} projectSlug - Project slug
+   * @param {string} organizationSlug - Organization slug
+   * @param {string} token - Project token
+   * @returns {Promise<Object>} Updated mapping
+   */
+  async switchProject(projectSlug, organizationSlug, token) {
+    let currentDir = process.cwd();
+    return this.createMapping(currentDir, {
+      projectSlug,
+      organizationSlug,
+      token
+    });
+  }
+
+  /**
+   * List all projects from API
+   * @returns {Promise<Array>} Array of projects
+   */
+  async listProjects() {
+    if (!this.apiService) {
+      // Return empty array if not authenticated - this is expected in local mode
+      return [];
+    }
+    try {
+      let response = await this.apiService.request('/api/cli/projects', {
+        method: 'GET'
+      });
+      return response.projects || [];
+    } catch {
+      // Return empty array on error - likely not authenticated
+      return [];
+    }
+  }
+
+  /**
+   * Get project details
+   * @param {string} projectSlug - Project slug
+   * @param {string} organizationSlug - Organization slug
+   * @returns {Promise<Object>} Project details
+   */
+  async getProject(projectSlug, organizationSlug) {
+    if (!this.apiService) {
+      throw new VizzlyError('API service not available', 'NO_API_SERVICE');
+    }
+    try {
+      let response = await this.apiService.request(`/api/cli/organizations/${organizationSlug}/projects/${projectSlug}`, {
+        method: 'GET'
+      });
+      return response.project;
+    } catch (error) {
+      throw new VizzlyError(`Failed to fetch project: ${error.message}`, 'PROJECT_FETCH_FAILED', {
+        originalError: error
+      });
+    }
+  }
+
+  /**
+   * Get recent builds for a project
+   * @param {string} projectSlug - Project slug
+   * @param {string} organizationSlug - Organization slug
+   * @param {Object} options - Query options
+   * @param {number} [options.limit=10] - Number of builds to fetch
+   * @param {string} [options.branch] - Filter by branch
+   * @returns {Promise<Array>} Array of builds
+   */
+  async getRecentBuilds(projectSlug, organizationSlug, options = {}) {
+    if (!this.apiService) {
+      // Return empty array if not authenticated
+      return [];
+    }
+    let queryParams = new globalThis.URLSearchParams();
+    if (options.limit) queryParams.append('limit', String(options.limit));
+    if (options.branch) queryParams.append('branch', options.branch);
+    let query = queryParams.toString();
+    let url = `/api/cli/organizations/${organizationSlug}/projects/${projectSlug}/builds${query ? `?${query}` : ''}`;
+    try {
+      let response = await this.apiService.request(url, {
+        method: 'GET'
+      });
+      return response.builds || [];
+    } catch {
+      // Return empty array on error
+      return [];
+    }
+  }
+
+  /**
+   * Create a project token
+   * @param {string} projectSlug - Project slug
+   * @param {string} organizationSlug - Organization slug
+   * @param {Object} tokenData - Token data
+   * @param {string} tokenData.name - Token name
+   * @param {string} [tokenData.description] - Token description
+   * @returns {Promise<Object>} Created token
+   */
+  async createProjectToken(projectSlug, organizationSlug, tokenData) {
+    if (!this.apiService) {
+      throw new VizzlyError('API service not available', 'NO_API_SERVICE');
+    }
+    try {
+      let response = await this.apiService.request(`/api/cli/organizations/${organizationSlug}/projects/${projectSlug}/tokens`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify(tokenData)
+      });
+      return response.token;
+    } catch (error) {
+      throw new VizzlyError(`Failed to create project token: ${error.message}`, 'TOKEN_CREATE_FAILED', {
+        originalError: error
+      });
+    }
+  }
+
+  /**
+   * List project tokens
+   * @param {string} projectSlug - Project slug
+   * @param {string} organizationSlug - Organization slug
+   * @returns {Promise<Array>} Array of tokens
+   */
+  async listProjectTokens(projectSlug, organizationSlug) {
+    if (!this.apiService) {
+      throw new VizzlyError('API service not available', 'NO_API_SERVICE');
+    }
+    try {
+      let response = await this.apiService.request(`/api/cli/organizations/${organizationSlug}/projects/${projectSlug}/tokens`, {
+        method: 'GET'
+      });
+      return response.tokens || [];
+    } catch (error) {
+      throw new VizzlyError(`Failed to fetch project tokens: ${error.message}`, 'TOKENS_FETCH_FAILED', {
+        originalError: error
+      });
+    }
+  }
+
+  /**
+   * Revoke a project token
+   * @param {string} projectSlug - Project slug
+   * @param {string} organizationSlug - Organization slug
+   * @param {string} tokenId - Token ID
+   * @returns {Promise<void>}
+   */
+  async revokeProjectToken(projectSlug, organizationSlug, tokenId) {
+    if (!this.apiService) {
+      throw new VizzlyError('API service not available', 'NO_API_SERVICE');
+    }
+    try {
+      await this.apiService.request(`/api/cli/organizations/${organizationSlug}/projects/${projectSlug}/tokens/${tokenId}`, {
+        method: 'DELETE'
+      });
+    } catch (error) {
+      throw new VizzlyError(`Failed to revoke project token: ${error.message}`, 'TOKEN_REVOKE_FAILED', {
+        originalError: error
+      });
+    }
+  }
+}

package/dist/services/server-manager.js

@@ -7,13 +7,14 @@ import { BaseService } from './base-service.js';
 import { createHttpServer } from '../server/http-server.js';
 import { createTddHandler } from '../server/handlers/tdd-handler.js';
 import { createApiHandler } from '../server/handlers/api-handler.js';
+import { writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
 export class ServerManager extends BaseService {
-  constructor(config, logger) {
-    super(config, {
-      logger
-    });
+  constructor(config, options = {}) {
+    super(config, options);
     this.httpServer = null;
     this.handler = null;
+    this.services = options.services || {};
   }
   async start(buildId = null, tddMode = false, setBaseline = false) {
     this.buildId = buildId;
@@ -30,10 +31,36 @@ export class ServerManager extends BaseService {
       const apiService = await this.createApiService();
       this.handler = createApiHandler(apiService);
     }
-    this.httpServer = createHttpServer(port, this.handler);
+    this.httpServer = createHttpServer(port, this.handler, this.services);
     if (this.httpServer) {
       await this.httpServer.start();
     }
+
+    // Write server info to .vizzly/server.json for SDK discovery
+    // This allows SDKs that can't access environment variables (like Swift/iOS)
+    // to discover both the server port and current build ID
+    try {
+      const vizzlyDir = join(process.cwd(), '.vizzly');
+      mkdirSync(vizzlyDir, {
+        recursive: true
+      });
+      const serverFile = join(vizzlyDir, 'server.json');
+      const serverInfo = {
+        port: port.toString(),
+        pid: process.pid,
+        startTime: Date.now()
+      };
+
+      // Include buildId if we have one (for `vizzly run` mode)
+      if (this.buildId) {
+        serverInfo.buildId = this.buildId;
+      }
+      writeFileSync(serverFile, JSON.stringify(serverInfo, null, 2));
+      this.logger.debug(`Wrote server info to ${serverFile}`);
+    } catch (error) {
+      // Non-fatal - SDK can still use health check or environment variables
+      this.logger.debug(`Failed to write server.json: ${error.message}`);
+    }
   }
   async createApiService() {
     if (!this.config.apiKey) return null;