hetzner-cli 2.0.0

package/dist/cloud/commands/load-balancer.js

@@ -0,0 +1,177 @@
+import { cloudAction, cloudOutput, cloudConfirm } from '../helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as cloudFmt from '../formatter.js';
+export function registerLoadBalancerCommands(parent) {
+    const lb = parent.command('load-balancer').description('Load balancer management');
+    lb.command('list').alias('ls').description('List all load balancers')
+        .option('-l, --label-selector <selector>', 'Label selector')
+        .option('-s, --sort <field>', 'Sort by field')
+        .action(cloudAction(async (client, options) => {
+        const lbs = await client.listLoadBalancers({ label_selector: options.labelSelector, sort: options.sort });
+        cloudOutput(lbs, cloudFmt.formatLoadBalancerList, options);
+    }));
+    lb.command('describe <id>').description('Show load balancer details')
+        .action(cloudAction(async (client, id, options) => {
+        const loadBalancer = await client.getLoadBalancer(parseInt(id));
+        cloudOutput(loadBalancer, cloudFmt.formatLoadBalancerDetails, options);
+    }));
+    lb.command('create').description('Create a load balancer')
+        .requiredOption('--name <name>', 'Load balancer name')
+        .requiredOption('--type <type>', 'Load balancer type')
+        .option('--location <loc>', 'Location')
+        .option('--network-zone <zone>', 'Network zone')
+        .option('--algorithm <algo>', 'Algorithm (round_robin, least_connections)', 'round_robin')
+        .action(cloudAction(async (client, options) => {
+        const { load_balancer: created } = await client.createLoadBalancer({
+            name: options.name,
+            load_balancer_type: options.type,
+            location: options.location,
+            network_zone: options.networkZone,
+            algorithm: options.algorithm ? { type: options.algorithm } : undefined,
+        });
+        console.log(fmt.success(`Load balancer '${created.name}' created (ID: ${created.id})`));
+    }));
+    lb.command('delete <id>').description('Delete a load balancer')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(cloudAction(async (client, id, options) => {
+        if (!await cloudConfirm(`Delete load balancer ${id}?`, options))
+            return;
+        await client.deleteLoadBalancer(parseInt(id));
+        console.log(fmt.success(`Load balancer ${id} deleted.`));
+    }));
+    lb.command('update <id>').description('Update load balancer')
+        .option('--name <name>', 'New name')
+        .action(cloudAction(async (client, id, options) => {
+        await client.updateLoadBalancer(parseInt(id), { name: options.name });
+        console.log(fmt.success(`Load balancer ${id} updated.`));
+    }));
+    lb.command('add-target <id>').description('Add target to load balancer')
+        .requiredOption('--type <type>', 'Target type (server, label_selector, ip)')
+        .option('--server <server>', 'Server ID')
+        .option('--label-selector <selector>', 'Label selector')
+        .option('--ip <ip>', 'IP address')
+        .option('--use-private-ip', 'Use private IP')
+        .action(cloudAction(async (client, id, options) => {
+        const target = { type: options.type, use_private_ip: !!options.usePrivateIp };
+        if (options.server)
+            target.server = { id: parseInt(options.server) };
+        if (options.labelSelector)
+            target.label_selector = { selector: options.labelSelector };
+        if (options.ip)
+            target.ip = { ip: options.ip };
+        await client.addTargetToLoadBalancer(parseInt(id), target);
+        console.log(fmt.success(`Target added to load balancer ${id}.`));
+    }));
+    lb.command('remove-target <id>').description('Remove target from load balancer')
+        .requiredOption('--type <type>', 'Target type (server, label_selector, ip)')
+        .option('--server <server>', 'Server ID')
+        .option('--label-selector <selector>', 'Label selector')
+        .option('--ip <ip>', 'IP address')
+        .action(cloudAction(async (client, id, options) => {
+        const target = { type: options.type };
+        if (options.server)
+            target.server = { id: parseInt(options.server) };
+        if (options.labelSelector)
+            target.label_selector = { selector: options.labelSelector };
+        if (options.ip)
+            target.ip = { ip: options.ip };
+        await client.removeTargetFromLoadBalancer(parseInt(id), target);
+        console.log(fmt.success(`Target removed from load balancer ${id}.`));
+    }));
+    lb.command('add-service <id>').description('Add service to load balancer')
+        .requiredOption('--protocol <protocol>', 'Protocol (tcp, http, https)')
+        .requiredOption('--listen-port <port>', 'Listen port')
+        .requiredOption('--destination-port <port>', 'Destination port')
+        .option('--proxyprotocol', 'Enable proxy protocol')
+        .action(cloudAction(async (client, id, options) => {
+        await client.addServiceToLoadBalancer(parseInt(id), {
+            protocol: options.protocol,
+            listen_port: parseInt(options.listenPort),
+            destination_port: parseInt(options.destinationPort),
+            proxyprotocol: !!options.proxyprotocol,
+            health_check: { protocol: options.protocol, port: parseInt(options.destinationPort), interval: 15, timeout: 10, retries: 3 },
+        });
+        console.log(fmt.success(`Service added to load balancer ${id}.`));
+    }));
+    lb.command('update-service <id>').description('Update a service on load balancer')
+        .requiredOption('--listen-port <port>', 'Listen port of the service to update')
+        .option('--protocol <protocol>', 'New protocol')
+        .option('--destination-port <port>', 'New destination port')
+        .option('--proxyprotocol <bool>', 'Enable/disable proxy protocol (true/false)')
+        .action(cloudAction(async (client, id, options) => {
+        const service = { listen_port: parseInt(options.listenPort) };
+        if (options.protocol)
+            service.protocol = options.protocol;
+        if (options.destinationPort)
+            service.destination_port = parseInt(options.destinationPort);
+        if (options.proxyprotocol !== undefined)
+            service.proxyprotocol = options.proxyprotocol === 'true';
+        await client.updateServiceOnLoadBalancer(parseInt(id), service);
+        console.log(fmt.success(`Service on load balancer ${id} updated.`));
+    }));
+    lb.command('delete-service <id>').description('Delete a service from load balancer')
+        .requiredOption('--listen-port <port>', 'Listen port of the service to delete')
+        .action(cloudAction(async (client, id, options) => {
+        await client.deleteServiceFromLoadBalancer(parseInt(id), parseInt(options.listenPort));
+        console.log(fmt.success(`Service on port ${options.listenPort} deleted from load balancer ${id}.`));
+    }));
+    lb.command('change-algorithm <id>').description('Change load balancer algorithm')
+        .requiredOption('--algorithm <type>', 'Algorithm type (round_robin, least_connections)')
+        .action(cloudAction(async (client, id, options) => {
+        await client.changeLoadBalancerAlgorithm(parseInt(id), options.algorithm);
+        console.log(fmt.success(`Algorithm changed for load balancer ${id}.`));
+    }));
+    lb.command('change-type <id>').description('Change load balancer type')
+        .requiredOption('--type <type>', 'New load balancer type')
+        .action(cloudAction(async (client, id, options) => {
+        await client.changeLoadBalancerType(parseInt(id), options.type);
+        console.log(fmt.success(`Type changed for load balancer ${id}.`));
+    }));
+    lb.command('attach-to-network <id>').description('Attach load balancer to network')
+        .requiredOption('--network <network>', 'Network ID')
+        .option('--ip <ip>', 'IP address in network')
+        .action(cloudAction(async (client, id, options) => {
+        await client.attachLoadBalancerToNetwork(parseInt(id), parseInt(options.network), options.ip);
+        console.log(fmt.success(`Load balancer ${id} attached to network ${options.network}.`));
+    }));
+    lb.command('detach-from-network <id>').description('Detach load balancer from network')
+        .requiredOption('--network <network>', 'Network ID')
+        .action(cloudAction(async (client, id, options) => {
+        await client.detachLoadBalancerFromNetwork(parseInt(id), parseInt(options.network));
+        console.log(fmt.success(`Load balancer ${id} detached from network ${options.network}.`));
+    }));
+    lb.command('enable-public-interface <id>').description('Enable public interface')
+        .action(cloudAction(async (client, id) => {
+        await client.enableLoadBalancerPublicInterface(parseInt(id));
+        console.log(fmt.success(`Public interface enabled for load balancer ${id}.`));
+    }));
+    lb.command('disable-public-interface <id>').description('Disable public interface')
+        .action(cloudAction(async (client, id) => {
+        await client.disableLoadBalancerPublicInterface(parseInt(id));
+        console.log(fmt.success(`Public interface disabled for load balancer ${id}.`));
+    }));
+    lb.command('enable-protection <id>').description('Enable delete protection')
+        .action(cloudAction(async (client, id) => {
+        await client.changeLoadBalancerProtection(parseInt(id), true);
+        console.log(fmt.success(`Protection enabled for load balancer ${id}.`));
+    }));
+    lb.command('disable-protection <id>').description('Disable delete protection')
+        .action(cloudAction(async (client, id) => {
+        await client.changeLoadBalancerProtection(parseInt(id), false);
+        console.log(fmt.success(`Protection disabled for load balancer ${id}.`));
+    }));
+    lb.command('add-label <id> <label>').description('Add a label (key=value)')
+        .action(cloudAction(async (client, id, label) => {
+        const loadBalancer = await client.getLoadBalancer(parseInt(id));
+        const [key, value] = label.split('=');
+        await client.updateLoadBalancer(parseInt(id), { labels: { ...loadBalancer.labels, [key]: value || '' } });
+        console.log(fmt.success(`Label '${key}' added.`));
+    }));
+    lb.command('remove-label <id> <key>').description('Remove a label')
+        .action(cloudAction(async (client, id, key) => {
+        const loadBalancer = await client.getLoadBalancer(parseInt(id));
+        const labels = Object.fromEntries(Object.entries(loadBalancer.labels).filter(([k]) => k !== key));
+        await client.updateLoadBalancer(parseInt(id), { labels });
+        console.log(fmt.success(`Label '${key}' removed.`));
+    }));
+}

