mfer 1.4.2 → 2.0.0

package/README.md

@@ -1,6 +1,7 @@
 # mfer (Micro Frontend Runner)
 
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT) [![npm version](https://img.shields.io/npm/v/mfer.svg)](https://www.npmjs.com/package/mfer)
+
 
 A powerful CLI tool designed to simplify the management and execution of multiple micro frontend applications. mfer helps developers run, update, and organize their micro frontend projects with minimal configuration and maximum efficiency.
 
@@ -123,11 +124,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/init.js

@@ -12,7 +12,7 @@ import { configExists, isConfigValid, saveConfig, configPath, } from "../utils/c
 import chalk from "chalk";
 import * as fs from "fs";
 import { input, confirm, checkbox } from "@inquirer/prompts";
-function createAndSaveConfig(githubUsername, mfeDirectory, allGroup = []) {
+function createAndSaveConfig(githubUsername, mfeDirectory, allGroup = [], libDirectory, libs = []) {
     const repositories = allGroup.length > 0 ? allGroup : ["my_mfe_1", "my_mfe_2"];
     const newConfig = {
         base_github_url: `https://github.com/${githubUsername}`,
@@ -21,6 +21,10 @@ function createAndSaveConfig(githubUsername, mfeDirectory, allGroup = []) {
             all: repositories,
         },
     };
+    if (libDirectory && libs.length > 0) {
+        newConfig.lib_directory = libDirectory;
+        newConfig.libs = libs;
+    }
     saveConfig(newConfig);
     const successMessage = allGroup.length > 0
         ? "Configuration created successfully!"
@@ -32,6 +36,10 @@ function createAndSaveConfig(githubUsername, mfeDirectory, allGroup = []) {
         console.log(chalk.yellow("\nNote: Placeholder repository names have been added to show proper YAML syntax."));
         console.log(chalk.yellow("Please replace 'my_mfe_1' and 'my_mfe_2' with your actual repository names."));
     }
+    if (libDirectory && libs.length > 0) {
+        console.log(chalk.green(`\nLibrary configuration added: ${libs.length} librar${libs.length === 1 ? 'y' : 'ies'} configured.`));
+        console.log(chalk.yellow("You can now use 'mfer lib build', 'mfer lib deploy', and 'mfer lib publish' commands."));
+    }
 }
 function getFoldersFromDirectory(directoryPath) {
     try {
@@ -98,6 +106,44 @@ function promptForFolderSelection(folders) {
         }
     });
 }
+function promptForLibDirectory() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const useLibs = yield confirm({
+                message: "Do you have internal npm packages/libraries that need to be built and deployed to your micro frontends?",
+                default: false,
+            });
+            if (!useLibs) {
+                return undefined;
+            }
+            return yield input({
+                message: [
+                    "Enter the path to the folder containing your internal npm packages/libraries.",
+                    "  (Tip: Drag a folder from your file explorer into this terminal to paste its path)",
+                    "  >>>",
+                ].join("\n"),
+                validate: (val) => val && val.trim() !== "" ? true : "Folder path cannot be empty",
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    });
+}
+function promptForLibSelection(libs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            return yield checkbox({
+                message: "Select which libraries to include in the configuration:",
+                choices: libs.map((lib) => ({ name: lib, value: lib })),
+                validate: (arr) => (arr.length > 0 ? true : "Select at least one library"),
+            });
+        }
+        catch (error) {
+            throw error;
+        }
+    });
+}
 const initCommand = new Command("init")
     .description("setup a new configuration")
     .option("-f, --force", "force re-initialization even if config exists and is valid")
@@ -138,11 +184,45 @@ const initCommand = new Command("init")
             if (interrupted) {
                 return;
             }
