mfer 1.5.0 → 2.1.0

package/README.md

@@ -1,6 +1,6 @@
 # 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.
 
@@ -98,6 +98,7 @@ mfer pull frontend
 - [`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
+- [`mfer lib`](#mfer-lib) - Manage internal npm packages
 - [`mfer config`](#mfer-config) - Manage configuration settings
 - [`mfer help`](#mfer-help) - Display help information
 
@@ -214,6 +215,87 @@ mfer help run       # Show help for run command
 mfer help config    # Show help for config command
 ```
 
+### `mfer lib`
+
+Manage internal npm packages and their distribution to micro frontends.
+
+**Subcommands:**
+
+- [`mfer lib build`](#mfer-lib-build-lib-name) - Build internal npm packages
+- [`mfer lib deploy`](#mfer-lib-deploy-lib-name) - Copy built libraries to micro frontends
+- [`mfer lib publish`](#mfer-lib-publish-lib-name) - Build and deploy libraries to micro frontends
+- [`mfer lib list`](#mfer-lib-list) - List configured libraries and their status
+
+### `mfer lib build [lib-name]`
+
+Build internal npm packages.
+
+**Arguments:**
+
+- `lib-name`: Name of the library to build (builds all if not specified)
+
+**Options:**
+
+- `-s, --select`: Prompt to select which libraries to build
+
+**Examples:**
+
+```bash
+mfer lib build                    # Build all libraries
+mfer lib build my-shared-utils    # Build specific library
+mfer lib build --select           # Select libraries to build interactively
+```
+
+### `mfer lib deploy [lib-name]`
+
+Copy built libraries to micro frontends.
+
+**Arguments:**
+
+- `lib-name`: Name of the library to deploy (deploys all if not specified)
+
+**Options:**
+
+- `-s, --select`: Prompt to select which libraries to deploy
+
+**Examples:**
+
+```bash
+mfer lib deploy                    # Deploy all libraries
+mfer lib deploy my-shared-utils    # Deploy specific library
+mfer lib deploy --select           # Select libraries to deploy interactively
+```
+
+### `mfer lib publish [lib-name]`
+
+Build and deploy libraries to micro frontends.
+
+**Arguments:**
+
+- `lib-name`: Name of the library to publish (publishes all if not specified)
+
+**Options:**
+
+- `-s, --select`: Prompt to select which libraries to publish
+
+**Examples:**
+
+```bash
+mfer lib publish                    # Publish all libraries
+mfer lib publish my-shared-utils    # Publish specific library
+mfer lib publish --select           # Select libraries to publish interactively
+```
+
+### `mfer lib list`
+
+List configured libraries and their status.
+
+**Example:**
+
+```bash
+mfer lib list    # Show all configured libraries and their build status
+```
+
 ## ⚙️ Configuration
 
 mfer uses a YAML configuration file located at `~/.mfer/config.yaml`. Here's an example structure:
@@ -221,6 +303,11 @@ mfer uses a YAML configuration file located at `~/.mfer/config.yaml`. Here's an
 ```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
@@ -238,6 +325,8 @@ groups:
 
 - **`base_github_url`**: Your GitHub base URL for repository operations
 - **`mfe_directory`**: Path to the directory containing all your micro frontend projects
+- **`lib_directory`**: Path to the directory containing your internal npm packages (optional)
+- **`libs`**: List of internal npm package names to manage (optional)
 - **`groups`**: Named collections of micro frontend projects
   - **`all`**: Default group containing all projects (required)
   - **Custom groups**: Any additional groups you want to create

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,112 @@
+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 { checkbox } from "@inquirer/prompts";
+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)")
+    .option("-s, --select", "prompt to select which libraries to build")
+    .action((libName, options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    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;
+    }
+    let libsToBuild;
+    if (options === null || options === void 0 ? void 0 : options.select) {
+        try {
+            console.log(chalk.blue(`Select libraries to build:`));
+            const selectedLibs = yield checkbox({
+                message: "Choose which libraries to build:",
+                choices: currentConfig.libs.map((lib) => ({ name: lib, value: lib })),
+                validate: (arr) => arr.length > 0 ? true : "Select at least one library",
+            });
+            libsToBuild = selectedLibs;
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                (((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes("SIGINT")) ||
+                    ((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes("User force closed")))) {
+                console.log(chalk.yellow("\nReceived SIGINT. Stopping..."));
+                process.exit(130);
+            }
+            throw error;
+        }
+    }
+    else {
+        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;
+    }
+    const libsText = (options === null || options === void 0 ? void 0 : options.select)
+        ? `selected libraries (${libsToBuild.length})`
+        : libName
+            ? `library '${libName}'`
+            : `all libraries (${libsToBuild.length})`;
+    console.log(chalk.blue(`Building ${libsText}...`));
+    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,140 @@
+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 { checkbox } from "@inquirer/prompts";
+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)")
+    .option("-s, --select", "prompt to select which libraries to deploy")
+    .action((libName, options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    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;
+    }
+    let libsToDeploy;
+    if (options === null || options === void 0 ? void 0 : options.select) {
+        try {
+            console.log(chalk.blue(`Select libraries to deploy:`));
+            const selectedLibs = yield checkbox({
+                message: "Choose which libraries to deploy:",
+                choices: currentConfig.libs.map((lib) => ({ name: lib, value: lib })),
+                validate: (arr) => arr.length > 0 ? true : "Select at least one library",
+            });
+            libsToDeploy = selectedLibs;
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                (((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes("SIGINT")) ||
+                    ((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes("User force closed")))) {
+                console.log(chalk.yellow("\nReceived SIGINT. Stopping..."));
+                process.exit(130);
+            }
+            throw error;
+        }
+    }
+    else {
+        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;
+    }
+    const libsText = (options === null || options === void 0 ? void 0 : options.select)
+        ? `selected libraries (${libsToDeploy.length})`
+        : libName
+            ? `library '${libName}'`
+            : `all libraries (${libsToDeploy.length})`;
+    console.log(chalk.blue(`Deploying ${libsText}...`));
+    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,173 @@
+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 { checkbox } from "@inquirer/prompts";
+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)")
+    .option("-s, --select", "prompt to select which libraries to publish")
+    .action((libName, options) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    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;
+    }
+    let libsToPublish;
+    if (options === null || options === void 0 ? void 0 : options.select) {
+        try {
+            console.log(chalk.blue(`Select libraries to publish:`));
+            const selectedLibs = yield checkbox({
+                message: "Choose which libraries to publish:",
+                choices: currentConfig.libs.map((lib) => ({ name: lib, value: lib })),
+                validate: (arr) => arr.length > 0 ? true : "Select at least one library",
+            });
+            libsToPublish = selectedLibs;
+        }
+        catch (error) {
+            if (error instanceof Error &&
+                (((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes("SIGINT")) ||
+                    ((_b = error.message) === null || _b === void 0 ? void 0 : _b.includes("User force closed")))) {
+                console.log(chalk.yellow("\nReceived SIGINT. Stopping..."));
+                process.exit(130);
+            }
+            throw error;
+        }
+    }
+    else {
+        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;
+    }
+    const libsText = (options === null || options === void 0 ? void 0 : options.select)
+        ? `selected libraries (${libsToPublish.length})`
+        : libName
+            ? `library '${libName}'`
+            : `all libraries (${libsToPublish.length})`;
+    console.log(chalk.blue(`Publishing ${libsText}...`));
+    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/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.5.0", "-v, --version", "mfer CLI version")
+    .version("2.1.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.5.0",
+  "version": "2.1.0",
   "description": "CLI tool designed to sensibly run micro-frontends from the terminal.",
   "bin": {
     "mfer": "dist/index.js"