package/dist/cloud/commands/location.d.ts

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

package/dist/cloud/commands/location.js

@@ -0,0 +1,20 @@
+import { cloudAction, cloudOutput } from '../helpers.js';
+import * as cloudFmt from '../formatter.js';
+export function registerLocationCommands(parent) {
+    const location = parent.command('location').description('Location information');
+    location
+        .command('list')
+        .alias('ls')
+        .description('List all locations')
+        .action(cloudAction(async (client, options) => {
+        const locations = await client.listLocations();
+        cloudOutput(locations, cloudFmt.formatLocationList, options);
+    }));
+    location
+        .command('describe <id>')
+        .description('Show location details')
+        .action(cloudAction(async (client, id, options) => {
+        const location = await client.getLocation(parseInt(id));
+        cloudOutput(location, cloudFmt.formatLocationDetails, options);
+    }));
+}

package/dist/cloud/commands/network.d.ts

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

package/dist/cloud/commands/network.js

@@ -0,0 +1,96 @@
+import { cloudAction, cloudOutput, cloudConfirm } from '../helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as cloudFmt from '../formatter.js';
+export function registerNetworkCommands(parent) {
+    const network = parent.command('network').description('Network management');
+    network.command('list').alias('ls').description('List all networks')
+        .option('-l, --label-selector <selector>', 'Label selector')
+        .action(cloudAction(async (client, options) => {
+        const networks = await client.listNetworks({ label_selector: options.labelSelector });
+        cloudOutput(networks, cloudFmt.formatNetworkList, options);
+    }));
+    network.command('describe <id>').description('Show network details')
+        .action(cloudAction(async (client, id, options) => {
+        const net = await client.getNetwork(parseInt(id));
+        cloudOutput(net, cloudFmt.formatNetworkDetails, options);
+    }));
+    network.command('create').description('Create a network')
+        .requiredOption('--name <name>', 'Network name')
+        .requiredOption('--ip-range <range>', 'IP range (CIDR)')
+        .action(cloudAction(async (client, options) => {
+        const { network: net } = await client.createNetwork({ name: options.name, ip_range: options.ipRange });
+        console.log(fmt.success(`Network '${net.name}' created (ID: ${net.id})`));
+    }));
+    network.command('delete <id>').description('Delete a network')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(cloudAction(async (client, id, options) => {
+        if (!await cloudConfirm(`Delete network ${id}?`, options))
+            return;
+        await client.deleteNetwork(parseInt(id));
+        console.log(fmt.success(`Network ${id} deleted.`));
+    }));
+    network.command('update <id>').description('Update a network')
+        .option('--name <name>', 'New name')
+        .action(cloudAction(async (client, id, options) => {
+        await client.updateNetwork(parseInt(id), { name: options.name });
+        console.log(fmt.success(`Network ${id} updated.`));
+    }));
+    network.command('add-subnet <id>').description('Add subnet to network')
+        .requiredOption('--ip-range <range>', 'Subnet IP range')
+        .requiredOption('--type <type>', 'Subnet type (cloud, server, vswitch)')
+        .requiredOption('--network-zone <zone>', 'Network zone')
+        .action(cloudAction(async (client, id, options) => {
+        await client.addSubnetToNetwork(parseInt(id), { ip_range: options.ipRange, type: options.type, network_zone: options.networkZone });
+        console.log(fmt.success('Subnet added.'));
+    }));
+    network.command('delete-subnet <id>').description('Delete subnet from network')
+        .requiredOption('--ip-range <range>', 'Subnet IP range to delete')
+        .action(cloudAction(async (client, id, options) => {
+        await client.deleteSubnetFromNetwork(parseInt(id), options.ipRange);
+        console.log(fmt.success('Subnet deleted.'));
+    }));
+    network.command('add-route <id>').description('Add route to network')
+        .requiredOption('--destination <cidr>', 'Destination CIDR')
+        .requiredOption('--gateway <ip>', 'Gateway IP')
+        .action(cloudAction(async (client, id, options) => {
+        await client.addRouteToNetwork(parseInt(id), { destination: options.destination, gateway: options.gateway });
+        console.log(fmt.success('Route added.'));
+    }));
+    network.command('delete-route <id>').description('Delete route from network')
+        .requiredOption('--destination <cidr>', 'Destination CIDR')
+        .requiredOption('--gateway <ip>', 'Gateway IP')
+        .action(cloudAction(async (client, id, options) => {
+        await client.deleteRouteFromNetwork(parseInt(id), { destination: options.destination, gateway: options.gateway });
+        console.log(fmt.success('Route deleted.'));
+    }));
+    network.command('change-ip-range <id>').description('Change network IP range')
+        .requiredOption('--ip-range <range>', 'New IP range')
+        .action(cloudAction(async (client, id, options) => {
+        await client.changeNetworkIpRange(parseInt(id), options.ipRange);
+        console.log(fmt.success('IP range changed.'));
+    }));
+    network.command('enable-protection <id>').description('Enable delete protection')
+        .action(cloudAction(async (client, id) => {
+        await client.changeNetworkProtection(parseInt(id), true);
+        console.log(fmt.success(`Protection enabled for network ${id}.`));
+    }));
+    network.command('disable-protection <id>').description('Disable delete protection')
+        .action(cloudAction(async (client, id) => {
+        await client.changeNetworkProtection(parseInt(id), false);
+        console.log(fmt.success(`Protection disabled for network ${id}.`));
+    }));
+    network.command('add-label <id> <label>').description('Add a label (key=value)')
+        .action(cloudAction(async (client, id, label) => {
+        const net = await client.getNetwork(parseInt(id));
+        const [key, value] = label.split('=');
+        await client.updateNetwork(parseInt(id), { labels: { ...net.labels, [key]: value || '' } });
+        console.log(fmt.success(`Label '${key}' added.`));
+    }));
+    network.command('remove-label <id> <key>').description('Remove a label')
+        .action(cloudAction(async (client, id, key) => {
+        const net = await client.getNetwork(parseInt(id));
+        const labels = Object.fromEntries(Object.entries(net.labels).filter(([k]) => k !== key));
+        await client.updateNetwork(parseInt(id), { labels });
+        console.log(fmt.success(`Label '${key}' removed.`));
+    }));
+}

