@vizzly-testing/cli 0.39.1 → 0.39.2

package/dist/server/routers/assets.js

@@ -1,95 +0,0 @@
-/**
- * Assets Router
- * Serves static assets (bundle files, images)
- */
-
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import * as output from '../../utils/output.js';
-import { sendError, sendFile, sendNotFound } from '../middleware/response.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const PROJECT_ROOT = join(__dirname, '..', '..', '..');
-
-/**
- * Create assets router
- * @param {Object} context - Router context
- * @returns {Function} Route handler
- */
-export function createAssetsRouter() {
-  return async function handleAssetsRoute(req, res, pathname) {
-    if (req.method !== 'GET') {
-      return false;
-    }
-
-    // Serve React bundle JS
-    if (pathname === '/reporter-bundle.js') {
-      const bundlePath = join(PROJECT_ROOT, 'dist', 'reporter', 'reporter-bundle.iife.js');
-      if (existsSync(bundlePath)) {
-        try {
-          const bundle = readFileSync(bundlePath, 'utf8');
-          sendFile(res, bundle, 'application/javascript');
-          return true;
-        } catch (error) {
-          output.debug('Error serving reporter bundle:', {
-            error: error.message
-          });
-          sendError(res, 500, 'Error loading reporter bundle');
-          return true;
-        }
-      } else {
-        sendNotFound(res, 'Reporter bundle not found');
-        return true;
-      }
-    }
-
-    // Serve React bundle CSS
-    if (pathname === '/reporter-bundle.css') {
-      const cssPath = join(PROJECT_ROOT, 'dist', 'reporter', 'reporter-bundle.css');
-      if (existsSync(cssPath)) {
-        try {
-          const css = readFileSync(cssPath, 'utf8');
-          sendFile(res, css, 'text/css');
-          return true;
-        } catch (error) {
-          output.debug('Error serving reporter CSS:', {
-            error: error.message
-          });
-          sendError(res, 500, 'Error loading reporter CSS');
-          return true;
-        }
-      } else {
-        sendNotFound(res, 'Reporter CSS not found');
-        return true;
-      }
-    }
-
-    // Serve images from .vizzly directory
-    if (pathname.startsWith('/images/')) {
-      const imagePath = pathname.replace('/images/', '');
-      const fullImagePath = join(process.cwd(), '.vizzly', imagePath);
-      if (existsSync(fullImagePath)) {
-        try {
-          const imageData = readFileSync(fullImagePath);
-          // Images are rewritten in place between TDD runs, so disable browser caching.
-          res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate');
-          res.setHeader('Pragma', 'no-cache');
-          res.setHeader('Expires', '0');
-          sendFile(res, imageData, 'image/png');
-          return true;
-        } catch (error) {
-          output.debug('Error serving image:', {
-            error: error.message
-          });
-          sendError(res, 500, 'Error loading image');
-          return true;
-        }
-      } else {
-        sendNotFound(res, 'Image not found');
-        return true;
-      }
-    }
-    return false;
-  };
-}

package/dist/server/routers/cloud-proxy.js

