mage-remote-run 1.3.1 → 1.4.0

package/bin/mage-remote-run.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { Command } from 'commander';
-import { loadConfig } from '../lib/config.js';
+import { loadConfig, saveConfig } from '../lib/config.js';
 import chalk from 'chalk';
 
 import { createRequire } from 'module';
@@ -78,20 +78,23 @@ const profile = await getActiveProfile();
 // but we can pass a way to get it or just pass null for now if not used at startup.
 // Also mcpServer is not running here unless mcp command is used.
 const appContext = {
-    program,
-    config: await loadConfig(), // Re-load or reuse config
-    profile,
-    eventBus,
-    events,
-    createClient
+  program,
+  config: await loadConfig(), // Re-load or reuse config
+  saveConfig,
+  profile,
+  eventBus,
+  events,
+  createClient
 };
 
 const pluginLoader = new PluginLoader(appContext);
 await pluginLoader.loadPlugins();
 
 eventBus.emit(events.INIT, appContext);
+import { registerVirtualCommands } from '../lib/commands/virtual.js';
 
 registerCommands(program, profile);
+registerVirtualCommands(program, appContext.config, profile);
 
 program.hook('preAction', async (thisCommand, actionCommand) => {
   eventBus.emit(events.BEFORE_COMMAND, { thisCommand, actionCommand, profile });
@@ -113,7 +116,7 @@ program.hook('preAction', async (thisCommand, actionCommand) => {
 });
 
 program.hook('postAction', async (thisCommand, actionCommand) => {
-    eventBus.emit(events.AFTER_COMMAND, { thisCommand, actionCommand, profile });
+  eventBus.emit(events.AFTER_COMMAND, { thisCommand, actionCommand, profile });
 });
 
 import { expandCommandAbbreviations } from '../lib/command-helper.js';

package/lib/commands/orders.js

@@ -32,6 +32,7 @@ Examples:
   $ mage-remote-run order list --fields "increment_id,grand_total,customer_email"
   $ mage-remote-run order list --filter "grand_total>=100" --add-fields "base_grand_total,billing_address.city"
   $ mage-remote-run order list --filter "status=pending" --filter "grand_total>100"
+  $ mage-remote-run order list --filter "created_at>=2024-01-01"
   $ mage-remote-run order list --sort "grand_total:DESC" --sort "created_at:ASC"
   $ mage-remote-run order list --format json
 `);

package/lib/commands/products.js

@@ -25,6 +25,7 @@ Examples:
   $ mage-remote-run product list --sort-by price --sort-order DESC
   $ mage-remote-run product list --sort "price:DESC" "sku:ASC"
   $ mage-remote-run product list --filter "type_id=simple" "price>=100"
+  $ mage-remote-run product list --filter "created_at>=2024-01-01"
   $ mage-remote-run product list --fields "sku,name,price"
   $ mage-remote-run product list --add-fields "created_at,updated_at"
 `);

package/lib/commands/virtual.js

@@ -0,0 +1,295 @@
+import { createClient } from '../api/factory.js';
+import { handleError, formatOutput, addFormatOption, addFilterOption, addSortOption, addPaginationOptions, buildSearchCriteria, buildSortCriteria } from '../utils.js';
+import chalk from 'chalk';
+
+function getInputDefinitions(cmdDef) {
+    const definitions = new Map();
+    const sources = [
+        ['parameter', cmdDef.parameter],
+        ['parameter', cmdDef.parameters],
+        ['option', cmdDef.option],
+        ['option', cmdDef.options]
+    ];
+
+    for (const [source, group] of sources) {
+        if (!group || typeof group !== 'object') {
+            continue;
+        }
+
+        for (const [key, definition] of Object.entries(group)) {
+            definitions.set(key, {
+                ...definition,
+                _source: source
+            });
+        }
+    }
+
+    return Object.fromEntries(definitions);
+}
+
+function buildOptionFlags(key, definition = {}) {
+    if (definition.flags) {
+        return definition.flags;
+    }
+
+    const shortFlag = definition.short
+        ? `${definition.short.startsWith('-') ? definition.short : `-${definition.short}`}, `
+        : '';
+    const longFlag = definition.long
+        ? (definition.long.startsWith('-') ? definition.long : `--${definition.long}`)
+        : `--${key}`;
+
+    if (definition.type === 'boolean') {
+        return `${shortFlag}${longFlag}`;
+    }
+
+    const argName = definition.argName || 'value';
+    const valuePlaceholder = definition.variadic ? `<${argName}...>` : `<${argName}>`;
+    return `${shortFlag}${longFlag} ${valuePlaceholder}`;
+}
+
+function getFlagTokens(flags) {
+    return flags
+        .split(',')
+        .map(flag => flag.trim().split(' ')[0])
+        .filter(Boolean);
+}
+
+function hasOption(command, flags) {
+    const requestedFlags = new Set(getFlagTokens(flags));
+
+    return (command.options || []).some(option => {
+        const existingFlags = [option.short, option.long, ...(option.flags ? getFlagTokens(option.flags) : [])]
+            .filter(Boolean);
+
+        return existingFlags.some(flag => requestedFlags.has(flag));
+    });
+}
+
+function addCommandOption(command, flags, description, defaultValue, required = false) {
+    if (hasOption(command, flags)) {
+        return command;
+    }
+
+    if (required) {
+        if (defaultValue !== undefined) {
+            return command.requiredOption(flags, description, defaultValue);
+        }
+
+        return command.requiredOption(flags, description);
+    }
+
+    if (defaultValue !== undefined) {
+        return command.option(flags, description, defaultValue);
+    }
+
+    return command.option(flags, description);
+}
+
+function normalizeListValue(value) {
+    if (value === undefined || value === null) {
+        return [];
+    }
+
+    if (Array.isArray(value)) {
+        return value.filter(item => typeof item === 'string' && item.trim().length > 0);
+    }
+
+    if (typeof value === 'string' && value.trim().length > 0) {
+        return [value];
+    }
+
+    return [];
+}
+
+function interpolateTemplateValue(template, values) {
+    if (typeof template !== 'string' || template.length === 0) {
+        return template;
+    }
+
+    return template
+        .replace(/\$\{([a-zA-Z0-9_]+)\}/g, (match, key) => {
+            const value = values[key];
+            return value === undefined || value === null ? match : String(value);
+        })
+        .replace(/\{:\s*([a-zA-Z0-9_]+)\s*\}/g, (match, key) => {
+            const value = values[key];
+            return value === undefined || value === null ? match : String(value);
+        })
+        .replace(/:([a-zA-Z0-9_]+)/g, (match, key) => {
+            const value = values[key];
+            return value === undefined || value === null ? match : String(value);
+        });
+}
+
+export function registerVirtualCommands(program, config, profile) {
+    if (!config || !config.commands || !Array.isArray(config.commands)) {
+        return;
+    }
+
+    for (const cmdDef of config.commands) {
+        // Validation namespace vs command
+        if (!cmdDef.name) {
+            if (process.env.DEBUG) {
+                console.error(chalk.yellow(`Skipping invalid virtual command definition without name: ${JSON.stringify(cmdDef)}`));
+            }
+            continue;
+        }
+
+        // Filtering by connection_types
+        if (cmdDef.connection_types && Array.isArray(cmdDef.connection_types)) {
+            if (!profile || !profile.type || !cmdDef.connection_types.includes(profile.type)) {
+                continue; // Skip if profile type is not in connection_types
+            }
+        }
+
+        // Command Generation: Find or create subcommands
+        let currentCmd = program;
+        const parts = cmdDef.name.split(' ');
+
+        for (let i = 0; i < parts.length; i++) {
+            const part = parts[i];
+            const existing = currentCmd.commands.find(c => c.name() === part);
+            if (existing) {
+                currentCmd = existing;
+            } else {
+                currentCmd = currentCmd.command(part);
+            }
+        }
+
+        if (cmdDef.description) {
+            currentCmd.description(cmdDef.description);
+        } else if (cmdDef.endpoint && cmdDef.method) {
+            currentCmd.description(`Virtual command to execute ${cmdDef.method.toUpperCase()} ${cmdDef.endpoint}`);
+        }
+
+        if (cmdDef.summary) {
+            currentCmd.summary(cmdDef.summary);
+        } else if (cmdDef.description) {
+            // Fallback to description if summary is not explicitly provided
+            // We use a shortened version if it's too long
+            const summaryText = cmdDef.description.split('\n')[0];
+            currentCmd.summary(summaryText.length > 80 ? summaryText.substring(0, 77) + '...' : summaryText);
+        } else if (cmdDef.endpoint && cmdDef.method) {
+            currentCmd.summary(`${cmdDef.method.toUpperCase()} ${cmdDef.endpoint}`);
+        }
+
+        // It is just a namespace wrapper if there's no endpoint or method
+        if (!cmdDef.endpoint || !cmdDef.method) {
+            continue;
+        }
+
+        if (!hasOption(currentCmd, '-f, --format <type>')) {
+            addFormatOption(currentCmd);
+        }
+
+        // Map parameters to options
+        const inputDefinitions = getInputDefinitions(cmdDef);
+        const parameterKeys = Object.keys(inputDefinitions);
+        for (const key of parameterKeys) {
+            const paramDef = inputDefinitions[key];
+            const flags = buildOptionFlags(key, paramDef);
+            const desc = paramDef.description || `${paramDef._source === 'option' ? 'Option' : 'Parameter'} ${key}`;
+
+            addCommandOption(currentCmd, flags, desc, paramDef.default, paramDef.required);
+        }
+
+        // Add filter and sort options if enabled
+        if (cmdDef.supports_filters !== false) {
+             if (!hasOption(currentCmd, '--filter <filters...>')) {
+                 addFilterOption(currentCmd);
+             }
+             if (!hasOption(currentCmd, '--sort-by <field>')) {
+                 addSortOption(currentCmd);
+             }
+             if (!hasOption(currentCmd, '-p, --page <number>')) {
+                 addPaginationOptions(currentCmd);
+             }
+        }
+
+        // Add action
+        currentCmd.action(async (options) => {
+            try {
+                const client = await createClient();
+                const method = cmdDef.method.toUpperCase();
+                let requestPath = cmdDef.endpoint;
+
+                const payload = {};
+                let queryParams = {};
+
+                // Process options based on whether they are in the endpoint path
+                for (const key of parameterKeys) {
+                    const value = options[key];
+                    if (value === undefined || value === null) {
+                        continue;
+                    }
+
+                    const placeholder = `:${key}`;
+                    if (requestPath.includes(placeholder)) {
+                        requestPath = requestPath.replace(placeholder, encodeURIComponent(value));
+                    } else {
+                        if (['POST', 'PUT', 'PATCH'].includes(method)) {
+                            // Can be mapped to nested objects if needed, but for now simple flat payload
+                            payload[key] = value;
+                        } else {
+                            queryParams[key] = value;
+                        }
+                    }
+                }
+
+                if (cmdDef.supports_filters !== false) {
+                     const predefinedFilters = normalizeListValue(cmdDef.filters ?? cmdDef.filter)
+                        .map(filter => interpolateTemplateValue(filter, options));
+                     const mergedFilterOptions = {
+                        ...options,
+                        filter: [
+                            ...predefinedFilters,
+                            ...normalizeListValue(options.filter)
+                        ]
+                     };
+                     const { params: searchParams } = buildSearchCriteria(mergedFilterOptions);
+                     const { params: sortParams } = buildSortCriteria(options);
+
+                     queryParams = {
+                        ...queryParams,
+                        ...searchParams,
+                        ...sortParams
+                     };
+                }
+
+                // Clean up any remaining path placeholders if they had defaults or were optional
+                requestPath = requestPath.replace(/:[a-zA-Z0-9_]+/g, '');
+
+                const reqConfig = {
+                    headers: {
+                        'Content-Type': 'application/json'
+                    }
+                };
+
+                if (options.format === 'json') reqConfig.headers.Accept = 'application/json';
+                else if (options.format === 'xml') reqConfig.headers.Accept = 'application/xml';
+
+                const response = await client.request(
+                    method,
+                    requestPath,
+                    Object.keys(payload).length > 0 ? payload : undefined,
+                    Object.keys(queryParams).length > 0 ? queryParams : undefined,
+                    reqConfig
+                );
+
+                if (formatOutput(options, response)) {
+                    return;
+                }
+
+                if (typeof response === 'object') {
+                    console.log(JSON.stringify(response, null, 2));
+                } else {
+                    console.log(response);
+                }
+
+            } catch (error) {
+                handleError(error);
+            }
+        });
+    }
+}

package/lib/mcp.js

@@ -158,6 +158,10 @@ export async function startMcpServer(options) {
         let token = options.token || process.env.MAGE_REMOTE_RUN_MCP_TOKEN;
 
         if (!token) {
+            if (!process.stderr.isTTY) {
+                throw new Error('Authentication token is required for HTTP transport in non-TTY environments. Please provide it via --token or MAGE_REMOTE_RUN_MCP_TOKEN environment variable.');
+            }
+
             token = crypto.randomBytes(16).toString('hex');
             console.error(chalk.yellow(`--------------------------------------------------------------------------------`));
             console.error(chalk.yellow(`MCP Server Authentication Token: `) + chalk.green.bold(token));

package/lib/plugin-loader.js

@@ -41,28 +41,34 @@ export class PluginLoader {
             // 2. Try global node_modules (npm)
             try {
                 const globalNpmPath = path.join(globalDirs.npm.packages, pluginName);
-                if (fs.existsSync(globalNpmPath)) {
+                const npmExists = await fs.promises.access(globalNpmPath).then(() => true).catch(() => false);
+                if (npmExists) {
                     const pkgJsonPath = path.join(globalNpmPath, 'package.json');
-                    if (fs.existsSync(pkgJsonPath)) {
-                        const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+                    const pkgJsonExists = await fs.promises.access(pkgJsonPath).then(() => true).catch(() => false);
+                    if (pkgJsonExists) {
+                        const pkgContent = await fs.promises.readFile(pkgJsonPath, 'utf-8');
+                        const pkg = JSON.parse(pkgContent);
                         const mainFile = pkg.main || 'index.js';
                         pluginPath = path.join(globalNpmPath, mainFile);
                     } else {
-                         pluginPath = path.join(globalNpmPath, 'index.js');
+                        pluginPath = path.join(globalNpmPath, 'index.js');
                     }
                 } else {
                     // 3. Try global node_modules (yarn)
-                     const globalYarnPath = path.join(globalDirs.yarn.packages, pluginName);
-                     if (fs.existsSync(globalYarnPath)) {
+                    const globalYarnPath = path.join(globalDirs.yarn.packages, pluginName);
+                    const yarnExists = await fs.promises.access(globalYarnPath).then(() => true).catch(() => false);
+                    if (yarnExists) {
                         const pkgJsonPath = path.join(globalYarnPath, 'package.json');
-                        if (fs.existsSync(pkgJsonPath)) {
-                            const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, 'utf-8'));
+                        const pkgJsonExists = await fs.promises.access(pkgJsonPath).then(() => true).catch(() => false);
+                        if (pkgJsonExists) {
+                            const pkgContent = await fs.promises.readFile(pkgJsonPath, 'utf-8');
+                            const pkg = JSON.parse(pkgContent);
                             const mainFile = pkg.main || 'index.js';
                             pluginPath = path.join(globalYarnPath, mainFile);
                         } else {
-                             pluginPath = path.join(globalYarnPath, 'index.js');
+                            pluginPath = path.join(globalYarnPath, 'index.js');
                         }
-                     }
+                    }
                 }
             } catch (globalErr) {
                 // Ignore global errors, proceed to throw if not found
@@ -81,18 +87,79 @@ export class PluginLoader {
             console.log(chalk.gray(`Loading plugin from: ${pluginUrl}`));
         }
 
-        const pluginModule = await import(pluginUrl);
+        // Find plugin root to load static config
+        let currentDir = path.dirname(pluginPath);
+        let pluginRoot = currentDir;
+        while (currentDir !== path.parse(currentDir).root) {
+            const pkgPath = path.join(currentDir, 'package.json');
+            const pkgExists = await fs.promises.access(pkgPath).then(() => true).catch(() => false);
+            if (pkgExists) {
+                pluginRoot = currentDir;
+                break;
+            }
+            currentDir = path.dirname(currentDir);
+        }
+
+        // Try to load static configuration
+        let staticConfig = null;
+        const mageConfigPath = path.join(pluginRoot, 'mage-remote-run.json');
+        const pkgPath = path.join(pluginRoot, 'package.json');
+
+        if (await fs.promises.access(mageConfigPath).then(() => true).catch(() => false)) {
+            staticConfig = JSON.parse(await fs.promises.readFile(mageConfigPath, 'utf8'));
+        } else if (await fs.promises.access(pkgPath).then(() => true).catch(() => false)) {
+            const pkg = JSON.parse(await fs.promises.readFile(pkgPath, 'utf8'));
+            if (pkg['mage-remote-run']) {
+                staticConfig = pkg['mage-remote-run'];
+            }
+        }
+
+        if (staticConfig) {
+            if (process.env.DEBUG) {
+                console.log(chalk.gray(`Found static configuration for plugin: ${pluginName}`));
+            }
+            // Merge static config into appContext.config
+            if (staticConfig.commands && Array.isArray(staticConfig.commands)) {
+                if (!this.appContext.config.commands) {
+                    this.appContext.config.commands = [];
+                }
+                this.appContext.config.commands.push(...staticConfig.commands);
+            }
+        }
+
+        let pluginModule = null;
+        try {
+            pluginModule = await import(pluginUrl);
+        } catch (err) {
+            if (process.env.DEBUG) {
+                console.error(chalk.yellow(`Could not import plugin module for ${pluginName} at ${pluginUrl}: ${err.message}`));
+            }
+        }
 
         if (pluginModule && pluginModule.default) {
             if (typeof pluginModule.default === 'function') {
                  await pluginModule.default(this.appContext);
                  this.plugins.push({ name: pluginName, module: pluginModule });
                  if (process.env.DEBUG) {
-                     console.log(chalk.gray(`Loaded plugin: ${pluginName}`));
+                     console.log(chalk.gray(`Loaded plugin script: ${pluginName}`));
                  }
             } else {
-                console.warn(chalk.yellow(`Plugin ${pluginName} does not export a default function.`));
+                if (!staticConfig) {
+                    console.warn(chalk.yellow(`Plugin ${pluginName} does not export a default function and has no static config.`));
+                } else {
+                    this.plugins.push({ name: pluginName, module: pluginModule });
+                    if (process.env.DEBUG) {
+                        console.log(chalk.gray(`Loaded plugin config only: ${pluginName}`));
+                    }
+                }
             }
+        } else if (staticConfig) {
+             this.plugins.push({ name: pluginName, module: null });
+             if (process.env.DEBUG) {
+                 console.log(chalk.gray(`Loaded plugin config only: ${pluginName}`));
+             }
+        } else {
+             console.warn(chalk.yellow(`Plugin ${pluginName} could not be loaded because it has no default export and no static config.`));
         }
     }
 }

package/lib/prompts.js

@@ -1,4 +1,4 @@
-import { input, select, password, confirm } from '@inquirer/prompts';
+import { input, select, password } from '@inquirer/prompts';
 
 export async function askForProfileSettings(defaults = {}) {
     const type = await select({

package/package.json

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