-            createAndSaveConfig(githubUsername, mfeDirectory, selectedFolders);
+            const libDirectory = yield promptForLibDirectory();
+            if (interrupted) {
+                return;
+            }
+            let libs = [];
+            if (libDirectory) {
+                const availableLibs = getFoldersFromDirectory(libDirectory);
+                if (availableLibs.length > 0) {
+                    libs = yield promptForLibSelection(availableLibs);
+                    if (interrupted) {
+                        return;
+                    }
+                }
+                else {
+                    console.log(chalk.yellow("No library directories found in the specified path."));
+                }
+            }
+            createAndSaveConfig(githubUsername, mfeDirectory, selectedFolders, libDirectory, libs);
         }
         else {
             console.log("Add the names of your micro frontends to the 'groups' section.");
-            createAndSaveConfig(githubUsername, mfeDirectory);
+            const libDirectory = yield promptForLibDirectory();
+            if (interrupted) {
+                return;
+            }
+            let libs = [];
+            if (libDirectory) {
+                const availableLibs = getFoldersFromDirectory(libDirectory);
+                if (availableLibs.length > 0) {
+                    libs = yield promptForLibSelection(availableLibs);
+                    if (interrupted) {
+                        return;
+                    }
+                }
+                else {
+                    console.log(chalk.yellow("No library directories found in the specified path."));
+                }
+            }
+            createAndSaveConfig(githubUsername, mfeDirectory, [], libDirectory, libs);
         }
     }
     catch (error) {

package/dist/commands/lib/build.js

@@ -0,0 +1,81 @@
+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 chalk from "chalk";
+import { spawn } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import { currentConfig, configExists, warnOfMissingConfig, } from "../../utils/config-utils.js";
+const buildCommand = new Command("build")
+    .description("Build internal npm packages")
+    .argument("[lib-name]", "Name of the library to build (builds all if not specified)")
+    .action((libName) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!configExists) {
+        warnOfMissingConfig();
+        return;
+    }
+    if (!currentConfig.lib_directory || !currentConfig.libs) {
+        console.log(chalk.red("Error: Library configuration not found in config file."));
+        console.log(chalk.yellow("Please run 'mfer init' to configure library settings."));
+        return;
+    }
+    const libsToBuild = libName
+        ? [libName].filter(lib => currentConfig.libs.includes(lib))
+        : currentConfig.libs;
+    if (libName && !currentConfig.libs.includes(libName)) {
+        console.log(chalk.red(`Error: Library '${libName}' not found in configuration.`));
+        console.log(chalk.yellow(`Available libraries: ${currentConfig.libs.join(", ")}`));
+        return;
+    }
+    if (libsToBuild.length === 0) {
+        console.log(chalk.yellow("No libraries to build."));
+        return;
+    }
+    console.log(chalk.blue(`Building ${libsToBuild.length} librar${libsToBuild.length === 1 ? 'y' : 'ies'}...`));
+    for (const lib of libsToBuild) {
+        const libPath = path.join(currentConfig.lib_directory, lib);
+        if (!fs.existsSync(libPath)) {
+            console.log(chalk.red(`Error: Library directory not found: ${libPath}`));
+            continue;
+        }
+        console.log(chalk.blue(`\nBuilding ${chalk.bold(lib)}...`));
+        try {
+            yield buildLibrary(libPath, lib);
+            console.log(chalk.green(`✓ ${lib} built successfully`));
+        }
+        catch (error) {
+            console.log(chalk.red(`✗ Failed to build ${lib}: ${error}`));
+        }
+    }
+    console.log(chalk.green("\nBuild process completed!"));
+}));
+function buildLibrary(libPath, libName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            const buildProcess = spawn("npm", ["run", "build"], {
+                stdio: "inherit",
+                cwd: libPath,
+                shell: true,
+            });
+            buildProcess.on("close", (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Build process exited with code ${code}`));
+                }
+            });
+            buildProcess.on("error", (error) => {
+                reject(error);
+            });
+        });
+    });
+}
+export default buildCommand;

package/dist/commands/lib/deploy.js

@@ -0,0 +1,109 @@
+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 chalk from "chalk";
+import * as fs from "fs";
+import * as path from "path";
+import { currentConfig, configExists, warnOfMissingConfig, } from "../../utils/config-utils.js";
+const deployCommand = new Command("deploy")
+    .description("Copy built libraries to micro frontends")
+    .argument("[lib-name]", "Name of the library to deploy (deploys all if not specified)")
+    .action((libName) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!configExists) {
+        warnOfMissingConfig();
+        return;
+    }
+    if (!currentConfig.lib_directory || !currentConfig.libs) {
+        console.log(chalk.red("Error: Library configuration not found in config file."));
+        console.log(chalk.yellow("Please run 'mfer init' to configure library settings."));
+        return;
+    }
+    const libsToDeploy = libName
+        ? [libName].filter(lib => currentConfig.libs.includes(lib))
+        : currentConfig.libs;
+    if (libName && !currentConfig.libs.includes(libName)) {
+        console.log(chalk.red(`Error: Library '${libName}' not found in configuration.`));
+        console.log(chalk.yellow(`Available libraries: ${currentConfig.libs.join(", ")}`));
+        return;
+    }
+    if (libsToDeploy.length === 0) {
+        console.log(chalk.yellow("No libraries to deploy."));
+        return;
+    }
+    console.log(chalk.blue(`Deploying ${libsToDeploy.length} librar${libsToDeploy.length === 1 ? 'y' : 'ies'}...`));
+    const mfeDirectories = currentConfig.groups.all.map(mfe => path.join(currentConfig.mfe_directory, mfe));
+    for (const lib of libsToDeploy) {
+        const libDistPath = path.join(currentConfig.lib_directory, lib, "dist");
+        if (!fs.existsSync(libDistPath)) {
+            console.log(chalk.red(`Error: Build directory not found for ${lib}: ${libDistPath}`));
+            console.log(chalk.yellow(`Please run 'mfer lib build ${lib}' first.`));
+            continue;
+        }
+        console.log(chalk.blue(`\nDeploying ${chalk.bold(lib)}...`));
+        let deployedCount = 0;
+        for (const mfeDir of mfeDirectories) {
+            if (!fs.existsSync(mfeDir)) {
+                console.log(chalk.yellow(`Warning: MFE directory not found: ${mfeDir}`));
+                continue;
+            }
+            const targetPath = path.join(mfeDir, "node_modules", lib);
+            if (fs.existsSync(targetPath)) {
+                try {
+                    yield copyLibraryToMfe(libDistPath, targetPath, lib);
+                    console.log(chalk.green(`  ✓ Deployed to ${path.basename(mfeDir)}`));
+                    deployedCount++;
+                }
+                catch (error) {
+                    console.log(chalk.red(`  ✗ Failed to deploy to ${path.basename(mfeDir)}: ${error}`));
+                }
+            }
+            else {
+                console.log(chalk.gray(`  - Skipped ${path.basename(mfeDir)} (not installed)`));
+            }
+        }
+        if (deployedCount > 0) {
+            console.log(chalk.green(`✓ ${lib} deployed to ${deployedCount} MFE${deployedCount === 1 ? '' : 's'}`));
+        }
+        else {
+            console.log(chalk.yellow(`⚠ ${lib} not deployed (not found in any MFE's node_modules)`));
+        }
+    }
+    console.log(chalk.green("\nDeploy process completed!"));
+}));
+function copyLibraryToMfe(sourcePath, targetPath, libName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            if (fs.existsSync(targetPath)) {
+                fs.rmSync(targetPath, { recursive: true, force: true });
+            }
+            fs.mkdirSync(targetPath, { recursive: true });
+            copyDirectoryRecursive(sourcePath, targetPath);
+            resolve();
+        });
+    });
+}
+function copyDirectoryRecursive(source, target) {
+    if (!fs.existsSync(target)) {
+        fs.mkdirSync(target, { recursive: true });
+    }
+    const items = fs.readdirSync(source);
+    for (const item of items) {
+        const sourcePath = path.join(source, item);
+        const targetPath = path.join(target, item);
+        const stat = fs.statSync(sourcePath);
+        if (stat.isDirectory()) {
+            copyDirectoryRecursive(sourcePath, targetPath);
+        }
+        else {
+            fs.copyFileSync(sourcePath, targetPath);
+        }
+    }
+}
+export default deployCommand;

