mfer 3.2.4 → 3.3.0

package/README.md

@@ -95,7 +95,7 @@ mfer pull frontend
 ### Quick Reference
 
 - [`mfer init`](#mfer-init) - Interactive setup wizard
-- [`mfer run`](#mfer-run-group_name) - Run micro frontend applications
+- [`mfer run`](#mfer-run-group_name) - Run micro frontend applications (supports per-MFE run modes)
 - [`mfer pull`](#mfer-pull-group_name) - Pull latest changes from git repositories
 - [`mfer install`](#mfer-install-group_name) - Install dependencies for micro frontends
 - [`mfer clone`](#mfer-clone-group_name) - Clone repositories that don't exist locally
@@ -127,20 +127,24 @@ Run micro frontend applications concurrently.
 
 **Options:**
 
-- `-c, --command <command>`: Custom command to run (default: npm start)
-- `-a, --async`: Run custom command concurrently instead of sequentially
+- `-c, --command <command>`: Custom command to run for all MFEs (default: npm start)
+- `-a, --async`: Run custom command concurrently instead of sequentially (only with `--command`)
+- `-m, --mode <mode_name>`: Run MFEs using a named mode from config (see [Per-MFE Run Modes](#per-mfe-run-modes))
 - `-s, --select`: Prompt to select which micro frontends to run
 
+> **Note:** `--mode` and `--command` are mutually exclusive.
+
 **Examples:**
 
 ```bash
-mfer run                    # Run all micro frontends with default command (npm start)
-mfer run frontend          # Run only frontend group with default command
-mfer run --command "npm ci" home    # Run custom command sequentially on home group
-mfer run -c "yarn install" shared  # Run yarn install sequentially on shared group
+mfer run                          # Run all MFEs with default command (npm start)
+mfer run frontend                 # Run frontend group with default command
+mfer run --mode mock              # Run all MFEs in mock mode (per-MFE commands from config)
+mfer run frontend --mode mock     # Run frontend group in mock mode
+mfer run --command "npm ci" home  # Run custom command sequentially on home group
+mfer run -c "yarn install" shared # Run yarn install sequentially on shared group
 mfer run --command "npm ci" --async home  # Run custom command concurrently on home group
-mfer run -c "yarn install" -a shared  # Run yarn install concurrently on shared group
-mfer run --command "npm run build" --select  # Select MFEs and run build command sequentially
+mfer run --command "npm run build" --select  # Select MFEs and run build sequentially
 ```
 
 ### `mfer pull [group_name]`
@@ -376,6 +380,11 @@ groups:
   admin:
     - my-admin-panel
     - my-shared-components
+mfes: # optional, per-MFE configuration
+  my-main-app:
+    modes:
+      - mode_name: mock
+        command: npm run start:mocked
 ```
 
 ### Configuration Options
@@ -387,6 +396,42 @@ groups:
 - **`groups`**: Named collections of micro frontend projects
   - **`all`**: Default group containing all projects (required)
   - **Custom groups**: Any additional groups you want to create
+- **`mfes`**: Per-MFE configuration (optional). Each key is an MFE name matching one in `groups`.
+  - **`modes`**: Array of named run modes for the MFE. Each mode has:
+    - **`mode_name`**: Name used with `mfer run --mode <name>`
+    - **`command`**: The command to run for this MFE when the mode is active
+
+### Per-MFE Run Modes
+
+Run modes let individual MFEs use a different start command while the rest of the group continue using `npm start`. This is useful when some MFEs support a mocked/stubbed backend while others don't need it.
+
+**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
+```
+
+**Usage:**
+
+```bash
+mfer run --mode mock
+# root-config → npm run start:mocked
+# mfe-nav     → npm start  (no mock mode defined, falls back to default)
+# mfe-dashboard → npm start
+```
+
+- MFEs that **do not** have the mode defined silently fall back to `npm start`.
+- If **no MFE** in the group has the requested mode, a warning is printed but the command still runs (all MFEs use `npm start`).
+- `--mode` cannot be combined with `--command`; they are mutually exclusive.
 
 ### Editing Configuration
 
@@ -456,11 +501,10 @@ groups:
 
 ### Custom Start Commands
 
-By default, mfer runs `npm start` in each project directory.
-You can currently only customize this by modifying the run command in the source code.
+By default, mfer runs `npm start` in each project directory. You can customize this in two ways:
 
-Adding configurable custom start commands is something I plan on adding in the near future.
-I also welcome anyone to open a PR for that!
+- **Same command for all MFEs**: use `--command` (e.g. `mfer run --command "yarn start"`)
+- **Per-MFE commands via modes**: define `mfes[name].modes` in config and use `--mode` (see [Per-MFE Run Modes](#per-mfe-run-modes))
 
 ### Environment Variables
 

package/dist/commands/run.js

@@ -12,15 +12,15 @@ import { configExists, currentConfig, warnOfMissingConfig, } from "../utils/conf
 import concurrently from "concurrently";
 import chalk from "chalk";
 import path from "path";
-import { promptForMFESelection } from "../utils/command-utils.js";
+import { promptForMFESelection, resolveRunCommand, } from "../utils/command-utils.js";
 import { spawn } from "child_process";
-const DEFAULT_RUN_COMMAND = "npm start";
 const runCommand = new Command("run")
     .description("run micro-frontend applications")
     .argument("[group_name]", "name of the group as specified in the configuration", "all")
     .option("-s, --select", "prompt to select which micro frontends to run")
     .option("-c, --command <command>", "custom command to run (default: npm start)")
     .option("-a, --async", "run custom command concurrently instead of sequentially (only works with --command option)")
+    .option("-m, --mode <mode_name>", "run MFEs using a named mode from config")
     .action((groupName, options) => __awaiter(void 0, void 0, void 0, function* () {
     if (!configExists) {
         warnOfMissingConfig();
@@ -33,11 +33,16 @@ const runCommand = new Command("run")
         console.log(`${messagePrefix}: custom command cannot be empty`);
         return;
     }
-    if (options.async && !options.command) {
+    if (options.async && !options.command && !options.mode) {
         const messagePrefix = chalk.red("Error");
         console.log(`${messagePrefix}: --async can only be used with --command option`);
         return;
     }
+    if (options.mode && options.command) {
+        const messagePrefix = chalk.red("Error");
+        console.log(`${messagePrefix}: --mode and --command cannot be used together`);
+        return;
+    }
     const group = currentConfig.groups[groupName];
     if (!group) {
         const messagePrefix = chalk.red("Error");
@@ -54,26 +59,42 @@ const runCommand = new Command("run")
     if (options.select) {
         selectedMFEs = yield promptForMFESelection(groupName, group);
     }
+    if (options.mode) {
+        const hasAnyMfeWithMode = selectedMFEs.some((mfe) => {
+            var _a, _b, _c;
+            return (_c = (_b = (_a = currentConfig.mfes) === null || _a === void 0 ? void 0 : _a[mfe]) === null || _b === void 0 ? void 0 : _b.modes) === null || _c === void 0 ? void 0 : _c.some((m) => m.mode_name === options.mode);
+        });
+        if (!hasAnyMfeWithMode) {
+            console.log(chalk.yellow(`Warning: no MFE in the selected group has a '${options.mode}' mode defined. All MFEs will use the default command.`));
+        }
+    }
     const mfeDir = currentConfig.mfe_directory;
-    const commandToRun = options.command || DEFAULT_RUN_COMMAND;
     const isAsync = options.async && options.command;
+    const mfeCommands = selectedMFEs.map((mfe) => ({
+        mfe,
+        command: options.command
+            ? options.command
+            : resolveRunCommand(mfe, options.mode, currentConfig),
+    }));
     const groupText = options.select
         ? `selected MFEs from group '${groupName}'`
         : `group '${groupName}'`;
     const commandText = options.command
-        ? `custom command '${commandToRun}'`
-        : "default command";
+        ? `custom command '${options.command}'`
+        : options.mode
+            ? `mode '${options.mode}'`
+            : "default command";
     console.log(chalk.green(`Running ${commandText} on micro frontends in ${groupText}...`));
     if (isAsync || !options.command) {
-        yield runConcurrently(selectedMFEs, commandToRun, mfeDir);
+        yield runConcurrently(mfeCommands, mfeDir);
     }
     else {
-        yield runSequentially(selectedMFEs, commandToRun, mfeDir);
+        yield runSequentially(mfeCommands, mfeDir);
     }
 }));
-function runSequentially(mfes, command, mfeDir) {
+function runSequentially(mfeCommands, mfeDir) {
     return __awaiter(this, void 0, void 0, function* () {
-        for (const mfe of mfes) {
+        for (const { mfe, command } of mfeCommands) {
             const cwd = path.join(mfeDir, mfe);
             console.log(chalk.blue(`\n[${mfe}] Running: ${command}`));
             try {
@@ -101,9 +122,9 @@ function runSequentially(mfes, command, mfeDir) {
         }
     });
 }
-function runConcurrently(mfes, command, mfeDir) {
+function runConcurrently(mfeCommands, mfeDir) {
     return __awaiter(this, void 0, void 0, function* () {
-        const commands = mfes.map((mfe) => ({
+        const commands = mfeCommands.map(({ mfe, command }) => ({
             command,
             name: mfe,
             cwd: path.join(mfeDir, mfe),

package/dist/index.js

@@ -9,11 +9,11 @@ import pullCommand from "./commands/pull.js";
 import libCommand from "./commands/lib/index.js";
 import updateCommand from "./commands/update.js";
 import { loadConfig } from "./utils/config-utils.js";
-import { checkForUpdateNotification } from "./utils/version-utils.js";
+import { checkForUpdateNotification, getInstalledVersion, } from "./utils/version-utils.js";
 program
     .name("mfer")
     .description("Micro Frontend Runner (mfer) - A CLI for running your project's micro frontends.")
-    .version("3.2.4", "-v, --version", "mfer CLI version")
+    .version(getInstalledVersion(), "-v, --version", "mfer CLI version")
     .hook("preAction", () => {
     console.log();
 })

package/dist/utils/command-utils.js

@@ -13,6 +13,14 @@ import { spawnSync } from "child_process";
 import concurrently from "concurrently";
 import path from "path";
 import fs from "fs";
+export const DEFAULT_RUN_COMMAND = "npm start";
+export function resolveRunCommand(mfe, modeName, config) {
+    var _a, _b, _c, _d;
+    if (!modeName)
+        return DEFAULT_RUN_COMMAND;
+    const mode = (_c = (_b = (_a = config.mfes) === null || _a === void 0 ? void 0 : _a[mfe]) === null || _b === void 0 ? void 0 : _b.modes) === null || _c === void 0 ? void 0 : _c.find((m) => m.mode_name === modeName);
+    return (_d = mode === null || mode === void 0 ? void 0 : mode.command) !== null && _d !== void 0 ? _d : DEFAULT_RUN_COMMAND;
+}
 export function promptForMFESelection(groupName, mfes) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a, _b;

package/dist/utils/config-utils.js

@@ -39,6 +39,24 @@ export const isConfigValid = () => {
         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))
+                        return false;
+                    for (const mode of modes) {
+                        if (!mode ||
+                            typeof mode !== "object" ||
+                            !mode.mode_name ||
+                            !mode.command) {
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
         return hasRequiredFields;
     }
     catch (_a) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mfer",
-  "version": "3.2.4",
+  "version": "3.3.0",
   "description": "CLI tool designed to sensibly run micro-frontends from the terminal.",
   "bin": {
     "mfer": "dist/index.js"