hetzner-cli 2.0.0

package/dist/robot/commands/rdns.js

@@ -0,0 +1,41 @@
+import { asyncAction, output } from '../../shared/helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as robotFmt from '../formatter.js';
+export function registerRdnsCommands(parent) {
+    const rdns = parent.command('rdns').description('Reverse DNS management');
+    rdns
+        .command('list')
+        .alias('ls')
+        .description('List all reverse DNS entries')
+        .action(asyncAction(async (client, options) => {
+        const entries = await client.listRdns();
+        output(entries, robotFmt.formatRdnsList, options);
+    }));
+    rdns
+        .command('get <ip>')
+        .alias('show')
+        .description('Get reverse DNS entry for IP')
+        .action(asyncAction(async (client, ipAddr, options) => {
+        const { rdns: entry } = await client.getRdns(ipAddr);
+        output(entry, (e) => `IP: ${e.ip}\nPTR: ${e.ptr}`, options);
+    }));
+    rdns
+        .command('set <ip> <ptr>')
+        .description('Create or update reverse DNS entry')
+        .action(asyncAction(async (client, ipAddr, ptr) => {
+        try {
+            await client.createRdns(ipAddr, ptr);
+        }
+        catch {
+            await client.updateRdns(ipAddr, ptr);
+        }
+        console.log(fmt.success(`rDNS set: ${ipAddr} -> ${ptr}`));
+    }));
+    rdns
+        .command('delete <ip>')
+        .description('Delete reverse DNS entry')
+        .action(asyncAction(async (client, ipAddr) => {
+        await client.deleteRdns(ipAddr);
+        console.log(fmt.success('rDNS entry deleted.'));
+    }));
+}

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

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

package/dist/robot/commands/reset.js

@@ -0,0 +1,77 @@
+import { Option } from 'commander';
+import { select, confirm } from '@inquirer/prompts';
+import { asyncAction, output } from '../../shared/helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as robotFmt from '../formatter.js';
+export function registerResetCommands(parent) {
+    const reset = parent.command('reset').description('Server reset operations');
+    reset
+        .command('options [server]')
+        .description('Show reset options for server(s)')
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        if (serverIdOrIp) {
+            const { reset: rst } = await client.getResetOptions(serverIdOrIp);
+            output(rst, robotFmt.formatResetOptions, options);
+        }
+        else {
+            const resets = await client.listResetOptions();
+            if (options.json) {
+                console.log(fmt.formatJson(resets));
+            }
+            else {
+                for (const { reset: rst } of resets) {
+                    console.log(robotFmt.formatResetOptions(rst));
+                    console.log('');
+                }
+            }
+        }
+    }));
+    reset
+        .command('execute <servers...>')
+        .alias('run')
+        .description('Reset one or more servers')
+        .addOption(new Option('-t, --type <type>', 'Reset type')
+        .choices(['sw', 'hw', 'man', 'power', 'power_long'])
+        .default('sw'))
+        .option('-i, --interactive', 'Interactively select reset type')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(asyncAction(async (client, servers, options) => {
+        let resetType = options.type;
+        if (options.interactive) {
+            resetType = (await select({
+                message: 'Select reset type:',
+                choices: [
+                    { value: 'sw', name: 'Software reset (ACPI) - Recommended' },
+                    { value: 'hw', name: 'Hardware reset (forced)' },
+                    { value: 'power', name: 'Power cycle' },
+                    { value: 'power_long', name: 'Long power cycle (10+ seconds)' },
+                    { value: 'man', name: 'Manual reset (technician)' },
+                ],
+            }));
+        }
+        if (!options.yes) {
+            console.log('');
+            console.log(fmt.warning(`About to reset ${servers.length} server(s) with type: ${resetType}`));
+            console.log(`Servers: ${servers.join(', ')}`);
+            console.log('');
+            const confirmed = await confirm({
+                message: 'Are you sure you want to proceed?',
+                default: false,
+            });
+            if (!confirmed) {
+                console.log('Aborted.');
+                return;
+            }
+        }
+        console.log('');
+        for (const srv of servers) {
+            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 error'}`));
+            }
+        }
+    }));
+}

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

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

