mfer 3.0.1 → 3.2.4

package/README.md

@@ -151,11 +151,17 @@ Pull latest changes from git repositories.
 
 - `group_name`: Name of the group to pull from (defaults to "all")
 
-**Example:**
+**Options:**
+
+- `-s, --select`: Prompt to select which repositories to pull
+
+**Examples:**
 
 ```bash
 mfer pull         # Pull from all repositories
 mfer pull shared  # Pull from shared components group only
+mfer pull --select # Select repositories to pull interactively
+mfer pull frontend --select # Select repositories from frontend group
 ```
 
 ### `mfer install [group_name]`
@@ -166,11 +172,17 @@ Install dependencies for all micro frontends in a group.
 
 - `group_name`: Name of the group to install dependencies for (defaults to "all")
 
-**Example:**
+**Options:**
+
+- `-s, --select`: Prompt to select which micro frontends to install
+
+**Examples:**
 
 ```bash
 mfer install          # Install dependencies for all micro frontends
 mfer install frontend # Install dependencies for frontend group only
+mfer install --select # Select micro frontends to install interactively
+mfer install shared --select # Select micro frontends from shared group
 ```
 
 ### `mfer clone [group_name]`
@@ -226,6 +238,8 @@ Manage internal npm packages and their distribution to micro frontends.
 - [`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 pull`](#mfer-lib-pull-lib-name) - Pull latest changes from library git repositories
+- [`mfer lib install`](#mfer-lib-install-lib-name) - Install dependencies for libraries
 
 ### `mfer lib build [lib-name]`
 
@@ -297,6 +311,48 @@ List configured libraries and their status.
 mfer lib list    # Show all configured libraries and their build status
 ```
 
+### `mfer lib pull [lib-name]`
+
+Pull latest changes from library git repositories.
+
+**Arguments:**
+
+- `lib-name`: Name of the library to pull from (pulls all if not specified)
+
+**Options:**
+
+- `-s, --select`: Prompt to select which libraries to pull
+
+**Examples:**
+
+```bash
+mfer lib pull                    # Pull from all libraries
+mfer lib pull my-shared-utils    # Pull from specific library only
+mfer lib pull --select           # Select libraries to pull interactively
+mfer lib pull my-design-system --select # Select libraries from specific library
+```
+
+### `mfer lib install [lib-name]`
+
+Install dependencies for libraries.
+
+**Arguments:**
+
+- `lib-name`: Name of the library to install dependencies for (installs all if not specified)
+
+**Options:**
+
+- `-s, --select`: Prompt to select which libraries to install
+
+**Examples:**
+
+```bash
+mfer lib install                    # Install dependencies for all libraries
+mfer lib install my-shared-utils    # Install dependencies for specific library only
+mfer lib install --select           # Select libraries to install interactively
+mfer lib install my-design-system --select # Select libraries from specific library
+```
+
 ## ⚙️ Configuration
 
 mfer uses a YAML configuration file located at `~/.mfer/config.yaml`. Here's an example structure:

package/dist/commands/install.js

@@ -10,12 +10,12 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { Command } from "commander";
 import { configExists, currentConfig, warnOfMissingConfig, } from "../utils/config-utils.js";
 import chalk from "chalk";
-import path from "path";
-import { spawnSync } from "child_process";
+import { runNpmInstallSequentially, promptForMFESelection, } from "../utils/command-utils.js";
 const installCommand = new Command("install")
     .description("run 'npm install' in micro-frontend applications synchronously")
     .argument("[group_name]", "name of the group as specified in the configuration", "all")
-    .action((groupName) => __awaiter(void 0, void 0, void 0, function* () {
+    .option("-s, --select", "prompt to select which micro frontends to install")
+    .action((groupName, options) => __awaiter(void 0, void 0, void 0, function* () {
     if (!configExists) {
         warnOfMissingConfig();
         return;
@@ -32,42 +32,12 @@ const installCommand = new Command("install")
         console.log(`${messagePrefix}: group '${groupName}' has no micro frontends defined.`);
         return;
     }
-    const mfeDir = currentConfig.mfe_directory;
-    let hadError = false;
-    console.log(chalk.green(`Running 'npm install' in group: ${groupName}`));
-    let interrupted = false;
-    const handleSigint = () => {
-        interrupted = true;
-        console.log(chalk.yellow("\nReceived SIGINT. Stopping installs..."));
-    };
-    process.once("SIGINT", handleSigint);
-    for (const mfe of group) {
-        if (interrupted)
-            break;
-        const cwd = path.join(mfeDir, mfe);
-        console.log(chalk.blue(`[${mfe}] Running 'npm install' in ${cwd}`));
-        const result = spawnSync("npm", ["install"], {
-            cwd,
-            stdio: "inherit",
-            shell: true,
-        });
-        if (result.status !== 0) {
-            hadError = true;
-            console.error(chalk.red(`  MFE ${mfe} failed to install (cwd: ${cwd}) with exit code ${result.status}`));
-        }
-        else {
-            console.log(chalk.green(`  MFE ${mfe} installed successfully (cwd: ${cwd})`));
-        }
-    }
-    if (hadError) {
-        console.error(chalk.red("One or more installs failed."));
-        process.exitCode = 1;
-    }
-    else if (interrupted) {
-        process.exitCode = 130;
-    }
-    else {
-        console.log(chalk.green("All installs completed successfully."));
+    let selectedMFEs = group;
+    if (options.select) {
+        selectedMFEs = yield promptForMFESelection(groupName, group);
     }
+    const mfeDir = currentConfig.mfe_directory;
+    const contextName = `group: ${groupName}`;
+    yield runNpmInstallSequentially(selectedMFEs, mfeDir, contextName, options);
 }));
 export default installCommand;

package/dist/commands/lib/index.js

@@ -3,10 +3,14 @@ import buildCommand from "./build.js";
 import deployCommand from "./deploy.js";
 import publishCommand from "./publish.js";
 import listCommand from "./list.js";
+import pullCommand from "./pull.js";
+import installCommand from "./install.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);
+    .addCommand(listCommand)
+    .addCommand(pullCommand)
+    .addCommand(installCommand);
 export default libCommand;

package/dist/commands/lib/install.js

@@ -0,0 +1,52 @@
+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 { configExists, currentConfig, warnOfMissingConfig, } from "../../utils/config-utils.js";
+import chalk from "chalk";
+import { runNpmInstallSequentially, promptForLibrarySelection, } from "../../utils/command-utils.js";
+const installCommand = new Command("install")
+    .description("run 'npm install' in library directories")
+    .argument("[lib-name]", "name of the library to install dependencies for (installs all if not specified)")
+    .option("-s, --select", "prompt to select which libraries to install")
+    .action((libName, options) => __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;
+    }
+    if (!Array.isArray(currentConfig.libs) || currentConfig.libs.length === 0) {
+        console.log(chalk.red("Error: No libraries configured in config file."));
+        return;
+    }
+    let targetLibs;
+    if (libName) {
+        if (!currentConfig.libs.includes(libName)) {
+            console.log(chalk.red(`Error: Library '${libName}' not found in configuration.`));
+            console.log(`Available libraries: ${chalk.green(currentConfig.libs.join(" "))}`);
+            return;
+        }
+        targetLibs = [libName];
+    }
+    else {
+        targetLibs = currentConfig.libs;
+    }
+    let selectedLibs = targetLibs;
+    if (options.select) {
+        selectedLibs = yield promptForLibrarySelection(targetLibs);
+    }
+    const libDir = currentConfig.lib_directory;
+    const contextName = libName ? `library '${libName}'` : "all libraries";
+    yield runNpmInstallSequentially(selectedLibs, libDir, contextName, options);
+}));
+export default installCommand;

package/dist/commands/lib/pull.js

@@ -0,0 +1,68 @@
+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 { configExists, currentConfig, warnOfMissingConfig, } from "../../utils/config-utils.js";
+import chalk from "chalk";
+import { validateGitRepositories, runGitPullConcurrently, promptForLibrarySelection, } from "../../utils/command-utils.js";
+const pullCommand = new Command("pull")
+    .description("pull latest changes from library git repositories")
+    .argument("[lib-name]", "name of the library to pull from (pulls all if not specified)")
+    .option("-s, --select", "prompt to select which libraries to pull")
+    .action((libName, options) => __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;
+    }
+    if (!Array.isArray(currentConfig.libs) || currentConfig.libs.length === 0) {
+        console.log(chalk.red("Error: No libraries configured in config file."));
+        return;
+    }
+    let targetLibs;
+    if (libName) {
+        if (!currentConfig.libs.includes(libName)) {
+            console.log(chalk.red(`Error: Library '${libName}' not found in configuration.`));
+            console.log(`Available libraries: ${chalk.green(currentConfig.libs.join(" "))}`);
+            return;
+        }
+        targetLibs = [libName];
+    }
+    else {
+        targetLibs = currentConfig.libs;
+    }
+    const libDir = currentConfig.lib_directory;
+    console.log(chalk.blue(`Validating library repositories...`));
+    const { validRepos, invalidRepos } = validateGitRepositories(targetLibs, libDir);
+    if (invalidRepos.length > 0) {
+        console.log(chalk.yellow("\nSkipping invalid repositories:"));
+        invalidRepos.forEach(({ name, reason }) => {
+            console.log(chalk.yellow(`  ${name}: ${reason}`));
+        });
+        console.log();
+    }
+    if (validRepos.length === 0) {
+        console.log(chalk.red("No valid git repositories found to pull from."));
+        if (invalidRepos.some((repo) => repo.reason.includes("Directory does not exist"))) {
+            console.log(chalk.blue("\nTip: Make sure your libraries are cloned to the configured directory."));
+        }
+        return;
+    }
+    let selectedLibs = validRepos;
+    if (options.select) {
+        selectedLibs = yield promptForLibrarySelection(validRepos);
+    }
+    const contextName = libName ? `library '${libName}'` : "all libraries";
+    yield runGitPullConcurrently(selectedLibs, libDir, contextName, options);
+}));
+export default pullCommand;

package/dist/commands/pull.js

@@ -1,14 +1,21 @@
+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 { configExists, currentConfig, warnOfMissingConfig, } from "../utils/config-utils.js";
-import concurrently from "concurrently";
 import chalk from "chalk";
-import path from "path";
-import fs from "fs";
-import { spawnSync } from "child_process";
+import { validateGitRepositories, runGitPullConcurrently, promptForMFESelection, } from "../utils/command-utils.js";
 const pullCommand = new Command("pull")
     .description("pull latest changes from git repositories")
     .argument("[group_name]", "name of the group as specified in the configuration", "all")
-    .action((groupName) => {
+    .option("-s, --select", "prompt to select which repositories to pull")
+    .action((groupName, options) => __awaiter(void 0, void 0, void 0, function* () {
     if (!configExists) {
         warnOfMissingConfig();
         return;
@@ -26,32 +33,8 @@ const pullCommand = new Command("pull")
         return;
     }
     const mfeDir = currentConfig.mfe_directory;
-    const validRepos = [];
-    const invalidRepos = [];
     console.log(chalk.blue(`Validating repositories in group: ${groupName}...`));
-    for (const repo of group) {
-        const repoPath = path.join(mfeDir, repo);
-        if (!fs.existsSync(repoPath)) {
-            invalidRepos.push({
-                name: repo,
-                reason: `Directory does not exist: ${repoPath}`,
-            });
-            continue;
-        }
-        const gitResult = spawnSync("git", ["rev-parse", "--git-dir"], {
-            cwd: repoPath,
-            stdio: "pipe",
-            shell: true,
-        });
-        if (gitResult.status !== 0) {
-            invalidRepos.push({
-                name: repo,
-                reason: `Not a git repository: ${repoPath}`,
-            });
-            continue;
-        }
-        validRepos.push(repo);
-    }
+    const { validRepos, invalidRepos } = validateGitRepositories(group, mfeDir);
     if (invalidRepos.length > 0) {
         console.log(chalk.yellow("\nSkipping invalid repositories:"));
         invalidRepos.forEach(({ name, reason }) => {
@@ -66,44 +49,11 @@ const pullCommand = new Command("pull")
         }
         return;
     }
-    const commands = validRepos.map((repo) => ({
-        command: "git pull",
-        name: repo,
-        cwd: path.join(mfeDir, repo),
-        prefixColor: "green",
-    }));
-    console.log(chalk.green(`Pulling latest changes for ${validRepos.length} repositories in group: ${groupName}...`));
-    const concurrentlyResult = concurrently(commands, {
-        prefix: "{name} |",
-        killOthersOn: ["failure"],
-        restartTries: 0,
-    });
-    const handleSigint = () => {
-        console.log(chalk.yellow("\nReceived SIGINT. Stopping all git pull operations..."));
-        concurrentlyResult.commands.forEach((cmd) => {
-            if (cmd && typeof cmd.kill === "function") {
-                cmd.kill();
-            }
-        });
-        process.exit(0);
-    };
-    process.once("SIGINT", handleSigint);
-    concurrentlyResult.result.then(() => {
-        console.log(chalk.green(`\nSuccessfully pulled latest changes for all repositories in group: ${groupName}`));
-    }, (err) => {
-        console.error(chalk.red("One or more repositories failed to pull."));
-        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(`  Repository ${name} failed to pull (cwd: ${cwd}) with exit code ${exitCode}`));
-            });
-        }
-        else if (err && typeof err === "object" && "message" in err) {
-            console.error(err.message);
-        }
-    });
-});
+    let selectedRepos = validRepos;
+    if (options.select) {
+        selectedRepos = yield promptForMFESelection(groupName, validRepos);
+    }
+    const contextName = `group: ${groupName}`;
+    yield runGitPullConcurrently(selectedRepos, mfeDir, contextName, options);
+}));
 export default pullCommand;

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 { checkbox } from "@inquirer/prompts";
+import { promptForMFESelection } from "../utils/command-utils.js";
 import { spawn } from "child_process";
 const DEFAULT_RUN_COMMAND = "npm start";
 const runCommand = new Command("run")
@@ -20,9 +20,8 @@ const runCommand = new Command("run")
     .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")
+    .option("-a, --async", "run custom command concurrently instead of sequentially (only works with --command option)")
     .action((groupName, options) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a, _b;
     if (!configExists) {
         warnOfMissingConfig();
         return;
@@ -53,23 +52,7 @@ const runCommand = new Command("run")
     }
     let selectedMFEs = group;
     if (options.select) {
-        try {
-            console.log(chalk.blue(`Select micro frontends to run from group '${groupName}':`));
-            selectedMFEs = yield checkbox({
-                message: "Choose which micro frontends to run:",
-                choices: group.map((mfe) => ({ name: mfe, value: mfe })),
-                validate: (arr) => arr.length > 0 ? true : "Select at least one micro frontend",
-            });
-        }
-        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;
-        }
+        selectedMFEs = yield promptForMFESelection(groupName, group);
     }
     const mfeDir = currentConfig.mfe_directory;
     const commandToRun = options.command || DEFAULT_RUN_COMMAND;
@@ -80,8 +63,7 @@ const runCommand = new Command("run")
     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}...`));
