@vizzly-testing/cli 0.35.3-beta.0 → 0.35.3-beta.2

package/dist/commands/doctor.js

@@ -264,12 +264,4 @@ export async function doctorCommand(options = {}, globalOptions = {}, deps = {})
     output.cleanup();
     if (hasErrors) exit(1);
   }
-}
-
-/**
- * Validate doctor options (no specific validation needed)
- * @param {Object} options - Command options
- */
-export function validateDoctorOptions() {
-  return []; // No specific validation for now
 }

package/dist/commands/init.js

@@ -23,6 +23,7 @@ function createInitDeps(deps = {}) {
     output: deps.output || output,
     promptAgentSkill: deps.promptAgentSkill || promptAgentSkill,
     readFile: deps.readFile || fs.readFile,
+    remove: deps.remove || fs.rm,
     skillSourcePath: deps.skillSourcePath || getPackagedAgentSkillPath(),
     writeFile: deps.writeFile || fs.writeFile
   };
@@ -37,7 +38,7 @@ function configureOutput(output, options) {
 export function getInitConfigPath(cwd = process.cwd()) {
   return path.join(cwd, 'vizzly.config.js');
 }
-export function getPackagedAgentSkillPath(baseDir = commandDir) {
+function getPackagedAgentSkillPath(baseDir = commandDir) {
   return path.resolve(baseDir, '..', '..', 'skills', 'vizzly');
 }
 export function getProjectAgentSkillPath(cwd = process.cwd()) {
@@ -54,10 +55,10 @@ export async function fileExists(filePath, access = fs.access) {
     return false;
   }
 }
-export function getPluginsWithConfig(plugins = []) {
+function getPluginsWithConfig(plugins = []) {
   return plugins.filter(plugin => plugin.configSchema);
 }
-export function getPluginConfigNames(plugins = []) {
+function getPluginConfigNames(plugins = []) {
   return getPluginsWithConfig(plugins).map(plugin => plugin.name);
 }
 function formatObjectKey(key) {
@@ -115,7 +116,7 @@ export function formatPluginConfig(plugin, output = null) {
     return '';
   }
 }
-export function generatePluginConfigs(plugins = [], output = null) {
+function generatePluginConfigs(plugins = [], output = null) {
   let sections = [];
   for (let plugin of plugins) {
     if (plugin.configSchema) {
@@ -212,17 +213,21 @@ async function shouldInstallAgentSkill(options, deps) {
 }
 let agentGuidanceStart = '<!-- vizzly-agent-guidance -->';
 let agentGuidanceEnd = '<!-- /vizzly-agent-guidance -->';
-export function createAgentGuidanceContent() {
+function createAgentGuidanceContent() {
+  let skillPath = '.agents/skills/vizzly/SKILL.md';
   return `${agentGuidanceStart}
 ## Visual Testing With Vizzly
 
-Use Vizzly for user-facing UI changes when this repo has Vizzly configured.
+For user-facing changes, use the repo-local Vizzly skill at
+\`${skillPath}\`.
 
-- Read visual history before changing UI: \`npx vizzly context build current --source local --agent\`
-- Inspect named screenshot history when useful: \`npx vizzly context screenshot "<screenshot-name>" --source local --json\`
-- Verify visual changes through the existing user workflow that owns the surface: \`npx vizzly tdd run "<test command>" --no-open\`
+- Inspect existing visual evidence before and after the change.
+- Use the repository's established Vizzly command and owning user workflow.
+- Read bounded JSON with \`--agent --json\`, then inspect baseline, current, and
+  diff images together.
 
-Prefer existing E2E/user journeys over narrow screenshot-only specs. Treat Vizzly diffs as review evidence; do not approve or reject changes unless asked.
+Treat Vizzly diffs as review evidence. Do not approve, reject, or replace
+evidence unless the task explicitly asks for that mutation.
 ${agentGuidanceEnd}
 `;
 }
@@ -232,7 +237,7 @@ function appendSection(content, section) {
   }
   return `${content.replace(/\s*$/, '')}\n\n${section}`;
 }
-export async function upsertProjectAgentGuidance({
+async function upsertProjectAgentGuidance({
   cwd,
   access = fs.access,
   readFile = fs.readFile,
@@ -248,9 +253,28 @@ export async function upsertProjectAgentGuidance({
     };
   }
   let existingContent = await readFile(agentsPath, 'utf8');
-  if (existingContent.includes(agentGuidanceStart)) {
+  let startIndex = existingContent.indexOf(agentGuidanceStart);
+  let endIndex = existingContent.indexOf(agentGuidanceEnd);
+  let startCount = existingContent.split(agentGuidanceStart).length - 1;
+  let endCount = existingContent.split(agentGuidanceEnd).length - 1;
+  if (startCount !== endCount || startCount > 1 || startCount === 1 && endIndex < startIndex) {
     return {
-      status: 'exists',
+      status: 'malformed',
+      agentsPath
+    };
+  }
+  if (startIndex >= 0 && endIndex >= startIndex) {
+    let blockEnd = endIndex + agentGuidanceEnd.length;
+    let refreshedContent = `${existingContent.slice(0, startIndex)}${guidance.trimEnd()}${existingContent.slice(blockEnd)}`;
+    if (refreshedContent === existingContent) {
+      return {
+        status: 'exists',
+        agentsPath
+      };
+    }
+    await writeFile(agentsPath, refreshedContent, 'utf8');
+    return {
+      status: 'refreshed',
       agentsPath
     };
   }
@@ -263,9 +287,11 @@ export async function upsertProjectAgentGuidance({
 export async function installProjectAgentSkill({
   cwd,
   sourcePath,
+  refresh = false,
   access = fs.access,
   copy = fs.cp,
-  mkdir = fs.mkdir
+  mkdir = fs.mkdir,
+  remove = fs.rm
 }) {
   let targetPath = getProjectAgentSkillPath(cwd);
   if (!(await fileExists(path.join(sourcePath, 'SKILL.md'), access))) {
@@ -275,7 +301,8 @@ export async function installProjectAgentSkill({
       targetPath
     };
   }
-  if (await fileExists(targetPath, access)) {
+  let targetExists = await fileExists(targetPath, access);
+  if (targetExists && !refresh) {
     return {
       status: 'exists',
       sourcePath,
@@ -287,11 +314,16 @@ export async function installProjectAgentSkill({
   });
   await copy(sourcePath, targetPath, {
     recursive: true,
-    errorOnExist: true,
-    force: false
+    errorOnExist: !targetExists,
+    force: targetExists
   });
+  if (targetExists) {
+    await remove(path.join(targetPath, 'agents', 'openai.yaml'), {
+      force: true
+    });
+  }
   return {
-    status: 'installed',
+    status: targetExists ? 'refreshed' : 'installed',
     sourcePath,
     targetPath
   };
@@ -305,6 +337,11 @@ function writeAgentSkillOutput(output, result) {
     output.hint(`Installed at ${result.targetPath}`);
     return;
   }
+  if (result.status === 'refreshed') {
+    output.complete('Refreshed Vizzly agent skill');
+    output.hint(`Updated ${result.targetPath}`);
+    return;
+  }
   if (result.status === 'exists') {
     output.hint('Vizzly agent skill already exists in this repo');
     return;
@@ -327,8 +364,18 @@ function writeAgentGuidanceOutput(output, result) {
     output.hint(`Updated ${result.agentsPath}`);
     return;
   }
+  if (result.status === 'refreshed') {
+    output.complete('Refreshed Vizzly guidance in AGENTS.md');
+    output.hint(`Updated ${result.agentsPath}`);
+    return;
+  }
   if (result.status === 'exists') {
     output.hint('Vizzly guidance already exists in AGENTS.md');
+    return;
+  }
+  if (result.status === 'malformed') {
+    output.warn('Vizzly guidance markers in AGENTS.md are incomplete');
+    output.hint(`Repair the managed block in ${result.agentsPath}`);
   }
 }
 function withAgentSetupResults(payload, {
@@ -362,16 +409,11 @@ async function loadInitPlugins(options, deps) {
   }
   try {
     let config = await deps.loadConfig(options.config, {});
-    return await deps.loadPlugins(options.config, config, null);
+    return await deps.loadPlugins(options.config, config);
   } catch {
     return [];
   }
 }
-
-// Export factory function for CLI
-export function createInitCommand(options) {
-  return () => init(options);
-}
 export async function init(options = {}, deps = {}) {
   let resolvedDeps = createInitDeps(deps);
   configureOutput(resolvedDeps.output, options);
@@ -386,7 +428,9 @@ export async function init(options = {}, deps = {}) {
       sourcePath: resolvedDeps.skillSourcePath,
       access: resolvedDeps.access,
       copy: resolvedDeps.copy,
-      mkdir: resolvedDeps.mkdir
+      mkdir: resolvedDeps.mkdir,
+      refresh: options.agentGuidance || options.agentSkill,
+      remove: resolvedDeps.remove
     });
   }
   if (options.agentGuidance) {

package/dist/commands/login.js

@@ -236,17 +236,4 @@ export async function loginCommand(options = {}, globalOptions = {}, deps = {})
       exit(1);
     }
   }
-}
-
-/**
- * Validate login options
- * @param {Object} options - Command options
- */
-export function validateLoginOptions() {
-  let errors = [];
-
-  // No specific validation needed for login command
-  // OAuth device flow handles everything via browser
-
-  return errors;
 }

package/dist/commands/logout.js

@@ -70,16 +70,4 @@ export async function logoutCommand(options = {}, globalOptions = {}, deps = {})
     output.cleanup();
     exit(1);
   }
-}
-
-/**
- * Validate logout options
- * @param {Object} options - Command options
- */
-export function validateLogoutOptions() {
-  let errors = [];
-
-  // No specific validation needed for logout command
-
-  return errors;
 }

package/dist/commands/orgs.js

@@ -82,13 +82,4 @@ export async function orgsCommand(_options = {}, globalOptions = {}, deps = {})
     output.cleanup();
     exit(1);
   }
-}
-
-/**
- * Validate orgs options
- * @param {Object} _options - Command options
- * @returns {string[]} Validation errors
- */
-export function validateOrgsOptions(_options = {}) {
-  return [];
 }

package/dist/commands/whoami.js

@@ -182,16 +182,4 @@ export async function whoamiCommand(options = {}, globalOptions = {}, deps = {})
       exit(1);
     }
   }
-}
-
-/**
- * Validate whoami options
- * @param {Object} options - Command options
- */
-export function validateWhoamiOptions() {
-  let errors = [];
-
-  // No specific validation needed for whoami command
-
-  return errors;
 }

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

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { existsSync as defaultExistsSync, readFileSync } from 'node:fs';
 import { basename, isAbsolute, join } from 'node:path';
 import { pathToFileURL } from 'node:url';
@@ -204,31 +205,6 @@ function buildReviewState(build, reviewSummary) {
     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;
@@ -306,6 +282,141 @@ function mapLocalComparison(snapshot, comparison) {
     }
   };
 }
+function projectLocalScreenshot(screenshot, baseline) {
+  if (!screenshot) return null;
+  return {
+    id: screenshot.id,
+    name: screenshot.name,
+    browser: screenshot.browser,
+    viewport: {
+      width: screenshot.viewport_width,
+      height: screenshot.viewport_height
+    },
+    url: screenshot.original_url,
+    baseline: baseline ? {
+      id: baseline.id,
+      build_id: baseline.build_id,
+      name: baseline.name,
+      browser: baseline.browser,
+      viewport: {
+        width: baseline.viewport_width,
+        height: baseline.viewport_height
+      },
+      url: baseline.original_url
+    } : null
+  };
+}
+function projectLocalDiff(diff, includeDiffs) {
+  let projected = {
+    percentage: diff?.percentage ?? null,
+    changed_pixels: diff?.changed_pixels ?? null,
+    total_pixels: diff?.total_pixels ?? null,
+    threshold: diff?.threshold ?? null,
+    image_url: diff?.image_url ?? null,
+    fingerprint_hash: diff?.fingerprint_hash ?? null,
+    region_count: Array.isArray(diff?.regions) ? diff.regions.length : null
+  };
+  if (includeDiffs) {
+    projected.regions = diff?.regions || [];
+    projected.cluster_metadata = diff?.cluster_metadata ?? null;
+    projected.fingerprint_data = diff?.fingerprint_data ?? null;
+    projected.diff_lines = diff?.diff_lines ?? [];
+  }
+  return projected;
+}
+function projectLocalEvidence(comparison, includeDiffs) {
+  return {
+    type: 'comparison',
+    id: comparison.id,
+    screenshot_name: comparison.screenshot_name,
+    status: comparison.status,
+    result: comparison.result,
+    approval_status: comparison.approval_status,
+    needs_review: comparison.needs_review,
+    build_id: comparison.build_id,
+    build_name: comparison.build_name,
+    build_branch: comparison.build_branch,
+    build_commit_sha: comparison.build_commit_sha,
+    build_created_at: comparison.build_created_at,
+    screenshot: projectLocalScreenshot(comparison.screenshot, comparison.baseline),
+    diff: projectLocalDiff(comparison.diff, includeDiffs)
+  };
+}
+function projectLocalFocusedComparison(comparison, includeDiffs) {
+  if (includeDiffs) return comparison;
+  let analysis = comparison.analysis || {};
+  let {
+    diff_regions: _diffRegions,
+    cluster_metadata: _clusterMetadata,
+    fingerprint_data: _fingerprintData,
+    diff_lines: _diffLines,
+    ...summaryAnalysis
+  } = analysis;
+  return {
+    ...comparison,
+    diff: projectLocalDiff(comparison.diff, false),
+    analysis: summaryAnalysis
+  };
+}
+function projectLocalHistoryItem(comparison) {
+  return {
+    id: comparison.id,
+    screenshot_name: comparison.screenshot_name,
+    result: comparison.result,
+    status: comparison.status,
+    needs_review: comparison.needs_review,
+    build_id: comparison.build_id,
+    build_name: comparison.build_name,
+    build_branch: comparison.build_branch,
+    build_created_at: comparison.build_created_at,
+    screenshot: projectLocalScreenshot(comparison.screenshot, comparison.baseline),
+    diff: {
+      percentage: comparison.diff?.percentage ?? null,
+      fingerprint_hash: comparison.diff?.fingerprint_hash ?? null,
+      region_count: Array.isArray(comparison.diff?.regions) ? comparison.diff.regions.length : null
+    }
+  };
+}
+function compactLocalCollection(items) {
+  return {
+    total: Array.isArray(items) ? items.length : null,
+    included: false,
+    details_available: Array.isArray(items) && items.length > 0
+  };
+}
+function createLocalDynamicRegions(comparison = null) {
+  let confirmedRegions = comparison?.analysis?.confirmed_regions;
+  let hotspotAnalysis = comparison?.analysis?.hotspot_analysis;
+  return {
+    decision: null,
+    patterns: compactLocalCollection([]),
+    confirmed_regions: compactLocalCollection(confirmedRegions),
+    exclusions: {
+      total: null,
+      included: false,
+      details_available: false
+    },
+    hotspot_analysis: hotspotAnalysis ? {
+      total_builds_analyzed: hotspotAnalysis.total_builds_analyzed ?? null,
+      confidence: hotspotAnalysis.confidence ?? null,
+      confidence_score: hotspotAnalysis.confidence_score ?? null,
+      data_source: hotspotAnalysis.data_source ?? null,
+      coverage: hotspotAnalysis.coverage ?? null,
+      confirmed_region_coverage: hotspotAnalysis.confirmed_region_coverage ?? null
+    } : null
+  };
+}
+function createLocalSnapshotRevision(snapshot) {
+  let revisionInput = {
+    serverInfo: snapshot.serverInfo,
+    reportData: snapshot.reportData,
+    comparisonDetails: snapshot.comparisonDetails,
+    baselineMetadata: snapshot.baselineMetadata,
+    hotspotFile: snapshot.hotspotFile,
+    regionFile: snapshot.regionFile
+  };
+  return createHash('sha256').update(JSON.stringify(revisionInput)).digest('base64url');
+}
 function buildReviewSummary(comparisons = []) {
   let approved = comparisons.filter(comparison => mapApprovalStatus(comparison.status) === 'approved').length;
   let rejected = comparisons.filter(comparison => mapApprovalStatus(comparison.status) === 'rejected').length;
@@ -405,17 +516,66 @@ export function createLocalWorkspaceContextProvider(options = {}, deps = {}) {
       } : {})
     };
   }
-  function getBuildContext(buildId) {
+  function createLocalCursor(resource, target, query, stream, offset, revision) {
+    return Buffer.from(JSON.stringify({
+      version: 1,
+      resource,
+      target,
+      query,
+      stream,
+      offset,
+      revision
+    })).toString('base64url');
+  }
+  function readLocalCursor(cursor, resource, target, query, revision, streams) {
+    if (!cursor) return null;
+    try {
+      let parsed = JSON.parse(Buffer.from(cursor, 'base64url').toString());
+      if (parsed.version !== 1 || parsed.resource !== resource || parsed.target !== target || parsed.query !== query || parsed.revision !== revision || !streams.includes(parsed.stream) || !Number.isInteger(parsed.offset) || parsed.offset < 0) {
+        throw new Error('mismatch');
+      }
+      return parsed;
+    } catch {
+      throw createLocalWorkspaceError('The local context cursor is invalid or the local results changed. Start again without --cursor.');
+    }
+  }
+  function createLocalPage(items, {
+    limit,
+    offset,
+    resource,
+    target,
+    query,
+    stream,
+    revision
+  }) {
+    if (offset > items.length) {
+      throw createLocalWorkspaceError('The local context cursor is invalid or the local results changed. Start again without --cursor.');
+    }
+    let pageItems = items.slice(offset, offset + limit);
+    let nextOffset = offset + pageItems.length;
+    let hasMore = nextOffset < items.length;
+    return {
+      items: pageItems,
+      page: {
+        limit,
+        returned: pageItems.length,
+        total: items.length,
+        has_more: hasMore,
+        next_cursor: hasMore ? createLocalCursor(resource, target, query, stream, nextOffset, revision) : null
+      }
+    };
+  }
+  function getBuildContext(buildId, query = {}) {
     let snapshot = loadSnapshot();
     let resolvedBuild = buildBuildSnapshot(snapshot);
     if (!(buildId === 'current' || buildId === 'local' || buildId === resolvedBuild.id)) {
       throw createLocalWorkspaceError(`Local workspace context is only available for the active local build (${resolvedBuild.id})`);
     }
     let mappedComparisons = snapshot.reportData.comparisons.map(comparison => mapLocalComparison(snapshot, comparison));
-    let mappedScreenshots = snapshot.reportData.comparisons.map(comparison => mapLocalScreenshot(snapshot, comparison));
+    let mappedScreenshots = mappedComparisons.map(comparison => projectLocalScreenshot(comparison.screenshot, comparison.baseline));
     let reviewSummary = buildReviewSummary(snapshot.reportData.comparisons);
     let reviewState = buildReviewState(resolvedBuild, reviewSummary);
-    return {
+    let context = {
       resource: 'build_context',
       source: LOCAL_CONTEXT_SOURCE,
       scope: createScope(),
@@ -446,8 +606,48 @@ export function createLocalWorkspaceContextProvider(options = {}, deps = {}) {
       },
       links: createBuildLinks(snapshot)
     };
+    if (!query.details) return context;
+    let revision = createLocalSnapshotRevision(snapshot);
+    let limit = query.limit || 10;
+    let cursorQuery = `${query.details}:${limit}`;
+    let cursor = readLocalCursor(query.cursor, 'build_context', resolvedBuild.id, cursorQuery, revision, ['evidence']);
+    let includeDiffs = query.details === 'diffs';
+    let evidence = mappedComparisons.map(comparison => projectLocalEvidence(comparison, includeDiffs));
+    return {
+      resource: 'build_context',
+      source: LOCAL_CONTEXT_SOURCE,
+      scope: context.scope,
+      build: context.build,
+      baseline: context.baseline,
+      status: context.status,
+      summary: context.summary,
+      preview: null,
+      signature_properties: [],
+      dynamic_regions: {
+        exclusions: {
+          total: null,
+          included: false,
+          details_available: false
+        },
+        item_details_included: false
+      },
+      evidence: createLocalPage(evidence, {
+        limit,
+        offset: cursor?.offset || 0,
+        resource: 'build_context',
+        target: resolvedBuild.id,
+        query: cursorQuery,
+        stream: 'evidence',
+        revision
+      }),
+      comments: {
+        build: compactLocalCollection(context.comments.build),
+        screenshot_count: context.comments.screenshot_count
+      },
+      links: context.links
+    };
   }
-  function getComparisonContext(comparisonId) {
+  function getComparisonContext(comparisonId, query = {}) {
     let snapshot = loadSnapshot();
     let comparison = findComparison(snapshot, comparisonId);
     if (!comparison) {
@@ -456,7 +656,7 @@ export function createLocalWorkspaceContextProvider(options = {}, deps = {}) {
     let mappedComparison = mapLocalComparison(snapshot, comparison);
     let comparisonName = comparison.originalName || comparison.name;
     let history = snapshot.reportData.comparisons.filter(candidate => candidate.id !== comparison.id && (candidate.originalName || candidate.name) === comparisonName).map(candidate => mapLocalComparison(snapshot, candidate));
-    return {
+    let context = {
       resource: 'comparison_context',
       source: LOCAL_CONTEXT_SOURCE,
       scope: createScope(),
@@ -485,6 +685,52 @@ export function createLocalWorkspaceContextProvider(options = {}, deps = {}) {
       },
       links: buildComparisonLinks(snapshot, comparison.id)
     };
+    if (!query.details) return context;
+    let revision = createLocalSnapshotRevision(snapshot);
+    let limit = query.limit || 10;
+    let cursorQuery = `${query.details}:${limit}`;
+    let cursor = readLocalCursor(query.cursor, 'comparison_context', comparison.id, cursorQuery, revision, ['similar_by_fingerprint', 'recent_by_name']);
+    let activeStream = cursor?.stream;
+    let similarOffset = activeStream === 'similar_by_fingerprint' ? cursor.offset : 0;
+    let recentOffset = activeStream === 'recent_by_name' ? cursor.offset : 0;
+    return {
+      resource: 'comparison_context',
+      source: LOCAL_CONTEXT_SOURCE,
+      scope: context.scope,
+      build: context.build,
+      signature_properties: [],
+      comparison: projectLocalFocusedComparison(context.comparison, query.details === 'diffs'),
+      dynamic_regions: createLocalDynamicRegions(context.comparison),
+      history: {
+        active_stream: activeStream || null,
+        similar_by_fingerprint: createLocalPage([], {
+          limit,
+          offset: similarOffset,
+          resource: 'comparison_context',
+          target: comparison.id,
+          query: cursorQuery,
+          stream: 'similar_by_fingerprint',
+          revision
+        }),
+        recent_by_name: createLocalPage(history.map(projectLocalHistoryItem), {
+          limit,
+          offset: recentOffset,
+          resource: 'comparison_context',
+          target: comparison.id,
+          query: cursorQuery,
+          stream: 'recent_by_name',
+          revision
+        })
+      },
+      review: {
+        review_summary: context.review.review_summary,
+        assignments: compactLocalCollection(context.review.assignments),
+        build_comments: compactLocalCollection(context.review.build_comments),
+        screenshot_comments: compactLocalCollection(context.review.screenshot_comments)
+      },
+      links: context.links,
+      details: query.details
+    };
   }
   function getScreenshotContext(screenshotName) {
     let snapshot = loadSnapshot();

package/dist/plugin-loader.js

@@ -55,7 +55,7 @@ export async function loadPlugins(configPath, config) {
  * Discover installed plugins from node_modules/@vizzly-testing/*
  * @returns {Promise<Array>} Array of plugin info objects
  */
-export async function discoverInstalledPlugins() {
+async function discoverInstalledPlugins() {
   let plugins = [];
   try {
     // Find all @vizzly-testing packages