mage-remote-run 0.13.0 → 0.15.0

package/bin/mage-remote-run.js

@@ -11,24 +11,24 @@ const pkg = require('../package.json');
 const program = new Command();
 
 program
-    .name('mage-remote-run')
-    .description('The remote swiss army knife for Magento Open Source, Mage-OS, Adobe Commerce')
-    .version(pkg.version)
-    .configureHelp({
-        visibleCommands: (cmd) => {
-            const commands = cmd.commands.filter(c => !c._hidden);
-            return commands.sort((a, b) => {
-                if (a.name() === 'connection') return -1;
-                if (b.name() === 'connection') return 1;
-                return a.name().localeCompare(b.name());
-            });
-        },
-        subcommandTerm: (cmd) => chalk.cyan(cmd.name()),
-        subcommandDescription: (cmd) => chalk.gray(cmd.description()),
-        optionTerm: (option) => chalk.yellow(option.flags),
-        optionDescription: (option) => chalk.gray(option.description)
-    })
-    .addHelpText('before', chalk.hex('#FFA500')(`
+  .name('mage-remote-run')
+  .description('The remote swiss army knife for Magento Open Source, Mage-OS, Adobe Commerce')
+  .version(pkg.version)
+  .configureHelp({
+    visibleCommands: (cmd) => {
+      const commands = cmd.commands.filter(c => !c._hidden);
+      return commands.sort((a, b) => {
+        if (a.name() === 'connection') return -1;
+        if (b.name() === 'connection') return 1;
+        return a.name().localeCompare(b.name());
+      });
+    },
+    subcommandTerm: (cmd) => chalk.cyan(cmd.name()),
+    subcommandDescription: (cmd) => chalk.gray(cmd.description()),
+    optionTerm: (option) => chalk.yellow(option.flags),
+    optionDescription: (option) => chalk.gray(option.description)
+  })
+  .addHelpText('before', chalk.hex('#FFA500')(`
    _ __ ___   __ _  __ _  ___      _ __ ___ _ __ ___   ___ | |_ ___      _ __ _   _ _ __ 
   | '_ \` _ \\ / _\` |/ _\` |/ _ \\____| '__/ _ \\ '_ \` _ \\ / _ \\| __/ _ \\____| '__| | | | '_ \\
   | | | | | | (_| | (_| |  __/____| | |  __/ | | | | | (_) | ||  __/____| |  | |_| | | | |
@@ -38,27 +38,49 @@ program
 
 
 
-import { registerCommands } from '../lib/command-registry.js';
+import {
+  registerConnectionCommands,
+  registerCoreCommands,
+  registerCloudCommands
+} from '../lib/command-registry.js';
 import { getActiveProfile } from '../lib/config.js';
+import { startMcpServer } from '../lib/mcp.js';
+
+registerConnectionCommands(program);
+
+program.command('mcp')
+  .description('Run as MCP server')
+  .option('--transport <type>', 'Transport type (stdio, http)', 'stdio')
+  .option('--host <host>', 'HTTP Host', '127.0.0.1')
+  .option('--port <port>', 'HTTP Port', '18098')
+  .action(async (options) => {
+    await startMcpServer(options);
+  });
 
 const profile = await getActiveProfile();
 
-registerCommands(program, profile);
+if (profile) {
+  registerCoreCommands(program);
+
+  if (profile.type === 'ac-cloud-paas' || profile.type === 'ac-saas') {
+    registerCloudCommands(program);
+  }
+}
 
 program.hook('preAction', async (thisCommand, actionCommand) => {
-    // 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.
-    if (profile) {
-        const config = await loadConfig();
-        if (config.showActiveConnectionHeader !== false) {
-            const opts = actionCommand.opts();
-            if (opts.format !== 'json' && opts.format !== 'xml') {
-                console.log(chalk.cyan(`Active Connection: ${chalk.bold(profile.name)} (${profile.type})`));
-                console.log(chalk.gray('━'.repeat(60)) + '\n');
-            }
-        }
+  // 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.
+  if (profile) {
+    const config = await loadConfig();
+    if (config.showActiveConnectionHeader !== false) {
+      const opts = actionCommand.opts();
+      if (opts.format !== 'json' && opts.format !== 'xml') {
+        console.log(chalk.cyan(`Active Connection: ${chalk.bold(profile.name)} (${profile.type})`));
+        console.log(chalk.gray('━'.repeat(60)) + '\n');
+      }
     }
+  }
 });
 
 import { expandCommandAbbreviations } from '../lib/command-helper.js';
@@ -72,28 +94,28 @@ const config = await loadConfig();
 const hasProfiles = Object.keys(config.profiles || {}).length > 0;
 
 if (!hasProfiles && args.length === 0) {
-    console.log(chalk.bold.blue('Welcome to mage-remote-run! 🚀'));
-    console.log(chalk.gray('The remote swiss army knife for Magento Open Source, Mage-OS, Adobe Commerce'));
-    console.log(chalk.gray('It looks like you haven\'t configured any connections yet.'));
-    console.log(chalk.gray('Let\'s set up your first connection now.\n'));
-
-    // Trigger the interactive add command directly
-    // We can simulate running the 'connection add' command
-    // But since we are at top level, we might need to invoke it manually or parse specific args.
-    // Easiest is to manually invoke program.parse with ['node', 'script', 'connection', 'add']
-    // BUT program.parse executes asynchronously usually? commander is synchronous by default but actions are async.
-    // Let's modify process.argv before parsing.
-    args = ['connection', 'add'];
+  console.log(chalk.bold.blue('Welcome to mage-remote-run! 🚀'));
+  console.log(chalk.gray('The remote swiss army knife for Magento Open Source, Mage-OS, Adobe Commerce'));
+  console.log(chalk.gray('It looks like you haven\'t configured any connections yet.'));
+  console.log(chalk.gray('Let\'s set up your first connection now.\n'));
+
+  // Trigger the interactive add command directly
+  // We can simulate running the 'connection add' command
+  // But since we are at top level, we might need to invoke it manually or parse specific args.
+  // Easiest is to manually invoke program.parse with ['node', 'script', 'connection', 'add']
+  // BUT program.parse executes asynchronously usually? commander is synchronous by default but actions are async.
+  // Let's modify process.argv before parsing.
+  args = ['connection', 'add'];
 }
 
 try {
-    args = expandCommandAbbreviations(program, args);
+  args = expandCommandAbbreviations(program, args);
 } catch (e) {
-    if (e.isAmbiguous) {
-        console.error(e.message);
-        process.exit(1);
-    }
-    throw e;
+  if (e.isAmbiguous) {
+    console.error(e.message);
+    process.exit(1);
+  }
+  throw e;
 }
 process.argv = [...process.argv.slice(0, 2), ...args];
 

package/lib/command-registry.js

@@ -12,24 +12,57 @@ import { registerAdobeIoEventsCommands } from './commands/adobe-io-events.js';
 import { registerWebhooksCommands } from './commands/webhooks.js';
 import { registerConsoleCommand } from './commands/console.js';
 
-export function registerCommands(program, profile) {
-    registerConnectionCommands(program);
-    registerConsoleCommand(program);
-
-    if (profile) {
-        registerWebsitesCommands(program);
-        registerStoresCommands(program);
-        registerCustomersCommands(program);
-        registerOrdersCommands(program);
-        registerEavCommands(program);
-        registerProductsCommands(program);
-        registerTaxCommands(program);
-        registerInventoryCommands(program);
-
-        if (profile.type === 'ac-cloud-paas' || profile.type === 'ac-saas') {
-            registerAdobeIoEventsCommands(program);
-            registerCompanyCommands(program);
-            registerWebhooksCommands(program);
-        }
-    }
+export { registerConnectionCommands, registerConsoleCommand };
+
+export function registerCoreCommands(program) {
+  registerWebsitesCommands(program);
+  registerStoresCommands(program);
+  registerCustomersCommands(program);
+  registerOrdersCommands(program);
+  registerEavCommands(program);
+  registerProductsCommands(program);
+  registerTaxCommands(program);
+  registerInventoryCommands(program);
+  registerConsoleCommand(program);
+}
+
+export function registerCloudCommands(program) {
+  registerAdobeIoEventsCommands(program);
+  registerCompanyCommands(program);
+  registerWebhooksCommands(program);
 }
+
+export function registerAllCommands(program) {
+  registerConnectionCommands(program);
+  registerCoreCommands(program);
+  registerCloudCommands(program);
+}
+
+// Alias for backwards compatibility with console.js (and potential other usages)
+export const registerCommands = (program, profile) => {
+  // Note: console.js passes profile, but registerAllCommands doesn't strictly use it 
+  // (it registers everything, profile checks happen inside or via selective registration).
+  // The original behavior in console.js:
+  // const profile = await getActiveProfile();
+  // registerCommands(localProgram, profile);
+
+  // In bin/mage-remote-run.js old logic:
+  // registerConnectionCommands(program);
+  // if (profile) { registerWebsitesCommands... }
+
+  // We should replicate that 'selective' registration if we want to match exact behavior?
+  // BUT console.js wants to register ALL available commands for the profile.
+
+  registerConnectionCommands(program);
+
+  // Simple logic: If profile exists, register all. 
+  // console.js usage implies profile is present if it's running (or it tries to get it).
+
+  if (profile) {
+    registerCoreCommands(program);
+    // Cloud check
+    if (profile.type === 'ac-cloud-paas' || profile.type === 'ac-saas') {
+      registerCloudCommands(program);
+    }
+  }
+};

package/lib/commands/connections.js

@@ -349,6 +349,10 @@ Examples:
                     default: config.activeProfile
                 });
 
+                if (process.env.DEBUG) {
+                    console.log(chalk.gray(`DEBUG: Selected profile: ${selected}`));
+                }
+
                 config.activeProfile = selected;
                 await saveConfig(config);
                 console.log(chalk.green(`Active profile set to "${selected}".`));
@@ -393,6 +397,8 @@ Examples:
                 config.showActiveConnectionHeader = state === 'on';
                 await saveConfig(config);
                 console.log(chalk.green(`Active connection header is now ${state === 'on' ? 'enabled' : 'disabled'}.`));
-            } catch (e) { handleError(e); }
+            } catch (e) {
+                handleError(e);
+            }
         });
 }

