feat(cli): add multiple version detection

Signed-off-by: Cory Rylan <crylan@nvidia.com>

Author: coryrylan

projects/internals/tools/src/internal/node.test.ts

@@ -9,7 +9,11 @@ vi.mock('node:child_process', () => ({
 }));
 
 vi.mock('node:fs', () => ({
+  accessSync: vi.fn(),
+  constants: { X_OK: 1 },
   existsSync: vi.fn(),
+  realpathSync: vi.fn(),
+  statSync: vi.fn(),
   readFileSync: vi.fn()
 }));
 
@@ -37,7 +41,7 @@ describe('internal/node', () => {
   describe('isCommandAvailable', () => {
     it('should return true when command exits with code 0', async () => {
       const { spawn } = await import('node:child_process');
-      vi.mocked(spawn).mockReturnValue(createMockChild(0) as ReturnType<typeof spawn>);
+      vi.mocked(spawn).mockImplementation(() => createMockChild(0) as ReturnType<typeof spawn>);
 
       const { isCommandAvailable } = await import('./node.js');
       const result = await isCommandAvailable('pnpm');
@@ -46,7 +50,7 @@ describe('internal/node', () => {
 
     it('should return false when command exits with non-zero code', async () => {
       const { spawn } = await import('node:child_process');
-      vi.mocked(spawn).mockReturnValue(createMockChild(1) as ReturnType<typeof spawn>);
+      vi.mocked(spawn).mockImplementation(() => createMockChild(1) as ReturnType<typeof spawn>);
 
       const { isCommandAvailable } = await import('./node.js');
       const result = await isCommandAvailable('missing-tool');
@@ -55,7 +59,7 @@ describe('internal/node', () => {
 
     it('should return false when spawn errors', async () => {
       const { spawn } = await import('node:child_process');
-      vi.mocked(spawn).mockReturnValue(createMockChild(0, true) as ReturnType<typeof spawn>);
+      vi.mocked(spawn).mockImplementation(() => createMockChild(0, true) as ReturnType<typeof spawn>);
 
       const { isCommandAvailable } = await import('./node.js');
       const result = await isCommandAvailable('not-found');
@@ -118,4 +122,45 @@ describe('internal/node', () => {
       expect(result.version).toBe('1.0.0');
     });
   });
+
+  describe('findExecutablesOnPath', () => {
+    it('should find and dedupe executables on PATH by real path', async () => {
+      const { existsSync, realpathSync, statSync } = await import('node:fs');
+      vi.mocked(existsSync).mockReturnValue(true);
+      vi.mocked(statSync).mockReturnValue({ isFile: () => true } as ReturnType<typeof statSync>);
+      vi.mocked(realpathSync).mockImplementation(path => {
+        return path.toString().startsWith('/b/') ? '/a/nve' : path.toString();
+      });
+
+      const { findExecutablesOnPath } = await import('./node.js');
+      const result = findExecutablesOnPath('nve', { envPath: '/a:/b' });
+
+      expect(result).toEqual(['/a/nve']);
+    });
+
+    it('should ignore PATH entries that do not contain the command', async () => {
+      const { existsSync, statSync } = await import('node:fs');
+      vi.mocked(existsSync).mockReturnValue(false);
+      vi.mocked(statSync).mockReturnValue({ isFile: () => true } as ReturnType<typeof statSync>);
+
+      const { findExecutablesOnPath } = await import('./node.js');
+      const result = findExecutablesOnPath('nve', { envPath: '/a:/b' });
+
+      expect(result).toEqual([]);
+    });
+
+    it('should ignore files that are not executable on POSIX platforms', async () => {
+      const { accessSync, existsSync, statSync } = await import('node:fs');
+      vi.mocked(existsSync).mockReturnValue(true);
+      vi.mocked(statSync).mockReturnValue({ isFile: () => true } as ReturnType<typeof statSync>);
+      vi.mocked(accessSync).mockImplementation(() => {
+        throw new Error('not executable');
+      });
+
+      const { findExecutablesOnPath } = await import('./node.js');
+      const result = findExecutablesOnPath('nve', { envPath: '/a' });
+
+      expect(result).toEqual([]);
+    });
+  });
 });

projects/internals/tools/src/internal/node.ts

@@ -2,8 +2,14 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { spawn } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import { accessSync, constants, existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { delimiter, join, resolve } from 'node:path';
+
+interface FindExecutablesOptions {
+  envPath?: string;
+  platform?: NodeJS.Platform;
+  pathExt?: string;
+}
 
 export async function getNPMClient() {
   const hasNPM = await isCommandAvailable('npm');
@@ -28,3 +34,68 @@ export function getPackageJson(cwd: string) {
 
   return JSON.parse(readFileSync(packageJsonPath, 'utf8'));
 }
+
+export function findExecutablesOnPath(command: string, options: FindExecutablesOptions = {}) {
+  const envPath = options.envPath ?? process.env.PATH ?? '';
+  const commandNames = getExecutableNames(command, options);
+  const executables = new Map<string, string>();
+
+  envPath
+    .split(delimiter)
+    .filter(Boolean)
+    .forEach(directory => {
+      commandNames.forEach(commandName => {
+        const commandPath = resolve(directory, commandName);
+
+        if (!existsSync(commandPath)) {
+          return;
+        }
+
+        try {
+          if (!isExecutableFile(commandPath, options.platform ?? process.platform)) {
+            return;
+          }
+
+          const realpath = realpathSync(commandPath);
+          if (!executables.has(realpath)) {
+            executables.set(realpath, commandPath);
+          }
+        } catch {
+          // Ignore PATH entries this process cannot inspect.
+        }
+      });
+    });
+
+  return [...executables.values()];
+}
+
+function getExecutableNames(command: string, options: FindExecutablesOptions) {
+  if ((options.platform ?? process.platform) !== 'win32') {
+    return [command];
+  }
+
+  const pathExt = options.pathExt ?? process.env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD;.PS1';
+  const extensions = pathExt
+    .split(';')
+    .filter(Boolean)
+    .map(extension => extension.toLowerCase());
+
+  return [command, ...extensions.map(extension => `${command}${extension}`)];
+}
+
+function isExecutableFile(commandPath: string, platform: NodeJS.Platform) {
+  if (!statSync(commandPath).isFile()) {
+    return false;
+  }
+
+  if (platform === 'win32') {
+    return true;
+  }
+
+  try {
+    accessSync(commandPath, constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}

projects/internals/tools/src/project/health.test.ts

@@ -5,6 +5,7 @@ import { describe, expect, it, vi, beforeEach } from 'vitest';
 import type { Project } from '@internals/metadata';
 import type { Result } from 'publint';
 import {
+  checkCliInstallations,
   checkDependencies,
   checkPeerDependencies,
   checkSemanticDependencies,
@@ -15,6 +16,7 @@ import {
 } from './health.js';
 import type { ElementVersions } from '../api/utils.js';
 import type { PackageData } from '../internal/types.js';
+import { findExecutablesOnPath } from '../internal/node.js';
 
 // Mock the publint module
 vi.mock('publint', () => ({
@@ -23,6 +25,7 @@ vi.mock('publint', () => ({
 
 // Mock the internal node module
 vi.mock('../internal/node.js', () => ({
+  findExecutablesOnPath: vi.fn(() => []),
   getPackageJson: vi.fn()
 }));
 
@@ -39,6 +42,11 @@ vi.mock('../api/utils.js', () => ({
   getPublishedProjects: vi.fn((projects: { name: string }[]) => projects)
 }));
 
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.mocked(findExecutablesOnPath).mockReturnValue([]);
+});
+
 describe('getVersionNum', () => {
   it('should return the correct version number', () => {
     expect(getVersionNum('1.0.0')).toEqual({ major: 1, minor: 0, patch: 0 });
@@ -121,6 +129,41 @@ describe('getVersionStatus', () => {
   });
 });
 
+describe('checkCliInstallations', () => {
+  it('should return success when a single nve CLI is found on PATH', () => {
+    vi.mocked(findExecutablesOnPath).mockReturnValue(['/usr/local/bin/nve']);
+
+    const result = checkCliInstallations();
+
+    expect(result).toEqual({
+      message: 'One nve CLI executable found on PATH: /usr/local/bin/nve',
+      status: 'success'
+    });
+  });
+
+  it('should return danger when multiple nve CLIs are found on PATH', () => {
+    vi.mocked(findExecutablesOnPath).mockReturnValue(['/usr/local/bin/nve', '/Users/test/Library/pnpm/nve']);
+
+    const result = checkCliInstallations();
+
+    expect(result.status).toBe('danger');
+    expect(result.message).toBe(
+      'Multiple nve CLI executables found on PATH: /usr/local/bin/nve, /Users/test/Library/pnpm/nve'
+    );
+  });
+
+  it('should return warning when no nve CLI executable is found on PATH', () => {
+    vi.mocked(findExecutablesOnPath).mockReturnValue([]);
+
+    const result = checkCliInstallations();
+
+    expect(result).toEqual({
+      message: 'No nve CLI executable found on PATH',
+      status: 'warning'
+    });
+  });
+});
+
 describe('getVersionHealth', () => {
   it('should return the correct version health', async () => {
     expect(
@@ -599,10 +642,10 @@ describe('checkSemanticDependencies', () => {
 
 describe('getHealthReport', () => {
   beforeEach(() => {
-    vi.clearAllMocks();
+    vi.mocked(findExecutablesOnPath).mockReturnValue(['/usr/local/bin/nve']);
   });
 
-  it('should return health report for application type with only dependencies check', async () => {
+  it('should return health report for application type with dependencies and CLI checks', async () => {
     const { getPackageJson } = await import('../internal/node.js');
     const { ProjectsService } = await import('@internals/metadata');
     const { getLatestPublishedVersions } = await import('../api/utils.js');
@@ -611,7 +654,10 @@ describe('getHealthReport', () => {
       created: string;
       data: Project[];
     });
-    vi.mocked(getLatestPublishedVersions).mockResolvedValue({ '@nvidia-elements/core': '1.0.0' } as ElementVersions);
+    vi.mocked(getLatestPublishedVersions).mockResolvedValue({
+      '@nvidia-elements/core': '1.0.0',
+      '@nvidia-elements/cli': '1.0.0'
+    } as ElementVersions);
     vi.mocked(getPackageJson).mockReturnValue({
       dependencies: { '@nvidia-elements/core': '^1.0.0' },
       devDependencies: {},
@@ -620,11 +666,16 @@ describe('getHealthReport', () => {
 
     const result = await getHealthReport('/test/path', 'application');
     expect(result).toHaveProperty('dependencies');
+    expect(result).toHaveProperty('cliInstallations');
     expect(result).not.toHaveProperty('peerDependencies');
     expect(result).not.toHaveProperty('semanticDependencies');
     expect(result.dependencies).toHaveProperty('versions');
     expect(result.dependencies).toHaveProperty('status');
     expect(result.dependencies).toHaveProperty('message');
+    expect(result.cliInstallations).toEqual({
+      message: 'One nve CLI executable found on PATH: /usr/local/bin/nve',
+      status: 'success'
+    });
   });
 
   it('should return health report for library type with all checks', async () => {
@@ -637,7 +688,10 @@ describe('getHealthReport', () => {
       created: string;
       data: Project[];
     });
-    vi.mocked(getLatestPublishedVersions).mockResolvedValue({ '@nvidia-elements/core': '1.0.0' } as ElementVersions);
+    vi.mocked(getLatestPublishedVersions).mockResolvedValue({
+      '@nvidia-elements/core': '1.0.0',
+      '@nvidia-elements/cli': '1.0.0'
+    } as ElementVersions);
     vi.mocked(publint).mockResolvedValue({ messages: [] } as Result);
     vi.mocked(getPackageJson).mockReturnValue({
       dependencies: {},
@@ -647,6 +701,7 @@ describe('getHealthReport', () => {
 
     const result = await getHealthReport('/test/path', 'library');
     expect(result).toHaveProperty('dependencies');
+    expect(result).toHaveProperty('cliInstallations');
     expect(result).toHaveProperty('peerDependencies');
     expect(result).toHaveProperty('semanticDependencies');
     expect(result.peerDependencies).toHaveProperty('status');

projects/internals/tools/src/project/health.ts

@@ -5,15 +5,16 @@ import { publint as publintFn } from 'publint';
 import { ProjectsService } from '@internals/metadata';
 import { type ElementVersions, getLatestPublishedVersions, getPublishedProjects } from '../api/utils.js';
 import type { ReportCheck, Report, PackageData } from '../internal/types.js';
-import { getPackageJson } from '../internal/node.js';
+import { findExecutablesOnPath, getPackageJson } from '../internal/node.js';
 
 export async function getHealthReport(cwd: string, type: 'application' | 'library') {
   const packageJson = getPackageJson(cwd);
   const projects = getPublishedProjects((await ProjectsService.getData()).data);
   const currentVersions = await getLatestPublishedVersions(projects);
 
   let report: Report = {
-    dependencies: await checkDependencies(packageJson, currentVersions)
+    dependencies: await checkDependencies(packageJson, currentVersions),
+    cliInstallations: checkCliInstallations()
   };
 
   if (type === 'library') {
@@ -77,6 +78,35 @@ export function getVersionNum(value: string): { major: number; minor: number; pa
   };
 }
 
+export function checkCliInstallations(): ReportCheck {
+  const paths = findExecutablesOnPath('nve');
+
+  if (!paths.length) {
+    return {
+      message: 'No nve CLI executable found on PATH',
+      status: 'warning'
+    };
+  }
+
+  const summary = formatCliInstallations(paths);
+
+  if (paths.length > 1) {
+    return {
+      message: `Multiple nve CLI executables found on PATH: ${summary}`,
+      status: 'danger'
+    };
+  }
+
+  return {
+    message: `One nve CLI executable found on PATH: ${summary}`,
+    status: 'success'
+  };
+}
+
+function formatCliInstallations(paths: string[]) {
+  return paths.join(', ');
+}
+
 async function checkPublint(cwd: string): Promise<Report> {
   const { messages } = await publintFn({
     pkgDir: cwd,