`bit ws-config write` / `bit install` always write Oxlint configuration with generated defaults ignoring custom values

[rvnlord]

Summary

Custom Oxlint configuration defined by an environment is ignored when workspace configuration is generated.

Running either:

bit ws-config write

or

bit install

always generates .oxlintrc.json files that extend a cached configuration containing the default values, instead of the custom configuration from the environment.

Environment

• Windows 10 / Windows 11
• Bit v2.0.11
• Node.js v22.16
• Fresh workspace
• Clean pnpm store

Steps to reproduce

Create a custom environment:

bit init --default-scope projects
bit install

bit create react-env envs/my-react-env --aspect bitdev.react/react-env
bit create react-app apps/react-frontend --env projects/envs/my-react-env

Replace projects/envs/my-react-env/config/oxlintrc.json with:

{
  "$schema": "https://raw.githubusercontent.com/oxc-project/oxc/main/npm/oxlint/configuration_schema.json",
  "plugins": ["react", "unicorn", "typescript", "oxc"],
  "settings": {
    "react": {
      "version": "19"
    }
  },
  "options": {
    "typeAware": true
  },
  "rules": {
    "no-unused-vars": "off"
  }
}

Then run either:

bit ws-config write

or

bit install

Bit reports:

5 config files added to workspace
2 typescript configurations added
  projects\envs\tsconfig.json

  tsconfig.json

2 oxlint configurations added
  projects\envs\.oxlintrc.json
  .oxlintrc.json

1 prettier configurations added
  .prettierrc.cjs

Actual behavior

The generated .oxlintrc.json points to a cache:

{
  "extends": [
    "./node_modules/.cache/oxlintrc.bit.b3a5458e3e9b6949bee9213fc4dd6a329a94610a.json"
  ]
}

which contains the default configuration instead of the custom one:

{
  "plugins": [
    "react",
    "unicorn",
    "typescript",
    "oxc"
  ],
  "settings": {
    "react": {
      "version": "18"
    }
  },
  "options": {
    "typeAware": true
  }
}

Expected behavior

The generated configuration should reference a cache file containing the effective configuration from the environment rather than the built-in defaults.

Root cause

After looking into EslintConfigWriter, the primary issue appears to be how it handles configurations provided via configPath.

When the writer is created like this:

EslintConfigWriter.from({
  configPath: this.oxlintConfigPath,
  tsconfig: this.tsconfigPath,
})

the configuration is supplied as a file path rather than an object.

The execution flow is:

1. EslintConfigWriter.create() calls computeEslintConfig().
2. computeEslintConfig() returns:

{ overrideConfigFile: configPath }

It sets overrideConfigFile, but never loads the file into overrideConfig.

Later, calcConfigFiles() only checks overrideConfig:

const config = this.eslintConfig.overrideConfig;

if (!config) {
  return [];
}

Since overrideConfig is undefined, calcConfigFiles() returns an empty array without writing the environment's configuration to the cache.

As a result, Bit falls back to generating a cached .oxlintrc.bit.<hash>.json containing the default configuration, which is why custom values are lost and replaced with the defaults.

The fix would be to support both configuration modes consistently. Either:

• calcConfigFiles() should read and serialize overrideConfigFile when overrideConfig is absent, or
• computeEslintConfig() should populate overrideConfig from the supplied file before returning.

There is also a separate design limitation: EslintConfigWriter is still hardcoded around ESLint naming, so even with this bug fixed it would continue generating .eslintrc.json-style artifacts rather than Oxlint-specific ones.

Workaround

As a temporary workaround, I replaced the built-in EslintConfigWriter with a custom function that creates OxlintConfigWriter which reads the environment's config/oxlintrc.json directly, hashes its contents, writes the corresponding cached .oxlintrc.bit.<hash>.json and generates the extending .oxlintrc.json pointing to that cache file.

