@ebowwa/hetzner 0.1.0

package/actions.js

@@ -0,0 +1,802 @@
+/**
+ * Hetzner Cloud API action polling and management
+ *
+ * Provides a robust polling service for monitoring async Hetzner actions
+ * with progress tracking, error handling, and cancellation support.
+ */
+import { ActionCommand, } from "./types.js";
+import { HetznerActionError, HetznerTimeoutError, isRetryableError, calculateRetryDelay, } from "./errors.js";
+// ============================================================================
+// Action Operations Class
+// ============================================================================
+/**
+ * Action operations for the Hetzner Cloud API
+ *
+ * Provides methods for managing and polling actions with enhanced
+ * polling capabilities including cancellation, progress tracking,
+ * and batch operations.
+ */
+export class ActionOperations {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Get a specific action by ID
+     *
+     * @param id - Action ID
+     * @returns Action details
+     */
+    async get(id) {
+        const response = await this.client.request(`/actions/${id}`);
+        return response.action;
+    }
+    /**
+     * List all actions
+     *
+     * @param options - Optional filters (status, sort, etc.)
+     * @returns Array of actions
+     */
+    async list(options) {
+        const params = new URLSearchParams();
+        if (options?.status)
+            params.append("status", options.status);
+        if (options?.sort)
+            params.append("sort", options.sort);
+        if (options?.page)
+            params.append("page", options.page.toString());
+        if (options?.per_page)
+            params.append("per_page", options.per_page.toString());
+        const query = params.toString();
+        const response = await this.client.request(`/actions${query ? `?${query}` : ""}`);
+        return response.actions;
+    }
+    /**
+     * Poll a single action until completion (enhanced version)
+     *
+     * This is the main polling service method with full feature support:
+     * - Progress tracking with onProgress callback
+     * - Success/failure callbacks
+     * - Cancellation via AbortSignal
+     * - Adaptive polling intervals
+     * - Comprehensive error handling
+     *
+     * @param actionId - Action ID to poll
+     * @param options - Polling options
+     * @returns Promise resolving to the completed action
+     *
+     * @example
+     * ```typescript
+     * const action = await client.actions.poll(123, {
+     *   onProgress: (a) => console.log(`Progress: ${a.progress}%`),
+     *   onComplete: (a) => console.log('Done!'),
+     *   onError: (e) => console.error('Failed:', e.message),
+     *   timeout: 300000, // 5 minutes
+     *   signal: abortController.signal
+     * });
+     * ```
+     */
+    async poll(actionId, options = {}) {
+        return pollAction(this.client, actionId, options);
+    }
+    /**
+     * Poll multiple actions until completion
+     *
+     * Handles concurrent polling of multiple actions with optional
+     * concurrency limit and individual action tracking.
+     *
+     * @param actionIds - Array of action IDs to poll
+     * @param options - Polling options
+     * @returns Promise resolving to array of completed actions
+     *
+     * @example
+     * ```typescript
+     * const actions = await client.actions.pollMany([1, 2, 3], {
+     *   onProgress: (a) => updateUI(a),
+     *   concurrency: 3, // Poll 3 at a time
+     *   signal: abortController.signal
+     * });
+     * ```
+     */
+    async pollMany(actionIds, options = {}) {
+        return pollActions(this.client, actionIds, options);
+    }
+    /**
+     * Poll multiple actions with detailed result tracking
+     *
+     * Returns a BatchPollingResult with success/failure counts and
+     * per-action results for better error handling.
+     *
+     * @param actionIds - Array of action IDs to poll
+     * @param options - Polling options
+     * @returns Batch polling result with detailed status
+     *
+     * @example
+     * ```typescript
+     * const result = await client.actions.pollManyDetailed([1, 2, 3], {
+     *   concurrency: 2
+     * });
+     * console.log(`Success: ${result.successful}, Failed: ${result.failed}`);
+     * for (const [id, r] of result.results) {
+     *   if (r.error) console.error(`Action ${id} failed:`, r.error);
+     * }
+     * ```
+     */
+    async pollManyDetailed(actionIds, options = {}) {
+        return pollActionsDetailed(this.client, actionIds, options);
+    }
+    /**
+     * Wait for an action to complete (backward compatible alias)
+     *
+     * @param id - Action ID
+     * @param options - Polling options
+     * @returns Completed action
+     * @deprecated Use poll() instead for new code
+     */
+    async waitFor(id, options) {
+        return waitForAction(this.client, id, options);
+    }
+    /**
+     * Wait for multiple actions to complete (backward compatible alias)
+     *
+     * @param ids - Array of action IDs
+     * @param options - Polling options
+     * @returns Array of completed actions
+     * @deprecated Use pollMany() instead for new code
+     */
+    async waitForMany(ids, options) {
+        return waitForMultipleActions(this.client, ids, options);
+    }
+    /**
+     * Batch check multiple actions (no polling, single fetch)
+     *
+     * @param ids - Array of action IDs
+     * @returns Map of action ID to action
+     */
+    async batchCheck(ids) {
+        return batchCheckActions(this.client, ids);
+    }
+}
+// ============================================================================
+// Action Timeouts
+// ============================================================================
+/**
+ * Default timeouts for different action types (in milliseconds)
+ * Adjusted based on typical operation durations
+ */
+export const ACTION_TIMEOUTS = {
+    // Quick operations (under 1 minute)
+    [ActionCommand.StartServer]: 60000,
+    [ActionCommand.StopServer]: 60000,
+    [ActionCommand.RebootServer]: 120000,
+    [ActionCommand.Poweroff]: 60000,
+    [ActionCommand.ShutdownServer]: 60000,
+    [ActionCommand.ResetServer]: 60000,
+    // Medium operations (1-5 minutes)
+    [ActionCommand.CreateServer]: 300000,
+    [ActionCommand.DeleteServer]: 180000,
+    [ActionCommand.ChangeServerType]: 600000,
+    [ActionCommand.ChangeDnsPtr]: 30000,
+    // Long operations (5-30 minutes)
+    [ActionCommand.RebuildServer]: 900000,
+    [ActionCommand.CreateImage]: 1800000,
+    [ActionCommand.EnableRescue]: 120000,
+    [ActionCommand.DisableRescue]: 60000,
+    // Volume operations
+    [ActionCommand.CreateVolume]: 300000,
+    [ActionCommand.DeleteVolume]: 180000,
+    [ActionCommand.AttachVolume]: 120000,
+    [ActionCommand.DetachVolume]: 60000,
+    [ActionCommand.ResizeVolume]: 600000,
+    // Network operations
+    [ActionCommand.AddSubnet]: 60000,
+    [ActionCommand.DeleteSubnet]: 60000,
+    [ActionCommand.AddRoute]: 60000,
+    [ActionCommand.DeleteRoute]: 60000,
+    [ActionCommand.ChangeIpRange]: 120000,
+    [ActionCommand.AttachToNetwork]: 60000,
+    [ActionCommand.DetachFromNetwork]: 60000,
+    // Floating IP operations
+    [ActionCommand.AssignFloatingIp]: 60000,
+    [ActionCommand.UnassignFloatingIp]: 60000,
+    // Load Balancer operations
+    [ActionCommand.CreateLoadBalancer]: 300000,
+    [ActionCommand.DeleteLoadBalancer]: 180000,
+    [ActionCommand.AddTarget]: 60000,
+    [ActionCommand.RemoveTarget]: 60000,
+    [ActionCommand.AddService]: 60000,
+    [ActionCommand.UpdateService]: 60000,
+    [ActionCommand.DeleteService]: 60000,
+    [ActionCommand.LoadBalancerAttachToNetwork]: 60000,
+    [ActionCommand.LoadBalancerDetachFromNetwork]: 60000,
+    [ActionCommand.ChangeAlgorithm]: 60000,
+    [ActionCommand.ChangeType]: 60000,
+    // Certificate operations
+    [ActionCommand.IssueCertificate]: 600000, // Can take up to 10 minutes
+    [ActionCommand.RetryCertificate]: 600000,
+    // Firewall operations
+    [ActionCommand.SetFirewallRules]: 60000,
+    [ActionCommand.ApplyFirewall]: 120000,
+    [ActionCommand.RemoveFirewall]: 60000,
+    // Floating IP DNS
+    [ActionCommand.FloatingIpChangeDnsPtr]: 30000,
+    // Backup operations
+    [ActionCommand.EnableBackup]: 60000,
+    [ActionCommand.DisableBackup]: 60000,
+    // Protection operations
+    [ActionCommand.ChangeProtection]: 30000,
+    [ActionCommand.VolumeChangeProtection]: 30000,
+    [ActionCommand.NetworkChangeProtection]: 30000,
+    [ActionCommand.FloatingIpChangeProtection]: 30000,
+    [ActionCommand.LoadBalancerChangeProtection]: 30000,
+    [ActionCommand.FirewallChangeProtection]: 30000,
+    [ActionCommand.ImageChangeProtection]: 30000,
+    // Other operations
+    [ActionCommand.ChangeAliasIps]: 60000,
+};
+/**
+ * Get default timeout for an action command
+ */
+export function getActionTimeout(command) {
+    return ACTION_TIMEOUTS[command] || 300000; // Default 5 minutes
+}
+// ============================================================================
+// Enhanced Action Polling Service
+// ============================================================================
+/**
+ * Default polling options
+ */
+const DEFAULT_POLLING_OPTIONS = {
+    pollInterval: 2000,
+    maxRetries: 60,
+    timeout: 300000,
+    onProgress: () => { },
+    onComplete: () => { },
+    onError: () => { },
+    onRetry: () => { },
+    signal: undefined,
+    adaptive: false,
+    concurrency: 5,
+};
+/**
+ * Poll for an action to complete with full feature support
+ *
+ * This is the core polling service function that provides:
+ * - Progress tracking via onProgress callback
+ * - Success/error notification via onComplete/onError
+ * - Cancellation support via AbortSignal
+ * - Adaptive polling intervals
+ * - Retry logic with exponential backoff
+ *
+ * @param client - Hetzner API client
+ * @param actionId - Action ID to poll
+ * @param options - Polling options
+ * @returns Completed action
+ * @throws {HetznerActionError} If action fails
+ * @throws {HetznerTimeoutError} If action times out
+ *
+ * @example
+ * ```typescript
+ * const action = await pollAction(client, 123, {
+ *   onProgress: (a) => console.log(`Progress: ${a.progress}%`),
+ *   onComplete: (a) => console.log('Completed:', a.command),
+ *   onError: (e) => console.error('Failed:', e.message),
+ *   timeout: 60000,
+ *   signal: abortSignal
+ * });
+ * ```
+ */
+export async function pollAction(client, actionId, options = {}) {
+    const opts = { ...DEFAULT_POLLING_OPTIONS, ...options };
+    const startTime = Date.now();
+    let lastProgress = 0;
+    let lastError = null;
+    let attempt = 0;
+    // Check if already aborted
+    if (opts.signal?.aborted) {
+        throw new Error("Polling aborted before start");
+    }
+    // Set up abort listener
+    const abortListener = () => {
+        throw new Error("Polling aborted");
+    };
+    opts.signal?.addEventListener("abort", abortListener);
+    try {
+        while (attempt < opts.maxRetries) {
+            // Check timeout
+            const elapsed = Date.now() - startTime;
+            if (elapsed > opts.timeout) {
+                throw new HetznerTimeoutError(actionId, opts.timeout, lastProgress);
+            }
+            try {
+                const response = await client.request(`/actions/${actionId}`);
+                const action = response.action;
+                attempt++;
+                // Notify progress callback on any change
+                if (action.progress !== lastProgress) {
+                    lastProgress = action.progress;
+                    opts.onProgress(action);
+                }
+                // Check if action completed successfully
+                if (action.status === "success") {
+                    opts.onComplete(action);
+                    return action;
+                }
+                // Check if action failed
+                if (action.status === "error") {
+                    const error = new HetznerActionError(action.error, actionId);
+                    opts.onError(error, action);
+                    throw error;
+                }
+                // Still running - calculate wait time
+                let waitTime = opts.pollInterval;
+                if (opts.adaptive) {
+                    waitTime = getAdaptivePollInterval(action.progress);
+                }
+                await sleep(waitTime);
+            }
+            catch (error) {
+                // Check if this is a retryable error
+                if (isRetryableError(error)) {
+                    const delay = calculateRetryDelay(attempt);
+                    opts.onRetry(attempt, delay);
+                    if (opts.signal?.aborted) {
+                        throw new Error("Polling aborted during retry");
+                    }
+                    await sleep(delay);
+                    continue;
+                }
+                // Non-retryable error - throw immediately
+                throw error;
+            }
+        }
+        // Max retries exceeded
+        throw new HetznerTimeoutError(actionId, opts.timeout, lastProgress);
+    }
+    finally {
+        opts.signal?.removeEventListener("abort", abortListener);
+    }
+}
+/**
+ * Poll multiple actions concurrently
+ *
+ * Manages polling of multiple actions with optional concurrency limit.
+ * Each action is polled independently with shared callbacks.
+ *
+ * @param client - Hetzner API client
+ * @param actionIds - Array of action IDs to poll
+ * @param options - Polling options
+ * @returns Array of completed actions in same order as input
+ *
+ * @example
+ * ```typescript
+ * const actions = await pollActions(client, [1, 2, 3], {
+ *   onProgress: (a) => console.log(`Action ${a.id}: ${a.progress}%`),
+ *   onComplete: (a) => console.log(`Action ${a.id} complete`),
+ *   concurrency: 3 // Poll 3 actions at a time
+ * });
+ * ```
+ */
+export async function pollActions(client, actionIds, options = {}) {
+    const concurrency = options.concurrency ?? DEFAULT_POLLING_OPTIONS.concurrency;
+    // If concurrency is high enough, poll all at once
+    if (concurrency >= actionIds.length) {
+        const promises = actionIds.map((id) => pollAction(client, id, options));
+        return Promise.all(promises);
+    }
+    // Otherwise, process in batches with concurrency limit
+    const results = new Array(actionIds.length);
+    let currentIndex = 0;
+    const processBatch = async () => {
+        while (currentIndex < actionIds.length) {
+            const batchStart = currentIndex;
+            const batchEnd = Math.min(currentIndex + concurrency, actionIds.length);
+            const batchIds = actionIds.slice(batchStart, batchEnd);
+            currentIndex = batchEnd;
+            const batchResults = await Promise.all(batchIds.map((id, i) => pollAction(client, id, options)));
+            // Store results in correct positions
+            batchResults.forEach((result, i) => {
+                results[batchStart + i] = result;
+            });
+        }
+    };
+    // Process batches sequentially but actions within each batch concurrently
+    await processBatch();
+    return results;
+}
+/**
+ * Poll multiple actions with detailed result tracking
+ *
+ * Similar to pollActions but returns a BatchPollingResult with
+ * success/failure counts and per-action results for better
+ * error handling and monitoring.
+ *
+ * @param client - Hetzner API client
+ * @param actionIds - Array of action IDs to poll
+ * @param options - Polling options
+ * @returns Batch polling result with detailed status
+ *
+ * @example
+ * ```typescript
+ * const result = await pollActionsDetailed(client, [1, 2, 3], {
+ *   onProgress: (a) => updateProgressBar(a)
+ * });
+ *
+ * console.log(`Completed: ${result.successful}/${actionIds.length}`);
+ * for (const [id, r] of result.results) {
+ *   if (r.error) {
+ *     console.error(`Action ${id} failed:`, r.error.message);
+ *   }
+ * }
+ * ```
+ */
+export async function pollActionsDetailed(client, actionIds, options = {}) {
+    const startTime = Date.now();
+    const results = new Map();
+    let successful = 0;
+    let failed = 0;
+    // Wrap callbacks to track results
+    const wrappedOptions = {
+        ...options,
+        onComplete: (action) => {
+            results.set(action.id, {
+                success: true,
+                action,
+                attempts: 0,
+                elapsed: Date.now() - startTime,
+            });
+            successful++;
+            options.onComplete?.(action);
+        },
+        onError: (error, action) => {
+            results.set(action.id, {
+                success: false,
+                action,
+                error,
+                attempts: 0,
+                elapsed: Date.now() - startTime,
+            });
+            failed++;
+            options.onError?.(error, action);
+        },
+    };
+    try {
+        // Poll all actions
+        await pollActions(client, actionIds, wrappedOptions);
+    }
+    catch (error) {
+        // Some actions may have failed, but we still return results
+        console.warn("Some actions failed during batch polling:", error);
+    }
+    return {
+        results,
+        successful,
+        failed,
+        elapsed: Date.now() - startTime,
+    };
+}
+// ============================================================================
+// Backward Compatible Polling Functions
+// ============================================================================
+/**
+ * Poll for an action to complete (backward compatible)
+ *
+ * @deprecated Use pollAction() instead for new code
+ */
+export async function waitForAction(client, actionId, options = {}) {
+    const opts = { ...DEFAULT_POLLING_OPTIONS, ...options };
+    const startTime = Date.now();
+    let lastProgress = 0;
+    let lastError = null;
+    for (let attempt = 0; attempt < opts.maxRetries; attempt++) {
+        // Check timeout
+        if (Date.now() - startTime > opts.timeout) {
+            throw new HetznerTimeoutError(actionId, opts.timeout, lastProgress);
+        }
+        try {
+            const action = await client.request(`/actions/${actionId}`);
+            // Notify progress callback
+            if (action.action.progress !== lastProgress) {
+                lastProgress = action.action.progress;
+                opts.onProgress(action.action);
+            }
+            // Check if action is complete
+            if (action.action.status === "success") {
+                return action.action;
+            }
+            if (action.action.status === "error") {
+                throw new HetznerActionError(action.action.error, actionId);
+            }
+            // Still running - wait before next poll
+            await sleep(opts.pollInterval);
+        }
+        catch (error) {
+            // Check if error is retryable
+            if (isRetryableError(error)) {
+                const delay = calculateRetryDelay(attempt);
+                console.warn(`Retrying action ${actionId} after ${delay}ms (attempt ${attempt + 1}/${opts.maxRetries})`);
+                await sleep(delay);
+                continue;
+            }
+            // Non-retryable error - throw immediately
+            throw error;
+        }
+    }
+    // Max retries exceeded
+    throw new HetznerTimeoutError(actionId, opts.timeout, lastProgress);
+}
+/**
+ * Poll for multiple actions concurrently (backward compatible)
+ *
+ * @deprecated Use pollActions() instead for new code
+ */
+export async function waitForMultipleActions(client, actionIds, options = {}) {
+    const promises = actionIds.map((id) => waitForAction(client, id, options));
+    return Promise.all(promises);
+}
+/**
+ * Poll for multiple actions with concurrency limit (backward compatible)
+ *
+ * @deprecated Use pollActions() with concurrency option instead
+ */
+export async function waitForMultipleActionsWithLimit(client, actionIds, concurrency = 5, options = {}) {
+    const results = [];
+    const chunks = [];
+    // Split action IDs into chunks
+    for (let i = 0; i < actionIds.length; i += concurrency) {
+        chunks.push(actionIds.slice(i, i + concurrency));
+    }
+    // Process each chunk sequentially
+    for (const chunk of chunks) {
+        const chunkResults = await waitForMultipleActions(client, chunk, options);
+        results.push(...chunkResults);
+    }
+    return results;
+}
+/**
+ * Batch check multiple actions in a single API call
+ *
+ * Uses the /actions?id=42&id=43 endpoint to fetch multiple actions at once
+ *
+ * @param client - Hetzner API client
+ * @param actionIds - Array of action IDs to check
+ * @returns Map of action ID to action
+ */
+export async function batchCheckActions(client, actionIds) {
+    const MAX_BATCH_SIZE = 50; // API limit for ID parameter
+    const results = new Map();
+    // Process in batches
+    for (let i = 0; i < actionIds.length; i += MAX_BATCH_SIZE) {
+        const batch = actionIds.slice(i, i + MAX_BATCH_SIZE);
+        const idParams = batch.map((id) => `id=${id}`).join("&");
+        const response = await client.request(`/actions?${idParams}`);
+        for (const action of response.actions) {
+            results.set(action.id, action);
+        }
+    }
+    return results;
+}
+// ============================================================================
+// Action Status Utilities
+// ============================================================================
+/**
+ * Check if an action is running
+ */
+export function isActionRunning(action) {
+    return action.status === "running";
+}
+/**
+ * Check if an action completed successfully
+ */
+export function isActionSuccess(action) {
+    return action.status === "success";
+}
+/**
+ * Check if an action failed
+ */
+export function isActionError(action) {
+    return action.status === "error";
+}
+/**
+ * Format action progress for display
+ */
+export function formatActionProgress(action) {
+    const command = action.command.replace(/_/g, " ");
+    const status = action.status.toUpperCase();
+    return `${status}: ${command} (${action.progress}%)`;
+}
+/**
+ * Get human-readable action description
+ */
+export function getActionDescription(command) {
+    const descriptions = {
+        [ActionCommand.CreateServer]: "Creating server",
+        [ActionCommand.DeleteServer]: "Deleting server",
+        [ActionCommand.StartServer]: "Starting server",
+        [ActionCommand.StopServer]: "Stopping server",
+        [ActionCommand.RebootServer]: "Rebooting server",
+        [ActionCommand.ResetServer]: "Resetting server",
+        [ActionCommand.ShutdownServer]: "Shutting down server",
+        [ActionCommand.Poweroff]: "Cutting power to server",
+        [ActionCommand.ChangeServerType]: "Changing server type",
+        [ActionCommand.RebuildServer]: "Rebuilding server",
+        [ActionCommand.EnableBackup]: "Enabling backups",
+        [ActionCommand.DisableBackup]: "Disabling backups",
+        [ActionCommand.CreateImage]: "Creating image",
+        [ActionCommand.ChangeDnsPtr]: "Changing reverse DNS",
+        [ActionCommand.AttachToNetwork]: "Attaching to network",
+        [ActionCommand.DetachFromNetwork]: "Detaching from network",
+        [ActionCommand.ChangeAliasIps]: "Changing alias IPs",
+        [ActionCommand.EnableRescue]: "Enabling rescue mode",
+        [ActionCommand.DisableRescue]: "Disabling rescue mode",
+        [ActionCommand.ChangeProtection]: "Changing protection",
+        [ActionCommand.CreateVolume]: "Creating volume",
+        [ActionCommand.DeleteVolume]: "Deleting volume",
+        [ActionCommand.AttachVolume]: "Attaching volume",
+        [ActionCommand.DetachVolume]: "Detaching volume",
+        [ActionCommand.ResizeVolume]: "Resizing volume",
+        [ActionCommand.VolumeChangeProtection]: "Changing volume protection",
+        [ActionCommand.AddSubnet]: "Adding subnet",
+        [ActionCommand.DeleteSubnet]: "Deleting subnet",
+        [ActionCommand.AddRoute]: "Adding route",
+        [ActionCommand.DeleteRoute]: "Deleting route",
+        [ActionCommand.ChangeIpRange]: "Changing IP range",
+        [ActionCommand.NetworkChangeProtection]: "Changing network protection",
+        [ActionCommand.AssignFloatingIp]: "Assigning floating IP",
+        [ActionCommand.UnassignFloatingIp]: "Unassigning floating IP",
+        [ActionCommand.FloatingIpChangeDnsPtr]: "Changing floating IP DNS",
+        [ActionCommand.FloatingIpChangeProtection]: "Changing floating IP protection",
+        [ActionCommand.CreateLoadBalancer]: "Creating load balancer",
+        [ActionCommand.DeleteLoadBalancer]: "Deleting load balancer",
+        [ActionCommand.AddTarget]: "Adding target to load balancer",
+        [ActionCommand.RemoveTarget]: "Removing target from load balancer",
+        [ActionCommand.AddService]: "Adding service to load balancer",
+        [ActionCommand.UpdateService]: "Updating load balancer service",
+        [ActionCommand.DeleteService]: "Deleting load balancer service",
+        [ActionCommand.LoadBalancerAttachToNetwork]: "Attaching load balancer to network",
+        [ActionCommand.LoadBalancerDetachFromNetwork]: "Detaching load balancer from network",
+        [ActionCommand.ChangeAlgorithm]: "Changing load balancer algorithm",
+        [ActionCommand.ChangeType]: "Changing load balancer type",
+        [ActionCommand.LoadBalancerChangeProtection]: "Changing load balancer protection",
+        [ActionCommand.IssueCertificate]: "Issuing certificate",
+        [ActionCommand.RetryCertificate]: "Retrying certificate",
+        [ActionCommand.SetFirewallRules]: "Setting firewall rules",
+        [ActionCommand.ApplyFirewall]: "Applying firewall",
+        [ActionCommand.RemoveFirewall]: "Removing firewall",
+        [ActionCommand.FirewallChangeProtection]: "Changing firewall protection",
+        [ActionCommand.ImageChangeProtection]: "Changing image protection",
+    };
+    return descriptions[command] || command.replace(/_/g, " ");
+}
+// ============================================================================
+// Adaptive Polling
+// ============================================================================
+/**
+ * Get adaptive polling interval based on operation type
+ */
+export function getPollInterval(command) {
+    const intervals = {
+        // Quick operations - poll frequently
+        [ActionCommand.StartServer]: 5000,
+        [ActionCommand.StopServer]: 5000,
+        [ActionCommand.RebootServer]: 10000,
+        [ActionCommand.Poweroff]: 5000,
+        [ActionCommand.ShutdownServer]: 5000,
+        // Medium operations
+        [ActionCommand.CreateServer]: 15000,
+        [ActionCommand.CreateVolume]: 10000,
+        [ActionCommand.AttachVolume]: 8000,
+        [ActionCommand.DetachVolume]: 5000,
+        // Long operations - poll less frequently
+        [ActionCommand.RebuildServer]: 30000,
+        [ActionCommand.CreateImage]: 60000,
+        [ActionCommand.IssueCertificate]: 30000,
+    };
+    return intervals[command] || 10000; // Default 10 seconds
+}
+/**
+ * Get adaptive polling interval based on action progress
+ */
+export function getAdaptivePollInterval(progress) {
+    if (progress < 10)
+        return 2000; // Quick progress at start
+    if (progress < 50)
+        return 5000; // Medium progress
+    if (progress < 90)
+        return 10000; // Slowing down
+    return 15000; // Near completion
+}
+/**
+ * Poll with adaptive intervals (backward compatible)
+ *
+ * @deprecated Use pollAction() with adaptive: true option instead
+ */
+export async function waitForActionAdaptive(client, actionId, command, options = {}) {
+    const startTime = Date.now();
+    const timeout = options.timeout ?? getActionTimeout(command);
+    let lastProgress = -1;
+    while (Date.now() - startTime < timeout) {
+        const action = await client.request(`/actions/${actionId}`);
+        // Notify progress callback
+        if (action.action.progress !== lastProgress) {
+            lastProgress = action.action.progress;
+            options.onProgress?.(action.action);
+        }
+        if (action.action.status === "success") {
+            return action.action;
+        }
+        if (action.action.status === "error") {
+            throw new HetznerActionError(action.action.error, actionId);
+        }
+        // Adaptive polling based on progress
+        const interval = getAdaptivePollInterval(action.action.progress);
+        await sleep(interval);
+    }
+    throw new HetznerTimeoutError(actionId, timeout, lastProgress);
+}
+// ============================================================================
+// Rate Limit Handling
+// ============================================================================
+/**
+ * Parse rate limit headers from response
+ */
+export function parseRateLimitHeaders(headers) {
+    const limit = headers.get("RateLimit-Limit");
+    const remaining = headers.get("RateLimit-Remaining");
+    const reset = headers.get("RateLimit-Reset");
+    if (!limit || !remaining || !reset) {
+        return null;
+    }
+    return {
+        limit: parseInt(limit, 10),
+        remaining: parseInt(remaining, 10),
+        reset: parseInt(reset, 10),
+    };
+}
+/**
+ * Check if rate limit is low (should warn user)
+ */
+export function isRateLimitLow(info, threshold = 100) {
+    return info.remaining < threshold;
+}
+/**
+ * Get human-readable rate limit status
+ */
+export function formatRateLimitStatus(info) {
+    const resetDate = new Date(info.reset * 1000);
+    const remaining = info.remaining;
+    const limit = info.limit;
+    const percentage = ((remaining / limit) * 100).toFixed(1);
+    return `${remaining}/${limit} (${percentage}%) - resets at ${resetDate.toISOString()}`;
+}
+/**
+ * Wait for rate limit to reset
+ */
+export async function waitForRateLimitReset(info) {
+    const resetTime = info.reset * 1000;
+    const now = Date.now();
+    const waitTime = Math.max(0, resetTime - now);
+    if (waitTime > 0) {
+        const waitSeconds = Math.ceil(waitTime / 1000);
+        console.log(`Rate limit exhausted. Waiting ${waitSeconds}s for reset...`);
+        await sleep(waitTime);
+    }
+}
+// ============================================================================
+// Utilities
+// ============================================================================
+/**
+ * Sleep for specified milliseconds
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Create a progress logger for actions
+ */
+export function createProgressLogger(prefix = "Action") {
+    return (action) => {
+        console.log(`[${prefix}] ${getActionDescription(action.command)}: ${action.progress}%`);
+    };
+}
+//# sourceMappingURL=actions.js.map