hetzner-cli 2.0.0

package/dist/robot/commands/auth.js

@@ -0,0 +1,54 @@
+import { promptLogin, clearConfig, getCredentials, } from '../../shared/config.js';
+import * as fmt from '../../shared/formatter.js';
+import { asyncAction } from '../../shared/helpers.js';
+export function registerAuthCommands(parent) {
+    const auth = parent.command('auth').description('Authentication management');
+    auth
+        .command('login')
+        .description('Interactively configure credentials')
+        .action(async () => {
+        try {
+            await promptLogin();
+            console.log('');
+            console.log(fmt.success('Authentication configured successfully.'));
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === 'ExitPromptError') {
+                process.exit(0);
+            }
+            throw error;
+        }
+    });
+    auth
+        .command('logout')
+        .description('Clear saved credentials')
+        .action(async () => {
+        await clearConfig();
+        console.log(fmt.success('Credentials cleared.'));
+    });
+    auth
+        .command('status')
+        .description('Check authentication status')
+        .action(async () => {
+        const creds = await getCredentials();
+        if (creds) {
+            console.log(fmt.success(`Authenticated as: ${creds.user}`));
+            const sourceLabels = {
+                environment: 'environment variables',
+                keychain: 'keychain',
+                file: 'config file',
+            };
+            console.log(fmt.info('Stored in: ' + (sourceLabels[creds.source ?? ''] ?? 'unknown')));
+        }
+        else {
+            console.log(fmt.warning('Not authenticated. Run: hetzner auth login'));
+        }
+    });
+    auth
+        .command('test')
+        .description('Test API credentials')
+        .action(asyncAction(async (client) => {
+        const servers = await client.listServers();
+        console.log(fmt.success(`Authenticated successfully. Found ${servers.length} server(s).`));
+    }));
+}

package/dist/robot/commands/boot.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerBootCommands(parent: Command): void;

package/dist/robot/commands/boot.js

@@ -0,0 +1,72 @@
+import { asyncAction, output } from '../../shared/helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as robotFmt from '../formatter.js';
+export function registerBootCommands(parent) {
+    const boot = parent.command('boot').description('Boot configuration (rescue, linux, vnc, windows)');
+    boot
+        .command('status <server>')
+        .description('Show boot configuration status')
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        const { boot: bootConfig } = await client.getBootConfig(serverIdOrIp);
+        output(bootConfig, (b) => robotFmt.formatBootConfig(b, parseInt(serverIdOrIp) || 0), options);
+    }));
+    const rescue = boot.command('rescue').description('Rescue system management');
+    rescue
+        .command('activate <server>')
+        .description('Activate rescue system')
+        .option('-o, --os <os>', 'Operating system (linux, linuxold, vkvm)', 'linux')
+        .option('-a, --arch <arch>', 'Architecture (64 or 32)', '64')
+        .option('-k, --keys <fingerprints...>', 'SSH key fingerprints')
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        const { rescue: rsc } = await client.activateRescue(serverIdOrIp, options.os, parseInt(options.arch), options.keys);
+        console.log(robotFmt.formatRescueActivation(rsc));
+    }));
+    rescue
+        .command('deactivate <server>')
+        .description('Deactivate rescue system')
+        .action(asyncAction(async (client, serverIdOrIp) => {
+        await client.deactivateRescue(serverIdOrIp);
+        console.log(fmt.success('Rescue system deactivated.'));
+    }));
+    rescue
+        .command('last <server>')
+        .description('Show last rescue activation details')
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        const { rescue: rsc } = await client.getLastRescue(serverIdOrIp);
+        output(rsc, robotFmt.formatRescueActivation, options);
+    }));
+    const linux = boot.command('linux').description('Linux installation management');
+    linux
+        .command('activate <server>')
+        .description('Activate Linux installation')
+        .requiredOption('-d, --dist <dist>', 'Distribution (e.g., Debian-1210-bookworm-amd64-base)')
+        .option('-a, --arch <arch>', 'Architecture (64 or 32)', '64')
+        .option('-l, --lang <lang>', 'Language', 'en')
+        .option('-k, --keys <fingerprints...>', 'SSH key fingerprints')
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        const { linux: lnx } = await client.activateLinux(serverIdOrIp, options.dist, parseInt(options.arch), options.lang, options.keys);
+        console.log(robotFmt.formatLinuxActivation(lnx));
+    }));
+    linux
+        .command('deactivate <server>')
+        .description('Deactivate Linux installation')
+        .action(asyncAction(async (client, serverIdOrIp) => {
+        await client.deactivateLinux(serverIdOrIp);
+        console.log(fmt.success('Linux installation deactivated.'));
+    }));
+    linux
+        .command('options <server>')
+        .description('Show available Linux distributions')
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        const { linux: lnx } = await client.getLinux(serverIdOrIp);
+        output(lnx, (l) => {
+            const lines = [fmt.heading('Available Linux Distributions'), ''];
+            for (const dist of l.dist) {
+                lines.push(`  ${dist}`);
+            }
+            lines.push('', fmt.info(`Languages: ${l.lang.join(', ')}`));
+            lines.push(fmt.info(`Architectures: ${l.arch.join(', ')}-bit`));
+            return lines.join('\n');
+        }, options);
+    }));
+}