+    console.log(chalk.green(`Running ${commandText} on micro frontends in ${groupText}...`));
     if (isAsync || !options.command) {
         yield runConcurrently(selectedMFEs, commandToRun, mfeDir);
     }

package/dist/commands/update.js

@@ -0,0 +1,41 @@
+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 { spawnSync } from "child_process";
+import { getInstalledVersion, getLatestVersion, } from "../utils/version-utils.js";
+const updateCommand = new Command("update")
+    .description("update mfer to the latest version")
+    .action(() => __awaiter(void 0, void 0, void 0, function* () {
+    const installedVersion = getInstalledVersion();
+    console.log(chalk.blue(`Current version: ${installedVersion}`));
+    console.log(chalk.blue("Checking for updates..."));
+    const latestVersion = yield getLatestVersion();
+    if (!latestVersion) {
+        console.log(chalk.red("Error: Could not fetch the latest version from npm."));
+        return;
+    }
+    if (latestVersion === installedVersion) {
+        console.log(chalk.green("You are already on the latest version."));
+        return;
+    }
+    console.log(chalk.yellow(`New version available: ${latestVersion}`));
+    console.log(chalk.blue("Updating mfer..."));
+    const result = spawnSync("npm", ["install", "-g", "mfer@latest"], {
+        stdio: "inherit",
+        shell: true,
+    });
+    if (result.status !== 0) {
+        console.log(chalk.red(`Error: Update failed with exit code ${result.status}. Try running: npm install -g mfer@latest`));
+        return;
+    }
+    console.log(chalk.green(`Successfully updated mfer to ${latestVersion}.`));
+}));
+export default updateCommand;