@@ -1,146 +0,0 @@
-/**
- * Cloud Proxy Router
- * Proxies requests to Vizzly cloud API with OAuth authentication
- *
- * This router transparently handles OAuth token management:
- * - Reads tokens from ~/.vizzly/config.json via authService
- * - Adds Authorization header to outgoing requests
- * - Handles token refresh on 401 responses
- * - Returns proxied response to React app
- */
-
-import * as output from '../../utils/output.js';
-import { parseJsonBody } from '../middleware/json-parser.js';
-import { sendError, sendServiceUnavailable, sendSuccess } from '../middleware/response.js';
-
-/**
- * Create cloud proxy router
- * @param {Object} context - Router context
- * @param {Object} context.authService - Auth service for token management
- * @param {string} context.apiUrl - Base API URL (default: https://app.vizzly.dev)
- * @returns {Function} Route handler
- */
-export function createCloudProxyRouter({
-  authService,
-  apiUrl: _apiUrl = 'https://app.vizzly.dev'
-}) {
-  /**
-   * Make an authenticated request to the cloud API
-   * @param {string} endpoint - API endpoint (e.g., /api/cli/projects)
-   * @param {Object} options - Fetch options
-   * @returns {Promise<Object>} Response data
-   */
-  async function proxyRequest(endpoint, options = {}) {
-    if (!authService) {
-      throw new Error('Auth service not available');
-    }
-
-    // Use authService.authenticatedRequest which handles token refresh
-    return authService.authenticatedRequest(endpoint, options);
-  }
-  return async function handleCloudProxyRoute(req, res, pathname, parsedUrl) {
-    // Only handle /api/cloud/* routes
-    if (!pathname.startsWith('/api/cloud')) {
-      return false;
-    }
-
-    // Check auth service availability
-    if (!authService) {
-      sendServiceUnavailable(res, 'Auth service');
-      return true;
-    }
-
-    // Route: GET /api/cloud/projects - List user's projects
-    if (req.method === 'GET' && pathname === '/api/cloud/projects') {
-      try {
-        const response = await proxyRequest('/api/cli/projects', {
-          method: 'GET'
-        });
-        sendSuccess(res, {
-          projects: response.projects || []
-        });
-        return true;
-      } catch (error) {
-        output.error('Error fetching projects from cloud:', error);
-        // Return empty array instead of error for better UX when not logged in
-        if (error.message?.includes('not authenticated') || error.code === 'AUTH_ERROR') {
-          sendSuccess(res, {
-            projects: [],
-            authenticated: false
-          });
-        } else {
-          sendError(res, 500, error.message);
-        }
-        return true;
-      }
-    }
-
-    // Route: GET /api/cloud/organizations/:org/projects/:project/builds
-    const buildsMatch = pathname.match(/^\/api\/cloud\/organizations\/([^/]+)\/projects\/([^/]+)\/builds$/);
-    if (req.method === 'GET' && buildsMatch) {
-      try {
-        const organizationSlug = decodeURIComponent(buildsMatch[1]);
-        const projectSlug = decodeURIComponent(buildsMatch[2]);
-        const limit = parsedUrl.searchParams.get('limit') || '20';
-        const branch = parsedUrl.searchParams.get('branch');
-        const queryParams = new URLSearchParams();
-        if (limit) queryParams.append('limit', limit);
-        if (branch) queryParams.append('branch', branch);
-        const query = queryParams.toString();
-        const endpoint = `/api/cli/organizations/${organizationSlug}/projects/${projectSlug}/builds${query ? `?${query}` : ''}`;
-        const response = await proxyRequest(endpoint, {
-          method: 'GET'
-        });
-        sendSuccess(res, {
-          builds: response.builds || []
-        });
-        return true;
-      } catch (error) {
-        output.error('Error fetching builds from cloud:', error);
-        sendError(res, 500, error.message);
-        return true;
-      }
-    }
-
-    // Route: POST /api/cloud/baselines/download - Download baselines from build
-    if (req.method === 'POST' && pathname === '/api/cloud/baselines/download') {
-      try {
-        const body = await parseJsonBody(req);
-        const {
-          buildId,
-          screenshotNames
-        } = body;
-        if (!buildId) {
-          sendError(res, 400, 'buildId is required');
-          return true;
-        }
-
-        // Download baselines from the specified build
-        const response = await proxyRequest('/api/cli/baselines/download', {
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json'
-          },
-          body: JSON.stringify({
-            buildId,
-            screenshotNames
-          })
-        });
-        sendSuccess(res, {
-          success: true,
-          message: `Baselines downloaded from build ${buildId}`,
-          ...response
-        });
-        return true;
-      } catch (error) {
-        output.error('Error downloading baselines from cloud:', error);
-        sendError(res, 500, error.message);
-        return true;
-      }
-    }
-
-    // Unknown cloud route
-    sendError(res, 404, 'Cloud API endpoint not found');
-    return true;
-  };
-}

package/dist/server/routers/dashboard.js

