hetzner-cli 2.0.0

package/dist/cloud/commands/server.js

@@ -0,0 +1,260 @@
+import { cloudAction, cloudOutput, cloudConfirm } from '../helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as cloudFmt from '../formatter.js';
+export function registerCloudServerCommands(parent) {
+    const server = parent.command('server').description('Cloud server management');
+    server
+        .command('list')
+        .alias('ls')
+        .description('List all servers')
+        .option('-l, --label-selector <selector>', 'Label selector')
+        .option('-n, --name <name>', 'Filter by name')
+        .option('-s, --sort <field>', 'Sort by field')
+        .option('--status <status>', 'Filter by status')
+        .action(cloudAction(async (client, options) => {
+        const servers = await client.listServers({ label_selector: options.labelSelector, name: options.name, sort: options.sort, status: options.status });
+        cloudOutput(servers, cloudFmt.formatCloudServerList, options);
+    }));
+    server
+        .command('describe <id>')
+        .description('Show server details')
+        .action(cloudAction(async (client, id, options) => {
+        const srv = await client.getServer(parseInt(id));
+        cloudOutput(srv, cloudFmt.formatCloudServerDetails, options);
+    }));
+    server
+        .command('create')
+        .description('Create a new server')
+        .requiredOption('--name <name>', 'Server name')
+        .requiredOption('--type <type>', 'Server type')
+        .requiredOption('--image <image>', 'Image to use')
+        .option('--location <location>', 'Location')
+        .option('--datacenter <dc>', 'Datacenter')
+        .option('--ssh-key <keys...>', 'SSH key IDs or names')
+        .option('--user-data <data>', 'Cloud-init user data')
+        .option('--start-after-create', 'Start server after creation', true)
+        .option('--no-start-after-create', 'Do not start server after creation')
+        .action(cloudAction(async (client, options) => {
+        const result = await client.createServer({
+            name: options.name,
+            server_type: options.type,
+            image: options.image,
+            location: options.location,
+            datacenter: options.datacenter,
+            ssh_keys: options.sshKey,
+            user_data: options.userData,
+            start_after_create: options.startAfterCreate,
+        });
+        console.log(fmt.success(`Server '${result.server.name}' created (ID: ${result.server.id})`));
+        if (result.root_password) {
+            console.log(`Root password: ${fmt.colorize(result.root_password, 'yellow')}`);
+        }
+        console.log(fmt.info(`IPv4: ${result.server.public_net.ipv4?.ip || 'pending'}`));
+    }));
+    server
+        .command('delete <id>')
+        .description('Delete a server')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(cloudAction(async (client, id, options) => {
+        if (!await cloudConfirm(`Delete server ${id}?`, options))
+            return;
+        await client.deleteServer(parseInt(id));
+        console.log(fmt.success(`Server ${id} deleted.`));
+    }));
+    server
+        .command('update <id>')
+        .description('Update server')
+        .option('--name <name>', 'New name')
+        .action(cloudAction(async (client, id, options) => {
+        const { server: srv } = await client.updateServer(parseInt(id), { name: options.name });
+        console.log(fmt.success(`Server '${srv.name}' updated.`));
+    }));
+    server
+        .command('poweron <id>')
+        .description('Power on a server')
+        .action(cloudAction(async (client, id) => {
+        await client.powerOnServer(parseInt(id));
+        console.log(fmt.success(`Server ${id} powered on.`));
+    }));
+    server
+        .command('poweroff <id>')
+        .description('Power off a server (hard)')
+        .action(cloudAction(async (client, id) => {
+        await client.powerOffServer(parseInt(id));
+        console.log(fmt.success(`Server ${id} powered off.`));
+    }));
+    server
+        .command('reboot <id>')
+        .description('Soft reboot a server')
+        .action(cloudAction(async (client, id) => {
+        await client.rebootServer(parseInt(id));
+        console.log(fmt.success(`Server ${id} rebooted.`));
+    }));
+    server
+        .command('reset <id>')
+        .description('Hard reset a server')
+        .action(cloudAction(async (client, id) => {
+        await client.resetServer(parseInt(id));
+        console.log(fmt.success(`Server ${id} reset.`));
+    }));
+    server
+        .command('shutdown <id>')
+        .description('Gracefully shutdown a server (ACPI)')
+        .action(cloudAction(async (client, id) => {
+        await client.shutdownServer(parseInt(id));
+        console.log(fmt.success(`Server ${id} shutdown initiated.`));
+    }));
+    server
+        .command('rebuild <id>')
+        .description('Rebuild a server with a new image')
+        .requiredOption('--image <image>', 'Image to rebuild with')
+        .action(cloudAction(async (client, id, options) => {
+        const result = await client.rebuildServer(parseInt(id), options.image);
+        console.log(fmt.success(`Server ${id} rebuilding.`));
+        if (result.root_password) {
+            console.log(`Root password: ${fmt.colorize(result.root_password, 'yellow')}`);
+        }
+    }));
+    server
+        .command('change-type <id>')
+        .description('Change server type (resize)')
+        .requiredOption('--type <type>', 'New server type')
+        .option('--upgrade-disk', 'Upgrade disk size (irreversible)', false)
+        .action(cloudAction(async (client, id, options) => {
+        await client.changeServerType(parseInt(id), options.type, !!options.upgradeDisk);
+        console.log(fmt.success(`Server ${id} type change initiated.`));
+    }));
+    server
+        .command('enable-rescue <id>')
+        .description('Enable rescue mode')
+        .option('--type <type>', 'Rescue system type', 'linux64')
+        .option('--ssh-key <keys...>', 'SSH key IDs')
+        .action(cloudAction(async (client, id, options) => {
+        const result = await client.enableServerRescue(parseInt(id), options.type, options.sshKey?.map(Number));
+        console.log(fmt.success('Rescue mode enabled.'));
+        console.log(`Root password: ${fmt.colorize(result.root_password, 'yellow')}`);
+    }));
+    server
+        .command('disable-rescue <id>')
+        .description('Disable rescue mode')
+        .action(cloudAction(async (client, id) => {
+        await client.disableServerRescue(parseInt(id));
+        console.log(fmt.success('Rescue mode disabled.'));
+    }));
+    server
+        .command('enable-backup <id>')
+        .description('Enable automatic backups')
+        .action(cloudAction(async (client, id) => {
+        await client.enableServerBackup(parseInt(id));
+        console.log(fmt.success(`Backups enabled for server ${id}.`));
+    }));
+    server
+        .command('disable-backup <id>')
+        .description('Disable automatic backups')
+        .action(cloudAction(async (client, id) => {
+        await client.disableServerBackup(parseInt(id));
+        console.log(fmt.success(`Backups disabled for server ${id}.`));
+    }));
+    server
+        .command('create-image <id>')
+        .description('Create an image (snapshot) from server')
+        .option('--description <desc>', 'Image description')
+        .option('--type <type>', 'Image type (snapshot or backup)', 'snapshot')
+        .action(cloudAction(async (client, id, options) => {
+        const result = await client.createServerImage(parseInt(id), { description: options.description, type: options.type });
+        console.log(fmt.success(`Image created (ID: ${result.image.id})`));
+    }));
+    server
+        .command('attach-iso <id>')
+        .description('Attach an ISO to a server')
+        .requiredOption('--iso <iso>', 'ISO name or ID')
+        .action(cloudAction(async (client, id, options) => {
+        await client.attachIsoToServer(parseInt(id), options.iso);
+        console.log(fmt.success(`ISO attached to server ${id}.`));
+    }));
+    server
+        .command('detach-iso <id>')
+        .description('Detach ISO from a server')
+        .action(cloudAction(async (client, id) => {
+        await client.detachIsoFromServer(parseInt(id));
+        console.log(fmt.success(`ISO detached from server ${id}.`));
+    }));
+    server
+        .command('reset-password <id>')
+        .description('Reset server root password')
+        .action(cloudAction(async (client, id) => {
+        const result = await client.resetServerPassword(parseInt(id));
+        console.log(fmt.success('Root password reset.'));
+        console.log(`New password: ${fmt.colorize(result.root_password, 'yellow')}`);
+    }));
+    server
+        .command('set-rdns <id>')
+        .description('Set reverse DNS for server')
+        .requiredOption('--ip <ip>', 'IP address')
+        .requiredOption('--dns-ptr <ptr>', 'DNS pointer')
+        .action(cloudAction(async (client, id, options) => {
+        await client.setServerRdns(parseInt(id), options.ip, options.dnsPtr);
+        console.log(fmt.success(`rDNS set: ${options.ip} -> ${options.dnsPtr}`));
+    }));
+    server
+        .command('enable-protection <id>')
+        .description('Enable server protection')
+        .option('--delete', 'Enable delete protection', true)
+        .option('--rebuild', 'Enable rebuild protection', false)
+        .action(cloudAction(async (client, id, options) => {
+        await client.enableServerProtection(parseInt(id), { delete: options.delete, rebuild: options.rebuild });
+        console.log(fmt.success(`Protection enabled for server ${id}.`));
+    }));
+    server
+        .command('disable-protection <id>')
+        .description('Disable server protection')
+        .action(cloudAction(async (client, id) => {
+        await client.enableServerProtection(parseInt(id), { delete: false, rebuild: false });
+        console.log(fmt.success(`Protection disabled for server ${id}.`));
+    }));
+    server
+        .command('request-console <id>')
+        .description('Request a WebSocket VNC console')
+        .action(cloudAction(async (client, id) => {
+        const result = await client.requestServerConsole(parseInt(id));
+        console.log(fmt.success('Console ready.'));
+        console.log(`WebSocket URL: ${result.wss_url}`);
+        console.log(`Password: ${fmt.colorize(result.password, 'yellow')}`);
+    }));
+    server
+        .command('attach-to-network <id>')
+        .description('Attach server to a network')
+        .requiredOption('--network <network>', 'Network ID')
+        .option('--ip <ip>', 'IP address in network')
+        .action(cloudAction(async (client, id, options) => {
+        await client.attachServerToNetwork(parseInt(id), parseInt(options.network), options.ip);
+        console.log(fmt.success(`Server ${id} attached to network ${options.network}.`));
+    }));
+    server
+        .command('detach-from-network <id>')
+        .description('Detach server from a network')
+        .requiredOption('--network <network>', 'Network ID')
+        .action(cloudAction(async (client, id, options) => {
+        await client.detachServerFromNetwork(parseInt(id), parseInt(options.network));
+        console.log(fmt.success(`Server ${id} detached from network ${options.network}.`));
+    }));
+    server
+        .command('add-label <id> <label>')
+        .description('Add a label (key=value)')
+        .action(cloudAction(async (client, id, label) => {
+        const srv = await client.getServer(parseInt(id));
+        const [key, value] = label.split('=');
+        const labels = { ...srv.labels, [key]: value || '' };
+        await client.updateServer(parseInt(id), { labels });
+        console.log(fmt.success(`Label '${key}' added to server ${id}.`));
+    }));
+    server
+        .command('remove-label <id> <key>')
+        .description('Remove a label by key')
+        .action(cloudAction(async (client, id, key) => {
+        const srv = await client.getServer(parseInt(id));
+        const labels = Object.fromEntries(Object.entries(srv.labels).filter(([k]) => k !== key));
+        await client.updateServer(parseInt(id), { labels });
+        console.log(fmt.success(`Label '${key}' removed from server ${id}.`));
+    }));
+}

