mage-remote-run 0.26.1 → 0.28.0

package/bin/mage-remote-run.js

@@ -44,6 +44,9 @@ import {
 } from '../lib/command-registry.js';
 import { getActiveProfile } from '../lib/config.js';
 import { startMcpServer } from '../lib/mcp.js';
+import { PluginLoader } from '../lib/plugin-loader.js';
+import { eventBus, EVENTS } from '../lib/events.js';
+import { createClient } from '../lib/api/factory.js';
 
 // Connection commands are registered dynamically via registerCommands
 // But we need them registered early if we want them to show up in help even if config fails?
@@ -65,9 +68,31 @@ program.command('mcp [args...]')
   });
 
 const profile = await getActiveProfile();
+
+// Load Plugins
+// We construct an initial context.
+// Note: client is not available yet as it is created per command usually, 
+// but we can pass a way to get it or just pass null for now if not used at startup.
+// Also mcpServer is not running here unless mcp command is used.
+const appContext = {
+    program,
+    config: await loadConfig(), // Re-load or reuse config
+    profile,
+    eventBus,
+    EVENTS,
+    createClient
+};
+
+const pluginLoader = new PluginLoader(appContext);
+await pluginLoader.loadPlugins();
+
+eventBus.emit(EVENTS.INIT, appContext);
+
 registerCommands(program, profile);
 
 program.hook('preAction', async (thisCommand, actionCommand) => {
+  eventBus.emit(EVENTS.BEFORE_COMMAND, { thisCommand, actionCommand, profile });
+
   // Check if we have an active profile and if format is not json/xml
   // Note: 'options' are available on the command that has them defined.
   // actionCommand is the command actually being executed.
@@ -84,6 +109,10 @@ program.hook('preAction', async (thisCommand, actionCommand) => {
   }
 });
 
+program.hook('postAction', async (thisCommand, actionCommand) => {
+    eventBus.emit(EVENTS.AFTER_COMMAND, { thisCommand, actionCommand, profile });
+});
+
 import { expandCommandAbbreviations } from '../lib/command-helper.js';
 
 // Check for first run (no profiles configured and no arguments or just help)

package/lib/command-registry.js

@@ -17,8 +17,9 @@ import { registerModulesCommands } from './commands/modules.js';
 import { registerConsoleCommand } from './commands/console.js';
 import { registerShipmentCommands } from './commands/shipments.js';
 import { registerRestCommands } from './commands/rest.js';
+import { registerPluginsCommands } from './commands/plugins.js';
 
-export { registerConnectionCommands, registerConsoleCommand, registerShipmentCommands, registerRestCommands };
+export { registerConnectionCommands, registerConsoleCommand, registerShipmentCommands, registerRestCommands, registerPluginsCommands };
 
 const GROUPS = {
   CORE: [
@@ -33,7 +34,8 @@ const GROUPS = {
     registerInventoryCommands,
     registerShipmentCommands,
     registerConsoleCommand,
-    registerRestCommands
+    registerRestCommands,
+    registerPluginsCommands
   ],
   COMMERCE: [
     registerCompanyCommands,

package/lib/commands/plugins.js

@@ -0,0 +1,106 @@
+import chalk from 'chalk';
+import { loadConfig, saveConfig } from '../config.js';
+import path from 'node:path';
+import { realpath } from 'node:fs/promises';
+
+
+function isFilesystemPath(pluginRef) {
+    const isScopedPackageName = /^@[^/\\]+\/[^/\\]+$/.test(pluginRef);
+    const hasPathSeparator = pluginRef.includes('/') || pluginRef.includes('\\');
+
+    return (
+        path.isAbsolute(pluginRef)
+        || pluginRef.startsWith('./')
+        || pluginRef.startsWith('../')
+        || pluginRef.startsWith('.\\')
+        || pluginRef.startsWith('..\\')
+        || pluginRef.startsWith('~/')
+        || pluginRef.startsWith('~\\')
+        || pluginRef.startsWith('file:')
+        || (hasPathSeparator && !isScopedPackageName)
+    );
+}
+
+async function resolvePluginReference(pluginRef) {
+    if (!isFilesystemPath(pluginRef)) {
+        return pluginRef;
+    }
+
+    if (pluginRef.startsWith('~/') || pluginRef.startsWith('~\\')) {
+        return realpath(path.join(process.env.HOME || process.env.USERPROFILE || '', pluginRef.slice(2)));
+    }
+
+    if (pluginRef.startsWith('file:')) {
+        return realpath(new URL(pluginRef));
+    }
+
+    return realpath(pluginRef);
+}
+
+
+export function registerPluginsCommands(program) {
+    const pluginsCmd = program.command('plugin')
+        .description('Manage plugins');
+
+    pluginsCmd.command('register <package-name>')
+        .description('Register an installed plugin in the configuration')
+        .action(async (packageName) => {
+            try {
+                const pluginRef = await resolvePluginReference(packageName);
+                const config = await loadConfig();
+                if (!config.plugins) {
+                    config.plugins = [];
+                }
+
+                if (config.plugins.includes(pluginRef)) {
+                    console.log(chalk.yellow(`Plugin "${pluginRef}" is already registered.`));
+                    return;
+                }
+
+                config.plugins.push(pluginRef);
+                await saveConfig(config);
+                console.log(chalk.green(`Plugin "${pluginRef}" successfully registered.`));
+                console.log(chalk.gray(`Make sure the package is installed globally or in the local project.`));
+                
+            } catch (error) {
+                console.error(chalk.red(`Error registering plugin: ${error.message}`));
+            }
+        });
+
+    pluginsCmd.command('unregister <package-name>')
+        .description('Unregister a plugin from the configuration')
+        .action(async (packageName) => {
+             try {
+                const pluginRef = await resolvePluginReference(packageName);
+                const config = await loadConfig();
+                if (!config.plugins || !config.plugins.includes(pluginRef)) {
+                     console.log(chalk.yellow(`Plugin "${pluginRef}" is not registered.`));
+                     return;
+                }
+
+                config.plugins = config.plugins.filter(p => p !== pluginRef);
+                await saveConfig(config);
+                console.log(chalk.green(`Plugin "${pluginRef}" successfully unregistered.`));
+
+             } catch (error) {
+                 console.error(chalk.red(`Error unregistering plugin: ${error.message}`));
+             }
+        });
+
+    pluginsCmd.command('list')
+        .description('List registered plugins')
+        .action(async () => {
+            const config = await loadConfig();
+            const plugins = config.plugins || [];
+            
+            if (plugins.length === 0) {
+                console.log(chalk.gray('No plugins registered.'));
+                return;
+            }
+
+            console.log(chalk.bold('Registered Plugins:'));
+            plugins.forEach(plugin => {
+                console.log(`- ${plugin}`);
+            });
+        });
+}

package/lib/config.js

@@ -42,10 +42,14 @@ export async function loadConfig() {
     try {
         await migrateOldConfig();
         if (!fs.existsSync(CONFIG_FILE)) {
-            return { profiles: {}, activeProfile: null };
+            return { profiles: {}, activeProfile: null, plugins: [] };
         }
         const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
-        return JSON.parse(data);
+        const config = JSON.parse(data);
+        if (!config.plugins) {
+            config.plugins = [];
+        }
+        return config;
     } catch (e) {
         console.error("Error loading config:", e.message);
         return { profiles: {}, activeProfile: null };

package/lib/events.js

@@ -0,0 +1,12 @@
+import { EventEmitter } from 'events';
+
+export class AppEventBus extends EventEmitter {}
+
+export const eventBus = new AppEventBus();
+
+export const EVENTS = {
+    INIT: 'init',
+    BEFORE_COMMAND: 'beforeCommand',
+    AFTER_COMMAND: 'afterCommand',
+    MCP_START: 'mcpStart'
+};

package/lib/mcp.js

@@ -9,6 +9,9 @@ import { readFileSync } from "fs";
 
 // Import command registry
 import { registerAllCommands } from './command-registry.js';
+import { PluginLoader } from './plugin-loader.js';
+import { loadConfig } from './config.js';
+import { eventBus, AppEventBus, EVENTS } from './events.js';
 
 // Helper to strip ANSI codes for cleaner output
 function stripAnsi(str) {
@@ -28,13 +31,15 @@ export async function startMcpServer(options) {
     );
 
     // 1. Setup a dynamic program to discovery commands
-    const program = setupProgram();
+    const program = await setupProgramAsync();
 
     const server = new McpServer({
         name: "mage-remote-run",
         version: packageJson.version
     });
 
+    eventBus.emit(EVENTS.MCP_START, { server, options });
+
     const toolsCount = registerTools(server, program);
 
     if (options.transport === 'http') {
@@ -138,7 +143,7 @@ function registerTools(server, program) {
 
 // Re-register all commands on a fresh program instance
 // We export this logic so we can reuse it
-function setupProgram() {
+async function setupProgramAsync() {
     const program = new Command();
 
     // Silence output for the main program instance to avoid double printing during parsing
@@ -147,8 +152,33 @@ function setupProgram() {
         writeErr: (str) => { }
     });
 
+    const localEventBus = new AppEventBus();
+
+    const appContext = {
+        program,
+        config: await loadConfig(),
+        profile: null, // MCP uses all commands, usually? Or should we use active profile?
+        // registerAllCommands registers everything. Plugins might need to know if they should register.
+        // Assuming plugins register globally for now or handle checking config themselves.
+        eventBus: localEventBus,
+        EVENTS
+    };
+
+    const pluginLoader = new PluginLoader(appContext);
+    await pluginLoader.loadPlugins();
+
+    localEventBus.emit(EVENTS.INIT, appContext);
+
     registerAllCommands(program);
 
+    program.hook('preAction', async (thisCommand, actionCommand) => {
+        localEventBus.emit(EVENTS.BEFORE_COMMAND, { thisCommand, actionCommand, profile: null });
+    });
+
+    program.hook('postAction', async (thisCommand, actionCommand) => {
+        localEventBus.emit(EVENTS.AFTER_COMMAND, { thisCommand, actionCommand, profile: null });
+    });
+
     return program;
 }
 
@@ -172,7 +202,7 @@ async function executeCommand(cmdDefinition, args, parentName) {
     console.error = logInterceptor;
 
     try {
-        const program = setupProgram();
+        const program = await setupProgramAsync();
 
         // Construct argv
         // We need to build [node, script, command, subcommand, ..., args, options]
@@ -180,43 +210,6 @@ async function executeCommand(cmdDefinition, args, parentName) {
 
         // Reconstruct command path
         if (parentName) {
-            // parentName might be "website" or "website_domain" (if nested deeper? current logic supports 1 level nesting)
-            // Current processCommand logic: `cmdName = parentName ? ${parentName}_${cmd.name()} : cmd.name()`
-            // But parentName passed to executeCommand is the prefix.
-            // Wait, registerTools calls: `executeCommand(cmd, args, parentName)`
-            // If parentName is "website", and cmd is "list", we need "website list"
-
-            // NOTE: parentName in processCommand is built recursively with underscores?
-            // In processCommand(subCmd, cmdName), cmdName is "parent_sub".
-            // So if we have website -> list.
-            // processCommand(website) -> processCommand(list, "website")
-            // parentName in executeCommand is "website".
-            // cmd.name() is "list".
-
-            // However, parentName might contain underscores if deeper nesting?
-            // "store_config_list" -> parent "store_config", cmd "list".
-            // Commander commands are usually space separated in argv.
-
-            // We need to parse parentName back to argv tokens?
-            // Or better: store the "command path" as an array in the tool context.
-
-            // Let's rely on standard splitting by underscore, assuming command names don't have underscores.
-            // Or we can assume parentName matches the command structure.
-
-            // Safest: splitting parentName by UNDERSCORE might be risky if command names have underscores.
-            // But standard commands here: website, store, etc. don't.
-
-            // Actually, we can just push parentName, then cmd.name()
-            // But parentName comes from `cmdName` variable passed as `parentName` to recursive call.
-            // `processCommand(subCmd, cmdName)`
-            // `cmdName` = `parentName_cmd.name()`.
-            // So for `website list`:
-            // `processCommand(website, '')` -> `cmdName="website"`.
-            //   -> `processCommand(list, "website")`.
-            //      -> register tool "website_list". `parentName` passed to execute is "website".
-
-            // So `parentName` is the accumulated prefix with underscores.
-
             const parts = parentName.split('_');
             argv.push(...parts);
         }

package/lib/plugin-loader.js

@@ -0,0 +1,98 @@
+import path from 'path';
+import fs from 'fs';
+import { pathToFileURL } from 'url';
+import globalDirs from 'global-dirs';
+import chalk from 'chalk';
+import { createRequire } from 'module';
+import { loadConfig } from './config.js';
+
+const require = createRequire(import.meta.url);
+
+export class PluginLoader {
+    constructor(appContext) {
+        this.appContext = appContext;
+        this.plugins = [];
+    }
+
+    async loadPlugins() {
+        const config = await loadConfig();
+        // If config.plugins is missing, we default to empty array
+        const plugins = config.plugins || [];
+
+        for (const pluginName of plugins) {
+            try {
+                await this.loadPlugin(pluginName);
+            } catch (e) {
+                console.error(chalk.red(`Failed to load plugin ${pluginName}: ${e.message}`));
+                if (process.env.DEBUG) {
+                    console.error(e);
+                }
+            }
+        }
+    }
+
+    async loadPlugin(pluginName) {
+        let pluginPath;
+
+        // 1. Try local node_modules
+        try {
+            pluginPath = require.resolve(pluginName);
+        } catch (e) {
+            // 2. Try global node_modules (npm)
+            try {
+                const globalNpmPath = path.join(globalDirs.npm.packages, pluginName);
+                if (fs.existsSync(globalNpmPath)) {
+                    const pkgJsonPath = path.join(globalNpmPath, 'package.json');
+                    if (fs.existsSync(pkgJsonPath)) {
+                        const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+                        const mainFile = pkg.main || 'index.js';
+                        pluginPath = path.join(globalNpmPath, mainFile);
+                    } else {
+                         pluginPath = path.join(globalNpmPath, 'index.js');
+                    }
+                } else {
+                    // 3. Try global node_modules (yarn)
+                     const globalYarnPath = path.join(globalDirs.yarn.packages, pluginName);
+                     if (fs.existsSync(globalYarnPath)) {
+                        const pkgJsonPath = path.join(globalYarnPath, 'package.json');
+                        if (fs.existsSync(pkgJsonPath)) {
+                            const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+                            const mainFile = pkg.main || 'index.js';
+                            pluginPath = path.join(globalYarnPath, mainFile);
+                        } else {
+                             pluginPath = path.join(globalYarnPath, 'index.js');
+                        }
+                     }
+                }
+            } catch (globalErr) {
+                // Ignore global errors, proceed to throw if not found
+            }
+        }
+
+        if (!pluginPath) {
+             throw new Error(`Could not resolve plugin '${pluginName}' locally or globally.`);
+        }
+
+        // Import using file URL for absolute paths in ESM
+        // Windows paths need to be converted to file URLs
+        const pluginUrl = pathToFileURL(pluginPath).href;
+        
+        if (process.env.DEBUG) {
+            console.log(chalk.gray(`Loading plugin from: ${pluginUrl}`));
+        }
+
+        const pluginModule = await import(pluginUrl);
+
+        if (pluginModule && pluginModule.default) {
+            if (typeof pluginModule.default === 'function') {
+                 await pluginModule.default(this.appContext);
+                 this.plugins.push({ name: pluginName, module: pluginModule });
+                 if (process.env.DEBUG) {
+                     console.log(chalk.gray(`Loaded plugin: ${pluginName}`));
+                 }
+            } else {
+                console.warn(chalk.yellow(`Plugin ${pluginName} does not export a default function.`));
+            }
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mage-remote-run",
-  "version": "0.26.1",
+  "version": "0.28.0",
   "description": "The remote swiss army knife for Magento Open Source, Mage-OS, Adobe Commerce",
   "main": "index.js",
   "scripts": {
@@ -40,7 +40,8 @@
     "commander": "^14.0.2",
     "csv-parse": "^6.1.0",
     "csv-stringify": "^6.6.0",
-    "env-paths": "^3.0.0",
+    "env-paths": "^4.0.0",
+    "global-dirs": "^3.0.1",
     "html-to-text": "^9.0.5",
     "inquirer": "^13.1.0",
     "mkdirp": "^3.0.1",