package/lib/commands/console.js

@@ -25,48 +25,55 @@ export function registerConsoleCommand(program) {
             console.log(chalk.gray('Type "list" to see available commands.'));
             console.log(chalk.gray('Type .exit to quit.\n'));
 
-            // Create a fresh program instance for the REPL
-            const localProgram = new Command();
-
-            // Configure custom output for REPL to avoid duplicate error printing when we catch it
-            localProgram.configureOutput({
-                writeOut: (str) => process.stdout.write(str),
-                writeErr: (str) => process.stderr.write(str),
-            });
-
-            // Apply exitOverride recursively to ensure all subcommands (and sub-subcommands)
-            // handle help/errors without exiting the process.
-            const applyExitOverride = (cmd) => {
-                cmd.exitOverride((err) => {
-                    throw err;
+            // State for the REPL
+            let localProgram;
+            let currentProfile;
+
+            // Function to load/reload commands based on current profile
+            const loadLocalCommands = async () => {
+                // Create a fresh program instance for the REPL
+                localProgram = new Command();
+
+                // Configure custom output for REPL to avoid duplicate error printing
+                localProgram.configureOutput({
+                    writeOut: (str) => process.stdout.write(str),
+                    writeErr: (str) => process.stderr.write(str),
                 });
-                // Check for subcommands
-                if (cmd.commands) {
-                    cmd.commands.forEach(applyExitOverride);
-                }
-            };
 
-            // Register all commands on the local instance
-            const profile = await getActiveProfile();
-            registerCommands(localProgram, profile);
+                // Apply exitOverride recursively
+                const applyExitOverride = (cmd) => {
+                    cmd.exitOverride((err) => {
+                        throw err;
+                    });
+                    if (cmd.commands) {
+                        cmd.commands.forEach(applyExitOverride);
+                    }
+                };
 
-            // Apply overrides AFTER registration to catch all commands
-            applyExitOverride(localProgram);
+                // Get current profile and register commands
+                const profile = await getActiveProfile();
+                registerCommands(localProgram, profile);
+                applyExitOverride(localProgram);
 
-            const r = repl.start({
-                prompt: chalk.green('mage> '),
-                // We do NOT provide 'eval' here so we get the default one which supports top-level await
-            });
+                // Update current profile state (store simple unique string for comparison)
+                currentProfile = profile ? `${profile.name}:${profile.type}` : 'null';
+
+                return { localProgram, profile };
+            };
 
-            const defaultEval = r.eval;
+            // Initial load
+            await loadLocalCommands();
 
-            // Capture default completer
-            const defaultCompleter = r.completer;
+            // Use 'stream' module to create dummy REPL for capturing defaults
+            const { PassThrough } = await import('stream');
+            const dummy = repl.start({ input: new PassThrough(), output: new PassThrough(), terminal: false });
+            const defaultCompleter = dummy.completer;
+            const defaultEval = dummy.eval;
+            dummy.close();
 
-            // Custom completer
+            // Custom completer definition
             const myCompleter = (line, callback) => {
                 const parts = line.split(/\s+/);
-                // Remove empty start if line starts with space (not typical for completion line but safe)
                 if (parts[0] === '') parts.shift();
 
                 let current = '';
@@ -80,19 +87,16 @@ export function registerConsoleCommand(program) {
                     contextParts = parts;
                 }
 
-                // Helper to get candidates from a command object
                 const getCandidates = (cmdObj) => {
                     return cmdObj.commands.map(c => c.name());
                 };
 
                 let hits = [];
 
-                // Top-level completion (start of line)
                 if (contextParts.length === 0) {
                     const candidates = getCandidates(localProgram);
                     hits = candidates.filter(c => c.startsWith(current));
                 } else {
-                    // Subcommand completion
                     let cmd = localProgram;
                     let validContext = true;
 
@@ -112,20 +116,18 @@ export function registerConsoleCommand(program) {
                     }
                 }
 
-                // If we have distinct command hits, return them
                 if (hits.length > 0) {
                     return callback(null, [hits, current]);
                 }
 
-                // Fallback to default JS completion
                 return defaultCompleter(line, callback);
             };
 
-            // Override completer
-            r.completer = myCompleter;
+            // Custom evaluator definition
+            const myEval = async function (cmd, context, filename, callback) {
+                // 'this' is the REPLServer instance
+                const rInstance = this;
 
-            // Custom evaluator to support both CLI commands and JS
-            const myEval = async (cmd, context, filename, callback) => {
                 cmd = cmd.trim();
 
                 if (!cmd) {
@@ -135,7 +137,6 @@ export function registerConsoleCommand(program) {
 
                 if (cmd === 'list') {
                     console.log(chalk.bold('\nAvailable Commands:'));
-                    // Use localProgram commands
                     localProgram.commands.filter(c => !c._hidden).sort((a, b) => a.name().localeCompare(b.name())).forEach(c => {
                         console.log(`  ${chalk.cyan(c.name().padEnd(25))} ${c.description()}`);
                     });
@@ -151,8 +152,6 @@ export function registerConsoleCommand(program) {
                 }
 
                 try {
-                    // Parse arguments nicely
-                    // This regex handles quoted arguments
                     const args = (cmd.match(/[^\s"']+|"([^"]*)"|'([^']*)'/g) || []).map(arg => {
                         if (arg.startsWith('"') && arg.endsWith('"')) return arg.slice(1, -1);
                         if (arg.startsWith("'") && arg.endsWith("'")) return arg.slice(1, -1);
@@ -171,32 +170,10 @@ export function registerConsoleCommand(program) {
                             }
                         } catch (e) {
                             if (e.isAmbiguous) {
-                                // If ambiguous, print error and return (don't execute JS, as user likelihood meant a command)
-                                // But wait, what if "c" is a var? 
-                                // If I type "c", it is ambiguous. 
-                                // If I fallback to JS, "c" might work.
-                                // If I print error, "c" access is blocked.
-
-                                // Compromise: If it LOOKS like a command usage (e.g. multiple args), treat as command error?
-                                // Or just always fallback to JS if ambiguous? 
-                                // If fallback to JS, user sees "c is not defined". 
-                                // User asks: "Why didn't it run command?". Answer: "Ambiguous". 
-                                // Explicit ambiguity error is arguably better than generic ReferenceError.
-
-                                // However, "c = 1" or "const c = 1"
-                                // "const" -> ambiguous? "connection", "console"... no "const" is not in list of commands. 
-                                // "const" might NOT match any command prefix if lucky.
-                                // But if it does...
-
-                                // Let's stick to safe approach: fallback to JS if ambiguous, unless we are SURE it's not JS?
-                                // Or: Just print the ambiguous error if the first arg matched *something*.
-
-                                // Let's try to assume command first. If ambiguous, show error.
                                 console.error(chalk.red(e.message));
                                 callback(null);
                                 return;
                             }
-                            // Other errors?
                             throw e;
                         }
 
@@ -205,32 +182,84 @@ export function registerConsoleCommand(program) {
 
                         if (knownCommands.includes(firstWord)) {
                             // Valid command found
+                            let keypressListeners = [];
                             try {
-                                r.pause();
-                                await localProgram.parseAsync(['node', 'mage-remote-run', ...expandedArgs]);
+                                rInstance.pause();
+
+                                // Capture and remove keypress listeners to prevent REPL from intercepting input
+                                // intended for interactive commands (like inquirer)
+                                keypressListeners = process.stdin.listeners('keypress');
+                                process.stdin.removeAllListeners('keypress');
 
-                                // Restore REPL state
                                 if (process.stdin.isTTY) {
-                                    process.stdin.setRawMode(true);
+                                    process.stdin.setRawMode(false);
                                 }
-                                process.stdin.resume();
-                                r.resume();
-                                r.displayPrompt();
+
+                                await localProgram.parseAsync(['node', 'mage-remote-run', ...expandedArgs]);
+
+                                // Check for profile change after command execution
+                                const newProfileObj = await getActiveProfile();
+                                const newProfileKey = newProfileObj ? `${newProfileObj.name}:${newProfileObj.type}` : 'null';
+
+                                if (process.env.DEBUG) {
+                                    console.log(chalk.gray(`DEBUG: Check Profile Switch. Current: ${currentProfile}, New: ${newProfileKey}`));
+                                }
+
+                                if (newProfileKey !== currentProfile) {
+                                    await loadLocalCommands();
+                                    // Update context variables
+                                    rInstance.context.config = await loadConfig();
+
+                                    if (process.env.DEBUG) {
+                                        console.log(chalk.green(`\nConnection switched to ${newProfileObj ? newProfileObj.name : 'none'}. Commands reloaded.`));
+                                    }
+                                }
+
+                                // Restore REPL state
+                                setTimeout(() => {
+                                    // Restore keypress listeners
+                                    keypressListeners.forEach(fn => process.stdin.on('keypress', fn));
+
+                                    if (process.stdin.isTTY) {
+                                        process.stdin.setRawMode(true);
+                                    }
+                                    process.stdin.resume();
+
+                                    // Flush stdin to remove any buffered leftovers
+                                    let chunk;
+                                    while ((chunk = process.stdin.read()) !== null) { }
+
+                                    rInstance.resume();
+                                    rInstance.displayPrompt(true);
+                                }, 100);
+
                             } catch (e) {
+                                // Restore listeners in error case too!
+                                keypressListeners.forEach(fn => process.stdin.on('keypress', fn));
+
                                 if (process.stdin.isTTY) {
                                     process.stdin.setRawMode(true);
                                 }
                                 process.stdin.resume();
-                                r.resume();
+                                rInstance.resume();
+
+                                // Flush stdin
+                                let chunk;
+                                while ((chunk = process.stdin.read()) !== null) { }
+
                                 if (e.code === 'commander.helpDisplayed') {
                                     // Help was displayed, clean exit for us
+                                    setImmediate(() => rInstance.displayPrompt());
                                 } else if (e.code === 'commander.unknownOption' || e.code === 'commander.unknownCommand') {
                                     console.error(chalk.red(e.message));
+                                    setImmediate(() => rInstance.displayPrompt());
                                 } else {
                                     if (e.code) {
                                         // Likely a commander exit error we rethrew
+                                        setImmediate(() => rInstance.displayPrompt());
                                     } else {
                                         console.error(chalk.red('Command execution error:'), e);
+                                        setImmediate(() => rInstance.displayPrompt());
                                     }
                                 }
                             }
@@ -239,27 +268,29 @@ export function registerConsoleCommand(program) {
                         }
                     }
                 } catch (e) {
-                    // unexpected error during CLI detection
+                    // unexpected error
                 }
 
                 // Fallback to default eval which supports top-level await
-                defaultEval.call(r, cmd, context, filename, callback);
+                return defaultEval.call(rInstance, cmd, context, filename, callback);
             };
 
-            // Override the eval function
-            r.eval = myEval;
+            const r = repl.start({
+                prompt: chalk.green('mage> '),
+                eval: myEval,
+                completer: myCompleter
+            });
 
-            // Initialize context
             r.context.client = createClient;
             r.context.config = await loadConfig();
             r.context.chalk = chalk;
-            r.context.program = program; // Expose global program just in case? Or local?
-            r.context.localProgram = localProgram; // Expose local debugging
 
             // Helper to reload config if changed
             r.context.reload = async () => {
                 r.context.config = await loadConfig();
-                console.log(chalk.gray('Config reloaded.'));
+                // We should also reload commands here in case a manual config edit changed the type
+                await loadLocalCommands();
+                console.log(chalk.gray('Config and commands reloaded.'));
             };
 
             r.on('exit', () => {

package/lib/mcp.js

@@ -0,0 +1,271 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { z } from "zod";
+import http from "http";
+import chalk from "chalk";
+import { Command } from "commander";
+import { readFileSync } from "fs";
+
+// Import command registry
+import { registerAllCommands } from './command-registry.js';
+
+// Helper to strip ANSI codes for cleaner output
+function stripAnsi(str) {
+    return str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
+}
+
+/**
+ * Starts the MCP server.
+ * @param {Object} options Configuration options
+ * @param {string} options.transport 'stdio' or 'http'
+ * @param {string} [options.host] Host for HTTP server
+ * @param {number} [options.port] Port for HTTP server
+ */
+export async function startMcpServer(options) {
+    const packageJson = JSON.parse(
+        readFileSync(new URL("../package.json", import.meta.url))
+    );
+
+    // 1. Setup a dynamic program to discovery commands
+    const program = setupProgram();
+
+    const server = new McpServer({
+        name: "mage-remote-run",
+        version: packageJson.version
+    });
+
+    const toolsCount = registerTools(server, program);
+
+    if (options.transport === 'http') {
+        const host = options.host || '127.0.0.1';
+        const port = options.port || 18098;
+
+        const transport = new StreamableHTTPServerTransport();
+
+        const httpServer = http.createServer(async (req, res) => {
+            if (req.url === '/sse' || (req.url === '/messages' && req.method === 'POST')) {
+                await transport.handleRequest(req, res);
+            } else {
+                res.writeHead(404);
+                res.end();
+            }
+        });
+
+        httpServer.listen(port, host, () => {
+            console.error(`MCP Server running on http://${host}:${port}`);
+            console.error(`Protocol: HTTP (SSE)`);
+            console.error(`Registered Tools: ${toolsCount}`);
+        });
+
+        await server.connect(transport);
+
+    } else {
+        // STDIO
+        console.error(`Protocol: stdio`);
+        console.error(`Registered Tools: ${toolsCount}`);
+        const transport = new StdioServerTransport();
+        await server.connect(transport);
+    }
+}
+
+function registerTools(server, program) {
+    let count = 0;
+
+    function processCommand(cmd, parentName = '') {
+        const cmdName = parentName ? `${parentName}_${cmd.name()}` : cmd.name();
+
+        // If it has subcommands, process them
+        if (cmd.commands && cmd.commands.length > 0) {
+            cmd.commands.forEach(subCmd => processCommand(subCmd, cmdName));
+            return;
+        }
+
+        // It's a leaf command, register as tool
+        // Tool name: Replace spaces/colons with underscores. 
+        // Example: website list -> website_list
+        const toolName = cmdName.replace(/[^a-zA-Z0-9_]/g, '_');
+
+        const schema = {};
+
+        // Arguments
+        // Commander args: cmd._args
+        // Options: cmd.options
+
+        const zodShape = {};
+
+        cmd._args.forEach(arg => {
+            // arg.name(), arg.required
+            if (arg.required) {
+                zodShape[arg.name()] = z.string().describe(arg.description || '');
+            } else {
+                zodShape[arg.name()] = z.string().optional().describe(arg.description || '');
+            }
+        });
+
+        cmd.options.forEach(opt => {
+            const name = opt.name(); // e.g. "format" for --format
+            // Check flags to guess type. 
+            // -f, --format <type> -> string
+            // -v, --verbose -> boolean
+
+            if (opt.flags.includes('<')) {
+                // Takes an argument, assume string
+                zodShape[name] = z.string().optional().describe(opt.description);
+            } else {
+                // Boolean flag
+                zodShape[name] = z.boolean().optional().describe(opt.description);
+            }
+        });
+
+        const description = cmd.description() || `Execute mage-remote-run ${cmdName.replace(/_/g, ' ')}`;
+
+        server.tool(
+            toolName,
+            description,
+            zodShape,
+            async (args) => {
+                return await executeCommand(cmd, args, parentName);
+            }
+        );
+        count++;
+    }
+
+
+    program.commands.forEach(cmd => processCommand(cmd));
+    return count;
+}
+
+// Re-register all commands on a fresh program instance
+// We export this logic so we can reuse it
+function setupProgram() {
+    const program = new Command();
+
+    // Silence output for the main program instance to avoid double printing during parsing
+    program.configureOutput({
+        writeOut: (str) => { },
+        writeErr: (str) => { }
+    });
+
+    registerAllCommands(program);
+
+    return program;
+}
+
+async function executeCommand(cmdDefinition, args, parentName) {
+    // cmdDefinition is the original command object from discovery, used for context if needed,
+    // but here we mainly need the path to find it in the new program.
+    // Actually, we can just reconstruct the path from parentName + cmd.name()
+
+    // Intercept Console
+    let output = '';
+    const originalLog = console.log;
+    const originalError = console.error;
+
+    // Simple custom logger
+    const logInterceptor = (...msgArgs) => {
+        const line = msgArgs.map(String).join(' ');
+        output += stripAnsi(line) + '\n';
+    };
+
+    console.log = logInterceptor;
+    console.error = logInterceptor;
+
+    try {
+        const program = setupProgram();
+
+        // Construct argv
+        // We need to build [node, script, command, subcommand, ..., args, options]
+        const argv = ['node', 'mage-remote-run'];
+
+        // 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);
+        }
+
+        argv.push(cmdDefinition.name());
+
+        // Add arguments and options from the tool args
+
+        // 1. Positional arguments
+        cmdDefinition._args.forEach(arg => {
+            if (args[arg.name()]) {
+                argv.push(args[arg.name()]);
+            }
+        });
+
+        // 2. Options
+        cmdDefinition.options.forEach(opt => {
+            const name = opt.name(); // e.g. "format"
+            if (args[name] !== undefined) {
+                const val = args[name];
+                if (opt.flags.includes('<')) {
+                    // String option
+                    argv.push(`--${name}`);
+                    argv.push(val);
+                } else {
+                    // Boolean flag
+                    if (val === true) {
+                        argv.push(`--${name}`);
+                    }
+                }
+            }
+        });
+
+        // Execute
+        await program.parseAsync(argv);
+
+        return {
+            content: [{ type: "text", text: output }]
+        };
+
+    } catch (e) {
+        // Commander throws nicely formatted errors usually, but we suppressed output.
+        // If it throws, it might be a cleaner exit error.
+        return {
+            content: [{ type: "text", text: output + `\nError: ${e.message}` }],
+            isError: true
+        };
+    } finally {
+        console.log = originalLog;
+        console.error = originalError;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mage-remote-run",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "The remote swiss army knife for Magento Open Source, Mage-OS, Adobe Commerce",
   "main": "index.js",
   "scripts": {
@@ -31,6 +31,7 @@
   ],
   "dependencies": {
     "@inquirer/prompts": "^8.1.0",
+    "@modelcontextprotocol/sdk": "^1.25.1",
     "axios": "^1.13.2",
     "chalk": "^5.6.2",
     "cli-table3": "^0.6.5",
@@ -40,7 +41,8 @@
     "inquirer": "^13.1.0",
     "mkdirp": "^3.0.1",
     "oauth-1.0a": "^2.2.6",
-    "openapi-client-axios": "^7.8.0"
+    "openapi-client-axios": "^7.8.0",
+    "zod": "^4.2.1"
   },
   "devDependencies": {
     "jest": "^30.2.0"