@vizzly-testing/cli 0.39.0 → 0.39.2

package/dist/domains/context/context.validations.js

@@ -0,0 +1,100 @@
+function buildSourceErrorMessage() {
+  return '--source must be one of: auto, cloud, local';
+}
+function buildIncludeErrorMessage() {
+  return '--include must contain only: diffs';
+}
+function validateLimitRange(value, flagName, {
+  min = 1,
+  max
+}) {
+  if (value == null) {
+    return [];
+  }
+  if (!Number.isInteger(value) || value < min || value > max) {
+    return [`${flagName} must be an integer between ${min} and ${max}`];
+  }
+  return [];
+}
+function validateCursor(value) {
+  if (value == null) {
+    return [];
+  }
+  if (typeof value !== 'string' || value.trim().length === 0) {
+    return ['--cursor must be a non-empty opaque cursor'];
+  }
+  return [];
+}
+function validateOffset(value) {
+  if (value == null) return [];
+  if (!Number.isInteger(value) || value < 0) {
+    return ['--offset must be a non-negative integer'];
+  }
+  return [];
+}
+function validateSourceOption(value) {
+  if (value == null) {
+    return [];
+  }
+  if (!['auto', 'cloud', 'local'].includes(value)) {
+    return [buildSourceErrorMessage()];
+  }
+  return [];
+}
+export function parseIncludeOption(value) {
+  if (!value) {
+    return [];
+  }
+  let rawItems = Array.isArray(value) ? value : String(value).split(',');
+  return rawItems.map(item => item.trim()).filter(Boolean);
+}
+function validateIncludeOption(value) {
+  let allowed = new Set(['diffs']);
+  let invalid = parseIncludeOption(value).filter(item => !allowed.has(item));
+  return invalid.length > 0 ? [buildIncludeErrorMessage()] : [];
+}
+function validateScopedProjectOptions(options = {}) {
+  let errors = [];
+  if (options.org && !options.project) {
+    errors.push('--org requires --project');
+  }
+  return errors;
+}
+export function validateContextBuildOptions(_options = {}) {
+  let errors = validateSourceOption(_options.source);
+  errors.push(...validateIncludeOption(_options.include));
+  errors.push(...validateCursor(_options.cursor));
+  return errors;
+}
+export function validateContextComparisonOptions(options = {}) {
+  let errors = [];
+  errors.push(...validateSourceOption(options.source));
+  errors.push(...validateIncludeOption(options.include));
+  errors.push(...validateCursor(options.cursor));
+  return errors;
+}
+export function validateContextScreenshotOptions(options = {}) {
+  let errors = validateScopedProjectOptions(options);
+  errors.push(...validateSourceOption(options.source));
+  errors.push(...validateLimitRange(options.recentLimit, '--recent-limit', {
+    max: 50
+  }));
+  return errors;
+}
+export function validateContextSimilarOptions(options = {}) {
+  let errors = validateScopedProjectOptions(options);
+  errors.push(...validateSourceOption(options.source));
+  errors.push(...validateLimitRange(options.limit, '--limit', {
+    max: 50
+  }));
+  return errors;
+}
+export function validateContextReviewQueueOptions(options = {}) {
+  let errors = validateScopedProjectOptions(options);
+  errors.push(...validateSourceOption(options.source));
+  errors.push(...validateLimitRange(options.limit, '--limit', {
+    max: 100
+  }));
+  errors.push(...validateOffset(options.offset));
+  return errors;
+}