package/dist/robot/commands/cancel.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerCancelCommands(parent: Command): void;

package/dist/robot/commands/cancel.js

@@ -0,0 +1,36 @@
+import { asyncAction, output, confirmAction } from '../../shared/helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as robotFmt from '../formatter.js';
+export function registerCancelCommands(parent) {
+    const cancel = parent.command('cancel').description('Server cancellation');
+    cancel
+        .command('status <server>')
+        .description('Get cancellation status')
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        const { cancellation } = await client.getCancellation(serverIdOrIp);
+        output(cancellation, robotFmt.formatCancellation, options);
+    }));
+    cancel
+        .command('request <server>')
+        .description('Request server cancellation')
+        .option('--date <date>', 'Cancellation date (YYYY-MM-DD)')
+        .option('--reason <reasons...>', 'Cancellation reasons')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        if (!options.yes) {
+            console.log(fmt.warning('This will cancel your server!'));
+        }
+        if (!await confirmAction('Are you sure you want to cancel this server?', options))
+            return;
+        const { cancellation } = await client.cancelServer(serverIdOrIp, options.date, options.reason);
+        console.log(fmt.success('Cancellation requested.'));
+        console.log(robotFmt.formatCancellation(cancellation));
+    }));
+    cancel
+        .command('revoke <server>')
+        .description('Revoke server cancellation')
+        .action(asyncAction(async (client, serverIdOrIp) => {
+        await client.revokeCancellation(serverIdOrIp);
+        console.log(fmt.success('Cancellation revoked.'));
+    }));
+}

package/dist/robot/commands/failover.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerFailoverCommands(parent: Command): void;

package/dist/robot/commands/failover.js

@@ -0,0 +1,42 @@
+import { asyncAction, output, confirmAction } from '../../shared/helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as robotFmt from '../formatter.js';
+export function registerFailoverCommands(parent) {
+    const failover = parent.command('failover').description('Failover IP management');
+    failover
+        .command('list')
+        .alias('ls')
+        .description('List all failover IPs')
+        .action(asyncAction(async (client, options) => {
+        const failovers = await client.listFailovers();
+        output(failovers, robotFmt.formatFailoverList, options);
+    }));
+    failover
+        .command('get <ip>')
+        .alias('show')
+        .description('Get failover IP details')
+        .action(asyncAction(async (client, failoverIp, options) => {
+        const { failover: fo } = await client.getFailover(failoverIp);
+        output(fo, (f) => robotFmt.formatFailoverList([{ failover: f }]), options);
+    }));
+    failover
+        .command('switch <failover-ip> <target-server-ip>')
+        .description('Switch failover IP routing to another server')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(asyncAction(async (client, failoverIp, targetServerIp, options) => {
+        if (!await confirmAction(`Route ${failoverIp} to ${targetServerIp}?`, options, true))
+            return;
+        const { failover: fo } = await client.switchFailover(failoverIp, targetServerIp);
+        console.log(robotFmt.formatFailoverSwitch(fo));
+    }));
+    failover
+        .command('delete <ip>')
+        .description('Delete failover IP routing')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(asyncAction(async (client, failoverIp, options) => {
+        if (!await confirmAction(`Delete routing for ${failoverIp}?`, options))
+            return;
+        await client.deleteFailoverRouting(failoverIp);
+        console.log(fmt.success('Failover routing deleted.'));
+    }));
+}