workspaceConfig(): ConfigWriterList {
    const cwl = ConfigWriterList.from([
        TypescriptConfigWriter.from({
            tsconfig: this.tsconfigPath,
            types: resolveTypes(__dirname, [this.tsTypesPath]),
        }),
        this.createOxlintConfigWriter(),
        PrettierConfigWriter.from({
            configPath: this.prettierConfigPath
        })
    ]);

    return cwl;
}

private createOxlintConfigWriter(): ConfigWriterHandler {
    const oxlintConfigPath = this.oxlintConfigPath;
    return {
        name: "OxlintConfigWriter",
        handler: () => {
            const configContent = fs.readFileSync(oxlintConfigPath, "utf-8");
            const configHash = sha1(configContent);
            const configFileName = `.oxlintrc.bit.${configHash}.json`;

            const entry: ConfigWriterEntry = {
                id: "oxlint",
                name: "OxlintConfigWriter",
                patterns: ["**/.oxlintrc.json"],
                calcConfigFiles: (): ConfigFile[] => {
                    console.log("Writing OXLint config from:", oxlintConfigPath);
                    return [
                        {
                            content: configContent,
                            name: configFileName,
                            hash: configHash,
                        },
                    ];
                },
                generateExtendingFile: (args: GenerateExtendingConfigFilesArgs) => {
                    const oxlintConfigFile = args.writtenConfigFiles.find(
                        (file) => file.name.includes(".oxlintrc.bit")
                    );
                    if (!oxlintConfigFile) return undefined;

                    const extendingConfig = {
                        extends: [`{${oxlintConfigFile.name}}`],
                    };
                    const content = `${BIT_GENERATED_OXLINT_CONFIG_COMMENT}\n${JSON.stringify(extendingConfig, null, 2)}`;
                    return {
                        content,
                        name: ".oxlintrc.json",
                        extendingTarget: oxlintConfigFile,
                        useAbsPaths: false,
                    };
                },
                isBitGenerated: (filePath: string) => {
                    const content = fs.readFileSync(filePath).toString();
                    return content.includes(BIT_GENERATED_OXLINT_CONFIG_COMMENT);
                },
            };
            return entry;
        },
    };
}

Additional observation: undocumented, dedicated Oxlint writer has similar issues

I just noticed there is an undocumented dedicated package, @teambit/oxc.linter.oxlint-linter, which looks to be the intended replacement for using EslintConfigWriter with Oxlint.

But, replacing EslintConfigWriter with it manually:

import { OxlintConfigWriter, OxlintLinter, OxlintTask } from "@teambit/oxc.linter.oxlint-linter";

OxlintConfigWriter.from({
    configPath: this.oxlintConfigPath
}),

currently results in generating two configuration files, one that's correct (at the root of the workspace) and another one with default values (for the environment variable):

bit ws-config write

2 oxlint configurations added
  projects\commonlib\envs\.oxlintrc.json
  .oxlintrc.json

[rvnlord]

After digging deeper, I think this issue is slightly more subtle than I originally thought.

There seems to be another code path that always generates .oxlintrc.json for the environment using the default configuration, regardless of what your environment config contains.

From my testing:

• If you don't configure any writer, the generated .oxlintrc.json extends a cached file containing the default Oxlint configuration.
• If you use the built-in OxlintConfigWriter with custom options, the workspace root receives your custom config, but the environment still gets a generated .oxlintrc.json pointing to the default cached config.
• If you replace OxlintConfigWriter with a completely custom ConfigWriterEntry, the same default-writing logic still runs before your writer, even though it is not part of the ConfigWriterList.

I also tried overriding it in postProcessExtendingConfigFiles(), but that doesn't work either. The default .oxlintrc.json is recreated after post-processing, so deleting or replacing it there has no effect.

The best workaround I've found is not to fight that generation step, but to overwrite the contents of the generated .oxlintrc.json so it extends the correct cached config instead.

I'm currently using the following custom ConfigWriterEntry, which works around the issue:

workspaceConfig(): ConfigWriterList {
    return ConfigWriterList.from([
        TypescriptConfigWriter.from({
            tsconfig: this.tsconfigPath,
            types: resolveTypes(this.dirName, [this.tsTypesPath]),
        }),
        MyOxlintConfigWriter.from({
            configPath: this.oxlintConfigPath,
        }),
        PrettierConfigWriter.from({
            configPath: this.prettierConfigPath
        })
    ]);
}

import fs from "fs";
import crypto from "crypto";
import type { EnvHandler } from "@teambit/envs";
import type {
    ConfigWriterEntry,
    ConfigFile,
    GenerateExtendingConfigFilesArgs,
    ExtendingConfigFile,
} from "@teambit/workspace-config-files";
import path from "path";

const BIT_GENERATED_OXLINT_CONFIG_COMMENT = "// bit-generated-oxlint-config";
const sha1 = (str: string) => crypto.createHash("sha1").update(str).digest("hex");
const __baseDirName = process.cwd().replace(/\\/g, "/");

export type MyOxlintConfigWriterOptions = {
    name?: string;
    /**
     * absolute path to the oxlint config file to use as the base config.
     */
    configPath: string;
};

export class MyOxlintConfigWriter implements ConfigWriterEntry {
    id = "oxlint";
    patterns = ["**/.oxlintrc.json"];

    constructor(public name: string, private configPath: string) { }

    calcConfigFiles(): ConfigFile[] | undefined {
        try {
            const raw = fs.readFileSync(this.configPath, "utf-8");
            const parsed = JSON.parse(raw);
            delete parsed.$schema;
            const content = JSON.stringify(parsed, null, 2);
            const hash = sha1(raw);
            const result = [{ name: `oxlintrc.bit.${hash}.json`, content, hash }];
            return result;
        } catch (error) {
            console.error(`[MyOxlintConfigWriter.calcConfigFiles] Error:`, error);
            throw error;
        }
    }

    generateExtendingFile({ writtenConfigFiles }: GenerateExtendingConfigFilesArgs): ExtendingConfigFile | undefined {
        const configFile = writtenConfigFiles.find((f) => f.name.includes("oxlintrc.bit."));

        if (!configFile) {
            console.log(`[MyOxlintConfigWriter.generateExtendingFile] No oxlintrc.bit file found, returning undefined`);
            return undefined;
        }

        const config = { extends: [`{${configFile.name}}`] };
        const content = `${BIT_GENERATED_OXLINT_CONFIG_COMMENT}\n${JSON.stringify(config, null, 2)}`;
        const result = {
            content,
            name: ".oxlintrc.json",
            extendingTarget: configFile,
            useAbsPaths: false
        };

        return result;
    }

    isBitGenerated(filePath: string): boolean {
        try {
            const content = fs.readFileSync(filePath, "utf-8");
            const isGenerated = content.includes(BIT_GENERATED_OXLINT_CONFIG_COMMENT);
            return isGenerated;
        } catch (error) {
            return false;
        }
    }

