voyageai-cli 1.29.0 → 1.30.0

package/src/commands/playground.js

@@ -67,6 +67,9 @@ function loadAnnouncementsFromMarkdown() {
       badge: metadata.badge || 'Info',
       published: metadata.published || new Date().toISOString().split('T')[0],
       expires: metadata.expires || '2099-12-31',
+      bg_image: metadata.bg_image || null,
+      bg_color: metadata.bg_color || null,
+      icon: metadata.icon || null,
       cta: {
         label: metadata.cta_label || 'Learn More',
         action: metadata.cta_action || 'link',
@@ -159,7 +162,9 @@ function createPlaygroundServer() {
     try {
       // Serve HTML
       if (req.method === 'GET' && (req.url === '/' || req.url === '/index.html')) {
-        const html = fs.readFileSync(htmlPath, 'utf8');
+        const { getVersion } = require('../lib/banner');
+        let html = fs.readFileSync(htmlPath, 'utf8');
+        html = html.replace('</head>', `<script>window.__VAI_VERSION__="${getVersion()}";</script></head>`);
         res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
         res.end(html);
         return;
@@ -223,6 +228,25 @@ function createPlaygroundServer() {
         return;
       }
 
+      // Serve announcement assets: /assets/announcements/{filename}
+      const assetMatch = req.url.match(/^\/assets\/announcements\/([a-zA-Z0-9_.-]+\.(jpg|jpeg|png|webp|gif))$/);
+      if (req.method === 'GET' && assetMatch) {
+        const assetPath = path.join(__dirname, '..', 'playground', 'assets', 'announcements', assetMatch[1]);
+        if (fs.existsSync(assetPath)) {
+          const mimeTypes = { jpg: 'image/jpeg', jpeg: 'image/jpeg', png: 'image/png', webp: 'image/webp', gif: 'image/gif' };
+          const data = fs.readFileSync(assetPath);
+          res.writeHead(200, {
+            'Content-Type': mimeTypes[assetMatch[2]] || 'application/octet-stream',
+            'Cache-Control': 'public, max-age=86400',
+          });
+          res.end(data);
+        } else {
+          res.writeHead(404);
+          res.end('Asset not found');
+        }
+        return;
+      }
+
       // API: Models
       if (req.method === 'GET' && req.url === '/api/models') {
         const models = MODEL_CATALOG.filter(m => !m.legacy && !m.local && !m.unreleased);
@@ -360,6 +384,14 @@ function createPlaygroundServer() {
         return;
       }
 
+      // API: Workflow node help
+      if (req.method === 'GET' && req.url === '/api/workflows/node-help') {
+        const nodeHelp = require('../playground/help/workflow-nodes');
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ nodeHelp }));
+        return;
+      }
+
       // API: Chat config (GET)
       if (req.method === 'GET' && req.url === '/api/chat/config') {
         const { resolveLLMConfig } = require('../lib/llm');
@@ -656,6 +688,17 @@ function createPlaygroundServer() {
               description: def.description || '',
             }));
 
+            // Derive capabilities from tools
+            const toolsList = vai.tools || [];
+            const capabilities = [];
+            if (toolsList.includes('http')) capabilities.push('NETWORK');
+            if (toolsList.includes('ingest') || toolsList.includes('aggregate')) capabilities.push('WRITE_DB');
+            if (toolsList.includes('generate')) capabilities.push('LLM');
+            if (toolsList.includes('loop') || toolsList.includes('forEach')) capabilities.push('LOOP');
+            if (toolsList.some(t => ['query','search','collections','aggregate'].includes(t))) capabilities.push('READ_DB');
+
+            const isOfficial = (r.name || '').startsWith('@vaicli/');
+
             return {
               name: shortName,
               packageName: r.name,
@@ -663,11 +706,10 @@ function createPlaygroundServer() {
               description: r.description || '',
               category,
               tags: vai.tags || [],
-              tools: vai.tools || [],
-              steps: vai.steps || (vai.tools || []).length || 0,
-              tools: vai.tools || [],
-              toolCount: (vai.tools || []).length,
-              tier: (r.name || '').startsWith('@vaicli/') ? 'official' : 'community',
+              tools: toolsList,
+              steps: vai.steps || toolsList.length || 0,
+              toolCount: toolsList.length,
+              tier: isOfficial ? 'official' : 'community',
               downloads: 0,
               featured: FEATURED.includes(shortName),
               installed: installedNames.has(r.name),
@@ -676,6 +718,10 @@ function createPlaygroundServer() {
               author,
               assets,
               inputs,
+              capabilities,
+              verified: isOfficial,
+              security: [],
+              rating: null,
             };
           });
 

package/src/commands/query.js

@@ -5,6 +5,7 @@ const { generateEmbeddings, apiRequest } = require('../lib/api');
 const { getMongoCollection } = require('../lib/mongo');
 const { loadProject } = require('../lib/project');
 const ui = require('../lib/ui');
+const { showCombinedCostSummary } = require('../lib/cost-display');
 
 /**
  * Register the query command on a Commander program.
@@ -33,6 +34,7 @@ function registerQuery(program) {
     .option('-q, --quiet', 'Suppress non-essential output')
     .action(async (text, opts) => {
       let client;
+      const telemetry = require('../lib/telemetry');
       try {
         // Merge project config
         const { config: proj } = loadProject();
@@ -51,6 +53,14 @@ function registerQuery(program) {
           process.exit(1);
         }
 
+        const done = telemetry.timer('cli_query', {
+          model,
+          rerankModel: doRerank ? rerankModel : undefined,
+          rerank: doRerank,
+          limit: opts.limit,
+          topK: opts.topK,
+        });
+
         const useColor = !opts.json;
         const useSpinner = useColor && !opts.quiet;
 
@@ -242,8 +252,14 @@ function registerQuery(program) {
         if (!opts.quiet) {
           const totalTokens = embedTokens + rerankTokens;
           console.log(ui.dim(`  Tokens: ${totalTokens} (embed: ${embedTokens}${rerankTokens ? `, rerank: ${rerankTokens}` : ''})`));
+          const costOps = [{ model, tokens: embedTokens, label: `embed (${model})` }];
+          if (rerankTokens) costOps.push({ model: rerankModel, tokens: rerankTokens, label: `rerank (${rerankModel})` });
+          showCombinedCostSummary(costOps, opts);
         }
+
+        done({ resultCount: finalResults.length });
       } catch (err) {
+        telemetry.send('cli_error', { command: 'query', errorType: err.constructor.name });
         console.error(ui.error(err.message));
         process.exit(1);
       } finally {

package/src/commands/rerank.js

@@ -4,6 +4,7 @@ const fs = require('fs');
 const { DEFAULT_RERANK_MODEL } = require('../lib/catalog');
 const { apiRequest } = require('../lib/api');
 const ui = require('../lib/ui');
+const { showCostSummary } = require('../lib/cost-display');
 
 /**
  * Register the rerank command on a Commander program.
@@ -25,6 +26,7 @@ function registerRerank(program) {
     .option('--json', 'Machine-readable JSON output')
     .option('-q, --quiet', 'Suppress non-essential output')
     .action(async (opts) => {
+      const telemetry = require('../lib/telemetry');
       try {
         let documents = opts.documents;
 
@@ -81,6 +83,12 @@ function registerRerank(program) {
           opts.model = chosenModel;
         }
 
+        const done = telemetry.timer('cli_rerank', {
+          model: opts.model,
+          docCount: documents.length,
+          topK: opts.topK,
+        });
+
         const body = {
           query: opts.query,
           documents,
@@ -120,6 +128,7 @@ function registerRerank(program) {
           if (result.usage) {
             console.log(ui.label('Tokens', ui.dim(String(result.usage.total_tokens))));
           }
+          showCostSummary(result.model || opts.model, result.usage?.total_tokens || 0, opts);
           console.log('');
         }
 
@@ -134,7 +143,10 @@ function registerRerank(program) {
 
         console.log('');
         console.log(ui.success('Reranking complete'));
+
+        done();
       } catch (err) {
+        telemetry.send('cli_error', { command: 'rerank', errorType: err.constructor.name });
         console.error(ui.error(err.message));
         process.exit(1);
       }

package/src/commands/scaffold.js

@@ -55,7 +55,9 @@ function registerScaffold(program) {
     .option('--dry-run', 'Show what would be created without writing')
     .option('-q, --quiet', 'Suppress non-essential output')
     .action(async (name, opts) => {
+      const telemetry = require('../lib/telemetry');
       try {
+        telemetry.send('cli_scaffold', { template: opts.target });
         const target = opts.target;
         const projectDir = path.resolve(process.cwd(), name);
         

package/src/commands/search.js

@@ -4,6 +4,7 @@ const { getDefaultModel } = require('../lib/catalog');
 const { generateEmbeddings } = require('../lib/api');
 const { getMongoCollection } = require('../lib/mongo');
 const ui = require('../lib/ui');
+const { showCostSummary } = require('../lib/cost-display');
 
 /**
  * Register the search command on a Commander program.
@@ -29,7 +30,13 @@ function registerSearch(program) {
     .option('-q, --quiet', 'Suppress non-essential output')
     .action(async (opts) => {
       let client;
+      const telemetry = require('../lib/telemetry');
       try {
+        const done = telemetry.timer('cli_search', {
+          model: opts.model,
+          limit: opts.limit,
+        });
+
         const useColor = !opts.json;
         const useSpinner = useColor && !opts.quiet;
         let spin;
@@ -93,9 +100,12 @@ function registerSearch(program) {
         if (!opts.quiet) {
           console.log(ui.label('Query', ui.cyan(`"${opts.query}"`)));
           console.log(ui.label('Results', String(cleanResults.length)));
+          showCostSummary(opts.model, embedResult.usage?.total_tokens || 0, opts);
           console.log('');
         }
 
+        done({ resultCount: cleanResults.length });
+
         if (cleanResults.length === 0) {
           console.log(ui.yellow('No results found.'));
           return;
@@ -113,6 +123,7 @@ function registerSearch(program) {
           console.log('');
         }
       } catch (err) {
+        telemetry.send('cli_error', { command: 'search', errorType: err.constructor.name });
         console.error(ui.error(err.message));
         process.exit(1);
       } finally {

package/src/commands/similarity.js

@@ -5,6 +5,7 @@ const { generateEmbeddings } = require('../lib/api');
 const { cosineSimilarity } = require('../lib/math');
 const { getDefaultModel } = require('../lib/catalog');
 const ui = require('../lib/ui');
+const { showCostSummary } = require('../lib/cost-display');
 
 /**
  * Register the similarity command on a Commander program.
@@ -23,6 +24,7 @@ function registerSimilarity(program) {
     .option('--json', 'Machine-readable JSON output')
     .option('-q, --quiet', 'Suppress non-essential output')
     .action(async (texts, opts) => {
+      const telemetry = require('../lib/telemetry');
       try {
         let textA = null;
         let compareTexts = [];
@@ -57,6 +59,8 @@ function registerSimilarity(program) {
           process.exit(1);
         }
 
+        const done = telemetry.timer('cli_similarity', { model: opts.model });
+
         // Batch all texts into one API call
         const allTexts = [textA, ...compareTexts];
 
@@ -113,6 +117,7 @@ function registerSimilarity(program) {
           console.log(ui.label('Text B', `"${truncate(compareTexts[0], 70)}"`));
           console.log(ui.label('Model', ui.cyan(model)));
           console.log(ui.label('Tokens', ui.dim(String(tokens))));
+          showCostSummary(model, tokens, opts);
           console.log('');
         } else {
           // One-vs-many comparison
@@ -152,9 +157,13 @@ function registerSimilarity(program) {
 
           console.log('');
           console.log(`  ${ui.dim(`${results.length} comparisons, ${tokens} tokens`)}`);
+          showCostSummary(model, tokens, opts);
           console.log('');
         }
+
+        done();
       } catch (err) {
+        telemetry.send('cli_error', { command: 'similarity', errorType: err.constructor.name });
         console.error(ui.error(err.message));
         process.exit(1);
       }

package/src/commands/store.js

@@ -29,6 +29,8 @@ function registerStore(program) {
     .option('-q, --quiet', 'Suppress non-essential output')
     .action(async (opts) => {
       let client;
+      const telemetry = require('../lib/telemetry');
+      const done = telemetry.timer('cli_store', { model: opts.model });
       try {
         // Batch mode: .jsonl file
         if (opts.file && opts.file.endsWith('.jsonl')) {
@@ -102,7 +104,9 @@ function registerStore(program) {
             console.log(ui.label('Tokens', String(embedResult.usage.total_tokens)));
           }
         }
+        done();
       } catch (err) {
+        telemetry.send('cli_error', { command: 'store', errorType: err.constructor.name });
         console.error(ui.error(err.message));
         process.exit(1);
       } finally {

package/src/commands/workflow.js

@@ -188,6 +188,12 @@ function registerWorkflow(program) {
       }
 
       // Execute workflow
+      const telemetry = require('../lib/telemetry');
+      const wfDone = telemetry.timer('cli_workflow_run', {
+        workflowName,
+        stepCount: definition.steps?.length || 0,
+        isBuiltin: !!(definition._source === 'builtin'),
+      });
       try {
         const result = await executeWorkflow(definition, {
           inputs: opts.input,
@@ -224,6 +230,8 @@ function registerWorkflow(program) {
           console.error();
         }
 
+        wfDone();
+
         // Output
         if (opts.json) {
           console.log(JSON.stringify(result.output, null, 2));
@@ -261,6 +269,269 @@ function registerWorkflow(program) {
       }
     });
 
+  // ── workflow check <path> ──
+  wfCmd
+    .command('check <path>')
+    .description('Run validation, security, and quality checks on a workflow package')
+    .option('--security', 'Run security checks only', false)
+    .option('--quality', 'Run quality checks only', false)
+    .option('--all', 'Run all check tiers', false)
+    .option('--json', 'Output machine-readable JSON', false)
+    .option('--ci', 'Output CI-optimized JSON with summary metadata', false)
+    .action((pkgPath, opts) => {
+      const { validateSchemaEnhanced, loadWorkflow } = require('../lib/workflow');
+      const { securityAudit, extractCapabilities } = require('../lib/security-audit');
+      const { qualityAudit } = require('../lib/quality-audit');
+      const fs = require('fs');
+
+      const resolvedPath = path.resolve(pkgPath);
+      const runAll = opts.all || (!opts.security && !opts.quality);
+
+      // Load workflow definition
+      let definition;
+      let pkg = {};
+      let workflowFile;
+
+      try {
+        // Check if it's a directory (package) or a single file
+        const stat = fs.statSync(resolvedPath);
+        if (stat.isDirectory()) {
+          // Package directory
+          const pkgJsonPath = path.join(resolvedPath, 'package.json');
+          if (fs.existsSync(pkgJsonPath)) {
+            pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf8'));
+          }
+          // Find workflow file
+          workflowFile = pkg.main || 'workflow.json';
+          const wfPath = path.join(resolvedPath, workflowFile);
+          if (fs.existsSync(wfPath)) {
+            definition = JSON.parse(fs.readFileSync(wfPath, 'utf8'));
+          } else {
+            console.error(ui.error(`Workflow file not found: ${wfPath}`));
+            process.exit(1);
+          }
+        } else {
+          // Single file
+          definition = loadWorkflow(resolvedPath);
+        }
+      } catch (err) {
+        console.error(ui.error(err.message));
+        process.exit(1);
+      }
+
+      const results = { schema: [], security: [], quality: [], capabilities: [] };
+
+      // L1: Schema validation (always runs)
+      if (runAll || (!opts.security && !opts.quality)) {
+        results.schema = validateSchemaEnhanced(definition);
+      }
+
+      // L2: Security
+      if (runAll || opts.security) {
+        const packageDir = fs.statSync(resolvedPath).isDirectory() ? resolvedPath : null;
+        results.security = securityAudit(definition, packageDir);
+        results.capabilities = [...extractCapabilities(definition)];
+      }
+
+      // L3: Quality
+      if (runAll || opts.quality) {
+        const packageDir = fs.statSync(resolvedPath).isDirectory() ? resolvedPath : null;
+        results.quality = qualityAudit(definition, pkg, packageDir);
+      }
+
+      // CI output (machine-readable JSON with summary metadata)
+      if (opts.ci) {
+        const criticalCount = results.security.filter(f => f.severity === 'critical').length;
+        const highCount = results.security.filter(f => f.severity === 'high').length;
+        const schemaPass = results.schema.length === 0;
+        const securityPass = criticalCount === 0 && highCount === 0;
+        const qualityPass = results.quality.filter(i => i.level === 'error').length === 0;
+        const ciOutput = {
+          schema: { pass: schemaPass, errors: results.schema },
+          security: { pass: securityPass, findings: results.security },
+          quality: { pass: qualityPass, issues: results.quality },
+          capabilities: results.capabilities,
+          summary: {
+            passAll: schemaPass && securityPass && qualityPass,
+            criticalCount,
+            highCount,
+          },
+        };
+        console.log(JSON.stringify(ciOutput, null, 2));
+        if (criticalCount > 0) process.exit(2);
+        if (highCount > 0) process.exit(1);
+        return;
+      }
+
+      // JSON output
+      if (opts.json) {
+        console.log(JSON.stringify(results, null, 2));
+        // Exit code 1 if critical/high security findings
+        const hasCritical = results.security.some(f => f.severity === 'critical' || f.severity === 'high');
+        if (hasCritical) process.exit(1);
+        return;
+      }
+
+      // Pretty output
+      console.log();
+      console.log(pc.bold(`Workflow Check: ${definition.name || pkgPath}`));
+      console.log(pc.dim('═'.repeat(50)));
+
+      // Schema
+      if (results.schema.length > 0) {
+        console.log();
+        console.log(pc.bold('Schema Validation:'));
+        for (const e of results.schema) {
+          console.log(`  ${pc.red('✗')} ${e}`);
+        }
+      } else if (runAll || (!opts.security && !opts.quality)) {
+        console.log();
+        console.log(`${pc.bold('Schema Validation:')} ${pc.green('✔ passed')}`);
+      }
+
+      // Security
+      if (runAll || opts.security) {
+        console.log();
+        console.log(pc.bold('Security Audit:'));
+        if (results.security.length === 0) {
+          console.log(`  ${pc.green('✔')} No security issues found`);
+        } else {
+          for (const f of results.security) {
+            const color = f.severity === 'critical' ? pc.red :
+                          f.severity === 'high' ? pc.red :
+                          f.severity === 'medium' ? pc.yellow : pc.dim;
+            const icon = f.severity === 'critical' || f.severity === 'high' ? '✗' : '⚠';
+            console.log(`  ${color(icon)} [${f.severity.toUpperCase()}] ${f.message}`);
+          }
+        }
+
+        // Capability flags
+        if (results.capabilities.length > 0) {
+          console.log();
+          console.log(pc.bold('Capabilities:'));
+          const capIcons = { NETWORK: '🌐', WRITE_DB: '💾', LLM: '🤖', LOOP: '🔄', READ_DB: '📊' };
+          for (const cap of results.capabilities) {
+            console.log(`  ${capIcons[cap] || '•'} ${cap}`);
+          }
+        }
+      }
+
+      // Quality
+      if (runAll || opts.quality) {
+        console.log();
+        console.log(pc.bold('Quality Audit:'));
+        if (results.quality.length === 0) {
+          console.log(`  ${pc.green('✔')} No quality issues found`);
+        } else {
+          for (const issue of results.quality) {
+            const color = issue.level === 'error' ? pc.red :
+                          issue.level === 'warning' ? pc.yellow : pc.dim;
+            const icon = issue.level === 'error' ? '✗' : issue.level === 'warning' ? '⚠' : 'ℹ';
+            console.log(`  ${color(icon)} [${issue.level.toUpperCase()}] ${issue.message}`);
+          }
+        }
+      }
+
+      console.log();
+
+      // Exit code 1 if critical/high security findings
+      const hasCritical = results.security.some(f => f.severity === 'critical' || f.severity === 'high');
+      if (hasCritical) process.exit(1);
+    });
+
+  // ── workflow test <path> ──
+  wfCmd
+    .command('test <path>')
+    .description('Run test fixtures for a workflow package')
+    .option('--test <name>', 'Run a specific test case by name')
+    .option('--json', 'Output machine-readable JSON', false)
+    .action(async (pkgPath, opts) => {
+      const { loadWorkflow } = require('../lib/workflow');
+      const { runAllTests, loadTestCases } = require('../lib/workflow-test-runner');
+      const fs = require('fs');
+
+      const resolvedPath = path.resolve(pkgPath);
+
+      // Load workflow definition
+      let definition;
+      try {
+        const stat = fs.statSync(resolvedPath);
+        if (stat.isDirectory()) {
+          const wfPath = path.join(resolvedPath, 'workflow.json');
+          if (fs.existsSync(wfPath)) {
+            definition = JSON.parse(fs.readFileSync(wfPath, 'utf8'));
+          } else {
+            console.error(ui.error(`Workflow file not found: ${wfPath}`));
+            process.exit(1);
+          }
+        } else {
+          console.error(ui.error('Path must be a workflow package directory'));
+          process.exit(1);
+        }
+      } catch (err) {
+        console.error(ui.error(err.message));
+        process.exit(1);
+      }
+
+      // Check for tests directory
+      const testsDir = path.join(resolvedPath, 'tests');
+      if (!fs.existsSync(testsDir)) {
+        console.error(ui.error('No tests/ directory found in package'));
+        process.exit(1);
+      }
+
+      const testCases = loadTestCases(resolvedPath);
+      if (testCases.length === 0) {
+        console.error(ui.error('No *.test.json files found in tests/'));
+        process.exit(1);
+      }
+
+      try {
+        const aggregate = await runAllTests(definition, resolvedPath, {
+          testName: opts.test,
+        });
+
+        if (opts.json) {
+          console.log(JSON.stringify(aggregate, null, 2));
+          if (aggregate.failed > 0) process.exit(1);
+          return;
+        }
+
+        // Pretty output
+        console.log();
+        console.log(pc.bold(`Workflow Tests: ${definition.name || pkgPath}`));
+        console.log(pc.dim('═'.repeat(50)));
+        console.log();
+
+        for (const result of aggregate.results) {
+          const icon = result.passed ? pc.green('✔') : pc.red('✗');
+          console.log(`${icon} ${result.name || result.file}`);
+
+          if (result.error) {
+            console.log(`  ${pc.red(result.error)}`);
+          }
+
+          for (const assertion of result.assertions) {
+            const aIcon = assertion.pass ? pc.green('  ✔') : pc.red('  ✗');
+            console.log(`${aIcon} ${assertion.message}`);
+          }
+
+          for (const err of (result.errors || [])) {
+            console.log(`  ${pc.red('Error:')} ${err}`);
+          }
+        }
+
+        console.log();
+        console.log(`${pc.bold('Summary:')} ${pc.green(`${aggregate.passed} passed`)}, ${aggregate.failed > 0 ? pc.red(`${aggregate.failed} failed`) : `${aggregate.failed} failed`}`);
+        console.log();
+
+        if (aggregate.failed > 0) process.exit(1);
+      } catch (err) {
+        console.error(ui.error(err.message));
+        process.exit(1);
+      }
+    });
+
   // ── workflow validate <file> ──
   wfCmd
     .command('validate <file>')
@@ -404,9 +675,11 @@ function registerWorkflow(program) {
         packageName = WORKFLOW_PREFIX + packageName;
       }
 
+      const telemetry = require('../lib/telemetry');
       console.log(`Installing ${pc.cyan(packageName)}...`);
 
       try {
+        telemetry.send('cli_workflow_install', { packageName });
         const result = installPackage(packageName, { global: opts.global });
         console.log(`${pc.green('✔')} Downloaded ${pc.cyan(packageName)}@${result.version}`);
 
@@ -417,6 +690,17 @@ function registerWorkflow(program) {
             const steps = validation.definition?.steps?.length || 0;
             const tools = (validation.pkg?.vai?.tools || []).join(', ');
             console.log(`${pc.green('✔')} Validated workflow definition (${steps} steps${tools ? `, tools: ${tools}` : ''})`);
+
+            // Display capability flags
+            if (validation.definition) {
+              const { extractCapabilities } = require('../lib/security-audit');
+              const caps = extractCapabilities(validation.definition);
+              if (caps.size > 0) {
+                const capIcons = { NETWORK: '🌐', WRITE_DB: '💾', LLM: '🤖', LOOP: '🔄', READ_DB: '📊' };
+                const capList = [...caps].map(c => `${capIcons[c] || '•'} ${c}`).join('  ');
+                console.log(`${pc.dim('Capabilities:')} ${capList}`);
+              }
+            }
           } else {
             console.log(`${pc.yellow('⚠')} Validation issues:`);
             for (const e of validation.errors) {
@@ -479,11 +763,13 @@ function registerWorkflow(program) {
     .action(async (query, opts) => {
       const { searchNpm } = require('../lib/npm-utils');
 
+      const telemetry = require('../lib/telemetry');
       console.log(`Searching npm for vai-workflow packages matching "${query}"...`);
       console.log();
 
       try {
         const results = await searchNpm(query, { limit: parseInt(opts.limit, 10) });
+        telemetry.send('cli_workflow_search', { query: query.slice(0, 50), resultCount: results.length });
 
         if (opts.json) {
           console.log(JSON.stringify(results, null, 2));