mage-remote-run 0.12.0 → 0.14.0

package/lib/commands/console.js

@@ -0,0 +1,300 @@
+import repl from 'repl';
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { createClient } from '../api/factory.js';
+import { loadConfig, getActiveProfile } from '../config.js';
+import { registerCommands } from '../command-registry.js';
+import { expandCommandAbbreviations } from '../command-helper.js';
+
+export function registerConsoleCommand(program) {
+    program
+        .command('console')
+        .alias('repl')
+        .description('Start an interactive console')
+        .option('-d, --debug', 'Enable debug output')
+        .action(async (options) => {
+            if (options.debug) {
+                process.env.DEBUG = '1';
+                console.log(chalk.gray('Debug mode enabled'));
+            }
+
+            console.log(chalk.bold.blue('Mage Remote Run Interactive Console'));
+            console.log(chalk.gray('Type your commands directly or write JS code.'));
+            console.log(chalk.gray('Global variables available: client (async factory), config, chalk'));
+            console.log(chalk.gray('Example JS: await (await client()).get("V1/store/websites")'));
+            console.log(chalk.gray('Type "list" to see available commands.'));
+            console.log(chalk.gray('Type .exit to quit.\n'));
+
+            // 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),
+                });
+
+                // Apply exitOverride recursively
+                const applyExitOverride = (cmd) => {
+                    cmd.exitOverride((err) => {
+                        throw err;
+                    });
+                    if (cmd.commands) {
+                        cmd.commands.forEach(applyExitOverride);
+                    }
+                };
+
+                // Get current profile and register commands
+                const profile = await getActiveProfile();
+                registerCommands(localProgram, profile);
+                applyExitOverride(localProgram);
+
+                // Update current profile state (store simple unique string for comparison)
+                currentProfile = profile ? `${profile.name}:${profile.type}` : 'null';
+
+                return { localProgram, profile };
+            };
+
+            // Initial load
+            await loadLocalCommands();
+
+            // 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 definition
+            const myCompleter = (line, callback) => {
+                const parts = line.split(/\s+/);
+                if (parts[0] === '') parts.shift();
+
+                let current = '';
+                let contextParts = [];
+
+                if (line.match(/\s$/)) {
+                    current = '';
+                    contextParts = parts.filter(p => p.length > 0);
+                } else {
+                    current = parts.pop();
+                    contextParts = parts;
+                }
+
+                const getCandidates = (cmdObj) => {
+                    return cmdObj.commands.map(c => c.name());
+                };
+
+                let hits = [];
+
+                if (contextParts.length === 0) {
+                    const candidates = getCandidates(localProgram);
+                    hits = candidates.filter(c => c.startsWith(current));
+                } else {
+                    let cmd = localProgram;
+                    let validContext = true;
+
+                    for (const part of contextParts) {
+                        const found = cmd.commands.find(c => c.name() === part || (c.aliases && c.aliases().includes(part)));
+                        if (found) {
+                            cmd = found;
+                        } else {
+                            validContext = false;
+                            break;
+                        }
+                    }
+
+                    if (validContext) {
+                        const candidates = getCandidates(cmd);
+                        hits = candidates.filter(c => c.startsWith(current));
+                    }
+                }
+
+                if (hits.length > 0) {
+                    return callback(null, [hits, current]);
+                }
+
+                return defaultCompleter(line, callback);
+            };
+
+            // Custom evaluator definition
+            const myEval = async function (cmd, context, filename, callback) {
+                // 'this' is the REPLServer instance
+                const rInstance = this;
+
+                cmd = cmd.trim();
+
+                if (!cmd) {
+                    callback(null);
+                    return;
+                }
+
+                if (cmd === 'list') {
+                    console.log(chalk.bold('\nAvailable 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()}`);
+                    });
+                    console.log('');
+                    callback(null);
+                    return;
+                }
+
+                if (cmd === 'help') {
+                    localProgram.outputHelp();
+                    callback(null);
+                    return;
+                }
+
+                try {
+                    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);
+                        return arg;
+                    });
+
+                    if (args.length > 0) {
+                        if (process.env.DEBUG) {
+                            console.log(chalk.gray('DEBUG: Parsing args:'), args);
+                        }
+                        let expandedArgs;
+                        try {
+                            expandedArgs = expandCommandAbbreviations(localProgram, args);
+                            if (process.env.DEBUG) {
+                                console.log(chalk.gray('DEBUG: Expanded args:'), expandedArgs);
+                            }
+                        } catch (e) {
+                            if (e.isAmbiguous) {
+                                console.error(chalk.red(e.message));
+                                callback(null);
+                                return;
+                            }
+                            throw e;
+                        }
+
+                        const firstWord = expandedArgs[0];
+                        const knownCommands = localProgram.commands.map(c => c.name());
+
+                        if (knownCommands.includes(firstWord)) {
+                            // Valid command found
+                            let keypressListeners = [];
+                            try {
+                                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');
+
+                                if (process.stdin.isTTY) {
+                                    process.stdin.setRawMode(false);
+                                }
+
+                                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();
+                                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());
+                                    }
+                                }
+                            }
+                            callback(null);
+                            return;
+                        }
+                    }
+                } catch (e) {
+                    // unexpected error
+                }
+
+                // Fallback to default eval which supports top-level await
+                return defaultEval.call(rInstance, cmd, context, filename, callback);
+            };
+
+            const r = repl.start({
+                prompt: chalk.green('mage> '),
+                eval: myEval,
+                completer: myCompleter
+            });
+
+            r.context.client = createClient;
+            r.context.config = await loadConfig();
+            r.context.chalk = chalk;
+
+            // Helper to reload config if changed
+            r.context.reload = async () => {
+                r.context.config = await loadConfig();
+                // 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', () => {
+                process.exit();
+            });
+        });
+}

