fix(cli): handle pnpm build approvals

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

Author: coryrylan

projects/cli/README.md

@@ -115,6 +115,17 @@ Install to Cursor with the MCP configuration below.
 }
 ```
 
+### Codex
+
+Install to Codex with the MCP configuration below.
+
+```toml
+[mcp_servers.elements]
+description = "NVIDIA Elements UI Design System (nve-*), custom element schemas, APIs and examples"
+command = "nve"
+args = ["mcp"]
+```
+
 ### Prompts
 
 | Prompt | Description | Example Prompt |

projects/internals/tools/src/api/utils.test.ts

@@ -8,9 +8,14 @@ import {
   getContextAPIs,
   getContextTokens,
   getPublishedPackageNames,
+  searchContextAPIs,
   type PartialAPIResult
 } from './utils.js';
 
+vi.mock('@internals/metadata', () => ({
+  ApiService: { search: vi.fn() }
+}));
+
 describe('getPublishedPackageNames', () => {
   const projects = [
     {
@@ -613,4 +618,88 @@ describe('attributeMetadataToMarkdown', () => {
 
     expect(markdown.includes('| `disabled` | `string` |`true` |')).toBe(true);
   });
+
+  it('should use the built-in example for nve-layout', () => {
+    const attribute: Attribute = {
+      name: 'nve-layout',
+      description: 'Layout utility attribute',
+      example: '',
+      markdown: '',
+      values: [{ name: 'row' }, { name: 'column' }]
+    };
+
+    const markdown = attributeMetadataToMarkdown(attribute);
+
+    expect(markdown).toContain('## nve-layout');
+    expect(markdown).toContain('nve-layout="row gap:sm"');
+    expect(markdown).toContain('nve-layout="grid gap:sm span-items:6"');
+  });
+
+  it('should use the built-in example for nve-text', () => {
+    const attribute: Attribute = {
+      name: 'nve-text',
+      description: 'Typography utility attribute',
+      example: '',
+      markdown: '',
+      values: [{ name: 'heading' }, { name: 'body' }]
+    };
+
+    const markdown = attributeMetadataToMarkdown(attribute);
+
+    expect(markdown).toContain('## nve-text');
+    expect(markdown).toContain('nve-text="heading"');
+    expect(markdown).toContain('nve-text="monospace"');
+  });
+});
+
+describe('searchContextAPIs', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should attach markdown to attribute results that have values', async () => {
+    const { ApiService } = await import('@internals/metadata');
+    vi.mocked(ApiService.search).mockResolvedValue([
+      { name: 'nve-layout', description: 'Layout utility', values: [{ name: 'row' }], markdown: '' }
+    ] as never);
+
+    const results = (await searchContextAPIs('layout')) as Attribute[];
+
+    expect(results).toHaveLength(1);
+    expect(results[0].markdown).toContain('## nve-layout');
+  });
+
+  it('should leave element results without a markdown field untouched', async () => {
+    const { ApiService } = await import('@internals/metadata');
+    vi.mocked(ApiService.search).mockResolvedValue([
+      { name: 'nve-button', manifest: { metadata: { markdown: 'x' } } }
+    ] as never);
+
+    const results = (await searchContextAPIs('button')) as Element[];
+
+    expect(results).toHaveLength(1);
+    expect((results[0] as Attribute).markdown).toBeUndefined();
+  });
+
+  it('should limit results to the configured limit', async () => {
+    const { ApiService } = await import('@internals/metadata');
+    vi.mocked(ApiService.search).mockResolvedValue(
+      Array.from({ length: 5 }, (_, index) => ({ name: `nve-item-${index}` })) as never
+    );
+
+    const results = await searchContextAPIs('item', { limit: 2 });
+
+    expect(results).toHaveLength(2);
+  });
+
+  it('should return every result when no limit is provided', async () => {
+    const { ApiService } = await import('@internals/metadata');
+    vi.mocked(ApiService.search).mockResolvedValue(
+      Array.from({ length: 5 }, (_, index) => ({ name: `nve-item-${index}` })) as never
+    );
+
+    const results = await searchContextAPIs('item', {});
+
+    expect(results).toHaveLength(5);
+  });
 });

projects/internals/tools/src/distill/examples.test.ts

@@ -128,6 +128,10 @@ describe('isContextExample', () => {
       })
     ).toBe(false);
   });
+
+  it('should treat an example with no id, tags, or element as a default', () => {
+    expect(isContextExample({})).toBe(true);
+  });
 });
 
 describe('rankExample', () => {
@@ -147,6 +151,10 @@ describe('rankExample', () => {
     expect(rankExample({ id: 'button-default' })).toBe(3);
   });
 
+  it('should default to the lowest rank when the id is missing', () => {
+    expect(rankExample({})).toBe(3);
+  });
+
   it('should strip elements- prefix before ranking', () => {
     expect(rankExample({ id: 'elements-template-foo' })).toBe(0);
     expect(rankExample({ id: 'elements-pattern-form' })).toBe(1);
@@ -267,4 +275,18 @@ describe('distillExamples', () => {
     expect(result).toHaveLength(1);
     expect(result[0].summary).toBe('Has summary');
   });
+
+  it('should default every shaped field when examples omit them', () => {
+    const result = distillExamples([{}, {}]);
+
+    expect(result).toHaveLength(2);
+    expect(result[0]).toEqual({ id: '', name: '', summary: '', element: '', template: '' });
+  });
+
+  it('should fall back to the description when the summary is missing', () => {
+    const result = distillExamples([{ id: 'widget', element: 'nve-widget', description: 'Reusable widget' }]);
+
+    expect(result).toHaveLength(1);
+    expect(result[0].summary).toBe('Reusable widget');
+  });
 });

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

@@ -162,5 +162,68 @@ describe('internal/node', () => {
 
       expect(result).toEqual([]);
     });
+
+    it('should ignore PATH entries that are not regular files', async () => {
+      const { existsSync, statSync } = await import('node:fs');
+      vi.mocked(existsSync).mockReturnValue(true);
+      vi.mocked(statSync).mockReturnValue({ isFile: () => false } as ReturnType<typeof statSync>);
+
+      const { findExecutablesOnPath } = await import('./node.js');
+      const result = findExecutablesOnPath('nve', { envPath: '/a' });
+
+      expect(result).toEqual([]);
+    });
+
+    it('should expand the command with explicit PATHEXT extensions on win32', async () => {
+      const { existsSync, statSync, realpathSync } = await import('node:fs');
+      vi.mocked(existsSync).mockReturnValue(true);
+      vi.mocked(statSync).mockReturnValue({ isFile: () => true } as ReturnType<typeof statSync>);
+      vi.mocked(realpathSync).mockImplementation(path => path.toString());
+
+      const { findExecutablesOnPath } = await import('./node.js');
+      const result = findExecutablesOnPath('nve', { envPath: 'C:/bin', platform: 'win32', pathExt: '.EXE;.CMD' });
+
+      expect(result.some(commandPath => commandPath.toLowerCase().endsWith('nve.exe'))).toBe(true);
+      expect(result.some(commandPath => commandPath.toLowerCase().endsWith('nve.cmd'))).toBe(true);
+    });
+
+    it('should fall back to the PATHEXT environment variable on win32', async () => {
+      const { existsSync, statSync, realpathSync } = await import('node:fs');
+      vi.mocked(existsSync).mockReturnValue(true);
+      vi.mocked(statSync).mockReturnValue({ isFile: () => true } as ReturnType<typeof statSync>);
+      vi.mocked(realpathSync).mockImplementation(path => path.toString());
+      vi.stubEnv('PATHEXT', '.BAT');
+
+      const { findExecutablesOnPath } = await import('./node.js');
+      const result = findExecutablesOnPath('nve', { envPath: 'C:/bin', platform: 'win32' });
+
+      expect(result.some(commandPath => commandPath.toLowerCase().endsWith('nve.bat'))).toBe(true);
+      vi.unstubAllEnvs();
+    });
+
+    it('should treat any matching file as executable on win32 without an access check', async () => {
+      const { accessSync, existsSync, statSync, realpathSync } = await import('node:fs');
+      vi.mocked(existsSync).mockReturnValue(true);
+      vi.mocked(statSync).mockReturnValue({ isFile: () => true } as ReturnType<typeof statSync>);
+      vi.mocked(realpathSync).mockImplementation(path => path.toString());
+
+      const { findExecutablesOnPath } = await import('./node.js');
+      const result = findExecutablesOnPath('nve', { envPath: 'C:/bin', platform: 'win32', pathExt: '.EXE' });
+
+      expect(result.length).toBeGreaterThan(0);
+      expect(accessSync).not.toHaveBeenCalled();
+    });
+
+    it('should default to process PATH and platform when options are omitted', async () => {
+      const { existsSync } = await import('node:fs');
+      vi.mocked(existsSync).mockReturnValue(false);
+      vi.stubEnv('PATH', '/usr/bin:/bin');
+
+      const { findExecutablesOnPath } = await import('./node.js');
+      const result = findExecutablesOnPath('definitely-not-a-real-command');
+
+      expect(result).toEqual([]);
+      vi.unstubAllEnvs();
+    });
   });
 });

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

@@ -1,9 +1,9 @@
 // SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import { describe, expect, it } from 'vitest';
+import { afterEach, describe, expect, it, vi } from 'vitest';
 import type { ProjectElement } from '@internals/metadata';
-import { getElementImports, getAvailableElementTags, wrapText } from './utils.js';
+import { getElementImports, getAvailableElementTags, isDebug, wrapText } from './utils.js';
 
 describe('getElementImports', () => {
   const elements: ProjectElement[] = [
@@ -124,4 +124,33 @@ describe('wrapText', () => {
     const result = wrapText(text, 10);
     expect(result).toContain('superlongwordthatexceedswidth');
   });
+
+  it('should handle a single word longer than width with nothing trailing', () => {
+    const text = 'superlongwordthatexceedswidth';
+    expect(wrapText(text, 10)).toBe('superlongwordthatexceedswidth');
+  });
+});
+
+describe('isDebug', () => {
+  afterEach(() => {
+    vi.unstubAllEnvs();
+  });
+
+  it('should return true when debug is enabled outside of the mcp environment', () => {
+    vi.stubEnv('ELEMENTS_DEBUG', 'true');
+    vi.stubEnv('ELEMENTS_ENV', 'cli');
+    expect(isDebug()).toBe(true);
+  });
+
+  it('should return false when debug is not enabled', () => {
+    vi.stubEnv('ELEMENTS_DEBUG', 'false');
+    vi.stubEnv('ELEMENTS_ENV', 'cli');
+    expect(isDebug()).toBe(false);
+  });
+
+  it('should return false in the mcp environment even when debug is enabled', () => {
+    vi.stubEnv('ELEMENTS_DEBUG', 'true');
+    vi.stubEnv('ELEMENTS_ENV', 'mcp');
+    expect(isDebug()).toBe(false);
+  });
 });

projects/internals/tools/src/packages/utils.test.ts

@@ -4,7 +4,9 @@
 import { describe, expect, it, vi } from 'vitest';
 import {
   findPublicAPIChangelog,
+  getAvailablePackages,
   getPackage,
+  getVersions,
   hasChangelogEntries,
   limitChangelogVersions,
   scopeOrder
@@ -198,4 +200,47 @@ describe('getPackage', () => {
     expect(result).toContain('# @nvidia-elements/core v1.0.0');
     expect(result).toContain('No readme pkg');
   });
+
+  it('should throw with no available packages when metadata is missing', async () => {
+    const { ProjectsService } = await import('@internals/metadata');
+    vi.mocked(ProjectsService.getData).mockResolvedValueOnce(undefined as never);
+
+    await expect(getPackage('@nvidia-elements/core')).rejects.toThrow('No package found for "@nvidia-elements/core"');
+  });
+});
+
+describe('getVersions', () => {
+  it('should resolve the latest published versions for available packages', async () => {
+    const result = await getVersions();
+    expect(result).toEqual({
+      '@nvidia-elements/core': '2.0.0',
+      '@nvidia-elements/themes': '1.5.0'
+    });
+  });
+
+  it('should default to an empty package list when metadata is missing', async () => {
+    const { ProjectsService } = await import('@internals/metadata');
+    vi.mocked(ProjectsService.getData).mockResolvedValueOnce(undefined as never);
+
+    const result = await getVersions();
+    expect(result).toBeDefined();
+  });
+});
+
+describe('getAvailablePackages', () => {
+  it('should format available packages as markdown sections', async () => {
+    const result = await getAvailablePackages();
+    expect(result).toContain('## @nvidia-elements/core v2.0.0');
+    expect(result).toContain('Core elements');
+    expect(result).toContain('## @nvidia-elements/themes v1.5.0');
+    expect(result).toContain('Theme tokens');
+  });
+
+  it('should return an empty string when metadata is missing', async () => {
+    const { ProjectsService } = await import('@internals/metadata');
+    vi.mocked(ProjectsService.getData).mockResolvedValueOnce(undefined as never);
+
+    const result = await getAvailablePackages();
+    expect(result).toBe('');
+  });
 });

projects/internals/tools/src/project/setup-agent.test.ts

@@ -171,6 +171,9 @@ describe('setup-mcp', () => {
 
       const written = vi.mocked(writeFileSync).mock.calls[0][1] as string;
       expect(written).toContain('[mcp_servers.elements]');
+      expect(written).toContain(
+        'description = "NVIDIA Elements UI Design System (nve-*), custom element schemas, APIs and examples"'
+      );
       expect(written).toContain('command = "nve"');
       expect(written).toContain('args = ["mcp"]');
     });

projects/internals/tools/src/project/setup-agent.ts

@@ -65,7 +65,7 @@ export function writeMcpTomlConfig(configPath: string): string {
 
   const sectionRegex = new RegExp(`\\[mcp_servers\\.elements\\][\\s\\S]*?(?=\\n\\[|$)`);
   const content = existing.replace(sectionRegex, '').trimEnd();
-  const block = `\n\n[mcp_servers.elements]\ncommand = "nve"\nargs = ["mcp"]\n`;
+  const block = `\n\n[mcp_servers.elements]\ndescription = "${DESCRIPTION}"\ncommand = "nve"\nargs = ["mcp"]\n`;
   const updated = (content + block).trimStart();
   const dir = configPath.substring(0, configPath.lastIndexOf('/'));