@@ -1,172 +0,0 @@
-/**
- * Dashboard Router
- * Serves the React SPA for all dashboard routes
- */
-
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import * as output from '../../utils/output.js';
-import { sendError, sendHtml, sendSuccess } from '../middleware/response.js';
-
-// SPA routes that should serve the dashboard HTML
-const SPA_ROUTES = ['/', '/stats', '/settings', '/projects', '/builds'];
-let COMPARISON_DETAIL_FIELDS = new Set(['boundingBox', 'diffClusters', 'intensityStats']);
-function presentComparisonDetails(details = {}) {
-  return Object.fromEntries(Object.entries(details).filter(([field]) => COMPARISON_DETAIL_FIELDS.has(field)));
-}
-
-/**
- * Create dashboard router
- * @param {Object} context - Router context
- * @param {string} context.workingDir - Working directory for report data
- * @returns {Function} Route handler
- */
-export function createDashboardRouter(context) {
-  const {
-    workingDir = process.cwd()
-  } = context || {};
-
-  /**
-   * Read baseline metadata from baselines/metadata.json
-   */
-  const readBaselineMetadata = () => {
-    const metadataPath = join(workingDir, '.vizzly', 'baselines', 'metadata.json');
-    if (!existsSync(metadataPath)) {
-      return null;
-    }
-    try {
-      return JSON.parse(readFileSync(metadataPath, 'utf8'));
-    } catch {
-      return null;
-    }
-  };
-  return async function handleDashboardRoute(req, res, pathname) {
-    if (req.method !== 'GET') {
-      return false;
-    }
-
-    // API endpoint for fetching report data
-    if (pathname === '/api/report-data') {
-      const reportDataPath = join(workingDir, '.vizzly', 'report-data.json');
-      if (existsSync(reportDataPath)) {
-        try {
-          const data = JSON.parse(readFileSync(reportDataPath, 'utf8'));
-          // Include baseline metadata for stats view
-          data.baseline = readBaselineMetadata();
-          res.setHeader('Content-Type', 'application/json');
-          res.statusCode = 200;
-          res.end(JSON.stringify(data));
-          return true;
-        } catch (error) {
-          output.debug('Error reading report data:', {
-            error: error.message
-          });
-          res.statusCode = 500;
-          res.end(JSON.stringify({
-            error: 'Failed to read report data'
-          }));
-          return true;
-        }
-      } else {
-        sendSuccess(res, null);
-        return true;
-      }
-    }
-
-    // API endpoint for fetching full comparison details (lightweight + heavy fields)
-    let comparisonMatch = pathname.match(/^\/api\/comparison\/(.+)$/);
-    if (comparisonMatch) {
-      let comparisonId = decodeURIComponent(comparisonMatch[1]);
-      if (!comparisonId) {
-        sendError(res, 400, 'Comparison ID is required');
-        return true;
-      }
-      let reportDataPath = join(workingDir, '.vizzly', 'report-data.json');
-      if (!existsSync(reportDataPath)) {
-        sendError(res, 404, 'No report data found');
-        return true;
-      }
-      try {
-        let reportData = JSON.parse(readFileSync(reportDataPath, 'utf8'));
-        let comparison = (reportData.comparisons || []).find(c => c.id === comparisonId || c.signature === comparisonId || c.name === comparisonId);
-        if (!comparison) {
-          sendError(res, 404, 'Comparison not found');
-          return true;
-        }
-
-        // Merge with heavy fields from comparison-details.json
-        let detailsPath = join(workingDir, '.vizzly', 'comparison-details.json');
-        if (existsSync(detailsPath)) {
-          try {
-            let details = JSON.parse(readFileSync(detailsPath, 'utf8'));
-            let heavy = details[comparison.id];
-            if (heavy) {
-              comparison = {
-                ...comparison,
-                ...presentComparisonDetails(heavy)
-              };
-            }
-          } catch (error) {
-            output.debug('Failed to read comparison details:', {
-              error: error.message
-            });
-          }
-        }
-        sendSuccess(res, comparison);
-      } catch (error) {
-        output.debug('Error reading comparison data:', {
-          error: error.message
-        });
-        sendError(res, 500, 'Failed to read comparison data');
-      }
-      return true;
-    }
-
-    // Serve React SPA for dashboard routes
-    if (SPA_ROUTES.includes(pathname) || pathname.startsWith('/comparison/')) {
-      const reportDataPath = join(workingDir, '.vizzly', 'report-data.json');
-      let reportData = null;
-      if (existsSync(reportDataPath)) {
-        try {
-          const data = readFileSync(reportDataPath, 'utf8');
-          reportData = JSON.parse(data);
-          // Include baseline metadata for stats view
-          reportData.baseline = readBaselineMetadata();
-        } catch (error) {
-          output.debug('Could not read report data:', {
-            error: error.message
-          });
-        }
-      }
-      const dashboardHtml = `
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Vizzly Dev Dashboard</title>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1">
-    <link rel="stylesheet" href="/reporter-bundle.css">
-</head>
-<body>
-    <div id="vizzly-reporter-root">
-        <div class="reporter-loading">
-            <div>
-                <div class="spinner"></div>
-                <p>Loading Vizzly Dev Dashboard...</p>
-            </div>
-        </div>
-    </div>
-
-    <script>
-        // Inject report data if available
-        ${reportData ? `window.VIZZLY_REPORTER_DATA = ${JSON.stringify(reportData)};` : ''}
-    </script>
-    <script src="/reporter-bundle.js"></script>
-</body>
-</html>`;
-      sendHtml(res, 200, dashboardHtml);
-      return true;
-    }
-    return false;
-  };
-}

