hetzner-cli 2.0.0

package/dist/auction/client.d.ts

@@ -0,0 +1,4 @@
+import type { AuctionServer, AuctionFilterOptions, AuctionResponse } from '../types.js';
+export declare function fetchAuctionServers(currency?: 'EUR' | 'USD'): Promise<AuctionResponse>;
+export declare function filterAuctionServers(servers: AuctionServer[], filters: AuctionFilterOptions): AuctionServer[];
+export declare function sortAuctionServers(servers: AuctionServer[], field: string, desc: boolean): AuctionServer[];

package/dist/auction/client.js

@@ -0,0 +1,103 @@
+// ============================================================================
+// Hetzner Auction API Client (public, no auth required)
+// Endpoint: https://www.hetzner.com/_resources/app/data/app/live_data_sb_EUR.json
+// ============================================================================
+const AUCTION_BASE_URL = 'https://www.hetzner.com/_resources/app/data/app';
+export async function fetchAuctionServers(currency = 'EUR') {
+    const url = `${AUCTION_BASE_URL}/live_data_sb_${currency}.json`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch auction data: HTTP ${response.status}`);
+    }
+    return response.json();
+}
+export function filterAuctionServers(servers, filters) {
+    return servers.filter(s => {
+        if (filters.minPrice !== undefined && s.price < filters.minPrice)
+            return false;
+        if (filters.maxPrice !== undefined && s.price > filters.maxPrice)
+            return false;
+        if (filters.maxHourlyPrice !== undefined && s.hourly_price > filters.maxHourlyPrice)
+            return false;
+        if (filters.minRam !== undefined && s.ram_size < filters.minRam)
+            return false;
+        if (filters.maxRam !== undefined && s.ram_size > filters.maxRam)
+            return false;
+        if (filters.cpu && !s.cpu.toLowerCase().includes(filters.cpu.toLowerCase()))
+            return false;
+        if (filters.datacenter && !s.datacenter.toLowerCase().includes(filters.datacenter.toLowerCase()))
+            return false;
+        if (filters.minDiskSize !== undefined || filters.maxDiskSize !== undefined) {
+            const total = [...s.serverDiskData.nvme, ...s.serverDiskData.sata, ...s.serverDiskData.hdd]
+                .reduce((sum, d) => sum + d, 0);
+            if (filters.minDiskSize !== undefined && total < filters.minDiskSize)
+                return false;
+            if (filters.maxDiskSize !== undefined && total > filters.maxDiskSize)
+                return false;
+        }
+        if (filters.minDiskCount !== undefined && s.hdd_count < filters.minDiskCount)
+            return false;
+        if (filters.maxDiskCount !== undefined && s.hdd_count > filters.maxDiskCount)
+            return false;
+        if (filters.diskType) {
+            if (s.serverDiskData[filters.diskType].length === 0)
+                return false;
+        }
+        if (filters.ecc !== undefined && s.is_ecc !== filters.ecc)
+            return false;
+        if (filters.gpu !== undefined) {
+            const hasGpu = s.specials.includes('GPU');
+            if (filters.gpu !== hasGpu)
+                return false;
+        }
+        if (filters.inic !== undefined) {
+            const hasInic = s.specials.includes('iNIC');
+            if (filters.inic !== hasInic)
+                return false;
+        }
+        if (filters.highio !== undefined && s.is_highio !== filters.highio)
+            return false;
+        if (filters.specials) {
+            const search = filters.specials.toLowerCase();
+            if (!s.specials.some(sp => sp.toLowerCase().includes(search)))
+                return false;
+        }
+        if (filters.fixedPrice !== undefined && s.fixed_price !== filters.fixedPrice)
+            return false;
+        if (filters.maxSetupPrice !== undefined && s.setup_price > filters.maxSetupPrice)
+            return false;
+        if (filters.minCpuCount !== undefined && s.cpu_count < filters.minCpuCount)
+            return false;
+        if (filters.maxCpuCount !== undefined && s.cpu_count > filters.maxCpuCount)
+            return false;
+        if (filters.minBandwidth !== undefined && s.bandwidth < filters.minBandwidth)
+            return false;
+        if (filters.text) {
+            const searchText = filters.text.toLowerCase();
+            const haystack = s.description.join(' ').toLowerCase();
+            if (!haystack.includes(searchText))
+                return false;
+        }
+        return true;
+    });
+}
+export function sortAuctionServers(servers, field, desc) {
+    const totalDisk = (s) => [...s.serverDiskData.nvme, ...s.serverDiskData.sata, ...s.serverDiskData.hdd].reduce((sum, d) => sum + d, 0);
+    const sorted = [...servers].sort((a, b) => {
+        switch (field) {
+            case 'price': return a.price - b.price;
+            case 'hourly': return a.hourly_price - b.hourly_price;
+            case 'setup': return a.setup_price - b.setup_price;
+            case 'ram': return a.ram_size - b.ram_size;
+            case 'disk': return totalDisk(a) - totalDisk(b);
+            case 'disk_count': return a.hdd_count - b.hdd_count;
+            case 'cpu': return a.cpu.localeCompare(b.cpu);
+            case 'cpu_count': return a.cpu_count - b.cpu_count;
+            case 'datacenter': return a.datacenter.localeCompare(b.datacenter);
+            case 'bandwidth': return a.bandwidth - b.bandwidth;
+            case 'next_reduce': return a.next_reduce - b.next_reduce;
+            default: return a.price - b.price;
+        }
+    });
+    return desc ? sorted.reverse() : sorted;
+}

package/dist/auction/commands.d.ts

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

package/dist/auction/commands.js

@@ -0,0 +1,138 @@
+import { Option } from 'commander';
+import { fetchAuctionServers, filterAuctionServers, sortAuctionServers } from './client.js';
+import { formatAuctionList, formatAuctionDetails } from './formatter.js';
+import { formatJson, error } from '../shared/formatter.js';
+function parseNum(val) {
+    if (val === undefined)
+        return undefined;
+    const n = Number(val);
+    return isNaN(n) ? undefined : n;
+}
+export function registerAuctionCommands(parent) {
+    const auction = parent.command('auction').description('Server auction monitoring (public, no auth required).\n' +
+        'Fetches ~1000+ servers from Hetzner\'s public auction endpoint and filters/sorts client-side.\n' +
+        'Typical ranges: 30-450 EUR/mo, 32-1024 GB RAM, NVMe/SATA/HDD, datacenters in FSN/HEL/NBG.');
+    auction
+        .command('list')
+        .alias('ls')
+        .description('List and filter auction servers.\n' +
+        'All filters are optional and combinable. String filters (cpu, datacenter, specials, search) are case-insensitive substrings.\n' +
+        'Examples:\n' +
+        '  hetzner auction list --cpu epyc --ecc --disk-type nvme --datacenter HEL --sort price\n' +
+        '  hetzner auction list --gpu --max-price 150 --json\n' +
+        '  hetzner auction list --auction-only --sort next_reduce --limit 20')
+        .option('--min-price <n>', 'Minimum monthly price')
+        .option('--max-price <n>', 'Maximum monthly price')
+        .option('--max-hourly-price <n>', 'Maximum hourly price')
+        .option('--min-ram <gb>', 'Minimum RAM in GB')
+        .option('--max-ram <gb>', 'Maximum RAM in GB')
+        .option('--cpu <text>', 'CPU model substring (e.g. "Ryzen", "i7-6700")')
+        .option('--min-cpu-count <n>', 'Minimum CPU/socket count')
+        .option('--max-cpu-count <n>', 'Maximum CPU/socket count')
+        .option('--datacenter <text>', 'Datacenter substring (e.g. "FSN", "HEL1-DC2")')
+        .option('--min-disk-size <gb>', 'Minimum total disk capacity in GB')
+        .option('--max-disk-size <gb>', 'Maximum total disk capacity in GB')
+        .option('--min-disk-count <n>', 'Minimum number of drives')
+        .option('--max-disk-count <n>', 'Maximum number of drives')
+        .addOption(new Option('--disk-type <type>', 'Filter by disk type present')
+        .choices(['nvme', 'sata', 'hdd']))
+        .option('--min-bandwidth <mbit>', 'Minimum bandwidth in Mbit/s')
+        .option('--ecc', 'Only ECC RAM servers')
+        .option('--gpu', 'Only GPU servers')
+        .option('--inic', 'Only servers with Intel NIC')
+        .option('--highio', 'Only high I/O servers')
+        .option('--specials <text>', 'Filter by special feature (substring match)')
+        .option('--fixed-price', 'Only fixed-price servers')
+        .option('--auction-only', 'Only auction (non-fixed) servers')
+        .option('--no-setup-fee', 'Only servers with no setup fee')
+        .option('--max-setup-price <n>', 'Maximum setup price')
+        .option('--search <text>', 'Free-text search across description')
+        .addOption(new Option('--currency <currency>', 'Price currency')
+        .choices(['EUR', 'USD'])
+        .default('EUR'))
+        .addOption(new Option('--sort <field>', 'Sort by field')
+        .choices(['price', 'hourly', 'setup', 'ram', 'disk', 'disk_count', 'cpu', 'cpu_count', 'datacenter', 'bandwidth', 'next_reduce'])
+        .default('price'))
+        .option('--desc', 'Sort in descending order')
+        .option('--limit <n>', 'Limit output rows')
+        .action(async (options) => {
+        try {
+            const { server: servers } = await fetchAuctionServers(options.currency);
+            const filters = {
+                minPrice: parseNum(options.minPrice),
+                maxPrice: parseNum(options.maxPrice),
+                maxHourlyPrice: parseNum(options.maxHourlyPrice),
+                minRam: parseNum(options.minRam),
+                maxRam: parseNum(options.maxRam),
+                cpu: options.cpu,
+                datacenter: options.datacenter,
+                minDiskSize: parseNum(options.minDiskSize),
+                maxDiskSize: parseNum(options.maxDiskSize),
+                minDiskCount: parseNum(options.minDiskCount),
+                maxDiskCount: parseNum(options.maxDiskCount),
+                diskType: options.diskType,
+                minBandwidth: parseNum(options.minBandwidth),
+                ecc: options.ecc ? true : undefined,
+                gpu: options.gpu ? true : undefined,
+                inic: options.inic ? true : undefined,
+                highio: options.highio ? true : undefined,
+                specials: options.specials,
+                fixedPrice: options.fixedPrice ? true : options.auctionOnly ? false : undefined,
+                maxSetupPrice: options.noSetupFee ? 0 : parseNum(options.maxSetupPrice),
+                minCpuCount: parseNum(options.minCpuCount),
+                maxCpuCount: parseNum(options.maxCpuCount),
+                text: options.search,
+            };
+            let filtered = filterAuctionServers(servers, filters);
+            filtered = sortAuctionServers(filtered, options.sort || 'price', !!options.desc);
+            const limit = parseNum(options.limit);
+            if (limit !== undefined && limit > 0) {
+                filtered = filtered.slice(0, limit);
+            }
+            if (options.json) {
+                console.log(formatJson(filtered));
+            }
+            else {
+                console.log(formatAuctionList(filtered));
+            }
+        }
+        catch (err) {
+            console.error(error(err instanceof Error ? err.message : 'Failed to fetch auction data'));
+            process.exit(1);
+        }
+    });
+    auction
+        .command('show <id>')
+        .description('Show detailed info for an auction server.\n' +
+        'Displays CPU, RAM, disk breakdown by type, datacenter, pricing (monthly + hourly),\n' +
+        'specials (GPU, iNIC, ECC), IP pricing, and full description.\n' +
+        'Example: hetzner auction show 2919866')
+        .addOption(new Option('--currency <currency>', 'Price currency')
+        .choices(['EUR', 'USD'])
+        .default('EUR'))
+        .action(async (id, options) => {
+        try {
+            const serverId = parseInt(id);
+            if (isNaN(serverId)) {
+                console.error(error('Invalid server ID'));
+                process.exit(1);
+            }
+            const { server: servers } = await fetchAuctionServers(options.currency);
+            const server = servers.find(s => s.id === serverId);
+            if (!server) {
+                console.error(error(`Auction server ${id} not found`));
+                process.exit(1);
+            }
+            if (options.json) {
+                console.log(formatJson(server));
+            }
+            else {
+                console.log(formatAuctionDetails(server));
+            }
+        }
+        catch (err) {
+            console.error(error(err instanceof Error ? err.message : 'Failed to fetch auction data'));
+            process.exit(1);
+        }
+    });
+}

package/dist/auction/formatter.d.ts

@@ -0,0 +1,3 @@
+import type { AuctionServer } from '../types.js';
+export declare function formatAuctionList(servers: AuctionServer[]): string;
+export declare function formatAuctionDetails(server: AuctionServer): string;

package/dist/auction/formatter.js

@@ -0,0 +1,87 @@
+import { colorize, info, heading, createTable, } from '../shared/formatter.js';
+function summarizeDisks(server) {
+    const parts = [];
+    const { nvme, sata, hdd } = server.serverDiskData;
+    if (nvme.length > 0) {
+        parts.push(`${nvme.length}x ${formatDiskSize(nvme[0])} NVMe`);
+    }
+    if (sata.length > 0) {
+        parts.push(`${sata.length}x ${formatDiskSize(sata[0])} SATA`);
+    }
+    if (hdd.length > 0) {
+        parts.push(`${hdd.length}x ${formatDiskSize(hdd[0])} HDD`);
+    }
+    return parts.length > 0 ? parts.join(', ') : '-';
+}
+function formatDiskSize(gb) {
+    if (gb >= 1000)
+        return `${(gb / 1000).toFixed(gb % 1000 === 0 ? 0 : 1)} TB`;
+    return `${gb} GB`;
+}
+function formatNextReduce(server) {
+    if (server.fixed_price)
+        return 'Fixed';
+    if (server.next_reduce <= 0)
+        return '-';
+    const hours = Math.floor(server.next_reduce / 60);
+    const mins = server.next_reduce % 60;
+    if (hours > 0)
+        return `${hours}h ${mins}m`;
+    return `${mins}m`;
+}
+export function formatAuctionList(servers) {
+    if (servers.length === 0) {
+        return info('No auction servers found matching your filters.');
+    }
+    const table = createTable(['ID', 'CPU', 'RAM', 'Disks', 'DC', 'Price', 'Setup', 'Type', 'Reduce', 'Specials']);
+    for (const s of servers) {
+        const specials = s.specials.length > 0 ? s.specials.join(', ') : '-';
+        table.push([
+            s.id.toString(),
+            s.cpu,
+            `${s.ram_size} GB${s.is_ecc ? ' ECC' : ''}`,
+            summarizeDisks(s),
+            s.datacenter,
+            `€${s.price.toFixed(2)}`,
+            s.setup_price > 0 ? `€${s.setup_price.toFixed(2)}` : 'Free',
+            s.fixed_price ? 'Fixed' : 'Auction',
+            formatNextReduce(s),
+            specials,
+        ]);
+    }
+    return `${table.toString()}\n${colorize(`${servers.length} server(s) found`, 'gray')}`;
+}
+export function formatAuctionDetails(server) {
+    const lines = [];
+    lines.push(heading(`Auction Server ${server.id}`));
+    lines.push('');
+    const table = createTable(['Property', 'Value']);
+    table.push(['ID', server.id.toString()], ['Name', server.name], ['CPU', server.cpu], ['CPU Count', server.cpu_count.toString()], ['RAM', `${server.ram_size} GB${server.is_ecc ? ' (ECC)' : ''}`], ['RAM Details', server.ram.join(', ')], ['Disks', summarizeDisks(server)], ['Disk Details', server.hdd_hr.join(', ') || '-'], ['Total Disk Size', `${server.hdd_size} GB`], ['Disk Count', server.hdd_count.toString()], ['Datacenter', `${server.datacenter_hr} (${server.datacenter})`], ['Traffic', server.traffic], ['Bandwidth', `${server.bandwidth} Mbit/s`], ['Price', `€${server.price.toFixed(2)}/mo`], ['Hourly Price', `€${server.hourly_price.toFixed(4)}/h`], ['Setup Price', server.setup_price > 0 ? `€${server.setup_price.toFixed(2)}` : 'Free'], ['Price Type', server.fixed_price ? 'Fixed' : 'Auction'], ['Next Reduce', formatNextReduce(server)], ['Specials', server.specials.length > 0 ? server.specials.join(', ') : 'None'], ['High I/O', server.is_highio ? 'Yes' : 'No'], ['ECC', server.is_ecc ? 'Yes' : 'No']);
+    lines.push(table.toString());
+    // Disk breakdown
+    const { nvme, sata, hdd } = server.serverDiskData;
+    if (nvme.length > 0 || sata.length > 0 || hdd.length > 0) {
+        lines.push('');
+        lines.push(colorize('Disk Breakdown:', 'bold'));
+        if (nvme.length > 0)
+            lines.push(`  NVMe: ${nvme.map(d => formatDiskSize(d)).join(', ')}`);
+        if (sata.length > 0)
+            lines.push(`  SATA: ${sata.map(d => formatDiskSize(d)).join(', ')}`);
+        if (hdd.length > 0)
+            lines.push(`  HDD:  ${hdd.map(d => formatDiskSize(d)).join(', ')}`);
+    }
+    // IP Pricing
+    lines.push('');
+    lines.push(colorize('Additional IP Pricing:', 'bold'));
+    lines.push(`  Monthly: €${server.ip_price.Monthly.toFixed(2)}`);
+    lines.push(`  Hourly:  €${server.ip_price.Hourly.toFixed(4)}`);
+    // Description
+    if (server.description.length > 0) {
+        lines.push('');
+        lines.push(colorize('Description:', 'bold'));
+        for (const line of server.description) {
+            lines.push(`  ${line}`);
+        }
+    }
+    return lines.join('\n');
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import { Command, Option } from 'commander';
+import { config } from 'dotenv';
+import { registerRobotCommands } from './robot/commands/index.js';
+import { registerCloudCommands } from './cloud/commands/index.js';
+import { registerAuctionCommands } from './auction/commands.js';
+import { generateReference } from './shared/reference.js';
+config();
+const program = new Command();
+program
+    .name('hetzner')
+    .description('Unified CLI for Hetzner Robot API (dedicated servers), Cloud API, and public server auction.\n\n' +
+    '  Three APIs, one tool:\n' +
+    '    Robot commands   — manage dedicated servers (requires Robot web service credentials)\n' +
+    '    Cloud commands   — manage cloud infrastructure under "hetzner cloud ..." (requires Cloud API token)\n' +
+    '    Auction commands — browse server auction under "hetzner auction ..." (no auth required)\n\n' +
+    '  Run "hetzner reference" for a complete structured reference of all commands and options.\n' +
+    '  Run "hetzner <command> --help" for help on a specific command.')
+    .version('2.0.0')
+    .option('-u, --user <username>', 'Hetzner Robot web service username (or set HETZNER_ROBOT_USER)')
+    .option('-p, --password <password>', 'Hetzner Robot web service password (or set HETZNER_ROBOT_PASSWORD; use "-" to read from stdin)')
+    .option('--json', 'Output raw JSON instead of formatted tables');
+// Register all robot commands directly on program (backward compat)
+registerRobotCommands(program);
+// Register cloud commands under 'hetzner cloud ...'
+registerCloudCommands(program);
+// Register auction commands (public API, no auth required)
+registerAuctionCommands(program);
+// Built-in reference command (structured docs for LLMs and humans)
+program
+    .command('reference')
+    .alias('ref')
+    .description('Print complete CLI reference (optimized for LLM context)')
+    .addOption(new Option('--section <section>', 'Show only a specific section')
+    .choices(['robot', 'cloud', 'auction']))
+    .action((options) => {
+    console.log(generateReference(options.section));
+});
+program.parse();

package/dist/client.d.ts

@@ -0,0 +1,2 @@
+export { HetznerRobotClient } from './robot/client.js';
+export { fetchAuctionServers, filterAuctionServers, sortAuctionServers } from './auction/client.js';

package/dist/client.js

@@ -0,0 +1,4 @@
+// Re-export from new location for backward compatibility
+export { HetznerRobotClient } from './robot/client.js';
+// Auction client (public API, no auth)
+export { fetchAuctionServers, filterAuctionServers, sortAuctionServers } from './auction/client.js';