package/dist/robot/commands/firewall.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerFirewallCommands(parent: Command): void;

package/dist/robot/commands/firewall.js

@@ -0,0 +1,66 @@
+import { asyncAction, output, confirmAction } from '../../shared/helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as robotFmt from '../formatter.js';
+export function registerFirewallCommands(parent) {
+    const firewall = parent.command('firewall').description('Firewall management');
+    firewall
+        .command('get <server>')
+        .alias('show')
+        .description('Get firewall configuration')
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        const { firewall: fw } = await client.getFirewall(serverIdOrIp);
+        output(fw, robotFmt.formatFirewall, options);
+    }));
+    firewall
+        .command('enable <server>')
+        .description('Enable firewall')
+        .action(asyncAction(async (client, serverIdOrIp) => {
+        await client.updateFirewall(serverIdOrIp, 'active');
+        console.log(fmt.success('Firewall enabled.'));
+    }));
+    firewall
+        .command('disable <server>')
+        .description('Disable firewall')
+        .action(asyncAction(async (client, serverIdOrIp) => {
+        await client.updateFirewall(serverIdOrIp, 'disabled');
+        console.log(fmt.success('Firewall disabled.'));
+    }));
+    firewall
+        .command('delete <server>')
+        .description('Delete all firewall rules')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        if (!await confirmAction('Delete all firewall rules?', options))
+            return;
+        await client.deleteFirewall(serverIdOrIp);
+        console.log(fmt.success('Firewall rules deleted.'));
+    }));
+    const fwTemplate = firewall.command('template').description('Firewall template management');
+    fwTemplate
+        .command('list')
+        .alias('ls')
+        .description('List firewall templates')
+        .action(asyncAction(async (client, options) => {
+        const templates = await client.listFirewallTemplates();
+        output(templates, robotFmt.formatFirewallTemplateList, options);
+    }));
+    fwTemplate
+        .command('get <id>')
+        .alias('show')
+        .description('Get firewall template details')
+        .action(asyncAction(async (client, templateId, options) => {
+        const { firewall_template: tmpl } = await client.getFirewallTemplate(parseInt(templateId));
+        output(tmpl, (t) => robotFmt.formatFirewallTemplateList([{ firewall_template: t }]), options);
+    }));
+    fwTemplate
+        .command('delete <id>')
+        .alias('rm')
+        .description('Delete firewall template')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(asyncAction(async (client, templateId, options) => {
+        if (!await confirmAction(`Delete firewall template ${templateId}?`, options))
+            return;
+        await client.deleteFirewallTemplate(parseInt(templateId));
+        console.log(fmt.success('Firewall template deleted.'));
+    }));
+}

package/dist/robot/commands/index.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerRobotCommands(parent: Command): void;

package/dist/robot/commands/index.js

@@ -0,0 +1,36 @@
+import { registerAuthCommands } from './auth.js';
+import { registerServerCommands } from './server.js';
+import { registerResetCommands } from './reset.js';
+import { registerBootCommands } from './boot.js';
+import { registerIpCommands } from './ip.js';
+import { registerSubnetCommands } from './subnet.js';
+import { registerFailoverCommands } from './failover.js';
+import { registerRdnsCommands } from './rdns.js';
+import { registerKeyCommands } from './key.js';
+import { registerFirewallCommands } from './firewall.js';
+import { registerVSwitchCommands } from './vswitch.js';
+import { registerStorageBoxCommands } from './storagebox.js';
+import { registerTrafficCommands } from './traffic.js';
+import { registerWolCommands } from './wol.js';
+import { registerCancelCommands } from './cancel.js';
+import { registerOrderCommands } from './order.js';
+import { registerInteractiveCommands } from './interactive.js';
+export function registerRobotCommands(parent) {
+    registerAuthCommands(parent);
+    registerServerCommands(parent);
+    registerResetCommands(parent);
+    registerBootCommands(parent);
+    registerIpCommands(parent);
+    registerSubnetCommands(parent);
+    registerFailoverCommands(parent);
+    registerRdnsCommands(parent);
+    registerKeyCommands(parent);
+    registerFirewallCommands(parent);
+    registerVSwitchCommands(parent);
+    registerStorageBoxCommands(parent);
+    registerTrafficCommands(parent);
+    registerWolCommands(parent);
+    registerCancelCommands(parent);
+    registerOrderCommands(parent);
+    registerInteractiveCommands(parent);
+}