package/dist/cloud/commands/ssh-key.d.ts

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

package/dist/cloud/commands/ssh-key.js

@@ -0,0 +1,63 @@
+import { readFileSync } from 'node:fs';
+import { cloudAction, cloudOutput, cloudConfirm } from '../helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as cloudFmt from '../formatter.js';
+export function registerCloudSshKeyCommands(parent) {
+    const sshKey = parent.command('ssh-key').description('SSH key management');
+    sshKey.command('list').alias('ls').description('List all SSH keys')
+        .option('-l, --label-selector <selector>', 'Label selector')
+        .option('-s, --sort <field>', 'Sort by field')
+        .action(cloudAction(async (client, options) => {
+        const keys = await client.listSshKeys({ label_selector: options.labelSelector, sort: options.sort });
+        cloudOutput(keys, cloudFmt.formatCloudSshKeyList, options);
+    }));
+    sshKey.command('describe <id>').description('Show SSH key details')
+        .action(cloudAction(async (client, id, options) => {
+        const key = await client.getSshKey(parseInt(id));
+        cloudOutput(key, cloudFmt.formatCloudSshKeyDetails, options);
+    }));
+    sshKey.command('create').description('Create an SSH key')
+        .requiredOption('--name <name>', 'Key name')
+        .option('--public-key <key>', 'Public key string')
+        .option('--public-key-from-file <path>', 'Read public key from file')
+        .action(cloudAction(async (client, options) => {
+        let pubKey = options.publicKey;
+        if (options.publicKeyFromFile) {
+            pubKey = readFileSync(options.publicKeyFromFile, 'utf-8').trim();
+        }
+        if (!pubKey) {
+            console.error(fmt.error('Provide --public-key or --public-key-from-file'));
+            process.exit(1);
+        }
+        const { ssh_key: key } = await client.createSshKey({ name: options.name, public_key: pubKey });
+        console.log(fmt.success(`SSH key '${key.name}' created (ID: ${key.id})`));
+    }));
+    sshKey.command('delete <id>').description('Delete an SSH key')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(cloudAction(async (client, id, options) => {
+        if (!await cloudConfirm(`Delete SSH key ${id}?`, options))
+            return;
+        await client.deleteSshKey(parseInt(id));
+        console.log(fmt.success(`SSH key ${id} deleted.`));
+    }));
+    sshKey.command('update <id>').description('Update SSH key')
+        .option('--name <name>', 'New name')
+        .action(cloudAction(async (client, id, options) => {
+        await client.updateSshKey(parseInt(id), { name: options.name });
+        console.log(fmt.success(`SSH key ${id} updated.`));
+    }));
+    sshKey.command('add-label <id> <label>').description('Add a label (key=value)')
+        .action(cloudAction(async (client, id, label) => {
+        const key = await client.getSshKey(parseInt(id));
+        const [k, v] = label.split('=');
+        await client.updateSshKey(parseInt(id), { labels: { ...key.labels, [k]: v || '' } });
+        console.log(fmt.success(`Label '${k}' added.`));
+    }));
+    sshKey.command('remove-label <id> <key>').description('Remove a label')
+        .action(cloudAction(async (client, id, key) => {
+        const sshKeyData = await client.getSshKey(parseInt(id));
+        const labels = Object.fromEntries(Object.entries(sshKeyData.labels).filter(([k]) => k !== key));
+        await client.updateSshKey(parseInt(id), { labels });
+        console.log(fmt.success(`Label '${key}' removed.`));
+    }));
+}

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

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

