mfer 3.3.0 → 4.0.1

package/README.md

@@ -24,7 +24,7 @@ A powerful CLI tool designed to simplify the management and execution of multipl
 - **Concurrent Execution**: Run multiple micro frontends simultaneously with organized output
 - **Group Management**: Organize micro frontends into logical groups for selective execution
 - **Git Integration**: Pull latest changes from all repositories with a single command
-- **Smart Configuration**: Interactive setup wizard with YAML-based configuration
+- **Smart Configuration**: Interactive setup wizard with TOML-based configuration
 - **Cross-Platform**: Works on Windows, macOS, and Linux
 - **Graceful Shutdown**: Clean termination of all processes with Ctrl+C
 
@@ -359,34 +359,27 @@ mfer lib install my-design-system --select # Select libraries from specific libr
 
 ## ⚙️ Configuration
 
-mfer uses a YAML configuration file located at `~/.mfer/config.yaml`. Here's an example structure:
-
-```yaml
-base_github_url: "https://github.com/your-username"
-mfe_directory: "/path/to/your/micro-frontends"
-lib_directory: "/path/to/your/internal-libs"
-libs:
-  - my-shared-utils
-  - my-design-system
-  - my-common-components
-groups:
-  all:
-    - my-main-app
-    - my-admin-panel
-    - my-shared-components
-  main:
-    - my-main-app
-    - my-shared-components
-  admin:
-    - my-admin-panel
-    - my-shared-components
-mfes: # optional, per-MFE configuration
-  my-main-app:
-    modes:
-      - mode_name: mock
-        command: npm run start:mocked
+mfer uses a TOML configuration file located at `~/.mfer/config.toml`. Here's an example structure:
+
+```toml
+base_github_url = "https://github.com/your-username"
+mfe_directory = "/path/to/your/micro-frontends"
+lib_directory = "/path/to/your/internal-libs"
+libs = ["my-shared-utils", "my-design-system", "my-common-components"]
+
+[groups]
+all = ["my-main-app", "my-admin-panel", "my-shared-components"]
+main = ["my-main-app", "my-shared-components"]
+admin = ["my-admin-panel", "my-shared-components"]
+
+# optional, per-MFE configuration
+[[mfes.my-main-app.modes]]
+mode_name = "mock"
+command = "npm run start:mocked"
 ```
 
+> **Migrating from v3.x?** v4.0.0 is a breaking change: YAML config is no longer supported. Run `mfer config migrate` to convert your existing `~/.mfer/config.yaml` to TOML automatically.
+
 ### Configuration Options
 
 - **`base_github_url`**: Your GitHub base URL for repository operations
@@ -407,17 +400,13 @@ Run modes let individual MFEs use a different start command while the rest of th
 
 **Config example** — `root-config` runs with a mocked API, everything else runs normally:
 
-```yaml
-groups:
-  all:
-    - root-config
-    - mfe-nav
-    - mfe-dashboard
-mfes:
-  root-config:
-    modes:
-      - mode_name: mock
-        command: npm run start:mocked
+```toml
+[groups]
+all = ["root-config", "mfe-nav", "mfe-dashboard"]
+
+[[mfes.root-config.modes]]
+mode_name = "mock"
+command = "npm run start:mocked"
 ```
 
 **Usage:**
@@ -447,12 +436,20 @@ You can edit your configuration in several ways:
 
    ```bash
    # On macOS/Linux
-   nano ~/.mfer/config.yaml
+   nano ~/.mfer/config.toml
 
    # On Windows
-   notepad %USERPROFILE%\.mfer\config.yaml
+   notepad %USERPROFILE%\.mfer\config.toml
    ```
 
+3. **Migrate a legacy YAML config**:
+
+   ```bash
+   mfer config migrate
+   ```
+
+   Converts `~/.mfer/config.yaml` → `~/.mfer/config.toml`. Prompts before overwriting an existing TOML file and optionally removes the legacy YAML afterward.
+
 ## 🎯 Use Cases
 
 ### Development Workflow