package/dist/commands/lib/index.js

@@ -0,0 +1,12 @@
+import { Command } from "commander";
+import buildCommand from "./build.js";
+import deployCommand from "./deploy.js";
+import publishCommand from "./publish.js";
+import listCommand from "./list.js";
+const libCommand = new Command("lib")
+    .description("Manage internal npm packages and their distribution to micro frontends")
+    .addCommand(buildCommand)
+    .addCommand(deployCommand)
+    .addCommand(publishCommand)
+    .addCommand(listCommand);
+export default libCommand;

package/dist/commands/lib/list.js

@@ -0,0 +1,57 @@
+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 chalk from "chalk";
+import * as fs from "fs";
+import * as path from "path";
+import { currentConfig, configExists, warnOfMissingConfig, } from "../../utils/config-utils.js";
+const listCommand = new Command("list")
+    .description("List configured libraries and their status")
+    .action(() => __awaiter(void 0, void 0, void 0, function* () {
+    if (!configExists) {
+        warnOfMissingConfig();
+        return;
+    }
+    if (!currentConfig.lib_directory || !currentConfig.libs) {
+        console.log(chalk.red("Error: Library configuration not found in config file."));
+        console.log(chalk.yellow("Please run 'mfer init' to configure library settings."));
+        return;
+    }
+    console.log(chalk.blue("Configured Libraries:"));
+    console.log(chalk.gray("─".repeat(50)));
+    if (currentConfig.libs.length === 0) {
+        console.log(chalk.yellow("No libraries configured."));
+        return;
+    }
+    for (const lib of currentConfig.libs) {
+        const libPath = path.join(currentConfig.lib_directory, lib);
+        const distPath = path.join(libPath, "dist");
+        const libExists = fs.existsSync(libPath);
+        const distExists = fs.existsSync(distPath);
+        let status = "";
+        if (!libExists) {
+            status = chalk.red("✗ Directory not found");
+        }
+        else if (!distExists) {
+            status = chalk.yellow("⚠ Not built");
+        }
+        else {
+            status = chalk.green("✓ Built");
+        }
+        console.log(`${chalk.bold(lib)}`);
+        console.log(`  Path: ${libPath}`);
+        console.log(`  Status: ${status}`);
+        console.log("");
+    }
+    console.log(chalk.gray("─".repeat(50)));
+    console.log(chalk.blue(`Library Directory: ${currentConfig.lib_directory}`));
+    console.log(chalk.blue(`Total Libraries: ${currentConfig.libs.length}`));
+}));
+export default listCommand;

