mfer 1.4.2 → 1.5.0

package/README.md

@@ -123,11 +123,22 @@ Run micro frontend applications concurrently.
 
 - `group_name`: Name of the group to run (defaults to "all")
 
-**Example:**
+**Options:**
+
+- `-c, --command <command>`: Custom command to run (default: npm start)
+- `-a, --async`: Run custom command concurrently instead of sequentially
+- `-s, --select`: Prompt to select which micro frontends to run
+
+**Examples:**
 
 ```bash
-mfer run          # Run all micro frontends
-mfer run frontend # Run only frontend group
+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 --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 pull [group_name]`

package/dist/commands/run.js

@@ -13,17 +13,32 @@ import concurrently from "concurrently";
 import chalk from "chalk";
 import path from "path";
 import { checkbox } from "@inquirer/prompts";
-const RUN_COMMAND = "npm start";
+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")
     .action((groupName, options) => __awaiter(void 0, void 0, void 0, function* () {
     var _a, _b;
     if (!configExists) {
         warnOfMissingConfig();
         return;
     }
+    if (options.command &&
+        typeof options.command === "string" &&
+        options.command.trim() === "") {
+        const messagePrefix = chalk.red("Error");
+        console.log(`${messagePrefix}: custom command cannot be empty`);
+        return;
+    }
+    if (options.async && !options.command) {
+        const messagePrefix = chalk.red("Error");
+        console.log(`${messagePrefix}: --async can only be used with --command option`);
+        return;
+    }
     const group = currentConfig.groups[groupName];
     if (!group) {
         const messagePrefix = chalk.red("Error");
@@ -57,45 +72,91 @@ const runCommand = new Command("run")
         }
     }
     const mfeDir = currentConfig.mfe_directory;
-    const commands = selectedMFEs.map((mfe) => ({
-        command: RUN_COMMAND,
-        name: mfe,
-        cwd: path.join(mfeDir, mfe),
-        prefixColor: "blue",
-    }));
+    const commandToRun = options.command || DEFAULT_RUN_COMMAND;
+    const isAsync = options.async && options.command;
     const groupText = options.select
         ? `selected MFEs from group '${groupName}'`
         : `group '${groupName}'`;
-    console.log(chalk.green(`Running micro frontends in ${groupText}...`));
-    const concurrentlyResult = concurrently(commands, {
-        prefix: "{name} |",
-        killOthersOn: ["failure", "success"],
-        restartTries: 0,
-    });
-    const handleSigint = () => {
-        console.log(chalk.yellow("\nReceived SIGINT. Stopping all micro frontends..."));
-        concurrentlyResult.commands.forEach((cmd) => {
-            if (cmd && typeof cmd.kill === "function") {
-                cmd.kill();
+    const commandText = options.command
+        ? `custom command '${commandToRun}'`
+        : "default command";
+    const executionMode = isAsync ? "concurrently" : "sequentially";
+    console.log(chalk.green(`Running ${commandText} on micro frontends in ${groupText} ${executionMode}...`));
+    if (isAsync || !options.command) {
+        yield runConcurrently(selectedMFEs, commandToRun, mfeDir);
+    }
+    else {
+        yield runSequentially(selectedMFEs, commandToRun, mfeDir);
+    }
+}));
+function runSequentially(mfes, command, mfeDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        for (const mfe of mfes) {
+            const cwd = path.join(mfeDir, mfe);
+            console.log(chalk.blue(`\n[${mfe}] Running: ${command}`));
+            try {
+                const result = yield new Promise((resolve) => {
+                    const child = spawn(command, [], {
+                        stdio: "inherit",
+                        cwd,
+                        shell: true,
+                    });
+                    child.on("close", (exitCode) => {
+                        resolve({ exitCode });
+                    });
+                    child.on("error", (error) => {
+                        console.error(chalk.red(`[${mfe}] Error: ${error.message}`));
+                        resolve({ exitCode: 1 });
+                    });
+                });
+                if (result.exitCode !== 0) {
+                    console.error(chalk.red(`[${mfe}] Command failed with exit code ${result.exitCode}`));
+                }
             }
+            catch (error) {
+                console.error(chalk.red(`[${mfe}] Unexpected error: ${error}`));
+            }
+        }
+    });
+}
+function runConcurrently(mfes, command, mfeDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const commands = mfes.map((mfe) => ({
+            command,
+            name: mfe,
+            cwd: path.join(mfeDir, mfe),
+            prefixColor: "blue",
+        }));
+        const concurrentlyResult = concurrently(commands, {
+            prefix: "{name} |",
+            killOthersOn: ["failure", "success"],
+            restartTries: 0,
         });
-        process.exit(0);
-    };
-    process.once("SIGINT", handleSigint);
-    concurrentlyResult.result.then(() => { }, (err) => {
-        console.error(chalk.red("One or more micro frontends failed to start."));
-        if (Array.isArray(err)) {
-            err.forEach((fail) => {
-                var _a, _b;
-                const name = ((_a = fail.command) === null || _a === void 0 ? void 0 : _a.name) || "unknown";
-                const exitCode = fail.exitCode;
-                const cwd = ((_b = fail.command) === null || _b === void 0 ? void 0 : _b.cwd) || "unknown";
-                console.error(chalk.yellow(`  MFE ${name} failed to start (cwd: ${cwd}) with exit code ${exitCode}`));
+        const handleSigint = () => {
+            console.log(chalk.yellow("\nReceived SIGINT. Stopping all micro frontends..."));
+            concurrentlyResult.commands.forEach((cmd) => {
+                if (cmd && typeof cmd.kill === "function") {
+                    cmd.kill();
+                }
             });
-        }
-        else if (err && typeof err === "object" && "message" in err) {
-            console.error(err.message);
-        }
+            process.exit(0);
+        };
+        process.once("SIGINT", handleSigint);
+        concurrentlyResult.result.then(() => { }, (err) => {
+            console.error(chalk.red("One or more micro frontends failed to start."));
+            if (Array.isArray(err)) {
+                err.forEach((fail) => {
+                    var _a, _b;
+                    const name = ((_a = fail.command) === null || _a === void 0 ? void 0 : _a.name) || "unknown";
+                    const exitCode = fail.exitCode;
+                    const cwd = ((_b = fail.command) === null || _b === void 0 ? void 0 : _b.cwd) || "unknown";
+                    console.error(chalk.yellow(`  MFE ${name} failed to start (cwd: ${cwd}) with exit code ${exitCode}`));
+                });
+            }
+            else if (err && typeof err === "object" && "message" in err) {
+                console.error(err.message);
+            }
+        });
     });
-}));
+}
 export default runCommand;

package/dist/index.js

@@ -10,7 +10,7 @@ import { loadConfig } from "./utils/config-utils.js";
 program
     .name("mfer")
     .description("Micro Frontend Runner (mfer) - A CLI for running your project's micro frontends.")
-    .version("1.4.2", "-v, --version", "mfer CLI version")
+    .version("1.5.0", "-v, --version", "mfer CLI version")
     .hook("preAction", () => {
     console.log();
 })

package/package.json

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