fix(lint): respect --config in Rslint plugin workers

Rslint runs JS plugin rules in worker threads that import the internal
lint config again in a fresh realm. The --config path only lived in the
main thread's global state, so the workers searched cwd instead. From a
directory without rstack.config.*, linting failed with "worker exited
during init", and when a config in cwd registered the same plugin name,
the workers silently ran that config's implementation.

Before starting Rslint, set an environment variable to the resolved
--config path and pass it to loadRstackConfig() in the internal lint
config. Only that config reads it, so other commands and programmatic
loadRstackConfig() calls are unchanged. Clear the variable when
--config is absent so an inherited value is ignored.

Author: LucasIcarus

packages/rstack/src/cli/commands.ts

@@ -1,6 +1,6 @@
 import { join, resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
-import { getConfigState } from '../config.ts';
+import { CLI_CONFIG_PATH_ENV, getConfigState } from '../config.ts';
 import { insertConfigArg, parseArgs, parseCliArgs } from './args.ts';
 import { hasHelpFlag, printCommandHelp } from './help.ts';
 
@@ -153,6 +153,15 @@ async function runRslintCLI(args: string[]): Promise<void> {
     return printCommandHelp('lint');
   }
 
+  // Rslint's JS plugin workers inherit `process.env`. Clear an inherited path so
+  // that a run without `--config` still searches cwd.
+  const { configPath } = getConfigState();
+  if (configPath === undefined) {
+    delete process.env[CLI_CONFIG_PATH_ENV];
+  } else {
+    process.env[CLI_CONFIG_PATH_ENV] = configPath;
+  }
+
   const argv = [
     process.execPath,
     'rslint',

packages/rstack/src/config.ts

@@ -140,6 +140,13 @@ export const getConfigState = (): ConfigState => {
   return globalThis.__rstackCliState;
 };
 
+/**
+ * Passes the `--config` path to Rslint's JS plugin workers, which import the
+ * internal lint config in a fresh realm without the CLI state above. Only that
+ * config reads it.
+ */
+export const CLI_CONFIG_PATH_ENV = 'RSTACK_CLI_CONFIG_PATH';
+
 type Define = {
   /**
    * Inherits shared configs from left to right, followed by the project's own

packages/rstack/src/rslintConfig.ts

@@ -1,13 +1,20 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
-import { loadRstackConfig, type LoadedRstackConfig } from './config.ts';
+import {
+  CLI_CONFIG_PATH_ENV,
+  loadRstackConfig,
+  type LoadedRstackConfig,
+} from './config.ts';
 import type { RslintConfig } from '@rslint/core';
 import { color, logger } from 'rslog';
 import { resolveRslintConfig } from './configLayers.ts';
 
 // Expose the loaded config so `rs check` can pass it to fmt instead of loading
-// and executing the Rstack config a second time.
-export const loadedConfig: LoadedRstackConfig = await loadRstackConfig();
+// and executing the Rstack config a second time. Rslint also imports this
+// module in its JS plugin workers, which get `--config` from the environment.
+export const loadedConfig: LoadedRstackConfig = await loadRstackConfig({
+  configFilePath: process.env[CLI_CONFIG_PATH_ENV],
+});
 const { configs } = loadedConfig;
 const lintConfig = await resolveRslintConfig([configs]);
 

packages/rstack/tests/cli/specify-config-lint/index.test.ts

@@ -0,0 +1,47 @@
+import path from 'node:path';
+import { test } from '#test-helpers';
+import { expect } from 'rstack/test';
+
+// Rslint runs JS plugin rules in worker threads, which must also load the
+// config selected by `--config` instead of searching cwd.
+test('should run JS plugin rules from --config outside cwd', async ({
+  execCli,
+  logHelper,
+}) => {
+  expect(() =>
+    execCli('lint -c workspace/app/rstack.config.ts workspace/app/src'),
+  ).toThrow();
+  await logHelper.expectLog('foo is not allowed');
+});
+
+test('should prefer --config JS plugin rules over the cwd config', async ({
+  cwd,
+  execCli,
+  logHelper,
+}) => {
+  expect(() =>
+    execCli('lint -c app/rstack.config.ts app/src', {
+      cwd: path.join(cwd, 'workspace'),
+    }),
+  ).toThrow();
+  await logHelper.expectLog('foo is not allowed');
+  logHelper.expectNoLog('rule from the cwd config');
+});
+
+test('should ignore an inherited config path without --config', async ({
+  cwd,
+  execCli,
+  logHelper,
+}) => {
+  const workspace = path.join(cwd, 'workspace');
+  expect(() =>
+    execCli('lint app/src', {
+      cwd: workspace,
+      env: {
+        RSTACK_CLI_CONFIG_PATH: path.join(workspace, 'app/rstack.config.ts'),
+      },
+    }),
+  ).toThrow();
+  await logHelper.expectLog('rule from the cwd config');
+  logHelper.expectNoLog('foo is not allowed');
+});

packages/rstack/tests/cli/specify-config-lint/workspace/app/rstack.config.ts

@@ -0,0 +1,26 @@
+import { define } from 'rstack';
+
+type Context = { report: (descriptor: object) => void };
+
+define.lint([
+  {
+    files: ['**/*.js'],
+    plugins: {
+      local: {
+        rules: {
+          'no-foo': {
+            meta: { messages: { foo: 'foo is not allowed' } },
+            create: (context: Context) => ({
+              Identifier(node: { name: string }) {
+                if (node.name === 'foo') {
+                  context.report({ node, messageId: 'foo' });
+                }
+              },
+            }),
+          },
+        },
+      },
+    },
+    rules: { 'local/no-foo': 'error' },
+  },
+]);

packages/rstack/tests/cli/specify-config-lint/workspace/app/src/index.js

@@ -0,0 +1 @@
+export const foo = 1;

packages/rstack/tests/cli/specify-config-lint/workspace/rstack.config.ts

@@ -0,0 +1,24 @@
+import { define } from 'rstack';
+
+type Context = { report: (descriptor: object) => void };
+
+// Registers the same plugin name as `app/rstack.config.ts` with another rule.
+define.lint([
+  {
+    plugins: {
+      local: {
+        rules: {
+          'no-foo': {
+            meta: { messages: { cwd: 'rule from the cwd config' } },
+            create: (context: Context) => ({
+              Program(node: object) {
+                context.report({ node, messageId: 'cwd' });
+              },
+            }),
+          },
+        },
+      },
+    },
+    rules: { 'local/no-foo': 'error' },
+  },
+]);