mage-remote-run 0.24.0 → 0.26.0

package/lib/api/paas.js

@@ -40,15 +40,21 @@ export class PaasClient extends ApiClient {
                 const baseURL = config.baseURL || '';
                 const url = baseURL.replace(/\/$/, '') + '/' + config.url.replace(/^\//, ''); // rudimentary join
 
+                // Determine signature method (default to HMAC-SHA256)
+                const signatureMethod = (this.config.auth.signatureMethod || 'hmac-sha256').toLowerCase();
+                const isSha1 = signatureMethod === 'hmac-sha1' || signatureMethod === 'sha1';
+                const methodStr = isSha1 ? 'HMAC-SHA1' : 'HMAC-SHA256';
+                const hashAlgo = isSha1 ? 'sha1' : 'sha256';
+
                 const oauth = OAuth({
                     consumer: {
                         key: this.config.auth.consumerKey,
                         secret: this.config.auth.consumerSecret
                     },
-                    signature_method: 'HMAC-SHA256',
+                    signature_method: methodStr,
                     hash_function(base_string, key) {
                         return crypto
-                            .createHmac('sha256', key)
+                            .createHmac(hashAlgo, key)
                             .update(base_string)
                             .digest('base64');
                     }

package/lib/command-registry.js

@@ -16,8 +16,9 @@ import { registerImportCommands } from './commands/import.js';
 import { registerModulesCommands } from './commands/modules.js';
 import { registerConsoleCommand } from './commands/console.js';
 import { registerShipmentCommands } from './commands/shipments.js';
+import { registerRestCommands } from './commands/rest.js';
 
-export { registerConnectionCommands, registerConsoleCommand, registerShipmentCommands };
+export { registerConnectionCommands, registerConsoleCommand, registerShipmentCommands, registerRestCommands };
 
 const GROUPS = {
   CORE: [
@@ -31,7 +32,8 @@ const GROUPS = {
     registerTaxCommands,
     registerInventoryCommands,
     registerShipmentCommands,
-    registerConsoleCommand
+    registerConsoleCommand,
+    registerRestCommands
   ],
   COMMERCE: [
     registerCompanyCommands,

package/lib/commands/connections.js

@@ -7,6 +7,22 @@ import inquirer from 'inquirer';
 import chalk from 'chalk';
 import { getMissingB2BModules } from '../b2b.js';
 
+// Helper to test connection (non-interactive or one-shot)
+async function testConnection(name, settings) {
+    console.log(chalk.blue(`\nTesting connection "${name}"...`));
+    try {
+        const client = await createClient(settings);
+        const start = Date.now();
+        await client.get('V1/store/storeViews');
+        const duration = Date.now() - start;
+        console.log(chalk.green(`✔ Connection successful! (${duration}ms)`));
+        return { success: true };
+    } catch (e) {
+        console.error(chalk.red(`✖ Connection failed: ${e.message}`));
+        return { success: false, error: e };
+    }
+}
+
 // Helper to handle interactive connection configuration and testing
 async function configureAndTestConnection(name, initialSettings = {}) {
     let settings = await askForProfileSettings(initialSettings);
@@ -19,18 +35,13 @@ async function configureAndTestConnection(name, initialSettings = {}) {
         });
 
         if (shouldTest) {
-            console.log(chalk.blue(`\nTesting connection "${name}"...`));
-            try {
-                const client = await createClient(settings);
-                const start = Date.now();
-                await client.get('V1/store/storeViews');
-                const duration = Date.now() - start;
-                console.log(chalk.green(`✔ Connection successful! (${duration}ms)`));
+            const result = await testConnection(name, settings);
+            
+            if (result.success) {
                 lastTestError = null;
                 break; // Test passed, proceed to save
-            } catch (e) {
-                console.error(chalk.red(`✖ Connection failed: ${e.message}`));
-                lastTestError = e;
+            } else {
+                lastTestError = result.error;
                 const shouldEdit = await confirm({
                     message: 'Connection failed. Do you want to change settings?',
                     default: true
@@ -345,41 +356,152 @@ export function registerConnectionCommands(program) {
     //-------------------------------------------------------
     connections.command('add')
         .description('Configure a new connection profile')
+        .option('--name <name>', 'Profile Name')
+        .option('--type <type>', 'System Type (magento-os, mage-os, ac-on-prem, ac-cloud-paas, ac-saas)')
+        .option('--url <url>', 'Instance URL')
+        .option('--client-id <id>', 'Client ID (SaaS)')
+        .option('--client-secret <secret>', 'Client Secret (SaaS)')
+        .option('--auth-method <method>', 'Auth Method (bearer, oauth1)')
+        .option('--token <token>', 'Bearer Token')
+        .option('--consumer-key <key>', 'Consumer Key (OAuth1)')
+        .option('--consumer-secret <secret>', 'Consumer Secret (OAuth1)')
+        .option('--access-token <token>', 'Access Token (OAuth1)')
+        .option('--token-secret <secret>', 'Token Secret (OAuth1)')
+        .option('--signature-method <method>', 'Signature Method (hmac-sha256, hmac-sha1)', 'hmac-sha256')
+        .option('--active', 'Set as active profile')
+        .option('--no-test', 'Skip connection test')
         .addHelpText('after', `
 Examples:
+  Interactive Mode:
   $ mage-remote-run connection add
+
+  SaaS (Non-Interactive):
+  $ mage-remote-run connection add --name "MySaaS" --type ac-saas --url "https://example.com" --client-id "id" --client-secret "secret" --active
+
+  Bearer Token (Non-Interactive):
+  $ mage-remote-run connection add --name "MyStore" --type magento-os --url "https://magento.example.com" --token "tkn"
 `)
-        .action(async () => {
+        .action(async (options) => {
             console.log(chalk.blue('Configure a new connection Profile'));
             try {
-                const name = await input({
-                    message: 'Profile Name:',
-                    validate: value => value ? true : 'Name is required'
-                });
+                let name = options.name;
+                let settings = null;
 
-                const settings = await configureAndTestConnection(name);
-                if (!settings) {
-                    console.log(chalk.yellow('\nConfiguration cancelled.'));
-                    return;
+                // Non-Interactive Mode
+                if (options.type) {
+                    if (!name) {
+                        throw new Error('Option --name is required when using --type');
+                    }
+                    if (!options.url) {
+                        throw new Error('Option --url is required when using --type');
+                    }
+
+                    settings = {
+                        type: options.type,
+                        url: options.url,
+                        auth: {}
+                    };
+
+                    if (options.type === 'ac-saas') {
+                        if (!options.clientId || !options.clientSecret) {
+                            throw new Error('SaaS authentication requires --client-id and --client-secret');
+                        }
+                        settings.auth = {
+                            clientId: options.clientId,
+                            clientSecret: options.clientSecret
+                        };
+                    } else {
+                        // Infer auth method if not provided
+                        let method = options.authMethod;
+                        if (!method) {
+                            if (options.token) {
+                                method = 'bearer';
+                            } else if (options.consumerKey && options.consumerSecret) {
+                                method = 'oauth1';
+                            }
+                        }
+
+                        if (method === 'bearer') {
+                            if (!options.token) {
+                                throw new Error('Bearer authentication requires --token');
+                            }
+                            settings.auth = {
+                                method: 'bearer',
+                                token: options.token
+                            };
+                        } else if (method === 'oauth1') {
+                            if (!options.consumerKey || !options.consumerSecret || !options.accessToken || !options.tokenSecret) {
+                                throw new Error('OAuth1 authentication requires --consumer-key, --consumer-secret, --access-token, and --token-secret');
+                            }
+                            settings.auth = {
+                                method: 'oauth1',
+                                consumerKey: options.consumerKey,
+                                consumerSecret: options.consumerSecret,
+                                accessToken: options.accessToken,
+                                tokenSecret: options.tokenSecret,
+                                signatureMethod: options.signatureMethod
+                            };
+                        } else {
+                            throw new Error('Invalid or missing authentication options. Use --token for Bearer or provide OAuth keys.');
+                        }
+                    }
+
+                    // Test connection if not skipped
+                    let lastTestError = null;
+                    if (options.test !== false) { // --no-test sets options.test to false
+                         const result = await testConnection(name, settings);
+                         if (!result.success) {
+                             throw new Error(`Connection test failed: ${result.error.message}`);
+                         }
+                    }
+
+                    settings = await updateProfileCapabilities(settings, lastTestError);
+
+                } else {
+                    // Interactive Mode
+                    name = await input({
+                        message: 'Profile Name:',
+                        validate: value => value ? true : 'Name is required'
+                    });
+
+                    settings = await configureAndTestConnection(name);
+                    if (!settings) {
+                        console.log(chalk.yellow('\nConfiguration cancelled.'));
+                        return;
+                    }
                 }
 
                 await addProfile(name, settings);
                 console.log(chalk.green(`\nProfile "${name}" saved successfully!`));
 
-                // Ask to set as active if multiple exist
                 const config = await loadConfig();
-                if (Object.keys(config.profiles).length > 1) {
-                    const setActive = await confirm({
-                        message: 'Set this as the active profile?',
-                        default: true
-                    });
-
-                    if (setActive) {
-                        config.activeProfile = name;
-                        await saveConfig(config);
-                        console.log(chalk.green(`Profile "${name}" set as active.`));
+                
+                let setActive = false;
+                if (options.type) {
+                    // Non-interactive: only set active if requested or if it's the only one (handled by addProfile implicitly for first one, but we check logic here)
+                    if (options.active) {
+                        setActive = true;
                     }
+                } else {
+                    // Interactive
+                    if (Object.keys(config.profiles).length > 1) {
+                        setActive = await confirm({
+                            message: 'Set this as the active profile?',
+                            default: true
+                        });
+                    }
+                }
+                
+                // addProfile already sets active if it's the first profile. 
+                // We only need to force it if requested or confirmed and it wasn't already set (e.g. multiple profiles)
+                // Actually addProfile sets it if !activeProfile. 
+                
+                if (setActive && config.activeProfile !== name) {
+                     config.activeProfile = name;
+                     await saveConfig(config);
+                     console.log(chalk.green(`Profile "${name}" set as active.`));
                 }
+                
             } catch (e) {
                 if (e.name === 'ExitPromptError') {
                     console.log(chalk.yellow('\nConfiguration cancelled.'));

package/lib/commands/rest.js

@@ -0,0 +1,136 @@
+import { createClient } from '../api/factory.js';
+import { handleError } from '../utils.js';
+import chalk from 'chalk';
+import { input, select, editor } from '@inquirer/prompts';
+
+export function registerRestCommands(program) {
+    program.command('rest [path]')
+        .description('Execute a manual REST API request')
+        .option('-m, --method <method>', 'HTTP Method (GET, POST, PUT, DELETE)')
+        .option('-d, --data <data>', 'Request body data (JSON)')
+        .option('-q, --query <string>', 'Query parameters (e.g. "a=1&b=2")')
+        .option('--page-size <number>', 'Search Criteria Page Size')
+        .option('--current-page <number>', 'Search Criteria Current Page')
+        .option('-c, --content-type <type>', 'Content-Type', 'application/json')
+        .option('-f, --format <type>', 'Output format (json, xml)')
+        .addHelpText('after', `
+Examples:
+  $ mage-remote-run rest V1/store/websites
+  $ mage-remote-run rest V1/customers/1 -m GET
+  $ mage-remote-run rest V1/customers -m POST -d '{"customer": {"email": "test@example.com", ...}}'
+  $ mage-remote-run rest V1/products -m GET -q "searchCriteria[pageSize]=10&fields=items[sku,name]"
+  $ mage-remote-run rest V1/products -m GET --page-size 10 --current-page 1
+`)
+        .action(async (path, options) => {
+            try {
+                const client = await createClient();
+
+                // 1. Path
+                let requestPath = path;
+                if (!requestPath) {
+                    requestPath = await input({
+                        message: 'Enter the endpoint path (relative to base URL):',
+                        validate: (value) => value.length > 0 ? true : 'Path is required'
+                    });
+                }
+
+                // 2. Method
+                let method = options.method;
+                if (!method) {
+                    method = await select({
+                        message: 'Select HTTP Method:',
+                        choices: [
+                            { name: 'GET', value: 'GET' },
+                            { name: 'POST', value: 'POST' },
+                            { name: 'PUT', value: 'PUT' },
+                            { name: 'DELETE', value: 'DELETE' }
+                        ]
+                    });
+                }
+                method = method.toUpperCase();
+
+                // 3. Data (Body)
+                let data = options.data;
+                const contentType = options.contentType || 'application/json';
+
+                if ((method === 'POST' || method === 'PUT') && data === undefined) {
+                    data = await editor({
+                        message: 'Enter request body:',
+                        default: contentType === 'application/json' ? '{\n  \n}' : ''
+                    });
+                }
+
+                // Validate and Parse JSON
+                let parsedData = data;
+                if (contentType === 'application/json' && data) {
+                    if (typeof data === 'string') {
+                        try {
+                            parsedData = JSON.parse(data);
+                        } catch (e) {
+                            throw new Error('Invalid JSON data provided.');
+                        }
+                    }
+                }
+
+                // 4. Execution
+                if (!options.format) {
+                    console.log(chalk.gray(`Executing ${method} ${requestPath}...`));
+                }
+                
+                const config = {
+                    headers: {
+                        'Content-Type': contentType
+                    }
+                };
+
+                if (options.format === 'json') {
+                    config.headers['Accept'] = 'application/json';
+                } else if (options.format === 'xml') {
+                    config.headers['Accept'] = 'application/xml';
+                }
+
+                // Parse query options
+                let params = {};
+                if (options.query) {
+                    const searchParams = new URLSearchParams(options.query);
+                    for (const [key, value] of searchParams) {
+                        params[key] = value;
+                    }
+                }
+
+                if (options.pageSize) {
+                    params['searchCriteria[pageSize]'] = options.pageSize;
+                }
+
+                if (options.currentPage) {
+                    params['searchCriteria[currentPage]'] = options.currentPage;
+                }
+
+                const response = await client.request(method, requestPath, parsedData, params, config);
+
+                // 5. Output
+                if (options.format === 'json') {
+                    // Ensure we output valid JSON even if response is already an object
+                    if (typeof response === 'object') {
+                        console.log(JSON.stringify(response, null, 2));
+                    } else {
+                        // Attempt to parse if string, otherwise output as is (or error?)
+                        // Usually response.data is parsed by axios if json.
+                        console.log(response);
+                    }
+                } else if (options.format === 'xml') {
+                    console.log(response);
+                } else {
+                    // Default behavior
+                    if (typeof response === 'object') {
+                        console.log(JSON.stringify(response, null, 2));
+                    } else {
+                        console.log(response);
+                    }
+                }
+
+            } catch (e) {
+                handleError(e);
+            }
+        });
+}

package/lib/prompts.js

@@ -81,12 +81,22 @@ export async function askForProfileSettings(defaults = {}) {
                 validate: value => (value || defaults.auth?.tokenSecret) ? true : 'Token Secret is required'
             });
 
+            const signatureMethod = await select({
+                message: 'Signature Method:',
+                default: defaults.auth?.signatureMethod || 'hmac-sha256',
+                choices: [
+                    { name: 'HMAC-SHA256 (Default, Newer Versions)', value: 'hmac-sha256' },
+                    { name: 'HMAC-SHA1 (Older Versions)', value: 'hmac-sha1' }
+                ]
+            });
+
             authConfig = {
                 method: 'oauth1',
                 consumerKey,
                 consumerSecret: consumerSecret || defaults.auth?.consumerSecret,
                 accessToken: accessToken || defaults.auth?.accessToken,
-                tokenSecret: tokenSecret || defaults.auth?.tokenSecret
+                tokenSecret: tokenSecret || defaults.auth?.tokenSecret,
+                signatureMethod
             };
         }
     }

package/package.json

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