@ebowwa/hetzner 0.3.2 → 0.3.3

package/dist/actions.js

@@ -0,0 +1,782 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = import.meta.require;
+
+// src/types.ts
+import {
+  EnvironmentStatus,
+  ActionStatus,
+  VolumeStatus
+} from "@ebowwa/codespaces-types/compile";
+var ActionCommand;
+((ActionCommand2) => {
+  ActionCommand2["CreateServer"] = "create_server";
+  ActionCommand2["DeleteServer"] = "delete_server";
+  ActionCommand2["StartServer"] = "start_server";
+  ActionCommand2["StopServer"] = "stop_server";
+  ActionCommand2["RebootServer"] = "reboot_server";
+  ActionCommand2["ResetServer"] = "reset_server";
+  ActionCommand2["ShutdownServer"] = "shutdown_server";
+  ActionCommand2["Poweroff"] = "poweroff";
+  ActionCommand2["ChangeServerType"] = "change_server_type";
+  ActionCommand2["RebuildServer"] = "rebuild_server";
+  ActionCommand2["EnableBackup"] = "enable_backup";
+  ActionCommand2["DisableBackup"] = "disable_backup";
+  ActionCommand2["CreateImage"] = "create_image";
+  ActionCommand2["ChangeDnsPtr"] = "change_dns_ptr";
+  ActionCommand2["AttachToNetwork"] = "attach_to_network";
+  ActionCommand2["DetachFromNetwork"] = "detach_from_network";
+  ActionCommand2["ChangeAliasIps"] = "change_alias_ips";
+  ActionCommand2["EnableRescue"] = "enable_rescue";
+  ActionCommand2["DisableRescue"] = "disable_rescue";
+  ActionCommand2["ChangeProtection"] = "change_protection";
+  ActionCommand2["CreateVolume"] = "create_volume";
+  ActionCommand2["DeleteVolume"] = "delete_volume";
+  ActionCommand2["AttachVolume"] = "attach_volume";
+  ActionCommand2["DetachVolume"] = "detach_volume";
+  ActionCommand2["ResizeVolume"] = "resize_volume";
+  ActionCommand2["VolumeChangeProtection"] = "volume_change_protection";
+  ActionCommand2["AddSubnet"] = "add_subnet";
+  ActionCommand2["DeleteSubnet"] = "delete_subnet";
+  ActionCommand2["AddRoute"] = "add_route";
+  ActionCommand2["DeleteRoute"] = "delete_route";
+  ActionCommand2["ChangeIpRange"] = "change_ip_range";
+  ActionCommand2["NetworkChangeProtection"] = "network_change_protection";
+  ActionCommand2["AssignFloatingIp"] = "assign_floating_ip";
+  ActionCommand2["UnassignFloatingIp"] = "unassign_floating_ip";
+  ActionCommand2["FloatingIpChangeDnsPtr"] = "floating_ip_change_dns_ptr";
+  ActionCommand2["FloatingIpChangeProtection"] = "floating_ip_change_protection";
+  ActionCommand2["CreateLoadBalancer"] = "create_load_balancer";
+  ActionCommand2["DeleteLoadBalancer"] = "delete_load_balancer";
+  ActionCommand2["AddTarget"] = "add_target";
+  ActionCommand2["RemoveTarget"] = "remove_target";
+  ActionCommand2["AddService"] = "add_service";
+  ActionCommand2["UpdateService"] = "update_service";
+  ActionCommand2["DeleteService"] = "delete_service";
+  ActionCommand2["LoadBalancerAttachToNetwork"] = "load_balancer_attach_to_network";
+  ActionCommand2["LoadBalancerDetachFromNetwork"] = "load_balancer_detach_from_network";
+  ActionCommand2["ChangeAlgorithm"] = "change_algorithm";
+  ActionCommand2["ChangeType"] = "change_type";
+  ActionCommand2["LoadBalancerChangeProtection"] = "load_balancer_change_protection";
+  ActionCommand2["IssueCertificate"] = "issue_certificate";
+  ActionCommand2["RetryCertificate"] = "retry_certificate";
+  ActionCommand2["SetFirewallRules"] = "set_firewall_rules";
+  ActionCommand2["ApplyFirewall"] = "apply_firewall";
+  ActionCommand2["RemoveFirewall"] = "remove_firewall";
+  ActionCommand2["FirewallChangeProtection"] = "firewall_change_protection";
+  ActionCommand2["ImageChangeProtection"] = "image_change_protection";
+})(ActionCommand ||= {});
+var ResourceType;
+((ResourceType2) => {
+  ResourceType2["Server"] = "server";
+  ResourceType2["Volume"] = "volume";
+  ResourceType2["Network"] = "network";
+  ResourceType2["FloatingIp"] = "floating_ip";
+  ResourceType2["LoadBalancer"] = "load_balancer";
+  ResourceType2["Certificate"] = "certificate";
+  ResourceType2["Firewall"] = "firewall";
+  ResourceType2["Image"] = "image";
+})(ResourceType ||= {});
+
+// src/errors.ts
+var HetznerErrorCode;
+((HetznerErrorCode2) => {
+  HetznerErrorCode2["Unauthorized"] = "unauthorized";
+  HetznerErrorCode2["InvalidInput"] = "invalid_input";
+  HetznerErrorCode2["JSONError"] = "json_error";
+  HetznerErrorCode2["Forbidden"] = "forbidden";
+  HetznerErrorCode2["NotFound"] = "not_found";
+  HetznerErrorCode2["ResourceLocked"] = "locked";
+  HetznerErrorCode2["ResourceLimitExceeded"] = "resource_limit_exceeded";
+  HetznerErrorCode2["UniquenessError"] = "uniqueness_error";
+  HetznerErrorCode2["RateLimitExceeded"] = "rate_limit_exceeded";
+  HetznerErrorCode2["Conflict"] = "conflict";
+  HetznerErrorCode2["ServiceError"] = "service_error";
+  HetznerErrorCode2["ServerNotStopped"] = "server_not_stopped";
+  HetznerErrorCode2["ServerAlreadyStopped"] = "server_already_stopped";
+  HetznerErrorCode2["InvalidServerType"] = "invalid_server_type";
+  HetznerErrorCode2["IpNotOwned"] = "ip_not_owned";
+  HetznerErrorCode2["IpAlreadyAssigned"] = "ip_already_assigned";
+  HetznerErrorCode2["VolumeAlreadyAttached"] = "volume_already_attached";
+  HetznerErrorCode2["VolumeSizeNotMultiple"] = "volume_size_not_multiple";
+  HetznerErrorCode2["FirewallInUse"] = "firewall_in_use";
+  HetznerErrorCode2["CertificateValidationFailed"] = "certificate_validation_failed";
+  HetznerErrorCode2["CertificatePending"] = "certificate_pending";
+})(HetznerErrorCode ||= {});
+
+class HetznerAPIError extends Error {
+  code;
+  details;
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "HetznerAPIError";
+  }
+}
+
+class HetznerUnauthorizedError extends HetznerAPIError {
+  constructor(message = "Unauthorized: Invalid API token") {
+    super(message, "unauthorized" /* Unauthorized */);
+    this.name = "HetznerUnauthorizedError";
+  }
+}
+
+class HetznerForbiddenError extends HetznerAPIError {
+  constructor(message = "Forbidden: Insufficient permissions") {
+    super(message, "forbidden" /* Forbidden */);
+    this.name = "HetznerForbiddenError";
+  }
+}
+
+class HetznerNotFoundError extends HetznerAPIError {
+  constructor(resource, id) {
+    super(`${resource} with ID ${id} not found`, "not_found" /* NotFound */, { resource, id });
+    this.name = "HetznerNotFoundError";
+  }
+}
+
+class HetznerRateLimitError extends HetznerAPIError {
+  rateLimitInfo;
+  constructor(message = "Rate limit exceeded", rateLimitInfo) {
+    super(message, "rate_limit_exceeded" /* RateLimitExceeded */, rateLimitInfo);
+    this.rateLimitInfo = rateLimitInfo;
+    this.name = "HetznerRateLimitError";
+  }
+  get resetInMs() {
+    if (!this.rateLimitInfo)
+      return 60000;
+    return Math.max(0, this.rateLimitInfo.reset * 1000 - Date.now());
+  }
+  get resetTime() {
+    if (!this.rateLimitInfo)
+      return "unknown";
+    return new Date(this.rateLimitInfo.reset * 1000).toISOString();
+  }
+}
+
+class HetznerResourceLockedError extends HetznerAPIError {
+  actionInProgress;
+  constructor(resource, id, actionInProgress) {
+    super(`${resource} ${id} is locked${actionInProgress ? ` by ${actionInProgress}` : ""}`, "locked" /* ResourceLocked */, { resource, id, actionInProgress });
+    this.actionInProgress = actionInProgress;
+    this.name = "HetznerResourceLockedError";
+  }
+}
+
+class HetznerResourceLimitError extends HetznerAPIError {
+  constructor(resource, limit) {
+    super(`Resource limit exceeded: ${resource} (limit: ${limit})`, "resource_limit_exceeded" /* ResourceLimitExceeded */, { resource, limit });
+    this.name = "HetznerResourceLimitError";
+  }
+}
+
+class HetznerInvalidInputError extends HetznerAPIError {
+  fields;
+  constructor(message, fields) {
+    super(message, "invalid_input" /* InvalidInput */, { fields });
+    this.fields = fields;
+    this.name = "HetznerInvalidInputError";
+  }
+}
+
+class HetznerConflictError extends HetznerAPIError {
+  constructor(message, details) {
+    super(message, "conflict" /* Conflict */, details);
+    this.name = "HetznerConflictError";
+  }
+}
+
+class HetznerServiceError extends HetznerAPIError {
+  statusCode;
+  constructor(message, statusCode) {
+    super(message, "service_error" /* ServiceError */, { statusCode });
+    this.statusCode = statusCode;
+    this.name = "HetznerServiceError";
+  }
+}
+
+class HetznerActionError extends HetznerAPIError {
+  actionError;
+  actionId;
+  constructor(actionError, actionId) {
+    super(`Action ${actionId} failed: ${actionError.code} - ${actionError.message}`, actionError.code, { actionError, actionId });
+    this.actionError = actionError;
+    this.actionId = actionId;
+    this.name = "HetznerActionError";
+  }
+}
+
+class HetznerTimeoutError extends HetznerAPIError {
+  lastProgress;
+  constructor(actionId, timeout, lastProgress) {
+    super(`Action ${actionId} timed out after ${timeout}ms (last progress: ${lastProgress}%)`, "timeout", { actionId, timeout, lastProgress });
+    this.lastProgress = lastProgress;
+    this.name = "HetznerTimeoutError";
+  }
+}
+function createHetznerError(statusCode, body) {
+  const error = body.error;
+  if (!error) {
+    return new HetznerServiceError(`HTTP ${statusCode}: ${JSON.stringify(body)}`, statusCode);
+  }
+  switch (statusCode) {
+    case 401:
+      return new HetznerUnauthorizedError(error.message);
+    case 403:
+      return new HetznerForbiddenError(error.message);
+    case 404:
+      return new HetznerNotFoundError("resource", "unknown");
+    case 429:
+      return new HetznerRateLimitError(error.message);
+    case 400:
+      if (error.code === "locked" /* ResourceLocked */) {
+        return new HetznerResourceLockedError("resource", "unknown", error.message);
+      }
+      if (error.code === "invalid_input" /* InvalidInput */) {
+        return new HetznerInvalidInputError(error.message);
+      }
+      return new HetznerInvalidInputError(error.message);
+    case 409:
+      return new HetznerConflictError(error.message, error.details);
+    default:
+      if (statusCode >= 500) {
+        return new HetznerServiceError(error.message, statusCode);
+      }
+      return new HetznerAPIError(error.message, error.code, error.details);
+  }
+}
+function isRetryableError(error) {
+  if (error instanceof HetznerRateLimitError)
+    return true;
+  if (error instanceof HetznerResourceLockedError)
+    return true;
+  if (error instanceof HetznerServiceError)
+    return true;
+  if (error instanceof HetznerConflictError)
+    return true;
+  return false;
+}
+function isRateLimitError(error) {
+  return error instanceof HetznerRateLimitError;
+}
+function isResourceLockedError(error) {
+  return error instanceof HetznerResourceLockedError;
+}
+function calculateRetryDelay(attempt, baseDelay = 1000, maxDelay = 60000) {
+  const delay = baseDelay * Math.pow(2, attempt);
+  const jitter = delay * 0.25 * (Math.random() * 2 - 1);
+  return Math.min(maxDelay, delay + jitter);
+}
+function defaultErrorHandler(error) {
+  console.error(`[Hetzner API Error] ${error.name}: ${error.message}`);
+  if (error.details) {
+    console.error("Details:", error.details);
+  }
+}
+
+// src/actions.ts
+class ActionOperations {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async get(id) {
+    const response = await this.client.request(`/actions/${id}`);
+    return response.action;
+  }
+  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());
+    if (options?.server_id)
+      params.append("server_id", options.server_id.toString());
+    const query = params.toString();
+    const response = await this.client.request(`/actions${query ? `?${query}` : ""}`);
+    return response.actions;
+  }
+  async poll(actionId, options = {}) {
+    return pollAction(this.client, actionId, options);
+  }
+  async pollMany(actionIds, options = {}) {
+    return pollActions(this.client, actionIds, options);
+  }
+  async pollManyDetailed(actionIds, options = {}) {
+    return pollActionsDetailed(this.client, actionIds, options);
+  }
+  async waitFor(id, options) {
+    return waitForAction(this.client, id, options);
+  }
+  async waitForMany(ids, options) {
+    return waitForMultipleActions(this.client, ids, options);
+  }
+  async batchCheck(ids) {
+    return batchCheckActions(this.client, ids);
+  }
+}
+var ACTION_TIMEOUTS = {
+  ["start_server" /* StartServer */]: 60000,
+  ["stop_server" /* StopServer */]: 60000,
+  ["reboot_server" /* RebootServer */]: 120000,
+  ["poweroff" /* Poweroff */]: 60000,
+  ["shutdown_server" /* ShutdownServer */]: 60000,
+  ["reset_server" /* ResetServer */]: 60000,
+  ["create_server" /* CreateServer */]: 300000,
+  ["delete_server" /* DeleteServer */]: 180000,
+  ["change_server_type" /* ChangeServerType */]: 600000,
+  ["change_dns_ptr" /* ChangeDnsPtr */]: 30000,
+  ["rebuild_server" /* RebuildServer */]: 900000,
+  ["create_image" /* CreateImage */]: 1800000,
+  ["enable_rescue" /* EnableRescue */]: 120000,
+  ["disable_rescue" /* DisableRescue */]: 60000,
+  ["create_volume" /* CreateVolume */]: 300000,
+  ["delete_volume" /* DeleteVolume */]: 180000,
+  ["attach_volume" /* AttachVolume */]: 120000,
+  ["detach_volume" /* DetachVolume */]: 60000,
+  ["resize_volume" /* ResizeVolume */]: 600000,
+  ["add_subnet" /* AddSubnet */]: 60000,
+  ["delete_subnet" /* DeleteSubnet */]: 60000,
+  ["add_route" /* AddRoute */]: 60000,
+  ["delete_route" /* DeleteRoute */]: 60000,
+  ["change_ip_range" /* ChangeIpRange */]: 120000,
+  ["attach_to_network" /* AttachToNetwork */]: 60000,
+  ["detach_from_network" /* DetachFromNetwork */]: 60000,
+  ["assign_floating_ip" /* AssignFloatingIp */]: 60000,
+  ["unassign_floating_ip" /* UnassignFloatingIp */]: 60000,
+  ["create_load_balancer" /* CreateLoadBalancer */]: 300000,
+  ["delete_load_balancer" /* DeleteLoadBalancer */]: 180000,
+  ["add_target" /* AddTarget */]: 60000,
+  ["remove_target" /* RemoveTarget */]: 60000,
+  ["add_service" /* AddService */]: 60000,
+  ["update_service" /* UpdateService */]: 60000,
+  ["delete_service" /* DeleteService */]: 60000,
+  ["load_balancer_attach_to_network" /* LoadBalancerAttachToNetwork */]: 60000,
+  ["load_balancer_detach_from_network" /* LoadBalancerDetachFromNetwork */]: 60000,
+  ["change_algorithm" /* ChangeAlgorithm */]: 60000,
+  ["change_type" /* ChangeType */]: 60000,
+  ["issue_certificate" /* IssueCertificate */]: 600000,
+  ["retry_certificate" /* RetryCertificate */]: 600000,
+  ["set_firewall_rules" /* SetFirewallRules */]: 60000,
+  ["apply_firewall" /* ApplyFirewall */]: 120000,
+  ["remove_firewall" /* RemoveFirewall */]: 60000,
+  ["floating_ip_change_dns_ptr" /* FloatingIpChangeDnsPtr */]: 30000,
+  ["enable_backup" /* EnableBackup */]: 60000,
+  ["disable_backup" /* DisableBackup */]: 60000,
+  ["change_protection" /* ChangeProtection */]: 30000,
+  ["volume_change_protection" /* VolumeChangeProtection */]: 30000,
+  ["network_change_protection" /* NetworkChangeProtection */]: 30000,
+  ["floating_ip_change_protection" /* FloatingIpChangeProtection */]: 30000,
+  ["load_balancer_change_protection" /* LoadBalancerChangeProtection */]: 30000,
+  ["firewall_change_protection" /* FirewallChangeProtection */]: 30000,
+  ["image_change_protection" /* ImageChangeProtection */]: 30000,
+  ["change_alias_ips" /* ChangeAliasIps */]: 60000
+};
+function getActionTimeout(command) {
+  return ACTION_TIMEOUTS[command] || 300000;
+}
+var DEFAULT_POLLING_OPTIONS = {
+  pollInterval: 2000,
+  maxRetries: 60,
+  timeout: 300000,
+  onProgress: () => {},
+  onComplete: () => {},
+  onError: () => {},
+  onRetry: () => {},
+  signal: undefined,
+  adaptive: false,
+  concurrency: 5
+};
+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;
+  if (opts.signal?.aborted) {
+    throw new Error("Polling aborted before start");
+  }
+  const abortListener = () => {
+    throw new Error("Polling aborted");
+  };
+  opts.signal?.addEventListener("abort", abortListener);
+  try {
+    while (attempt < opts.maxRetries) {
+      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++;
+        if (action.progress !== lastProgress) {
+          lastProgress = action.progress;
+          opts.onProgress(action);
+        }
+        if (action.status === "success") {
+          opts.onComplete(action);
+          return action;
+        }
+        if (action.status === "error") {
+          const error = new HetznerActionError(action.error, actionId);
+          opts.onError(error, action);
+          throw error;
+        }
+        let waitTime = opts.pollInterval;
+        if (opts.adaptive) {
+          waitTime = getAdaptivePollInterval(action.progress);
+        }
+        await sleep(waitTime);
+      } catch (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;
+        }
+        throw error;
+      }
+    }
+    throw new HetznerTimeoutError(actionId, opts.timeout, lastProgress);
+  } finally {
+    opts.signal?.removeEventListener("abort", abortListener);
+  }
+}
+async function pollActions(client, actionIds, options = {}) {
+  const concurrency = options.concurrency ?? DEFAULT_POLLING_OPTIONS.concurrency;
+  if (concurrency >= actionIds.length) {
+    const promises = actionIds.map((id) => pollAction(client, id, options));
+    return Promise.all(promises);
+  }
+  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)));
+      batchResults.forEach((result, i) => {
+        results[batchStart + i] = result;
+      });
+    }
+  };
+  await processBatch();
+  return results;
+}
+async function pollActionsDetailed(client, actionIds, options = {}) {
+  const startTime = Date.now();
+  const results = new Map;
+  let successful = 0;
+  let failed = 0;
+  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 {
+    await pollActions(client, actionIds, wrappedOptions);
+  } catch (error) {
+    console.warn("Some actions failed during batch polling:", error);
+  }
+  return {
+    results,
+    successful,
+    failed,
+    elapsed: Date.now() - startTime
+  };
+}
+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++) {
+    if (Date.now() - startTime > opts.timeout) {
+      throw new HetznerTimeoutError(actionId, opts.timeout, lastProgress);
+    }
+    try {
+      const action = await client.request(`/actions/${actionId}`);
+      if (action.action.progress !== lastProgress) {
+        lastProgress = action.action.progress;
+        opts.onProgress(action.action);
+      }
+      if (action.action.status === "success") {
+        return action.action;
+      }
+      if (action.action.status === "error") {
+        throw new HetznerActionError(action.action.error, actionId);
+      }
+      await sleep(opts.pollInterval);
+    } catch (error) {
+      if (isRetryableError(error)) {
+        const delay = calculateRetryDelay(attempt);
+        console.warn(`Retrying action ${actionId} after ${delay}ms (attempt ${attempt + 1}/${opts.maxRetries})`);
+        await sleep(delay);
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw new HetznerTimeoutError(actionId, opts.timeout, lastProgress);
+}
+async function waitForMultipleActions(client, actionIds, options = {}) {
+  const promises = actionIds.map((id) => waitForAction(client, id, options));
+  return Promise.all(promises);
+}
+async function waitForMultipleActionsWithLimit(client, actionIds, concurrency = 5, options = {}) {
+  const results = [];
+  const chunks = [];
+  for (let i = 0;i < actionIds.length; i += concurrency) {
+    chunks.push(actionIds.slice(i, i + concurrency));
+  }
+  for (const chunk of chunks) {
+    const chunkResults = await waitForMultipleActions(client, chunk, options);
+    results.push(...chunkResults);
+  }
+  return results;
+}
+async function batchCheckActions(client, actionIds) {
+  const MAX_BATCH_SIZE = 50;
+  const results = new Map;
+  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;
+}
+function isActionRunning(action) {
+  return action.status === "running";
+}
+function isActionSuccess(action) {
+  return action.status === "success";
+}
+function isActionError(action) {
+  return action.status === "error";
+}
+function formatActionProgress(action) {
+  const command = action.command.replace(/_/g, " ");
+  const status = action.status.toUpperCase();
+  return `${status}: ${command} (${action.progress}%)`;
+}
+function getActionDescription(command) {
+  const descriptions = {
+    ["create_server" /* CreateServer */]: "Creating server",
+    ["delete_server" /* DeleteServer */]: "Deleting server",
+    ["start_server" /* StartServer */]: "Starting server",
+    ["stop_server" /* StopServer */]: "Stopping server",
+    ["reboot_server" /* RebootServer */]: "Rebooting server",
+    ["reset_server" /* ResetServer */]: "Resetting server",
+    ["shutdown_server" /* ShutdownServer */]: "Shutting down server",
+    ["poweroff" /* Poweroff */]: "Cutting power to server",
+    ["change_server_type" /* ChangeServerType */]: "Changing server type",
+    ["rebuild_server" /* RebuildServer */]: "Rebuilding server",
+    ["enable_backup" /* EnableBackup */]: "Enabling backups",
+    ["disable_backup" /* DisableBackup */]: "Disabling backups",
+    ["create_image" /* CreateImage */]: "Creating image",
+    ["change_dns_ptr" /* ChangeDnsPtr */]: "Changing reverse DNS",
+    ["attach_to_network" /* AttachToNetwork */]: "Attaching to network",
+    ["detach_from_network" /* DetachFromNetwork */]: "Detaching from network",
+    ["change_alias_ips" /* ChangeAliasIps */]: "Changing alias IPs",
+    ["enable_rescue" /* EnableRescue */]: "Enabling rescue mode",
+    ["disable_rescue" /* DisableRescue */]: "Disabling rescue mode",
+    ["change_protection" /* ChangeProtection */]: "Changing protection",
+    ["create_volume" /* CreateVolume */]: "Creating volume",
+    ["delete_volume" /* DeleteVolume */]: "Deleting volume",
+    ["attach_volume" /* AttachVolume */]: "Attaching volume",
+    ["detach_volume" /* DetachVolume */]: "Detaching volume",
+    ["resize_volume" /* ResizeVolume */]: "Resizing volume",
+    ["volume_change_protection" /* VolumeChangeProtection */]: "Changing volume protection",
+    ["add_subnet" /* AddSubnet */]: "Adding subnet",
+    ["delete_subnet" /* DeleteSubnet */]: "Deleting subnet",
+    ["add_route" /* AddRoute */]: "Adding route",
+    ["delete_route" /* DeleteRoute */]: "Deleting route",
+    ["change_ip_range" /* ChangeIpRange */]: "Changing IP range",
+    ["network_change_protection" /* NetworkChangeProtection */]: "Changing network protection",
+    ["assign_floating_ip" /* AssignFloatingIp */]: "Assigning floating IP",
+    ["unassign_floating_ip" /* UnassignFloatingIp */]: "Unassigning floating IP",
+    ["floating_ip_change_dns_ptr" /* FloatingIpChangeDnsPtr */]: "Changing floating IP DNS",
+    ["floating_ip_change_protection" /* FloatingIpChangeProtection */]: "Changing floating IP protection",
+    ["create_load_balancer" /* CreateLoadBalancer */]: "Creating load balancer",
+    ["delete_load_balancer" /* DeleteLoadBalancer */]: "Deleting load balancer",
+    ["add_target" /* AddTarget */]: "Adding target to load balancer",
+    ["remove_target" /* RemoveTarget */]: "Removing target from load balancer",
+    ["add_service" /* AddService */]: "Adding service to load balancer",
+    ["update_service" /* UpdateService */]: "Updating load balancer service",
+    ["delete_service" /* DeleteService */]: "Deleting load balancer service",
+    ["load_balancer_attach_to_network" /* LoadBalancerAttachToNetwork */]: "Attaching load balancer to network",
+    ["load_balancer_detach_from_network" /* LoadBalancerDetachFromNetwork */]: "Detaching load balancer from network",
+    ["change_algorithm" /* ChangeAlgorithm */]: "Changing load balancer algorithm",
+    ["change_type" /* ChangeType */]: "Changing load balancer type",
+    ["load_balancer_change_protection" /* LoadBalancerChangeProtection */]: "Changing load balancer protection",
+    ["issue_certificate" /* IssueCertificate */]: "Issuing certificate",
+    ["retry_certificate" /* RetryCertificate */]: "Retrying certificate",
+    ["set_firewall_rules" /* SetFirewallRules */]: "Setting firewall rules",
+    ["apply_firewall" /* ApplyFirewall */]: "Applying firewall",
+    ["remove_firewall" /* RemoveFirewall */]: "Removing firewall",
+    ["firewall_change_protection" /* FirewallChangeProtection */]: "Changing firewall protection",
+    ["image_change_protection" /* ImageChangeProtection */]: "Changing image protection"
+  };
+  return descriptions[command] || command.replace(/_/g, " ");
+}
+function getPollInterval(command) {
+  const intervals = {
+    ["start_server" /* StartServer */]: 5000,
+    ["stop_server" /* StopServer */]: 5000,
+    ["reboot_server" /* RebootServer */]: 1e4,
+    ["poweroff" /* Poweroff */]: 5000,
+    ["shutdown_server" /* ShutdownServer */]: 5000,
+    ["create_server" /* CreateServer */]: 15000,
+    ["create_volume" /* CreateVolume */]: 1e4,
+    ["attach_volume" /* AttachVolume */]: 8000,
+    ["detach_volume" /* DetachVolume */]: 5000,
+    ["rebuild_server" /* RebuildServer */]: 30000,
+    ["create_image" /* CreateImage */]: 60000,
+    ["issue_certificate" /* IssueCertificate */]: 30000
+  };
+  return intervals[command] || 1e4;
+}
+function getAdaptivePollInterval(progress) {
+  if (progress < 10)
+    return 2000;
+  if (progress < 50)
+    return 5000;
+  if (progress < 90)
+    return 1e4;
+  return 15000;
+}
+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}`);
+    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);
+    }
+    const interval = getAdaptivePollInterval(action.action.progress);
+    await sleep(interval);
+  }
+  throw new HetznerTimeoutError(actionId, timeout, lastProgress);
+}
+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)
+  };
+}
+function isRateLimitLow(info, threshold = 100) {
+  return info.remaining < threshold;
+}
+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()}`;
+}
+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);
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function createProgressLogger(prefix = "Action") {
+  return (action) => {
+    console.log(`[${prefix}] ${getActionDescription(action.command)}: ${action.progress}%`);
+  };
+}
+export {
+  waitForRateLimitReset,
+  waitForMultipleActionsWithLimit,
+  waitForMultipleActions,
+  waitForActionAdaptive,
+  waitForAction,
+  pollActionsDetailed,
+  pollActions,
+  pollAction,
+  parseRateLimitHeaders,
+  isRateLimitLow,
+  isActionSuccess,
+  isActionRunning,
+  isActionError,
+  getPollInterval,
+  getAdaptivePollInterval,
+  getActionTimeout,
+  getActionDescription,
+  formatRateLimitStatus,
+  formatActionProgress,
+  createProgressLogger,
+  batchCheckActions,
+  ActionOperations,
+  ACTION_TIMEOUTS
+};