package/lib/commands/customers.js

@@ -6,6 +6,10 @@ import inquirer from 'inquirer';
 export function registerCustomersCommands(program) {
     const customers = program.command('customer').description('Manage customers');
 
+
+    //-------------------------------------------------------
+    // "customer list" Command
+    //-------------------------------------------------------
     customers.command('list')
         .description('List customers')
         .option('-p, --page <number>', 'Page number', '1')
@@ -45,6 +49,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "customer search" Command
+    //-------------------------------------------------------
     customers.command('search <query>')
         .description('Search customers by email')
         .addHelpText('after', `
@@ -65,6 +73,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "customer edit" Command
+    //-------------------------------------------------------
     customers.command('edit <id>')
         .description('Edit a customer')
         .addHelpText('after', `
@@ -96,6 +108,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "customer show" Command
+    //-------------------------------------------------------
     customers.command('show <customerId>')
         .description('Show detailed customer information')
         .option('-f, --format <type>', 'Output format (text, json, xml)', 'text')
@@ -156,6 +172,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "customer delete" Command
+    //-------------------------------------------------------
     customers.command('delete <customerId>')
         .description('Delete a customer')
         .option('--force', 'Force delete without confirmation')
@@ -185,6 +205,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "customer confirm" Command
+    //-------------------------------------------------------
     customers.command('confirm [customerId]')
         .description('Resend customer confirmation email')
         .option('--redirect-url <url>', 'Redirect URL after confirmation')
@@ -242,6 +266,10 @@ Examples:
         });
     const groups = customers.command('group').description('Manage customer groups');
 
+
+    //-------------------------------------------------------
+    // "customer group list" Command
+    //-------------------------------------------------------
     groups.command('list')
         .description('List customer groups')
         .option('-p, --page <number>', 'Page number', '1')

package/lib/commands/eav.js