package/dist/index.js

@@ -7,11 +7,13 @@ 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 updateCommand from "./commands/update.js";
 import { loadConfig } from "./utils/config-utils.js";
+import { checkForUpdateNotification } from "./utils/version-utils.js";
 program
     .name("mfer")
     .description("Micro Frontend Runner (mfer) - A CLI for running your project's micro frontends.")
-    .version("3.0.1", "-v, --version", "mfer CLI version")
+    .version("3.2.4", "-v, --version", "mfer CLI version")
     .hook("preAction", () => {
     console.log();
 })
@@ -25,5 +27,7 @@ program.addCommand(installCommand);
 program.addCommand(cloneCommand);
 program.addCommand(pullCommand);
 program.addCommand(libCommand);
+program.addCommand(updateCommand);
 loadConfig();
 program.parse();
+checkForUpdateNotification().catch(() => { });

package/dist/utils/command-utils.js

@@ -0,0 +1,181 @@
+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 chalk from "chalk";
+import { checkbox } from "@inquirer/prompts";
+import { spawnSync } from "child_process";
+import concurrently from "concurrently";
+import path from "path";
+import fs from "fs";
+export function promptForMFESelection(groupName, mfes) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        try {
+            console.log(chalk.blue(`Select micro frontends to operate on from group '${groupName}':`));
+            const selectedMFEs = yield checkbox({
+                message: "Choose which micro frontends to operate on:",
+                choices: mfes.map((mfe) => ({ name: mfe, value: mfe })),
+                validate: (arr) => arr.length > 0 ? true : "Select at least one micro frontend",
+            });
+            return selectedMFEs;
+        }
+        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;
+        }
+    });
+}
+export function promptForLibrarySelection(libs) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        try {
+            console.log(chalk.blue("Select libraries to operate on:"));
+            const selectedLibs = yield checkbox({
+                message: "Choose which libraries to operate on:",
+                choices: libs.map((lib) => ({ name: lib, value: lib })),
+                validate: (arr) => arr.length > 0 ? true : "Select at least one library",
+            });
+            return 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;
+        }
+    });
+}
+export function validateGitRepositories(repos, baseDir) {
+    const validRepos = [];
+    const invalidRepos = [];
+    for (const repo of repos) {
+        const repoPath = path.join(baseDir, repo);
+        if (!fs.existsSync(repoPath)) {
+            invalidRepos.push({
+                name: repo,
+                reason: `Directory does not exist: ${repoPath}`,
+            });
+            continue;
+        }
+        const gitResult = spawnSync("git", ["rev-parse", "--git-dir"], {
+            cwd: repoPath,
+            stdio: "pipe",
+            shell: true,
+        });
+        if (gitResult.status !== 0) {
+            invalidRepos.push({
+                name: repo,
+                reason: `Not a git repository: ${repoPath}`,
+            });
+            continue;
+        }
+        validRepos.push(repo);
+    }
+    return { validRepos, invalidRepos };
+}
+export function runGitPullConcurrently(repos, baseDir, contextName, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const commands = repos.map((repo) => ({
+            command: "git pull",
+            name: repo,
+            cwd: path.join(baseDir, repo),
+            prefixColor: "green",
+        }));
+        const repoText = options.select
+            ? `selected repositories from ${contextName}`
+            : `${repos.length} repositories in ${contextName}`;
+        console.log(chalk.green(`Pulling latest changes for ${repoText}...`));
+        const concurrentlyResult = concurrently(commands, {
+            prefix: "{name} |",
+            killOthersOn: ["failure"],
+            restartTries: 0,
+        });
+        const handleSigint = () => {
+            console.log(chalk.yellow("\nReceived SIGINT. Stopping all git pull operations..."));
+            concurrentlyResult.commands.forEach((cmd) => {
+                if (cmd && typeof cmd.kill === "function") {
+                    cmd.kill();
+                }
+            });
+            process.exit(0);
+        };
+        process.once("SIGINT", handleSigint);
+        return concurrentlyResult.result.then(() => {
+            const successText = options.select
+                ? `selected repositories from ${contextName}`
+                : `all repositories in ${contextName}`;
+            console.log(chalk.green(`\nSuccessfully pulled latest changes for ${successText}`));
+        }, (err) => {
+            console.error(chalk.red("One or more repositories failed to pull."));
+            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(`  Repository ${name} failed to pull (cwd: ${cwd}) with exit code ${exitCode}`));
+                });
+            }
+            else if (err && typeof err === "object" && "message" in err) {
+                console.error(err.message);
+            }
+        });
+    });
+}
+export function runNpmInstallSequentially(items, baseDir, contextName, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let hadError = false;
+        const groupText = options.select
+            ? `selected items from ${contextName}`
+            : `${contextName}`;
+        console.log(chalk.green(`Running 'npm install' in ${groupText}`));
+        let interrupted = false;
+        const handleSigint = () => {
+            interrupted = true;
+            console.log(chalk.yellow("\nReceived SIGINT. Stopping installs..."));
+        };
+        process.once("SIGINT", handleSigint);
+        for (const item of items) {
+            if (interrupted)
+                break;
+            const cwd = path.join(baseDir, item);
+            console.log(chalk.blue(`[${item}] Running 'npm install' in ${cwd}`));
+            const result = spawnSync("npm", ["install", "--no-fund"], {
+                cwd,
+                stdio: "inherit",
+                shell: true,
+            });
+            if (result.status !== 0) {
+                hadError = true;
+                console.error(chalk.red(`  ${item} failed to install (cwd: ${cwd}) with exit code ${result.status}`));
+            }
+            else {
+                console.log(chalk.green(`  ${item} installed successfully (cwd: ${cwd})\n`));
+            }
+        }
+        if (hadError) {
+            console.error(chalk.red("One or more installs failed."));
+            process.exitCode = 1;
+        }
+        else if (interrupted) {
+            process.exitCode = 130;
+        }
+        else {
+            console.log(chalk.green("All installs completed successfully."));
+        }
+    });
+}