package/dist/robot/commands/server.js

@@ -0,0 +1,29 @@
+import { asyncAction, output } from '../../shared/helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as robotFmt from '../formatter.js';
+export function registerServerCommands(parent) {
+    const server = parent.command('server').alias('servers').description('Server management');
+    server
+        .command('list')
+        .alias('ls')
+        .description('List all servers')
+        .action(asyncAction(async (client, options) => {
+        const servers = await client.listServers();
+        output(servers, robotFmt.formatServerList, options);
+    }));
+    server
+        .command('get <server>')
+        .alias('show')
+        .description('Get server details')
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        const { server: srv } = await client.getServer(serverIdOrIp);
+        output(srv, robotFmt.formatServerDetails, options);
+    }));
+    server
+        .command('rename <server> <name>')
+        .description('Rename a server')
+        .action(asyncAction(async (client, serverIdOrIp, name) => {
+        await client.updateServerName(serverIdOrIp, name);
+        console.log(fmt.success(`Server renamed to: ${name}`));
+    }));
+}

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

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

package/dist/robot/commands/storagebox.js

@@ -0,0 +1,116 @@
+import { asyncAction, output, confirmAction } from '../../shared/helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as robotFmt from '../formatter.js';
+export function registerStorageBoxCommands(parent) {
+    const storagebox = parent.command('storagebox').alias('storage').description('Storage Box management');
+    storagebox
+        .command('list')
+        .alias('ls')
+        .description('List all storage boxes')
+        .action(asyncAction(async (client, options) => {
+        const boxes = await client.listStorageBoxes();
+        output(boxes, robotFmt.formatStorageBoxList, options);
+    }));
+    storagebox
+        .command('get <id>')
+        .alias('show')
+        .description('Get storage box details')
+        .action(asyncAction(async (client, boxId, options) => {
+        const { storagebox: box } = await client.getStorageBox(parseInt(boxId));
+        output(box, robotFmt.formatStorageBoxDetails, options);
+    }));
+    storagebox
+        .command('update <id>')
+        .description('Update storage box settings')
+        .option('-n, --name <name>', 'Storage box name')
+        .option('--webdav <enabled>', 'Enable/disable WebDAV')
+        .option('--samba <enabled>', 'Enable/disable Samba/CIFS')
+        .option('--ssh <enabled>', 'Enable/disable SSH/SFTP')
+        .option('--external <enabled>', 'Enable/disable external reachability')
+        .option('--zfs <enabled>', 'Enable/disable ZFS')
+        .action(asyncAction(async (client, boxId, options) => {
+        await client.updateStorageBox(parseInt(boxId), options.name, options.webdav ? options.webdav === 'true' : undefined, options.samba ? options.samba === 'true' : undefined, options.ssh ? options.ssh === 'true' : undefined, options.external ? options.external === 'true' : undefined, options.zfs ? options.zfs === 'true' : undefined);
+        console.log(fmt.success('Storage box updated.'));
+    }));
+    storagebox
+        .command('reset-password <id>')
+        .description('Reset storage box password')
+        .action(asyncAction(async (client, boxId) => {
+        const { password } = await client.resetStorageBoxPassword(parseInt(boxId));
+        console.log(fmt.success('Password reset.'));
+        console.log(`New password: ${fmt.colorize(password, 'yellow')}`);
+    }));
+    const snapshot = storagebox.command('snapshot').description('Storage box snapshot management');
+    snapshot
+        .command('list <box-id>')
+        .alias('ls')
+        .description('List storage box snapshots')
+        .action(asyncAction(async (client, boxId, options) => {
+        const snapshots = await client.listStorageBoxSnapshots(parseInt(boxId));
+        output(snapshots, robotFmt.formatStorageBoxSnapshots, options);
+    }));
+    snapshot
+        .command('create <box-id>')
+        .description('Create a new snapshot')
+        .action(asyncAction(async (client, boxId) => {
+        const { snapshot: snap } = await client.createStorageBoxSnapshot(parseInt(boxId));
+        console.log(fmt.success(`Snapshot created: ${snap.name}`));
+    }));
+    snapshot
+        .command('delete <box-id> <name>')
+        .alias('rm')
+        .description('Delete a snapshot')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(asyncAction(async (client, boxId, snapshotName, options) => {
+        if (!await confirmAction(`Delete snapshot ${snapshotName}?`, options))
+            return;
+        await client.deleteStorageBoxSnapshot(parseInt(boxId), snapshotName);
+        console.log(fmt.success('Snapshot deleted.'));
+    }));
+    snapshot
+        .command('revert <box-id> <name>')
+        .description('Revert to a snapshot')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(asyncAction(async (client, boxId, snapshotName, options) => {
+        if (!options.yes) {
+            console.log(fmt.warning('This will revert your storage box to the snapshot state.'));
+        }
+        if (!await confirmAction(`Revert to snapshot ${snapshotName}?`, options))
+            return;
+        await client.revertStorageBoxSnapshot(parseInt(boxId), snapshotName);
+        console.log(fmt.success('Reverted to snapshot.'));
+    }));
+    const subaccount = storagebox.command('subaccount').description('Storage box subaccount management');
+    subaccount
+        .command('list <box-id>')
+        .alias('ls')
+        .description('List storage box subaccounts')
+        .action(asyncAction(async (client, boxId, options) => {
+        const subaccounts = await client.listStorageBoxSubaccounts(parseInt(boxId));
+        output(subaccounts, robotFmt.formatStorageBoxSubaccounts, options);
+    }));
+    subaccount
+        .command('create <box-id> <home-directory>')
+        .description('Create a new subaccount')
+        .option('--samba <enabled>', 'Enable Samba')
+        .option('--ssh <enabled>', 'Enable SSH')
+        .option('--webdav <enabled>', 'Enable WebDAV')
+        .option('--external <enabled>', 'Enable external reachability')
+        .option('--readonly <enabled>', 'Read-only access')
+        .option('--comment <comment>', 'Comment')
+        .action(asyncAction(async (client, boxId, homeDir, options) => {
+        const { subaccount: sub } = await client.createStorageBoxSubaccount(parseInt(boxId), homeDir, options.samba ? options.samba === 'true' : undefined, options.ssh ? options.ssh === 'true' : undefined, options.external ? options.external === 'true' : undefined, options.webdav ? options.webdav === 'true' : undefined, options.readonly ? options.readonly === 'true' : undefined, options.comment);
+        console.log(fmt.success(`Subaccount created: ${sub.username}`));
+    }));
+    subaccount
+        .command('delete <box-id> <username>')
+        .alias('rm')
+        .description('Delete a subaccount')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(asyncAction(async (client, boxId, username, options) => {
+        if (!await confirmAction(`Delete subaccount ${username}?`, options))
+            return;
+        await client.deleteStorageBoxSubaccount(parseInt(boxId), username);
+        console.log(fmt.success('Subaccount deleted.'));
+    }));
+}

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

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