@@ -8,6 +8,10 @@ export function registerEavCommands(program) {
     // Attribute Sets
     const attributeSets = eav.command('attribute-set').description('Manage attribute sets');
 
+
+    //-------------------------------------------------------
+    // "eav attribute-set list" Command
+    //-------------------------------------------------------
     attributeSets.command('list')
         .description('List all attribute sets')
         .option('-p, --page <number>', 'Page number', '1')
@@ -51,6 +55,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "eav attribute-set show" Command
+    //-------------------------------------------------------
     attributeSets.command('show <id>')
         .description('Show attribute set details')
         .addHelpText('after', `

package/lib/commands/inventory.js

@@ -8,6 +8,10 @@ export function registerInventoryCommands(program) {
 
     const stock = inventory.command('stock').description('Manage inventory stocks');
 
+
+    //-------------------------------------------------------
+    // "inventory stock list" Command
+    //-------------------------------------------------------
     stock.command('list')
         .description('List inventory stocks')
         .addHelpText('after', `
@@ -28,6 +32,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "inventory stock show" Command
+    //-------------------------------------------------------
     stock.command('show <stockId>')
         .description('Show stock details')
         .addHelpText('after', `
@@ -52,6 +60,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "inventory resolve-stock" Command
+    //-------------------------------------------------------
     inventory.command('resolve-stock <type> <code>')
         .description('Resolve stock for a sales channel')
         .addHelpText('after', `
@@ -68,6 +80,10 @@ Examples:
 
     const source = inventory.command('source').description('Manage inventory sources');
 
+
+    //-------------------------------------------------------
+    // "inventory source list" Command
+    //-------------------------------------------------------
     source.command('list')
         .description('List inventory sources')
         .option('-p, --page <number>', 'Page number', '1')
@@ -108,6 +124,10 @@ Examples:
 
     const ssa = source.command('selection-algorithm').description('Manage source selection algorithms');
 
+
+    //-------------------------------------------------------
+    // "inventory source selection-algorithm list" Command
+    //-------------------------------------------------------
     ssa.command('list')
         .description('List available source selection algorithms')
         .addHelpText('after', `

package/lib/commands/orders.js

@@ -6,6 +6,10 @@ import inquirer from 'inquirer';
 export function registerOrdersCommands(program) {
     const orders = program.command('order').description('Manage orders');
 
+
+    //-------------------------------------------------------
+    // "order list" Command
+    //-------------------------------------------------------
     orders.command('list')
         .option('-p, --page <number>', 'Page number', '1')
         .option('-s, --size <number>', 'Page size', '20')
@@ -44,6 +48,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "order search" Command
+    //-------------------------------------------------------
     orders.command('search <query>')
         .description('Search orders by Increment ID')
         .addHelpText('after', `
@@ -64,6 +72,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "order edit" Command
+    //-------------------------------------------------------
     orders.command('edit <id>')
         .description('Update order status (via Comment)')
         .addHelpText('after', `
@@ -92,6 +104,10 @@ Examples:
                 console.log(chalk.green(`Order ${id} updated.`));
             } catch (e) { handleError(e); }
         });
+
+    //-------------------------------------------------------
+    // "order show" Command
+    //-------------------------------------------------------
     orders.command('show <identifier>')
         .description('Show detailed order information by ID or Increment ID')
         .option('-f, --format <type>', 'Output format (text, json, xml)', 'text')
@@ -106,6 +122,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "order latest" Command
+    //-------------------------------------------------------
     orders.command('latest')
         .description('List latest orders sorted by created_at DESC with selection')
         .option('-p, --page <number>', 'Page number', '1')
@@ -199,7 +219,7 @@ async function showOrder(identifier, format = 'text') {
                     order = await client.get(`V1/orders/${order.entity_id}`, {}, { headers });
                 } catch (subError) {
                     // ignore or log? If we fail to get formatted, fallback or throw?
-                    // If we found it via search, 'order' is the object. 
+                    // If we found it via search, 'order' is the object.
                     // If format is json, we are good.
                     // If format is xml, we NEED to re-fetch because 'order' is currently a JS object from JSON response.
                     if (format === 'xml') throw subError;
@@ -267,8 +287,8 @@ function statusColor(status) {
     // Basic color coding
     if (['pending'].includes(status)) return status;
     if (['processing'].includes(status)) return status;
-    if (['complete'].includes(status)) return status; // green? 
-    // Since we don't have direct chalk access in this helper easily without passing it, 
+    if (['complete'].includes(status)) return status; // green?
+    // Since we don't have direct chalk access in this helper easily without passing it,
     // and I don't want to import it again if I can avoid it or I can just return string.
     // Actually, I can import properly in module scope if I change top imports but I am overwriting the file so I can add imports.
     return status;

package/lib/commands/products.js

@@ -5,6 +5,10 @@ import chalk from 'chalk';
 export function registerProductsCommands(program) {
     const products = program.command('product').description('Manage products');
 
+
+    //-------------------------------------------------------
+    // "product list" Command
+    //-------------------------------------------------------
     products.command('list')
         .description('List products')
         .option('-p, --page <number>', 'Page number', '1')
@@ -48,6 +52,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "product show" Command
+    //-------------------------------------------------------
     products.command('show <sku>')
         .description('Show product details')
         .option('-f, --format <type>', 'Output format (text, json, xml)', 'text')
@@ -165,6 +173,10 @@ Examples:
 
     const types = products.command('type').description('Manage product types');
 
+
+    //-------------------------------------------------------
+    // "product type list" Command
+    //-------------------------------------------------------
     types.command('list')
         .description('List available product types')
         .addHelpText('after', `
@@ -182,6 +194,10 @@ Examples:
 
     const attributes = products.command('attribute').description('Manage product attributes');
 
+
+    //-------------------------------------------------------
+    // "product attribute list" Command
+    //-------------------------------------------------------
     attributes.command('list')
         .description('List product attributes')
         .option('-p, --page <number>', 'Page number', '1')
@@ -213,6 +229,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "product attribute show" Command
+    //-------------------------------------------------------
     attributes.command('show <attributeCode>')
         .description('Show product attribute details')
         .option('-f, --format <type>', 'Output format (text, json, xml)', 'text')
@@ -293,6 +313,10 @@ Examples:
         });
 
     const attributeTypes = attributes.command('type').description('Manage attribute types');
+
+    //-------------------------------------------------------
+    // "product attribute type list" Command
+    //-------------------------------------------------------
     attributeTypes.command('list')
         .description('List product attribute types')
         .addHelpText('after', `