@vizzly-testing/cli 0.30.0 → 0.32.0

package/dist/commands/tdd.js

@@ -15,6 +15,9 @@ import { initializeDaemon as defaultInitializeDaemon, runTests as defaultRunTest
 import { loadConfig as defaultLoadConfig } from '../utils/config-loader.js';
 import { detectBranch as defaultDetectBranch, detectCommit as defaultDetectCommit } from '../utils/git.js';
 import * as defaultOutput from '../utils/output.js';
+function buildLocalContextCommand() {
+  return 'vizzly context build current --source local --agent';
+}
 
 /**
  * TDD command implementation
@@ -91,7 +94,7 @@ export async function tddCommand(testCommand, options = {}, globalOptions = {},
       output.header('tdd', mode);
 
       // Show config in verbose mode
-      output.debug('config', `port=${config.server.port} threshold=${config.comparison.threshold}`);
+      output.debug('config', `port=${config.server.port} threshold=${config.comparison.threshold} minClusterSize=${config.comparison.minClusterSize}`);
     }
 
     // Create functional dependencies
@@ -133,6 +136,7 @@ export async function tddCommand(testCommand, options = {}, globalOptions = {},
       commit,
       environment: config.build.environment,
       threshold: config.comparison.threshold,
+      minClusterSize: config.comparison.minClusterSize,
       allowNoToken: config.allowNoToken || false,
       baselineBuildId: config.baselineBuildId,
       baselineComparisonId: config.baselineComparisonId,
@@ -231,10 +235,15 @@ export async function tddCommand(testCommand, options = {}, globalOptions = {},
         exitCode,
         comparisons,
         summary,
-        reportPath: runResult.reportPath || '.vizzly/report/index.html'
+        reportPath: runResult.reportPath || '.vizzly/report/index.html',
+        contextCommand: buildLocalContextCommand()
       });
       output.cleanup();
     }
+    if (!globalOptions.json && !options.daemon) {
+      output.blank?.();
+      output.print(`  Context      ${buildLocalContextCommand()}`);
+    }
     return {
       result: {
         success: !hasFailures,
@@ -287,22 +296,28 @@ export function validateTddOptions(testCommand, options) {
     errors.push('Test command is required');
   }
   if (options.port) {
-    let port = parseInt(options.port, 10);
-    if (Number.isNaN(port) || port < 1 || port > 65535) {
+    let port = Number(options.port);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
       errors.push('Port must be a valid number between 1 and 65535');
     }
   }
   if (options.timeout) {
-    let timeout = parseInt(options.timeout, 10);
-    if (Number.isNaN(timeout) || timeout < 1000) {
+    let timeout = Number(options.timeout);
+    if (!Number.isInteger(timeout) || timeout < 1000) {
       errors.push('Timeout must be at least 1000 milliseconds');
     }
   }
   if (options.threshold !== undefined) {
-    let threshold = parseFloat(options.threshold);
-    if (Number.isNaN(threshold) || threshold < 0) {
+    let threshold = Number(options.threshold);
+    if (!Number.isFinite(threshold) || threshold < 0) {
       errors.push('Threshold must be a non-negative number (CIEDE2000 Delta E)');
     }
   }
+  if (options.minClusterSize !== undefined) {
+    let minClusterSize = Number(options.minClusterSize);
+    if (!Number.isInteger(minClusterSize) || minClusterSize < 1) {
+      errors.push('Min cluster size must be a positive integer');
+    }
+  }
   return errors;
 }

package/dist/commands/upload.js

@@ -1,5 +1,6 @@
 import { createApiClient as defaultCreateApiClient, finalizeBuild as defaultFinalizeBuild, getTokenContext as defaultGetTokenContext } from '../api/index.js';
-import { createUploader as defaultCreateUploader } from '../services/uploader.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, detectCommitMessage as defaultDetectCommitMessage, detectPullRequestNumber as defaultDetectPullRequestNumber, generateBuildNameWithGit as defaultGenerateBuildNameWithGit } from '../utils/git.js';
 import * as defaultOutput from '../utils/output.js';
@@ -26,7 +27,7 @@ export async function constructBuildUrl(buildId, apiUrl, apiToken, deps = {}) {
       command: 'upload'
     });
     let tokenContext = await getTokenContext(client);
-    let baseUrl = apiUrl.replace(/\/api.*$/, '');
+    let baseUrl = getAppBaseUrl(apiUrl);
     if (tokenContext.organization?.slug && tokenContext.project?.slug) {
       return `${baseUrl}/${tokenContext.organization.slug}/${tokenContext.project.slug}/builds/${buildId}`;
     }
@@ -38,7 +39,7 @@ export async function constructBuildUrl(buildId, apiUrl, apiToken, deps = {}) {
   }
 
   // Fallback URL construction
-  let baseUrl = apiUrl.replace(/\/api.*$/, '');
+  let baseUrl = getAppBaseUrl(apiUrl);
   return `${baseUrl}/builds/${buildId}`;
 }
 
@@ -375,20 +376,20 @@ export function validateUploadOptions(screenshotsPath, options) {
     }
   }
   if (options.threshold !== undefined) {
-    const threshold = parseFloat(options.threshold);
-    if (Number.isNaN(threshold) || threshold < 0) {
+    let threshold = Number(options.threshold);
+    if (!Number.isFinite(threshold) || threshold < 0) {
       errors.push('Threshold must be a non-negative number (CIEDE2000 Delta E)');
     }
   }
   if (options.batchSize !== undefined) {
-    const n = parseInt(options.batchSize, 10);
-    if (!Number.isFinite(n) || n <= 0) {
+    let n = Number(options.batchSize);
+    if (!Number.isInteger(n) || n <= 0) {
       errors.push('Batch size must be a positive integer');
     }
   }
   if (options.uploadTimeout !== undefined) {
-    const n = parseInt(options.uploadTimeout, 10);
-    if (!Number.isFinite(n) || n <= 0) {
+    let n = Number(options.uploadTimeout);
+    if (!Number.isInteger(n) || n <= 0) {
       errors.push('Upload timeout must be a positive integer (milliseconds)');
     }
   }

package/dist/commands/whoami.js

@@ -3,16 +3,63 @@
  * Shows current user and authentication status
  */
 
-import { createAuthClient, createTokenStore, getAuthTokens, whoami } from '../auth/index.js';
-import { getApiUrl } from '../utils/environment-config.js';
-import * as output from '../utils/output.js';
+import { createAuthClient as defaultCreateAuthClient, createTokenStore as defaultCreateTokenStore, getAuthTokens as defaultGetAuthTokens, whoami as defaultWhoami } from '../auth/index.js';
+import { getApiUrl as defaultGetApiUrl } from '../utils/environment-config.js';
+import * as defaultOutput from '../utils/output.js';
+export function getTokenExpiryStatus(expiresAt, now = new Date()) {
+  let expiresDate = new Date(expiresAt);
+  let msUntilExpiry = expiresDate.getTime() - now.getTime();
+  let daysUntilExpiry = Math.floor(msUntilExpiry / (1000 * 60 * 60 * 24));
+  let hoursUntilExpiry = Math.floor(msUntilExpiry / (1000 * 60 * 60));
+  let minutesUntilExpiry = Math.floor(msUntilExpiry / (1000 * 60));
+  if (msUntilExpiry <= 0) {
+    return {
+      level: 'warn',
+      message: 'Token has expired',
+      refreshHint: 'Run "vizzly login" to refresh your authentication'
+    };
+  }
+  if (daysUntilExpiry > 0) {
+    return {
+      level: 'hint',
+      message: `Token expires in ${daysUntilExpiry} day${daysUntilExpiry !== 1 ? 's' : ''} (${expiresDate.toLocaleDateString()})`
+    };
+  }
+  if (hoursUntilExpiry > 0) {
+    return {
+      level: 'hint',
+      message: `Token expires in ${hoursUntilExpiry} hour${hoursUntilExpiry !== 1 ? 's' : ''}`
+    };
+  }
+  if (minutesUntilExpiry > 0) {
+    return {
+      level: 'hint',
+      message: `Token expires in ${minutesUntilExpiry} minute${minutesUntilExpiry !== 1 ? 's' : ''}`
+    };
+  }
+  return {
+    level: 'warn',
+    message: 'Token expires in less than a minute',
+    refreshHint: 'Run "vizzly login" to refresh your authentication'
+  };
+}
 
 /**
  * Whoami command implementation
  * @param {Object} options - Command options
  * @param {Object} globalOptions - Global CLI options
+ * @param {Object} deps - Dependencies for testing
  */
-export async function whoamiCommand(options = {}, globalOptions = {}) {
+export async function whoamiCommand(options = {}, globalOptions = {}, deps = {}) {
+  let {
+    createAuthClient = defaultCreateAuthClient,
+    createTokenStore = defaultCreateTokenStore,
+    getApiUrl = defaultGetApiUrl,
+    getAuthTokens = defaultGetAuthTokens,
+    output = defaultOutput,
+    whoami = defaultWhoami,
+    exit = code => process.exit(code)
+  } = deps;
   output.configure({
     json: globalOptions.json,
     verbose: globalOptions.verbose,
@@ -98,27 +145,17 @@ export async function whoamiCommand(options = {}, globalOptions = {}) {
     // Show token expiry info
     if (auth.expiresAt) {
       output.blank();
-      let expiresAt = new Date(auth.expiresAt);
-      let now = new Date();
-      let msUntilExpiry = expiresAt.getTime() - now.getTime();
-      let daysUntilExpiry = Math.floor(msUntilExpiry / (1000 * 60 * 60 * 24));
-      let hoursUntilExpiry = Math.floor(msUntilExpiry / (1000 * 60 * 60));
-      let minutesUntilExpiry = Math.floor(msUntilExpiry / (1000 * 60));
-      if (msUntilExpiry <= 0) {
-        output.warn('Token has expired');
-        output.hint('Run "vizzly login" to refresh your authentication');
-      } else if (daysUntilExpiry > 0) {
-        output.hint(`Token expires in ${daysUntilExpiry} day${daysUntilExpiry !== 1 ? 's' : ''} (${expiresAt.toLocaleDateString()})`);
-      } else if (hoursUntilExpiry > 0) {
-        output.hint(`Token expires in ${hoursUntilExpiry} hour${hoursUntilExpiry !== 1 ? 's' : ''}`);
-      } else if (minutesUntilExpiry > 0) {
-        output.hint(`Token expires in ${minutesUntilExpiry} minute${minutesUntilExpiry !== 1 ? 's' : ''}`);
+      let expiry = getTokenExpiryStatus(auth.expiresAt);
+      if (expiry.level === 'warn') {
+        output.warn(expiry.message);
       } else {
-        output.warn('Token expires in less than a minute');
-        output.hint('Run "vizzly login" to refresh your authentication');
+        output.hint(expiry.message);
+      }
+      if (expiry.refreshHint) {
+        output.hint(expiry.refreshHint);
       }
       if (globalOptions.verbose) {
-        output.hint(`Token expires at: ${expiresAt.toISOString()}`);
+        output.hint(`Token expires at: ${new Date(auth.expiresAt).toISOString()}`);
       }
     }
     output.cleanup();
@@ -138,10 +175,11 @@ export async function whoamiCommand(options = {}, globalOptions = {}) {
         output.hint('Run "vizzly login" to authenticate again');
       }
       output.cleanup();
-      process.exit(1);
+      exit(1);
     } else {
       output.error('Failed to get user information', error);
-      process.exit(1);
+      output.cleanup();
+      exit(1);
     }
   }
 }
@@ -151,7 +189,7 @@ export async function whoamiCommand(options = {}, globalOptions = {}) {
  * @param {Object} options - Command options
  */
 export function validateWhoamiOptions() {
-  const errors = [];
+  let errors = [];
 
   // No specific validation needed for whoami command
 

package/dist/config/core.js

@@ -29,7 +29,8 @@ export const CONFIG_DEFAULTS = {
     timeout: 30000
   },
   comparison: {
-    threshold: 2.0
+    threshold: 2.0,
+    minClusterSize: 2
   },
   tdd: {
     openReport: false
@@ -91,6 +92,23 @@ export function validateWriteScope(scope) {
 // Deep Merge
 // ============================================================================
 
+function isPlainConfigObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value);
+}
+function cloneConfigValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(cloneConfigValue);
+  }
+  if (isPlainConfigObject(value)) {
+    let cloned = {};
+    for (let key of Object.keys(value)) {
+      cloned[key] = cloneConfigValue(value[key]);
+    }
+    return cloned;
+  }
+  return value;
+}
+
 /**
  * Deep merge two objects
  * @param {Object} target - Target object
@@ -98,18 +116,16 @@ export function validateWriteScope(scope) {
  * @returns {Object} Merged object (new object, inputs not mutated)
  */
 export function deepMerge(target, source) {
-  let output = {
-    ...target
-  };
+  let output = cloneConfigValue(target);
   for (let key of Object.keys(source)) {
-    if (source[key] && typeof source[key] === 'object' && !Array.isArray(source[key])) {
-      if (target[key] && typeof target[key] === 'object' && !Array.isArray(target[key])) {
+    if (isPlainConfigObject(source[key])) {
+      if (isPlainConfigObject(target[key])) {
         output[key] = deepMerge(target[key], source[key]);
       } else {
-        output[key] = source[key];
+        output[key] = cloneConfigValue(source[key]);
       }
     } else {
-      output[key] = source[key];
+      output[key] = cloneConfigValue(source[key]);
     }
   }
   return output;
@@ -125,11 +141,18 @@ export function deepMerge(target, source) {
  * @returns {Object} The value if it's an object, empty object otherwise
  */
 function ensureObject(value) {
-  if (value && typeof value === 'object' && !Array.isArray(value)) {
+  if (isPlainConfigObject(value)) {
     return value;
   }
   return {};
 }
+function applyConfigLayer(config, sources, layer, sourceName) {
+  let merged = deepMerge(config, layer);
+  for (let key of Object.keys(layer)) {
+    sources[key] = sourceName;
+  }
+  return merged;
+}
 
 /**
  * Build merged config from layers with source tracking
@@ -148,36 +171,14 @@ export function buildMergedConfig({
   let safeProjectConfig = ensureObject(projectConfig);
   let safeGlobalConfig = ensureObject(globalConfig);
   let safeEnvOverrides = ensureObject(envOverrides);
-  let mergedConfig = {};
+  let mergedConfig = cloneConfigValue(CONFIG_DEFAULTS);
   let sources = {};
-
-  // Layer 1: Defaults
   for (let key of Object.keys(CONFIG_DEFAULTS)) {
-    mergedConfig[key] = CONFIG_DEFAULTS[key];
     sources[key] = 'default';
   }
-
-  // Layer 2: Global config (auth, project mappings, user preferences)
-  if (safeGlobalConfig.auth) {
-    mergedConfig.auth = safeGlobalConfig.auth;
-    sources.auth = 'global';
-  }
-  if (safeGlobalConfig.projects) {
-    mergedConfig.projects = safeGlobalConfig.projects;
-    sources.projects = 'global';
-  }
-
-  // Layer 3: Project config file
-  for (let key of Object.keys(safeProjectConfig)) {
-    mergedConfig[key] = safeProjectConfig[key];
-    sources[key] = 'project';
-  }
-
-  // Layer 4: Environment variables
-  for (let key of Object.keys(safeEnvOverrides)) {
-    mergedConfig[key] = safeEnvOverrides[key];
-    sources[key] = 'env';
-  }
+  mergedConfig = applyConfigLayer(mergedConfig, sources, safeGlobalConfig, 'global');
+  mergedConfig = applyConfigLayer(mergedConfig, sources, safeProjectConfig, 'project');
+  mergedConfig = applyConfigLayer(mergedConfig, sources, safeEnvOverrides, 'env');
   return {
     config: mergedConfig,
     sources

package/dist/context/local-workspace-provider.js

@@ -1,10 +1,11 @@
-import { existsSync, readFileSync } from 'node:fs';
+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';
 let LOCAL_CONTEXT_SOURCE = 'local_workspace';
 let DEFAULT_LOCAL_REVIEW_QUEUE_LIMIT = 50;
 function readJsonIfExists(path) {
-  if (!existsSync(path)) {
+  if (!defaultExistsSync(path)) {
     return null;
   }
   try {
@@ -72,7 +73,7 @@ function resolveAssetReference(assetPath, snapshot) {
   if (!assetPath) {
     return null;
   }
-  if (/^https?:\/\//.test(assetPath) || isAbsolute(assetPath)) {
+  if (/^https?:\/\//.test(assetPath)) {
     return assetPath;
   }
   if (assetPath.startsWith('/images/')) {
@@ -81,6 +82,9 @@ function resolveAssetReference(assetPath, snapshot) {
     }
     return join(snapshot.vizzlyDir, assetPath.replace('/images/', ''));
   }
+  if (isAbsolute(assetPath)) {
+    return assetPath;
+  }
   return assetPath;
 }
 function normalizeConfirmedRegions(regions = []) {
@@ -149,6 +153,71 @@ function buildBuildSnapshot(snapshot) {
     created_at: snapshot.session?.createdAt || null
   };
 }
+function buildBaselineSnapshot(snapshot) {
+  let metadata = snapshot.baselineMetadata;
+  if (!metadata) {
+    return {
+      selected: null,
+      selection_reason: 'no_local_baseline_metadata',
+      comparison_baseline_build_ids: []
+    };
+  }
+  return {
+    selected: {
+      id: metadata.buildId || 'local-baseline',
+      name: metadata.buildName || metadata.buildId || 'Local TDD Baseline',
+      branch: metadata.branch || 'local',
+      commit_sha: metadata.buildInfo?.commitSha || null,
+      commit_message: metadata.buildInfo?.commitMessage || null,
+      approval_status: metadata.buildInfo?.approvalStatus || 'approved',
+      status: metadata.buildInfo?.completedAt ? 'completed' : 'local',
+      created_at: metadata.createdAt || null,
+      completed_at: metadata.buildInfo?.completedAt || null
+    },
+    selection_reason: 'local_workspace_baseline_metadata',
+    comparison_baseline_build_ids: metadata.buildId ? [metadata.buildId] : []
+  };
+}
+function buildReviewState(build, reviewSummary) {
+  let reasons = [];
+  if (build.approval_status === 'pending') {
+    reasons.push('build_pending_approval');
+  }
+  if (reviewSummary.pending > 0) {
+    reasons.push('comparisons_need_review');
+  }
+  return {
+    needs_review: reasons.length > 0,
+    reasons,
+    pending_comparisons: reviewSummary.pending,
+    unresolved_comments: 0
+  };
+}
+function mapLocalScreenshot(snapshot, comparison) {
+  let mapped = mapLocalComparison(snapshot, comparison);
+  let baselineBuildId = snapshot.baselineMetadata?.buildId || null;
+  return {
+    id: mapped.screenshot.id,
+    name: mapped.screenshot.name,
+    browser: mapped.screenshot.browser,
+    viewport: {
+      width: mapped.screenshot.viewport_width,
+      height: mapped.screenshot.viewport_height
+    },
+    url: mapped.screenshot.original_url,
+    baseline: mapped.baseline ? {
+      id: mapped.baseline.id,
+      build_id: baselineBuildId,
+      name: mapped.baseline.name,
+      browser: mapped.baseline.browser,
+      viewport: {
+        width: mapped.baseline.viewport_width,
+        height: mapped.baseline.viewport_height
+      },
+      url: mapped.baseline.original_url
+    } : null
+  };
+}
 function mapLocalComparison(snapshot, comparison) {
   let details = snapshot.comparisonDetails[comparison.id] || {};
   let comparisonName = comparison.originalName || comparison.name;
@@ -156,12 +225,19 @@ function mapLocalComparison(snapshot, comparison) {
   let hotspotAnalysis = buildHotspotAnalysis(snapshot, comparisonName, details);
   let properties = comparison.properties || {};
   let buildSnapshot = buildBuildSnapshot(snapshot);
+  let result = mapComparisonResult(comparison.status);
+  let approvalStatus = mapApprovalStatus(comparison.status);
+  let baselineBuildId = snapshot.baselineMetadata?.buildId || null;
+  let diffImageUrl = resolveAssetReference(comparison.diff, snapshot);
+  let diffRegions = details.diffClusters || [];
   return {
     id: comparison.id,
     name: comparisonName,
+    screenshot_name: comparisonName,
     status: comparison.status,
-    result: mapComparisonResult(comparison.status),
-    approval_status: mapApprovalStatus(comparison.status),
+    result,
+    approval_status: approvalStatus,
+    needs_review: approvalStatus === 'pending' && ['changed', 'new'].includes(result),
     build_id: buildSnapshot.id,
     build_name: buildSnapshot.name,
     build_branch: buildSnapshot.branch,
@@ -181,17 +257,33 @@ function mapLocalComparison(snapshot, comparison) {
     },
     baseline: comparison.baseline ? {
       id: `${comparison.id}-baseline`,
+      build_id: baselineBuildId,
       name: comparisonName,
       browser: properties.browser ?? null,
       viewport_width: properties.viewport_width ?? null,
       viewport_height: properties.viewport_height ?? null,
       original_url: resolveAssetReference(comparison.baseline, snapshot)
     } : null,
+    diff: {
+      percentage: comparison.diffPercentage ?? null,
+      changed_pixels: comparison.diffCount ?? null,
+      total_pixels: comparison.totalPixels ?? null,
+      threshold: comparison.threshold ?? null,
+      image_url: diffImageUrl,
+      regions: diffRegions,
+      cluster_metadata: diffRegions.length ? {
+        clusterCount: diffRegions.length,
+        local_workspace: true
+      } : null,
+      fingerprint_hash: null,
+      fingerprint_data: null,
+      diff_lines: []
+    },
     analysis: {
-      diff_image_url: resolveAssetReference(comparison.diff, snapshot),
-      diff_regions: details.diffClusters || [],
-      cluster_metadata: details.diffClusters ? {
-        clusterCount: details.diffClusters.length,
+      diff_image_url: diffImageUrl,
+      diff_regions: diffRegions,
+      cluster_metadata: diffRegions.length ? {
+        clusterCount: diffRegions.length,
         local_workspace: true
       } : null,
       diff_lines: null,
@@ -219,9 +311,17 @@ function createLocalWorkspaceError(message) {
   error.code = 'LOCAL_WORKSPACE_CONTEXT';
   return error;
 }
+function createReportUrl(snapshot) {
+  let reportPath = join(snapshot.vizzlyDir, 'report', 'index.html');
+  if (!snapshot.existsSync(reportPath)) {
+    return null;
+  }
+  return pathToFileURL(reportPath).href;
+}
 export function createLocalWorkspaceContextProvider(options = {}, deps = {}) {
   let projectRoot = options.projectRoot || process.cwd();
   let readJson = deps.readJsonIfExists || readJsonIfExists;
+  let existsSync = deps.existsSync || defaultExistsSync;
   let snapshotCache = null;
   function loadSnapshot() {
     if (snapshotCache) {
@@ -231,6 +331,7 @@ export function createLocalWorkspaceContextProvider(options = {}, deps = {}) {
     snapshotCache = {
       projectRoot,
       vizzlyDir,
+      existsSync,
       serverInfo: readJson(join(vizzlyDir, 'server.json')),
       session: readJson(join(vizzlyDir, 'session.json')),
       reportData: normalizeReportData(readJson(join(vizzlyDir, 'report-data.json')) || createEmptyReportData()),
@@ -278,14 +379,20 @@ export function createLocalWorkspaceContextProvider(options = {}, deps = {}) {
     return buildLocalScope(projectRoot);
   }
   function createBuildLinks(snapshot) {
+    let reportUrl = createReportUrl(snapshot);
     if (!snapshot.serverInfo?.port) {
-      return {};
+      return reportUrl ? {
+        report_url: reportUrl
+      } : {};
     }
     let buildId = buildBuildSnapshot(snapshot).id;
     return {
       build_url: `http://127.0.0.1:${snapshot.serverInfo.port}/builds`,
       comparison_url_prefix: `http://127.0.0.1:${snapshot.serverInfo.port}/comparison`,
-      current_build_id: buildId
+      current_build_id: buildId,
+      ...(reportUrl ? {
+        report_url: reportUrl
+      } : {})
     };
   }
   function getBuildContext(buildId) {
@@ -295,25 +402,38 @@ export function createLocalWorkspaceContextProvider(options = {}, deps = {}) {
       throw createLocalWorkspaceError(`Local workspace context is only available for the active session build (${resolvedBuild.id})`);
     }
     let mappedComparisons = snapshot.reportData.comparisons.map(comparison => mapLocalComparison(snapshot, comparison));
+    let mappedScreenshots = snapshot.reportData.comparisons.map(comparison => mapLocalScreenshot(snapshot, comparison));
     let reviewSummary = buildReviewSummary(snapshot.reportData.comparisons);
+    let reviewState = buildReviewState(resolvedBuild, reviewSummary);
     return {
       resource: 'build_context',
       source: LOCAL_CONTEXT_SOURCE,
       scope: createScope(),
       build: resolvedBuild,
+      baseline: buildBaselineSnapshot(snapshot),
+      status: reviewState,
       summary: {
         comparisons: {
           total: mappedComparisons.length,
           changed: mappedComparisons.filter(comparison => comparison.result === 'changed').length,
           new: mappedComparisons.filter(comparison => comparison.result === 'new').length
         },
-        review: reviewSummary
+        review: reviewSummary,
+        comments: {
+          build: 0,
+          screenshot: 0
+        }
       },
       review: {
         comments: [],
         assignments: []
       },
+      screenshots: mappedScreenshots,
       comparisons: mappedComparisons,
+      comments: {
+        build: [],
+        screenshot_count: 0
+      },
       links: createBuildLinks(snapshot)
     };
   }

package/dist/context/provider-resolver.js

@@ -4,7 +4,8 @@ export function resolveContextSource(options = {}, deps = {}) {
     requestedSource = 'auto',
     command,
     target = null,
-    projectRoot = process.cwd()
+    projectRoot = process.cwd(),
+    hasCloudScope = false
   } = options;
   let {
     createLocalWorkspaceContextProvider = defaultCreateLocalWorkspaceContextProvider
@@ -25,6 +26,9 @@ export function resolveContextSource(options = {}, deps = {}) {
     }
     return 'local';
   }
+  if (hasCloudScope) {
+    return 'cloud';
+  }
   if (isLocalAvailable && (localSnapshot == null ? localProvider.canHandle(command, target) : localProvider.canHandle(command, target, localSnapshot))) {
     return 'local';
   }

package/dist/index.js

@@ -11,13 +11,14 @@ import 'dotenv/config';
 // Client exports for convenience
 export { configure, setEnabled, vizzlyScreenshot } from './client/index.js';
 // Errors
-export { UploadError } from './errors/vizzly-error.js';
+export { AuthError, BuildError, ConfigError, NetworkError, ScreenshotError, TimeoutError, UploadError, ValidationError, VizzlyError } from './errors/vizzly-error.js';
+export { createPluginServices } from './plugin-api.js';
 // Primary SDK export
-export { createVizzly } from './sdk/index.js';
+export { createVizzly, VizzlySDK } from './sdk/index.js';
 export { createServices } from './services/index.js';
-// Core services (for advanced usage)
-export { createUploader } from './services/uploader.js';
 export { createTDDService } from './tdd/tdd-service.js';
+// Core services (for advanced usage)
+export { createUploader } from './uploader/index.js';
 // Configuration helper
 export { defineConfig } from './utils/config-helpers.js';
 // Utilities