mage-remote-run 0.23.1 → 0.25.0

package/lib/b2b.js

@@ -0,0 +1,19 @@
+export const B2B_MODULES = [
+    'Magento_Company',
+    'Magento_CompanyCredit',
+    'Magento_CompanyPayment',
+    'Magento_CompanyShipping',
+    'Magento_NegotiableQuote',
+    'Magento_PurchaseOrder',
+    'Magento_RequisitionList',
+    'Magento_SharedCatalog'
+];
+
+export function getMissingB2BModules(modules = []) {
+    const installed = new Set(modules);
+    return B2B_MODULES.filter(moduleName => !installed.has(moduleName));
+}
+
+export function hasB2BModules(modules = []) {
+    return getMissingB2BModules(modules).length === 0;
+}

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,
@@ -57,14 +59,32 @@ const TYPE_MAPPINGS = {
   'ac-saas': [...GROUPS.CORE, ...GROUPS.COMMERCE, ...GROUPS.CLOUD, ...GROUPS.IMPORT] // Assuming SaaS has same feature set as PaaS for CLI
 };
 
+const B2B_COMMANDS = new Set([registerCompanyCommands, registerPurchaseOrderCartCommands]);
+const B2B_CHECK_TYPES = new Set(['ac-on-prem', 'ac-cloud-paas']);
+
+function shouldRegisterCommandForProfile(registrar, profile) {
+  if (!B2B_COMMANDS.has(registrar)) {
+    return true;
+  }
+  if (!profile || !profile.type) {
+    return false;
+  }
+  if (!B2B_CHECK_TYPES.has(profile.type)) {
+    return true;
+  }
+  return profile.b2bModulesAvailable === true;
+}
+
 export function registerCoreCommands(program) {
   // Backward compatibility: Register CORE group
   GROUPS.CORE.forEach(registrar => registrar(program));
 }
 