package/dist/robot/commands/interactive.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerInteractiveCommands(parent: Command): void;

package/dist/robot/commands/interactive.js

@@ -0,0 +1,134 @@
+import { select, confirm, checkbox } from '@inquirer/prompts';
+import { asyncAction } from '../../shared/helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as robotFmt from '../formatter.js';
+export function registerInteractiveCommands(parent) {
+    parent
+        .command('interactive')
+        .alias('i')
+        .description('Interactive mode for common operations')
+        .action(asyncAction(async (client) => {
+        while (true) {
+            const action = await select({
+                message: 'What would you like to do?',
+                choices: [
+                    { value: 'servers', name: 'List servers' },
+                    { value: 'reset', name: 'Reset a server' },
+                    { value: 'rescue', name: 'Activate rescue mode' },
+                    { value: 'failover', name: 'Switch failover IP' },
+                    { value: 'keys', name: 'Manage SSH keys' },
+                    { value: 'exit', name: 'Exit' },
+                ],
+                pageSize: 10,
+            });
+            if (action === 'exit') {
+                console.log('Goodbye!');
+                break;
+            }
+            if (action === 'servers') {
+                const servers = await client.listServers();
+                console.log('');
+                console.log(robotFmt.formatServerList(servers));
+                console.log('');
+            }
+            if (action === 'reset') {
+                const servers = await client.listServers();
+                if (servers.length === 0) {
+                    console.log(fmt.info('No servers found.'));
+                    continue;
+                }
+                const selected = await checkbox({
+                    message: 'Select servers to reset:',
+                    choices: servers.map(({ server }) => ({
+                        value: server.server_ip,
+                        name: `${server.server_number} - ${server.server_ip} (${server.server_name || 'unnamed'})`,
+                    })),
+                });
+                if (selected.length === 0) {
+                    console.log('No servers selected.');
+                    continue;
+                }
+                const resetType = (await select({
+                    message: 'Select reset type:',
+                    choices: [
+                        { value: 'sw', name: 'Software reset (ACPI)' },
+                        { value: 'hw', name: 'Hardware reset (forced)' },
+                        { value: 'power', name: 'Power cycle' },
+                    ],
+                }));
+                const confirmed = await confirm({
+                    message: `Reset ${selected.length} server(s) with ${resetType}?`,
+                    default: false,
+                });
+                if (confirmed) {
+                    for (const srv of selected) {
+                        try {
+                            const { reset: rst } = await client.resetServer(srv, resetType);
+                            console.log(robotFmt.formatResetResult(rst, resetType));
+                        }
+                        catch (error) {
+                            console.log(fmt.error(`Failed to reset ${srv}: ${error instanceof Error ? error.message : 'Unknown'}`));
+                        }
+                    }
+                }
+            }
+            if (action === 'rescue') {
+                const servers = await client.listServers();
+                if (servers.length === 0) {
+                    console.log(fmt.info('No servers found.'));
+                    continue;
+                }
+                const serverIp = await select({
+                    message: 'Select server:',
+                    choices: servers.map(({ server }) => ({
+                        value: server.server_ip,
+                        name: `${server.server_number} - ${server.server_ip} (${server.server_name || 'unnamed'})`,
+                    })),
+                });
+                const os = await select({
+                    message: 'Select rescue OS:',
+                    choices: [
+                        { value: 'linux', name: 'Linux (64-bit)' },
+                        { value: 'linuxold', name: 'Linux (32-bit)' },
+                        { value: 'vkvm', name: 'vKVM' },
+                    ],
+                });
+                const { rescue } = await client.activateRescue(serverIp, os, 64);
+                console.log('');
+                console.log(robotFmt.formatRescueActivation(rescue));
+            }
+            if (action === 'failover') {
+                const failovers = await client.listFailovers();
+                if (failovers.length === 0) {
+                    console.log(fmt.info('No failover IPs found.'));
+                    continue;
+                }
+                const failoverIp = await select({
+                    message: 'Select failover IP:',
+                    choices: failovers.map(({ failover }) => ({
+                        value: failover.ip,
+                        name: `${failover.ip} -> ${failover.active_server_ip}`,
+                    })),
+                });
+                const servers = await client.listServers();
+                const targetIp = await select({
+                    message: 'Route to server:',
+                    choices: servers.map(({ server }) => ({
+                        value: server.server_ip,
+                        name: `${server.server_number} - ${server.server_ip}`,
+                    })),
+                });
+                const { failover: fo } = await client.switchFailover(failoverIp, targetIp);
+                console.log('');
+                console.log(robotFmt.formatFailoverSwitch(fo));
+            }
+            if (action === 'keys') {
+                const keys = await client.listSshKeys();
+                console.log('');
+                console.log(robotFmt.formatSshKeyList(keys));
+                console.log('');
+            }
+            console.log('');
+        }
+    }));
+}

