fix(cli): preserve local command failures

Author: danielroe

packages/nuxt-cli/src/commands/index.ts

@@ -2,7 +2,7 @@ import type { CommandDef } from 'citty'
 
 const _rDefault = (r: any) => (r.default || r) as Promise<CommandDef>
 
-export const commands = {
+const commandLoaders = {
   'add': () => import('./add').then(_rDefault),
   'add-template': () => import('./add-template').then(_rDefault),
   'analyze': () => import('./analyze').then(_rDefault),
@@ -22,3 +22,5 @@ export const commands = {
   'typecheck': () => import('./typecheck').then(_rDefault),
   'upgrade': () => import('./upgrade').then(_rDefault),
 } as const
+
+export const commands = Object.assign(Object.create(null), commandLoaders) as typeof commandLoaders

packages/nuxt-cli/src/main.ts

@@ -17,6 +17,7 @@ import { setupGlobalConsole } from './utils/console'
 import { checkEngines } from './utils/engines'
 import { debug, logger } from './utils/logger'
 import { setupProxySupport } from './utils/network'
+import { withLocalBinPath } from './utils/path-env'
 import { resolveProjectDir } from './utils/paths'
 import { templateNames } from './utils/templates/names'
 import { scheduleUpdateNudge } from './utils/update-lazy'
@@ -68,23 +69,26 @@ const _main = defineCommand({
     }
 
     // allow running arbitrary commands if there's a locally registered binary with `nuxt-` prefix
-    if (ctx.args.command && !(ctx.args.command in commands)) {
+    if (ctx.args.command && !Object.hasOwn(commands, ctx.args.command)) {
       const cwd = resolve(ctx.args.cwd)
       try {
         const { x } = await import('tinyexec')
-        // `tinyexec` will resolve command from local binaries
-        await x(`nuxt-${ctx.args.command}`, ctx.rawArgs.slice(1), {
-          nodeOptions: { stdio: 'inherit', cwd },
-          throwOnError: true,
+        const result = await x(`nuxt-${ctx.args.command}`, ctx.rawArgs.slice(1), {
+          nodeOptions: {
+            stdio: 'inherit',
+            cwd,
+            env: withLocalBinPath(cwd),
+          },
+          throwOnError: false,
         })
+        process.exit(result.exitCode ?? 1)
       }
       catch (err) {
-        // TODO: use windows err code as well
         if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
           return
         }
+        throw err
       }
-      process.exit()
     }
   },
 })

packages/nuxt-cli/src/run.ts

@@ -46,7 +46,7 @@ export async function runCommand(
   argv: string[] = process.argv.slice(2),
   data: { overrides?: Record<string, any> } = {},
 ): Promise<{ result: unknown }> {
-  if (!(name in commands)) {
+  if (!Object.hasOwn(commands, name)) {
     throw new Error(`Invalid command ${name}`)
   }
 

packages/nuxt-cli/src/utils/path-env.ts

@@ -0,0 +1,21 @@
+import process from 'node:process'
+import { delimiter, resolve } from 'pathe'
+
+/**
+ * Return a copy of `env` with `dirs` prepended to its `PATH`.
+ *
+ * On Windows the variable may be named `Path`, and adding a second `PATH` key
+ * would leave the child with two conflicting entries, so the existing key is
+ * reused when present.
+ */
+export function withPrependedPath(env: NodeJS.ProcessEnv, dirs: string[]): NodeJS.ProcessEnv {
+  const result: NodeJS.ProcessEnv = { ...env }
+  const key = Object.keys(result).find(name => name.toLowerCase() === 'path') ?? 'PATH'
+  const current = result[key]
+  result[key] = [...dirs, ...(current ? [current] : [])].join(delimiter)
+  return result
+}
+
+export function withLocalBinPath(cwd: string, env: NodeJS.ProcessEnv = process.env): NodeJS.ProcessEnv {
+  return withPrependedPath(env, [resolve(cwd, 'node_modules/.bin')])
+}

packages/nuxt-cli/test/e2e/commands.spec.ts

@@ -3,7 +3,7 @@ import type { commands } from '../../src/commands'
 
 import { existsSync } from 'node:fs'
 
-import { rm } from 'node:fs/promises'
+import { chmod, mkdir, rm, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { getPort } from 'get-port-please'
@@ -133,7 +133,7 @@ describe('commands', () => {
     expect(res.stderr).toBe('[error] No command specified.\n')
   })
 
-  // TODO: FIXME - windows currently throws 'nuxt-foo' is not recognized as an internal or external command, operable program or batch file.
+  // TODO: on Windows tinyexec falls back to `cmd.exe`, which reports the missing binary itself rather than surfacing ENOENT
   it.skipIf(isWindows)('throws error if wrong command is provided', async () => {
     const res = await x(nuxi, ['foo'], {
       nodeOptions: { stdio: 'pipe', cwd: fixtureDir },
@@ -142,6 +142,32 @@ describe('commands', () => {
     expect(res.stderr).toBe('[error] Unknown command foo\n')
   })
 
+  it.skipIf(isWindows)('rejects command names inherited from Object.prototype', async () => {
+    const res = await x(nuxi, ['toString'], {
+      nodeOptions: { stdio: 'pipe', cwd: fixtureDir },
+    })
+    expect(res.exitCode).toBe(1)
+    expect(res.stderr).toBe('[error] Unknown command toString\n')
+  })
+
+  it.skipIf(isWindows)('forwards the exit status of a local command', async () => {
+    const binDir = join(fixtureDir, 'node_modules/.bin')
+    const bin = join(binDir, 'nuxt-exit-test')
+    await mkdir(binDir, { recursive: true })
+    await writeFile(bin, '#!/bin/sh\nexit 42\n')
+    await chmod(bin, 0o755)
+
+    try {
+      const res = await x(nuxi, ['exit-test'], {
+        nodeOptions: { stdio: 'pipe', cwd: fixtureDir },
+      })
+      expect(res.exitCode).toBe(42)
+    }
+    finally {
+      await rm(bin, { force: true })
+    }
+  })
+
   const testsToRun = Object.entries(tests).filter(([_, value]) => value !== 'todo')
   it.each(testsToRun)(`%s`, { timeout: isWindows ? 200000 : 50000 }, (_, test) => (test as () => Promise<void>)())
 

packages/nuxt-cli/test/unit/run.spec.ts

@@ -65,4 +65,10 @@ describe('runCommand', () => {
 
     expect(argv).toEqual(['--clear', '--cwd', '.'])
   })
+
+  it('should reject inherited command properties', async () => {
+    const { runCommand } = await import('../../src/run')
+
+    await expect(runCommand('toString', [])).rejects.toThrow('Invalid command toString')
+  })
 })

packages/nuxt-cli/test/unit/utils/path-env.spec.ts

@@ -0,0 +1,24 @@
+import { delimiter } from 'pathe'
+import { describe, expect, it } from 'vitest'
+
+import { withLocalBinPath, withPrependedPath } from '../../../src/utils/path-env'
+
+describe('withPrependedPath', () => {
+  it('reuses an existing path key regardless of case', () => {
+    const env = withPrependedPath({ Path: '/usr/bin' }, ['/local/bin'])
+
+    expect(env).toEqual({ Path: `/local/bin${delimiter}/usr/bin` })
+  })
+
+  it('creates a path when none is set', () => {
+    expect(withPrependedPath({}, ['/local/bin'])).toEqual({ PATH: '/local/bin' })
+  })
+})
+
+describe('withLocalBinPath', () => {
+  it('prepends the local bin directory of the given directory', () => {
+    const env = withLocalBinPath('/project', { PATH: '/usr/bin' })
+
+    expect(env.PATH).toBe(`/project/node_modules/.bin${delimiter}/usr/bin`)
+  })
+})