@vizzly-testing/cli 0.30.0 → 0.32.0

package/dist/server/handlers/tdd-handler.js

@@ -157,6 +157,16 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
   const tddService = new TddService(config, workingDir, setBaseline);
   const reportPath = join(workingDir, '.vizzly', 'report-data.json');
   const detailsPath = join(workingDir, '.vizzly', 'comparison-details.json');
+  let clearJsonFile = path => {
+    if (existsSync(path)) {
+      unlinkSync(path);
+    }
+  };
+  let prepareRunArtifacts = () => {
+    clearJsonFile(reportPath);
+    clearJsonFile(detailsPath);
+    tddService.clearRunData?.();
+  };
 
   /**
    * Read heavy comparison details from comparison-details.json
@@ -267,6 +277,7 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
   };
   const initialize = async () => {
     output.debug('tdd', 'initializing local mode');
+    prepareRunArtifacts();
 
     // In baseline update mode, skip all baseline loading/downloading
     if (setBaseline) {
@@ -631,68 +642,33 @@ export const createTddHandler = (config, workingDir, baselineBuild, baselineComp
       let deletedBaselines = 0;
       let deletedCurrents = 0;
       let deletedDiffs = 0;
-
-      // Delete all baseline, current, and diff images
-      for (const comparison of reportData.comparisons) {
-        // Delete baseline image if it exists
-        if (comparison.baseline) {
-          const baselinePath = join(workingDir, '.vizzly', comparison.baseline.replace('/images/', ''));
-          if (existsSync(baselinePath)) {
-            try {
-              const {
-                unlinkSync
-              } = await import('node:fs');
-              unlinkSync(baselinePath);
-              deletedBaselines++;
-              // Silent deletion
-            } catch (error) {
-              output.warn(`Failed to delete baseline for ${comparison.name}: ${error.message}`);
-            }
-          }
-        }
-
-        // Delete current screenshot if it exists
-        if (comparison.current) {
-          const currentPath = join(workingDir, '.vizzly', comparison.current.replace('/images/', ''));
-          if (existsSync(currentPath)) {
-            try {
-              const {
-                unlinkSync
-              } = await import('node:fs');
-              unlinkSync(currentPath);
-              deletedCurrents++;
-              // Silent deletion
-            } catch (error) {
-              output.warn(`Failed to delete current screenshot for ${comparison.name}: ${error.message}`);
-            }
+      let deleteResetFile = (imagePath, label, name) => {
+        if (!imagePath) return 0;
+        try {
+          let filePath = safePath(workingDir, '.vizzly', imagePath.replace('/images/', ''));
+          if (!existsSync(filePath)) return 0;
+          unlinkSync(filePath);
+          if (label === 'diff') {
+            output.debug(`Deleted diff for ${name}`);
           }
+          return 1;
+        } catch (error) {
+          output.warn(`Failed to delete ${label} for ${name}: ${error.message}`);
+          return 0;
         }
+      };
 
-        // Delete diff image if it exists
-        if (comparison.diff) {
-          const diffPath = join(workingDir, '.vizzly', comparison.diff.replace('/images/', ''));
-          if (existsSync(diffPath)) {
-            try {
-              const {
-                unlinkSync
-              } = await import('node:fs');
-              unlinkSync(diffPath);
-              deletedDiffs++;
-              output.debug(`Deleted diff for ${comparison.name}`);
-            } catch (error) {
-              output.warn(`Failed to delete diff for ${comparison.name}: ${error.message}`);
-            }
-          }
-        }
+      // Delete all baseline, current, and diff images
+      for (let comparison of reportData.comparisons) {
+        deletedBaselines += deleteResetFile(comparison.baseline, 'baseline', comparison.name);
+        deletedCurrents += deleteResetFile(comparison.current, 'current screenshot', comparison.name);
+        deletedDiffs += deleteResetFile(comparison.diff, 'diff', comparison.name);
       }
 
       // Delete baseline metadata
-      const metadataPath = join(workingDir, '.vizzly', 'baselines', 'metadata.json');
+      let metadataPath = join(workingDir, '.vizzly', 'baselines', 'metadata.json');
       if (existsSync(metadataPath)) {
         try {
-          const {
-            unlinkSync
-          } = await import('node:fs');
           unlinkSync(metadataPath);
           output.debug('Deleted baseline metadata');
         } catch (error) {

package/dist/server/routers/baseline.js

@@ -6,6 +6,169 @@
 import * as output from '../../utils/output.js';
 import { parseJsonBody } from '../middleware/json-parser.js';
 import { sendError, sendServiceUnavailable, sendSuccess } from '../middleware/response.js';
+function sendBaselineUnavailable(res) {
+  sendError(res, 400, 'Baseline management not available');
+}
+async function parseRequiredComparisonId(req, res) {
+  let {
+    id
+  } = await parseJsonBody(req);
+  if (!id) {
+    sendError(res, 400, 'Comparison ID required');
+    return null;
+  }
+  return id;
+}
+async function handleComparisonAction({
+  req,
+  res,
+  screenshotHandler,
+  actionName,
+  action,
+  successMessage
+}) {
+  if (!screenshotHandler?.[actionName]) {
+    sendBaselineUnavailable(res);
+    return true;
+  }
+  try {
+    let id = await parseRequiredComparisonId(req, res);
+    if (!id) {
+      return true;
+    }
+    await screenshotHandler[actionName](id);
+    sendSuccess(res, {
+      success: true,
+      message: successMessage(id)
+    });
+    return true;
+  } catch (error) {
+    if (error.code === 'NOT_FOUND') {
+      sendError(res, 404, error.message);
+    } else {
+      output.error(`Error ${action}:`, error);
+      sendError(res, 500, error.message);
+    }
+    return true;
+  }
+}
+async function handleAcceptAllBaselines(res, screenshotHandler) {
+  if (!screenshotHandler?.acceptAllBaselines) {
+    sendBaselineUnavailable(res);
+    return true;
+  }
+  try {
+    let result = await screenshotHandler.acceptAllBaselines();
+    sendSuccess(res, {
+      success: true,
+      message: `Accepted ${result.count} baselines`,
+      count: result.count
+    });
+    return true;
+  } catch (error) {
+    output.error('Error accepting all baselines:', error);
+    sendError(res, 500, error.message);
+    return true;
+  }
+}
+async function handleResetBaselines(res, screenshotHandler) {
+  if (!screenshotHandler?.resetBaselines) {
+    sendBaselineUnavailable(res);
+    return true;
+  }
+  try {
+    await screenshotHandler.resetBaselines();
+    sendSuccess(res, {
+      success: true,
+      message: 'Baselines reset to previous state'
+    });
+    return true;
+  } catch (error) {
+    output.error('Error resetting baselines:', error);
+    sendError(res, 500, error.message);
+    return true;
+  }
+}
+function shouldFallbackFromOAuth(error) {
+  return error.message?.includes('Not authenticated') || error.message?.includes('401');
+}
+async function downloadBaselinesWithOAuth({
+  authService,
+  tddService,
+  buildId,
+  organizationSlug,
+  projectSlug
+}) {
+  output.info(`Downloading baselines from build ${buildId}...`);
+  output.debug('baseline', `Using OAuth for ${organizationSlug}/${projectSlug}`);
+  let apiResponse = await authService.authenticatedRequest(`/api/cli/${projectSlug}/builds/${buildId}/tdd-baselines`, {
+    method: 'GET',
+    headers: {
+      'X-Organization': organizationSlug
+    }
+  });
+  if (!apiResponse) {
+    throw new Error(`Build ${buildId} not found or API returned null`);
+  }
+  return tddService.processDownloadedBaselines(apiResponse, buildId);
+}
+async function downloadBaselinesWithToken(tddService, buildId) {
+  output.info(`Downloading baselines from build ${buildId}...`);
+  return tddService.downloadBaselines('test', null, buildId, null);
+}
+async function handleBaselineDownload({
+  req,
+  res,
+  tddService,
+  authService
+}) {
+  if (!tddService) {
+    sendServiceUnavailable(res, 'TDD service not available (only available in TDD mode)');
+    return true;
+  }
+  try {
+    let body = await parseJsonBody(req);
+    let {
+      buildId,
+      organizationSlug,
+      projectSlug
+    } = body;
+    if (!buildId) {
+      sendError(res, 400, 'buildId is required');
+      return true;
+    }
+    let result;
+    if (authService && organizationSlug && projectSlug) {
+      try {
+        result = await downloadBaselinesWithOAuth({
+          authService,
+          tddService,
+          buildId,
+          organizationSlug,
+          projectSlug
+        });
+      } catch (oauthError) {
+        if (!shouldFallbackFromOAuth(oauthError)) {
+          throw oauthError;
+        }
+        output.debug('baseline', `OAuth failed, trying other auth methods: ${oauthError.message}`);
+      }
+    }
+    if (!result) {
+      result = await downloadBaselinesWithToken(tddService, buildId);
+    }
+    sendSuccess(res, {
+      success: true,
+      message: `Baselines downloaded from build ${buildId}`,
+      ...result
+    });
+    return true;
+  } catch (error) {
+    output.error('Error downloading baselines:', error);
+    sendError(res, 500, error.message);
+    return true;
+  }
+}
 
 /**
  * Create baseline router
@@ -23,204 +186,58 @@ export function createBaselineRouter({
   return async function handleBaselineRoute(req, res, pathname) {
     // Accept a single screenshot as baseline
     if (req.method === 'POST' && pathname === '/api/baseline/accept') {
-      if (!screenshotHandler?.acceptBaseline) {
-        sendError(res, 400, 'Baseline management not available');
-        return true;
-      }
-      try {
-        const {
-          id
-        } = await parseJsonBody(req);
-        if (!id) {
-          sendError(res, 400, 'Comparison ID required');
-          return true;
-        }
-        await screenshotHandler.acceptBaseline(id);
-        sendSuccess(res, {
-          success: true,
-          message: `Baseline accepted for comparison ${id}`
-        });
-        return true;
-      } catch (error) {
-        output.error('Error accepting baseline:', error);
-        sendError(res, 500, error.message);
-        return true;
-      }
+      return handleComparisonAction({
+        req,
+        res,
+        screenshotHandler,
+        actionName: 'acceptBaseline',
+        action: 'accepting baseline',
+        successMessage: id => `Baseline accepted for comparison ${id}`
+      });
     }
 
     // Accept all screenshots as baseline
     if (req.method === 'POST' && pathname === '/api/baseline/accept-all') {
-      if (!screenshotHandler?.acceptAllBaselines) {
-        sendError(res, 400, 'Baseline management not available');
-        return true;
-      }
-      try {
-        const result = await screenshotHandler.acceptAllBaselines();
-        sendSuccess(res, {
-          success: true,
-          message: `Accepted ${result.count} baselines`,
-          count: result.count
-        });
-        return true;
-      } catch (error) {
-        output.error('Error accepting all baselines:', error);
-        sendError(res, 500, error.message);
-        return true;
-      }
+      return handleAcceptAllBaselines(res, screenshotHandler);
     }
 
     // Reject a single comparison (keep current baseline, discard changes)
     if (req.method === 'POST' && pathname === '/api/baseline/reject') {
-      if (!screenshotHandler?.rejectBaseline) {
-        sendError(res, 400, 'Baseline management not available');
-        return true;
-      }
-      try {
-        const {
-          id
-        } = await parseJsonBody(req);
-        if (!id) {
-          sendError(res, 400, 'Comparison ID required');
-          return true;
-        }
-        await screenshotHandler.rejectBaseline(id);
-        sendSuccess(res, {
-          success: true,
-          message: `Changes rejected for comparison ${id}`
-        });
-        return true;
-      } catch (error) {
-        output.error('Error rejecting baseline:', error);
-        sendError(res, 500, error.message);
-        return true;
-      }
+      return handleComparisonAction({
+        req,
+        res,
+        screenshotHandler,
+        actionName: 'rejectBaseline',
+        action: 'rejecting baseline',
+        successMessage: id => `Changes rejected for comparison ${id}`
+      });
     }
 
     // Delete a comparison entirely (removes from report and deletes files)
     if (req.method === 'POST' && pathname === '/api/baseline/delete') {
-      if (!screenshotHandler?.deleteComparison) {
-        sendError(res, 400, 'Baseline management not available');
-        return true;
-      }
-      try {
-        const {
-          id
-        } = await parseJsonBody(req);
-        if (!id) {
-          sendError(res, 400, 'Comparison ID required');
-          return true;
-        }
-        await screenshotHandler.deleteComparison(id);
-        sendSuccess(res, {
-          success: true,
-          message: `Comparison ${id} deleted`
-        });
-        return true;
-      } catch (error) {
-        if (error.code === 'NOT_FOUND') {
-          sendError(res, 404, error.message);
-        } else {
-          output.error('Error deleting comparison:', error);
-          sendError(res, 500, error.message);
-        }
-        return true;
-      }
+      return handleComparisonAction({
+        req,
+        res,
+        screenshotHandler,
+        actionName: 'deleteComparison',
+        action: 'deleting comparison',
+        successMessage: id => `Comparison ${id} deleted`
+      });
     }
 
     // Reset baselines to previous state
     if (req.method === 'POST' && pathname === '/api/baseline/reset') {
-      if (!screenshotHandler?.resetBaselines) {
-        sendError(res, 400, 'Baseline management not available');
-        return true;
-      }
-      try {
-        await screenshotHandler.resetBaselines();
-        sendSuccess(res, {
-          success: true,
-          message: 'Baselines reset to previous state'
-        });
-        return true;
-      } catch (error) {
-        output.error('Error resetting baselines:', error);
-        sendError(res, 500, error.message);
-        return true;
-      }
+      return handleResetBaselines(res, screenshotHandler);
     }
 
     // Download baselines from a remote build
     if (req.method === 'POST' && pathname === '/api/baselines/download') {
-      if (!tddService) {
-        sendServiceUnavailable(res, 'TDD service not available (only available in TDD mode)');
-        return true;
-      }
-      try {
-        let body = await parseJsonBody(req);
-        let {
-          buildId,
-          organizationSlug,
-          projectSlug
-        } = body;
-        if (!buildId) {
-          sendError(res, 400, 'buildId is required');
-          return true;
-        }
-
-        // Try OAuth authentication first (allows access to any project user has membership to)
-        // This is the preferred method when user is logged in via the dashboard
-        if (authService && organizationSlug && projectSlug) {
-          try {
-            output.info(`Downloading baselines from build ${buildId}...`);
-            output.debug('baseline', `Using OAuth for ${organizationSlug}/${projectSlug}`);
-
-            // Use the CLI endpoint which accepts OAuth and checks project membership
-            let apiResponse = await authService.authenticatedRequest(`/api/cli/${projectSlug}/builds/${buildId}/tdd-baselines`, {
-              method: 'GET',
-              headers: {
-                'X-Organization': organizationSlug
-              }
-            });
-            if (!apiResponse) {
-              throw new Error(`Build ${buildId} not found or API returned null`);
-            }
-
-            // Process the baselines through tddService
-            let result = await tddService.processDownloadedBaselines(apiResponse, buildId);
-            sendSuccess(res, {
-              success: true,
-              message: `Baselines downloaded from build ${buildId}`,
-              ...result
-            });
-            return true;
-          } catch (oauthError) {
-            // If OAuth fails with auth error, fall through to other methods
-            if (!oauthError.message?.includes('Not authenticated') && !oauthError.message?.includes('401')) {
-              throw oauthError;
-            }
-            output.debug('baseline', `OAuth failed, trying other auth methods: ${oauthError.message}`);
-          }
-        }
-
-        // Fall back to using tddService directly (requires VIZZLY_TOKEN env var)
-        output.info(`Downloading baselines from build ${buildId}...`);
-        let result = await tddService.downloadBaselines('test',
-        // environment
-        null,
-        // branch (not needed when buildId is specified)
-        buildId,
-        // specific build to download from
-        null // comparisonId (not needed)
-        );
-        sendSuccess(res, {
-          success: true,
-          message: `Baselines downloaded from build ${buildId}`,
-          ...result
-        });
-        return true;
-      } catch (error) {
-        output.error('Error downloading baselines:', error);
-        sendError(res, 500, error.message);
-        return true;
-      }
+      return handleBaselineDownload({
+        req,
+        res,
+        tddService,
+        authService
+      });
     }
     return false;
   };