@vizzly-testing/cli 0.14.0 → 0.15.0

package/dist/services/config-service.js

@@ -3,7 +3,6 @@
  * 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';
@@ -13,11 +12,10 @@ import { loadGlobalConfig, saveGlobalConfig, getGlobalConfigPath } from '../util
 
 /**
  * ConfigService for reading and writing configuration
- * @extends BaseService
  */
-export class ConfigService extends BaseService {
+export class ConfigService {
   constructor(config, options = {}) {
-    super(config, options);
+    this.config = config;
     this.projectRoot = options.projectRoot || process.cwd();
     this.explorer = cosmiconfigSync('vizzly');
   }

package/dist/services/html-report-generator.js

@@ -7,8 +7,7 @@ import { writeFile, mkdir } from 'fs/promises';
 import { existsSync } from 'fs';
 import { join, relative, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { createServiceLogger } from '../utils/logger-factory.js';
-const logger = createServiceLogger('HTML-REPORT');
+import * as output from '../utils/output.js';
 export class HtmlReportGenerator {
   constructor(workingDir, config) {
     this.workingDir = workingDir;
@@ -93,10 +92,12 @@ export class HtmlReportGenerator {
         recursive: true
       });
       await writeFile(this.reportPath, htmlContent, 'utf8');
-      logger.debug(`HTML report generated: ${this.reportPath}`);
+      output.debug('report', 'generated html report');
       return this.reportPath;
     } catch (error) {
-      logger.error(`Failed to generate HTML report: ${error.message}`);
+      output.debug('report', 'html generation failed', {
+        error: error.message
+      });
       throw new Error(`Report generation failed: ${error.message}`);
     }
   }
@@ -108,7 +109,7 @@ export class HtmlReportGenerator {
    */
   processComparison(comparison) {
     if (!comparison || typeof comparison !== 'object') {
-      logger.warn('Invalid comparison object provided');
+      output.warn('Invalid comparison object provided');
       return null;
     }
     return {

package/dist/services/index.js

@@ -0,0 +1,64 @@
+/**
+ * Service Factory
+ * Creates all services with explicit dependencies - no DI container needed
+ */
+
+import { ApiService } from './api-service.js';
+import { AuthService } from './auth-service.js';
+import { ConfigService } from './config-service.js';
+import { ProjectService } from './project-service.js';
+import { createUploader } from './uploader.js';
+import { BuildManager } from './build-manager.js';
+import { ServerManager } from './server-manager.js';
+import { createTDDService } from './tdd-service.js';
+import { TestRunner } from './test-runner.js';
+
+/**
+ * Create all services with their dependencies
+ * @param {Object} config - Configuration object
+ * @param {string} [command='run'] - Command context ('run', 'tdd', 'status')
+ * @returns {Object} Services object
+ */
+export function createServices(config, command = 'run') {
+  let apiService = new ApiService({
+    ...config,
+    allowNoToken: true
+  });
+  let authService = new AuthService({
+    baseUrl: config.apiUrl
+  });
+  let configService = new ConfigService(config, {
+    projectRoot: process.cwd()
+  });
+  let projectService = new ProjectService(config, {
+    apiService,
+    authService
+  });
+  let uploader = createUploader({
+    ...config,
+    command
+  });
+  let buildManager = new BuildManager(config);
+  let tddService = createTDDService(config, {
+    authService
+  });
+  let serverManager = new ServerManager(config, {
+    services: {
+      configService,
+      authService,
+      projectService
+    }
+  });
+  let testRunner = new TestRunner(config, buildManager, serverManager, tddService);
+  return {
+    apiService,
+    authService,
+    configService,
+    projectService,
+    uploader,
+    buildManager,
+    serverManager,
+    tddService,
+    testRunner
+  };
+}

package/dist/services/project-service.js

@@ -3,18 +3,17 @@
  * 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 {
+export class ProjectService {
   constructor(config, options = {}) {
-    super(config, options);
+    this.config = config;
     this.apiService = options.apiService;
+    this.authService = options.authService;
   }
 
   /**
@@ -100,22 +99,64 @@ export class ProjectService extends BaseService {
 
   /**
    * List all projects from API
-   * @returns {Promise<Array>} Array of projects
+   * Uses OAuth authentication (authService) when available, falls back to API token
+   * @returns {Promise<Array>} Array of projects with organization info
    */
   async listProjects() {
-    if (!this.apiService) {
-      // Return empty array if not authenticated - this is expected in local mode
-      return [];
+    // Try OAuth-based request first (user login via device flow)
+    if (this.authService) {
+      try {
+        // First get the user's organizations via whoami
+        let whoami = await this.authService.authenticatedRequest('/api/auth/cli/whoami', {
+          method: 'GET'
+        });
+        let organizations = whoami.organizations || [];
+        if (organizations.length === 0) {
+          return [];
+        }
+
+        // Fetch projects for each organization
+        let allProjects = [];
+        for (let org of organizations) {
+          try {
+            let response = await this.authService.authenticatedRequest('/api/project', {
+              method: 'GET',
+              headers: {
+                'X-Organization': org.slug
+              }
+            });
+
+            // Add organization info to each project
+            let projects = (response.projects || []).map(project => ({
+              ...project,
+              organizationSlug: org.slug,
+              organizationName: org.name
+            }));
+            allProjects.push(...projects);
+          } catch {
+            // Silently skip failed orgs
+          }
+        }
+        return allProjects;
+      } catch {
+        // Fall back to API token
+      }
     }
-    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 [];
+
+    // Fall back to API token-based request (tokens are org-scoped, so no org header needed)
+    if (this.apiService) {
+      try {
+        let response = await this.apiService.request('/api/project', {
+          method: 'GET'
+        });
+        return response.projects || [];
+      } catch {
+        return [];
+      }
     }
+
+    // No authentication available
+    return [];
   }
 
   /**
@@ -125,23 +166,43 @@ export class ProjectService extends BaseService {
    * @returns {Promise<Object>} Project details
    */
   async getProject(projectSlug, organizationSlug) {
-    if (!this.apiService) {
-      throw new VizzlyError('API service not available', 'NO_API_SERVICE');
+    // Try OAuth-based request first
+    if (this.authService) {
+      try {
+        let response = await this.authService.authenticatedRequest(`/api/project/${projectSlug}`, {
+          method: 'GET',
+          headers: {
+            'X-Organization': organizationSlug
+          }
+        });
+        return response.project || response;
+      } catch {
+        // Fall back to API token
+      }
     }
-    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
-      });
+
+    // Fall back to API token
+    if (this.apiService) {
+      try {
+        let response = await this.apiService.request(`/api/project/${projectSlug}`, {
+          method: 'GET',
+          headers: {
+            'X-Organization': organizationSlug
+          }
+        });
+        return response.project || response;
+      } catch (error) {
+        throw new VizzlyError(`Failed to fetch project: ${error.message}`, 'PROJECT_FETCH_FAILED', {
+          originalError: error
+        });
+      }
     }
+    throw new VizzlyError('No authentication available', 'NO_AUTH_SERVICE');
   }
 
   /**
    * Get recent builds for a project
+   * Uses OAuth authentication (authService) when available, falls back to API token
    * @param {string} projectSlug - Project slug
    * @param {string} organizationSlug - Organization slug
    * @param {Object} options - Query options
@@ -150,24 +211,44 @@ export class ProjectService extends BaseService {
    * @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 [];
+    let url = `/api/build/${projectSlug}${query ? `?${query}` : ''}`;
+
+    // Try OAuth-based request first (user login via device flow)
+    if (this.authService) {
+      try {
+        let response = await this.authService.authenticatedRequest(url, {
+          method: 'GET',
+          headers: {
+            'X-Organization': organizationSlug
+          }
+        });
+        return response.builds || [];
+      } catch {
+        // Fall back to API token
+      }
     }
+
+    // Fall back to API token-based request
+    if (this.apiService) {
+      try {
+        let response = await this.apiService.request(url, {
+          method: 'GET',
+          headers: {
+            'X-Organization': organizationSlug
+          }
+        });
+        return response.builds || [];
+      } catch {
+        return [];
+      }
+    }
+
+    // No authentication available
+    return [];
   }
 
   /**

package/dist/services/screenshot-server.js

@@ -4,32 +4,32 @@
  */
 
 import { createServer } from 'http';
-import { BaseService } from './base-service.js';
 import { VizzlyError } from '../errors/vizzly-error.js';
-export class ScreenshotServer extends BaseService {
-  constructor(config, logger, buildManager) {
-    super(config, logger);
+import * as output from '../utils/output.js';
+export class ScreenshotServer {
+  constructor(config, buildManager) {
+    this.config = config;
     this.buildManager = buildManager;
     this.server = null;
   }
-  async onStart() {
+  async start() {
     this.server = createServer(this.handleRequest.bind(this));
     return new Promise((resolve, reject) => {
       this.server.listen(this.config.server.port, '127.0.0.1', error => {
         if (error) {
           reject(new VizzlyError(`Failed to start screenshot server: ${error.message}`, 'SERVER_ERROR'));
         } else {
-          this.logger.info(`Screenshot server listening on http://127.0.0.1:${this.config.server.port}`);
+          output.info(`Screenshot server listening on http://127.0.0.1:${this.config.server.port}`);
           resolve();
         }
       });
     });
   }
-  async onStop() {
+  async stop() {
     if (this.server) {
       return new Promise(resolve => {
         this.server.close(() => {
-          this.logger.info('Screenshot server stopped');
+          output.info('Screenshot server stopped');
           resolve();
         });
       });
@@ -65,7 +65,7 @@ export class ScreenshotServer extends BaseService {
           success: true
         }));
       } catch (error) {
-        this.logger.error('Failed to process screenshot:', error);
+        output.error('Failed to process screenshot:', error);
         res.statusCode = 500;
         res.end(JSON.stringify({
           error: 'Internal server error'

package/dist/services/server-manager.js

@@ -3,15 +3,14 @@
  * Manages the HTTP server with functional handlers
  */
 
-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 {
+export class ServerManager {
   constructor(config, options = {}) {
-    super(config, options);
+    this.config = config;
     this.httpServer = null;
     this.handler = null;
     this.services = options.services || {};
@@ -20,9 +19,6 @@ export class ServerManager extends BaseService {
     this.buildId = buildId;
     this.tddMode = tddMode;
     this.setBaseline = setBaseline;
-    return super.start();
-  }
-  async onStart() {
     const port = this.config?.server?.port || 47392;
     if (this.tddMode) {
       this.handler = createTddHandler(this.config, process.cwd(), this.config?.baselineBuildId, this.config?.baselineComparisonId, this.setBaseline);
@@ -32,12 +28,14 @@ export class ServerManager extends BaseService {
       this.handler = createApiHandler(apiService);
     }
 
-    // Pass buildId in services so http-server can use it as default
-    const servicesWithBuildId = {
+    // Pass buildId and tddService in services so http-server can use them
+    const servicesWithExtras = {
       ...this.services,
-      buildId: this.buildId
+      buildId: this.buildId,
+      // Expose tddService for baseline download operations (TDD mode only)
+      tddService: this.tddMode ? this.handler.tddService : null
     };
-    this.httpServer = createHttpServer(port, this.handler, servicesWithBuildId);
+    this.httpServer = createHttpServer(port, this.handler, servicesWithExtras);
     if (this.httpServer) {
       await this.httpServer.start();
     }
@@ -62,10 +60,8 @@ export class ServerManager extends BaseService {
         serverInfo.buildId = this.buildId;
       }
       writeFileSync(serverFile, JSON.stringify(serverInfo, null, 2));
-      this.logger.debug(`Wrote server info to ${serverFile}`);
-    } catch (error) {
+    } catch {
       // Non-fatal - SDK can still use health check or environment variables
-      this.logger.debug(`Failed to write server.json: ${error.message}`);
     }
   }
   async createApiService() {
@@ -76,19 +72,16 @@ export class ServerManager extends BaseService {
     return new ApiService({
       ...this.config,
       command: 'run'
-    }, {
-      logger: this.logger
     });
   }
-  async onStop() {
+  async stop() {
     if (this.httpServer) {
       await this.httpServer.stop();
     }
     if (this.handler?.cleanup) {
       try {
         this.handler.cleanup();
-      } catch (error) {
-        this.logger.debug('Handler cleanup error:', error.message);
+      } catch {
         // Don't throw - cleanup errors shouldn't fail the stop process
       }
     }

package/dist/services/static-report-generator.js

@@ -7,8 +7,7 @@ import { writeFile, mkdir, copyFile } from 'fs/promises';
 import { existsSync } from 'fs';
 import { join, dirname } from 'path';
 import { fileURLToPath } from 'url';
-import { createServiceLogger } from '../utils/logger-factory.js';
-const logger = createServiceLogger('STATIC-REPORT');
+import * as output from '../utils/output.js';
 let __filename = fileURLToPath(import.meta.url);
 let __dirname = dirname(__filename);
 let PROJECT_ROOT = join(__dirname, '..', '..');
@@ -49,10 +48,10 @@ export class StaticReportGenerator {
       // Generate HTML with embedded data
       let htmlContent = this.generateHtmlTemplate(reportData);
       await writeFile(this.reportPath, htmlContent, 'utf8');
-      logger.debug(`Static report generated: ${this.reportPath}`);
+      output.debug('report', 'generated static report');
       return this.reportPath;
     } catch (error) {
-      logger.error(`Failed to generate static report: ${error.message}`);
+      output.error(`Failed to generate static report: ${error.message}`);
       throw new Error(`Report generation failed: ${error.message}`);
     }
   }