@vizzly-testing/cli 0.29.6 → 0.31.0

package/dist/utils/config-schema.js

@@ -4,21 +4,22 @@
  */
 
 import { z } from 'zod';
+import { CONFIG_DEFAULTS } from '../config/core.js';
 
 /**
  * Server configuration schema
  */
 const serverSchema = z.object({
-  port: z.number().int().positive().default(47392),
-  timeout: z.number().int().positive().default(30000)
+  port: z.number().int().positive().default(CONFIG_DEFAULTS.server.port),
+  timeout: z.number().int().positive().default(CONFIG_DEFAULTS.server.timeout)
 });
 
 /**
  * Build configuration schema
  */
 const buildSchema = z.object({
-  name: z.string().default('Build {timestamp}'),
-  environment: z.string().default('test'),
+  name: z.string().default(CONFIG_DEFAULTS.build.name),
+  environment: z.string().default(CONFIG_DEFAULTS.build.environment),
   branch: z.string().optional(),
   commit: z.string().optional(),
   message: z.string().optional()
@@ -28,9 +29,9 @@ const buildSchema = z.object({
  * Upload configuration schema
  */
 const uploadSchema = z.object({
-  screenshotsDir: z.union([z.string(), z.array(z.string())]).default('./screenshots'),
-  batchSize: z.number().int().positive().default(10),
-  timeout: z.number().int().positive().default(30000)
+  screenshotsDir: z.union([z.string(), z.array(z.string())]).default(CONFIG_DEFAULTS.upload.screenshotsDir),
+  batchSize: z.number().int().positive().default(CONFIG_DEFAULTS.upload.batchSize),
+  timeout: z.number().int().positive().default(CONFIG_DEFAULTS.upload.timeout)
 });
 
 /**
@@ -39,15 +40,15 @@ const uploadSchema = z.object({
  * minClusterSize: pixels (1 = exact)
  */
 const comparisonSchema = z.object({
-  threshold: z.number().min(0).default(2.0),
-  minClusterSize: z.int().min(1).default(2)
+  threshold: z.number().min(0).default(CONFIG_DEFAULTS.comparison.threshold),
+  minClusterSize: z.int().min(1).default(CONFIG_DEFAULTS.comparison.minClusterSize)
 });
 
 /**
  * TDD configuration schema
  */
 const tddSchema = z.object({
-  openReport: z.boolean().default(false)
+  openReport: z.boolean().default(CONFIG_DEFAULTS.tdd.openReport)
 });
 
 /**
@@ -57,29 +58,14 @@ const tddSchema = z.object({
 export const vizzlyConfigSchema = z.object({
   // Core Vizzly config
   apiKey: z.string().optional(),
-  apiUrl: z.string().url().optional(),
-  server: serverSchema.default({
-    port: 47392,
-    timeout: 30000
-  }),
-  build: buildSchema.default({
-    name: 'Build {timestamp}',
-    environment: 'test'
-  }),
-  upload: uploadSchema.default({
-    screenshotsDir: './screenshots',
-    batchSize: 10,
-    timeout: 30000
-  }),
-  comparison: comparisonSchema.default({
-    threshold: 2.0,
-    minClusterSize: 2
-  }),
-  tdd: tddSchema.default({
-    openReport: false
-  }),
+  apiUrl: z.string().url().default(CONFIG_DEFAULTS.apiUrl),
+  server: serverSchema.default(CONFIG_DEFAULTS.server),
+  build: buildSchema.default(CONFIG_DEFAULTS.build),
+  upload: uploadSchema.default(CONFIG_DEFAULTS.upload),
+  comparison: comparisonSchema.default(CONFIG_DEFAULTS.comparison),
+  tdd: tddSchema.default(CONFIG_DEFAULTS.tdd),
   signatureProperties: z.array(z.string()).default([]),
-  plugins: z.array(z.string()).default([]),
+  plugins: z.array(z.string()).default(CONFIG_DEFAULTS.plugins),
   // Additional optional fields
   parallelId: z.string().optional(),
   baselineBuildId: z.string().optional(),
@@ -88,29 +74,7 @@ export const vizzlyConfigSchema = z.object({
   wait: z.boolean().optional(),
   allowNoToken: z.boolean().optional()
 }).passthrough() // Allow plugin-specific keys like `staticSite`, `storybook`, etc.
-.default({
-  server: {
-    port: 47392,
-    timeout: 30000
-  },
-  build: {
-    name: 'Build {timestamp}',
-    environment: 'test'
-  },
-  upload: {
-    screenshotsDir: './screenshots',
-    batchSize: 10,
-    timeout: 30000
-  },
-  comparison: {
-    threshold: 2.0,
-    minClusterSize: 2
-  },
-  tdd: {
-    openReport: false
-  },
-  plugins: []
-});
+.default(CONFIG_DEFAULTS);
 
 /**
  * Validate Vizzly configuration

package/dist/utils/fetch-utils.js

@@ -1,9 +1,16 @@
-function fetchWithTimeout(url, opts = {}, ms = 300000) {
-  const ctrl = new AbortController();
-  const id = setTimeout(() => ctrl.abort(), ms);
-  return fetch(url, {
+let defaultTimers = {
+  setTimeout,
+  clearTimeout
+};
+function fetchWithTimeout(url, opts = {}, ms = 300000, deps = {}) {
+  let fetchFn = deps.fetch || fetch;
+  let AbortControllerClass = deps.AbortController || AbortController;
+  let timers = deps.timers || defaultTimers;
+  let ctrl = new AbortControllerClass();
+  let timeoutId = timers.setTimeout(() => ctrl.abort(), ms);
+  return fetchFn(url, {
     ...opts,
     signal: ctrl.signal
-  }).finally(() => clearTimeout(id));
+  }).finally(() => timers.clearTimeout(timeoutId));
 }
 export { fetchWithTimeout };

package/dist/utils/git.js

@@ -1,15 +1,18 @@
-import { exec } from 'node:child_process';
+import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { getBranch as getCIBranch, getCommit as getCICommit, getCommitMessage as getCICommitMessage, getPullRequestNumber } from './ci-env.js';
-const execAsync = promisify(exec);
+let execFileAsync = promisify(execFile);
+async function runGit(args, cwd = process.cwd()) {
+  let {
+    stdout
+  } = await execFileAsync('git', args, {
+    cwd
+  });
+  return stdout.trim();
+}
 export async function getCommonAncestor(commit1, commit2, cwd = process.cwd()) {
   try {
-    const {
-      stdout
-    } = await execAsync(`git merge-base ${commit1} ${commit2}`, {
-      cwd
-    });
-    return stdout.trim();
+    return await runGit(['merge-base', commit1, commit2], cwd);
   } catch {
     // If merge-base fails (e.g., no common ancestor), return null
     return null;
@@ -17,24 +20,14 @@ export async function getCommonAncestor(commit1, commit2, cwd = process.cwd()) {
 }
 export async function getCurrentCommitSha(cwd = process.cwd()) {
   try {
-    const {
-      stdout
-    } = await execAsync('git rev-parse HEAD', {
-      cwd
-    });
-    return stdout.trim();
+    return await runGit(['rev-parse', 'HEAD'], cwd);
   } catch {
     return null;
   }
 }
 export async function getCurrentBranch(cwd = process.cwd()) {
   try {
-    const {
-      stdout
-    } = await execAsync('git rev-parse --abbrev-ref HEAD', {
-      cwd
-    });
-    return stdout.trim();
+    return await runGit(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
   } catch {
     // Fallback strategy: use a simple, non-recursive approach
     // to avoid circular dependency with getDefaultBranch()
@@ -48,24 +41,18 @@ export async function getCurrentBranch(cwd = process.cwd()) {
  */
 async function getCurrentBranchFallback(cwd = process.cwd()) {
   // Try common default branches in order of likelihood
-  const commonBranches = ['main', 'master', 'develop', 'dev'];
-  for (const branch of commonBranches) {
+  let commonBranches = ['main', 'master', 'develop', 'dev'];
+  for (let branch of commonBranches) {
     try {
-      await execAsync(`git show-ref --verify --quiet refs/heads/${branch}`, {
-        cwd
-      });
+      await runGit(['show-ref', '--verify', '--quiet', `refs/heads/${branch}`], cwd);
       return branch;
     } catch {}
   }
 
   // If none of the common branches exist, try to get any local branch
   try {
-    const {
-      stdout
-    } = await execAsync('git branch --format="%(refname:short)"', {
-      cwd
-    });
-    const branches = stdout.trim().split('\n').filter(b => b.trim());
+    let stdout = await runGit(['branch', '--format=%(refname:short)'], cwd);
+    let branches = stdout.trim().split('\n').filter(b => b.trim());
     if (branches.length > 0) {
       return branches[0]; // Return the first available branch
     }
@@ -80,35 +67,22 @@ async function getCurrentBranchFallback(cwd = process.cwd()) {
 export async function getDefaultBranch(cwd = process.cwd()) {
   try {
     // Try to get the default branch from remote origin
-    const {
-      stdout
-    } = await execAsync('git symbolic-ref refs/remotes/origin/HEAD', {
-      cwd
-    });
-    const defaultBranch = stdout.trim().replace('refs/remotes/origin/', '');
+    let stdout = await runGit(['symbolic-ref', 'refs/remotes/origin/HEAD'], cwd);
+    let defaultBranch = stdout.replace('refs/remotes/origin/', '');
     return defaultBranch;
   } catch {
     try {
       // Fallback: try to get default branch from git config
-      const {
-        stdout
-      } = await execAsync('git config --get init.defaultBranch', {
-        cwd
-      });
-      return stdout.trim();
+      return await runGit(['config', '--get', 'init.defaultBranch'], cwd);
     } catch {
       try {
         // Fallback: check if main exists
-        await execAsync('git show-ref --verify --quiet refs/heads/main', {
-          cwd
-        });
+        await runGit(['show-ref', '--verify', '--quiet', 'refs/heads/main'], cwd);
         return 'main';
       } catch {
         try {
           // Fallback: check if master exists
-          await execAsync('git show-ref --verify --quiet refs/heads/master', {
-            cwd
-          });
+          await runGit(['show-ref', '--verify', '--quiet', 'refs/heads/master'], cwd);
           return 'master';
         } catch {
           // If we're not in a git repo or no branches exist, return null
@@ -120,7 +94,7 @@ export async function getDefaultBranch(cwd = process.cwd()) {
   }
 }
 export function generateBuildName() {
-  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  let timestamp = new Date().toISOString().replace(/[:.]/g, '-');
   return `Build ${timestamp}`;
 }
 
@@ -131,12 +105,7 @@ export function generateBuildName() {
  */
 export async function getCommitMessage(cwd = process.cwd()) {
   try {
-    const {
-      stdout
-    } = await execAsync('git log -1 --pretty=%B', {
-      cwd
-    });
-    return stdout.trim();
+    return await runGit(['log', '-1', '--pretty=%B'], cwd);
   } catch {
     return null;
   }
@@ -152,7 +121,7 @@ export async function detectCommitMessage(override = null, cwd = process.cwd())
   if (override) return override;
 
   // Try CI environment variables first
-  const ciCommitMessage = getCICommitMessage();
+  let ciCommitMessage = getCICommitMessage();
   if (ciCommitMessage) return ciCommitMessage;
 
   // Fallback to regular git log
@@ -166,9 +135,7 @@ export async function detectCommitMessage(override = null, cwd = process.cwd())
  */
 export async function isGitRepository(cwd = process.cwd()) {
   try {
-    await execAsync('git rev-parse --git-dir', {
-      cwd
-    });
+    await runGit(['rev-parse', '--git-dir'], cwd);
     return true;
   } catch {
     return false;
@@ -182,12 +149,8 @@ export async function isGitRepository(cwd = process.cwd()) {
  */
 export async function getGitStatus(cwd = process.cwd()) {
   try {
-    const {
-      stdout
-    } = await execAsync('git status --porcelain', {
-      cwd
-    });
-    const changes = stdout.trim().split('\n').filter(line => line);
+    let stdout = await runGit(['status', '--porcelain'], cwd);
+    let changes = stdout.trim().split('\n').filter(line => line);
     return {
       hasChanges: changes.length > 0,
       changes: changes.map(line => ({
@@ -210,11 +173,11 @@ export async function detectBranch(override = null, cwd = process.cwd()) {
   if (override) return override;
 
   // Try CI environment variables first
-  const ciBranch = getCIBranch();
+  let ciBranch = getCIBranch();
   if (ciBranch) return ciBranch;
 
   // Fallback to git command when no CI environment variables
-  const currentBranch = await getCurrentBranch(cwd);
+  let currentBranch = await getCurrentBranch(cwd);
   return currentBranch || 'unknown';
 }
 
@@ -228,7 +191,7 @@ export async function detectCommit(override = null, cwd = process.cwd()) {
   if (override) return override;
 
   // Try CI environment variables first
-  const ciCommit = getCICommit();
+  let ciCommit = getCICommit();
   if (ciCommit) return ciCommit;
 
   // Fallback to git command when no CI environment variables
@@ -243,10 +206,10 @@ export async function detectCommit(override = null, cwd = process.cwd()) {
  */
 export async function generateBuildNameWithGit(override = null, cwd = process.cwd()) {
   if (override) return override;
-  const branch = await getCurrentBranch(cwd);
-  const shortSha = await getCurrentCommitSha(cwd);
+  let branch = await getCurrentBranch(cwd);
+  let shortSha = await getCurrentCommitSha(cwd);
   if (branch && shortSha) {
-    const shortCommit = shortSha.substring(0, 7);
+    let shortCommit = shortSha.substring(0, 7);
     return `${branch}-${shortCommit}`;
   }
   return generateBuildName();

package/dist/utils/global-config.js

@@ -8,6 +8,25 @@ import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import * as output from './output.js';
+export function expandHomePath(path) {
+  if (!path) {
+    return path;
+  }
+  let home = homedir();
+  if (path === '$HOME') {
+    return home;
+  }
+  if (path.startsWith('$HOME/')) {
+    return join(home, path.slice('$HOME/'.length));
+  }
+  if (path === '~') {
+    return home;
+  }
+  if (path.startsWith('~/')) {
+    return join(home, path.slice(2));
+  }
+  return path;
+}
 
 /**
  * Get the path to the global Vizzly directory
@@ -15,7 +34,7 @@ import * as output from './output.js';
  */
 export function getGlobalConfigDir() {
   if (process.env.VIZZLY_HOME) {
-    return process.env.VIZZLY_HOME;
+    return expandHomePath(process.env.VIZZLY_HOME);
   }
   return join(homedir(), '.vizzly');
 }
@@ -132,7 +151,7 @@ export async function getUserPath() {
  */
 export async function getAuthTokens() {
   const config = await loadGlobalConfig();
-  if (!config.auth || !config.auth.accessToken) {
+  if (!config.auth?.accessToken) {
     return null;
   }
   return config.auth;
@@ -170,7 +189,7 @@ export async function clearAuthTokens() {
  */
 export async function hasValidTokens() {
   const auth = await getAuthTokens();
-  if (!auth || !auth.accessToken) {
+  if (!auth?.accessToken) {
     return false;
   }
 

package/dist/utils/output.js

@@ -603,15 +603,27 @@ function getComponentColor(component) {
   };
   return componentColors[component] || colors.brand.info;
 }
-export function debug(component, message, data = {}) {
-  if (!shouldLog('debug')) return;
-
-  // Handle legacy calls: debug('message') or debug('message', {data})
+export function normalizeDebugArgs(component, message, data = {}) {
   if (typeof message === 'object' || message === undefined) {
-    data = message || {};
-    message = component;
-    component = null;
+    return {
+      component: null,
+      message: component,
+      data: message || {}
+    };
   }
+  return {
+    component,
+    message,
+    data
+  };
+}
+export function debug(component, message, data = {}) {
+  if (!shouldLog('debug')) return;
+  ({
+    component,
+    message,
+    data
+  } = normalizeDebugArgs(component, message, data));
   let elapsed = getElapsedTime();
   if (config.json) {
     console.error(JSON.stringify({

package/dist/utils/patterns.js

@@ -0,0 +1,14 @@
+export function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+export function createWildcardMatcher(pattern, options = {}) {
+  let {
+    anchored = false
+  } = options;
+  let regexPattern = String(pattern).split('*').map(escapeRegExp).join('.*');
+  if (anchored) {
+    regexPattern = `^${regexPattern}$`;
+  }
+  let regex = new RegExp(regexPattern, 'i');
+  return value => regex.test(String(value));
+}

package/dist/utils/project-link-store.js

@@ -0,0 +1,105 @@
+import { loadGlobalConfig, saveGlobalConfig } from './global-config.js';
+import { deleteSecret as defaultDeleteSecret, getSecret as defaultGetSecret, saveSecret as defaultSaveSecret } from './secret-store.js';
+export function buildProjectLinkAccount({
+  apiUrl,
+  organizationSlug,
+  projectSlug
+}) {
+  return `${apiUrl || 'https://app.vizzly.dev'}|${organizationSlug}/${projectSlug}`;
+}
+function getProjectLinkConfig(config) {
+  return config.projectLink || {
+    active: null,
+    links: {}
+  };
+}
+export async function saveProjectLink(link, deps = {}) {
+  let {
+    loadConfig = loadGlobalConfig,
+    saveConfig = saveGlobalConfig,
+    saveSecret = defaultSaveSecret,
+    now = () => new Date()
+  } = deps;
+  let config = await loadConfig();
+  let projectLink = getProjectLinkConfig(config);
+  let account = buildProjectLinkAccount(link);
+  let storedInKeychain = await saveSecret(account, link.token);
+  projectLink.active = account;
+  projectLink.links = {
+    ...projectLink.links,
+    [account]: {
+      apiUrl: link.apiUrl,
+      organizationSlug: link.organizationSlug,
+      organizationName: link.organizationName,
+      projectSlug: link.projectSlug,
+      projectName: link.projectName,
+      tokenId: link.tokenId,
+      tokenPrefix: link.tokenPrefix,
+      expiresAt: link.expiresAt || null,
+      createdAt: link.createdAt || now().toISOString(),
+      storage: storedInKeychain ? 'keychain' : 'file',
+      token: storedInKeychain ? undefined : link.token
+    }
+  };
+  config.projectLink = projectLink;
+  await saveConfig(config);
+  return {
+    ...projectLink.links[account],
+    account,
+    token: link.token
+  };
+}
+export async function getActiveProjectLink(options = {}, deps = {}) {
+  let {
+    loadConfig = loadGlobalConfig,
+    getSecret = defaultGetSecret
+  } = deps;
+  let config = await loadConfig();
+  let projectLink = getProjectLinkConfig(config);
+  let account = options.account || projectLink.active;
+  let link = account ? projectLink.links?.[account] : null;
+  if (!link && options.apiUrl && options.organizationSlug && options.projectSlug) {
+    account = buildProjectLinkAccount(options);
+    link = projectLink.links?.[account] || null;
+  }
+  if (!link) {
+    return null;
+  }
+  if (options.apiUrl && link.apiUrl && link.apiUrl !== options.apiUrl) {
+    return null;
+  }
+  let token = link.storage === 'keychain' ? await getSecret(account) : link.token;
+  if (!token) {
+    return null;
+  }
+  return {
+    ...link,
+    account,
+    token
+  };
+}
+export async function clearActiveProjectLink(deps = {}) {
+  let {
+    loadConfig = loadGlobalConfig,
+    saveConfig = saveGlobalConfig,
+    deleteSecret = defaultDeleteSecret
+  } = deps;
+  let config = await loadConfig();
+  let projectLink = getProjectLinkConfig(config);
+  let account = projectLink.active;
+  if (!account || !projectLink.links?.[account]) {
+    return null;
+  }
+  let link = projectLink.links[account];
+  if (link.storage === 'keychain') {
+    await deleteSecret(account);
+  }
+  delete projectLink.links[account];
+  projectLink.active = null;
+  config.projectLink = projectLink;
+  await saveConfig(config);
+  return {
+    ...link,
+    account
+  };
+}

package/dist/utils/report-data.js

@@ -0,0 +1,31 @@
+/**
+ * Ensure each comparison has a timestamp for image cache-busting.
+ */
+export function normalizeReportData(reportData) {
+  if (!reportData || !Array.isArray(reportData.comparisons)) {
+    return reportData;
+  }
+  let needsNormalization = reportData.comparisons.some(comparison => comparison && comparison.timestamp == null);
+  if (!needsNormalization) {
+    return reportData;
+  }
+  let fallbackTimestamp = reportData.timestamp ?? Date.now();
+  let comparisons = reportData.comparisons.map(comparison => normalizeComparisonUpdate(comparison, fallbackTimestamp));
+  return {
+    ...reportData,
+    comparisons
+  };
+}
+
+/**
+ * Ensure a single comparison includes a timestamp.
+ */
+export function normalizeComparisonUpdate(comparison, fallbackTimestamp) {
+  if (!comparison || comparison.timestamp != null) {
+    return comparison;
+  }
+  return {
+    ...comparison,
+    timestamp: fallbackTimestamp ?? Date.now()
+  };
+}

package/dist/utils/screenshot-options.js

@@ -0,0 +1,28 @@
+/**
+ * Normalize screenshot SDK options into the properties payload consumed by the
+ * local TDD server and cloud-compatible comparison path.
+ */
+export function createScreenshotProperties(options = {}) {
+  let {
+    buildId: _buildId,
+    properties = {},
+    threshold,
+    minClusterSize,
+    fullPage,
+    ...topLevelProperties
+  } = options;
+  let normalizedProperties = {
+    ...topLevelProperties,
+    ...properties
+  };
+  if (threshold !== undefined) {
+    normalizedProperties.threshold = threshold;
+  }
+  if (minClusterSize !== undefined) {
+    normalizedProperties.minClusterSize = minClusterSize;
+  }
+  if (fullPage !== undefined) {
+    normalizedProperties.fullPage = fullPage;
+  }
+  return normalizedProperties;
+}