package/dist/cloud/commands/volume.js

@@ -0,0 +1,92 @@
+import { cloudAction, cloudOutput, cloudConfirm } from '../helpers.js';
+import * as fmt from '../../shared/formatter.js';
+import * as cloudFmt from '../formatter.js';
+export function registerVolumeCommands(parent) {
+    const volume = parent.command('volume').description('Volume management');
+    volume.command('list').alias('ls').description('List all volumes')
+        .option('-l, --label-selector <selector>', 'Label selector')
+        .option('-s, --sort <field>', 'Sort by field')
+        .option('--status <status>', 'Filter by status')
+        .action(cloudAction(async (client, options) => {
+        const volumes = await client.listVolumes({ label_selector: options.labelSelector, sort: options.sort, status: options.status });
+        cloudOutput(volumes, cloudFmt.formatVolumeList, options);
+    }));
+    volume.command('describe <id>').description('Show volume details')
+        .action(cloudAction(async (client, id, options) => {
+        const vol = await client.getVolume(parseInt(id));
+        cloudOutput(vol, cloudFmt.formatVolumeDetails, options);
+    }));
+    volume.command('create').description('Create a volume')
+        .requiredOption('--name <name>', 'Volume name')
+        .requiredOption('--size <size>', 'Size in GB')
+        .option('--location <loc>', 'Location')
+        .option('--server <id>', 'Server to attach to')
+        .option('--format <format>', 'Filesystem format (ext4, xfs)')
+        .option('--automount', 'Auto-mount on server')
+        .action(cloudAction(async (client, options) => {
+        const { volume: vol } = await client.createVolume({
+            name: options.name,
+            size: parseInt(options.size),
+            location: options.location,
+            server: options.server ? parseInt(options.server) : undefined,
+            format: options.format,
+            automount: options.automount,
+        });
+        console.log(fmt.success(`Volume '${vol.name}' created (ID: ${vol.id}, ${vol.size} GB)`));
+    }));
+    volume.command('delete <id>').description('Delete a volume')
+        .option('-y, --yes', 'Skip confirmation')
+        .action(cloudAction(async (client, id, options) => {
+        if (!await cloudConfirm(`Delete volume ${id}?`, options))
+            return;
+        await client.deleteVolume(parseInt(id));
+        console.log(fmt.success(`Volume ${id} deleted.`));
+    }));
+    volume.command('update <id>').description('Update volume')
+        .option('--name <name>', 'New name')
+        .action(cloudAction(async (client, id, options) => {
+        await client.updateVolume(parseInt(id), { name: options.name });
+        console.log(fmt.success(`Volume ${id} updated.`));
+    }));
+    volume.command('attach <id> <server>').description('Attach volume to server')
+        .option('--automount', 'Auto-mount on server')
+        .action(cloudAction(async (client, id, server, options) => {
+        await client.attachVolume(parseInt(id), parseInt(server), options.automount);
+        console.log(fmt.success(`Volume ${id} attached to server ${server}.`));
+    }));
+    volume.command('detach <id>').description('Detach volume from server')
+        .action(cloudAction(async (client, id) => {
+        await client.detachVolume(parseInt(id));
+        console.log(fmt.success(`Volume ${id} detached.`));
+    }));
+    volume.command('resize <id>').description('Resize a volume')
+        .requiredOption('--size <size>', 'New size in GB')
+        .action(cloudAction(async (client, id, options) => {
+        await client.resizeVolume(parseInt(id), parseInt(options.size));
+        console.log(fmt.success(`Volume ${id} resized to ${options.size} GB.`));
+    }));
+    volume.command('enable-protection <id>').description('Enable delete protection')
+        .action(cloudAction(async (client, id) => {
+        await client.changeVolumeProtection(parseInt(id), true);
+        console.log(fmt.success(`Protection enabled for volume ${id}.`));
+    }));
+    volume.command('disable-protection <id>').description('Disable delete protection')
+        .action(cloudAction(async (client, id) => {
+        await client.changeVolumeProtection(parseInt(id), false);
+        console.log(fmt.success(`Protection disabled for volume ${id}.`));
+    }));
+    volume.command('add-label <id> <label>').description('Add a label (key=value)')
+        .action(cloudAction(async (client, id, label) => {
+        const vol = await client.getVolume(parseInt(id));
+        const [key, value] = label.split('=');
+        await client.updateVolume(parseInt(id), { labels: { ...vol.labels, [key]: value || '' } });
+        console.log(fmt.success(`Label '${key}' added.`));
+    }));
+    volume.command('remove-label <id> <key>').description('Remove a label')
+        .action(cloudAction(async (client, id, key) => {
+        const vol = await client.getVolume(parseInt(id));
+        const labels = Object.fromEntries(Object.entries(vol.labels).filter(([k]) => k !== key));
+        await client.updateVolume(parseInt(id), { labels });
+        console.log(fmt.success(`Label '${key}' removed.`));
+    }));
+}