package/dist/services/auth-service.js

@@ -1,117 +0,0 @@
-/**
- * Auth Service
- * Wraps auth operations for use by the HTTP server
- *
- * Provides the interface expected by src/server/routers/auth.js:
- * - isAuthenticated() - Returns boolean, false if no tokens or API call fails
- * - whoami() - Throws if not authenticated or tokens invalid
- * - initiateDeviceFlow() - Throws on API error
- * - pollDeviceAuthorization(deviceCode) - Returns pending status or tokens, throws on error
- * - completeDeviceFlow(tokens) - Saves tokens to global config
- * - logout() - Clears local tokens, may warn if server revocation fails
- * - authenticatedRequest(endpoint, options) - Throws 'Not authenticated' if no tokens
- *
- * Error handling:
- * - isAuthenticated() never throws, returns false on any error
- * - whoami() throws if tokens are missing/invalid (caller should check isAuthenticated first)
- * - authenticatedRequest() throws 'Not authenticated' if no access token
- * - Device flow methods throw on API errors (network, server errors)
- */
-
-import { createAuthClient } from '../auth/client.js';
-import * as authOps from '../auth/operations.js';
-import { getApiUrl } from '../utils/environment-config.js';
-import { clearAuthTokens, getAuthTokens, saveAuthTokens } from '../utils/global-config.js';
-
-/**
- * Create an auth service instance
- * @param {Object} [options]
- * @param {string} [options.apiUrl] - API base URL (defaults to VIZZLY_API_URL or https://app.vizzly.dev)
- * @param {Object} [options.httpClient] - Injectable HTTP client (for testing)
- * @param {Object} [options.tokenStore] - Injectable token store (for testing)
- * @returns {Object} Auth service
- */
-export function createAuthService(options = {}) {
-  let apiUrl = options.apiUrl || getApiUrl();
-
-  // Create HTTP client for API requests (uses auth client for proper auth handling)
-  // Allow injection for testing
-  let httpClient = options.httpClient || createAuthClient({
-    baseUrl: apiUrl
-  });
-
-  // Create token store adapter for global config
-  // Allow injection for testing
-  let tokenStore = options.tokenStore || {
-    getTokens: getAuthTokens,
-    saveTokens: saveAuthTokens,
-    clearTokens: clearAuthTokens
-  };
-  return {
-    /**
-     * Check if user is authenticated
-     * @returns {Promise<boolean>}
-     */
-    async isAuthenticated() {
-      return authOps.isAuthenticated(httpClient, tokenStore);
-    },
-    /**
-     * Get current user information
-     * @returns {Promise<Object>} User and organization data
-     */
-    async whoami() {
-      return authOps.whoami(httpClient, tokenStore);
-    },
-    /**
-     * Initiate OAuth device flow
-     * @returns {Promise<Object>} Device code info
-     */
-    async initiateDeviceFlow() {
-      return authOps.initiateDeviceFlow(httpClient);
-    },
-    /**
-     * Poll for device authorization
-     * @param {string} deviceCode
-     * @returns {Promise<Object>} Token data or pending status
-     */
-    async pollDeviceAuthorization(deviceCode) {
-      return authOps.pollDeviceAuthorization(httpClient, deviceCode);
-    },
-    /**
-     * Complete device flow and save tokens
-     * @param {Object} tokens - Token data
-     * @returns {Promise<Object>}
-     */
-    async completeDeviceFlow(tokens) {
-      return authOps.completeDeviceFlow(tokenStore, tokens);
-    },
-    /**
-     * Logout and revoke tokens
-     * @returns {Promise<void>}
-     */
-    async logout() {
-      return authOps.logout(httpClient, tokenStore);
-    },
-    /**
-     * Refresh access token
-     * @returns {Promise<Object>} New tokens
-     */
-    async refresh() {
-      return authOps.refresh(httpClient, tokenStore);
-    },
-    /**
-     * Make an authenticated request to the API
-     * Used by cloud-proxy router for proxying requests
-     * @param {string} endpoint - API endpoint
-     * @param {Object} options - Fetch options
-     * @returns {Promise<Object>} Response data
-     */
-    async authenticatedRequest(endpoint, options = {}) {
-      let auth = await tokenStore.getTokens();
-      if (!auth?.accessToken) {
-        throw new Error('Not authenticated');
-      }
-      return httpClient.authenticatedRequest(endpoint, auth.accessToken, options);
-    }
-  };
-}