mage-remote-run 0.1.0

package/lib/commands/customers.js

@@ -0,0 +1,196 @@
+import { createClient } from '../api/factory.js';
+import { printTable, handleError } from '../utils.js';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+
+export function registerCustomersCommands(program) {
+    const customers = program.command('customer').description('Manage customers');
+
+    customers.command('list')
+        .option('-p, --page <number>', 'Page number', '1')
+        .option('-s, --size <number>', 'Page size', '20')
+        .action(async (options) => {
+            try {
+                const client = await createClient();
+                const params = {
+                    'searchCriteria[currentPage]': options.page,
+                    'searchCriteria[pageSize]': options.size
+                };
+                const data = await client.get('customers/search', params);
+                const rows = (data.items || []).map(c => [c.id, c.email, c.firstname, c.lastname, c.group_id]);
+                console.log(chalk.bold(`Total: ${data.total_count}, Page: ${options.page}, Size: ${options.size}`));
+                printTable(['ID', 'Email', 'First Name', 'Last Name', 'Group'], rows);
+            } catch (e) { handleError(e); }
+        });
+
+    customers.command('search <query>')
+        .description('Search customers by email')
+        .action(async (query) => {
+            try {
+                const client = await createClient();
+                const params = {
+                    'searchCriteria[filter_groups][0][filters][0][field]': 'email',
+                    'searchCriteria[filter_groups][0][filters][0][value]': `%${query}%`,
+                    'searchCriteria[filter_groups][0][filters][0][condition_type]': 'like'
+                };
+                const data = await client.get('customers/search', params);
+                const rows = (data.items || []).map(c => [c.id, c.email, c.firstname, c.lastname]);
+                printTable(['ID', 'Email', 'Name', 'Lastname'], rows);
+            } catch (e) { handleError(e); }
+        });
+
+    customers.command('edit <id>')
+        .action(async (id) => {
+            try {
+                const client = await createClient();
+                const data = await client.get(`customers/${id}`);
+
+                const answers = await inquirer.prompt([
+                    { name: 'firstname', message: 'First Name', default: data.firstname },
+                    { name: 'lastname', message: 'Last Name', default: data.lastname },
+                    { name: 'email', message: 'Email', default: data.email }
+                ]);
+
+                const payload = {
+                    customer: {
+                        ...data,
+                        firstname: answers.firstname,
+                        lastname: answers.lastname,
+                        email: answers.email
+                    }
+                };
+
+                await client.put(`customers/${id}`, payload);
+                console.log(chalk.green(`Customer ${id} updated.`));
+            } catch (e) { handleError(e); }
+        });
+
+    customers.command('show <customerId>')
+        .description('Show detailed customer information')
+        .option('-f, --format <type>', 'Output format (text, json, xml)', 'text')
+        .action(async (customerId, options) => {
+            try {
+                const client = await createClient();
+                let headers = {};
+                if (options.format === 'json') headers['Accept'] = 'application/json';
+                else if (options.format === 'xml') headers['Accept'] = 'application/xml';
+
+                const data = await client.get(`customers/${customerId}`, {}, { 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👤 Customer Information'));
+                console.log(chalk.gray('━'.repeat(60)));
+
+                console.log(chalk.bold('\nℹ️  General Information'));
+                console.log(`  ${chalk.bold('ID:')}             ${data.id}`);
+                console.log(`  ${chalk.bold('Email:')}          ${data.email}`);
+                console.log(`  ${chalk.bold('First Name:')}     ${data.firstname}`);
+                console.log(`  ${chalk.bold('Last Name:')}      ${data.lastname}`);
+                console.log(`  ${chalk.bold('Group ID:')}       ${data.group_id}`);
+                console.log(`  ${chalk.bold('Created At:')}     ${data.created_at}`);
+                console.log(`  ${chalk.bold('Updated At:')}     ${data.updated_at}`);
+                console.log(`  ${chalk.bold('Website ID:')}     ${data.website_id}`);
+                console.log(`  ${chalk.bold('Store ID:')}       ${data.store_id}`);
+
+                if (data.addresses && data.addresses.length > 0) {
+                    console.log(chalk.bold('\n📍 Addresses'));
+                    data.addresses.forEach((addr, idx) => {
+                        console.log(chalk.bold(`  Address #${idx + 1} ${addr.default_billing ? '(Default Billing)' : ''} ${addr.default_shipping ? '(Default Shipping)' : ''}`));
+                        const addressLines = [
+                            `    ${addr.firstname} ${addr.lastname}`,
+                            ...(addr.street || []).map(s => `    ${s}`),
+                            `    ${addr.city}, ${addr.region ? addr.region.region : ''} ${addr.postcode}`,
+                            `    ${addr.country_id}`,
+                            `    T: ${addr.telephone}`
+                        ];
+                        console.log(addressLines.join('\n'));
+                        console.log('');
+                    });
+                }
+                console.log(chalk.gray('━'.repeat(60)));
+
+            } catch (e) { handleError(e); }
+        });
+
+    customers.command('delete <customerId>')
+        .description('Delete a customer')
+        .option('--force', 'Force delete without confirmation')
+        .action(async (customerId, options) => {
+            try {
+                if (!options.force) {
+                    const { confirm } = await inquirer.prompt([{
+                        type: 'confirm',
+                        name: 'confirm',
+                        message: `Are you sure you want to delete customer ${customerId}?`,
+                        default: false
+                    }]);
+                    if (!confirm) {
+                        console.log('Operation cancelled.');
+                        return;
+                    }
+                }
+
+                const client = await createClient();
+                await client.delete(`customers/${customerId}`);
+                console.log(chalk.green(`✅ Customer ${customerId} deleted.`));
+            } catch (e) { handleError(e); }
+        });
+
+    customers.command('confirm [customerId]')
+        .description('Resend customer confirmation email')
+        .option('--redirect-url <url>', 'Redirect URL after confirmation')
+        .action(async (customerId, options) => {
+            try {
+                const client = await createClient();
+                let email, websiteId;
+
+                if (customerId) {
+                    try {
+                        const customer = await client.get(`customers/${customerId}`);
+                        email = customer.email;
+                        websiteId = customer.website_id;
+                        console.log(chalk.gray(`Fetched customer ${customerId}: ${email} (Website: ${websiteId})`));
+                    } catch (e) {
+                        throw new Error(`Customer ${customerId} not found.`);
+                    }
+                } else {
+                    const answers = await inquirer.prompt([
+                        { name: 'email', message: 'Customer Email:' },
+                        { name: 'websiteId', message: 'Website ID:', default: '1' }
+                    ]);
+                    email = answers.email;
+                    websiteId = answers.websiteId;
+                }
+
+                if (!customerId && !options.redirectUrl) {
+                    const { redirectUrl } = await inquirer.prompt([
+                        { name: 'redirectUrl', message: 'Redirect URL (optional):' }
+                    ]);
+                    options.redirectUrl = redirectUrl;
+                }
+
+                const payload = {
+                    email: email,
+                    websiteId: parseInt(websiteId, 10),
+                    redirectUrl: options.redirectUrl || undefined
+                };
+
+                await client.post('customers/confirm', payload);
+                console.log(chalk.green(`✅ Confirmation email sent to ${email}`));
+            } catch (e) {
+                if (e.response && e.response.status === 400 && e.response.data && e.response.data.message === "Confirmation isn't needed.") {
+                    console.log(chalk.yellow('ℹ️  Confirmation is not needed for this customer (already confirmed).'));
+                } else {
+                    handleError(e);
+                }
+            }
+        });
+}

package/lib/commands/eav.js

@@ -0,0 +1,49 @@
+import { createClient } from '../api/factory.js';
+import { printTable, handleError } from '../utils.js';
+import chalk from 'chalk';
+
+export function registerEavCommands(program) {
+    const eav = program.command('eav').description('Manage EAV attributes and sets');
+
+    // Attribute Sets
+    const attributeSets = eav.command('attribute-set').description('Manage attribute sets');
+
+    attributeSets.command('list')
+        .description('List all attribute sets')
+        .option('-p, --page <number>', 'Page number', '1')
+        .option('-s, --size <number>', 'Page size', '20')
+        .action(async (options) => {
+            try {
+                const client = await createClient();
+                const params = {
+                    'searchCriteria[currentPage]': options.page,
+                    'searchCriteria[pageSize]': options.size
+                };
+                const data = await client.get('eav/attribute-sets/list', params);
+                const rows = (data.items || []).map(set => [
+                    set.attribute_set_id,
+                    set.attribute_set_name,
+                    set.entity_type_id,
+                    set.sort_order
+                ]);
+                console.log(chalk.bold(`Total: ${data.total_count}, Page: ${options.page}, Size: ${options.size}`));
+                printTable(['ID', 'Name', 'Entity Type ID', 'Sort Order'], rows);
+            } catch (e) { handleError(e); }
+        });
+
+    attributeSets.command('show <id>')
+        .description('Show attribute set details')
+        .action(async (id) => {
+            try {
+                const client = await createClient();
+                const data = await client.get(`eav/attribute-sets/${id}`);
+
+                console.log(chalk.bold.blue('\nAttribute Set Details:'));
+                console.log(`${chalk.bold('ID:')}             ${data.attribute_set_id}`);
+                console.log(`${chalk.bold('Name:')}           ${data.attribute_set_name}`);
+                console.log(`${chalk.bold('Entity Type ID:')} ${data.entity_type_id}`);
+                console.log(`${chalk.bold('Sort Order:')}     ${data.sort_order}`);
+
+            } catch (e) { handleError(e); }
+        });
+}

package/lib/commands/orders.js

@@ -0,0 +1,247 @@
+import { createClient } from '../api/factory.js';
+import { printTable, handleError } from '../utils.js';
+import chalk from 'chalk';
+import inquirer from 'inquirer';
+
+export function registerOrdersCommands(program) {
+    const orders = program.command('order').description('Manage orders');
+
+    orders.command('list')
+        .option('-p, --page <number>', 'Page number', '1')
+        .option('-s, --size <number>', 'Page size', '20')
+        .action(async (options) => {
+            try {
+                const client = await createClient();
+                const params = {
+                    'searchCriteria[currentPage]': options.page,
+                    'searchCriteria[pageSize]': options.size
+                };
+                const data = await client.get('orders', params);
+                const rows = (data.items || []).map(o => [o.entity_id, o.increment_id, o.status, o.grand_total, o.customer_email]);
+                console.log(chalk.bold(`Total: ${data.total_count}, Page: ${options.page}, Size: ${options.size}`));
+                printTable(['ID', 'Increment ID', 'Status', 'Total', 'Email'], rows);
+            } catch (e) { handleError(e); }
+        });
+
+    orders.command('search <query>')
+        .description('Search orders by Increment ID')
+        .action(async (query) => {
+            try {
+                const client = await createClient();
+                const params = {
+                    'searchCriteria[filter_groups][0][filters][0][field]': 'increment_id',
+                    'searchCriteria[filter_groups][0][filters][0][value]': `%${query}%`,
+                    'searchCriteria[filter_groups][0][filters][0][condition_type]': 'like'
+                };
+                const data = await client.get('orders', params);
+                const rows = (data.items || []).map(o => [o.entity_id, o.increment_id, o.status, o.grand_total]);
+                printTable(['ID', 'Increment ID', 'Status', 'Total'], rows);
+            } catch (e) { handleError(e); }
+        });
+
+    orders.command('edit <id>')
+        .description('Update order status (via Comment)')
+        .action(async (id) => {
+            try {
+                const client = await createClient();
+                // Check if order exists?
+                // Just ask for status
+                const answers = await inquirer.prompt([
+                    { name: 'status', message: 'New Status Code (e.g. pending, processing):' },
+                    { name: 'comment', message: 'Comment:' }
+                ]);
+
+                // POST /V1/orders/:id/comments
+                await client.post(`orders/${id}/comments`, {
+                    statusHistory: {
+                        comment: answers.comment,
+                        status: answers.status,
+                        is_customer_notified: 0,
+                        is_visible_on_front: 0
+                    }
+                });
+                console.log(chalk.green(`Order ${id} updated.`));
+            } catch (e) { handleError(e); }
+        });
+    orders.command('show <identifier>')
+        .description('Show detailed order information by ID or Increment ID')
+        .option('-f, --format <type>', 'Output format (text, json, xml)', 'text')
+        .action(async (identifier, options) => {
+            try {
+                await showOrder(identifier, options.format);
+            } catch (e) { handleError(e); }
+        });
+
+    orders.command('latest')
+        .description('List latest orders sorted by created_at DESC with selection')
+        .option('-p, --page <number>', 'Page number', '1')
+        .option('-z, --size <number>', 'Page size', '20')
+        .option('-s, --select', 'Interactive selection mode')
+        .action(async (options) => {
+            try {
+                const client = await createClient();
+                const params = {
+                    'searchCriteria[pageSize]': options.size,
+                    'searchCriteria[currentPage]': options.page,
+                    'searchCriteria[sortOrders][0][field]': 'created_at',
+                    'searchCriteria[sortOrders][0][direction]': 'DESC'
+                };
+                const data = await client.get('orders', params);
+                const items = data.items || [];
+
+                if (items.length === 0) {
+                    console.log('No orders found.');
+                    return;
+                }
+
+                const rows = (data.items || []).map(o => [o.entity_id, o.increment_id, o.status, o.grand_total, o.created_at]);
+                console.log(chalk.bold(`Total: ${data.total_count}, Page: ${options.page}, Size: ${options.size}`));
+                printTable(['ID', 'Increment ID', 'Status', 'Total', 'Created At'], rows);
+
+                if (options.select) {
+                    // Interactive selection
+                    const choices = items.map(o => ({
+                        name: `${o.increment_id} (ID: ${o.entity_id})`,
+                        value: o.entity_id
+                    }));
+
+                    // Add exit option
+                    choices.push({ name: 'Exit', value: null });
+
+                    const { orderId } = await inquirer.prompt([{
+                        type: 'list',
+                        name: 'orderId',
+                        message: `Select an order to view details (Page ${options.page}):`,
+                        choices,
+                        pageSize: 15
+                    }]);
+
+                    if (orderId) {
+                        await showOrder(orderId, 'text');
+                    }
+                }
+            } catch (e) { handleError(e); }
+        });
+}
+
+async function showOrder(identifier, format = 'text') {
+    const { createClient } = await import('../api/factory.js');
+    const { printTable } = await import('../utils.js');
+    const chalk = (await import('chalk')).default;
+    const client = await createClient();
+
+    let order;
+
+    // Map format to Accept header
+    let headers = {};
+    if (format === 'json') {
+        headers['Accept'] = 'application/json';
+    } else if (format === 'xml') {
+        headers['Accept'] = 'application/xml';
+    }
+
+    try {
+        order = await client.get(`orders/${identifier}`, {}, { headers });
+    } catch (e) {
+        // If 404, maybe it was an increment ID
+        // Or if user provided something that is definitely an increment ID
+        const params = {
+            'searchCriteria[filter_groups][0][filters][0][field]': 'increment_id',
+            'searchCriteria[filter_groups][0][filters][0][value]': identifier,
+            'searchCriteria[filter_groups][0][filters][0][condition_type]': 'eq'
+        };
+        const searchData = await client.get('orders', params);
+        if (searchData.items && searchData.items.length > 0) {
+            order = searchData.items[0];
+            // If format is specific, we might want to re-fetch by ID with headers if search didn't return format?
+            // Search API usually returns JSON. If user wants XML, search return helps find ID, then we fetch XML.
+            if (format !== 'text') {
+                try {
+                    order = await client.get(`orders/${order.entity_id}`, {}, { headers });
+                } catch (subError) {
+                    // ignore or log? If we fail to get formatted, fallback or throw?
+                    // If we found it via search, 'order' is the object. 
+                    // If format is json, we are good.
+                    // If format is xml, we NEED to re-fetch because 'order' is currently a JS object from JSON response.
+                    if (format === 'xml') throw subError;
+                }
+            }
+        } else {
+            throw new Error(`Order '${identifier}' not found.`);
+        }
+    }
+
+    if (format === 'xml') {
+        console.log(order); // Axios likely returns the XML string body
+        return;
+    }
+
+    if (format === 'json') {
+        // order is likely an object parsed by axios (if content-type was json)
+        console.log(JSON.stringify(order, null, 2));
+        return;
+    }
+
+    if (!order) throw new Error('Order not found');
+
+    const currency = order.order_currency_code || '';
+
+    console.log(chalk.bold.blue('\n📦 Order Information'));
+    console.log(chalk.gray('━'.repeat(50)));
+    console.log(`${chalk.bold('Increment ID:')}   ${order.increment_id}`);
+    console.log(`${chalk.bold('Internal ID:')}    ${order.entity_id}`);
+    console.log(`${chalk.bold('Status:')}         ${statusColor(order.status)} (${order.state})`);
+    console.log(`${chalk.bold('Created At:')}     ${order.created_at}`);
+    console.log(`${chalk.bold('Customer:')}       ${order.customer_firstname} ${order.customer_lastname} <${order.customer_email}>`);
+    console.log(`${chalk.bold('Grand Total:')}    ${chalk.green(order.grand_total + ' ' + currency)}`);
+    console.log(chalk.gray('━'.repeat(50)));
+
+    if (order.items && order.items.length > 0) {
+        console.log(chalk.bold('\n🛒 Items'));
+        const itemRows = order.items.map(item => [
+            item.sku,
+            item.name,
+            Math.floor(item.qty_ordered),
+            `${item.price} ${currency}`,
+            `${item.row_total} ${currency}`
+        ]);
+        printTable(['SKU', 'Name', 'Qty', 'Price', 'Subtotal'], itemRows);
+    }
+
+    if (order.billing_address || order.extension_attributes?.shipping_assignments?.[0]?.shipping?.address) {
+        console.log(chalk.bold('\n📍 Addresses'));
+
+        if (order.billing_address) {
+            console.log(chalk.bold.underline('Billing Address:'));
+            printAddress(order.billing_address);
+        }
+
+        const shippingAddress = order.extension_attributes?.shipping_assignments?.[0]?.shipping?.address;
+        if (shippingAddress) {
+            console.log(chalk.bold.underline('\nShipping Address:'));
+            printAddress(shippingAddress);
+        }
+    }
+}
+
+function statusColor(status) {
+    // Basic color coding
+    if (['pending'].includes(status)) return status;
+    if (['processing'].includes(status)) return status;
+    if (['complete'].includes(status)) return status; // green? 
+    // Since we don't have direct chalk access in this helper easily without passing it, 
+    // and I don't want to import it again if I can avoid it or I can just return string.
+    // Actually, I can import properly in module scope if I change top imports but I am overwriting the file so I can add imports.
+    return status;
+}
+
+function printAddress(addr) {
+    const lines = [
+        `${addr.firstname} ${addr.lastname}`,
+        ...(addr.street || []),
+        `${addr.city}, ${addr.region || ''} ${addr.postcode}`,
+        addr.country_id,
+        addr.telephone ? `T: ${addr.telephone}` : null
+    ].filter(Boolean);
+    console.log(lines.join('\n'));
+}

package/lib/commands/products.js

@@ -0,0 +1,133 @@
+import { createClient } from '../api/factory.js';
+import { printTable, handleError } from '../utils.js';
+import chalk from 'chalk';
+
+export function registerProductsCommands(program) {
+    const products = program.command('product').description('Manage products');
+
+    products.command('types')
+        .description('List available product types')
+        .action(async () => {
+            try {
+                const client = await createClient();
+                const data = await client.get('products/types');
+                const rows = (data || []).map(t => [t.name, t.label]);
+                printTable(['Name (ID)', 'Label'], rows);
+            } catch (e) { handleError(e); }
+        });
+
+    const attributes = products.command('attribute').description('Manage product attributes');
+
+    attributes.command('list')
+        .description('List product attributes')
+        .option('-p, --page <number>', 'Page number', '1')
+        .option('-s, --size <number>', 'Page size', '20')
+        .action(async (options) => {
+            try {
+                const client = await createClient();
+                const params = {
+                    'searchCriteria[currentPage]': options.page,
+                    'searchCriteria[pageSize]': options.size,
+                    'searchCriteria[sortOrders][0][field]': 'attribute_code',
+                    'searchCriteria[sortOrders][0][direction]': 'ASC'
+                };
+                const data = await client.get('products/attributes', params);
+                const rows = (data.items || []).map(a => [
+                    a.attribute_id,
+                    a.attribute_code,
+                    a.default_frontend_label,
+                    a.is_required,
+                    a.is_user_defined
+                ]);
+                console.log(chalk.bold(`Total: ${data.total_count}, Page: ${options.page}, Size: ${options.size}`));
+                printTable(['ID', 'Code', 'Label', 'Required', 'User Defined'], rows);
+            } catch (e) { handleError(e); }
+        });
+
+    attributes.command('show <attributeCode>')
+        .description('Show product attribute details')
+        .option('-f, --format <type>', 'Output format (text, json, xml)', 'text')
+        .action(async (attributeCode, options) => {
+            try {
+                const client = await createClient();
+                let headers = {};
+                if (options.format === 'json') headers['Accept'] = 'application/json';
+                else if (options.format === 'xml') headers['Accept'] = 'application/xml';
+
+                let data;
+                try {
+                    data = await client.get(`products/attributes/${attributeCode}`, {}, { headers });
+                } catch (e) {
+                    throw new Error(`Attribute '${attributeCode}' not found.`);
+                }
+
+                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📦 Attribute Information'));
+                console.log(chalk.gray('━'.repeat(60)));
+
+                // Helper for boolean display
+                const showBool = (val) => {
+                    const isTrue = val === '1' || val === 1 || val === true || val === 'true';
+                    return isTrue ? chalk.green('✅ Yes') : chalk.red('❌ No');
+                };
+
+                // General
+                console.log(chalk.bold('\nℹ️  General Information'));
+                console.log(`  ${chalk.bold('ID:')}             ${data.attribute_id}`);
+                console.log(`  ${chalk.bold('Code:')}           ${data.attribute_code}`);
+                console.log(`  ${chalk.bold('Default Label:')}  ${data.default_frontend_label}`);
+                console.log(`  ${chalk.bold('Required:')}       ${showBool(data.is_required)}`);
+                console.log(`  ${chalk.bold('User Defined:')}   ${showBool(data.is_user_defined)}`);
+                console.log(`  ${chalk.bold('Unique:')}         ${showBool(data.is_unique)}`);
+
+                // Frontend Properties
+                console.log(chalk.bold('\n🎨 Frontend Properties'));
+                console.log(`  ${chalk.bold('Input Type:')}     ${data.frontend_input}`);
+                console.log(`  ${chalk.bold('Class:')}          ${data.frontend_class || '-'}`);
+                console.log(`  ${chalk.bold('Visible on Front:')} ${showBool(data.is_visible_on_front)}`);
+                console.log(`  ${chalk.bold('HTML Allowed:')}   ${showBool(data.is_html_allowed_on_front)}`);
+
+                // Storefront Properties
+                console.log(chalk.bold('\n🏪 Storefront Properties'));
+                console.log(`  ${chalk.bold('Searchable:')}     ${showBool(data.is_searchable)}`);
+                console.log(`  ${chalk.bold('Filterable:')}     ${showBool(data.is_filterable_in_search)}`);
+                console.log(`  ${chalk.bold('Comparable:')}     ${showBool(data.is_comparable)}`);
+                console.log(`  ${chalk.bold('Sort By:')}        ${showBool(data.used_for_sort_by)}`);
+                console.log(`  ${chalk.bold('Promo Rules:')}    ${showBool(data.is_used_for_promo_rules)}`);
+
+                console.log(chalk.gray('━'.repeat(60)));
+
+                if (data.options && data.options.length > 0) {
+                    // Filter out empty options if needed, but showing all is safer
+                    // Often option value '' is a placeholder
+                    const visibleOptions = data.options.filter(o => o.value !== '' && o.label !== '');
+                    if (visibleOptions.length > 0) {
+                        console.log(chalk.bold('\n📋 Options'));
+                        const optRows = visibleOptions.map(o => [o.value, o.label]);
+                        printTable(['Value', 'Label'], optRows);
+                    }
+                }
+
+            } catch (e) { handleError(e); }
+        });
+
+    const attributeTypes = attributes.command('type').description('Manage attribute types');
+    attributeTypes.command('list')
+        .description('List product attribute types')
+        .action(async () => {
+            try {
+                const client = await createClient();
+                const data = await client.get('products/attributes/types');
+                const rows = (data || []).map(t => [t.value, t.label]);
+                printTable(['Value', 'Label'], rows);
+            } catch (e) { handleError(e); }
+        });
+}