mage-remote-run 0.1.0

package/bin/mage-remote-run.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { loadConfig } from '../lib/config.js';
+import chalk from 'chalk';
+
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+
+const program = new Command();
+
+program
+    .name('mage-remote-run')
+    .description('The remote swiss army knife for Magento Open Source, Mage-OS, Adobe Commerce')
+    .version(pkg.version);
+
+
+
+import { registerWebsitesCommands } from '../lib/commands/websites.js';
+import { registerStoresCommands } from '../lib/commands/stores.js';
+import { registerConnectionCommands } from '../lib/commands/connections.js';
+import { registerCustomersCommands } from '../lib/commands/customers.js';
+import { registerOrdersCommands } from '../lib/commands/orders.js';
+import { registerEavCommands } from '../lib/commands/eav.js';
+import { registerProductsCommands } from '../lib/commands/products.js';
+import { registerTaxCommands } from '../lib/commands/tax.js';
+
+registerConnectionCommands(program);
+registerWebsitesCommands(program);
+registerStoresCommands(program);
+registerCustomersCommands(program);
+registerOrdersCommands(program);
+registerEavCommands(program);
+registerProductsCommands(program);
+registerTaxCommands(program);
+
+// Check for first run (no profiles configured and no arguments or just help)
+// We need to check args length.
+// node script.js -> length 2.
+// node script.js command -> length 3.
+const args = process.argv.slice(2);
+const config = await loadConfig();
+const hasProfiles = Object.keys(config.profiles || {}).length > 0;
+
+if (!hasProfiles && args.length === 0) {
+    console.log(chalk.bold.blue('Welcome to mage-remote-run! 🚀'));
+    console.log(chalk.gray('The remote swiss army knife for Magento Open Source, Mage-OS, Adobe Commerce'));
+    console.log(chalk.gray('It looks like you haven\'t configured any connections yet.'));
+    console.log(chalk.gray('Let\'s set up your first connection now.\n'));
+
+    // Trigger the interactive add command directly
+    // We can simulate running the 'connection add' command
+    // But since we are at top level, we might need to invoke it manually or parse specific args.
+    // Easiest is to manually invoke program.parse with ['node', 'script', 'connection', 'add']
+    // BUT program.parse executes asynchronously usually? commander is synchronous by default but actions are async.
+    // Let's modify process.argv before parsing.
+    process.argv = [...process.argv.slice(0, 2), 'connection', 'add'];
+}
+
+program.parse(process.argv);

package/lib/api/client.js

@@ -0,0 +1,22 @@
+export class ApiClient {
+    constructor(config) {
+        this.config = config;
+        this.baseUrl = config.url.replace(/\/$/, ''); // Remove trailing slash
+    }
+
+    async get(endpoint, params = {}, config = {}) {
+        throw new Error('Method not implemented');
+    }
+
+    async post(endpoint, data = {}, config = {}) {
+        throw new Error('Method not implemented');
+    }
+
+    async put(endpoint, data = {}, config = {}) {
+        throw new Error('Method not implemented');
+    }
+
+    async delete(endpoint, config = {}) {
+        throw new Error('Method not implemented');
+    }
+}

package/lib/api/factory.js

@@ -0,0 +1,27 @@
+import { SaasClient } from './saas.js';
+import { PaasClient } from './paas.js';
+import { getActiveProfile } from '../config.js';
+
+export async function createClient(configOrProfileName = null) {
+    let settings;
+    if (typeof configOrProfileName === 'object' && configOrProfileName !== null) {
+        settings = configOrProfileName;
+    } else if (typeof configOrProfileName === 'string') {
+        const { loadConfig } = await import('../config.js');
+        const config = await loadConfig();
+        settings = config.profiles[configOrProfileName];
+    } else {
+        settings = await getActiveProfile();
+    }
+
+    if (!settings) {
+        throw new Error("No active profile found. Please run 'mage-remote-run configure'.");
+    }
+
+    if (settings.type === 'ac-saas' || settings.type === 'saas') {
+        return new SaasClient(settings);
+    } else {
+        // magento-os, mage-os, ac-on-prem, ac-cloud-paas, paas
+        return new PaasClient(settings);
+    }
+}

package/lib/api/paas.js

