mage-remote-run 0.19.0 → 0.20.0

package/bin/mage-remote-run.js

@@ -39,14 +39,14 @@ program
 
 
 import {
-  registerConnectionCommands,
-  registerCoreCommands,
-  registerCloudCommands
+  registerCommands
 } from '../lib/command-registry.js';
 import { getActiveProfile } from '../lib/config.js';
 import { startMcpServer } from '../lib/mcp.js';
 
-registerConnectionCommands(program);
+// Connection commands are registered dynamically via registerCommands
+// But we need them registered early if we want them to show up in help even if config fails?
+// Actually registerCommands handles null profile by registering connection commands only.
 
 program.command('mcp')
   .description('Run as MCP server')
@@ -58,14 +58,7 @@ program.command('mcp')
   });
 
 const profile = await getActiveProfile();
-
-if (profile) {
-  registerCoreCommands(program);
-
-  if (profile.type === 'ac-cloud-paas' || profile.type === 'ac-saas') {
-    registerCloudCommands(program);
-  }
-}
+registerCommands(program, profile);
 
 program.hook('preAction', async (thisCommand, actionCommand) => {
   // Check if we have an active profile and if format is not json/xml

package/lib/command-registry.js

@@ -8,63 +8,74 @@ 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 { registerEventsCommands } from './commands/events.js';
 import { registerWebhooksCommands } from './commands/webhooks.js';
 import { registerPurchaseOrderCartCommands } from './commands/purchase-order-cart.js';
+import { registerImportCommands } from './commands/import.js';
 import { registerConsoleCommand } from './commands/console.js';
 
 export { registerConnectionCommands, registerConsoleCommand };
 
+const GROUPS = {
+  CORE: [
+    registerWebsitesCommands,
+    registerStoresCommands,
+    registerCustomersCommands,
+    registerOrdersCommands,
+    registerEavCommands,
+    registerProductsCommands,
+    registerTaxCommands,
+    registerInventoryCommands,
+    registerConsoleCommand
+  ],
+  COMMERCE: [
+    registerCompanyCommands,
+    registerPurchaseOrderCartCommands
+  ],
+  CLOUD: [
+    registerEventsCommands,
+    registerWebhooksCommands
+  ],
+  IMPORT: [
+    registerImportCommands
+  ]
+};
+
+const TYPE_MAPPINGS = {
+  'magento-os': [...GROUPS.CORE],
+  'mage-os': [...GROUPS.CORE],
+  'ac-on-prem': [...GROUPS.CORE, ...GROUPS.COMMERCE, ...GROUPS.IMPORT],
+  'ac-cloud-paas': [...GROUPS.CORE, ...GROUPS.COMMERCE, ...GROUPS.CLOUD, ...GROUPS.IMPORT],
+  'ac-saas': [...GROUPS.CORE, ...GROUPS.COMMERCE, ...GROUPS.CLOUD, ...GROUPS.IMPORT] // Assuming SaaS has same feature set as PaaS for CLI
+};
+
 export function registerCoreCommands(program) {
-  registerWebsitesCommands(program);
-  registerStoresCommands(program);
-  registerCustomersCommands(program);
-  registerOrdersCommands(program);
-  registerEavCommands(program);
-  registerProductsCommands(program);
-  registerTaxCommands(program);
-  registerInventoryCommands(program);
-  registerConsoleCommand(program);
+  // Backward compatibility: Register CORE group
+  GROUPS.CORE.forEach(registrar => registrar(program));
 }
 
 export function registerCloudCommands(program) {
-  registerAdobeIoEventsCommands(program);
-  registerCompanyCommands(program);
-  registerPurchaseOrderCartCommands(program);
-  registerWebhooksCommands(program);
+  // Backward compatibility
+  [...GROUPS.COMMERCE, ...GROUPS.CLOUD, ...GROUPS.IMPORT].forEach(registrar => registrar(program));
 }
 
+// Deprecated: Use registerCommands instead
 export function registerAllCommands(program) {
   registerConnectionCommands(program);
-  registerCoreCommands(program);
-  registerCloudCommands(program);
+  const all = new Set([...GROUPS.CORE, ...GROUPS.COMMERCE, ...GROUPS.CLOUD, ...GROUPS.IMPORT]);
+  all.forEach(registrar => registrar(program));
 }
 
-// Alias for backwards compatibility with console.js (and potential other usages)
 export const registerCommands = (program, profile) => {
-  // Note: console.js passes profile, but registerAllCommands doesn't strictly use it 
-  // (it registers everything, profile checks happen inside or via selective registration).
-  // The original behavior in console.js:
-  // const profile = await getActiveProfile();
-  // registerCommands(localProgram, profile);
-
-  // In bin/mage-remote-run.js old logic:
-  // registerConnectionCommands(program);
-  // if (profile) { registerWebsitesCommands... }
-
-  // We should replicate that 'selective' registration if we want to match exact behavior?
-  // BUT console.js wants to register ALL available commands for the profile.
-
   registerConnectionCommands(program);
 
-  // Simple logic: If profile exists, register all. 
-  // console.js usage implies profile is present if it's running (or it tries to get it).
-
-  if (profile) {
-    registerCoreCommands(program);
-    // Cloud check
-    if (profile.type === 'ac-cloud-paas' || profile.type === 'ac-saas') {
-      registerCloudCommands(program);
+  if (profile && profile.type) {
+    const registrars = TYPE_MAPPINGS[profile.type];
+    if (registrars) {
+      registrars.forEach(registrar => registrar(program, profile));
+    } else {
+      // Fallback for unknown types
+      GROUPS.CORE.forEach(registrar => registrar(program));
     }
   }
 };

package/lib/commands/events.js

@@ -0,0 +1,277 @@
+import { createClient } from '../api/factory.js';
+import { printTable, handleError } from '../utils.js';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+
+export function registerEventsCommands(program) {
+    const events = program.command('event').description('Manage Adobe I/O Events');
+
+    //-------------------------------------------------------
+    // "event check-configuration" Command (Renamed from adobe-io-event)
+    //-------------------------------------------------------
+    events.command('check-configuration')
+        .description('Check Adobe I/O Event configuration')
+        .option('-f, --format <type>', 'Output format (text, json, xml)', 'text')
+        .addHelpText('after', `
+Examples:
+  $ mage-remote-run event check-configuration
+  $ mage-remote-run event check-configuration --format json
+`)
+        .action(async (options) => {
+            try {
+                const client = await createClient();
+                const headers = {};
+                if (options.format === 'json') headers['Accept'] = 'application/json';
+                else if (options.format === 'xml') headers['Accept'] = 'application/xml';
+
+                const data = await client.get('V1/adobe_io_events/check_configuration', {}, { headers });
+
+                if (options.format === 'json') {
+                    console.log(JSON.stringify(data, null, 2));
+                    return;
+                }
+                if (options.format === 'xml') {
+                    console.log(data);
+                    return;
+                }
+
+                console.log(chalk.bold.blue('\n🔍 Configuration Check Result'));
+                console.log(chalk.gray('━'.repeat(60)));
+
+                if (typeof data === 'object' && data !== null) {
+                    if (Array.isArray(data)) {
+                        console.log(JSON.stringify(data, null, 2));
+                    } else {
+                        Object.entries(data).forEach(([key, value]) => {
+                            const label = key.replace(/_/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+                            let displayValue = value;
+                            if (typeof value === 'boolean') {
+                                displayValue = value ? chalk.green('Yes') : chalk.red('No');
+                            } else if (value === null) {
+                                displayValue = chalk.gray('null');
+                            } else if (typeof value === 'object') {
+                                displayValue = JSON.stringify(value);
+                            }
+                            console.log(`  ${chalk.bold(label + ':').padEnd(35)} ${displayValue}`);
+                        });
+                    }
+                } else {
+                    console.log(`  ${data}`);
+                }
+                console.log('');
+            } catch (e) { handleError(e); }
+        });
+
+    const provider = events.command('provider').description('Manage event providers');
+
+    //-------------------------------------------------------
+    // "event provider list" Command
+    //-------------------------------------------------------
+    provider.command('list')
+        .description('List event providers')
+        .option('-f, --format <type>', 'Output format (text, json, xml)', 'text')
+        .addHelpText('after', `
+Examples:
+  $ mage-remote-run event provider list
+`)
+        .action(async (options) => {
+            try {
+                const client = await createClient();
+                const headers = {};
+                if (options.format === 'json') headers['Accept'] = 'application/json';
+
+                const data = await client.get('V1/eventing/eventProvider', {}, { headers });
+
+                if (options.format === 'json') {
+                    console.log(JSON.stringify(data, null, 2));
+                    return;
+                }
+
+                const rows = (data || []).map(p => [p.id, p.label, p.description]);
+                printTable(['ID', 'Label', 'Description'], rows);
+            } catch (e) { handleError(e); }
+        });
+
+    //-------------------------------------------------------
+    // "event provider show" Command
+    //-------------------------------------------------------
+    provider.command('show <id>')
+        .description('Show event provider details')
+        .option('-f, --format <type>', 'Output format (text, json, xml)', 'text')
+        .action(async (id, options) => {
+            try {
+                const client = await createClient();
+                const headers = {};
+                if (options.format === 'json') headers['Accept'] = 'application/json';
+
+                // We try fetching all and filtering because the user mapped "show" to the specific endpoint that looks like a collection
+                const data = await client.get('V1/eventing/eventProvider', {}, { headers });
+
+                let item;
+                if (Array.isArray(data)) {
+                    item = data.find(p => p.id == id);
+                } else if (data.id == id) {
+                    item = data;
+                }
+
+                if (!item) {
+                    throw new Error(`Event Provider '${id}' not found.`);
+                }
+
+                if (options.format === 'json') {
+                    console.log(JSON.stringify(item, null, 2));
+                    return;
+                }
+
+                console.log(chalk.bold.blue('\n🔍 Event Provider Details'));
+                console.log(chalk.gray('━'.repeat(60)));
+                Object.entries(item).forEach(([key, value]) => {
+                    console.log(`  ${chalk.bold(key + ':').padEnd(20)} ${value}`);
+                });
+                console.log('');
+
+            } catch (e) { handleError(e); }
+        });
+
+    //-------------------------------------------------------
+    // "event provider create" Command
+    //-------------------------------------------------------
+    provider.command('create')
+        .description('Create a new event provider')
+        .action(async () => {
+            try {
+                const client = await createClient();
+
+                // Attempt to auto-detect instance_id from profile settings (SaaS only)
+                let defaultInstanceId = undefined;
+                try {
+                    console.log(chalk.gray('Attempting to auto-detect Instance ID...'));
+                    const { getActiveProfile } = await import('../config.js');
+                    const profile = await getActiveProfile();
+
+                    if (profile && (profile.type === 'ac-saas' || profile.type === 'saas')) {
+                        try {
+                            // Extract last part of URL path
+                            const url = new URL(profile.url);
+                            const pathParts = url.pathname.split('/').filter(p => p.length > 0);
+                            if (pathParts.length > 0) {
+                                defaultInstanceId = pathParts[pathParts.length - 1];
+                                console.log(chalk.gray(`Found Instance ID (from URL): ${defaultInstanceId}`));
+                            } else {
+                                console.log(chalk.gray('Could not extract Instance ID from URL.'));
+                            }
+                        } catch (e) {
+                            console.log(chalk.gray('Invalid URL in profile configuration.'));
+                        }
+                    } else {
+                        console.log(chalk.gray('Instance ID detection only supported for SaaS connections.'));
+                    }
+                } catch (e) {
+                    console.log(chalk.gray('Could not auto-detect Instance ID.'));
+                }
+
+                const answers = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'provider_id',
+                        message: `Enter Provider ID ${chalk.dim('(Found in Adobe Developer Console > Project > Events > Event Provider > ID)')}:`,
+                        validate: input => input ? true : 'Provider ID is required'
+                    },
+                    {
+                        type: 'input',
+                        name: 'label',
+                        message: `Enter Provider Label ${chalk.dim('(A friendly name for this provider)')}:`,
+                        validate: input => input ? true : 'Label is required'
+                    },
+                    {
+                        type: 'input',
+                        name: 'description',
+                        message: `Enter Provider Description ${chalk.dim('(Optional)')}:`
+                    },
+                    {
+                        type: 'input',
+                        name: 'instance_id',
+                        message: `Enter Instance ID ${chalk.dim('(Found in "check-configuration" or Adobe Developer Console)')}:`,
+                        default: defaultInstanceId
+                    },
+                    {
+                        type: 'editor',
+                        name: 'workspace_configuration',
+                        message: `Enter Workspace Configuration ${chalk.dim('(JSON from Adobe Developer Console > Download Project Config)')}:`
+                    }
+                ]);
+
+                const payload = {
+                    eventProvider: {
+                        provider_id: answers.provider_id,
+                        instance_id: answers.instance_id,
+                        label: answers.label,
+                        description: answers.description,
+                        workspace_configuration: answers.workspace_configuration
+                    }
+                };
+
+                const result = await client.post('V1/eventing/eventProvider', payload);
+                console.log(chalk.green('\n✅ Event Provider Created Successfully'));
+                console.log(JSON.stringify(result, null, 2));
+
+            } catch (e) { handleError(e); }
+        });
+
+    //-------------------------------------------------------
+    // "event provider delete" Command
+    //-------------------------------------------------------
+    provider.command('delete <id>')
+        .description('Delete an event provider')
+        .action(async (id) => {
+            try {
+                const client = await createClient();
+                // Assumed endpoint based on standard REST, though prompt said DELETE /V1/eventing/eventProvider
+                // Usually DELETE requires an ID. I will append the ID.
+                // Wait, if the prompt says DELETE /V1/eventing/eventProvider, it MIGHT expect a body or query param?
+                // Standard Magento: DELETE /V1/eventing/eventProvider/:id
+                // I will try appending ID.
+                await client.delete(`V1/eventing/eventProvider/${id}`);
+                console.log(chalk.green(`\n✅ Event Provider '${id}' deleted successfully.`));
+            } catch (e) { handleError(e); }
+        });
+
+    //-------------------------------------------------------
+    // "event supported-list" Command
+    //-------------------------------------------------------
+    events.command('supported-list')
+        .description('List supported events')
+        .option('-f, --format <type>', 'Output format (text, json)', 'text')
+        .action(async (options) => {
+            try {
+                const client = await createClient();
+                const headers = {};
+                if (options.format === 'json') headers['Accept'] = 'application/json';
+
+                const data = await client.get('V1/eventing/supportedList', {}, { headers });
+
+                if (options.format === 'json') {
+                    console.log(JSON.stringify(data, null, 2));
+                    return;
+                }
+
+                // Assuming data is list of strings or objects.
+                // If objects, we might need to know structure.
+                // Prompt didn't specify structure. Assuming list of strings or objects with 'name'/'id'.
+                if (Array.isArray(data)) {
+                    if (data.length > 0 && typeof data[0] === 'string') {
+                        data.forEach(d => console.log(d));
+                    } else {
+                        // Fallback table
+                        const keys = Object.keys(data[0] || {});
+                        const rows = data.map(d => Object.values(d));
+                        printTable(keys, rows);
+                    }
+                } else {
+                    console.log(data);
+                }
+
+            } catch (e) { handleError(e); }
+        });
+
+}

package/lib/commands/import.js

@@ -0,0 +1,275 @@
+
+import { createClient } from '../api/factory.js';
+import { handleError, readInput, validateAdobeCommerce, validatePaaSOrOnPrem } from '../utils.js';
+import chalk from 'chalk';
+import fs from 'fs';
+import { input, select, confirm, editor } from '@inquirer/prompts';
+import search from '@inquirer/search';
+import os from 'os';
+
+async function getImportBehaviorAndEntity(options) {
+    let entityType = options.entityType;
+    if (!entityType) {
+        const ENTITY_TYPES = [
+            { name: 'Advanced Pricing', value: 'advanced_pricing' },
+            { name: 'Products', value: 'catalog_product' },
+            { name: 'Customers and Addresses (single file)', value: 'customer_composite' },
+            { name: 'Customers Main File', value: 'customer' },
+            { name: 'Customer Addresses', value: 'customer_address' },
+            { name: 'Customer Finances', value: 'customer_finance' },
+            { name: 'Stock Sources', value: 'stock_sources' },
+            { name: 'Custom...', value: 'custom' }
+        ];
+
+        entityType = await search({
+            message: 'Select Entity Type:',
+            source: async (term) => {
+                if (!term) {
+                    return ENTITY_TYPES;
+                }
+                return ENTITY_TYPES.filter((type) =>
+                    type.name.toLowerCase().includes(term.toLowerCase()) ||
+                    type.value.toLowerCase().includes(term.toLowerCase())
+                );
+            }
+        });
+
+        if (entityType === 'custom') {
+            entityType = await input({
+                message: 'Enter Custom Entity Type:',
+                validate: value => value ? true : 'Entity Type is required'
+            });
+        }
+    }
+
+    let behavior = options.behavior;
+    if (!behavior) {
+        behavior = await select({
+            message: 'Import Behavior:',
+            choices: [
+                { name: 'Append/Update', value: 'append' },
+                { name: 'Replace', value: 'replace' },
+                { name: 'Delete', value: 'delete_entity' }
+            ],
+            default: 'append'
+        });
+    }
+
+    return { entityType, behavior };
+}
+
+async function getValidationOptions(options) {
+    let validationStrategy = options.validationStrategy;
+    if (!validationStrategy) {
+        validationStrategy = await select({
+            message: 'Validation Strategy:',
+            choices: [
+                { name: 'Stop on Error', value: 'validation-stop-on-errors' },
+                { name: 'Skip error entries', value: 'validation-skip-errors' }
+            ],
+            default: 'validation-stop-on-errors'
+        });
+    }
+
+    let allowedErrorCount = options.allowedErrorCount;
+    if (!allowedErrorCount) {
+        allowedErrorCount = await input({
+            message: 'Allowed Error Count:',
+            default: '10',
+            validate: (value) => {
+                const num = parseInt(value, 10);
+                return !isNaN(num) && num >= 0 ? true : 'Please enter a valid number';
+            }
+        });
+    }
+
+    return {
+        validationStrategy,
+        allowedErrorCount: parseInt(allowedErrorCount, 10)
+    };
+}
+
+export function registerImportCommands(program, profile) {
+    const importCmd = program.command('import').description('Import data');
+
+    //-------------------------------------------------------
+    // "import json" Command
+    //-------------------------------------------------------
+    importCmd.command('json [file]')
+        .description('Import data from JSON (Adobe Commerce)')
+        .option('--entity-type <type>', 'Entity Type (e.g. catalog_product, customer)')
+        .option('--behavior <behavior>', 'Import Behavior (append, replace, delete_entity)')
+        .option('--validation-strategy <strategy>', 'Validation Strategy (validation-stop-on-errors, validation-skip-errors)')
+        .option('--allowed-error-count <count>', 'Allowed Error Count')
+        .addHelpText('after', `
+Examples:
+  Product from file:
+  $ mage-remote-run import json products.json --entity-type=catalog_product --allowed-error-count=10 --validation-strategy=validation-skip-errors
+  
+  From STDIN (piped):
+  $ cat data.json | mage-remote-run import json
+`)
+        .action(async (file, options) => {
+            try {
+                await validateAdobeCommerce();
+
+                let content = await readInput(file);
+                if (!content) {
+                    const fromFile = await confirm({
+                        message: 'Do you want to import a file?',
+                        default: true
+                    });
+
+                    if (fromFile) {
+                        const filePath = await input({
+                            message: 'Path to JSON file:',
+                            validate: value => {
+                                let p = value;
+                                if (p.startsWith('~/') || p === '~') p = p.replace(/^~/, os.homedir());
+                                return fs.existsSync(p) ? true : 'File not found';
+                            }
+                        });
+                        content = await readInput(filePath);
+                    } else {
+                        content = await editor({
+                            message: 'Enter JSON content',
+                            postfix: '.json'
+                        });
+                    }
+                }
+
+                let data;
+                try {
+                    data = JSON.parse(content);
+                } catch (e) {
+                    throw new Error('Invalid JSON data');
+                }
+
+                const { entityType, behavior } = await getImportBehaviorAndEntity(options);
+                const { validationStrategy, allowedErrorCount } = await getValidationOptions(options);
+
+                const payload = {
+                    source: {
+                        entity: entityType,
+                        behavior: behavior,
+                        validation_strategy: validationStrategy,
+                        allowed_error_count: allowedErrorCount,
+                        items: Array.isArray(data) ? data : [data]
+                    }
+                };
+
+                const client = await createClient();
+                const endpoint = 'V1/import/json';
+
+                try {
+                    const result = await client.post(endpoint, payload);
+                    console.log(chalk.green('Import submitted successfully.'));
+                    if (result) console.log(JSON.stringify(result, null, 2));
+                } catch (apiError) {
+                    if (apiError.message && (apiError.message.includes('Route') || apiError.message.includes('404'))) {
+                        throw new Error(`The endpoint "${endpoint}" was not found on the server.\nEnsure your Magento instance has the required Import API module installed.`);
+                    }
+                    throw apiError;
+                }
+
+            } catch (e) {
+                if (e.name === 'ExitPromptError') return;
+                handleError(e);
+            }
+        });
+
+    //-------------------------------------------------------
+    // "import csv" Command
+    //-------------------------------------------------------
+    // Only register/show if profile is allowed (PaaS or On-Prem)
+    if (profile && (profile.type === 'ac-cloud-paas' || profile.type === 'ac-on-prem')) {
+        importCmd.command('csv [file]')
+            .description('Import data from CSV (Adobe Commerce PaaS/On-Prem)')
+            .option('--entity-type <type>', 'Entity Type (e.g. catalog_product, customer)')
+            .option('--behavior <behavior>', 'Import Behavior (append, replace, delete_entity)')
+            .option('--validation-strategy <strategy>', 'Validation Strategy (validation-stop-on-errors, validation-skip-errors)')
+            .option('--allowed-error-count <count>', 'Allowed Error Count')
+            .option('--field-separator <char>', 'Field Separator', ',')
+            .option('--multi-value-separator <char>', 'Multiple Value Separator', ',')
+            .option('--empty-value-constant <string>', 'Empty Attribute Value Constant', '__EMPTY__VALUE__')
+            .option('--images-file-dir <dir>', 'Images File Directory', 'var/import/images')
+            .addHelpText('after', `
+Examples:
+  Interactive:
+  $ mage-remote-run import csv products.csv
+
+  Non-Interactive:
+  $ mage-remote-run import csv products.csv --entity-type catalog_product --behavior append
+
+  Custom Separators:
+  $ mage-remote-run import csv products.csv --field-separator ";" --multi-value-separator "|"
+`)
+            .action(async (file, options) => {
+                try {
+                    await validatePaaSOrOnPrem();
+
+                    let content = await readInput(file);
+                    if (!content) {
+                        const fromFile = await confirm({
+                            message: 'Do you want to import a file?',
+                            default: true
+                        });
+
+                        if (fromFile) {
+                            const filePath = await input({
+                                message: 'Path to CSV file:',
+                                validate: value => {
+                                    let p = value;
+                                    if (p.startsWith('~/') || p === '~') p = p.replace(/^~/, os.homedir());
+                                    return fs.existsSync(p) ? true : 'File not found';
+                                }
+                            });
+                            content = await readInput(filePath);
+                        } else {
+                            content = await editor({
+                                message: 'Enter CSV content',
+                                postfix: '.csv'
+                            });
+                        }
+                    }
+
+                    console.log(chalk.blue(`Size: ${content.length} characters.`));
+
+                    const { entityType, behavior } = await getImportBehaviorAndEntity(options);
+                    const { validationStrategy, allowedErrorCount } = await getValidationOptions(options);
+
+                    const payload = {
+                        source: {
+                            entity: entityType,
+                            behavior: behavior,
+                            csv_data: Buffer.from(content).toString('base64'),
+                            import_field_separator: options.fieldSeparator,
+                            import_multiple_value_separator: options.multiValueSeparator,
+                            import_empty_attribute_value_constant: options.emptyValueConstant,
+                            import_images_file_dir: options.imagesFileDir,
+                            validation_strategy: validationStrategy,
+                            allowed_error_count: allowedErrorCount
+                        }
+                    };
+
+                    const client = await createClient();
+                    const endpoint = 'V1/import/csv';
+
+                    try {
+                        const result = await client.post(endpoint, payload);
+                        console.log(chalk.green('Import submitted successfully.'));
+                        if (result) console.log(JSON.stringify(result, null, 2));
+                    } catch (apiError) {
+                        if (apiError.message && (apiError.message.includes('Route') || apiError.message.includes('404'))) {
+                            throw new Error(`The endpoint "${endpoint}" was not found on the server.\nEnsure your Magento instance has the required Import API module installed.`);
+                        }
+                        throw apiError;
+                    }
+
+                } catch (e) {
+                    if (e.name === 'ExitPromptError') return;
+                    handleError(e);
+                }
+            });
+    }
+}

package/lib/utils.js

@@ -1,5 +1,8 @@
 import chalk from 'chalk';
 import Table from 'cli-table3';
+import fs from 'fs';
+import os from 'os';
+import { loadConfig } from './config.js';
 
 export function printTable(headers, data) {
     const table = new Table({
@@ -42,3 +45,44 @@ export function handleError(error) {
         console.error(error);
     }
 }
+
+export async function readInput(filePath) {
+    if (filePath) {
+        if (filePath.startsWith('~/') || filePath === '~') {
+            filePath = filePath.replace(/^~/, os.homedir());
+        }
+
+        if (!fs.existsSync(filePath)) {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        return fs.readFileSync(filePath, 'utf8');
+    }
+
+    if (!process.stdin.isTTY) {
+        let data = '';
+        for await (const chunk of process.stdin) {
+            data += chunk;
+        }
+        return data;
+    }
+
+    return null;
+}
+
+export async function validateAdobeCommerce() {
+    const config = await loadConfig();
+    const profile = config.profiles[config.activeProfile];
+    const allowed = ['ac-cloud-paas', 'ac-saas', 'ac-on-prem'];
+    if (!profile || !allowed.includes(profile.type)) {
+        throw new Error('This command is only available for Adobe Commerce (Cloud, SaaS, On-Premise).');
+    }
+}
+
+export async function validatePaaSOrOnPrem() {
+    const config = await loadConfig();
+    const profile = config.profiles[config.activeProfile];
+    const allowed = ['ac-cloud-paas', 'ac-on-prem'];
+    if (!profile || !allowed.includes(profile.type)) {
+        throw new Error('This command is only available for Adobe Commerce (Cloud/On-Premise).');
+    }
+}

package/package.json

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

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

@@ -1,70 +0,0 @@
-import { createClient } from '../api/factory.js';
-import { printTable, handleError } from '../utils.js';
-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')
-        .addHelpText('after', `
-Examples:
-  $ mage-remote-run adobe-io-event check-configuration
-  $ mage-remote-run adobe-io-event check-configuration --format json
-`)
-        .action(async (options) => {
-            try {
-                const client = await createClient();
-                const headers = {};
-                if (options.format === 'json') headers['Accept'] = 'application/json';
-                else if (options.format === 'xml') headers['Accept'] = 'application/xml';
-
-                // The endpoint is likely returning a simple boolean/string or a small object.
-                // Based on standard Magento APIs, let's assume it returns a boolean or object.
-                // We'll inspect the data structure.
-                const data = await client.get('V1/adobe_io_events/check_configuration', {}, { headers });
-
-                if (options.format === 'json') {
-                    console.log(JSON.stringify(data, null, 2));
-                    return;
-                }
-                if (options.format === 'xml') {
-                    console.log(data);
-                    return;
-                }
-
-                console.log(chalk.bold.blue('\n🔍 Configuration Check Result'));
-                console.log(chalk.gray('━'.repeat(60)));
-
-                if (typeof data === 'object' && data !== null) {
-                    if (Array.isArray(data)) {
-                        console.log(JSON.stringify(data, null, 2));
-                    } else {
-                        Object.entries(data).forEach(([key, value]) => {
-                            const label = key.replace(/_/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
-
-                            let displayValue = value;
-                            if (typeof value === 'boolean') {
-                                displayValue = value ? chalk.green('Yes') : chalk.red('No');
-                            } else if (value === null) {
-                                displayValue = chalk.gray('null');
-                            } else if (typeof value === 'object') {
-                                displayValue = JSON.stringify(value);
-                            }
-
-                            console.log(`  ${chalk.bold(label + ':').padEnd(35)} ${displayValue}`);
-                        });
-                    }
-                } else {
-                    console.log(`  ${data}`);
-                }
-                console.log('');
-
-            } catch (e) { handleError(e); }
-        });
-}