package/dist/robot/commands/subnet.js

@@ -0,0 +1,21 @@
+import { asyncAction, output } from '../../shared/helpers.js';
+import * as robotFmt from '../formatter.js';
+export function registerSubnetCommands(parent) {
+    const subnet = parent.command('subnet').alias('subnets').description('Subnet management');
+    subnet
+        .command('list')
+        .alias('ls')
+        .description('List all subnets')
+        .action(asyncAction(async (client, options) => {
+        const subnets = await client.listSubnets();
+        output(subnets, robotFmt.formatSubnetList, options);
+    }));
+    subnet
+        .command('get <subnet>')
+        .alias('show')
+        .description('Get subnet details')
+        .action(asyncAction(async (client, netIp, options) => {
+        const { subnet: subnetData } = await client.getSubnet(netIp);
+        output(subnetData, (s) => robotFmt.formatSubnetList([{ subnet: s }]), options);
+    }));
+}

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

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

package/dist/robot/commands/traffic.js

@@ -0,0 +1,20 @@
+import { asyncAction, output } from '../../shared/helpers.js';
+import * as robotFmt from '../formatter.js';
+export function registerTrafficCommands(parent) {
+    const traffic = parent.command('traffic').description('Traffic analytics');
+    traffic
+        .command('query')
+        .description('Query traffic data')
+        .option('-i, --ip <ips...>', 'IP addresses to query')
+        .option('-s, --subnet <subnets...>', 'Subnets to query')
+        .option('--from <date>', 'Start date (YYYY-MM-DD)')
+        .option('--to <date>', 'End date (YYYY-MM-DD)')
+        .option('-t, --type <type>', 'Query type (day, month, year)', 'month')
+        .action(asyncAction(async (client, options) => {
+        const now = new Date();
+        const from = options.from || new Date(now.getFullYear(), now.getMonth(), 1).toISOString().split('T')[0];
+        const to = options.to || now.toISOString().split('T')[0];
+        const { traffic: trafficData } = await client.getTraffic(options.ip || [], options.subnet || [], from, to, options.type);
+        output(trafficData, robotFmt.formatTraffic, options);
+    }));
+}

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

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

