@vizzly-testing/cli 0.39.0 → 0.39.2

package/dist/domains/reports/report.serializers.js

@@ -0,0 +1,99 @@
+/**
+ * Convert absolute file paths to web-accessible URLs
+ */
+export let convertPathToUrl = (filePath, vizzlyDir) => {
+  if (!filePath) return null;
+  // Convert absolute path to relative path from .vizzly directory
+  if (filePath.startsWith(vizzlyDir)) {
+    let relativePath = filePath.substring(vizzlyDir.length + 1);
+    return `/images/${relativePath}`;
+  }
+  return filePath;
+};
+
+/**
+ * Group comparisons by screenshot name with variant structure
+ * Matches cloud product's grouping logic from comparison.js
+ */
+export let groupComparisons = comparisons => {
+  let groups = new Map();
+
+  // Group by screenshot name
+  for (let comp of comparisons) {
+    if (!groups.has(comp.name)) {
+      groups.set(comp.name, {
+        name: comp.name,
+        comparisons: [],
+        browsers: new Set(),
+        viewports: new Set(),
+        devices: new Set(),
+        totalVariants: 0
+      });
+    }
+    let group = groups.get(comp.name);
+    group.comparisons.push(comp);
+    group.totalVariants++;
+
+    // Track unique browsers, viewports, devices
+    if (comp.properties?.browser) {
+      group.browsers.add(comp.properties.browser);
+    }
+    if (comp.properties?.viewport_width && comp.properties?.viewport_height) {
+      group.viewports.add(`${comp.properties.viewport_width}x${comp.properties.viewport_height}`);
+    }
+    if (comp.properties?.device) {
+      group.devices.add(comp.properties.device);
+    }
+  }
+
+  // Convert to final structure
+  return Array.from(groups.values()).map(group => {
+    let browsers = Array.from(group.browsers);
+    let viewports = Array.from(group.viewports);
+    let devices = Array.from(group.devices);
+
+    // Build variants structure (browser -> viewport -> comparisons)
+    let variants = {};
+    group.comparisons.forEach(comp => {
+      let browser = comp.properties?.browser || null;
+      let viewport = comp.properties?.viewport_width && comp.properties?.viewport_height ? `${comp.properties.viewport_width}x${comp.properties.viewport_height}` : null;
+      if (!variants[browser]) variants[browser] = {};
+      if (!variants[browser][viewport]) variants[browser][viewport] = [];
+      variants[browser][viewport].push(comp);
+    });
+
+    // Determine grouping strategy
+    let groupingStrategy = 'flat';
+    if (browsers.length > 1) groupingStrategy = 'browser';else if (viewports.length > 1) groupingStrategy = 'viewport';
+
+    // Sort comparisons by viewport area (largest first)
+    group.comparisons.sort((a, b) => {
+      let aArea = (a.properties?.viewport_width || 0) * (a.properties?.viewport_height || 0);
+      let bArea = (b.properties?.viewport_width || 0) * (b.properties?.viewport_height || 0);
+      if (bArea !== aArea) return bArea - aArea;
+      return (b.properties?.viewport_width || 0) - (a.properties?.viewport_width || 0);
+    });
+    return {
+      ...group,
+      browsers,
+      viewports,
+      devices: Array.from(devices),
+      variants,
+      groupingStrategy
+    };
+  }).sort((a, b) => {
+    // Sort groups: multi-variant first (by variant count), then singles alphabetically
+    if (a.totalVariants > 1 && b.totalVariants === 1) return -1;
+    if (a.totalVariants === 1 && b.totalVariants > 1) return 1;
+    if (a.totalVariants > 1 && b.totalVariants > 1) {
+      return b.totalVariants - a.totalVariants;
+    }
+    return a.name.localeCompare(b.name);
+  });
+};
+let COMPARISON_DETAIL_FIELDS = new Set(['boundingBox', 'diffClusters', 'intensityStats']);
+
+/** Heavy detail files may enrich a comparison, never replace its identity/state. */
+export function presentComparisonDetails(details = {}) {
+  return Object.fromEntries(Object.entries(details).filter(([field]) => COMPARISON_DETAIL_FIELDS.has(field)));
+}

package/dist/{services/static-report-generator.js → domains/reports/report.service.js}

@@ -6,22 +6,16 @@
  */
 
 import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-let __dirname = dirname(fileURLToPath(import.meta.url));
