@vizzly-testing/cli 0.30.0 → 0.32.0

package/dist/utils/config-loader.js

@@ -1,45 +1,15 @@
 import { resolve } from 'node:path';
 import { cosmiconfigSync } from 'cosmiconfig';
+import { CONFIG_DEFAULTS, deepMerge } from '../config/core.js';
 import { validateVizzlyConfigWithDefaults } from './config-schema.js';
 import { getApiToken, getApiUrl, getBuildName, getParallelId } from './environment-config.js';
 import { getAccessToken } from './global-config.js';
 import * as output from './output.js';
-const DEFAULT_CONFIG = {
-  // API Configuration
-  apiKey: undefined,
-  // Will be set from env, global config, or CLI overrides
-  apiUrl: getApiUrl(),
-  // Server Configuration (for run command)
-  server: {
-    port: 47392,
-    timeout: 30000
-  },
-  // Build Configuration
-  build: {
-    name: 'Build {timestamp}',
-    environment: 'test'
-  },
-  // Upload Configuration (for upload command)
-  upload: {
-    screenshotsDir: './screenshots',
-    batchSize: 10,
-    timeout: 30000
-  },
-  // Comparison Configuration (CIEDE2000 Delta E: 0=exact, 1=JND, 2=recommended)
-  comparison: {
-    threshold: 2.0
-  },
-  // TDD Configuration
-  tdd: {
-    openReport: false // Whether to auto-open HTML report in browser
-  },
-  // Plugins
-  plugins: []
-};
+import { getActiveProjectLink } from './project-link-store.js';
 export async function loadConfig(configPath = null, cliOverrides = {}) {
   // 1. Load from config file using cosmiconfig
-  const explorer = cosmiconfigSync('vizzly');
-  const result = configPath ? explorer.load(configPath) : explorer.search();
+  let explorer = cosmiconfigSync('vizzly');
+  let result = configPath ? explorer.load(configPath) : explorer.search();
   let fileConfig = {};
   if (result?.config) {
     // Handle ESM default export (cosmiconfig wraps it in { default: {...} })
@@ -47,28 +17,10 @@ export async function loadConfig(configPath = null, cliOverrides = {}) {
   }
 
   // 2. Validate config file using Zod schema
-  const validatedFileConfig = validateVizzlyConfigWithDefaults(fileConfig);
+  let validatedFileConfig = validateVizzlyConfigWithDefaults(fileConfig);
 
   // Create a proper clone of the default config to avoid shared object references
-  const config = {
-    ...DEFAULT_CONFIG,
-    server: {
-      ...DEFAULT_CONFIG.server
-    },
-    build: {
-      ...DEFAULT_CONFIG.build
-    },
-    upload: {
-      ...DEFAULT_CONFIG.upload
-    },
-    comparison: {
-      ...DEFAULT_CONFIG.comparison
-    },
-    tdd: {
-      ...DEFAULT_CONFIG.tdd
-    },
-    plugins: [...DEFAULT_CONFIG.plugins]
-  };
+  let config = deepMerge(CONFIG_DEFAULTS, {});
 
   // Merge validated file config
   mergeConfig(config, validatedFileConfig);
@@ -95,16 +47,35 @@ export async function loadConfig(configPath = null, cliOverrides = {}) {
   }
   applyCLIOverrides(config, cliOverrides);
 
-  // 5. Fall back to user auth token if no other token found
-  // This enables interactive commands (builds, comparisons, approve, etc.)
-  // to work without a project token when the user is logged in
+  // 5. Fall back to a linked project token for cloud upload commands.
   if (!config.apiKey) {
-    let userToken = await getAccessToken();
-    if (userToken) {
-      config.apiKey = userToken;
-      output.debug('config', 'using token from user login');
+    let linkedProject = await getActiveProjectLink({
+      apiUrl: config.apiUrl
+    });
+    if (linkedProject?.token) {
+      config.apiKey = linkedProject.token;
+      config.linkedProject = {
+        account: linkedProject.account,
+        apiUrl: linkedProject.apiUrl,
+        organizationSlug: linkedProject.organizationSlug,
+        organizationName: linkedProject.organizationName,
+        projectSlug: linkedProject.projectSlug,
+        projectName: linkedProject.projectName,
+        tokenId: linkedProject.tokenId,
+        tokenPrefix: linkedProject.tokenPrefix,
+        expiresAt: linkedProject.expiresAt,
+        storage: linkedProject.storage
+      };
+      output.debug('config', 'using linked project token');
     }
   }
+
+  // 6. Keep user auth separate from upload credentials.
+  let userToken = await getAccessToken();
+  if (userToken) {
+    config.userToken = userToken;
+    output.debug('config', 'using user login for user-authenticated commands');
+  }
   return config;
 }
 
@@ -126,19 +97,22 @@ function applyCLIOverrides(config, cliOverrides = {}) {
   if (cliOverrides.parallelId) config.parallelId = cliOverrides.parallelId;
 
   // Server overrides
-  if (cliOverrides.port) config.server.port = parseInt(cliOverrides.port, 10);
-  if (cliOverrides.timeout) config.server.timeout = parseInt(cliOverrides.timeout, 10);
+  if (cliOverrides.port) config.server.port = Number(cliOverrides.port);
+  if (cliOverrides.timeout) config.server.timeout = Number(cliOverrides.timeout);
 
   // Upload overrides
   if (cliOverrides.batchSize !== undefined) {
-    config.upload.batchSize = parseInt(cliOverrides.batchSize, 10);
+    config.upload.batchSize = Number(cliOverrides.batchSize);
   }
   if (cliOverrides.uploadTimeout !== undefined) {
-    config.upload.timeout = parseInt(cliOverrides.uploadTimeout, 10);
+    config.upload.timeout = Number(cliOverrides.uploadTimeout);
   }
 
   // Comparison overrides
   if (cliOverrides.threshold !== undefined) config.comparison.threshold = cliOverrides.threshold;
+  if (cliOverrides.minClusterSize !== undefined) {
+    config.comparison.minClusterSize = Number(cliOverrides.minClusterSize);
+  }
 
   // Baseline overrides
   if (cliOverrides.baselineBuild) config.baselineBuildId = cliOverrides.baselineBuild;

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');
 }

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));
+}