package/dist/utils/version-utils.js

@@ -0,0 +1,84 @@
+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 * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+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");
+    try {
+        const raw = fs.readFileSync(packageJsonPath, "utf8");
+        return JSON.parse(raw).version;
+    }
+    catch (_a) {
+        return "unknown";
+    }
+}
+export function getLatestVersion() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const result = spawnSync("npm", ["view", "mfer", "version"], {
+                stdio: "pipe",
+                shell: true,
+                timeout: 10000,
+            });
+            if (result.status !== 0 || !result.stdout) {
+                return null;
+            }
+            return result.stdout.toString().trim();
+        }
+        catch (_a) {
+            return null;
+        }
+    });
+}
+function getLastNotifiedVersion() {
+    try {
+        return fs.readFileSync(NOTIFIED_VERSION_FILE, "utf8").trim();
+    }
+    catch (_a) {
+        return null;
+    }
+}
+function setLastNotifiedVersion(version) {
+    try {
+        const dir = path.dirname(NOTIFIED_VERSION_FILE);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(NOTIFIED_VERSION_FILE, version);
+    }
+    catch (_a) {
+    }
+}
+export function checkForUpdateNotification() {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const installedVersion = getInstalledVersion();
+            if (installedVersion === "unknown")
+                return;
+            const latestVersion = yield getLatestVersion();
+            if (!latestVersion)
+                return;
+            if (latestVersion === installedVersion)
+                return;
+            const lastNotified = getLastNotifiedVersion();
+            if (lastNotified === latestVersion)
+                return;
+            console.log(chalk.yellow(`\n  Update available: ${installedVersion} → ${latestVersion}`));
+            console.log(chalk.yellow(`  Run ${chalk.bold("mfer update")} to update.\n`));
+            setLastNotifiedVersion(latestVersion);
+        }
+        catch (_a) {
+        }
+    });
+}

package/package.json

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