@@ -470,25 +467,12 @@ mfer run admin     # Start admin panel
 
 Organize your micro frontends into logical groups:
 
-```yaml
-groups:
-  all:
-    - main-app
-    - admin-panel
-    - user-dashboard
-    - shared-components
-    - design-system
-  core:
-    - main-app
-    - shared-components
-    - design-system
-  admin:
-    - admin-panel
-    - user-dashboard
-    - shared-components
-  ui:
-    - shared-components
-    - design-system
+```toml
+[groups]
+all = ["main-app", "admin-panel", "user-dashboard", "shared-components", "design-system"]
+core = ["main-app", "shared-components", "design-system"]
+admin = ["admin-panel", "user-dashboard", "shared-components"]
+ui = ["shared-components", "design-system"]
 ```
 
 ### Team Collaboration
@@ -588,4 +572,5 @@ Built with:
 - [Inquirer](https://github.com/SBoudrias/Inquirer.js) - Interactive prompts
 - [Concurrently](https://github.com/open-cli-tools/concurrently) - Process management
 - [Chalk](https://github.com/chalk/chalk) - Terminal styling
-- [YAML](https://github.com/eemeli/yaml) - Configuration parsing
+- [smol-toml](https://github.com/squirrelchat/smol-toml) - Configuration parsing
+- [YAML](https://github.com/eemeli/yaml) - Legacy config parsing for `mfer config migrate`

package/dist/commands/config/index.js

@@ -1,7 +1,9 @@
 import { Command } from "commander";
 import { listConfigCommand } from "./sub-commands/list-config.js";
 import { editConfigCommand } from "./sub-commands/edit-config.js";
+import { migrateConfigCommand } from "./sub-commands/migrate.js";
 const configCommand = new Command("config").description("configuration settings");
 configCommand.addCommand(listConfigCommand);
 configCommand.addCommand(editConfigCommand);
+configCommand.addCommand(migrateConfigCommand);
 export default configCommand;

package/dist/commands/config/sub-commands/list-config.js

@@ -1,10 +1,11 @@
+import { inspect } from "util";
 import { Command } from "commander";
 import { configExists, currentConfig, warnOfMissingConfig, } from "../../../utils/config-utils.js";
 export const listConfigCommand = new Command("list")
     .description("display the current configuration settings")
     .action(() => {
     if (configExists) {
-        console.log(currentConfig);
+        console.log(inspect(currentConfig, { depth: null, colors: true }));
     }
     else {
         warnOfMissingConfig();

package/dist/commands/config/sub-commands/migrate.js

@@ -0,0 +1,86 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { Command } from "commander";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import chalk from "chalk";
+import YAML from "yaml";
+import { stringify as stringifyToml } from "smol-toml";
+import { confirm } from "@inquirer/prompts";
+import { isParsedConfigValid, } from "../../../utils/config-utils.js";
+const yamlConfigPath = path.join(os.homedir(), ".mfer/config.yaml");
+const tomlConfigPath = path.join(os.homedir(), ".mfer/config.toml");
+export const migrateConfigCommand = new Command("migrate")
+    .description("migrate a legacy YAML config to TOML")
+    .action(() => __awaiter(void 0, void 0, void 0, function* () {
+    if (!fs.existsSync(yamlConfigPath)) {
+        console.log(`${chalk.red("Error")}: No YAML config found at ${yamlConfigPath}`);
+        return;
+    }
+    let parsed;
+    try {
+        parsed = YAML.parse(fs.readFileSync(yamlConfigPath, "utf8"));
+    }
+    catch (error) {
+        console.log(`${chalk.red("Error")}: Failed to parse YAML config\n${error}`);
+        return;
+    }
+    if (!parsed || typeof parsed !== "object") {
+        console.log(`${chalk.red("Error")}: YAML config is empty or invalid`);
+        return;
+    }
+    if (!isParsedConfigValid(parsed)) {
+        console.log(`${chalk.red("Error")}: YAML config is missing required fields or is structurally invalid. Migration aborted.`);
+        return;
+    }
+    if (fs.existsSync(tomlConfigPath)) {
+        try {
+            const overwrite = yield confirm({
+                message: `${tomlConfigPath} already exists. Overwrite?`,
+                default: false,
+            });
+            if (!overwrite) {
+                console.log(chalk.yellow("Migration cancelled."));
+                return;
+            }
+        }
+        catch (error) {
+            console.log(`${chalk.red("Error")}: Unable to prompt for overwrite\n${error}`);
+            return;
+        }
+    }
+    try {
+        fs.writeFileSync(tomlConfigPath, stringifyToml(parsed));
+    }
+    catch (error) {
+        console.log(`${chalk.red("Error")}: Failed to write TOML config\n${error}`);
+        return;
+    }
+    console.log(chalk.green(`Migrated config written to ${tomlConfigPath}`));
+    let removeOld = false;
+    try {
+        removeOld = yield confirm({
+            message: `Delete the legacy ${yamlConfigPath}?`,
+            default: false,
+        });
+    }
+    catch (error) {
+        console.log(`${chalk.yellow("Warning")}: Unable to prompt for legacy deletion — leaving legacy config in place\n${error}`);
+        return;
+    }
+    if (removeOld) {
+        fs.unlinkSync(yamlConfigPath);
+        console.log(chalk.green(`Removed ${yamlConfigPath}`));
+    }
+    else {
+        console.log(chalk.yellow(`Legacy config left in place at ${yamlConfigPath}. You can delete it manually.`));
+    }
+}));

package/dist/commands/init.js

@@ -33,7 +33,7 @@ function createAndSaveConfig(githubUsername, mfeDirectory, allGroup = [], libDir
     console.log(chalk.blue(`Config file saved to: ${configPath}`));
     console.log(chalk.yellow("You can edit the config file later using: mfer config edit"));
     if (allGroup.length === 0) {
-        console.log(chalk.yellow("\nNote: Placeholder repository names have been added to show proper YAML syntax."));
+        console.log(chalk.yellow("\nNote: Placeholder repository names have been added to show proper TOML syntax."));
         console.log(chalk.yellow("Please replace 'my_mfe_1' and 'my_mfe_2' with your actual repository names."));
     }
     if (libDirectory && libs.length > 0) {

package/dist/utils/config-utils.js

@@ -1,63 +1,73 @@
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
-import YAML from "yaml";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
 import chalk from "chalk";
 import { spawn } from "child_process";
-export const configPath = path.join(os.homedir(), ".mfer/config.yaml");
+export const configPath = path.join(os.homedir(), ".mfer/config.toml");
+export const legacyYamlConfigPath = path.join(os.homedir(), ".mfer/config.yaml");
 export const configExists = fs.existsSync(configPath);
+export const legacyYamlConfigExists = fs.existsSync(legacyYamlConfigPath);
 export let currentConfig;
 export const loadConfig = () => {
     if (configExists) {
         const configFile = fs.readFileSync(configPath, "utf8");
-        currentConfig = YAML.parse(configFile);
+        currentConfig = parseToml(configFile);
         return currentConfig;
     }
     return undefined;
 };
 export const warnOfMissingConfig = () => {
     if (!configExists) {
+        if (legacyYamlConfigExists) {
+            console.log(`${chalk.red("Error")}: No TOML configuration file detected, but a legacy YAML config was found at ${legacyYamlConfigPath}\n       Please run ${chalk.blue.bold("mfer config migrate")} to convert it to TOML`);
+            return;
+        }
         console.log(`${chalk.red("Error")}: No configuration file detected\n       Please run ${chalk.blue.bold("mfer init")} to create one`);
     }
 };
-export const isConfigValid = () => {
-    if (!configExists) {
+export const isParsedConfigValid = (parsed) => {
+    const config = parsed;
+    const hasRequiredFields = Boolean(config &&
+        typeof config === "object" &&
+        config.base_github_url &&
+        config.mfe_directory &&
+        config.groups &&
+        typeof config.groups === "object" &&
+        config.groups.all &&
+        Array.isArray(config.groups.all) &&
+        config.groups.all.length > 0);
+    if (!hasRequiredFields)
+        return false;
+    if (config.lib_directory && (!config.libs || !Array.isArray(config.libs))) {
         return false;
     }
-    try {
-        const configFile = fs.readFileSync(configPath, "utf8");
-        const config = YAML.parse(configFile);
-        const hasRequiredFields = config &&
-            typeof config === "object" &&
-            config.base_github_url &&
-            config.mfe_directory &&
-            config.groups &&
-            typeof config.groups === "object" &&
-            config.groups.all &&
-            Array.isArray(config.groups.all) &&
-            config.groups.all.length > 0;
-        if (config.lib_directory && (!config.libs || !Array.isArray(config.libs))) {
-            return false;
-        }
-        if (config.mfes && typeof config.mfes === "object") {
-            for (const mfeConfig of Object.values(config.mfes)) {
-                if (mfeConfig &&
-                    mfeConfig.modes !== undefined) {
-                    const modes = mfeConfig.modes;
-                    if (!Array.isArray(modes))
+    if (config.mfes && typeof config.mfes === "object") {
+        for (const mfeConfig of Object.values(config.mfes)) {
+            if (mfeConfig && mfeConfig.modes !== undefined) {
+                const modes = mfeConfig.modes;
+                if (!Array.isArray(modes))
+                    return false;
+                for (const mode of modes) {
+                    if (!mode ||
+                        typeof mode !== "object" ||
+                        !mode.mode_name ||
+                        !mode.command) {
                         return false;
-                    for (const mode of modes) {
-                        if (!mode ||
-                            typeof mode !== "object" ||
-                            !mode.mode_name ||
-                            !mode.command) {
-                            return false;
-                        }
                     }
                 }
             }
         }
-        return hasRequiredFields;
+    }
+    return true;
+};
+export const isConfigValid = () => {
+    if (!configExists) {
+        return false;
+    }
+    try {
+        const configFile = fs.readFileSync(configPath, "utf8");
+        return isParsedConfigValid(parseToml(configFile));
     }
     catch (_a) {
         return false;
@@ -69,7 +79,7 @@ export const saveConfig = (newConfig) => {
         if (!fs.existsSync(configDir)) {
             fs.mkdirSync(configDir, { recursive: true });
         }
-        fs.writeFileSync(configPath, YAML.stringify(newConfig));
+        fs.writeFileSync(configPath, stringifyToml(newConfig));
     }
     catch (error) {
         console.log(`Error writing config file!\n\n${error}`);

package/dist/utils/version-utils.js

@@ -10,11 +10,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import * as fs from "fs";
 import * as path from "path";
 import * as os from "os";
+import { fileURLToPath } from "url";
 import chalk from "chalk";
 import { spawnSync } from "child_process";
 const NOTIFIED_VERSION_FILE = path.join(os.homedir(), ".mfer", ".last-notified-version");
 export function getInstalledVersion() {
-    const packageJsonPath = path.join(path.dirname(new URL(import.meta.url).pathname), "../../package.json");
+    const packageJsonPath = path.join(path.dirname(fileURLToPath(import.meta.url)), "../../package.json");
     try {
         const raw = fs.readFileSync(packageJsonPath, "utf8");
         return JSON.parse(raw).version;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mfer",
-  "version": "3.3.0",
+  "version": "4.0.1",
   "description": "CLI tool designed to sensibly run micro-frontends from the terminal.",
   "bin": {
     "mfer": "dist/index.js"
@@ -57,6 +57,7 @@
     "chalk": "^5.6.2",
     "commander": "^14.0.0",
     "concurrently": "^9.2.0",
+    "smol-toml": "^1.6.1",
     "yaml": "^2.8.0"
   },
   "files": [