package/dist/cloud/commands/placement-group.d.ts

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

package/dist/cloud/commands/placement-group.js

@@ -0,0 +1,53 @@
+import { cloudAction, cloudOutput, cloudConfirm } from '../helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as cloudFmt from '../formatter.js';
+export function registerPlacementGroupCommands(parent) {
+    const pg = parent.command('placement-group').description('Placement group management');
+    pg.command('list').alias('ls').description('List all placement groups')
+        .option('-l, --label-selector <selector>', 'Label selector')
+        .option('-s, --sort <field>', 'Sort by field')
+        .action(cloudAction(async (client, options) => {
+        const groups = await client.listPlacementGroups({ label_selector: options.labelSelector, sort: options.sort });
+        cloudOutput(groups, cloudFmt.formatPlacementGroupList, options);
+    }));
+    pg.command('describe <id>').description('Show placement group details')
+        .action(cloudAction(async (client, id, options) => {
+        const group = await client.getPlacementGroup(parseInt(id));
+        cloudOutput(group, cloudFmt.formatPlacementGroupDetails, options);
+    }));
+    pg.command('create').description('Create a placement group')
+        .requiredOption('--name <name>', 'Placement group name')
+        .option('--type <type>', 'Placement group type', 'spread')
+        .action(cloudAction(async (client, options) => {
+        const { placement_group: group } = await client.createPlacementGroup({ name: options.name, type: (options.type || 'spread') });
+        console.log(fmt.success(`Placement group '${group.name}' created (ID: ${group.id})`));
+    }));
+    pg.command('delete <id>').description('Delete a placement group')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(cloudAction(async (client, id, options) => {
+        if (!await cloudConfirm(`Delete placement group ${id}?`, options))
+            return;
+        await client.deletePlacementGroup(parseInt(id));
+        console.log(fmt.success(`Placement group ${id} deleted.`));
+    }));
+    pg.command('update <id>').description('Update placement group')
+        .option('--name <name>', 'New name')
+        .action(cloudAction(async (client, id, options) => {
+        await client.updatePlacementGroup(parseInt(id), { name: options.name });
+        console.log(fmt.success(`Placement group ${id} updated.`));
+    }));
+    pg.command('add-label <id> <label>').description('Add a label (key=value)')
+        .action(cloudAction(async (client, id, label) => {
+        const group = await client.getPlacementGroup(parseInt(id));
+        const [key, value] = label.split('=');
+        await client.updatePlacementGroup(parseInt(id), { labels: { ...group.labels, [key]: value || '' } });
+        console.log(fmt.success(`Label '${key}' added.`));
+    }));
+    pg.command('remove-label <id> <key>').description('Remove a label')
+        .action(cloudAction(async (client, id, key) => {
+        const group = await client.getPlacementGroup(parseInt(id));
+        const labels = Object.fromEntries(Object.entries(group.labels).filter(([k]) => k !== key));
+        await client.updatePlacementGroup(parseInt(id), { labels });
+        console.log(fmt.success(`Label '${key}' removed.`));
+    }));
+}

