mfer 4.0.0 → 4.1.0

package/README.md

@@ -131,6 +131,7 @@ Run micro frontend applications concurrently.
 - `-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
+- `--config <path>`: Use a specific config file path (overrides default config location)
 
 > **Note:** `--mode` and `--command` are mutually exclusive.
 
@@ -145,6 +146,7 @@ mfer run --command "npm ci" home  # Run custom command sequentially on home grou
 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 --command "npm run build" --select  # Select MFEs and run build sequentially
+mfer run --config ./mfer.config.toml --select  # Use project-local config and select MFEs
 ```
 
 ### `mfer pull [group_name]`
@@ -359,7 +361,15 @@ mfer lib install my-design-system --select # Select libraries from specific libr
 
 ## ⚙️ Configuration
 
-mfer uses a TOML configuration file located at `~/.mfer/config.toml`. Here's an example structure:
+mfer uses a TOML configuration file. Default location: `~/.mfer/config.toml`
+
+Override options (highest precedence first):
+
+- CLI: `mfer --config ./path/to/config.toml ...`
+- Env: `MFER_CONFIG=./path/to/config.toml`
+- Default: `~/.mfer/config.toml`
+
+Here's an example structure:
 
 ```toml
 base_github_url = "https://github.com/your-username"
@@ -376,6 +386,11 @@ admin = ["my-admin-panel", "my-shared-components"]
 [[mfes.my-main-app.modes]]
 mode_name = "mock"
 command = "npm run start:mocked"
+
+# optional lifecycle hooks for `mfer run`
+[hooks]
+pre_run = "echo preparing run for $MFER_GROUP_NAME"
+post_run = "echo completed run for $MFER_GROUP_NAME"
 ```
 
 > **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.
