hetzner-cli 2.0.0

package/dist/shared/formatter.d.ts

@@ -0,0 +1,29 @@
+import Table from 'cli-table3';
+export declare const colors: {
+    reset: string;
+    bold: string;
+    dim: string;
+    red: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    magenta: string;
+    cyan: string;
+    white: string;
+    gray: string;
+    bgRed: string;
+    bgGreen: string;
+    bgYellow: string;
+};
+export declare function colorize(text: string, color: keyof typeof colors): string;
+export declare function success(message: string): string;
+export declare function error(message: string): string;
+export declare function warning(message: string): string;
+export declare function info(message: string): string;
+export declare function heading(text: string): string;
+export declare function formatStatus(status: string): string;
+export declare function formatBytes(bytes: number): string;
+export declare function formatDate(dateStr: string): string;
+export declare function formatDateTime(dateStr: string): string;
+export declare function createTable(head: string[], colWidths?: number[]): Table.Table;
+export declare function formatJson(data: unknown): string;

package/dist/shared/formatter.js

@@ -0,0 +1,118 @@
+import Table from 'cli-table3';
+export const colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    gray: '\x1b[90m',
+    bgRed: '\x1b[41m',
+    bgGreen: '\x1b[42m',
+    bgYellow: '\x1b[43m',
+};
+export function colorize(text, color) {
+    return `${colors[color]}${text}${colors.reset}`;
+}
+export function success(message) {
+    return `${colors.green}✓${colors.reset} ${message}`;
+}
+export function error(message) {
+    return `${colors.red}✗${colors.reset} ${message}`;
+}
+export function warning(message) {
+    return `${colors.yellow}⚠${colors.reset} ${message}`;
+}
+export function info(message) {
+    return `${colors.blue}ℹ${colors.reset} ${message}`;
+}
+export function heading(text) {
+    return `\n${colors.bold}${colors.cyan}${text}${colors.reset}\n${'─'.repeat(text.length)}`;
+}
+export function formatStatus(status) {
+    switch (status.toLowerCase()) {
+        case 'ready':
+        case 'active':
+        case 'enabled':
+        case 'success':
+            return colorize(status, 'green');
+        case 'installing':
+        case 'in process':
+        case 'running':
+            return colorize(status, 'yellow');
+        case 'maintenance':
+        case 'disabled':
+        case 'failed':
+        case 'cancelled':
+            return colorize(status, 'red');
+        default:
+            return status;
+    }
+}
+export function formatBytes(bytes) {
+    if (bytes === 0)
+        return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+export function formatDate(dateStr) {
+    if (!dateStr)
+        return '-';
+    const date = new Date(dateStr);
+    return date.toLocaleDateString('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+    });
+}
+export function formatDateTime(dateStr) {
+    if (!dateStr)
+        return '-';
+    const date = new Date(dateStr);
+    return date.toLocaleString('en-US', {
+        year: 'numeric',
+        month: 'short',
+        day: 'numeric',
+        hour: '2-digit',
+        minute: '2-digit',
+    });
+}
+export function createTable(head, colWidths) {
+    const options = {
+        head: head.map((h) => colorize(h, 'cyan')),
+        chars: {
+            top: '─',
+            'top-mid': '┬',
+            'top-left': '┌',
+            'top-right': '┐',
+            bottom: '─',
+            'bottom-mid': '┴',
+            'bottom-left': '└',
+            'bottom-right': '┘',
+            left: '│',
+            'left-mid': '├',
+            mid: '─',
+            'mid-mid': '┼',
+            right: '│',
+            'right-mid': '┤',
+            middle: '│',
+        },
+        style: {
+            'padding-left': 1,
+            'padding-right': 1,
+        },
+    };
+    if (colWidths) {
+        options.colWidths = colWidths;
+    }
+    return new Table(options);
+}
+export function formatJson(data) {
+    return JSON.stringify(data, null, 2);
+}

package/dist/shared/helpers.d.ts

@@ -0,0 +1,17 @@
+import { HetznerRobotClient } from '../robot/client.js';
+export interface ActionOptions {
+    user?: string;
+    password?: string;
+    json?: boolean;
+    yes?: boolean;
+}
+export declare function asyncAction<T extends unknown[]>(fn: (client: HetznerRobotClient, ...args: T) => Promise<void>): (...args: [...T, ActionOptions]) => Promise<void>;
+/**
+ * Output data as JSON or formatted table based on options.
+ */
+export declare function output<T>(data: T, formatter: (data: T) => string, options: ActionOptions): void;
+/**
+ * Confirm destructive action unless --yes flag is set.
+ * Returns true if confirmed, false if aborted.
+ */
+export declare function confirmAction(message: string, options: ActionOptions, defaultValue?: boolean): Promise<boolean>;

package/dist/shared/helpers.js

@@ -0,0 +1,72 @@
+import { confirm } from '@inquirer/prompts';
+import { readFileSync } from 'node:fs';
+import { HetznerRobotClient } from '../robot/client.js';
+import { requireCredentials } from './config.js';
+import * as fmt from './formatter.js';
+let client = null;
+/**
+ * Get or create API client with credentials.
+ * Credential sources (in order): CLI flags, env vars, config file, interactive prompt.
+ */
+async function getClient(options) {
+    if (client)
+        return client;
+    const { user } = options;
+    let password = options.password;
+    if (password === '-') {
+        try {
+            password = readFileSync(0, 'utf-8').trim();
+        }
+        catch {
+            throw new Error('Failed to read password from stdin');
+        }
+    }
+    if (user && password) {
+        client = new HetznerRobotClient(user, password);
+        return client;
+    }
+    const creds = await requireCredentials();
+    client = new HetznerRobotClient(creds.user, creds.password);
+    return client;
+}
+export function asyncAction(fn) {
+    return async (...args) => {
+        const options = args[args.length - 1];
+        try {
+            const apiClient = await getClient(options);
+            await fn(apiClient, ...args.slice(0, -1));
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                if (error.message.includes('ExitPromptError') || error.name === 'ExitPromptError') {
+                    process.exit(0);
+                }
+                console.error(fmt.error(error.message));
+            }
+            else {
+                console.error(fmt.error('An unknown error occurred'));
+            }
+            process.exit(1);
+        }
+    };
+}
+/**
+ * Output data as JSON or formatted table based on options.
+ */
+export function output(data, formatter, options) {
+    console.log(options.json ? fmt.formatJson(data) : formatter(data));
+}
+/**
+ * Confirm destructive action unless --yes flag is set.
+ * Returns true if confirmed, false if aborted.
+ */
+export async function confirmAction(message, options, defaultValue = false) {
+    if (options.yes)
+        return true;
+    const confirmed = await confirm({ message, default: defaultValue });
+    if (!confirmed) {
+        console.log('Aborted.');
+        return false;
+    }
+    return true;
+}

package/dist/shared/reference.d.ts

@@ -0,0 +1,2 @@
+export type ReferenceSection = 'robot' | 'cloud' | 'auction';
+export declare function generateReference(section?: ReferenceSection): string;