package/dist/commands/lib/publish.js

@@ -0,0 +1,142 @@
+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 chalk from "chalk";
+import { spawn } from "child_process";
+import * as fs from "fs";
+import * as path from "path";
+import { currentConfig, configExists, warnOfMissingConfig, } from "../../utils/config-utils.js";
+const publishCommand = new Command("publish")
+    .description("Build and deploy libraries to micro frontends")
+    .argument("[lib-name]", "Name of the library to publish (publishes all if not specified)")
+    .action((libName) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!configExists) {
+        warnOfMissingConfig();
+        return;
+    }
+    if (!currentConfig.lib_directory || !currentConfig.libs) {
+        console.log(chalk.red("Error: Library configuration not found in config file."));
+        console.log(chalk.yellow("Please run 'mfer init' to configure library settings."));
+        return;
+    }
+    const libsToPublish = libName
+        ? [libName].filter(lib => currentConfig.libs.includes(lib))
+        : currentConfig.libs;
+    if (libName && !currentConfig.libs.includes(libName)) {
+        console.log(chalk.red(`Error: Library '${libName}' not found in configuration.`));
+        console.log(chalk.yellow(`Available libraries: ${currentConfig.libs.join(", ")}`));
+        return;
+    }
+    if (libsToPublish.length === 0) {
+        console.log(chalk.yellow("No libraries to publish."));
+        return;
+    }
+    console.log(chalk.blue(`Publishing ${libsToPublish.length} librar${libsToPublish.length === 1 ? 'y' : 'ies'}...`));
+    const mfeDirectories = currentConfig.groups.all.map(mfe => path.join(currentConfig.mfe_directory, mfe));
+    for (const lib of libsToPublish) {
+        const libPath = path.join(currentConfig.lib_directory, lib);
+        if (!fs.existsSync(libPath)) {
+            console.log(chalk.red(`Error: Library directory not found: ${libPath}`));
+            continue;
+        }
+        console.log(chalk.blue(`\nPublishing ${chalk.bold(lib)}...`));
+        console.log(chalk.blue(`  Building ${lib}...`));
+        try {
+            yield buildLibrary(libPath, lib);
+            console.log(chalk.green(`  ✓ ${lib} built successfully`));
+        }
+        catch (error) {
+            console.log(chalk.red(`  ✗ Failed to build ${lib}: ${error}`));
+            continue;
+        }
+        console.log(chalk.blue(`  Deploying ${lib}...`));
+        const libDistPath = path.join(libPath, "dist");
+        let deployedCount = 0;
+        for (const mfeDir of mfeDirectories) {
+            if (!fs.existsSync(mfeDir)) {
+                console.log(chalk.yellow(`    Warning: MFE directory not found: ${mfeDir}`));
+                continue;
+            }
+            const targetPath = path.join(mfeDir, "node_modules", lib);
+            if (fs.existsSync(targetPath)) {
+                try {
+                    yield copyLibraryToMfe(libDistPath, targetPath, lib);
+                    console.log(chalk.green(`    ✓ Deployed to ${path.basename(mfeDir)}`));
+                    deployedCount++;
+                }
+                catch (error) {
+                    console.log(chalk.red(`    ✗ Failed to deploy to ${path.basename(mfeDir)}: ${error}`));
+                }
+            }
+            else {
+                console.log(chalk.gray(`    - Skipped ${path.basename(mfeDir)} (not installed)`));
+            }
+        }
+        if (deployedCount > 0) {
+            console.log(chalk.green(`  ✓ ${lib} published to ${deployedCount} MFE${deployedCount === 1 ? '' : 's'}`));
+        }
+        else {
+            console.log(chalk.yellow(`  ⚠ ${lib} not deployed (not found in any MFE's node_modules)`));
+        }
+    }
+    console.log(chalk.green("\nPublish process completed!"));
+}));
+function buildLibrary(libPath, libName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            const buildProcess = spawn("npm", ["run", "build"], {
+                stdio: "inherit",
+                cwd: libPath,
+                shell: true,
+            });
+            buildProcess.on("close", (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`Build process exited with code ${code}`));
+                }
+            });
+            buildProcess.on("error", (error) => {
+                reject(error);
+            });
+        });
+    });
+}
+function copyLibraryToMfe(sourcePath, targetPath, libName) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve, reject) => {
+            if (fs.existsSync(targetPath)) {
+                fs.rmSync(targetPath, { recursive: true, force: true });
+            }
+            fs.mkdirSync(targetPath, { recursive: true });
+            copyDirectoryRecursive(sourcePath, targetPath);
+            resolve();
+        });
+    });
+}
+function copyDirectoryRecursive(source, target) {
+    if (!fs.existsSync(target)) {
+        fs.mkdirSync(target, { recursive: true });
+    }
+    const items = fs.readdirSync(source);
+    for (const item of items) {
+        const sourcePath = path.join(source, item);
+        const targetPath = path.join(target, item);
+        const stat = fs.statSync(sourcePath);
+        if (stat.isDirectory()) {
+            copyDirectoryRecursive(sourcePath, targetPath);
+        }
+        else {
+            fs.copyFileSync(sourcePath, targetPath);
+        }
+    }
+}
+export default publishCommand;

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