package/dist/cloud/context.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Create a new cloud context.
+ */
+export declare function createContext(name: string, token: string): Promise<void>;
+/**
+ * Set the active context.
+ */
+export declare function useContext(name: string): void;
+/**
+ * Delete a context.
+ */
+export declare function deleteContext(name: string): Promise<void>;
+/**
+ * List all contexts.
+ */
+export declare function listContexts(): {
+    name: string;
+    active: boolean;
+}[];
+/**
+ * Get the active context name.
+ */
+export declare function getActiveContext(): string | null;
+/**
+ * Resolve the cloud API token.
+ * Priority: --token flag > HETZNER_CLOUD_TOKEN env > active context
+ */
+export declare function resolveToken(flagToken?: string): Promise<string>;

package/dist/cloud/context.js

@@ -0,0 +1,172 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const CONFIG_DIR = join(homedir(), '.hetzner-cli');
+const CONTEXTS_FILE = join(CONFIG_DIR, 'cloud-contexts.json');
+const KEYCHAIN_SERVICE = 'hetzner-cli';
+// Lazy-loaded keytar module
+let keytarModule = null;
+let keytarLoadAttempted = false;
+async function getKeytar() {
+    if (keytarLoadAttempted)
+        return keytarModule;
+    keytarLoadAttempted = true;
+    try {
+        keytarModule = await import('keytar');
+        return keytarModule;
+    }
+    catch {
+        return null;
+    }
+}
+function ensureConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+function loadContexts() {
+    if (!existsSync(CONTEXTS_FILE)) {
+        return { active: null, contexts: {} };
+    }
+    try {
+        const data = readFileSync(CONTEXTS_FILE, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return { active: null, contexts: {} };
+    }
+}
+function saveContexts(config) {
+    ensureConfigDir();
+    writeFileSync(CONTEXTS_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+function keychainAccount(contextName) {
+    return `cloud-token:${contextName}`;
+}
+async function storeToken(contextName, token) {
+    const keytar = await getKeytar();
+    if (keytar) {
+        try {
+            await keytar.setPassword(KEYCHAIN_SERVICE, keychainAccount(contextName), token);
+            return true;
+        }
+        catch {
+            // Fall through to file storage
+        }
+    }
+    console.warn('Warning: System keychain unavailable. Cloud token will be stored in plaintext at ~/.hetzner-cli/cloud-contexts.json');
+    return false;
+}
+async function retrieveToken(contextName) {
+    // Try keytar first
+    const keytar = await getKeytar();
+    if (keytar) {
+        try {
+            const token = await keytar.getPassword(KEYCHAIN_SERVICE, keychainAccount(contextName));
+            if (token)
+                return token;
+        }
+        catch {
+            // Fall through
+        }
+    }
+    // Fall back to file
+    const config = loadContexts();
+    return config.contexts[contextName]?.token ?? null;
+}
+async function deleteToken(contextName) {
+    const keytar = await getKeytar();
+    if (keytar) {
+        try {
+            await keytar.deletePassword(KEYCHAIN_SERVICE, keychainAccount(contextName));
+        }
+        catch {
+            // Ignore
+        }
+    }
+}
+/**
+ * Create a new cloud context.
+ */
+export async function createContext(name, token) {
+    const config = loadContexts();
+    const storedInKeychain = await storeToken(name, token);
+    config.contexts[name] = {
+        name,
+        ...(storedInKeychain ? {} : { token }),
+    };
+    // Auto-activate if first context
+    if (!config.active) {
+        config.active = name;
+    }
+    saveContexts(config);
+}
+/**
+ * Set the active context.
+ */
+export function useContext(name) {
+    const config = loadContexts();
+    if (!config.contexts[name]) {
+        throw new Error(`Context '${name}' not found. Use 'hetzner cloud context list' to see available contexts.`);
+    }
+    config.active = name;
+    saveContexts(config);
+}
+/**
+ * Delete a context.
+ */
+export async function deleteContext(name) {
+    const config = loadContexts();
+    if (!config.contexts[name]) {
+        throw new Error(`Context '${name}' not found.`);
+    }
+    await deleteToken(name);
+    const { [name]: _, ...rest } = config.contexts;
+    config.contexts = rest;
+    if (config.active === name) {
+        const remaining = Object.keys(config.contexts);
+        config.active = remaining.length > 0 ? remaining[0] : null;
+    }
+    saveContexts(config);
+}
+/**
+ * List all contexts.
+ */
+export function listContexts() {
+    const config = loadContexts();
+    return Object.values(config.contexts).map((ctx) => ({
+        name: ctx.name,
+        active: ctx.name === config.active,
+    }));
+}
+/**
+ * Get the active context name.
+ */
+export function getActiveContext() {
+    const config = loadContexts();
+    return config.active;
+}
+/**
+ * Resolve the cloud API token.
+ * Priority: --token flag > HETZNER_CLOUD_TOKEN env > active context
+ */
+export async function resolveToken(flagToken) {
+    // 1. CLI flag
+    if (flagToken)
+        return flagToken;
+    // 2. Environment variable
+    const envToken = process.env.HETZNER_CLOUD_TOKEN;
+    if (envToken)
+        return envToken;
+    // 3. Active context
+    const config = loadContexts();
+    if (config.active) {
+        const token = await retrieveToken(config.active);
+        if (token)
+            return token;
+    }
+    throw new Error('No cloud token found. Use one of:\n' +
+        '  --token <token>                  Pass token directly\n' +
+        '  HETZNER_CLOUD_TOKEN=<token>      Set environment variable\n' +
+        '  hetzner cloud context create     Configure a named context');
+}

package/dist/cloud/formatter.d.ts

@@ -0,0 +1,37 @@
+import type { Datacenter, Location, ServerType, LoadBalancerType, ISO, CloudServer, Network, CloudFirewall, FloatingIp, PrimaryIp, Volume, LoadBalancer, Image, CloudSshKey, Certificate, PlacementGroup } from './types.js';
+export declare function formatContextList(contexts: {
+    name: string;
+    active: boolean;
+}[]): string;
+export declare function formatDatacenterList(datacenters: Datacenter[]): string;
+export declare function formatDatacenterDetails(dc: Datacenter): string;
+export declare function formatLocationList(locations: Location[]): string;
+export declare function formatLocationDetails(loc: Location): string;
+export declare function formatServerTypeList(types: ServerType[]): string;
+export declare function formatServerTypeDetails(st: ServerType): string;
+export declare function formatLoadBalancerTypeList(types: LoadBalancerType[]): string;
+export declare function formatLoadBalancerTypeDetails(lbt: LoadBalancerType): string;
+export declare function formatIsoList(isos: ISO[]): string;
+export declare function formatIsoDetails(iso: ISO): string;
+export declare function formatCloudServerList(servers: CloudServer[]): string;
+export declare function formatCloudServerDetails(srv: CloudServer): string;
+export declare function formatNetworkList(networks: Network[]): string;
+export declare function formatNetworkDetails(net: Network): string;
+export declare function formatCloudFirewallList(firewalls: CloudFirewall[]): string;
+export declare function formatCloudFirewallDetails(fw: CloudFirewall): string;
+export declare function formatFloatingIpList(ips: FloatingIp[]): string;
+export declare function formatFloatingIpDetails(ip: FloatingIp): string;
+export declare function formatPrimaryIpList(ips: PrimaryIp[]): string;
+export declare function formatPrimaryIpDetails(ip: PrimaryIp): string;
+export declare function formatVolumeList(volumes: Volume[]): string;
+export declare function formatVolumeDetails(vol: Volume): string;
+export declare function formatLoadBalancerList(lbs: LoadBalancer[]): string;
+export declare function formatLoadBalancerDetails(lb: LoadBalancer): string;
+export declare function formatImageList(images: Image[]): string;
+export declare function formatImageDetails(img: Image): string;
+export declare function formatCloudSshKeyList(keys: CloudSshKey[]): string;
+export declare function formatCloudSshKeyDetails(key: CloudSshKey): string;
+export declare function formatCertificateList(certs: Certificate[]): string;
+export declare function formatCertificateDetails(cert: Certificate): string;
+export declare function formatPlacementGroupList(groups: PlacementGroup[]): string;
+export declare function formatPlacementGroupDetails(pg: PlacementGroup): string;