@reliverse/dler 1.7.16 → 1.7.18

package/bin/libs/cfg/rse/rse-impl/rse-gen-cfg.js

@@ -0,0 +1,186 @@
+import path from "@reliverse/pathkit";
+import { ensuredir } from "@reliverse/relifso";
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { destr } from "destr";
+import { execaCommand } from "execa";
+import { CONFIG_CATEGORIES, UNKNOWN_VALUE } from "./rse-consts.js";
+import { generateRseConfig } from "./rse-create.js";
+import { getRseConfigPath } from "./rse-path.js";
+async function generateBiomeConfig(projectPath) {
+  const biomePath = path.join(projectPath, "biome.json");
+  const biomeExists = await fs.pathExists(biomePath);
+  if (!biomeExists) {
+    await execaCommand("bunx biome init", {
+      cwd: projectPath,
+      stdio: "inherit"
+    });
+    relinka("verbose", "Generated biome.json");
+  }
+}
+async function generateVSCodeSettings(projectPath, overwrite) {
+  const vscodePath = path.join(projectPath, ".vscode");
+  await ensuredir(vscodePath);
+  const settingsPath = path.join(vscodePath, "settings.json");
+  const defaultSettings = {
+    "editor.formatOnSave": true,
+    "editor.defaultFormatter": "biomejs.biome",
+    "editor.codeActionsOnSave": {
+      "quickfix.biome": "explicit",
+      "source.addMissingImports": "never",
+      "source.fixAll.eslint": "explicit",
+      "source.organizeImports": "never",
+      "source.removeUnused": "never"
+    },
+    "eslint.ignoreUntitled": true,
+    "eslint.rules.customizations": [
+      {
+        rule: "perfectionist/sort-imports",
+        severity: "off"
+      }
+    ],
+    "markdownlint.config": {
+      MD033: false
+    },
+    "typescript.enablePromptUseWorkspaceTsdk": true
+  };
+  let settings = { ...defaultSettings };
+  if (!overwrite && await fs.pathExists(settingsPath)) {
+    try {
+      const content = await fs.readFile(settingsPath, "utf-8");
+      const existingSettings = destr(content);
+      if (existingSettings && typeof existingSettings === "object") {
+        const defaultCodeActions = {
+          "quickfix.biome": "explicit",
+          "source.addMissingImports": "never",
+          "source.fixAll.eslint": "explicit",
+          "source.organizeImports": "never",
+          "source.removeUnused": "never"
+        };
+        const existingCodeActions = {
+          ...defaultCodeActions,
+          ...existingSettings["editor.codeActionsOnSave"]
+        };
+        settings = {
+          ...defaultSettings,
+          ...existingSettings,
+          "editor.codeActionsOnSave": existingCodeActions
+        };
+      }
+    } catch (error) {
+      relinka(
+        "verbose",
+        "Error reading existing settings.json, creating new one",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  await fs.writeFile(settingsPath, JSON.stringify(settings, null, 2));
+  relinka(
+    "verbose",
+    overwrite ? "Generated brand new VSCode settings.json file" : "Updated VSCode settings.json with required settings"
+  );
+}
+export async function generateConfigFiles(projectPath, overwrite, projectName, deployService, primaryDomain, frontendUsername, enableI18n, isDev, filesToGenerate = []) {
+  try {
+    const shouldGenerateFile = (filename) => {
+      return filesToGenerate.length === 0 || filesToGenerate.includes(filename);
+    };
+    const cleanDomain = primaryDomain.replace(/^https?:\/\//, "").replace(/\/.*$/, "");
+    const finalFrontendUsername = isDev && frontendUsername === "blefnk" ? "reliverse" : frontendUsername;
+    const configInfo = await getRseConfigPath(projectPath, isDev, false);
+    const mainConfigFileName = path.basename(configInfo.configPath);
+    const configGenerators = {
+      [mainConfigFileName]: async () => {
+        await generateRseConfig({
+          projectName,
+          frontendUsername: !finalFrontendUsername || finalFrontendUsername.trim() === "" ? UNKNOWN_VALUE : finalFrontendUsername,
+          deployService,
+          primaryDomain: cleanDomain,
+          projectPath,
+          githubUsername: UNKNOWN_VALUE,
+          enableI18n,
+          overwrite,
+          isDev,
+          configInfo,
+          ...isDev && configInfo?.isTS ? {
+            customPathToTypes: "./src/libs/sdk/sdk-mod"
+          } : {},
+          overrides: {}
+        });
+        return true;
+      },
+      "biome.json": async () => {
+        await generateBiomeConfig(projectPath);
+        return true;
+      },
+      "settings.json": async () => {
+        await generateVSCodeSettings(projectPath, overwrite);
+        return true;
+      }
+    };
+    const generatedFiles = [];
+    await Promise.all(
+      Object.entries(configGenerators).filter(([filename]) => shouldGenerateFile(filename)).map(async ([filename, generator]) => {
+        const wasGenerated = await generator();
+        if (wasGenerated) {
+          generatedFiles.push(filename);
+        }
+      })
+    );
+    if (generatedFiles.length > 0) {
+      relinka("verbose", `Generated configuration files: ${generatedFiles.join(", ")}`);
+    }
+  } catch (error) {
+    relinka(
+      "error",
+      "Error generating config files:",
+      error instanceof Error ? error.message : String(error)
+    );
+    throw error;
+  }
+}
+export async function generateProjectConfigs(projectPath, projectName, frontendUsername, deployService, primaryDomain, enableI18n, isDev) {
+  try {
+    const existingFiles = [];
+    for (const category of Object.keys(CONFIG_CATEGORIES)) {
+      const files = CONFIG_CATEGORIES[category];
+      for (const file of files) {
+        const filePath = path.join(projectPath, file);
+        if (await fs.pathExists(filePath)) {
+          existingFiles.push(file);
+        }
+      }
+    }
+    if (existingFiles.length > 0) {
+      relinka("verbose", `Found ${existingFiles.length} existing configuration files`);
+      await generateConfigFiles(
+        projectPath,
+        false,
+        projectName,
+        deployService,
+        primaryDomain,
+        frontendUsername,
+        enableI18n,
+        isDev
+      );
+    } else {
+      await generateConfigFiles(
+        projectPath,
+        true,
+        projectName,
+        deployService,
+        primaryDomain,
+        frontendUsername,
+        enableI18n,
+        isDev
+      );
+    }
+  } catch (error) {
+    relinka(
+      "error",
+      `Failed to set up configuration files: ${error instanceof Error ? error.message : String(error)}`
+    );
+    throw error;
+  }
+}

package/bin/libs/cfg/rse/rse-impl/rse-inject.d.ts

@@ -0,0 +1 @@
+export declare function injectSectionComments(fileContent: string): string;

package/bin/libs/cfg/rse/rse-impl/rse-inject.js

@@ -0,0 +1,57 @@
+import MagicString from "magic-string";
+import { cliDomainDocs } from "./rse-consts.js";
+export function injectSectionComments(fileContent) {
+  const ms = new MagicString(fileContent);
+  const comment = (text) => text ? `// ${text}` : "";
+  const commentSections = {
+    $schema: [
+      comment(`RSE CONFIG (${cliDomainDocs})`),
+      comment("Restart the CLI to apply your config changes")
+    ],
+    projectName: [comment("General project information")],
+    skipPromptsUseAutoBehavior: [
+      comment("Enable auto-answering for prompts to skip manual confirmations."),
+      comment("Make sure you have unknown values configured above.")
+    ],
+    features: [comment("Project features")],
+    projectFramework: [comment("Primary tech stack/framework")],
+    codeStyle: [comment("Code style preferences")],
+    multipleRepoCloneMode: [comment("Settings for cloning an existing repo")],
+    envComposerOpenBrowser: [
+      comment("Set to false to disable opening the browser during env composing")
+    ],
+    ignoreDependencies: [comment("List dependencies to exclude from checks")],
+    customRules: [
+      comment("Provide custom rules for Reliverse AI"),
+      comment("You can use any json type here in {}")
+    ],
+    deployBehavior: [
+      comment("Prompt behavior for deployment"),
+      comment("Options: prompt | autoYes | autoNo")
+    ],
+    existingRepoBehavior: [
+      comment("Behavior for existing GitHub repos during project creation"),
+      comment("Options: prompt | autoYes | autoYesSkipCommit | autoNo")
+    ],
+    relinterConfirm: [
+      comment("Behavior for Reliverse AI chat and agent mode"),
+      comment("Options: promptOnce | promptEachFile | autoYes")
+    ]
+  };
+  for (const [section, lines] of Object.entries(commentSections)) {
+    if (!lines?.length) continue;
+    const combinedComments = lines.map((line, idx) => idx === 0 ? line : `  ${line}`).join("\n");
+    const regex = new RegExp(`(\\s+)(["']?)${section.replace("$", "\\$")}(\\2):`, "g");
+    let match = regex.exec(fileContent);
+    while (match !== null) {
+      const insertPos = match.index;
+      const insertion = `
+  ${combinedComments}`;
+      ms.prependLeft(insertPos, insertion);
+      match = regex.exec(fileContent);
+    }
+  }
+  let result = ms.toString();
+  result = result.replace(/\n{3,}/g, "\n\n").replace(/{\n\n/g, "{\n").replace(/\n\n}/g, "\n}");
+  return result.trim().concat("\n");
+}

package/bin/libs/cfg/rse/rse-impl/rse-migrate.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Migrates an external rseg file into the current project config.
+ * Only migrates fields that exist in the current schema.
+ */
+export declare function migrateRseConfig(externalrseth: string, projectPath: string, isDev: boolean): Promise<void>;

package/bin/libs/cfg/rse/rse-impl/rse-migrate.js

@@ -0,0 +1,56 @@
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { parseJSONC } from "confbox";
+import { updateRseConfig } from "./rse-update.js";
+export async function migrateRseConfig(externalrseth, projectPath, isDev) {
+  try {
+    const content = await fs.readFile(externalrseth, "utf-8");
+    const parsed = parseJSONC(content);
+    if (!parsed || typeof parsed !== "object") {
+      throw new Error("Invalid JSONC format in external config file");
+    }
+    const tempConfig = parsed;
+    const migratedFields = [];
+    const validConfig = {};
+    const keysToMigrate = [
+      "projectDescription",
+      "version",
+      "projectLicense",
+      "projectRepository",
+      "projectCategory",
+      "projectSubcategory",
+      "projectFramework",
+      "projectTemplate",
+      "projectArchitecture",
+      "deployBehavior",
+      "depsBehavior",
+      "gitBehavior",
+      "i18nBehavior",
+      "scriptsBehavior",
+      "existingRepoBehavior",
+      "repoPrivacy",
+      "features",
+      "preferredLibraries",
+      "codeStyle",
+      "monorepo",
+      "ignoreDependencies",
+      "customRules",
+      "skipPromptsUseAutoBehavior",
+      "relinterConfirm"
+    ];
+    for (const key of keysToMigrate) {
+      if (tempConfig[key] !== void 0) {
+        validConfig[key] = tempConfig[key];
+        migratedFields.push(String(key));
+      }
+    }
+    const success = await updateRseConfig(projectPath, validConfig, isDev);
+    if (success) {
+      relinka("success", "Successfully migrated config");
+      relinka("verbose", "Migrated fields:", migratedFields.join(", "));
+    }
+    await fs.remove(externalrseth);
+  } catch (error) {
+    relinka("warn", "Failed to migrate external config:", String(error));
+  }
+}

package/bin/libs/cfg/rse/rse-impl/rse-path.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Determines the rse config file path and whether it's TS or JSONC.
+ * Always looks in the .config directory first.
+ * - In dev mode, automatically selects the TS path.
+ * - Honors a custom tsconfig.json path if provided.
+ * - Caches results by projectPath.
+ */
+export declare function getRseConfigPath(projectPath: string, isDev: boolean, skipPrompt: boolean, customTsconfigPath?: string): Promise<{
+    configPath: string;
+    isTS: boolean;
+}>;

package/bin/libs/cfg/rse/rse-impl/rse-path.js

@@ -0,0 +1,33 @@
+import path from "@reliverse/pathkit";
+import fs from "@reliverse/relifso";
+import { tsconfigJson } from "./rse-consts.js";
+import { askRseConfigType } from "./rse-prompts.js";
+const configPathCache = /* @__PURE__ */ new Map();
+export async function getRseConfigPath(projectPath, isDev, skipPrompt, customTsconfigPath) {
+  const cached = configPathCache.get(projectPath);
+  if (cached) {
+    return cached;
+  }
+  const finalTsconfigPath = customTsconfigPath ? path.resolve(customTsconfigPath) : path.join(projectPath, tsconfigJson);
+  const configDir = path.join(projectPath, ".config");
+  const rseJsonc = path.join(configDir, "rse.jsonc");
+  const rseTs = path.join(configDir, "rse.ts");
+  const [tsconfigExists, jsoncExists, tsExists] = await Promise.all([
+    fs.pathExists(finalTsconfigPath),
+    fs.pathExists(rseJsonc),
+    fs.pathExists(rseTs)
+  ]);
+  let result;
+  if (isDev) {
+    result = { configPath: rseTs, isTS: true };
+  } else if (tsExists) {
+    result = { configPath: rseTs, isTS: true };
+  } else if (tsconfigExists && !jsoncExists && !skipPrompt) {
+    const choice = await askRseConfigType();
+    result = choice === "ts" ? { configPath: rseTs, isTS: true } : { configPath: rseJsonc, isTS: false };
+  } else {
+    result = { configPath: rseJsonc, isTS: false };
+  }
+  configPathCache.set(projectPath, result);
+  return result;
+}

package/bin/libs/cfg/rse/rse-impl/rse-prompts.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Prompts the user to select a config file type (JSONC or TS)
+ * @returns The selected config type ('jsonc' or 'ts')
+ */
+export declare function askRseConfigType(): Promise<"jsonc" | "ts">;

package/bin/libs/cfg/rse/rse-impl/rse-prompts.js

@@ -0,0 +1,12 @@
+import { selectPrompt } from "@reliverse/rempts";
+export async function askRseConfigType() {
+  return await selectPrompt({
+    title: "Please select a rseonfiguration file type. JSONC is recommended for most projects.",
+    content: "A tsconfig.json file was detected. You can use the TypeScript config type for this project; however, it requires @reliverse/rse to be installed (as a dev dependency); without it, the rse CLI may not run correctly when using the TS config type.",
+    options: [
+      { label: "TypeScript (rse) (recommended)", value: "ts" },
+      { label: "JSONC (rse)", value: "jsonc" }
+    ],
+    defaultValue: "jsonc"
+  });
+}

package/bin/libs/cfg/rse/rse-impl/rse-read.d.ts

@@ -0,0 +1,11 @@
+import type { RseConfig } from "./rse-types";
+/**
+ * Helper for TS config reading.
+ * Uses jiti for TypeScript module loading.
+ */
+export declare function readRseTs(configPath: string): Promise<RseConfig | null>;
+/**
+ * Reads and validates the config file.
+ * If errors are detected, it attempts to merge missing or invalid fields with defaults.
+ */
+export declare function readRseConfig(configPath: string, isDev: boolean): Promise<RseConfig | null>;

package/bin/libs/cfg/rse/rse-impl/rse-read.js

@@ -0,0 +1,84 @@
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { Value } from "@sinclair/typebox/value";
+import { parseJSONC } from "confbox";
+import { createJiti } from "jiti";
+import { writeRseConfig } from "./rse-create.js";
+import { repairAndParseJSON } from "./rse-repair.js";
+import { rseSchema } from "./rse-schema.js";
+import { mergeWithDefaults } from "./rse-update.js";
+import { getBackupAndTempPaths } from "./rse-utils.js";
+const jiti = createJiti(import.meta.url);
+async function parseRseConfig(configPath) {
+  try {
+    const content = (await fs.readFile(configPath, "utf-8")).trim();
+    if (!content || content === "{}") return null;
+    let parsed = parseJSONC(content);
+    if (!parsed || typeof parsed !== "object") {
+      const repaired = repairAndParseJSON(content);
+      if (!repaired) return null;
+      parsed = repaired;
+      relinka("info", "Config JSON was repaired.");
+      relinka("verbose", "Used tool: jsonrepair.");
+    }
+    const schemaProperties = Object.keys(rseSchema.properties);
+    const filteredParsed = Object.fromEntries(
+      Object.entries(parsed).filter(
+        ([key]) => schemaProperties.includes(key)
+      )
+    );
+    const isValid = Value.Check(rseSchema, filteredParsed);
+    return isValid ? { parsed: filteredParsed, errors: null } : {
+      parsed: filteredParsed,
+      errors: Value.Errors(rseSchema, filteredParsed)
+    };
+  } catch {
+    return null;
+  }
+}
+export async function readRseTs(configPath) {
+  try {
+    const config = await jiti.import(configPath, { default: true });
+    if (Value.Check(rseSchema, config)) {
+      return config;
+    }
+    relinka("warn", "TS config does not match the schema.");
+    return null;
+  } catch (error) {
+    relinka(
+      "error",
+      "Failed to import TS config:",
+      error instanceof Error ? error.message : String(error)
+    );
+    return null;
+  }
+}
+export async function readRseConfig(configPath, isDev) {
+  if (configPath.endsWith(".ts")) {
+    return await readRseTs(configPath);
+  }
+  if (!await fs.pathExists(configPath)) return null;
+  const { backupPath } = getBackupAndTempPaths(configPath);
+  const parseResult = await parseRseConfig(configPath);
+  if (!parseResult) return null;
+  if (!parseResult.errors) return parseResult.parsed;
+  const errors = [...parseResult.errors].map((err) => `Path "${err.path}": ${err.message}`);
+  relinka("verbose", "Detected invalid fields in config:", errors.join("; "));
+  const merged = mergeWithDefaults(parseResult.parsed);
+  if (Value.Check(rseSchema, merged)) {
+    await writeRseConfig(configPath, merged, isDev);
+    relinka("info", "Merged missing or invalid fields into config");
+    return merged;
+  }
+  if (await fs.pathExists(backupPath)) {
+    const backupResult = await parseRseConfig(backupPath);
+    if (backupResult && !backupResult.errors) {
+      await fs.copy(backupPath, configPath);
+      relinka("info", "Restored config from backup");
+      return backupResult.parsed;
+    }
+    relinka("warn", "Backup also invalid. Returning null.");
+    return null;
+  }
+  return null;
+}

package/bin/libs/cfg/rse/rse-impl/rse-repair.d.ts

@@ -0,0 +1,16 @@
+import type { TSchema } from "@sinclair/typebox";
+import type { RseConfig } from "./rse-types";
+export declare function repairAndParseJSON(raw: string): any;
+/**
+ * Recursively fixes each property in the object. Returns the fixed config and
+ * an array of property paths that were changed.
+ */
+export declare function fixLineByLine(userConfig: unknown, defaultConfig: unknown, schema: TSchema): {
+    fixedConfig: unknown;
+    changedKeys: string[];
+};
+/**
+ * Reads the config file, fixes invalid lines based on the schema,
+ * writes back the fixed config, and returns the fixed config.
+ */
+export declare function parseAndFixRseConfig(configPath: string, isDev: boolean): Promise<RseConfig | null>;

package/bin/libs/cfg/rse/rse-impl/rse-repair.js

@@ -0,0 +1,137 @@
+import fs from "@reliverse/relifso";
+import { relinka } from "@reliverse/relinka";
+import { Type } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+import { parseJSONC } from "confbox";
+import { jsonrepair } from "jsonrepair";
+import { writeRseConfig } from "./rse-create.js";
+import { DEFAULT_CONFIG_RSE } from "./rse-default.js";
+import { rseSchema } from "./rse-schema.js";
+import { cleanGitHubUrl } from "./rse-utils.js";
+export function repairAndParseJSON(raw) {
+  try {
+    const repaired = jsonrepair(raw);
+    return JSON.parse(repaired);
+  } catch (error) {
+    return null;
+  }
+}
+function createSinglePropertySchema(key, subSchema) {
+  return Type.Object({ [key]: subSchema }, {
+    additionalProperties: false,
+    required: [key]
+  });
+}
+function fixSingleProperty(schema, propName, userValue, defaultValue) {
+  const singlePropertySchema = createSinglePropertySchema(propName, schema);
+  const testObject = { [propName]: userValue };
+  return Value.Check(singlePropertySchema, testObject) ? userValue : defaultValue;
+}
+export function fixLineByLine(userConfig, defaultConfig, schema) {
+  const isObjectSchema = schema.type === "object" && schema.properties;
+  if (!isObjectSchema || typeof userConfig !== "object" || userConfig === null) {
+    const isValid = Value.Check(schema, userConfig);
+    return {
+      fixedConfig: isValid ? userConfig : defaultConfig,
+      changedKeys: isValid ? [] : ["<entire_object>"]
+    };
+  }
+  const properties = schema.properties;
+  const result = { ...defaultConfig ?? {} };
+  const changedKeys = [];
+  const missingKeys = [];
+  for (const propName of Object.keys(properties)) {
+    const subSchema = properties[propName];
+    const userValue = userConfig[propName];
+    const defaultValue = defaultConfig[propName];
+    if (!subSchema) {
+      result[propName] = defaultValue;
+      changedKeys.push(propName);
+      continue;
+    }
+    if (userValue === void 0 && !(propName in userConfig)) {
+      missingKeys.push(propName);
+      result[propName] = defaultValue;
+      continue;
+    }
+    if (propName === "customUserFocusedRepos" || propName === "customDevsFocusedRepos") {
+      if (Array.isArray(userValue)) {
+        result[propName] = userValue.map((url) => cleanGitHubUrl(String(url)));
+        continue;
+      }
+    }
+    const isValidStructure = Value.Check(createSinglePropertySchema(propName, subSchema), {
+      [propName]: userValue
+    });
+    if (!isValidStructure) {
+      result[propName] = defaultValue;
+      changedKeys.push(propName);
+    } else if (subSchema && typeof subSchema === "object" && "type" in subSchema && subSchema.type === "object") {
+      const { fixedConfig, changedKeys: nestedChanges } = fixLineByLine(
+        userValue,
+        defaultValue,
+        subSchema
+      );
+      result[propName] = fixedConfig;
+      if (nestedChanges.length > 0) {
+        changedKeys.push(...nestedChanges.map((nc) => `${propName}.${nc}`));
+      }
+    } else {
+      const originalValue = userValue;
+      const validatedValue = fixSingleProperty(subSchema, propName, userValue, defaultValue);
+      result[propName] = validatedValue;
+      if (originalValue !== void 0 && validatedValue !== originalValue) {
+        changedKeys.push(propName);
+      }
+    }
+  }
+  if (missingKeys.length > 0) {
+    relinka("verbose", "Missing fields injected from default config:", missingKeys.join(", "));
+  }
+  return { fixedConfig: result, changedKeys };
+}
+export async function parseAndFixRseConfig(configPath, isDev) {
+  try {
+    const raw = await fs.readFile(configPath, "utf-8");
+    let parsed = parseJSONC(raw);
+    if (!parsed || typeof parsed !== "object") {
+      const repaired = repairAndParseJSON(raw);
+      if (repaired) {
+        relinka("info", "Config JSON was repaired.");
+        relinka("verbose", "Used tool: jsonrepair.");
+      }
+      parsed = repaired;
+    }
+    if (parsed && typeof parsed === "object") {
+      const originalErrors = [...Value.Errors(rseSchema, parsed)];
+      if (originalErrors.length === 0) return parsed;
+      const { fixedConfig, changedKeys } = fixLineByLine(parsed, DEFAULT_CONFIG_RSE, rseSchema);
+      if (Value.Check(rseSchema, fixedConfig)) {
+        await writeRseConfig(configPath, fixedConfig, isDev);
+        const originalInvalidPaths = originalErrors.map((err) => err.path);
+        relinka(
+          "info",
+          "Your config has been fixed. Please ensure it aligns with your project.",
+          `Changed keys: ${changedKeys.join(", ") || "(none)"}`
+        );
+        relinka(
+          "verbose",
+          `Originally invalid paths were: ${originalInvalidPaths.join(", ") || "(none)"}`
+        );
+        return fixedConfig;
+      }
+      const newErrs = [...Value.Errors(rseSchema, fixedConfig)].map(
+        (e) => `Path "${e.path}": ${e.message}`
+      );
+      relinka("warn", "Could not fix all invalid config lines:", newErrs.join("; "));
+      return null;
+    }
+  } catch (error) {
+    relinka(
+      "warn",
+      "Failed to parse/fix config line-by-line:",
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  return null;
+}