@@ -0,0 +1,103 @@
+import axios from 'axios';
+import OAuth from 'oauth-1.0a';
+import crypto from 'crypto';
+import { ApiClient } from './client.js';
+import { OpenAPIClientAxios } from 'openapi-client-axios';
+import { loadSpec } from './spec-loader.js';
+
+export class PaasClient extends ApiClient {
+    constructor(config) {
+        super(config);
+        this.openApi = null;
+        this.axiosInstance = null;
+    }
+
+    async init() {
+        if (this.openApi) return;
+
+        const definition = loadSpec(this.config.type);
+        this.openApi = new OpenAPIClientAxios({
+            definition,
+            axiosConfigDefaults: {
+                baseURL: `${this.baseUrl}/rest/V1`
+            }
+        });
+
+        this.axiosInstance = await this.openApi.getClient();
+
+        // Add auth interceptor
+        this.axiosInstance.interceptors.request.use((config) => {
+            // Handle Auth
+            if (this.config.auth.method === 'bearer') {
+                config.headers['Authorization'] = `Bearer ${this.config.auth.token}`;
+            } else if (this.config.auth.method === 'oauth1') {
+                // Calculate OAuth1 signature
+                // Note: config.url here might be relative or full depending on axios usage.
+                // axios instance url is typically combined.
+
+                // We need to construct the full URL for signing.
+                // config.baseURL + config.url
+                const baseURL = config.baseURL || '';
+                const url = baseURL.replace(/\/$/, '') + '/' + config.url.replace(/^\//, ''); // rudimentary join
+
+                const oauth = OAuth({
+                    consumer: {
+                        key: this.config.auth.consumerKey,
+                        secret: this.config.auth.consumerSecret
+                    },
+                    signature_method: 'HMAC-SHA256',
+                    hash_function(base_string, key) {
+                        return crypto
+                            .createHmac('sha256', key)
+                            .update(base_string)
+                            .digest('base64');
+                    }
+                });
+
+                const requestData = {
+                    url,
+                    method: config.method.toUpperCase(),
+                    data: config.params // OAuth 1.0a signs query params
+                };
+
+                const token = {
+                    key: this.config.auth.accessToken,
+                    secret: this.config.auth.tokenSecret
+                };
+
+                const authHeader = oauth.toHeader(oauth.authorize(requestData, token));
+                Object.assign(config.headers, authHeader);
+            }
+            return config;
+        });
+    }
+
+    async request(method, endpoint, data = {}, params = {}, config = {}) {
+        await this.init();
+
+        const cleanEndpoint = endpoint.replace(/^\//, '');
+
+        try {
+            const response = await this.axiosInstance({
+                method,
+                url: cleanEndpoint,
+                data,
+                params,
+                ...config
+            });
+            return response.data;
+        } catch (error) {
+            if (error.response) {
+                const newError = new Error(`API Error ${error.response.status}: ${JSON.stringify(error.response.data)}`);
+                newError.response = error.response;
+                throw newError;
+            }
+            throw error;
+        }
+    }
+
+    async get(endpoint, params, config) { return this.request('get', endpoint, undefined, params, config); }
+    async post(endpoint, data, config) { return this.request('post', endpoint, data, undefined, config); }
+    async put(endpoint, data, config) { return this.request('put', endpoint, data, undefined, config); }
+    async delete(endpoint, config) { return this.request('delete', endpoint, undefined, undefined, config); }
+}

package/lib/api/saas.js

@@ -0,0 +1,97 @@
+import axios from 'axios';
+import { ApiClient } from './client.js';
+import { OpenAPIClientAxios } from 'openapi-client-axios';
+import { loadSpec } from './spec-loader.js';
+
+export class SaasClient extends ApiClient {
+    constructor(config) {
+        super(config);
+        this.token = null;
+        this.tokenExpiresAt = 0;
+        this.openApi = null;
+        this.axiosInstance = null;
+    }
+
+    async init() {
+        if (this.openApi) return;
+
+        const definition = loadSpec(this.config.type);
+        this.openApi = new OpenAPIClientAxios({
+            definition,
+            axiosConfigDefaults: {
+                baseURL: `${this.baseUrl}/rest/V1`, // Base for generated client
+                // Note: The definition might have servers block, but we override functionality.
+            }
+        });
+
+        // We initialize the client but we will handle auth via interceptors or manual token injection
+        this.axiosInstance = await this.openApi.getClient();
+
+        // Add auth interceptor
+        this.axiosInstance.interceptors.request.use(async (config) => {
+            const token = await this.getToken();
+            config.headers['Authorization'] = `Bearer ${token}`;
+            return config;
+        });
+    }
+
+    async getToken() {
+        if (this.token && Date.now() < this.tokenExpiresAt) {
+            return this.token;
+        }
+
+        const tokenUrl = `${this.baseUrl}/oauth/token`;
+
+        try {
+            // Use raw axios for token fetch to avoid circular dependency or interceptor issues
+            const response = await axios.post(tokenUrl, {
+                grant_type: 'client_credentials',
+                client_id: this.config.auth.clientId,
+                client_secret: this.config.auth.clientSecret
+            });
+
+            this.token = response.data.access_token;
+            const expiresIn = response.data.expires_in || 3600;
+            this.tokenExpiresAt = Date.now() + (expiresIn * 1000) - 60000;
+
+            return this.token;
+        } catch (error) {
+            throw new Error(`Failed to obtain OAuth2 token: ${error.message}`);
+        }
+    }
+
+    async request(method, endpoint, data = {}, params = {}, config = {}) {
+        await this.init();
+
+        // Use the configured axios instance for generic requests
+        // Note: endpoint passed here is like 'store/websites'
+        // openapi-client-axios client base is usually set to server root or we adjusted it.
+        // If we set baseURL to /rest/V1, we just need the relative path.
+
+        // Ensure endpoint does not start with / if base has it, or handle cleanly
+        const cleanEndpoint = endpoint.replace(/^\//, '');
+
+        try {
+            const response = await this.axiosInstance({
+                method,
+                url: cleanEndpoint,
+                data,
+                params,
+                ...config
+            });
+            return response.data;
+        } catch (error) {
+            if (error.response) {
+                const newError = new Error(`API Error ${error.response.status}: ${JSON.stringify(error.response.data)}`);
+                newError.response = error.response;
+                throw newError;
+            }
+            throw error;
+        }
+    }
+
+    async get(endpoint, params, config) { return this.request('get', endpoint, undefined, params, config); }
+    async post(endpoint, data, config) { return this.request('post', endpoint, data, undefined, config); }
+    async put(endpoint, data, config) { return this.request('put', endpoint, data, undefined, config); }
+    async delete(endpoint, config) { return this.request('delete', endpoint, undefined, undefined, config); }
+}

package/lib/api/spec-loader.js

@@ -0,0 +1,23 @@
+import { OpenAPIClientAxios } from 'openapi-client-axios';
+import fs from 'fs';
+import path from 'path';
+
+// Locate specs relative to project root (assuming we are in lib/api)
+const SPEC_DIR = path.resolve(process.cwd(), 'api-specs/2.4.8');
+
+export function loadSpec(type) {
+    let specFile;
+    if (type === 'ac-saas' || type === 'saas') {
+        specFile = 'swagger-saas.json';
+    } else {
+        // All others use PaaS/OpenSource spec
+        specFile = 'swagger-paas.json';
+    }
+
+    const filePath = path.join(SPEC_DIR, specFile);
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`OpenAPI spec not found at: ${filePath}`);
+    }
+
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+}

package/lib/commands/connections.js

@@ -0,0 +1,214 @@
+import { loadConfig, saveConfig, addProfile } from '../config.js';
+import { printTable, handleError } from '../utils.js';
+import { askForProfileSettings } from '../prompts.js';
+import { createClient } from '../api/factory.js';
+import { input, confirm, select } from '@inquirer/prompts';
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+
+export function registerConnectionCommands(program) {
+    const connections = program.command('connection').description('Manage connection profiles');
+
+    connections.command('add')
+        .description('Configure a new connection profile')
+        .action(async () => {
+            console.log(chalk.blue('Configure a new connection Profile'));
+            try {
+                const name = await input({
+                    message: 'Profile Name:',
+                    validate: value => value ? true : 'Name is required'
+                });
+
+                const settings = await askForProfileSettings();
+
+                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.`));
+                    }
+                }
+            } catch (e) {
+                if (e.name === 'ExitPromptError') {
+                    console.log(chalk.yellow('\nConfiguration cancelled.'));
+                    return;
+                }
+                handleError(e);
+            }
+        });
+
+    connections.command('list')
+        .description('List connection profiles')
+        .action(async () => {
+            try {
+                const config = await loadConfig();
+                const rows = Object.entries(config.profiles || {}).map(([name, p]) => [
+                    name,
+                    p.type,
+                    p.url,
+                    name === config.activeProfile ? chalk.green('Yes') : 'No'
+                ]);
+                printTable(['Name', 'Type', 'URL', 'Active'], rows);
+            } catch (e) { handleError(e); }
+        });
+
+    connections.command('search <query>')
+        .description('Search connection profiles')
+        .action(async (query) => {
+            try {
+                const config = await loadConfig();
+                const filtered = Object.entries(config.profiles || {}).filter(([name]) => name.includes(query));
+                const rows = filtered.map(([name, p]) => [name, p.type, p.url]);
+                printTable(['Name', 'Type', 'URL'], rows);
+            } catch (e) { handleError(e); }
+        });
+
+    connections.command('delete <name>')
+        .description('Delete a connection profile')
+        .action(async (name) => {
+            try {
+                const config = await loadConfig();
+                if (!config.profiles[name]) throw new Error(`Profile ${name} not found`);
+
+                const { confirm } = await inquirer.prompt([{ type: 'confirm', name: 'confirm', message: `Delete profile ${name}?` }]);
+                if (!confirm) return;
+
+                delete config.profiles[name];
+                if (config.activeProfile === name) config.activeProfile = null;
+                await saveConfig(config);
+                console.log(chalk.green(`Profile ${name} deleted.`));
+            } catch (e) { handleError(e); }
+        });
+
+    connections.command('edit <name>')
+        .description('Edit a connection profile')
+        .action(async (name) => {
+            try {
+                const config = await loadConfig();
+                const profile = config.profiles[name];
+                if (!profile) throw new Error(`Profile ${name} not found`);
+
+                const settings = await askForProfileSettings(profile);
+
+                config.profiles[name] = settings;
+                await saveConfig(config);
+                console.log(chalk.green(`Profile "${name}" updated.`));
+            } catch (e) {
+                if (e.name === 'ExitPromptError') {
+                    console.log(chalk.yellow('\nEdit cancelled.'));
+                    return;
+                }
+                handleError(e);
+            }
+        });
+
+    connections.command('test')
+        .description('Test connection(s)')
+        .option('--all', 'Test all configured connections')
+        .action(async (options) => {
+            try {
+                const config = await loadConfig();
+
+                if (options.all) {
+                    const profiles = Object.keys(config.profiles || {});
+                    if (profiles.length === 0) {
+                        console.log(chalk.yellow('No profiles found.'));
+                        return;
+                    }
+                    console.log(chalk.blue(`Testing ${profiles.length} connections...\n`));
+
+                    const results = [];
+                    for (const name of profiles) {
+                        try {
+                            const profileConfig = config.profiles[name];
+                            const client = await createClient(profileConfig);
+
+                            const start = Date.now();
+                            await client.get('store/storeViews');
+                            const duration = Date.now() - start;
+
+                            results.push([name, chalk.green('SUCCESS'), `${duration}ms`]);
+                        } catch (e) {
+                            results.push([name, chalk.red('FAILED'), e.message]);
+                        }
+                    }
+
+                    console.log(chalk.bold('Connection Test Results:'));
+                    printTable(['Profile', 'Status', 'Details'], results);
+
+                } else {
+                    if (!config.activeProfile) {
+                        console.log(chalk.yellow('No active profile configured. Run "connection add" or "connection test --all".'));
+                        return;
+                    }
+                    console.log(`Testing active connection: ${chalk.bold(config.activeProfile)}...`);
+                    try {
+                        const client = await createClient(); // Uses active profile
+                        const start = Date.now();
+                        await client.get('store/storeViews');
+                        const duration = Date.now() - start;
+
+                        console.log(chalk.green(`\n✔ Connection successful! (${duration}ms)`));
+                    } catch (e) {
+                        console.error(chalk.red('\n✖ Connection failed:'), e.message);
+                        if (process.env.DEBUG) console.error(e);
+                    }
+                }
+            } catch (e) {
+                console.error(chalk.red('Test failed:'), e.message);
+                if (process.env.DEBUG) console.error(e);
+            }
+        });
+    connections.command('status')
+        .description('Show current configuration status')
+        .action(async () => {
+            try {
+                const config = await loadConfig();
+                if (!config.activeProfile) {
+                    console.log(chalk.yellow('No active profile configured. Run "connection add" or "connection select".'));
+                    return;
+                }
+                console.log(chalk.bold('Active Profile:'), chalk.green(config.activeProfile));
+                const profile = config.profiles[config.activeProfile];
+                if (profile) {
+                    console.log(`Type: ${profile.type}`);
+                    console.log(`URL: ${profile.url}`);
+                } else {
+                    console.log(chalk.red('Profile not found in configuration!'));
+                }
+            } catch (e) { handleError(e); }
+        });
+
+    connections.command('select')
+        .description('Select the active connection profile')
+        .action(async () => {
+            try {
+                const config = await loadConfig();
+                const profiles = Object.keys(config.profiles || {});
+                if (profiles.length === 0) {
+                    console.log(chalk.yellow('No profiles found. Run "connection add" first.'));
+                    return;
+                }
+
+                const selected = await select({
+                    message: 'Select Active Profile:',
+                    choices: profiles.map(p => ({ value: p, name: p })),
+                    default: config.activeProfile
+                });
+
+                config.activeProfile = selected;
+                await saveConfig(config);
+                console.log(chalk.green(`Active profile set to "${selected}".`));
+            } catch (e) { handleError(e); }
+        });
+}