package/dist/robot/commands/ip.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerIpCommands(parent: Command): void;

package/dist/robot/commands/ip.js

@@ -0,0 +1,52 @@
+import { asyncAction, output } from '../../shared/helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as robotFmt from '../formatter.js';
+export function registerIpCommands(parent) {
+    const ip = parent.command('ip').alias('ips').description('IP address management');
+    ip.command('list')
+        .alias('ls')
+        .description('List all IPs')
+        .action(asyncAction(async (client, options) => {
+        const ips = await client.listIps();
+        output(ips, robotFmt.formatIpList, options);
+    }));
+    ip.command('get <ip>')
+        .alias('show')
+        .description('Get IP details')
+        .action(asyncAction(async (client, ipAddr, options) => {
+        const { ip: ipData } = await client.getIp(ipAddr);
+        output(ipData, robotFmt.formatIpDetails, options);
+    }));
+    ip.command('update <ip>')
+        .description('Update IP traffic warning settings')
+        .option('--warnings <enabled>', 'Enable/disable traffic warnings (true/false)')
+        .option('--hourly <mb>', 'Hourly traffic limit in MB')
+        .option('--daily <mb>', 'Daily traffic limit in MB')
+        .option('--monthly <gb>', 'Monthly traffic limit in GB')
+        .action(asyncAction(async (client, ipAddr, options) => {
+        await client.updateIp(ipAddr, options.warnings ? options.warnings === 'true' : undefined, options.hourly ? parseInt(options.hourly) : undefined, options.daily ? parseInt(options.daily) : undefined, options.monthly ? parseInt(options.monthly) : undefined);
+        console.log(fmt.success(`IP ${ipAddr} updated.`));
+    }));
+    const mac = ip.command('mac').description('MAC address management');
+    mac
+        .command('get <ip>')
+        .description('Get separate MAC address for IP')
+        .action(asyncAction(async (client, ipAddr, options) => {
+        const { mac: macData } = await client.getIpMac(ipAddr);
+        output(macData, (m) => `IP: ${m.ip}\nMAC: ${m.mac}`, options);
+    }));
+    mac
+        .command('generate <ip>')
+        .description('Generate separate MAC address for IP')
+        .action(asyncAction(async (client, ipAddr) => {
+        const { mac: macData } = await client.generateIpMac(ipAddr);
+        console.log(fmt.success(`Generated MAC: ${macData.mac}`));
+    }));
+    mac
+        .command('delete <ip>')
+        .description('Delete separate MAC address')
+        .action(asyncAction(async (client, ipAddr) => {
+        await client.deleteIpMac(ipAddr);
+        console.log(fmt.success('MAC address deleted.'));
+    }));
+}

