mage-remote-run 0.11.0 → 0.13.0

package/bin/mage-remote-run.js

@@ -38,40 +38,12 @@ program
 
 
 
-import { registerWebsitesCommands } from '../lib/commands/websites.js';
-import { registerStoresCommands } from '../lib/commands/stores.js';
-import { registerConnectionCommands } from '../lib/commands/connections.js';
-import { registerCustomersCommands } from '../lib/commands/customers.js';
-import { registerOrdersCommands } from '../lib/commands/orders.js';
-import { registerEavCommands } from '../lib/commands/eav.js';
-import { registerProductsCommands } from '../lib/commands/products.js';
-import { registerCompanyCommands } from '../lib/commands/company.js';
-import { registerTaxCommands } from '../lib/commands/tax.js';
-import { registerInventoryCommands } from '../lib/commands/inventory.js';
-import { registerAdobeIoEventsCommands } from '../lib/commands/adobe-io-events.js';
-import { registerWebhooksCommands } from '../lib/commands/webhooks.js';
+import { registerCommands } from '../lib/command-registry.js';
 import { getActiveProfile } from '../lib/config.js';
 
-registerConnectionCommands(program);
-
 const profile = await getActiveProfile();
 
-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);
-    }
-}
+registerCommands(program, profile);
 
 program.hook('preAction', async (thisCommand, actionCommand) => {
     // Check if we have an active profile and if format is not json/xml
@@ -89,70 +61,7 @@ program.hook('preAction', async (thisCommand, actionCommand) => {
     }
 });
 
-function resolveCommandMatch(parent, token) {
-    const tokenLower = token.toLowerCase();
-
-    // Check for exact match first
-    const exactMatch = parent.commands.find((cmd) => {
-        return cmd.name().toLowerCase() === tokenLower;
-    });
-
-    if (exactMatch) {
-        return {
-            match: exactMatch,
-            matches: [exactMatch]
-        };
-    }
-
-    const matches = parent.commands.filter((cmd) => {
-        const name = cmd.name().toLowerCase();
-        if (name.startsWith(tokenLower)) return true;
-        const aliases = cmd.aliases ? cmd.aliases() : [];
-        return aliases.some((alias) => alias.toLowerCase().startsWith(tokenLower));
-    });
-
-    return {
-        match: matches.length === 1 ? matches[0] : null,
-        matches
-    };
-}
-
-function expandCommandAbbreviations(rootCommand, argv) {
-    const expanded = [];
-    let current = rootCommand;
-    const path = [];
-
-    for (let i = 0; i < argv.length; i += 1) {
-        const token = argv[i];
-        if (token.startsWith('-')) {
-            expanded.push(token);
-            continue;
-        }
-
-        if (!current.commands || current.commands.length === 0) {
-            expanded.push(...argv.slice(i));
-            break;
-        }
-
-        const { match, matches } = resolveCommandMatch(current, token);
-        if (!match) {
-            if (matches.length > 1) {
-                const parentName = path.length > 0 ? path.join(' ') : current.name();
-                const options = matches.map((cmd) => cmd.name()).join(', ');
-                console.error(`Ambiguous command "${token}" under "${parentName}". Options: ${options}.`);
-                process.exit(1);
-            }
-            expanded.push(token);
-            continue;
-        }
-
-        expanded.push(match.name());
-        current = match;
-        path.push(match.name());
-    }
-
-    return expanded;
-}
+import { expandCommandAbbreviations } from '../lib/command-helper.js';
 
 // Check for first run (no profiles configured and no arguments or just help)
 // We need to check args length.
@@ -177,7 +86,15 @@ if (!hasProfiles && args.length === 0) {
     args = ['connection', 'add'];
 }
 
-args = expandCommandAbbreviations(program, args);
+try {
+    args = expandCommandAbbreviations(program, args);
+} catch (e) {
+    if (e.isAmbiguous) {
+        console.error(e.message);
+        process.exit(1);
+    }
+    throw e;
+}
 process.argv = [...process.argv.slice(0, 2), ...args];
 
 program.parse(process.argv);

package/lib/command-helper.js

@@ -0,0 +1,100 @@
+
+export function resolveCommandMatch(parent, token) {
+    const tokenLower = token.toLowerCase();
+
+    // Check for exact match first
+    const exactMatch = parent.commands.find((cmd) => {
+        return cmd.name().toLowerCase() === tokenLower;
+    });
+
+    if (exactMatch) {
+        return {
+            match: exactMatch,
+            matches: [exactMatch]
+        };
+    }
+
+    const matches = parent.commands.filter((cmd) => {
+        const name = cmd.name().toLowerCase();
+        if (name.startsWith(tokenLower)) return true;
+        const aliases = cmd.aliases ? cmd.aliases() : [];
+        return aliases.some((alias) => alias.toLowerCase().startsWith(tokenLower));
+    });
+
+    return {
+        match: matches.length === 1 ? matches[0] : null,
+        matches
+    };
+}
+
+export function expandCommandAbbreviations(rootCommand, argv) {
+    const expanded = [];
+    let current = rootCommand;
+    const path = [];
+
+    for (let i = 0; i < argv.length; i += 1) {
+        const token = argv[i];
+        if (token.startsWith('-')) {
+            expanded.push(token);
+            continue;
+        }
+
+        if (!current.commands || current.commands.length === 0) {
+            expanded.push(...argv.slice(i));
+            break;
+        }
+
+        // Feature: Support colon separators
+        // If the token contains colons, try to split it and resolve parts
+        if (token.includes(':')) {
+            const parts = token.split(':');
+            const originalArgv = argv.slice(0); // copy
+
+            // Modify argv effectively for this lookahead
+            const remainingArgv = [...parts, ...argv.slice(i + 1)];
+
+            // Recursively expand the new sequence from current point
+            // We need to resolve from 'current' but since expandCommandAbbreviations takes rootCommand, 
+            // we should probably just verify if these parts are valid commands.
+            // But expandCommandAbbreviations is designed to walk from root.
+            // However, we are currently at 'current'.
+
+            // To properly handle "cust:list" where "cust" is from root, we can just replace the token in the list
+            // and continue loop, IF the first part matches something.
+
+            // Let's check if the first part matches a command in current scope
+            const firstPart = parts[0];
+            const result = resolveCommandMatch(current, firstPart);
+
+            if (result.match) {
+                // If the first part matches, we replace the current token with the split parts
+                // and effectively 'restart' processing or just insert them into argv and decrement i to re-process first part
+                argv.splice(i, 1, ...parts);
+                i--; // Stay on same index to process the first part of the split
+                continue;
+            }
+        }
+
+        const { match, matches } = resolveCommandMatch(current, token);
+        if (!match) {
+            if (matches.length > 1) {
+                const parentName = path.length > 0 ? path.join(' ') : (current.name() !== 'mage-remote-run' ? current.name() : 'root');
+                const options = matches.map((cmd) => cmd.name()).join(', ');
+                let errorMessage = `Ambiguous command "${token}" under "${parentName}". Options: ${options}.`;
+                // If this is a script, we might not want to console.error directly if we want to test it easily,
+                // but complying with original code which did process.exit
+                const error = new Error(errorMessage);
+                error.isAmbiguous = true;
+                throw error;
+            }
+            expanded.push(token);
+            continue;
+        }
+
+        expanded.push(match.name());
+        current = match;
+        path.push(match.name());
+    }
+
+    return expanded;
+}

package/lib/command-registry.js

@@ -0,0 +1,35 @@
+import { registerWebsitesCommands } from './commands/websites.js';
+import { registerStoresCommands } from './commands/stores.js';
+import { registerConnectionCommands } from './commands/connections.js';
+import { registerCustomersCommands } from './commands/customers.js';
+import { registerOrdersCommands } from './commands/orders.js';
+import { registerEavCommands } from './commands/eav.js';
+import { registerProductsCommands } from './commands/products.js';
+import { registerCompanyCommands } from './commands/company.js';
+import { registerTaxCommands } from './commands/tax.js';
+import { registerInventoryCommands } from './commands/inventory.js';
+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);
+        }
+    }
+}