package/dist/{context → domains/context}/local-workspace-provider.js

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { existsSync as defaultExistsSync, readFileSync } from 'node:fs';
 import { basename, isAbsolute, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { normalizeReportData } from '../utils/report-data.js';
+import { normalizeReportData } from '../reports/report.normalizers.js';
 let LOCAL_CONTEXT_SOURCE = 'local_workspace';
 let DEFAULT_LOCAL_REVIEW_QUEUE_LIMIT = 50;
 function readJsonIfExists(path) {

package/dist/{commands/doctor.js → domains/diagnostics/doctor.commands.js}

@@ -1,9 +1,10 @@
 import { URL } from 'node:url';
-import { createApiClient as defaultCreateApiClient, getBuilds as defaultGetBuilds } from '../api/index.js';
-import { loadConfig as defaultLoadConfig } from '../utils/config-loader.js';
-import { getContext as defaultGetContext } from '../utils/context.js';
-import { getApiToken as defaultGetApiToken } from '../utils/environment-config.js';
-import * as defaultOutput from '../utils/output.js';
+import * as defaultOutput from '../../shared/output.js';
+import { createApiClient as defaultCreateApiClient } from '../auth/cloud-client.js';
+import { getBuilds as defaultGetBuilds } from '../builds/build.service.js';
+import { loadConfig as defaultLoadConfig } from '../config/config-loader.js';
+import { getApiToken as defaultGetApiToken } from '../config/environment.js';
+import { getContext as defaultGetContext } from './environment-context.js';
 export let MIN_NODE_MAJOR = 22;
 export function createDoctorDiagnostics() {
   return {

package/dist/{server/routers/health.js → domains/diagnostics/health.routes.js}

@@ -3,43 +3,34 @@
  * Health check endpoint with diagnostics
  */
 
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { sendSuccess } from '../middleware/response.js';
+import { sendSuccess } from '../../adapters/http/middleware/response.js';
+import { createReportStore } from '../reports/report-store.js';
 
 /**
  * Create health router
  * @param {Object} context - Router context
  * @param {number} context.port - Server port
  * @param {Object} context.screenshotHandler - Screenshot handler
+ * @param {string} [context.workingDir] - Workspace containing report artifacts
  * @returns {Function} Route handler
  */
 export function createHealthRouter({
   port,
-  screenshotHandler
+  screenshotHandler,
+  workingDir = process.cwd()
 }) {
+  let reports = createReportStore(workingDir);
   return async function handleHealthRoute(req, res, pathname) {
     if (req.method !== 'GET' || pathname !== '/health') {
       return false;
     }
-    const reportDataPath = join(process.cwd(), '.vizzly', 'report-data.json');
-    const baselineMetadataPath = join(process.cwd(), '.vizzly', 'baselines', 'metadata.json');
     let reportData = null;
-    let baselineInfo = null;
-    if (existsSync(reportDataPath)) {
-      try {
-        reportData = JSON.parse(readFileSync(reportDataPath, 'utf8'));
-      } catch {
-        // Ignore read errors
-      }
-    }
-    if (existsSync(baselineMetadataPath)) {
-      try {
-        baselineInfo = JSON.parse(readFileSync(baselineMetadataPath, 'utf8'));
-      } catch {
-        // Ignore read errors
-      }
+    try {
+      reportData = reports.readReport();
+    } catch {
+      // Health remains available when report artifacts cannot be read.
     }
+    let baselineInfo = reports.readBaselineMetadata();
     sendSuccess(res, {
       status: 'ok',
       port,

package/dist/{commands/preview.js → domains/previews/preview.commands.js}

@@ -12,13 +12,15 @@ import { readdir, readFile, realpath, stat, unlink } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { promisify } from 'node:util';
-import { createApiClient as defaultCreateApiClient, getBuild as defaultGetBuild, uploadPreviewZip as defaultUploadPreviewZip } from '../api/index.js';
-import { openBrowser as defaultOpenBrowser } from '../utils/browser.js';
-import { loadConfig as defaultLoadConfig } from '../utils/config-loader.js';
-import { detectBranch as defaultDetectBranch } from '../utils/git.js';
-import * as defaultOutput from '../utils/output.js';
-import { createWildcardMatcher } from '../utils/patterns.js';
-import { formatSessionAge as defaultFormatSessionAge, readSession as defaultReadSession } from '../utils/session.js';
+import { openBrowser as defaultOpenBrowser } from '../../shared/browser.js';
+import { detectBranch as defaultDetectBranch } from '../../shared/git.js';
+import * as defaultOutput from '../../shared/output.js';
+import { createWildcardMatcher } from '../../shared/patterns.js';
+import { createApiClient as defaultCreateApiClient } from '../auth/cloud-client.js';
+import { getBuild as defaultGetBuild } from '../builds/build.service.js';
+import { loadConfig as defaultLoadConfig } from '../config/config-loader.js';
+import { formatSessionAge as defaultFormatSessionAge, readSession as defaultReadSession } from '../runs/session-store.js';
+import { uploadPreviewZip as defaultUploadPreviewZip } from './preview.service.js';
 let execFileAsync = promisify(execFile);
 
 // Maximum files to show in dry-run output (use --verbose for all)

package/dist/domains/previews/preview.service.js

@@ -0,0 +1,37 @@
+/**
+ * Upload preview ZIP file for a build
+ * @param {Object} client - API client
+ * @param {string} buildId - Build ID
+ * @param {Buffer} zipBuffer - ZIP file contents
+ * @returns {Promise<Object>} Upload result with preview URL
+ */
+export async function uploadPreviewZip(client, buildId, zipBuffer) {
+  // Use native FormData (Node 18+) with Blob for proper fetch compatibility
+  let formData = new FormData();
+  let blob = new Blob([zipBuffer], {
+    type: 'application/zip'
+  });
+  formData.append('file', blob, 'preview.zip');
+  return client.request(`/api/sdk/builds/${buildId}/preview/upload-zip`, {
+    method: 'POST',
+    body: formData
+    // Let fetch set the Content-Type with boundary automatically
+  });
+}
+
+/**
+ * Get preview info for a build
+ * @param {Object} client - API client
+ * @param {string} buildId - Build ID
+ * @returns {Promise<Object>} Preview info or null if not found
+ */
+export async function getPreviewInfo(client, buildId) {
+  try {
+    return await client.request(`/api/sdk/builds/${buildId}/preview`);
+  } catch (error) {
+    if (error.context?.status === 404) {
+      return null;
+    }
+    throw error;
+  }
+}

package/dist/domains/projects/cloud-projects.routes.js

@@ -0,0 +1,28 @@
+import { sendError, sendSuccess } from '../../adapters/http/middleware/response.js';
+import * as output from '../../shared/output.js';
+export function createCloudProjectsRouter({
+  authService
+}) {
+  return async function handleCloudProjectsRoute(req, res, pathname) {
+    if (req.method !== 'GET' || pathname !== '/api/cloud/projects') return false;
+    try {
+      let response = await authService.authenticatedRequest('/api/cli/projects', {
+        method: 'GET'
+      });
+      sendSuccess(res, {
+        projects: response.projects || []
+      });
+    } catch (error) {
+      output.error('Error fetching projects from cloud:', error);
+      if (error.message?.toLowerCase().includes('not authenticated') || error.code === 'AUTH_ERROR') {
+        sendSuccess(res, {
+          projects: [],
+          authenticated: false
+        });
+      } else {
+        sendError(res, 500, error.message);
+      }
+    }
+    return true;
+  };
+}

package/dist/{commands/orgs.js → domains/projects/orgs.commands.js}

@@ -1,13 +1,12 @@
+import * as defaultOutput from '../../shared/output.js';
+import { createApiClient as defaultCreateApiClient } from '../auth/cloud-client.js';
+import { loadConfig as defaultLoadConfig } from '../config/config-loader.js';
+import { getApiUrl as defaultGetApiUrl } from '../config/environment.js';
+
 /**
  * Organizations command - List organizations the user has access to
  */
 
-import { createApiClient as defaultCreateApiClient } from '../api/client.js';
-import { loadConfig as defaultLoadConfig } from '../utils/config-loader.js';
-import { getApiUrl as defaultGetApiUrl } from '../utils/environment-config.js';
-import { getAccessToken as defaultGetAccessToken } from '../utils/global-config.js';
-import * as defaultOutput from '../utils/output.js';
-
 /**
  * Organizations command implementation
  * @param {Object} options - Command options
@@ -19,7 +18,6 @@ export async function orgsCommand(_options = {}, globalOptions = {}, deps = {})
     loadConfig = defaultLoadConfig,
     createApiClient = defaultCreateApiClient,
     getApiUrl = defaultGetApiUrl,
-    getAccessToken = defaultGetAccessToken,
     output = defaultOutput,
     exit = code => process.exit(code)
   } = deps;
@@ -33,7 +31,7 @@ export async function orgsCommand(_options = {}, globalOptions = {}, deps = {})
 
     // Prefer user auth token for listing orgs (project tokens are org-scoped).
     // Falls back to config.apiKey which may be: VIZZLY_TOKEN, --token flag, or project token.
-    let token = (await getAccessToken()) || config.apiKey;
+    let token = config.userToken || config.apiKey;
     if (!token) {
       output.error('API token required. Use --token, set VIZZLY_TOKEN, or run "vizzly login"');
       output.cleanup();

package/dist/{utils → domains/projects}/project-binding.js

@@ -1,7 +1,7 @@
 import path from 'node:path';
-import { VizzlyError } from '../errors/vizzly-error.js';
-import { discoverConfig } from './config-discovery.js';
-import { applyChanges } from './file-changes.js';
+import { applyChanges } from '../../shared/file-changes.js';
+import { VizzlyError } from '../../shared/vizzly-error.js';
+import { discoverConfig } from '../config/config-discovery.js';
 function sameProject(left, right) {
   return left?.organizationSlug === right.organizationSlug && left?.projectSlug === right.projectSlug;
 }

package/dist/domains/projects/project-errors.js

@@ -0,0 +1,61 @@
+import { VizzlyError } from '../../shared/vizzly-error.js';
+
+/**
+ * Build error for project fetch failure
+ * @param {Error} originalError - Original error
+ * @returns {VizzlyError} Wrapped error
+ */
+export function buildProjectFetchError(originalError) {
+  return new VizzlyError(`Failed to fetch project: ${originalError.message}`, 'PROJECT_FETCH_FAILED', {
+    originalError
+  });
+}
+
+/**
+ * Build error for no authentication available
+ * @returns {VizzlyError} No auth error
+ */
+export function buildNoAuthError() {
+  return new VizzlyError('No authentication available', 'NO_AUTH_SERVICE');
+}
+
+/**
+ * Build error for no API service available
+ * @returns {VizzlyError} No API service error
+ */
+export function buildNoApiServiceError() {
+  return new VizzlyError('API service not available', 'NO_API_SERVICE');
+}
+
+/**
+ * Build error for token creation failure
+ * @param {Error} originalError - Original error
+ * @returns {VizzlyError} Wrapped error
+ */
+export function buildTokenCreateError(originalError) {
+  return new VizzlyError(`Failed to create project token: ${originalError.message}`, 'TOKEN_CREATE_FAILED', {
+    originalError
+  });
+}
+
+/**
+ * Build error for token fetch failure
+ * @param {Error} originalError - Original error
+ * @returns {VizzlyError} Wrapped error
+ */
+export function buildTokensFetchError(originalError) {
+  return new VizzlyError(`Failed to fetch project tokens: ${originalError.message}`, 'TOKENS_FETCH_FAILED', {
+    originalError
+  });
+}
+
+/**
+ * Build error for token revoke failure
+ * @param {Error} originalError - Original error
+ * @returns {VizzlyError} Wrapped error
+ */
+export function buildTokenRevokeError(originalError) {
+  return new VizzlyError(`Failed to revoke project token: ${originalError.message}`, 'TOKEN_REVOKE_FAILED', {
+    originalError
+  });
+}

package/dist/{utils → domains/projects}/project-link-store.js

@@ -1,5 +1,5 @@
-import { loadGlobalConfig, saveGlobalConfig } from './global-config.js';
-import { deleteSecret as defaultDeleteSecret, getSecret as defaultGetSecret, saveSecret as defaultSaveSecret } from './secret-store.js';
+import { loadGlobalConfig, saveGlobalConfig } from '../../shared/global-config.js';
+import { deleteSecret as defaultDeleteSecret, getSecret as defaultGetSecret, saveSecret as defaultSaveSecret } from '../../shared/secret-store.js';
 export function buildProjectLinkAccount({
   apiUrl,
   organizationSlug,

package/dist/domains/projects/project-requests.js

@@ -0,0 +1,61 @@
+/**
+ * Build query params for builds API request
+ * @param {Object} options - Query options
+ * @param {number} [options.limit] - Number of builds to fetch
+ * @param {string} [options.branch] - Filter by branch
+ * @returns {string} Query string (empty string if no params)
+ */
+export function buildBuildsQueryParams(options = {}) {
+  let params = new globalThis.URLSearchParams();
+  if (options.limit) {
+    params.append('limit', String(options.limit));
+  }
+  if (options.branch) {
+    params.append('branch', options.branch);
+  }
+  let query = params.toString();
+  return query ? `?${query}` : '';
+}
+
+/**
+ * Build organization header object
+ * @param {string} organizationSlug - Organization slug
+ * @returns {Object} Headers object with X-Organization header
+ */
+export function buildOrgHeader(organizationSlug) {
+  return {
+    'X-Organization': organizationSlug
+  };
+}
+
+/**
+ * Build API URL for project endpoint
+ * @param {string} projectSlug - Project slug
+ * @returns {string} API URL path
+ */
+export function buildProjectUrl(projectSlug) {
+  return `/api/project/${projectSlug}`;
+}
+
+/**
+ * Build API URL for builds endpoint
+ * @param {string} projectSlug - Project slug
+ * @param {Object} options - Query options
+ * @returns {string} Full API URL path with query params
+ */
+export function buildBuildsUrl(projectSlug, options = {}) {
+  let queryString = buildBuildsQueryParams(options);
+  return `/api/build/${projectSlug}${queryString}`;
+}
+
+/**
+ * Build API URL for project tokens endpoint
+ * @param {string} organizationSlug - Organization slug
+ * @param {string} projectSlug - Project slug
+ * @param {string} [tokenId] - Optional token ID for specific token operations
+ * @returns {string} API URL path
+ */
+export function buildTokensUrl(_organizationSlug, projectSlug, tokenId) {
+  let base = `/api/project/${projectSlug}/tokens`;
+  return tokenId ? `${base}/${tokenId}` : base;
+}

package/dist/{commands/project.js → domains/projects/project.commands.js}

@@ -1,46 +1,14 @@
-import { createApiClient as defaultCreateApiClient } from '../api/client.js';
-import { loadConfig as defaultLoadConfig } from '../utils/config-loader.js';
-import { getApiUrl as defaultGetApiUrl } from '../utils/environment-config.js';
-import { preflightChanges } from '../utils/file-changes.js';
-import { getAccessToken as defaultGetAccessToken } from '../utils/global-config.js';
-import * as defaultOutput from '../utils/output.js';
-import { planProjectBinding as defaultPlanProjectBinding, writeProjectBinding as defaultWriteProjectBinding } from '../utils/project-binding.js';
-import { getProjectLink as defaultGetProjectLink, saveProjectLink as defaultSaveProjectLink } from '../utils/project-link-store.js';
-export function parseProjectSelector(selector, options = {}) {
-  let organizationSlug = options.org || null;
-  let projectSlug = options.project || null;
-  if (selector) {
-    let parts = selector.split('/');
-    if (parts.length === 2) {
-      organizationSlug = organizationSlug || parts[0];
-      projectSlug = projectSlug || parts[1];
-    } else if (parts.length === 1) {
-      projectSlug = projectSlug || parts[0];
-    }
-  }
-  return {
-    organizationSlug,
-    projectSlug
-  };
-}
-export function validateProjectLinkOptions(selector, options = {}) {
-  let errors = [];
-  let {
-    organizationSlug,
-    projectSlug
-  } = parseProjectSelector(selector, options);
-  if (!organizationSlug) {
-    errors.push('Organization is required. Use <org>/<project> or --org <slug>.');
-  }
-  if (!projectSlug) {
-    errors.push('Project is required. Use <org>/<project> or --project <slug>.');
-  }
-  return errors;
-}
+import { preflightChanges } from '../../shared/file-changes.js';
+import * as defaultOutput from '../../shared/output.js';
+import { createApiClient as defaultCreateApiClient } from '../auth/cloud-client.js';
+import { loadConfig as defaultLoadConfig } from '../config/config-loader.js';
+import { getApiUrl as defaultGetApiUrl } from '../config/environment.js';
+import { parseProjectSelector } from './project.validations.js';
+import { planProjectBinding as defaultPlanProjectBinding, writeProjectBinding as defaultWriteProjectBinding } from './project-binding.js';
+import { getProjectLink as defaultGetProjectLink, saveProjectLink as defaultSaveProjectLink } from './project-link-store.js';
 export async function projectLinkCommand(selector, options = {}, globalOptions = {}, deps = {}) {
   let {
     createApiClient = defaultCreateApiClient,
-    getAccessToken = defaultGetAccessToken,
     getApiUrl = defaultGetApiUrl,
     loadConfig = defaultLoadConfig,
     output = defaultOutput,
@@ -111,7 +79,7 @@ export async function projectLinkCommand(selector, options = {}, globalOptions =
       ...project
     }) : null;
     let reused = Boolean(linkedProject);
-    let userToken = linkedProject ? null : config.userToken || globalOptions.token || (await getAccessToken());
+    let userToken = linkedProject ? null : config.userToken || globalOptions.token;
     if (!linkedProject && !userToken) {
       output.error('Login required before linking a project');
       output.hint('Run "vizzly login" first, then try project link again');

package/dist/domains/projects/project.normalizers.js

@@ -0,0 +1,69 @@
+/**
+ * Extract projects from API response
+ * @param {Object} response - API response
+ * @returns {Array} Array of projects
+ */
+export function extractProjects(response) {
+  return response?.projects || [];
+}
+
+/**
+ * Extract project from API response
+ * @param {Object} response - API response
+ * @returns {Object} Project object
+ */
+export function extractProject(response) {
+  return response?.project || response;
+}
+
+/**
+ * Extract builds from API response
+ * @param {Object} response - API response
+ * @returns {Array} Array of builds
+ */
+export function extractBuilds(response) {
+  return response?.builds || [];
+}
+
+/**
+ * Extract token from API response
+ * @param {Object} response - API response
+ * @returns {Object} Token object
+ */
+export function extractToken(response) {
+  return response?.token;
+}
+
+/**
+ * Extract tokens from API response
+ * @param {Object} response - API response
+ * @returns {Array} Array of tokens
+ */
+export function extractTokens(response) {
+  return response?.tokens || [];
+}
+
+/**
+ * Enrich projects with organization info
+ * @param {Array} projects - Array of projects
+ * @param {Object} org - Organization object
+ * @param {string} org.slug - Organization slug
+ * @param {string} org.name - Organization name
+ * @returns {Array} Projects with organization info added
+ */
+export function enrichProjectsWithOrg(projects, org) {
+  return projects.map(project => ({
+    ...project,
+    organizationSlug: org.slug,
+    organizationName: org.name
+  }));
+}
+
+/**
+ * Extract organizations from whoami response
+ * @param {Object} whoamiResponse - Whoami API response
+ * @returns {Array} Array of organizations
+ */
+export function extractOrganizations(whoamiResponse) {
+  return whoamiResponse?.organizations || [];
+}