@vizzly-testing/cli 0.30.0 → 0.31.0

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

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

package/dist/utils/secret-store.js

@@ -0,0 +1,65 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+let execFileAsync = promisify(execFile);
+let KEYCHAIN_SERVICE = 'vizzly-cli';
+export function canUseKeychain(platform = process.platform, env = process.env) {
+  return platform === 'darwin' && env.VIZZLY_DISABLE_KEYCHAIN !== 'true';
+}
+export async function saveSecret(account, secret, options = {}) {
+  let {
+    service = KEYCHAIN_SERVICE,
+    platform = process.platform,
+    env = process.env,
+    execFileFn = execFileAsync
+  } = options;
+  if (!canUseKeychain(platform, env)) {
+    return false;
+  }
+  try {
+    try {
+      await execFileFn('security', ['delete-generic-password', '-s', service, '-a', account]);
+    } catch {
+      // Missing secrets are fine; add-generic-password creates the current value.
+    }
+    await execFileFn('security', ['add-generic-password', '-s', service, '-a', account, '-w', secret, '-U']);
+    return true;
+  } catch {
+    return false;
+  }
+}
+export async function getSecret(account, options = {}) {
+  let {
+    service = KEYCHAIN_SERVICE,
+    platform = process.platform,
+    env = process.env,
+    execFileFn = execFileAsync
+  } = options;
+  if (!canUseKeychain(platform, env)) {
+    return null;
+  }
+  try {
+    let {
+      stdout
+    } = await execFileFn('security', ['find-generic-password', '-s', service, '-a', account, '-w']);
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+export async function deleteSecret(account, options = {}) {
+  let {
+    service = KEYCHAIN_SERVICE,
+    platform = process.platform,
+    env = process.env,
+    execFileFn = execFileAsync
+  } = options;
+  if (!canUseKeychain(platform, env)) {
+    return false;
+  }
+  try {
+    await execFileFn('security', ['delete-generic-password', '-s', service, '-a', account]);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "@vizzly-testing/cli",
-  "version": "0.30.0",
-  "description": "Visual review platform for UI developers and designers",
+  "version": "0.31.0",
+  "description": "Visual review for agents and teams",
   "keywords": [
+    "llm-context",
+    "visual-context",
+    "approved-baselines",
     "visual-testing",
     "screenshot-testing",
-    "visual-regression",
     "visual-review",
     "ui-testing",
     "collaboration",
@@ -51,7 +53,6 @@
   "files": [
     "bin",
     "dist",
-    "claude-plugin",
     "README.md",
     "LICENSE"
   ],
@@ -71,12 +72,14 @@
     "test:watch": "node --test --test-reporter=spec --watch $(find tests -name '*.test.js')",
     "test:reporter": "playwright test --config=tests/reporter/playwright.config.js",
     "test:reporter:visual": "node bin/vizzly.js run \"npm run test:reporter\"",
+    "test:swift:e2e": "npm run build && node clients/swift/scripts/run-e2e.js",
     "test:tui": "node --test --test-reporter=spec tests/tui/*.test.js",
     "test:tui:docker": "./tests/tui/run-tui-tests.sh",
-    "lint": "biome check src tests",
-    "lint:fix": "biome check --write --unsafe src tests",
-    "format": "biome format --write src tests",
-    "format:check": "biome format src tests",
+    "smoke:prod:pack": "node scripts/smoke-prod-pack.js",
+    "lint": "biome check src tests clients/storybook/src clients/storybook/tests clients/static-site/src clients/static-site/tests clients/vitest/src clients/vitest/tests clients/ember/src clients/ember/tests clients/ember/bin",
+    "lint:fix": "biome check --write --unsafe src tests clients/storybook/src clients/storybook/tests clients/static-site/src clients/static-site/tests clients/vitest/src clients/vitest/tests clients/ember/src clients/ember/tests clients/ember/bin",
+    "format": "biome format --write src tests clients/storybook/src clients/storybook/tests clients/static-site/src clients/static-site/tests clients/vitest/src clients/vitest/tests clients/ember/src clients/ember/tests clients/ember/bin",
+    "format:check": "biome format src tests clients/storybook/src clients/storybook/tests clients/static-site/src clients/static-site/tests clients/vitest/src clients/vitest/tests clients/ember/src clients/ember/tests clients/ember/bin",
     "fix": "npm run format && npm run lint:fix"
   },
   "engines": {

package/dist/services/screenshot-server.js

@@ -1,65 +0,0 @@
-/**
- * Screenshot Server Service
- * Listens for and processes screenshots from the test runner
- *
- * This class is a thin wrapper around the functional operations in
- * src/screenshot-server/. It maintains backwards compatibility while
- * delegating to pure functions for testability.
- */
-
-import { createServer } from 'node:http';
-import { VizzlyError } from '../errors/vizzly-error.js';
-import { handleRequest, parseRequestBody, startServer, stopServer } from '../screenshot-server/index.js';
-import * as output from '../utils/output.js';
-export class ScreenshotServer {
-  constructor(config, buildManager, options = {}) {
-    this.config = config;
-    this.buildManager = buildManager;
-    this.server = null;
-
-    // Dependency injection for testing
-    this.deps = options.deps || {
-      createHttpServer: createServer,
-      output,
-      createError: (message, code) => new VizzlyError(message, code)
-    };
-  }
-  async start() {
-    this.server = await startServer({
-      config: this.config,
-      requestHandler: this.handleRequest.bind(this),
-      deps: {
-        createHttpServer: this.deps.createHttpServer,
-        createError: this.deps.createError,
-        output: this.deps.output
-      }
-    });
-  }
-  async stop() {
-    await stopServer({
-      server: this.server,
-      deps: {
-        output: this.deps.output
-      }
-    });
-  }
-  async handleRequest(req, res) {
-    await handleRequest({
-      req,
-      res,
-      deps: {
-        buildManager: this.buildManager,
-        createError: this.deps.createError,
-        output: this.deps.output
-      }
-    });
-  }
-  async parseRequestBody(req) {
-    return parseRequestBody({
-      req,
-      deps: {
-        createError: this.deps.createError
-      }
-    });
-  }
-}