package/dist/robot/commands/key.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerKeyCommands(parent: Command): void;

package/dist/robot/commands/key.js

@@ -0,0 +1,64 @@
+import { input } from '@inquirer/prompts';
+import { readFileSync } from 'node:fs';
+import { asyncAction, output, confirmAction } from '../../shared/helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as robotFmt from '../formatter.js';
+export function registerKeyCommands(parent) {
+    const key = parent.command('key').alias('keys').description('SSH key management');
+    key
+        .command('list')
+        .alias('ls')
+        .description('List all SSH keys')
+        .action(asyncAction(async (client, options) => {
+        const keys = await client.listSshKeys();
+        output(keys, robotFmt.formatSshKeyList, options);
+    }));
+    key
+        .command('get <fingerprint>')
+        .alias('show')
+        .description('Get SSH key details')
+        .action(asyncAction(async (client, fingerprint, options) => {
+        const { key: keyData } = await client.getSshKey(fingerprint);
+        output(keyData, robotFmt.formatSshKeyDetails, options);
+    }));
+    key
+        .command('add <name>')
+        .description('Add a new SSH key')
+        .option('-f, --file <path>', 'Path to public key file')
+        .option('-d, --data <key>', 'Public key data')
+        .action(asyncAction(async (client, name, options) => {
+        let keyData;
+        if (options.file) {
+            keyData = readFileSync(options.file, 'utf-8').trim();
+        }
+        else if (options.data) {
+            keyData = options.data;
+        }
+        else {
+            keyData = await input({
+                message: 'Paste public key:',
+                validate: (v) => v.length > 0 || 'Key data is required',
+            });
+        }
+        const { key: newKey } = await client.createSshKey(name, keyData);
+        console.log(fmt.success(`SSH key added: ${newKey.fingerprint}`));
+    }));
+    key
+        .command('rename <fingerprint> <name>')
+        .description('Rename an SSH key')
+        .action(asyncAction(async (client, fingerprint, name) => {
+        await client.updateSshKey(fingerprint, name);
+        console.log(fmt.success(`SSH key renamed to: ${name}`));
+    }));
+    key
+        .command('delete <fingerprint>')
+        .alias('rm')
+        .description('Delete an SSH key')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(asyncAction(async (client, fingerprint, options) => {
+        if (!await confirmAction(`Delete SSH key ${fingerprint}?`, options))
+            return;
+        await client.deleteSshKey(fingerprint);
+        console.log(fmt.success('SSH key deleted.'));
+    }));
+}

package/dist/robot/commands/order.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerOrderCommands(parent: Command): void;

package/dist/robot/commands/order.js

@@ -0,0 +1,33 @@
+import { asyncAction, output } from '../../shared/helpers.js';
+import * as robotFmt from '../formatter.js';
+export function registerOrderCommands(parent) {
+    const order = parent.command('order').description('Server ordering');
+    order
+        .command('products')
+        .description('List available server products')
+        .action(asyncAction(async (client, options) => {
+        const products = await client.listServerProducts();
+        output(products, robotFmt.formatServerProductList, options);
+    }));
+    order
+        .command('market')
+        .description('List server market (auction) products')
+        .action(asyncAction(async (client, options) => {
+        const products = await client.listServerMarketProducts();
+        output(products, robotFmt.formatServerMarketProductList, options);
+    }));
+    order
+        .command('transactions')
+        .description('List order transactions')
+        .action(asyncAction(async (client, options) => {
+        const transactions = await client.listServerTransactions();
+        output(transactions, robotFmt.formatTransactionList, options);
+    }));
+    order
+        .command('transaction <id>')
+        .description('Get order transaction details')
+        .action(asyncAction(async (client, transactionId, options) => {
+        const { transaction } = await client.getServerTransaction(transactionId);
+        output(transaction, (t) => robotFmt.formatTransactionList([{ transaction: t }]), options);
+    }));
+}

package/dist/robot/commands/rdns.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerRdnsCommands(parent: Command): void;