@vizzly-testing/cli 0.20.0 → 0.20.1-beta.1

package/dist/services/screenshot-server.js

@@ -1,99 +1,65 @@
 /**
  * Screenshot Server Service
  * Listens for and processes screenshots from the test runner
+ *
+ * This class is a thin wrapper around the functional operations in
+ * src/screenshot-server/. It maintains backwards compatibility while
+ * delegating to pure functions for testability.
  */
 
 import { createServer } from 'node:http';
 import { VizzlyError } from '../errors/vizzly-error.js';
+import { handleRequest, parseRequestBody, startServer, stopServer } from '../screenshot-server/index.js';
 import * as output from '../utils/output.js';
 export class ScreenshotServer {
-  constructor(config, buildManager) {
+  constructor(config, buildManager, options = {}) {
     this.config = config;
     this.buildManager = buildManager;
     this.server = null;
+
+    // Dependency injection for testing
+    this.deps = options.deps || {
+      createHttpServer: createServer,
+      output,
+      createError: (message, code) => new VizzlyError(message, code)
+    };
   }
   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 {
-          output.info(`Screenshot server listening on http://127.0.0.1:${this.config.server.port}`);
-          resolve();
-        }
-      });
+    this.server = await startServer({
+      config: this.config,
+      requestHandler: this.handleRequest.bind(this),
+      deps: {
+        createHttpServer: this.deps.createHttpServer,
+        createError: this.deps.createError,
+        output: this.deps.output
+      }
     });
   }
   async stop() {
-    if (this.server) {
-      return new Promise(resolve => {
-        this.server.close(() => {
-          output.info('Screenshot server stopped');
-          resolve();
-        });
-      });
-    }
+    await stopServer({
+      server: this.server,
+      deps: {
+        output: this.deps.output
+      }
+    });
   }
   async handleRequest(req, res) {
-    if (req.method === 'POST' && req.url === '/screenshot') {
-      try {
-        const body = await this.parseRequestBody(req);
-        const {
-          buildId,
-          name,
-          image,
-          properties
-        } = body;
-        if (!name || !image) {
-          res.statusCode = 400;
-          res.end(JSON.stringify({
-            error: 'name and image are required'
-          }));
-          return;
-        }
-
-        // Use default buildId if none provided
-        const effectiveBuildId = buildId || 'default';
-        await this.buildManager.addScreenshot(effectiveBuildId, {
-          name,
-          image,
-          properties
-        });
-        res.statusCode = 200;
-        res.end(JSON.stringify({
-          success: true
-        }));
-      } catch (error) {
-        output.error('Failed to process screenshot:', error);
-        res.statusCode = 500;
-        res.end(JSON.stringify({
-          error: 'Internal server error'
-        }));
+    await handleRequest({
+      req,
+      res,
+      deps: {
+        buildManager: this.buildManager,
+        createError: this.deps.createError,
+        output: this.deps.output
       }
-    } else {
-      res.statusCode = 404;
-      res.end(JSON.stringify({
-        error: 'Not found'
-      }));
-    }
+    });
   }
   async parseRequestBody(req) {
-    return new Promise((resolve, reject) => {
-      let body = '';
-      req.on('data', chunk => {
-        body += chunk.toString();
-      });
-      req.on('end', () => {
-        try {
-          resolve(JSON.parse(body));
-        } catch {
-          reject(new VizzlyError('Invalid JSON in request body', 'INVALID_JSON'));
-        }
-      });
-      req.on('error', error => {
-        reject(new VizzlyError(`Request error: ${error.message}`, 'REQUEST_ERROR'));
-      });
+    return parseRequestBody({
+      req,
+      deps: {
+        createError: this.deps.createError
+      }
     });
   }
 }

package/dist/services/server-manager.js

@@ -1,108 +1,71 @@
 /**
  * Server Manager Service
  * Manages the HTTP server with functional handlers
+ *
+ * This class is a thin wrapper around the functional operations in
+ * src/server-manager/. It maintains backwards compatibility while
+ * delegating to pure functions for testability.
  */
 
 import { existsSync, mkdirSync, unlinkSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { createApiClient } from '../api/index.js';
 import { createApiHandler } from '../server/handlers/api-handler.js';
 import { createTddHandler } from '../server/handlers/tdd-handler.js';
 import { createHttpServer } from '../server/http-server.js';
+import { buildServerInterface, getTddResults, startServer, stopServer } from '../server-manager/index.js';
 export class ServerManager {
   constructor(config, options = {}) {
     this.config = config;
     this.httpServer = null;
     this.handler = null;
     this.services = options.services || {};
+    this.tddMode = false;
+
+    // Dependency injection for testing - defaults to real implementations
+    this.deps = options.deps || {
+      createHttpServer,
+      createTddHandler,
+      createApiHandler,
+      createApiClient,
+      fs: {
+        mkdirSync,
+        writeFileSync,
+        existsSync,
+        unlinkSync
+      }
+    };
   }
   async start(buildId = null, tddMode = false, setBaseline = false) {
     this.buildId = buildId;
     this.tddMode = tddMode;
     this.setBaseline = setBaseline;
-    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);
-      await this.handler.initialize();
-    } else {
-      const apiService = await this.createApiService();
-      this.handler = createApiHandler(apiService);
-    }
-
-    // Pass buildId and tddService in services so http-server can use them
-    const servicesWithExtras = {
-      ...this.services,
-      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, servicesWithExtras);
-    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));
-    } catch {
-      // Non-fatal - SDK can still use health check or environment variables
-    }
-  }
-  async createApiService() {
-    if (!this.config.apiKey) return null;
-    const {
-      ApiService
-    } = await import('./api-service.js');
-    return new ApiService({
-      ...this.config,
-      command: 'run'
+    let result = await startServer({
+      config: this.config,
+      buildId,
+      tddMode,
+      setBaseline,
+      projectRoot: process.cwd(),
+      services: this.services,
+      deps: this.deps
     });
+    this.httpServer = result.httpServer;
+    this.handler = result.handler;
   }
   async stop() {
-    if (this.httpServer) {
-      await this.httpServer.stop();
-    }
-    if (this.handler?.cleanup) {
-      try {
-        this.handler.cleanup();
-      } catch {
-        // Don't throw - cleanup errors shouldn't fail the stop process
-      }
-    }
-
-    // Clean up server.json so the client SDK doesn't try to connect to a dead server
-    try {
-      const serverFile = join(process.cwd(), '.vizzly', 'server.json');
-      if (existsSync(serverFile)) {
-        unlinkSync(serverFile);
-      }
-    } catch {
-      // Non-fatal - cleanup errors shouldn't fail the stop process
-    }
+    await stopServer({
+      httpServer: this.httpServer,
+      handler: this.handler,
+      projectRoot: process.cwd(),
+      deps: this.deps
+    });
   }
 
   // Expose server interface for compatibility
   get server() {
-    return {
-      getScreenshotCount: buildId => this.handler?.getScreenshotCount?.(buildId) || 0,
-      finishBuild: buildId => this.httpServer?.finishBuild?.(buildId)
-    };
+    return buildServerInterface({
+      handler: this.handler,
+      httpServer: this.httpServer
+    });
   }
 
   /**
@@ -110,7 +73,9 @@ export class ServerManager {
    * Only available in TDD mode after tests have run
    */
   async getTddResults() {
-    if (!this.tddMode || !this.handler?.getResults) return null;
-    return await this.handler.getResults();
+    return getTddResults({
+      tddMode: this.tddMode,
+      handler: this.handler
+    });
   }
 }