@@ -393,6 +408,9 @@ command = "npm run start:mocked"
   - **`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
+- **`hooks`**: Optional run lifecycle hooks
+  - **`pre_run`**: Command executed before `mfer run` starts MFE processes
+  - **`post_run`**: Command executed after `mfer run` finishes successfully
 
 ### Per-MFE Run Modes
 
@@ -422,6 +440,17 @@ mfer run --mode mock
 - 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.
 
+### Run Lifecycle Hooks
+
+When configured, `pre_run` and `post_run` hooks run in the configured `mfe_directory`.
+
+Environment variables provided to hooks:
+
+- `MFER_HOOK_NAME` (`pre_run` or `post_run`)
+- `MFER_GROUP_NAME` (resolved group name)
+- `MFER_MFE_DIRECTORY` (configured mfe root directory)
+- `MFER_SELECTED_MFES` (comma-separated selected MFEs)
+
 ### Editing Configuration
 
 You can edit your configuration in several ways:

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/run.js

@@ -12,7 +12,7 @@ import { configExists, currentConfig, warnOfMissingConfig, } from "../utils/conf
 import concurrently from "concurrently";
 import chalk from "chalk";
 import path from "path";
-import { promptForMFESelection, resolveRunCommand, } from "../utils/command-utils.js";
+import { promptForMFESelection, resolveRunCommand, runLifecycleHook, } from "../utils/command-utils.js";
 import { spawn } from "child_process";
 const runCommand = new Command("run")
     .description("run micro-frontend applications")
@@ -22,6 +22,7 @@ const runCommand = new Command("run")
     .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* () {
+    var _a, _b;
     if (!configExists) {
         warnOfMissingConfig();
         return;
@@ -85,12 +86,22 @@ const runCommand = new Command("run")
             ? `mode '${options.mode}'`
             : "default command";
     console.log(chalk.green(`Running ${commandText} on micro frontends in ${groupText}...`));
+    yield runLifecycleHook((_a = currentConfig.hooks) === null || _a === void 0 ? void 0 : _a.pre_run, "pre_run", {
+        groupName,
+        mfeDirectory: mfeDir,
+        selectedMfes: selectedMFEs,
+    });
     if (isAsync || !options.command) {
         yield runConcurrently(mfeCommands, mfeDir);
     }
     else {
         yield runSequentially(mfeCommands, mfeDir);
     }
+    yield runLifecycleHook((_b = currentConfig.hooks) === null || _b === void 0 ? void 0 : _b.post_run, "post_run", {
+        groupName,
+        mfeDirectory: mfeDir,
+        selectedMfes: selectedMFEs,
+    });
 }));
 function runSequentially(mfeCommands, mfeDir) {
     return __awaiter(this, void 0, void 0, function* () {

package/dist/index.js

@@ -13,6 +13,7 @@ import { checkForUpdateNotification, getInstalledVersion, } from "./utils/versio
 program
     .name("mfer")
     .description("Micro Frontend Runner (mfer) - A CLI for running your project's micro frontends.")
+    .option("--config <path>", "path to config.toml (overrides ~/.mfer/config.toml)")
     .version(getInstalledVersion(), "-v, --version", "mfer CLI version")
     .hook("preAction", () => {
     console.log();

package/dist/utils/command-utils.js

@@ -14,6 +14,22 @@ import concurrently from "concurrently";
 import path from "path";
 import fs from "fs";
 export const DEFAULT_RUN_COMMAND = "npm start";
+export function runLifecycleHook(hookCommand, hookName, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!hookCommand) {
+            return;
+        }
+        const result = spawnSync(hookCommand, {
+            cwd: options.mfeDirectory,
+            env: Object.assign(Object.assign({}, process.env), { MFER_GROUP_NAME: options.groupName, MFER_HOOK_NAME: hookName, MFER_MFE_DIRECTORY: options.mfeDirectory, MFER_SELECTED_MFES: options.selectedMfes.join(",") }),
+            shell: true,
+            stdio: "inherit",
+        });
+        if (result.status !== 0) {
+            throw new Error(`Hook '${hookName}' failed with exit code ${result.status}`);
+        }
+    });
+}
 export function resolveRunCommand(mfe, modeName, config) {
     var _a, _b, _c, _d;
     if (!modeName)

package/dist/utils/config-utils.js

@@ -4,15 +4,44 @@ import * as os from "os";
 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.toml");
-export const legacyYamlConfigPath = path.join(os.homedir(), ".mfer/config.yaml");
+import { expandHomePath } from "./file-utils.js";
+const getCliOptionValue = (optionName) => {
+    const exactMatchIndex = process.argv.findIndex((arg) => arg === optionName);
+    if (exactMatchIndex >= 0) {
+        return process.argv[exactMatchIndex + 1];
+    }
+    const inlineMatch = process.argv.find((arg) => arg.startsWith(`${optionName}=`));
+    return inlineMatch === null || inlineMatch === void 0 ? void 0 : inlineMatch.split("=")[1];
+};
+const resolvedConfigPath = () => {
+    const pathFromCli = getCliOptionValue("--config");
+    const pathFromEnv = process.env.MFER_CONFIG;
+    const configPathOverride = pathFromCli || pathFromEnv;
+    if (!configPathOverride) {
+        return path.join(os.homedir(), ".mfer/config.toml");
+    }
+    const expandedConfigPath = expandHomePath(configPathOverride);
+    return path.isAbsolute(expandedConfigPath)
+        ? expandedConfigPath
+        : path.resolve(expandedConfigPath);
+};
+export const configPath = resolvedConfigPath();
+export const legacyYamlConfigPath = path.join(path.dirname(configPath), "config.yaml");
 export const configExists = fs.existsSync(configPath);
 export const legacyYamlConfigExists = fs.existsSync(legacyYamlConfigPath);
 export let currentConfig;
+const normalizeConfigPaths = (config) => {
+    const normalizedConfig = Object.assign(Object.assign({}, config), { mfe_directory: expandHomePath(config.mfe_directory) });
+    if (normalizedConfig.lib_directory) {
+        normalizedConfig.lib_directory = expandHomePath(normalizedConfig.lib_directory);
+    }
+    return normalizedConfig;
+};
 export const loadConfig = () => {
     if (configExists) {
         const configFile = fs.readFileSync(configPath, "utf8");
-        currentConfig = parseToml(configFile);
+        const parsedConfig = parseToml(configFile);
+        currentConfig = normalizeConfigPaths(parsedConfig);
         return currentConfig;
     }
     return undefined;
@@ -59,6 +88,20 @@ export const isParsedConfigValid = (parsed) => {
             }
         }
     }
+    if (config.hooks !== undefined) {
+        if (!config.hooks || typeof config.hooks !== "object") {
+            return false;
+        }
+        const hooksConfig = config.hooks;
+        for (const [hookName, hookCommand] of Object.entries(hooksConfig)) {
+            if (typeof hookCommand !== "string" || hookCommand.trim() === "") {
+                return false;
+            }
+            if (!["pre_run", "post_run"].includes(hookName)) {
+                return false;
+            }
+        }
+    }
     return true;
 };
 export const isConfigValid = () => {

package/dist/utils/file-utils.js

@@ -0,0 +1,11 @@
+import * as os from "os";
+import * as path from "path";
+export const expandHomePath = (targetPath) => {
+    if (targetPath === "~") {
+        return os.homedir();
+    }
+    if (!targetPath.startsWith("~/")) {
+        return targetPath;
+    }
+    return path.join(os.homedir(), targetPath.slice(2));
+};

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": "4.0.0",
+  "version": "4.1.0",
   "description": "CLI tool designed to sensibly run micro-frontends from the terminal.",
   "bin": {
     "mfer": "dist/index.js"