package/dist/robot/commands/vswitch.js

@@ -0,0 +1,64 @@
+import { asyncAction, output, confirmAction } from '../../shared/helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as robotFmt from '../formatter.js';
+export function registerVSwitchCommands(parent) {
+    const vswitch = parent.command('vswitch').description('vSwitch management');
+    vswitch
+        .command('list')
+        .alias('ls')
+        .description('List all vSwitches')
+        .action(asyncAction(async (client, options) => {
+        const vswitches = await client.listVSwitches();
+        output(vswitches, robotFmt.formatVSwitchList, options);
+    }));
+    vswitch
+        .command('get <id>')
+        .alias('show')
+        .description('Get vSwitch details')
+        .action(asyncAction(async (client, vswitchId, options) => {
+        const { vswitch: vs } = await client.getVSwitch(parseInt(vswitchId));
+        output(vs, robotFmt.formatVSwitchDetails, options);
+    }));
+    vswitch
+        .command('create <name> <vlan>')
+        .description('Create a new vSwitch')
+        .action(asyncAction(async (client, name, vlan) => {
+        const { vswitch: vs } = await client.createVSwitch(name, parseInt(vlan));
+        console.log(fmt.success(`vSwitch created: ID ${vs.id}`));
+    }));
+    vswitch
+        .command('update <id>')
+        .description('Update vSwitch')
+        .option('-n, --name <name>', 'New name')
+        .option('-v, --vlan <vlan>', 'New VLAN ID')
+        .action(asyncAction(async (client, vswitchId, options) => {
+        await client.updateVSwitch(parseInt(vswitchId), options.name, options.vlan ? parseInt(options.vlan) : undefined);
+        console.log(fmt.success('vSwitch updated.'));
+    }));
+    vswitch
+        .command('delete <id>')
+        .alias('rm')
+        .description('Delete vSwitch')
+        .option('-y, --yes', 'Skip confirmation')
+        .option('--date <date>', 'Cancellation date (YYYY-MM-DD)')
+        .action(asyncAction(async (client, vswitchId, options) => {
+        if (!await confirmAction(`Delete vSwitch ${vswitchId}?`, options))
+            return;
+        await client.deleteVSwitch(parseInt(vswitchId), options.date);
+        console.log(fmt.success('vSwitch deleted.'));
+    }));
+    vswitch
+        .command('add-server <vswitch-id> <server>')
+        .description('Add server to vSwitch')
+        .action(asyncAction(async (client, vswitchId, serverIdOrIp) => {
+        await client.addServerToVSwitch(parseInt(vswitchId), serverIdOrIp);
+        console.log(fmt.success('Server added to vSwitch.'));
+    }));
+    vswitch
+        .command('remove-server <vswitch-id> <server>')
+        .description('Remove server from vSwitch')
+        .action(asyncAction(async (client, vswitchId, serverIdOrIp) => {
+        await client.removeServerFromVSwitch(parseInt(vswitchId), serverIdOrIp);
+        console.log(fmt.success('Server removed from vSwitch.'));
+    }));
+}

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

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

