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,
 typePartialAPIResult
 }from'./utils.js';
 
+vi.mock('@internals/metadata',()=>({
+ApiService: {search: vi.fn()}
+}));
+
 describe('getPublishedPackageNames',()=>{
 constprojects=[
 {
@@ -613,4 +618,88 @@ describe('attributeMetadataToMarkdown', () => {
 
 expect(markdown.includes('| `disabled` | `string` |`true` |')).toBe(true);
 });
+
+it('should use the built-in example for nve-layout',()=>{
+constattribute: Attribute={
+name: 'nve-layout',
+description: 'Layout utility attribute',
+example: '',
+markdown: '',
+values: [{name: 'row'},{name: 'column'}]
+};
+
+constmarkdown=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',()=>{
+constattribute: Attribute={
+name: 'nve-text',
+description: 'Typography utility attribute',
+example: '',
+markdown: '',
+values: [{name: 'heading'},{name: 'body'}]
+};
+
+constmarkdown=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 }=awaitimport('@internals/metadata');
+vi.mocked(ApiService.search).mockResolvedValue([
+{name: 'nve-layout',description: 'Layout utility',values: [{name: 'row'}],markdown: ''}
+]asnever);
+
+constresults=(awaitsearchContextAPIs('layout'))asAttribute[];
+
+expect(results).toHaveLength(1);
+expect(results[0].markdown).toContain('## nve-layout');
+});
+
+it('should leave element results without a markdown field untouched',async()=>{
+const{ ApiService }=awaitimport('@internals/metadata');
+vi.mocked(ApiService.search).mockResolvedValue([
+{name: 'nve-button',manifest: {metadata: {markdown: 'x'}}}
+]asnever);
+
+constresults=(awaitsearchContextAPIs('button'))asElement[];
+
+expect(results).toHaveLength(1);
+expect((results[0]asAttribute).markdown).toBeUndefined();
+});
+
+it('should limit results to the configured limit',async()=>{
+const{ ApiService }=awaitimport('@internals/metadata');
+vi.mocked(ApiService.search).mockResolvedValue(
+Array.from({length: 5},(_,index)=>({name: `nve-item-${index}`}))asnever
+);
+
+constresults=awaitsearchContextAPIs('item',{limit: 2});
+
+expect(results).toHaveLength(2);
+});
+
+it('should return every result when no limit is provided',async()=>{
+const{ ApiService }=awaitimport('@internals/metadata');
+vi.mocked(ApiService.search).mockResolvedValue(
+Array.from({length: 5},(_,index)=>({name: `nve-item-${index}`}))asnever
+);
+
+constresults=awaitsearchContextAPIs('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',()=>{
+constresult=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',()=>{
+constresult=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 }=awaitimport('node:fs');
+vi.mocked(existsSync).mockReturnValue(true);
+vi.mocked(statSync).mockReturnValue({isFile: ()=>false}asReturnType<typeofstatSync>);
+
+const{ findExecutablesOnPath }=awaitimport('./node.js');
+constresult=findExecutablesOnPath('nve',{envPath: '/a'});
+
+expect(result).toEqual([]);
+});
+
+it('should expand the command with explicit PATHEXT extensions on win32',async()=>{
+const{ existsSync, statSync, realpathSync }=awaitimport('node:fs');
+vi.mocked(existsSync).mockReturnValue(true);
+vi.mocked(statSync).mockReturnValue({isFile: ()=>true}asReturnType<typeofstatSync>);
+vi.mocked(realpathSync).mockImplementation(path=>path.toString());
+
+const{ findExecutablesOnPath }=awaitimport('./node.js');
+constresult=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 }=awaitimport('node:fs');
+vi.mocked(existsSync).mockReturnValue(true);
+vi.mocked(statSync).mockReturnValue({isFile: ()=>true}asReturnType<typeofstatSync>);
+vi.mocked(realpathSync).mockImplementation(path=>path.toString());
+vi.stubEnv('PATHEXT','.BAT');
+
+const{ findExecutablesOnPath }=awaitimport('./node.js');
+constresult=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 }=awaitimport('node:fs');
+vi.mocked(existsSync).mockReturnValue(true);
+vi.mocked(statSync).mockReturnValue({isFile: ()=>true}asReturnType<typeofstatSync>);
+vi.mocked(realpathSync).mockImplementation(path=>path.toString());
+
+const{ findExecutablesOnPath }=awaitimport('./node.js');
+constresult=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 }=awaitimport('node:fs');
+vi.mocked(existsSync).mockReturnValue(false);
+vi.stubEnv('PATH','/usr/bin:/bin');
+
+const{ findExecutablesOnPath }=awaitimport('./node.js');
+constresult=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';
 importtype{ProjectElement}from'@internals/metadata';
-import{getElementImports,getAvailableElementTags,wrapText}from'./utils.js';
+import{getElementImports,getAvailableElementTags,isDebug,wrapText}from'./utils.js';
 
 describe('getElementImports',()=>{
 constelements: ProjectElement[]=[
@@ -124,4 +124,33 @@ describe('wrapText', () => {
 constresult=wrapText(text,10);
 expect(result).toContain('superlongwordthatexceedswidth');
 });
+
+it('should handle a single word longer than width with nothing trailing',()=>{
+consttext='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 }=awaitimport('@internals/metadata');
+vi.mocked(ProjectsService.getData).mockResolvedValueOnce(undefinedasnever);
+
+awaitexpect(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()=>{
+constresult=awaitgetVersions();
+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 }=awaitimport('@internals/metadata');
+vi.mocked(ProjectsService.getData).mockResolvedValueOnce(undefinedasnever);
+
+constresult=awaitgetVersions();
+expect(result).toBeDefined();
+});
+});
+
+describe('getAvailablePackages',()=>{
+it('should format available packages as markdown sections',async()=>{
+constresult=awaitgetAvailablePackages();
+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 }=awaitimport('@internals/metadata');
+vi.mocked(ProjectsService.getData).mockResolvedValueOnce(undefinedasnever);
+
+constresult=awaitgetAvailablePackages();
+expect(result).toBe('');
+});
 });

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

@@ -171,6 +171,9 @@ describe('setup-mcp', () => {
 
 constwritten=vi.mocked(writeFileSync).mock.calls[0][1]asstring;
 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 {
 
 constsectionRegex=newRegExp(`\\[mcp_servers\\.elements\\][\\s\\S]*?(?=\\n\\[|$)`);
 constcontent=existing.replace(sectionRegex,'').trimEnd();
-constblock=`\n\n[mcp_servers.elements]\ncommand = "nve"\nargs = ["mcp"]\n`;
+constblock=`\n\n[mcp_servers.elements]\ndescription = "${DESCRIPTION}"\ncommand = "nve"\nargs = ["mcp"]\n`;
 constupdated=(content+block).trimStart();
 constdir=configPath.substring(0,configPath.lastIndexOf('/'));