@@ -6,11 +6,12 @@ import runCommand from "./commands/run.js";
 import installCommand from "./commands/install.js";
 import cloneCommand from "./commands/clone.js";
 import pullCommand from "./commands/pull.js";
+import libCommand from "./commands/lib/index.js";
 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("2.0.0", "-v, --version", "mfer CLI version")
     .hook("preAction", () => {
     console.log();
 })
@@ -23,5 +24,6 @@ program.addCommand(runCommand);
 program.addCommand(installCommand);
 program.addCommand(cloneCommand);
 program.addCommand(pullCommand);
+program.addCommand(libCommand);
 loadConfig();
 program.parse();

package/dist/utils/config-utils.js

@@ -27,7 +27,7 @@ export const isConfigValid = () => {
     try {
         const configFile = fs.readFileSync(configPath, "utf8");
         const config = YAML.parse(configFile);
-        return (config &&
+        const hasRequiredFields = config &&
             typeof config === "object" &&
             config.base_github_url &&
             config.mfe_directory &&
@@ -35,7 +35,11 @@ export const isConfigValid = () => {
             typeof config.groups === "object" &&
             config.groups.all &&
             Array.isArray(config.groups.all) &&
-            config.groups.all.length > 0);
+            config.groups.all.length > 0;
+        if (config.lib_directory && (!config.libs || !Array.isArray(config.libs))) {
+            return false;
+        }
+        return hasRequiredFields;
     }
     catch (_a) {
         return false;

package/package.json

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