package/lib/commands/adobe-io-events.js

@@ -5,6 +5,10 @@ import chalk from 'chalk';
 export function registerAdobeIoEventsCommands(program) {
     const adobeIoEvents = program.command('adobe-io-event').description('Manage Adobe I/O Events');
 
+
+    //-------------------------------------------------------
+    // "adobe-io-event check-configuration" Command
+    //-------------------------------------------------------
     adobeIoEvents.command('check-configuration')
         .description('Check Adobe I/O Event configuration')
         .option('-f, --format <type>', 'Output format (text, json, xml)', 'text')

package/lib/commands/company.js

@@ -5,6 +5,10 @@ import chalk from 'chalk';
 export function registerCompanyCommands(program) {
     const company = program.command('company').description('Manage companies');
 
+
+    //-------------------------------------------------------
+    // "company list" Command
+    //-------------------------------------------------------
     company.command('list')
         .description('List companies')
         .option('-p, --page <number>', 'Page number', '1')
@@ -56,6 +60,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "company show" Command
+    //-------------------------------------------------------
     company.command('show <companyId>')
         .description('Show company details')
         .option('-f, --format <type>', 'Output format (text, json, xml)', 'text')

package/lib/commands/connections.js

@@ -60,6 +60,10 @@ async function configureAndTestConnection(name, initialSettings = {}) {
 export function registerConnectionCommands(program) {
     const connections = program.command('connection').description('Manage mage-remote-run connection profiles');
 
+
+    //-------------------------------------------------------
+    // "connection add" Command
+    //-------------------------------------------------------
     connections.command('add')
         .description('Configure a new connection profile')
         .addHelpText('after', `
@@ -106,6 +110,10 @@ Examples:
             }
         });
 
+
+    //-------------------------------------------------------
+    // "connection list" Command
+    //-------------------------------------------------------
     connections.command('list')
         .description('List connection profiles')
         .addHelpText('after', `
@@ -125,6 +133,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "connection search" Command
+    //-------------------------------------------------------
     connections.command('search <query>')
         .description('Search connection profiles')
         .addHelpText('after', `
@@ -140,6 +152,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "connection delete" Command
+    //-------------------------------------------------------
     connections.command('delete <name>')
         .description('Delete a connection profile')
         .addHelpText('after', `
@@ -161,6 +177,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "connection edit" Command
+    //-------------------------------------------------------
     connections.command('edit [name]')
         .description('Edit a connection profile')
         .addHelpText('after', `
@@ -208,6 +228,10 @@ Examples:
             }
         });
 
+
+    //-------------------------------------------------------
+    // "connection test" Command
+    //-------------------------------------------------------
     connections.command('test')
         .description('Test connection(s)')
         .option('--all', 'Test all configured connections')
@@ -270,6 +294,10 @@ Examples:
                 if (process.env.DEBUG) console.error(e);
             }
         });
+
+    //-------------------------------------------------------
+    // "connection status" Command
+    //-------------------------------------------------------
     connections.command('status')
         .description('Show current configuration status')
         .addHelpText('after', `
@@ -294,6 +322,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "connection select" Command
+    //-------------------------------------------------------
     connections.command('select')
         .description('Select the active connection profile (aliases: change, switch)')
         .aliases(['switch', 'change'])
@@ -323,6 +355,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "connection clear-token-cache" Command
+    //-------------------------------------------------------
     connections.command('clear-token-cache')
         .description('Clear cached access tokens')
         .addHelpText('after', `
@@ -336,6 +372,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "connection status-header" Command
+    //-------------------------------------------------------
     connections.command('status-header <state>')
         .description('Enable or disable the active connection header (on|off)')
         .addHelpText('after', `

package/lib/commands/console.js

@@ -0,0 +1,269 @@
+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'));
+
+            // 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;
+                });
+                // 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 overrides AFTER registration to catch all commands
+            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
+            });
+
+            const defaultEval = r.eval;
+
+            // Capture default completer
+            const defaultCompleter = r.completer;
+
+            // Custom completer
+            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 = '';
+                let contextParts = [];
+
+                if (line.match(/\s$/)) {
+                    current = '';
+                    contextParts = parts.filter(p => p.length > 0);
+                } else {
+                    current = parts.pop();
+                    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;
+
+                    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 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 to support both CLI commands and JS
+            const myEval = async (cmd, context, filename, callback) => {
+                cmd = cmd.trim();
+
+                if (!cmd) {
+                    callback(null);
+                    return;
+                }
+
+                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()}`);
+                    });
+                    console.log('');
+                    callback(null);
+                    return;
+                }
+
+                if (cmd === 'help') {
+                    localProgram.outputHelp();
+                    callback(null);
+                    return;
+                }
+
+                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);
+                        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) {
+                                // 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;
+                        }
+
+                        const firstWord = expandedArgs[0];
+                        const knownCommands = localProgram.commands.map(c => c.name());
+
+                        if (knownCommands.includes(firstWord)) {
+                            // Valid command found
+                            try {
+                                r.pause();
+                                await localProgram.parseAsync(['node', 'mage-remote-run', ...expandedArgs]);
+
+                                // Restore REPL state
+                                if (process.stdin.isTTY) {
+                                    process.stdin.setRawMode(true);
+                                }
+                                process.stdin.resume();
+                                r.resume();
+                                r.displayPrompt();
+                            } catch (e) {
+                                if (process.stdin.isTTY) {
+                                    process.stdin.setRawMode(true);
+                                }
+                                process.stdin.resume();
+                                r.resume();
+                                if (e.code === 'commander.helpDisplayed') {
+                                    // Help was displayed, clean exit for us
+                                } else if (e.code === 'commander.unknownOption' || e.code === 'commander.unknownCommand') {
+                                    console.error(chalk.red(e.message));
+                                } else {
+                                    if (e.code) {
+                                        // Likely a commander exit error we rethrew
+                                    } else {
+                                        console.error(chalk.red('Command execution error:'), e);
+                                    }
+                                }
+                            }
+                            callback(null);
+                            return;
+                        }
+                    }
+                } catch (e) {
+                    // unexpected error during CLI detection
+                }
+
+                // Fallback to default eval which supports top-level await
+                defaultEval.call(r, cmd, context, filename, callback);
+            };
+
+            // Override the eval function
+            r.eval = myEval;
+
+            // 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.'));
+            };
+
+            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', `

package/lib/commands/stores.js

@@ -9,6 +9,10 @@ export function registerStoresCommands(program) {
     // Store Groups
     const groups = stores.command('group').description('Manage store groups');
 
+
+    //-------------------------------------------------------
+    // "store group list" Command
+    //-------------------------------------------------------
     groups.command('list')
         .description('List store groups')
         .option('-f, --format <type>', 'Output format (text, json, xml)', 'text')
@@ -40,6 +44,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "store group search" Command
+    //-------------------------------------------------------
     groups.command('search <query>')
         .description('Search store groups')
         .addHelpText('after', `
@@ -56,6 +64,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "store group delete" Command
+    //-------------------------------------------------------
     groups.command('delete <id>')
         .description('Delete store group')
         .addHelpText('after', `
@@ -72,6 +84,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "store group edit" Command
+    //-------------------------------------------------------
     groups.command('edit <id>')
         .description('Edit store group')
         .addHelpText('after', `
@@ -99,6 +115,10 @@ Examples:
     // Store Views
     const views = stores.command('view').description('Manage store views');
 
+
+    //-------------------------------------------------------
+    // "store view list" Command
+    //-------------------------------------------------------
     views.command('list')
         .description('List store views')
         .option('-f, --format <type>', 'Output format (text, json, xml)', 'text')
@@ -130,6 +150,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "store view search" Command
+    //-------------------------------------------------------
     views.command('search <query>')
         .description('Search store views')
         .addHelpText('after', `
@@ -146,6 +170,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "store view delete" Command
+    //-------------------------------------------------------
     views.command('delete <id>')
         .description('Delete store view')
         .addHelpText('after', `
@@ -162,6 +190,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "store view edit" Command
+    //-------------------------------------------------------
     views.command('edit <id>')
         .description('Edit store view')
         .addHelpText('after', `
@@ -189,6 +221,10 @@ Examples:
     // Store Configs
     const configs = stores.command('config').description('Manage store configurations');
 
+
+    //-------------------------------------------------------
+    // "store config list" Command
+    //-------------------------------------------------------
     configs.command('list')
         .description('List store configurations')
         .addHelpText('after', `

package/lib/commands/tax.js

@@ -7,6 +7,10 @@ export function registerTaxCommands(program) {
 
     const taxClass = tax.command('class').description('Manage tax classes');
 
+
+    //-------------------------------------------------------
+    // "tax class list" Command
+    //-------------------------------------------------------
     taxClass.command('list')
         .description('List tax classes')
         .option('-p, --page <number>', 'Page number', '1')
@@ -49,6 +53,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "tax class show" Command
+    //-------------------------------------------------------
     taxClass.command('show <id>')
         .description('Show tax class details')
         .addHelpText('after', `

package/lib/commands/webhooks.js

@@ -5,6 +5,10 @@ import chalk from 'chalk';
 export function registerWebhooksCommands(program) {
     const webhooks = program.command('webhook').description('Manage webhooks');
 
+
+    //-------------------------------------------------------
+    // "webhook list" Command
+    //-------------------------------------------------------
     webhooks.command('list')
         .description('List available webhooks')
         .option('-p, --page <number>', 'Page number', '1')

package/lib/commands/websites.js

@@ -6,6 +6,10 @@ import inquirer from 'inquirer';
 export function registerWebsitesCommands(program) {
     const websites = program.command('website').description('Manage websites');
 
+
+    //-------------------------------------------------------
+    // "website list" Command
+    //-------------------------------------------------------
     websites.command('list')
         .description('List all websites')
         .option('-f, --format <type>', 'Output format (text, json, xml)', 'text')
@@ -37,6 +41,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "website search" Command
+    //-------------------------------------------------------
     websites.command('search <query>')
         .description('Search websites by code or name (local filter)')
         .addHelpText('after', `
@@ -55,6 +63,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "website delete" Command
+    //-------------------------------------------------------
     websites.command('delete <id>')
         .description('Delete a website by ID')
         .addHelpText('after', `
@@ -77,6 +89,10 @@ Examples:
             } catch (e) { handleError(e); }
         });
 
+
+    //-------------------------------------------------------
+    // "website edit" Command
+    //-------------------------------------------------------
     websites.command('edit <id>')
         .description('Edit a website')
         .addHelpText('after', `

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mage-remote-run",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "The remote swiss army knife for Magento Open Source, Mage-OS, Adobe Commerce",
   "main": "index.js",
   "scripts": {