+import { join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { getPackageRoot } from '../../shared/package-info.js';
+import { createReportStore } from './report-store.js';
 
 /**
  * Get the path to the dist/reporter directory (for CSS)
  */
 function getReporterDistPath() {
-  // Try production path first (when running from dist/)
-  let distPath = join(__dirname, '..', 'reporter');
-  if (existsSync(join(distPath, 'reporter-bundle.css'))) {
-    return distPath;
-  }
-
-  // Fall back to development path (when running from src/)
-  distPath = join(__dirname, '..', '..', 'dist', 'reporter');
+  let distPath = join(getPackageRoot(), 'dist', 'reporter');
   if (existsSync(join(distPath, 'reporter-bundle.css'))) {
     return distPath;
   }
@@ -32,14 +26,7 @@ function getReporterDistPath() {
  * Get the path to the SSR module
  */
 function getSSRModulePath() {
-  // Try production path first (when running from dist/)
-  let ssrPath = join(__dirname, '..', 'reporter-ssr', 'ssr-entry.js');
-  if (existsSync(ssrPath)) {
-    return ssrPath;
-  }
-
-  // Fall back to development path (when running from src/)
-  ssrPath = join(__dirname, '..', '..', 'dist', 'reporter-ssr', 'ssr-entry.js');
+  let ssrPath = join(getPackageRoot(), 'dist', 'reporter-ssr', 'ssr-entry.js');
   if (existsSync(ssrPath)) {
     return ssrPath;
   }
@@ -139,26 +126,17 @@ export async function generateStaticReport(workingDir, options = {}) {
   let outputDir = options.outputDir || join(workingDir, '.vizzly', 'report');
   let vizzlyDir = join(workingDir, '.vizzly');
   try {
-    // Read report data
-    let reportDataPath = join(vizzlyDir, 'report-data.json');
-    if (!existsSync(reportDataPath)) {
+    let reports = createReportStore(workingDir);
+    let reportData = reports.readReport();
+    if (!reportData) {
       return {
         success: false,
         reportPath: null,
         error: 'No report data found. Run tests first.'
       };
     }
-    let reportData = JSON.parse(readFileSync(reportDataPath, 'utf8'));
-
-    // Read baseline metadata if available
-    let metadataPath = join(vizzlyDir, 'baselines', 'metadata.json');
-    if (existsSync(metadataPath)) {
-      try {
-        reportData.baseline = JSON.parse(readFileSync(metadataPath, 'utf8'));
-      } catch {
-        // Ignore metadata read errors
-      }
-    }
+    let baseline = reports.readBaselineMetadata();
+    if (baseline !== null) reportData.baseline = baseline;
 
     // Transform image URLs to relative paths
     let transformedData = transformImageUrls(reportData);

package/dist/{commands/review.js → domains/review/review.commands.js}

@@ -3,10 +3,10 @@
  */
 
 import { randomUUID as defaultRandomUUID } from 'node:crypto';
-import { createApiClient as defaultCreateApiClient } from '../api/index.js';
-import { loadConfig as defaultLoadConfig } from '../utils/config-loader.js';
-import { getAccessToken as defaultGetAccessToken } from '../utils/global-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 { getAccessToken as defaultGetAccessToken } from '../auth/token-store.js';
+import { loadConfig as defaultLoadConfig } from '../config/config-loader.js';
 function createReviewDeps(deps = {}) {
   return {
     loadConfig: deps.loadConfig || defaultLoadConfig,

package/dist/domains/runs/run-environment.js

@@ -0,0 +1,69 @@
+/**
+ * Build environment variables for test process execution
+ * @param {Object} options - Options
+ * @param {number} options.port - Server port
+ * @param {string} options.buildId - Build ID
+ * @param {boolean} [options.setBaseline] - Whether to set baseline
+ * @param {boolean} [options.failOnDiff] - Whether visual diffs should fail tests
+ * @param {Object} [options.baseEnv] - Base environment (defaults to process.env)
+ * @returns {Object} Environment variables object
+ */
+export function buildTestEnv({
+  port,
+  buildId,
+  setBaseline = false,
+  failOnDiff = false,
+  baseEnv = process.env
+}) {
+  return {
+    ...baseEnv,
+    VIZZLY_SERVER_URL: `http://localhost:${port}`,
+    VIZZLY_BUILD_ID: buildId,
+    VIZZLY_ENABLED: 'true',
+    VIZZLY_SET_BASELINE: setBaseline ? 'true' : 'false',
+    VIZZLY_FAIL_ON_DIFF: failOnDiff ? 'true' : 'false'
+  };
+}
+
+/**
+ * Build environment for disabled Vizzly (allowNoToken mode)
+ * @param {Object} [baseEnv] - Base environment (defaults to process.env)
+ * @returns {Object} Environment variables object
+ */
+export function buildDisabledEnv(baseEnv = process.env) {
+  return {
+    ...baseEnv,
+    VIZZLY_ENABLED: 'false'
+  };
+}
+
+/**
+ * Build API client options from config
+ * @param {Object} config - Configuration object
+ * @returns {Object|null} Client options or null if no API key
+ */
+export function buildClientOptions(config) {
+  if (!config?.apiKey) {
+    return null;
+  }
+  return {
+    baseUrl: config.apiUrl,
+    token: config.apiKey,
+    command: 'run'
+  };
+}
+
+/**
+ * Build spawn options for test command execution
+ * @param {Object} env - Environment variables
+ * @param {Object} [options] - Spawn display options
+ * @param {boolean} [options.json] - Keep stdout reserved for CLI JSON output
+ * @returns {Object} Spawn options
+ */
+export function buildSpawnOptions(env, options = {}) {
+  return {
+    env,
+    stdio: options.json ? ['inherit', 'pipe', 'pipe'] : 'inherit',
+    shell: true
+  };
+}

package/dist/{services/test-runner.js → domains/runs/run-events.js}

@@ -1,19 +1,21 @@
+import { spawn } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import * as output from '../../shared/output.js';
+import { VizzlyError } from '../../shared/vizzly-error.js';
+import { createApiClient } from '../auth/cloud-client.js';
+import { createBuild as createApiBuild, finalizeBuild as finalizeApiBuild, getBuild } from '../builds/build.service.js';
+import { createBuildObject } from '../builds/build-info.js';
+import { cancelTests, createBuild, fetchBuildUrl, finalizeBuild, initializeDaemon, runTests } from './run.service.js';
+import { writeSession as defaultWriteSession } from './session-store.js';
+
 /**
  * Test Runner Service
  * Orchestrates the test execution flow
  *
  * This EventEmitter adapter keeps the stable plugin-facing runner contract
- * while delegating execution to the functional operations in src/test-runner/.
+ * while delegating execution to the domain's run.service.js operations.
  */
 
-import { spawn } from 'node:child_process';
-import { EventEmitter } from 'node:events';
-import { createBuild as createApiBuild, createApiClient, finalizeBuild as finalizeApiBuild, getBuild } from '../api/index.js';
-import { VizzlyError } from '../errors/vizzly-error.js';
-import { cancelTests, createBuild, fetchBuildUrl, finalizeBuild, initializeDaemon, runTests } from '../test-runner/index.js';
-import * as output from '../utils/output.js';
-import { writeSession as defaultWriteSession } from '../utils/session.js';
-import { createBuildObject } from './build-manager.js';
 export class TestRunner extends EventEmitter {
   constructor(config, serverManager, options = {}) {
     super();

package/dist/{commands/run.js → domains/runs/run.commands.js}

@@ -1,3 +1,19 @@
+import { spawn as defaultSpawn } from 'node:child_process';
+import { createServerManager as defaultCreateServerManager } from '../../adapters/http/server-manager.js';
+import { getAppBaseUrl } from '../../shared/api-url.js';
+import { detectBranch as defaultDetectBranch, detectCommit as defaultDetectCommit, detectCommitAuthor as defaultDetectCommitAuthor, detectCommitMessage as defaultDetectCommitMessage, detectPullRequestNumber as defaultDetectPullRequestNumber, generateBuildNameWithGit as defaultGenerateBuildNameWithGit } from '../../shared/git.js';
+import * as defaultOutput from '../../shared/output.js';
+import { VizzlyError } from '../../shared/vizzly-error.js';
+import { createApiClient as defaultCreateApiClient } from '../auth/cloud-client.js';
+import { createBuild as defaultCreateApiBuild, finalizeBuild as defaultFinalizeApiBuild, getBuild as defaultGetBuild } from '../builds/build.service.js';
+import { createBuildObject as defaultCreateBuildObject } from '../builds/build-info.js';
+import { CONFIG_DEFAULTS } from '../config/config-defaults.js';
+import { loadConfig as defaultLoadConfig } from '../config/config-loader.js';
+import { getTokenContext as defaultGetTokenContext } from '../context/context.service.js';
+import { createUploader as defaultCreateUploader } from '../uploads/upload.service.js';
+import { finalizeBuild as defaultFinalizeBuild, runTests as defaultRunTests } from './run.service.js';
+import { writeSession as defaultWriteSession } from './session-store.js';
+
 /**
  * Run tests and report their visual results in terminal or JSON output.
  *
@@ -8,19 +24,6 @@
  * Uses functional operations directly - no class wrappers needed
  */
 
-import { spawn as defaultSpawn } from 'node:child_process';
-import { createBuild as defaultCreateApiBuild, createApiClient as defaultCreateApiClient, finalizeBuild as defaultFinalizeApiBuild, getBuild as defaultGetBuild, getTokenContext as defaultGetTokenContext } from '../api/index.js';
-import { CONFIG_DEFAULTS } from '../config/core.js';
-import { VizzlyError } from '../errors/vizzly-error.js';
-import { createServerManager as defaultCreateServerManager } from '../server-manager/index.js';
-import { createBuildObject as defaultCreateBuildObject } from '../services/build-manager.js';
-import { finalizeBuild as defaultFinalizeBuild, runTests as defaultRunTests } from '../test-runner/index.js';
-import { createUploader as defaultCreateUploader } from '../uploader/index.js';
-import { getAppBaseUrl } from '../utils/api-url.js';
-import { loadConfig as defaultLoadConfig } from '../utils/config-loader.js';
-import { detectBranch as defaultDetectBranch, detectCommit as defaultDetectCommit, detectCommitAuthor as defaultDetectCommitAuthor, detectCommitMessage as defaultDetectCommitMessage, detectPullRequestNumber as defaultDetectPullRequestNumber, generateBuildNameWithGit as defaultGenerateBuildNameWithGit } from '../utils/git.js';
-import * as defaultOutput from '../utils/output.js';
-import { writeSession as defaultWriteSession } from '../utils/session.js';
 function formatUploadCounts({
   total,
   uploaded,

package/dist/domains/runs/run.normalizers.js

@@ -0,0 +1,8 @@
+/**
+ * Normalize setBaseline option (handles both camelCase and kebab-case)
+ * @param {Object} options - Options object
+ * @returns {boolean} Whether to set baseline
+ */
+export function normalizeSetBaseline(options) {
+  return Boolean(options?.setBaseline || options?.['set-baseline']);
+}

package/dist/domains/runs/run.rules.js

@@ -0,0 +1,56 @@
+/**
+ * Determine if we should skip Vizzly integration entirely
+ * @param {Object} options - Options
+ * @param {boolean} options.allowNoToken - Whether to allow running without token
+ * @param {boolean} options.hasApiKey - Whether an API key is available
+ * @param {boolean} options.tdd - Whether in TDD mode
+ * @returns {boolean} True if Vizzly should be disabled
+ */
+export function shouldDisableVizzly({
+  allowNoToken,
+  hasApiKey,
+  tdd
+}) {
+  return allowNoToken && !hasApiKey && !tdd;
+}
+
+/**
+ * Determine build mode
+ * @param {boolean} tdd - Whether TDD mode is enabled
+ * @returns {'tdd'|'api'} Build mode
+ */
+export function determineBuildMode(tdd) {
+  return tdd ? 'tdd' : 'api';
+}
+
+/**
+ * Validate daemon mode requirements
+ * @param {Object} options - Options
+ * @param {boolean} options.tdd - Whether TDD mode is enabled
+ * @param {boolean} options.daemon - Whether daemon mode is enabled
+ * @returns {{ valid: boolean, error: string|null }}
+ */
+export function validateDaemonMode({
+  tdd,
+  daemon
+}) {
+  if (!tdd || !daemon) {
+    return {
+      valid: false,
+      error: 'Initialize method is only for TDD daemon mode'
+    };
+  }
+  return {
+    valid: true,
+    error: null
+  };
+}
+
+/**
+ * Check if API key is available
+ * @param {Object} config - Configuration object
+ * @returns {boolean} Whether API key exists
+ */
+export function hasApiKey(config) {
+  return Boolean(config?.apiKey);
+}

package/dist/domains/runs/run.serializers.js

@@ -0,0 +1,101 @@
+/**
+ * Build API build payload from options
+ * @param {Object} options - Run options
+ * @param {Object} [comparisonConfig] - Comparison configuration (threshold, minClusterSize)
+ * @returns {Object} Build payload for API
+ */
+export function buildApiBuildPayload(options, comparisonConfig = null) {
+  let payload = {
+    name: options.buildName || `Test Run ${new Date().toISOString()}`,
+    branch: options.branch || 'main',
+    environment: options.environment || 'test',
+    commit_sha: options.commit,
+    commit_message: options.message,
+    commit_author_name: options.commitAuthorName,
+    commit_author_email: options.commitAuthorEmail,
+    github_pull_request_number: options.pullRequestNumber,
+    parallel_id: options.parallelId
+  };
+
+  // Only include metadata if we have meaningful config to send
+  if (comparisonConfig?.threshold != null || comparisonConfig?.minClusterSize != null) {
+    payload.metadata = {
+      comparison: {
+        threshold: comparisonConfig.threshold,
+        minClusterSize: comparisonConfig.minClusterSize
+      }
+    };
+  }
+  return payload;
+}
+
+/**
+ * Build result object for disabled run (no Vizzly integration)
+ * @returns {Object} Result object
+ */
+export function buildDisabledRunResult(reason = null) {
+  return {
+    testsPassed: 1,
+    testsFailed: 0,
+    screenshotsCaptured: 0,
+    ...(reason ? {
+      capture: {
+        setup: 'disabled',
+        reason,
+        accepted: 0,
+        rejected: 0,
+        errors: 0
+      }
+    } : {})
+  };
+}
+
+/**
+ * Build final run result object
+ * @param {Object} options - Options
+ * @param {string|null} options.buildId - Build ID
+ * @param {string|null} options.buildUrl - Build URL
+ * @param {boolean} options.testSuccess - Whether tests passed
+ * @param {number} options.screenshotCount - Number of screenshots
+ * @param {Object|null} options.tddResults - TDD results (comparisons, etc.)
+ * @param {Object|null} [options.uploadStats] - Cumulative cloud upload outcomes,
+ * exposed as `uploads` independently of test and local comparison results.
+ * @returns {Object} Final result object
+ */
+export function buildRunResult({
+  buildId,
+  buildUrl,
+  testSuccess,
+  screenshotCount,
+  tddResults,
+  uploadStats
+}) {
+  return {
+    buildId,
+    url: buildUrl,
+    testsPassed: testSuccess ? 1 : 0,
+    testsFailed: testSuccess ? 0 : 1,
+    screenshotsCaptured: screenshotCount,
+    ...(uploadStats ? {
+      uploads: uploadStats
+    } : {}),
+    comparisons: tddResults?.comparisons || null,
+    failed: (tddResults?.failed || 0) > 0,
+    ...(tddResults ? {
+      summary: {
+        total: tddResults.total ?? screenshotCount,
+        passed: tddResults.passed || 0,
+        failed: tddResults.failed || 0,
+        new: tddResults.new || 0,
+        errors: tddResults.errors || 0
+      },
+      capture: {
+        setup: 'ready',
+        reason: tddResults.error || null,
+        accepted: tddResults.capture?.accepted ?? screenshotCount,
+        rejected: tddResults.capture?.rejected || 0,
+        errors: tddResults.errors || 0
+      }
+    } : {})
+  };
+}

package/dist/{test-runner/operations.js → domains/runs/run.service.js}

@@ -1,5 +1,11 @@
+import { normalizeSetBaseline } from './run.normalizers.js';
+import { hasApiKey, shouldDisableVizzly, validateDaemonMode } from './run.rules.js';
+import { buildApiBuildPayload, buildDisabledRunResult, buildRunResult } from './run.serializers.js';
+import { validateTestCommand } from './run.validations.js';
+import { buildClientOptions, buildDisabledEnv, buildSpawnOptions, buildTestEnv } from './run-environment.js';
+
 /**
- * Test Runner Operations - Test execution operations with dependency injection
+ * Test execution and build lifecycle services
  *
  * Each operation takes its dependencies as parameters:
  * - spawn: child_process.spawn for executing commands
@@ -11,8 +17,6 @@
  * This makes them trivially testable without mocking modules.
  */
 
-import { buildApiBuildPayload, buildClientOptions, buildDisabledEnv, buildDisabledRunResult, buildRunResult, buildSpawnOptions, buildTestEnv, hasApiKey, normalizeSetBaseline, shouldDisableVizzly, validateDaemonMode, validateTestCommand } from './core.js';
-
 // ============================================================================
 // Build Operations
 // ============================================================================
@@ -111,9 +115,10 @@ export async function fetchBuildUrl({
  * @param {boolean} options.tdd - Whether in TDD mode
  * @param {boolean} options.success - Whether tests passed
  * @param {number} options.executionTime - Execution time in ms
+ * @param {string} [options.failureReason] - Explanation for a failed build
  * @param {Object} options.config - Configuration object
  * @param {Object} options.deps - Dependencies
- * @param {Object} options.deps.serverManager - Server manager
+ * @param {Object} [options.deps.serverManager] - Server manager when uploads exist
  * @param {Function} options.deps.createApiClient - API client factory
  * @param {Function} options.deps.finalizeApiBuild - API finalize function
  * @param {Object} options.deps.output - Output utilities
@@ -126,6 +131,7 @@ export async function finalizeBuild({
   tdd,
   success,
   executionTime,
+  failureReason,
   config,
   deps
 }) {
@@ -143,7 +149,7 @@ export async function finalizeBuild({
   try {
     if (tdd) {
       // TDD mode: use server handler to finalize (local-only)
-      if (serverManager.server?.finishBuild) {
+      if (serverManager?.server?.finishBuild) {
         await serverManager.server.finishBuild(buildId);
         output.debug('build', 'finalized', {
           success
@@ -151,7 +157,7 @@ export async function finalizeBuild({
       }
     } else {
       // API mode: flush uploads first, then finalize build
-      if (serverManager.server?.finishBuild) {
+      if (serverManager?.server?.finishBuild) {
         uploadStats = await serverManager.server.finishBuild(buildId);
       }
 
@@ -161,7 +167,7 @@ export async function finalizeBuild({
         let client = createApiClient(clientOptions);
         let uploadsFailed = uploadStats?.failed > 0;
         let buildSucceeded = success && !uploadsFailed;
-        await finalizeApiBuild(client, buildId, buildSucceeded, executionTime, uploadsFailed ? `${uploadStats.failed} screenshot(s) failed to upload. Visual testing is incomplete.` : undefined);
+        await finalizeApiBuild(client, buildId, buildSucceeded, executionTime, uploadsFailed ? `${uploadStats.failed} screenshot(s) failed to upload. Visual testing is incomplete.` : failureReason);
         output.debug('build', 'finalized via api', {
           success: buildSucceeded
         });
@@ -395,6 +401,28 @@ export async function runTests({
         error: stopError.message
       });
     }
+    if (buildId && !tdd) {
+      try {
+        await finalizeBuild({
+          buildId,
+          tdd: false,
+          success: false,
+          executionTime: Date.now() - startTime,
+          failureReason: error.message,
+          config,
+          deps: {
+            createApiClient,
+            finalizeApiBuild,
+            output,
+            onFinalizeFailed
+          }
+        });
+      } catch (finalizeError) {
+        output.debug('run', 'failed to finalize build after setup error', {
+          error: finalizeError.message
+        });
+      }
+    }
     return executeDisabledTestRun({
       testCommand,
       json: runOptions.json,

package/dist/domains/runs/run.validations.js

@@ -0,0 +1,17 @@
+/**
+ * Validate test command is provided
+ * @param {string|undefined} testCommand - Test command to validate
+ * @returns {{ valid: boolean, error: string|null }}
+ */
+export function validateTestCommand(testCommand) {
+  if (!testCommand) {
+    return {
+      valid: false,
+      error: 'No test command provided'
+    };
+  }
+  return {
+    valid: true,
+    error: null
+  };
+}

package/dist/{utils/session.js → domains/runs/session-store.js}

@@ -1,3 +1,6 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+
 /**
  * Session management for build context
  *
@@ -9,8 +12,6 @@
  * 2. GitHub Actions env ($GITHUB_ENV) - for cross-step persistence in GHA
  */
 
-import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
 let SESSION_DIR = '.vizzly';
 let SESSION_FILE = 'session.json';
 let SESSION_MAX_AGE_MS = 60 * 60 * 1000; // 1 hour

package/dist/{server/handlers/api-handler.js → domains/screenshots/cloud-handler.js}

@@ -1,10 +1,10 @@
 import { Buffer } from 'node:buffer';
 import { readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
-import { uploadScreenshot as defaultUploadScreenshot } from '../../api/index.js';
-import { detectImageInputType } from '../../utils/image-input-detector.js';
-import * as output from '../../utils/output.js';
-import { normalizeScreenshotOptions } from '../../utils/screenshot-options.js';
+import * as output from '../../shared/output.js';
+import { uploadScreenshot as defaultUploadScreenshot } from './cloud-screenshots.js';
+import { detectImageInputType } from './image-input.js';
+import { normalizeScreenshotOptions } from './screenshot-options.js';
 
 /**
  * Create a cloud screenshot handler for one run.