-export function registerCloudCommands(program) {
+export function registerCloudCommands(program, profile = null) {
   // Backward compatibility
-  [...GROUPS.COMMERCE, ...GROUPS.CLOUD, ...GROUPS.IMPORT].forEach(registrar => registrar(program));
+  [...GROUPS.COMMERCE, ...GROUPS.CLOUD, ...GROUPS.IMPORT]
+    .filter(registrar => shouldRegisterCommandForProfile(registrar, profile))
+    .forEach(registrar => registrar(program, profile));
 }
 
 // Deprecated: Use registerCommands instead
@@ -80,7 +100,9 @@ export const registerCommands = (program, profile) => {
   if (profile && profile.type) {
     const registrars = TYPE_MAPPINGS[profile.type];
     if (registrars) {
-      registrars.forEach(registrar => registrar(program, profile));
+      registrars
+        .filter(registrar => shouldRegisterCommandForProfile(registrar, profile))
+        .forEach(registrar => registrar(program, profile));
     } else {
       // Fallback for unknown types
       GROUPS.CORE.forEach(registrar => registrar(program));

package/lib/commands/connections.js

@@ -5,10 +5,12 @@ import { createClient } from '../api/factory.js';
 import { input, confirm, select } from '@inquirer/prompts';
 import inquirer from 'inquirer';
 import chalk from 'chalk';
+import { getMissingB2BModules } from '../b2b.js';
 
 // Helper to handle interactive connection configuration and testing
 async function configureAndTestConnection(name, initialSettings = {}) {
     let settings = await askForProfileSettings(initialSettings);
+    let lastTestError = null;
 
     while (true) {
         const shouldTest = await confirm({
@@ -24,9 +26,11 @@ async function configureAndTestConnection(name, initialSettings = {}) {
                 await client.get('V1/store/storeViews');
                 const duration = Date.now() - start;
                 console.log(chalk.green(`✔ Connection successful! (${duration}ms)`));
+                lastTestError = null;
                 break; // Test passed, proceed to save
             } catch (e) {
                 console.error(chalk.red(`✖ Connection failed: ${e.message}`));
+                lastTestError = e;
                 const shouldEdit = await confirm({
                     message: 'Connection failed. Do you want to change settings?',
                     default: true
@@ -53,20 +57,160 @@ async function configureAndTestConnection(name, initialSettings = {}) {
             break;
         }
     }
+    settings = await updateProfileCapabilities(settings, lastTestError);
     return settings;
 }
 
+function shouldCheckB2BModules(settings) {
+    return settings && ['ac-cloud-paas', 'ac-on-prem'].includes(settings.type);
+}
+
+function shouldCheckHyvaModules(settings) {
+    return settings && ['magento-os', 'mage-os', 'ac-on-prem', 'ac-cloud-paas'].includes(settings.type);
+}
+
+async function updateProfileCapabilities(settings, lastTestError) {
+    if (settings && settings.type === 'ac-saas') {
+        settings.b2bModulesAvailable = true;
+        settings.hyvaCommerceAvailable = false;
+        settings.hyvaThemeAvailable = false;
+        return settings;
+    }
+
+    if (!shouldCheckB2BModules(settings) && !shouldCheckHyvaModules(settings)) {
+        if (settings && 'b2bModulesAvailable' in settings) delete settings.b2bModulesAvailable;
+        if (settings && 'hyvaCommerceAvailable' in settings) delete settings.hyvaCommerceAvailable;
+        if (settings && 'hyvaThemeAvailable' in settings) delete settings.hyvaThemeAvailable;
+        if (settings && 'hyvaModulesAvailable' in settings) delete settings.hyvaModulesAvailable; // Cleanup legacy
+        return settings;
+    }
+
+    try {
+        const client = await createClient(settings);
+        const data = await client.get('V1/modules');
+        const modules = Array.isArray(data) ? data : (Array.isArray(data?.items) ? data.items : []);
+        
+        if (shouldCheckB2BModules(settings)) {
+            const missing = getMissingB2BModules(modules);
+            settings.b2bModulesAvailable = missing.length === 0;
+            if (process.env.DEBUG) {
+                if (settings.b2bModulesAvailable) {
+                    console.log(chalk.gray('DEBUG: B2B modules detected.'));
+                } else {
+                    console.log(chalk.gray(`DEBUG: Missing B2B modules: ${missing.join(', ')}`));
+                }
+            }
+        }
+
+        if (shouldCheckHyvaModules(settings)) {
+            settings.hyvaCommerceAvailable = modules.includes('Hyva_Commerce');
+            settings.hyvaThemeAvailable = modules.includes('Hyva_Theme');
+
+            // Cleanup old property if exists
+            if ('hyvaModulesAvailable' in settings) delete settings.hyvaModulesAvailable;
+
+            if (process.env.DEBUG) {
+                if (settings.hyvaCommerceAvailable) console.log(chalk.gray('DEBUG: Hyvä Commerce detected.'));
+                if (settings.hyvaThemeAvailable) console.log(chalk.gray('DEBUG: Hyvä Theme detected.'));
+            }
+        }
+
+    } catch (e) {
+        if (process.env.DEBUG) {
+            const suffix = lastTestError ? ' (connection test failed)' : '';
+            console.log(chalk.gray(`DEBUG: Unable to detect modules${suffix}: ${e.message}`));
+        }
+        if (shouldCheckB2BModules(settings)) settings.b2bModulesAvailable = null;
+        if (shouldCheckHyvaModules(settings)) {
+            settings.hyvaCommerceAvailable = null;
+            settings.hyvaThemeAvailable = null;
+        }
+    }
+
+    return settings;
+}
+
+async function ensureProfileCapabilities(profileName, profile, config) {
+    if (!profile || !profile.type) {
+        return false;
+    }
+
+    let updated = false;
+
+    // Migrate old property if exists
+    if ('hyvaModulesAvailable' in profile) {
+        profile.hyvaCommerceAvailable = profile.hyvaModulesAvailable;
+        delete profile.hyvaModulesAvailable;
+        updated = true;
+    }
+
+    if (profile.type === 'ac-saas') {
+        if (profile.b2bModulesAvailable !== true) {
+            profile.b2bModulesAvailable = true;
+            updated = true;
+        }
+        if (profile.hyvaCommerceAvailable !== false) {
+            profile.hyvaCommerceAvailable = false;
+            updated = true;
+        }
+        if (profile.hyvaThemeAvailable !== false) {
+            profile.hyvaThemeAvailable = false;
+            updated = true;
+        }
+        if (updated) config.profiles[profileName] = profile;
+        return updated;
+    }
+
+    const checkB2B = shouldCheckB2BModules(profile);
+    const checkHyva = shouldCheckHyvaModules(profile);
+
+    if (!checkB2B && !checkHyva) return false;
+
+    // Check if we need to detect
+    const needsB2B = checkB2B && profile.b2bModulesAvailable === undefined;
+    const needsHyva = checkHyva && (profile.hyvaCommerceAvailable === undefined || profile.hyvaThemeAvailable === undefined);
+
+    if (needsB2B || needsHyva) {
+        const newSettings = await updateProfileCapabilities({ ...profile });
+        
+        if (checkB2B) {
+            profile.b2bModulesAvailable = newSettings.b2bModulesAvailable;
+        }
+        if (checkHyva) {
+            profile.hyvaCommerceAvailable = newSettings.hyvaCommerceAvailable;
+            profile.hyvaThemeAvailable = newSettings.hyvaThemeAvailable;
+        }
+        
+        config.profiles[profileName] = profile;
+        return true;
+    }
+
+    if (updated) config.profiles[profileName] = profile;
+    return updated;
+}
 
 // Helper to print connection status
-async function printConnectionStatus(config) {
+async function printConnectionStatus(config, options = {}) {
     if (!config.activeProfile) {
-        console.log(chalk.yellow('No active profile configured. Run "connection add" or "connection select".'));
+        if (options.format === 'json') {
+            console.log(JSON.stringify({ error: 'No active profile configured' }));
+        } else {
+            console.log(chalk.yellow('No active profile configured. Run "connection add" or "connection select".'));
+        }
         return;
     }
 
     const profile = config.profiles[config.activeProfile];
 
     if (profile) {
+        if (options.format === 'json') {
+            console.log(JSON.stringify({
+                activeProfile: config.activeProfile,
+                ...profile
+            }, null, 2));
+            return;
+        }
+
         // ASCII Logos
         const logos = {
             adobe: chalk.red(`
@@ -149,9 +293,43 @@ async function printConnectionStatus(config) {
             console.log(logo);
         }
 
-        console.log(chalk.bold('Active Profile:'), chalk.green(config.activeProfile));
-        console.log(`Type: ${profile.type}`);
-        console.log(`URL: ${profile.url}`);
+        const rows = [
+            ['Active Profile', chalk.green(config.activeProfile)],
+            ['Type', profile.type],
+            ['URL', profile.url]
+        ];
+
+        if (['ac-cloud-paas', 'ac-on-prem', 'ac-saas'].includes(profile.type)) {
+            let b2bStatus = '?';
+            if (profile.type === 'ac-saas') {
+                b2bStatus = chalk.green('Yes');
+            } else if (profile.b2bModulesAvailable === true) {
+                b2bStatus = chalk.green('Yes');
+            } else if (profile.b2bModulesAvailable === false) {
+                b2bStatus = chalk.yellow('No');
+            }
+            rows.push(['B2B Modules', b2bStatus]);
+        }
+
+        if (['magento-os', 'mage-os', 'ac-on-prem', 'ac-cloud-paas'].includes(profile.type)) {
+            let hyvaCommerceStatus = '?';
+            if (profile.hyvaCommerceAvailable === true) {
+                hyvaCommerceStatus = chalk.green('Yes');
+            } else if (profile.hyvaCommerceAvailable === false) {
+                hyvaCommerceStatus = chalk.yellow('No');
+            }
+            rows.push(['Hyvä Commerce', hyvaCommerceStatus]);
+
+            let hyvaThemeStatus = '?';
+            if (profile.hyvaThemeAvailable === true) {
+                hyvaThemeStatus = chalk.green('Yes');
+            } else if (profile.hyvaThemeAvailable === false) {
+                hyvaThemeStatus = chalk.yellow('No');
+            }
+            rows.push(['Hyvä Theme', hyvaThemeStatus]);
+        }
+
+        printTable(['Configuration', 'Value'], rows);
     } else {
         console.log(chalk.red('Profile not found in configuration!'));
     }
@@ -217,20 +395,117 @@ Examples:
     //-------------------------------------------------------
     connections.command('list')
         .description('List connection profiles')
+        .option('--format <format>', 'Output format (table, json, csv)', 'table')
         .addHelpText('after', `
 Examples:
   $ mage-remote-run connection list
+  $ mage-remote-run connection list --format json
+  $ mage-remote-run connection list --format csv
 `)
-        .action(async () => {
+        .action(async (options) => {
             try {
                 const config = await loadConfig();
+                let updated = false;
+                for (const [name, profile] of Object.entries(config.profiles || {})) {
+                    updated = (await ensureProfileCapabilities(name, profile, config)) || updated;
+                }
+                if (updated) {
+                    await saveConfig(config);
+                }
+
+                if (options.format === 'json') {
+                    console.log(JSON.stringify(config.profiles || {}, null, 2));
+                    return;
+                }
+
+                if (options.format === 'csv') {
+                    const { stringify } = await import('csv-stringify/sync');
+                    const rows = Object.entries(config.profiles || {}).map(([name, p]) => ({
+                        name,
+                        type: p.type,
+                        url: p.url,
+                        b2b_modules_available: p.b2bModulesAvailable,
+                        hyva_theme_available: p.hyvaThemeAvailable,
+                        hyva_commerce_available: p.hyvaCommerceAvailable,
+                        active: name === config.activeProfile
+                    }));
+                    console.log(stringify(rows, { header: true }));
+                    return;
+                }
+
                 const rows = Object.entries(config.profiles || {}).map(([name, p]) => [
                     name,
                     p.type,
                     p.url,
+                    ['ac-cloud-paas', 'ac-on-prem', 'ac-saas'].includes(p.type)
+                        ? (p.type === 'ac-saas'
+                            ? 'Yes'
+                            : (p.b2bModulesAvailable === true ? 'Yes' : (p.b2bModulesAvailable === false ? 'No' : '?')))
+                        : '',
+                    (p.hyvaThemeAvailable === true ? 'Yes' : (p.hyvaThemeAvailable === false ? 'No' : '?')),
+                    (p.hyvaCommerceAvailable === true ? 'Yes' : (p.hyvaCommerceAvailable === false ? 'No' : '?')),
                     name === config.activeProfile ? chalk.green('Yes') : 'No'
                 ]);
-                printTable(['Name', 'Type', 'URL', 'Active'], rows);
+
+                const headers = ['Name', 'Type', 'URL', 'B2B', 'Hyvä Theme', 'Hyvä Comm.', 'Active'];
+                const termWidth = process.stdout.columns;
+
+                if (termWidth) {
+                    const visibleLength = (str) => {
+                        return ('' + str).replace(/\u001b\[[0-9;]*m/g, '').length;
+                    };
+
+                    const colWidths = headers.map((h, i) => {
+                        return Math.max(h.length, ...rows.map(r => visibleLength(r[i])));
+                    });
+
+                    const overhead = (headers.length * 3) + 1;
+                    const totalWidth = colWidths.reduce((a, b) => a + b, 0) + overhead;
+
+                    if (totalWidth > termWidth) {
+                        const available = termWidth - overhead;
+                        // Indices: 0=Name, 1=Type, 2=URL, 3=B2B, 4=HT, 5=HC, 6=Active
+                        const fixedIndices = [1, 3, 4, 5, 6];
+                        const fixedWidth = fixedIndices.reduce((sum, i) => sum + colWidths[i], 0);
+
+                        let fluidWidth = available - fixedWidth;
+                        if (fluidWidth < 20) fluidWidth = 20;
+
+                        const nameWidth = colWidths[0];
+                        const urlWidth = colWidths[2];
+                        let targetNameWidth = nameWidth;
+                        let targetUrlWidth = urlWidth;
+
+                        // Try to preserve Name, sacrifice URL
+                        if (nameWidth + urlWidth > fluidWidth) {
+                            // Keep Name as is if possible (assuming min URL width of 20)
+                            if (nameWidth + 20 <= fluidWidth) {
+                                targetUrlWidth = fluidWidth - nameWidth;
+                                targetNameWidth = nameWidth;
+                            } else {
+                                // We have to cut Name too
+                                // Give Name 30% or min 15
+                                let w = Math.floor(fluidWidth * 0.3);
+                                if (w < 15) w = 15;
+                                targetNameWidth = Math.min(nameWidth, w);
+                                targetUrlWidth = fluidWidth - targetNameWidth;
+                            }
+                        }
+
+                        const truncate = (str, len) => {
+                            if (!str) return str;
+                            if (visibleLength(str) <= len) return str;
+                            return str.substring(0, len - 3) + '...';
+                        };
+
+                        rows.forEach(row => {
+                            row[0] = truncate(row[0], targetNameWidth);
+                            row[2] = truncate(row[2], targetUrlWidth);
+                        });
+                    }
+                }
+
+                printTable(headers, rows);
             } catch (e) { handleError(e); }
         });
 
@@ -401,14 +676,21 @@ Examples:
     //-------------------------------------------------------
     connections.command('status')
         .description('Show current configuration status')
+        .option('--format <format>', 'Output format (text, json)', 'text')
         .addHelpText('after', `
 Examples:
   $ mage-remote-run connection status
+  $ mage-remote-run connection status --format json
 `)
-        .action(async () => {
+        .action(async (options) => {
             try {
                 const config = await loadConfig();
-                await printConnectionStatus(config);
+                const activeProfileName = config.activeProfile;
+                const activeProfile = activeProfileName ? config.profiles[activeProfileName] : null;
+                if (activeProfile && await ensureProfileCapabilities(activeProfileName, activeProfile, config)) {
+                    await saveConfig(config);
+                }
+                await printConnectionStatus(config, options);
             } catch (e) { handleError(e); }
         });
 

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mage-remote-run",
-  "version": "0.23.1",
+  "version": "0.25.0",
   "description": "The remote swiss army knife for Magento Open Source, Mage-OS, Adobe Commerce",
   "main": "index.js",
   "scripts": {
@@ -39,6 +39,7 @@
     "cli-table3": "^0.6.5",
     "commander": "^14.0.2",
     "csv-parse": "^6.1.0",
+    "csv-stringify": "^6.6.0",
     "env-paths": "^3.0.0",
     "html-to-text": "^9.0.5",
     "inquirer": "^13.1.0",