@vizzly-testing/cli 0.39.0 → 0.39.1

package/dist/reporter-ssr/ssr-entry.js

@@ -1,11 +1,10 @@
 import { renderToString } from "react-dom/server";
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
-//#region src/utils/status-utils.js
+// src/utils/status-utils.js
 function isNewComparisonStatus(status) {
 	return status === "new" || status === "baseline-created";
 }
-//#endregion
-//#region src/components/static-report-view.jsx
+// src/components/static-report-view.jsx
 /**
 * Static Report View
 *
@@ -637,8 +636,7 @@ function StaticReportView({ reportData }) {
 		})]
 	});
 }
-//#endregion
-//#region src/ssr-entry.jsx
+// src/ssr-entry.jsx
 /**
 * SSR Entry Point
 *
@@ -653,5 +651,4 @@ function StaticReportView({ reportData }) {
 function renderStaticReport(reportData) {
 	return renderToString(/* @__PURE__ */ jsx(StaticReportView, { reportData }));
 }
-//#endregion
 export { renderStaticReport };

package/dist/utils/cli-update.js

@@ -0,0 +1,105 @@
+import { execFile, spawn } from 'node:child_process';
+import { access, readFile, realpath } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { promisify } from 'node:util';
+import { getPackageName } from './package-info.js';
+let exec = promisify(execFile);
+let bundledRoot = fileURLToPath(new URL('../../', import.meta.url));
+let installCommands = {
+  npm: 'install',
+  pnpm: 'add'
+};
+let saveFlags = {
+  dependencies: '--save-prod',
+  devDependencies: '--save-dev',
+  optionalDependencies: '--save-optional'
+};
+async function exists(filename) {
+  try {
+    await access(filename);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Only offer an installer when the running package can be matched to that
+// installation. A checkout, npx cache, or unknown manager gets manual guidance.
+export async function findCliUpdatePlan(cwd, version, packageRoot = bundledRoot) {
+  if (!/^\d+\.\d+\.\d+$/.test(version)) return null;
+  let installed = await realpath(packageRoot);
+  if (!installed.split(path.sep).includes('node_modules')) return null;
+  let name = getPackageName();
+  let spec = `${name}@${version}`;
+  for (let directory = cwd;; directory = path.dirname(directory)) {
+    let manifest = path.join(directory, 'package.json');
+    try {
+      let pkg = JSON.parse(await readFile(manifest, 'utf8'));
+      let group = Object.keys(saveFlags).find(key => pkg[key]?.[name]);
+      if (group) {
+        let resolved = createRequire(manifest).resolve(name);
+        if ((await realpath(resolved)) !== path.join(installed, 'dist', 'index.js')) return null;
+        if (/^(workspace:|file:|link:|git|https?:|npm:)/.test(pkg[group][name])) return null;
+        let manager = pkg.packageManager?.split('@')[0];
+        if (!manager) {
+          if (await exists(path.join(directory, 'pnpm-lock.yaml'))) manager = 'pnpm';else if (await exists(path.join(directory, 'package-lock.json'))) manager = 'npm';
+        }
+        if (!['npm', 'pnpm'].includes(manager)) return null;
+        let args = [installCommands[manager], saveFlags[group]];
+        let preserveExactVersion = /^\d+\.\d+\.\d+(?:[-+].*)?$/.test(pkg[group][name]);
+        if (preserveExactVersion) args.push('--save-exact');
+        args.push(spec);
+        return {
+          command: manager,
+          args,
+          cwd: directory,
+          cliPath: path.join(directory, 'node_modules', name, 'dist', 'cli.js')
+        };
+      }
+    } catch {
+      // Keep looking for the workspace manifest that owns the dependency.
+    }
+    if (directory === path.dirname(directory)) break;
+  }
+  for (let manager of ['npm', 'pnpm']) {
+    try {
+      let {
+        stdout
+      } = await exec(manager, ['root', '--global'], {
+        timeout: 3000
+      });
+      let globalPackage = path.join(stdout.trim(), name);
+      if ((await realpath(globalPackage)) === installed) {
+        return {
+          command: manager,
+          args: [installCommands[manager], '--global', spec],
+          cwd,
+          cliPath: path.join(globalPackage, 'dist', 'cli.js')
+        };
+      }
+    } catch {
+      // An unavailable manager cannot own an update we offer to install.
+    }
+  }
+  return null;
+}
+function runProcess(command, args, cwd, stdio) {
+  return new Promise((resolve, reject) => {
+    let child = spawn(command, args, {
+      cwd,
+      stdio,
+      shell: process.platform === 'win32' && ['npm', 'pnpm'].includes(command)
+    });
+    child.once('error', reject);
+    child.once('close', (code, signal) => resolve(code ?? (signal === 'SIGINT' ? 130 : 1)));
+  });
+}
+export async function runUpdateProcess(command, args, cwd) {
+  let code = await runProcess(command, args, cwd, ['inherit', process.stderr, process.stderr]);
+  if (code !== 0) throw new Error(`${command} exited with status ${code}.`);
+}
+export function runUpdatedCli(cliPath, args, cwd) {
+  return runProcess(process.execPath, [cliPath, '--no-update-notifier', ...args], cwd, 'inherit');
+}

package/dist/utils/update-check.js

@@ -0,0 +1,2 @@
+import { checkForUpdate } from './update-notifications.js';
+await checkForUpdate();

package/dist/utils/update-notifications.js

@@ -0,0 +1,175 @@
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { agentGuidanceFlag, agentGuidancePath, bundledAgentSkill, planAgentSetup } from '../init/agents.js';
+import { createPrompts } from '../init/prompts.js';
+import { findCliUpdatePlan, runUpdateProcess } from './cli-update.js';
+import { readOptionalFile } from './config-discovery.js';
+import { applyChanges, fileChange, preflightChanges } from './file-changes.js';
+import { getGlobalConfigDir } from './global-config.js';
+import * as output from './output.js';
+import { getPackageName, getPackageVersion } from './package-info.js';
+let day = 24 * 60 * 60 * 1000;
+async function readState(filename) {
+  try {
+    let state = JSON.parse(await readOptionalFile(filename));
+    return state && typeof state === 'object' && !Array.isArray(state) ? state : {};
+  } catch {
+    return {};
+  }
+}
+async function stateChange(filename, state) {
+  return fileChange(filename, `${JSON.stringify(state, null, 2)}\n`);
+}
+
+// The registry's latest tag contains stable releases. Never suggest a downgrade
+// or a prerelease, even when an unexpected registry response is cached.
+export function isNewerStableVersion(candidate, current) {
+  let latest = /^(\d+)\.(\d+)\.(\d+)$/.exec(candidate);
+  let installed = /^(\d+)\.(\d+)\.(\d+)(-[\w.-]+)?(?:\+[\w.-]+)?$/.exec(current);
+  if (!latest || !installed) return false;
+  for (let index = 1; index <= 3; index++) {
+    let difference = Number(latest[index]) - Number(installed[index]);
+    if (difference) return difference > 0;
+  }
+  return Boolean(installed[4]);
+}
+export async function checkForUpdate() {
+  try {
+    let filename = path.join(getGlobalConfigDir(), 'updates.json');
+    let response = await fetch(`https://registry.npmjs.org/${encodeURIComponent(getPackageName())}/latest`, {
+      signal: AbortSignal.timeout(3000)
+    });
+    if (!response.ok) return;
+    let {
+      version
+    } = await response.json();
+    if (!/^\d+\.\d+\.\d+$/.test(version)) return;
+    // Keep notice history saved while the network request was in flight.
+    let state = await readState(filename);
+    await applyChanges([await stateChange(filename, {
+      ...state,
+      latestVersion: version
+    })]);
+  } catch {
+    // Update checks never affect the command being run.
+  }
+}
+async function offerUpdate(cwd, {
+  cliVersion,
+  guidanceFlag
+}) {
+  if (!process.stdin.isTTY) return;
+  let cliPlan = cliVersion ? await findCliUpdatePlan(cwd, cliVersion) : null;
+  if (!cliPlan && !guidanceFlag) return;
+  let updatedCli;
+  try {
+    let guidancePlan;
+    if (!cliPlan && guidanceFlag) {
+      guidancePlan = await planAgentSetup(cwd, {
+        skill: true,
+        guidance: guidanceFlag === '--agent-guidance'
+      });
+      await preflightChanges(guidancePlan.changes);
+    }
+    if (cliPlan) {
+      output.printErr(`  Apply: ${cliPlan.command} ${cliPlan.args.join(' ')} (in ${cliPlan.cwd})`);
+      // A CLI upgrade can bring new guidance even if the current bundle matches.
+      if (!guidanceFlag && (await readOptionalFile(path.join(cwd, '.agents', 'skills', 'vizzly', 'SKILL.md')))) {
+        guidanceFlag = await agentGuidanceFlag(cwd);
+      }
+    }
+    if (guidanceFlag) {
+      output.printErr(`  Refresh: vizzly init ${guidanceFlag} (replaces bundled skill files${guidanceFlag === '--agent-guidance' ? ' and the Vizzly AGENTS.md note' : ''})`);
+    }
+    if (!(await confirmUpdate())) return;
+    if (cliPlan) {
+      await runUpdateProcess(cliPlan.command, cliPlan.args, cliPlan.cwd);
+      updatedCli = cliPlan.cliPath;
+      if (guidanceFlag) {
+        await runUpdateProcess(process.execPath, [cliPlan.cliPath, 'init', guidanceFlag, '--no-update-notifier'], cwd);
+      }
+    } else {
+      await applyChanges(guidancePlan.changes);
+    }
+    output.printErr('  Vizzly update applied.');
+  } catch (error) {
+    if (error.code !== 'INIT_CANCELLED') output.printErr(`  Could not apply the Vizzly update: ${error.message}`);
+  }
+  return updatedCli;
+}
+async function confirmUpdate() {
+  let prompts = createPrompts();
+  try {
+    return await prompts.confirm('Apply available Vizzly updates now?');
+  } finally {
+    prompts.close();
+  }
+}
+async function planGuidanceNotice(cwd, cliVersion) {
+  let installed = await readOptionalFile(path.join(cwd, '.agents', 'skills', 'vizzly', 'SKILL.md'));
+  let guidance = await readState(agentGuidancePath(cwd));
+  if (!installed || isNewerStableVersion(guidance.cliVersion, cliVersion)) return null;
+  let {
+    version,
+    files
+  } = await bundledAgentSkill();
+  if (!guidance.version) {
+    let contents = await Promise.all(files.map(({
+      filename
+    }) => readOptionalFile(path.join(cwd, '.agents', 'skills', 'vizzly', filename))));
+    if (files.every(({
+      content
+    }, index) => content === contents[index])) guidance.version = version;
+  }
+  if (guidance.version === version || guidance.notifiedVersion === version) return null;
+  let flag = await agentGuidanceFlag(cwd);
+  return {
+    flag,
+    message: `Vizzly agent guidance has an update. Run vizzly init ${flag} to refresh it.`,
+    change: await stateChange(agentGuidancePath(cwd), {
+      ...guidance,
+      notifiedVersion: version
+    })
+  };
+}
+function startUpdateCheck() {
+  output.printErr('  Checking for Vizzly updates in the background…');
+  let child = spawn(process.execPath, [fileURLToPath(new URL('./update-check.js', import.meta.url))], {
+    detached: true,
+    stdio: 'ignore'
+  });
+  child.on('error', () => {});
+  child.unref();
+}
+export async function notifyUpdates(options = {}) {
+  if (options.updateNotifier === false || options.json || output.isJson() || !process.stderr.isTTY || !process.stdout.isTTY || process.env.CI || 'NO_UPDATE_NOTIFIER' in process.env || 'VIZZLY_NO_UPDATE_NOTIFIER' in process.env || !['info', 'debug'].includes(output.getLogLevel())) return;
+  try {
+    let cwd = process.cwd();
+    let filename = path.join(getGlobalConfigDir(), 'updates.json');
+    let state = await readState(filename);
+    let messages = [];
+    let available = {};
+    let cliVersion = getPackageVersion();
+    if (isNewerStableVersion(state.latestVersion, cliVersion) && state.notifiedCliVersion !== state.latestVersion) {
+      messages.push(`Vizzly ${state.latestVersion} is available (installed: ${cliVersion}). Update ${getPackageName()} with the package manager that installed it.`);
+      state.notifiedCliVersion = state.latestVersion;
+      available.cliVersion = state.latestVersion;
+    }
+    let guidanceNotice = await planGuidanceNotice(cwd, cliVersion);
+    if (guidanceNotice) {
+      messages.push(guidanceNotice.message);
+      available.guidanceFlag = guidanceNotice.flag;
+    }
+    let checkDue = !Number.isFinite(state.lastCheckedAt) || state.lastCheckedAt > Date.now() || Date.now() - state.lastCheckedAt >= day;
+    if (checkDue) state.lastCheckedAt = Date.now();
+    // If state cannot be saved, stay quiet instead of repeating a notice on
+    // every invocation. Setup's file preflight also protects against symlinks.
+    await applyChanges([guidanceNotice?.change, await stateChange(filename, state)]);
+    for (let message of messages) output.printErr(`  ${message}`);
+    if (checkDue) startUpdateCheck();
+    return await offerUpdate(cwd, available);
+  } catch {
+    // Missing, malformed, or unwritable metadata must not break CLI commands.
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vizzly-testing/cli",
-  "version": "0.39.0",
+  "version": "0.39.1",
   "description": "Visual regression testing from your terminal",
   "keywords": [
     "llm-context",
@@ -99,11 +99,11 @@
     "ansis": "^4.4.0",
     "commander": "^15.0.0",
     "cosmiconfig": "^10.0.1",
-    "dotenv": "^18.0.3",
+    "dotenv": "^18.0.9",
     "form-data": "^4.0.6",
     "glob": "^13.0.6",
-    "react": "^19.3.0",
-    "react-dom": "^19.3.0",
+    "react": "^19.3.1",
+    "react-dom": "^19.3.1",
     "zod": "^4.6.7"
   },
   "tsd": {
@@ -118,28 +118,28 @@
   },
   "devDependencies": {
     "@babel/cli": "^8.0.6",
-    "@babel/core": "^8.0.6",
-    "@babel/preset-env": "^8.0.6",
+    "@babel/core": "^8.0.7",
+    "@babel/preset-env": "^8.0.7",
     "@babel/preset-react": "^8.0.1",
-    "@babel/preset-typescript": "^8.0.1",
-    "@biomejs/biome": "^2.5.15",
+    "@babel/preset-typescript": "^8.0.7",
+    "@biomejs/biome": "^2.6.2",
     "@heroicons/react": "^2.2.0",
-    "@modelcontextprotocol/sdk": "^1.31.0",
-    "@playwright/test": "^1.63.0",
+    "@modelcontextprotocol/sdk": "^1.32.1",
+    "@playwright/test": "^1.64.1",
     "@tailwindcss/postcss": "^4.3.3",
-    "@tanstack/react-query": "^5.104.0",
-    "@types/node": "^26.6.3",
+    "@tanstack/react-query": "^5.104.5",
+    "@types/node": "^26.6.5",
     "@vitejs/plugin-react": "^6.1.2",
     "autoprefixer": "^10.6.1",
     "babel-plugin-react-compiler": "^1.0.0",
     "babel-plugin-transform-remove-console": "^6.9.4",
-    "postcss": "^8.5.29",
+    "postcss": "^8.5.31",
     "rimraf": "^6.1.3",
     "tailwindcss": "^4.3.3",
     "tsd": "^0.33.0",
     "tui-driver": "github:vizzly-testing/tui-driver",
     "typescript": "^7.0.2",
-    "vite": "^8.3.1",
-    "wouter": "^3.11.1"
+    "vite": "^8.3.5",
+    "wouter": "^3.13.0"
   }
 }