package/dist/cloud/commands/primary-ip.d.ts

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

package/dist/cloud/commands/primary-ip.js

@@ -0,0 +1,83 @@
+import { cloudAction, cloudOutput, cloudConfirm } from '../helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as cloudFmt from '../formatter.js';
+export function registerPrimaryIpCommands(parent) {
+    const pip = parent.command('primary-ip').description('Primary IP management');
+    pip.command('list').alias('ls').description('List all primary IPs')
+        .option('-l, --label-selector <selector>', 'Label selector')
+        .action(cloudAction(async (client, options) => {
+        const ips = await client.listPrimaryIps({ label_selector: options.labelSelector });
+        cloudOutput(ips, cloudFmt.formatPrimaryIpList, options);
+    }));
+    pip.command('describe <id>').description('Show primary IP details')
+        .action(cloudAction(async (client, id, options) => {
+        const ip = await client.getPrimaryIp(parseInt(id));
+        cloudOutput(ip, cloudFmt.formatPrimaryIpDetails, options);
+    }));
+    pip.command('create').description('Create a primary IP')
+        .requiredOption('--type <type>', 'IP type (ipv4, ipv6)')
+        .requiredOption('--name <name>', 'Name')
+        .option('--datacenter <dc>', 'Datacenter')
+        .option('--assignee-id <id>', 'Server to assign to')
+        .option('--auto-delete', 'Auto-delete with server')
+        .action(cloudAction(async (client, options) => {
+        const { primary_ip: ip } = await client.createPrimaryIp({ type: options.type, name: options.name, assignee_type: 'server', datacenter: options.datacenter, assignee_id: options.assigneeId ? parseInt(options.assigneeId) : undefined, auto_delete: options.autoDelete });
+        console.log(fmt.success(`Primary IP created (ID: ${ip.id}, IP: ${ip.ip})`));
+    }));
+    pip.command('delete <id>').description('Delete a primary IP')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(cloudAction(async (client, id, options) => {
+        if (!await cloudConfirm(`Delete primary IP ${id}?`, options))
+            return;
+        await client.deletePrimaryIp(parseInt(id));
+        console.log(fmt.success(`Primary IP ${id} deleted.`));
+    }));
+    pip.command('update <id>').description('Update primary IP')
+        .option('--name <name>', 'New name')
+        .option('--auto-delete <bool>', 'Auto-delete with server (true/false)')
+        .action(cloudAction(async (client, id, options) => {
+        await client.updatePrimaryIp(parseInt(id), { name: options.name, auto_delete: options.autoDelete ? options.autoDelete === 'true' : undefined });
+        console.log(fmt.success(`Primary IP ${id} updated.`));
+    }));
+    pip.command('assign <id> <server>').description('Assign primary IP to server')
+        .action(cloudAction(async (client, id, server) => {
+        await client.assignPrimaryIp(parseInt(id), parseInt(server));
+        console.log(fmt.success(`Primary IP ${id} assigned to server ${server}.`));
+    }));
+    pip.command('unassign <id>').description('Unassign primary IP')
+        .action(cloudAction(async (client, id) => {
+        await client.unassignPrimaryIp(parseInt(id));
+        console.log(fmt.success(`Primary IP ${id} unassigned.`));
+    }));
+    pip.command('enable-protection <id>').description('Enable delete protection')
+        .action(cloudAction(async (client, id) => {
+        await client.changePrimaryIpProtection(parseInt(id), true);
+        console.log(fmt.success(`Protection enabled for primary IP ${id}.`));
+    }));
+    pip.command('disable-protection <id>').description('Disable delete protection')
+        .action(cloudAction(async (client, id) => {
+        await client.changePrimaryIpProtection(parseInt(id), false);
+        console.log(fmt.success(`Protection disabled for primary IP ${id}.`));
+    }));
+    pip.command('set-rdns <id>').description('Set reverse DNS')
+        .requiredOption('--ip <ip>', 'IP address')
+        .requiredOption('--dns-ptr <ptr>', 'DNS pointer (empty to reset)')
+        .action(cloudAction(async (client, id, options) => {
+        await client.changePrimaryIpDnsPtr(parseInt(id), options.ip, options.dnsPtr || null);
+        console.log(fmt.success('rDNS updated.'));
+    }));
+    pip.command('add-label <id> <label>').description('Add a label (key=value)')
+        .action(cloudAction(async (client, id, label) => {
+        const ip = await client.getPrimaryIp(parseInt(id));
+        const [key, value] = label.split('=');
+        await client.updatePrimaryIp(parseInt(id), { labels: { ...ip.labels, [key]: value || '' } });
+        console.log(fmt.success(`Label '${key}' added.`));
+    }));
+    pip.command('remove-label <id> <key>').description('Remove a label')
+        .action(cloudAction(async (client, id, key) => {
+        const ip = await client.getPrimaryIp(parseInt(id));
+        const labels = Object.fromEntries(Object.entries(ip.labels).filter(([k]) => k !== key));
+        await client.updatePrimaryIp(parseInt(id), { labels });
+        console.log(fmt.success(`Label '${key}' removed.`));
+    }));
+}

package/dist/cloud/commands/server-type.d.ts

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

package/dist/cloud/commands/server-type.js

@@ -0,0 +1,20 @@
+import { cloudAction, cloudOutput } from '../helpers.js';
+import * as cloudFmt from '../formatter.js';
+export function registerServerTypeCommands(parent) {
+    const serverType = parent.command('server-type').description('Server type information');
+    serverType
+        .command('list')
+        .alias('ls')
+        .description('List all server types')
+        .action(cloudAction(async (client, options) => {
+        const types = await client.listServerTypes();
+        cloudOutput(types, cloudFmt.formatServerTypeList, options);
+    }));
+    serverType
+        .command('describe <id>')
+        .description('Show server type details')
+        .action(cloudAction(async (client, id, options) => {
+        const type = await client.getServerType(parseInt(id));
+        cloudOutput(type, cloudFmt.formatServerTypeDetails, options);
+    }));
+}

package/dist/cloud/commands/server.d.ts

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