package/dist/robot/commands/wol.js

@@ -0,0 +1,20 @@
+import { asyncAction, output } from '../../shared/helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as robotFmt from '../formatter.js';
+export function registerWolCommands(parent) {
+    const wol = parent.command('wol').description('Wake on LAN');
+    wol
+        .command('status <server>')
+        .description('Check WoL status for server')
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        const { wol: wolData } = await client.getWol(serverIdOrIp);
+        output(wolData, (w) => `Server: ${w.server_number} (${w.server_ip})\n${fmt.info('Wake on LAN is available for this server.')}`, options);
+    }));
+    wol
+        .command('send <server>')
+        .description('Send Wake on LAN packet')
+        .action(asyncAction(async (client, serverIdOrIp) => {
+        const { wol: wolData } = await client.sendWol(serverIdOrIp);
+        console.log(robotFmt.formatWolResult(wolData));
+    }));
+}

package/dist/robot/formatter.d.ts

@@ -0,0 +1,58 @@
+import type { Server, ServerDetails, Reset, IP, Subnet, Failover, Rdns, SshKey, Firewall, FirewallTemplate, VSwitch, StorageBox, StorageBoxSnapshot, StorageBoxSubaccount, Traffic, Wol, ServerProduct, ServerMarketProduct, ServerTransaction, RescueConfig, LinuxConfig, BootConfig, Cancellation } from './types.js';
+export declare function formatServerList(servers: {
+    server: Server;
+}[]): string;
+export declare function formatServerDetails(server: ServerDetails): string;
+export declare function formatResetOptions(reset: Reset): string;
+export declare function formatResetResult(reset: Reset, type: string): string;
+export declare function formatBootConfig(config: BootConfig, serverNumber: number): string;
+export declare function formatRescueActivation(rescue: RescueConfig): string;
+export declare function formatLinuxActivation(linux: LinuxConfig): string;
+export declare function formatIpList(ips: {
+    ip: IP;
+}[]): string;
+export declare function formatIpDetails(ip: IP): string;
+export declare function formatSubnetList(subnets: {
+    subnet: Subnet;
+}[]): string;
+export declare function formatFailoverList(failovers: {
+    failover: Failover;
+}[]): string;
+export declare function formatFailoverSwitch(failover: Failover): string;
+export declare function formatRdnsList(entries: {
+    rdns: Rdns;
+}[]): string;
+export declare function formatSshKeyList(keys: {
+    key: SshKey;
+}[]): string;
+export declare function formatSshKeyDetails(key: SshKey): string;
+export declare function formatFirewall(firewall: Firewall): string;
+export declare function formatFirewallTemplateList(templates: {
+    firewall_template: FirewallTemplate;
+}[]): string;
+export declare function formatVSwitchList(vswitches: {
+    vswitch: VSwitch;
+}[]): string;
+export declare function formatVSwitchDetails(vswitch: VSwitch): string;
+export declare function formatStorageBoxList(boxes: {
+    storagebox: StorageBox;
+}[]): string;
+export declare function formatStorageBoxDetails(box: StorageBox): string;
+export declare function formatStorageBoxSnapshots(snapshots: {
+    snapshot: StorageBoxSnapshot;
+}[]): string;
+export declare function formatStorageBoxSubaccounts(subaccounts: {
+    subaccount: StorageBoxSubaccount;
+}[]): string;
+export declare function formatTraffic(traffic: Traffic): string;
+export declare function formatWolResult(wol: Wol): string;
+export declare function formatServerProductList(products: {
+    product: ServerProduct;
+}[]): string;
+export declare function formatServerMarketProductList(products: {
+    product: ServerMarketProduct;
+}[]): string;
+export declare function formatTransactionList(transactions: {
+    transaction: ServerTransaction;
+}[]): string;
+export declare function formatCancellation(cancellation: Cancellation): string;