    async postProcessExtendingConfigFiles(args: {
        paths: string[];
        extendingConfigFile: ExtendingConfigFile;
    }): Promise<{ path: string; content: string }[]> {
        console.log(`[MyOxlintConfigWriter.postProcessExtendingConfigFiles] Called`);
        console.log(`[MyOxlintConfigWriter.postProcessExtendingConfigFiles] Original paths:`, args.paths);
        console.log(`[MyOxlintConfigWriter.postProcessExtendingConfigFiles] Original paths count: ${args.paths.length}`);

        // Collect all subdirectory paths that have .oxlintrc.json files
        const pathsToFix: string[] = [];

        console.log(`[MyOxlintConfigWriter.postProcessExtendingConfigFiles] Starting recursive collection of .oxlintrc.json paths from subdirectories`);
        console.log(`[MyOxlintConfigWriter.postProcessExtendingConfigFiles] Base directory: ${__baseDirName}`);

        // Start the recursive collection from the base directory
        MyOxlintConfigWriter.collectOxlintrcPaths(__baseDirName, true, pathsToFix);

        console.log(`[MyOxlintConfigWriter.postProcessExtendingConfigFiles] Collected ${pathsToFix.length} .oxlintrc.json paths from subdirectories`);
        console.log(`[MyOxlintConfigWriter.postProcessExtendingConfigFiles] Collected paths:`, pathsToFix);

        // Combine original paths with collected paths
        const paths = [...args.paths, ...pathsToFix];
        console.log(`[MyOxlintConfigWriter.postProcessExtendingConfigFiles] Total paths (original + collected): ${paths.length}`);

        const result = paths.length === 0 ? [] : paths.map((p) => ({
            path: p,
            content: args.extendingConfigFile.content,
        }));

        console.log(`[MyOxlintConfigWriter.postProcessExtendingConfigFiles] Returning ${result.length} path(s)`);

        return result;
    }

    private static collectOxlintrcPaths(dir: string, isRoot: boolean = true, pathsToFix: string[]) {
        try {
            //console.log(`[MyOxlintConfigWriter.collectOxlintrcPaths] Scanning directory: ${dir} (isRoot: ${isRoot})`);

            const entries = fs.readdirSync(dir, { withFileTypes: true });

            for (const entry of entries) {
                const fullPath = path.join(dir, entry.name);

                if (entry.isSymbolicLink()) {
                    //console.log(`[MyOxlintConfigWriter.collectOxlintrcPaths] Skipping symlink: ${fullPath}`);
                    continue;
                }

                if (entry.isDirectory()) {
                    // Skip node_modules directories
                    if (entry.name === "node_modules") {
                        //console.log(`[MyOxlintConfigWriter.collectOxlintrcPaths] Skipping node_modules directory: ${fullPath}`);
                        continue;
                    }

                    // Recursively process subdirectories
                    //console.log(`[MyOxlintConfigWriter.collectOxlintrcPaths] Entering subdirectory: ${fullPath}`);
                    MyOxlintConfigWriter.collectOxlintrcPaths(fullPath, false, pathsToFix);
                } else if (entry.isFile() && entry.name === ".oxlintrc.json") {
                    // Check if this file is in a subdirectory (not root)
                    if (!isRoot) {
                        //console.log(`[MyOxlintConfigWriter.collectOxlintrcPaths] Found .oxlintrc.json in subdirectory: ${fullPath}`);
                        // Get the directory path (relative to workspace root)
                        const dirPath = path.dirname(fullPath);
                        // Convert to relative path from __baseDirName
                        const relativePath = path.relative(__baseDirName, dirPath).replace(/\\/g, "/") || ".";
                        if (!pathsToFix.includes(relativePath)) {
                            //console.log(`[MyOxlintConfigWriter.collectOxlintrcPaths] Adding relative path: ${relativePath}`);
                            pathsToFix.push(relativePath);
                        }
                    } else {
                        //console.log(`[MyOxlintConfigWriter.collectOxlintrcPaths] Found .oxlintrc.json at root: ${fullPath} - keeping`);
                    }
                }
            }
        } catch (error) {
            console.error(`[MyOxlintConfigWriter.collectOxlintrcPaths] Error scanning directory ${dir}:`, error);
        }
    }

    static from(options: MyOxlintConfigWriterOptions): { name: string; handler: EnvHandler<MyOxlintConfigWriter> } {
        const name = options.name || "OxlintConfigWriter";

        return {
            name,
            handler: () => {
                return new MyOxlintConfigWriter(name, options.configPath);
            },
        };
    }
}

Based on this behavior, I suspect there's an additional Oxlint config generation step happening outside of ConfigWriterList that always writes the default environment configuration. That would also explain why replacing OxlintConfigWriter alone isn't sufficient to fix the problem.