fix(config): support custom export conditions from NODE_OPTIONS (#2576)

Node's export conditions passed via `NODE_OPTIONS` (e.g. `--conditions=dev` or `-C custom`) or `process.execArgv` were ignored during `vite.config.ts` resolution.

This caused packages whose `exports` map uses a custom condition (e.g. `dev` pointing to `./src/rules.ts` while `default` points to unbuilt `./dist/rules.js`) to fail resolution with `[UNRESOLVED_IMPORT]` and `ERR_MODULE_NOT_FOUND`.

- Parse conditions from `process.execArgv` and `process.env.NODE_OPTIONS` in `nodeResolve.ts`
- Pass `conditionNames` to Rolldown's `bundleConfigFile` resolver
- Ensure TypeScript source files resolved via conditions are bundled rather than externalized
- Support conditions in `runnerImport` for SSR
- Isolate `resolveCore` to the CLI's own `node_modules` hierarchy

Fixes #2576.

Author: kshanxs

packages/cli/src/__tests__/resolve-vite-config.spec.ts

@@ -5,7 +5,7 @@ import path from 'node:path';
 
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
-import { findViteConfigUp } from '../resolve-vite-config.js';
+import { findViteConfigUp, resolveViteConfig } from '../resolve-vite-config.js';
 
 describe('findViteConfigUp', () => {
   let tempDir: string;
@@ -118,3 +118,129 @@ describe('findViteConfigUp', () => {
     expect(result).toBe(path.join(tempDir, 'vite.config.mjs'));
   });
 });
+
+describe('resolveViteConfig export conditions', () => {
+  let tempDir: string;
+  let originalNodeOptions: string | undefined;
+
+  beforeEach(() => {
+    tempDir = fs.realpathSync(mkdtempSync(path.join(tmpdir(), 'vite-config-conditions-test-')));
+    originalNodeOptions = process.env.NODE_OPTIONS;
+  });
+
+  afterEach(() => {
+    if (originalNodeOptions !== undefined) {
+      process.env.NODE_OPTIONS = originalNodeOptions;
+    } else {
+      delete process.env.NODE_OPTIONS;
+    }
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('resolves self-referencing package via custom condition from NODE_OPTIONS (--conditions=dev)', async () => {
+    const pkgJson = {
+      name: '@test-scope/thing',
+      type: 'module',
+      exports: {
+        './rules': {
+          dev: './src/rules.ts',
+          default: './dist/rules.js',
+        },
+      },
+    };
+    fs.writeFileSync(path.join(tempDir, 'package.json'), JSON.stringify(pkgJson, null, 2));
+
+    const srcDir = path.join(tempDir, 'src');
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(srcDir, 'rules.ts'),
+      'export const customRule = { name: "custom-rule-from-dev-condition" };\n',
+    );
+
+    const configTs = `
+      import { customRule } from '@test-scope/thing/rules';
+      export default {
+        lint: {
+          plugins: [customRule],
+        },
+      };
+    `;
+    fs.writeFileSync(path.join(tempDir, 'vite.config.ts'), configTs);
+
+    process.env.NODE_OPTIONS = `${originalNodeOptions || ''} --conditions=dev`.trim();
+    const config = await resolveViteConfig(tempDir);
+    expect(config).toBeDefined();
+    expect(config.lint?.plugins).toEqual([{ name: 'custom-rule-from-dev-condition' }]);
+  });
+
+  it('resolves self-referencing package via -C short flag in NODE_OPTIONS', async () => {
+    const pkgJson = {
+      name: '@test-scope/short-flag',
+      type: 'module',
+      exports: {
+        './plugin': {
+          custom: './src/plugin.ts',
+          default: './dist/plugin.js',
+        },
+      },
+    };
+    fs.writeFileSync(path.join(tempDir, 'package.json'), JSON.stringify(pkgJson, null, 2));
+
+    const srcDir = path.join(tempDir, 'src');
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(srcDir, 'plugin.ts'),
+      'export const flagPlugin = { id: "short-flag-condition" };\n',
+    );
+
+    const configTs = `
+      import { flagPlugin } from '@test-scope/short-flag/plugin';
+      export default {
+        lint: {
+          plugins: [flagPlugin],
+        },
+      };
+    `;
+    fs.writeFileSync(path.join(tempDir, 'vite.config.ts'), configTs);
+
+    process.env.NODE_OPTIONS = `${originalNodeOptions || ''} -C custom`.trim();
+    const config = await resolveViteConfig(tempDir);
+    expect(config).toBeDefined();
+    expect(config.lint?.plugins).toEqual([{ id: 'short-flag-condition' }]);
+  });
+
+  it('fails to resolve without custom condition when dist does not exist', async () => {
+    const pkgJson = {
+      name: '@test-scope/fail-case',
+      type: 'module',
+      exports: {
+        './rules': {
+          dev: './src/rules.ts',
+          default: './dist/rules.js',
+        },
+      },
+    };
+    fs.writeFileSync(path.join(tempDir, 'package.json'), JSON.stringify(pkgJson, null, 2));
+
+    const srcDir = path.join(tempDir, 'src');
+    fs.mkdirSync(srcDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(srcDir, 'rules.ts'),
+      'export const customRule = { name: "custom-rule" };\n',
+    );
+
+    const configTs = `
+      import { customRule } from '@test-scope/fail-case/rules';
+      export default {
+        lint: {
+          plugins: [customRule],
+        },
+      };
+    `;
+    fs.writeFileSync(path.join(tempDir, 'vite.config.ts'), configTs);
+
+    // No condition set in NODE_OPTIONS
+    delete process.env.NODE_OPTIONS;
+    await expect(resolveViteConfig(tempDir)).rejects.toThrow();
+  });
+});

packages/cli/src/resolve-core.ts

@@ -1,6 +1,6 @@
 import { readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
-import { join } from 'node:path';
+import { dirname, join } from 'node:path';
 
 import { readNearestPackageJson } from './utils/package.ts';
 
@@ -58,14 +58,28 @@ export function resolveCore(
   modulePath = import.meta.url,
 ): string {
   const cliRequire = createRequire(modulePath);
-  // Read the selected CLI's installed manifest. A static JSON import is inlined
-  // during the build, before CI and preview packers can stamp a new version.
+  const cliPackageJsonPath = cliRequire.resolve('vite-plus/package.json');
   const { version: expectedVersion } = JSON.parse(
-    readFileSync(cliRequire.resolve('vite-plus/package.json'), 'utf8'),
+    readFileSync(cliPackageJsonPath, 'utf8'),
   ) as { version: string };
+  const cliDir = dirname(cliPackageJsonPath);
   let corePackageJsonPath: string;
   try {
     corePackageJsonPath = cliRequire.resolve('vite/package.json');
+    let curr = cliDir;
+    let isBundled = false;
+    while (true) {
+      if (corePackageJsonPath.startsWith(join(curr, 'node_modules') + '/')) {
+        isBundled = true;
+        break;
+      }
+      const parent = dirname(curr);
+      if (parent === curr) break;
+      curr = parent;
+    }
+    if (!isBundled) {
+      throw new Error('Resolved outside CLI directory');
+    }
   } catch (cause) {
     throw new Error('Could not resolve the bundled Vite dependency. Run `vp install`.', { cause });
   }

packages/tools/src/brand-vite.ts

@@ -197,5 +197,148 @@ export function brandVite(rootDir: string = process.cwd()) {
     ),
   );
 
+  // 7. nodeResolve.ts: Support Node export conditions (e.g. NODE_OPTIONS=--conditions=dev)
+  const nodeResolveFile = join(nodeDir, 'nodeResolve.ts');
+  const nodeResolveResults = [
+    replaceInFile(
+      nodeResolveFile,
+      `/**
+ * Resolve like Node.js using Vite's resolution algorithm with preconfigured options.
+ */
+export function nodeResolveWithVite(
+  id: string,
+  importer: string | undefined,
+  options: NodeResolveWithViteOptions,
+): string | undefined {
+  return tryNodeResolve(id, importer, {
+    root: options.root,
+    isBuild: true,
+    isProduction: true,
+    preferRelative: false,
+    tryIndex: true,
+    mainFields: [],
+    conditions: [
+      'node',
+      ...(isModuleSyncConditionEnabled ? ['module-sync'] : []),
+    ],`,
+      `/**
+ * Extract Node condition names from process.execArgv and process.env.NODE_OPTIONS.
+ */
+export function getNodeConditions(): string[] {
+  const conditions = new Set<string>()
+  function parseArgs(args: string[]) {
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i]
+      if (arg === '-C' || arg === '--conditions') {
+        if (i + 1 < args.length) conditions.add(args[++i])
+      } else if (arg.startsWith('--conditions=')) {
+        conditions.add(arg.slice('--conditions='.length))
+      }
+    }
+  }
+  if (process.execArgv) parseArgs(process.execArgv)
+  if (process.env.NODE_OPTIONS) {
+    const parts = process.env.NODE_OPTIONS.match(/(?:[^\\s"']+|"[^"]*"|'[^']*')+/g) || []
+    parseArgs(
+      parts.map((p) =>
+        (p.startsWith('"') && p.endsWith('"')) || (p.startsWith("'") && p.endsWith("'"))
+          ? p.slice(1, -1)
+          : p,
+      ),
+    )
+  }
+  return Array.from(conditions)
+}
+
+/**
+ * Resolve like Node.js using Vite's resolution algorithm with preconfigured options.
+ */
+export function nodeResolveWithVite(
+  id: string,
+  importer: string | undefined,
+  options: NodeResolveWithViteOptions,
+): string | undefined {
+  return tryNodeResolve(id, importer, {
+    root: options.root,
+    isBuild: true,
+    isProduction: true,
+    preferRelative: false,
+    tryIndex: true,
+    mainFields: [],
+    conditions: [
+      'node',
+      ...(isModuleSyncConditionEnabled ? ['module-sync'] : []),
+      ...getNodeConditions(),
+    ],`,
+    ),
+  ];
+  logPatch(
+    'nodeResolve.ts',
+    'Supported Node conditions in nodeResolveWithVite',
+    nodeResolveResults.includes('patched') ? 'patched' : 'already',
+  );
+
+  // 8. config.ts: Support Node conditions and bundle TS sources in bundleConfigFile
+  const configResults = [
+    replaceInFile(
+      configFile,
+      "import { nodeResolveWithVite } from './nodeResolve'",
+      "import { getNodeConditions, nodeResolveWithVite } from './nodeResolve'",
+    ),
+    replaceInFile(
+      configFile,
+      `    resolve: {
+      mainFields: ['main'],
+    },`,
+      `    resolve: {
+      mainFields: ['main'],
+      conditionNames: getNodeConditions(),
+    },`,
+    ),
+    replaceInFile(
+      configFile,
+      `            // always no-externalize json files as rolldown does not support import attributes
+            if (idFsPath.endsWith('.json')) {
+              return idFsPath
+            }`,
+      `            // always no-externalize json and ts files as rolldown does not support import attributes / node cannot always run ts directly
+            if (idFsPath.endsWith('.json') || /\\.(?:[cm]?ts|tsx)$/.test(idFsPath)) {
+              return idFsPath
+            }`,
+    ),
+  ];
+  logPatch(
+    'config.ts',
+    'Supported Node conditions and TS inlining in bundleConfigFile',
+    configResults.includes('patched') ? 'patched' : 'already',
+  );
+
+  // 9. ssr/runnerImport.ts: Support Node conditions in runnerImport
+  const runnerImportFile = join(nodeDir, 'ssr', 'runnerImport.ts');
+  const runnerImportResults = [
+    replaceInFile(
+      runnerImportFile,
+      "import type { InlineConfig } from '../config'",
+      "import type { InlineConfig } from '../config'\nimport { getNodeConditions } from '../nodeResolve'",
+    ),
+    replaceInFile(
+      runnerImportFile,
+      `            conditions: [
+              'node',
+              ...(isModuleSyncConditionEnabled ? ['module-sync'] : []),
+            ],`,
+      `            conditions: [
+              'node',
+              ...(isModuleSyncConditionEnabled ? ['module-sync'] : []),
+              ...getNodeConditions(),
+            ],`,
+    ),
+  ];
+  logPatch(
+    'ssr/runnerImport.ts',
+    'Supported Node conditions in runnerImport',
+    runnerImportResults.includes('patched') ? 'patched' : 'already',
+  );
+
   log('Done!');
 }