@ebowwa/hetzner 0.3.2 → 0.3.3

package/dist/pricing.js

@@ -0,0 +1,587 @@
+// @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/schemas.ts
+import { z } from "zod";
+import {
+  EnvironmentStatus,
+  ActionStatus,
+  VolumeStatus
+} from "@ebowwa/codespaces-types/compile";
+var ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/;
+var ipv6Regex = /^[0-9a-fA-F:]+(?:\/\d{1,3})?$/;
+var ipRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$|^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$/;
+var HetznerErrorSchema = z.object({
+  code: z.string(),
+  message: z.string(),
+  details: z.any().optional()
+});
+var HetznerPaginationSchema = z.object({
+  page: z.number(),
+  per_page: z.number(),
+  previous_page: z.number().nullable(),
+  next_page: z.number().nullable(),
+  last_page: z.number(),
+  total_entries: z.number()
+});
+var HetznerMetaSchema = z.object({
+  pagination: HetznerPaginationSchema.optional()
+});
+var HetznerActionResourceSchema = z.object({
+  id: z.number(),
+  type: z.enum([
+    "server",
+    "volume",
+    "network",
+    "floating_ip",
+    "load_balancer",
+    "certificate",
+    "firewall",
+    "image"
+  ])
+});
+var HetznerActionErrorSchema = z.object({
+  code: z.string(),
+  message: z.string()
+});
+var HetznerActionSchema = z.object({
+  id: z.number(),
+  command: z.string(),
+  status: z.nativeEnum(ActionStatus),
+  started: z.string(),
+  finished: z.string().nullable(),
+  progress: z.number().min(0).max(100),
+  resources: z.array(HetznerActionResourceSchema),
+  error: HetznerActionErrorSchema.nullable()
+});
+var HetznerActionResponseSchema = z.object({
+  action: HetznerActionSchema
+});
+var HetznerActionsResponseSchema = z.object({
+  actions: z.array(HetznerActionSchema),
+  meta: HetznerMetaSchema
+});
+var HetznerServerImageSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  description: z.string(),
+  type: z.enum(["snapshot", "backup", "system"])
+});
+var HetznerIPv4Schema = z.object({
+  ip: z.string().regex(ipv4Regex),
+  blocked: z.boolean()
+});
+var HetznerIPv6Schema = z.object({
+  ip: z.string().regex(ipv6Regex),
+  blocked: z.boolean()
+});
+var HetznerFloatingIpRefSchema = z.object({
+  id: z.number(),
+  ip: z.string()
+});
+var HetznerFirewallRefSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  status: z.enum(["applied", "pending"])
+});
+var HetznerPublicNetSchema = z.object({
+  ipv4: HetznerIPv4Schema,
+  ipv6: HetznerIPv6Schema.optional(),
+  floating_ips: z.array(HetznerFloatingIpRefSchema),
+  firewalls: z.array(HetznerFirewallRefSchema)
+});
+var HetznerServerTypeSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  description: z.string(),
+  cores: z.number(),
+  memory: z.number(),
+  disk: z.number()
+});
+var HetznerLocationSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  description: z.string(),
+  country: z.string(),
+  city: z.string(),
+  latitude: z.number(),
+  longitude: z.number(),
+  network_zone: z.string()
+});
+var HetznerDatacenterSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  description: z.string(),
+  location: HetznerLocationSchema,
+  supported_server_types: z.array(z.object({
+    id: z.number(),
+    name: z.string()
+  })).optional().nullable()
+});
+var HetznerVolumeRefSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  size: z.number().positive(),
+  linux_device: z.string()
+});
+var HetznerServerProtectionSchema = z.object({
+  delete: z.boolean(),
+  rebuild: z.boolean()
+});
+var HetznerServerSchema = z.object({
+  id: z.number().positive(),
+  name: z.string().min(1),
+  status: z.nativeEnum(EnvironmentStatus),
+  image: HetznerServerImageSchema.nullable().optional(),
+  public_net: HetznerPublicNetSchema,
+  server_type: HetznerServerTypeSchema,
+  datacenter: HetznerDatacenterSchema,
+  labels: z.record(z.string(), z.any()),
+  created: z.string().datetime(),
+  protection: HetznerServerProtectionSchema,
+  volumes: z.array(HetznerVolumeRefSchema)
+});
+var HetznerListServersResponseSchema = z.object({
+  servers: z.array(HetznerServerSchema),
+  meta: HetznerMetaSchema
+});
+var HetznerGetServerResponseSchema = z.object({
+  server: HetznerServerSchema
+});
+var HetznerCreateServerRequestSchema = z.object({
+  name: z.string().min(1).max(64).regex(/^[a-zA-Z0-9][a-zA-Z0-9-]*$/, "Name must start with letter/number and contain only letters, numbers, and hyphens"),
+  server_type: z.string().min(1),
+  image: z.string().min(1),
+  location: z.string().min(1).optional(),
+  datacenter: z.string().min(1).optional(),
+  ssh_keys: z.array(z.union([z.string(), z.number()])).optional(),
+  volumes: z.array(z.number().positive()).optional(),
+  labels: z.record(z.string(), z.any()).optional(),
+  start_after_create: z.boolean().optional()
+}).refine((data) => !(data.location && data.datacenter), "Cannot specify both location and datacenter");
+var HetznerCreateServerResponseSchema = z.object({
+  server: HetznerServerSchema,
+  action: HetznerActionSchema,
+  next_actions: z.array(HetznerActionSchema),
+  root_password: z.string().nullable()
+});
+var HetznerUpdateServerRequestSchema = z.object({
+  name: z.string().min(1).max(64).optional(),
+  labels: z.record(z.string(), z.any()).optional()
+});
+var HetznerUpdateServerResponseSchema = z.object({
+  server: HetznerServerSchema
+});
+var HetznerVolumeLocationSchema = z.object({
+  id: z.number(),
+  name: z.string(),
+  description: z.string(),
+  country: z.string(),
+  city: z.string(),
+  latitude: z.number(),
+  longitude: z.number()
+});
+var HetznerVolumeProtectionSchema = z.object({
+  delete: z.boolean()
+});
+var HetznerVolumeSchema = z.object({
+  id: z.number().positive(),
+  name: z.string().min(1),
+  status: z.nativeEnum(VolumeStatus),
+  server: z.number().positive().nullable().optional(),
+  size: z.number().positive(),
+  linux_device: z.string().nullable().optional(),
+  format: z.string().nullable().optional(),
+  location: HetznerVolumeLocationSchema.nullable().optional(),
+  labels: z.record(z.string(), z.any()),
+  created: z.string().datetime(),
+  protection: HetznerVolumeProtectionSchema
+});
+var HetznerListVolumesResponseSchema = z.object({
+  volumes: z.array(HetznerVolumeSchema),
+  meta: HetznerMetaSchema
+});
+var HetznerGetVolumeResponseSchema = z.object({
+  volume: HetznerVolumeSchema
+});
+var HetznerCreateVolumeRequestSchema = z.object({
+  name: z.string().min(1).max(64),
+  size: z.number().positive().multipleOf(1),
+  server: z.number().positive().optional(),
+  location: z.string().min(1).optional(),
+  automount: z.boolean().optional(),
+  format: z.string().optional(),
+  labels: z.record(z.string(), z.any()).optional()
+}).refine((data) => {
+  return Number.isInteger(data.size);
+}, "Volume size must be a whole number in GB");
+var HetznerCreateVolumeResponseSchema = z.object({
+  volume: HetznerVolumeSchema,
+  action: HetznerActionSchema,
+  next_actions: z.array(HetznerActionSchema)
+});
+var HetznerSubnetSchema = z.object({
+  type: z.enum(["server", "cloud", "vswitch"]),
+  ip_range: z.string().regex(ipRegex),
+  network_zone: z.string(),
+  gateway: z.string().regex(ipRegex)
+});
+var HetznerRouteSchema = z.object({
+  destination: z.string().regex(ipRegex),
+  gateway: z.string().regex(ipRegex)
+});
+var HetznerNetworkProtectionSchema = z.object({
+  delete: z.boolean()
+});
+var HetznerNetworkSchema = z.object({
+  id: z.number().positive(),
+  name: z.string().min(1).max(64),
+  ip_range: z.string().regex(ipRegex),
+  subnets: z.array(HetznerSubnetSchema),
+  routes: z.array(HetznerRouteSchema),
+  servers: z.array(z.number().positive()),
+  protection: HetznerNetworkProtectionSchema,
+  labels: z.record(z.string(), z.any()),
+  created: z.string().datetime()
+});
+var HetznerListNetworksResponseSchema = z.object({
+  networks: z.array(HetznerNetworkSchema),
+  meta: HetznerMetaSchema
+});
+var HetznerGetNetworkResponseSchema = z.object({
+  network: HetznerNetworkSchema
+});
+var HetznerSSHKeySchema = z.object({
+  id: z.number().positive(),
+  name: z.string().min(1).max(64),
+  fingerprint: z.string(),
+  public_key: z.string(),
+  labels: z.record(z.string(), z.any()),
+  created: z.string().datetime()
+});
+var HetznerListSSHKeysResponseSchema = z.object({
+  ssh_keys: z.array(HetznerSSHKeySchema),
+  meta: HetznerMetaSchema
+});
+var HetznerGetSSHKeyResponseSchema = z.object({
+  ssh_key: HetznerSSHKeySchema
+});
+var HetznerCreateSSHKeyRequestSchema = z.object({
+  name: z.string().min(1).max(64).regex(/^[a-zA-Z0-9][a-zA-Z0-9-]*$/, "Name must start with letter/number and contain only letters, numbers, and hyphens"),
+  public_key: z.string().min(1),
+  labels: z.record(z.string(), z.any()).optional()
+});
+var HetznerCreateSSHKeyResponseSchema = z.object({
+  ssh_key: HetznerSSHKeySchema
+});
+var HetznerFloatingIpSchema = z.object({
+  id: z.number().positive(),
+  name: z.string().min(1).max(64),
+  description: z.string().optional(),
+  type: z.enum(["ipv4", "ipv6"]),
+  ip: z.string().regex(ipRegex),
+  server: z.number().positive().nullable(),
+  dns_ptr: z.array(z.object({
+    ip: z.string(),
+    dns_ptr: z.string()
+  })),
+  home_location: HetznerLocationSchema,
+  blocked: z.boolean(),
+  protection: z.object({
+    delete: z.boolean()
+  }),
+  labels: z.record(z.string(), z.any()),
+  created: z.string().datetime()
+});
+var HetznerListFloatingIpsResponseSchema = z.object({
+  floating_ips: z.array(HetznerFloatingIpSchema),
+  meta: HetznerMetaSchema
+});
+var HetznerFirewallRuleSchema = z.object({
+  direction: z.enum(["in", "out"]),
+  source_ips: z.array(z.string().regex(ipRegex)).optional(),
+  destination_ips: z.array(z.string().regex(ipRegex)).optional(),
+  source_port: z.string().optional(),
+  destination_port: z.string().optional(),
+  protocol: z.enum(["tcp", "udp", "icmp", "esp", "gre"])
+});
+var HetznerFirewallResourceSchema = z.object({
+  type: z.enum(["server", "label_selector"]),
+  server: z.object({
+    id: z.number().positive()
+  }).optional(),
+  label_selector: z.object({
+    selector: z.string()
+  }).optional()
+});
+var HetznerFirewallSchema = z.object({
+  id: z.number().positive(),
+  name: z.string().min(1).max(64),
+  rules: z.array(HetznerFirewallRuleSchema),
+  apply_to: z.array(HetznerFirewallResourceSchema),
+  labels: z.record(z.string(), z.any()),
+  created: z.string().datetime()
+});
+var HetznerListFirewallsResponseSchema = z.object({
+  firewalls: z.array(HetznerFirewallSchema),
+  meta: HetznerMetaSchema
+});
+var HetznerIsoSchema = z.object({
+  id: z.number().positive(),
+  name: z.string(),
+  description: z.string(),
+  type: z.enum(["public", "private"]),
+  deprecated: z.date().nullable().optional(),
+  architecture: z.array(z.enum(["x86", "arm"])).optional()
+});
+var HetznerListIsosResponseSchema = z.object({
+  isos: z.array(HetznerIsoSchema),
+  meta: HetznerMetaSchema
+});
+var HetznerListLocationsResponseSchema = z.object({
+  locations: z.array(HetznerLocationSchema)
+});
+var HetznerListDatacentersResponseSchema = z.object({
+  datacenters: z.array(HetznerDatacenterSchema)
+});
+var HetznerServerTypePricingSchema = z.object({
+  location: z.string().nullable().optional(),
+  price_hourly: z.object({
+    net: z.string(),
+    gross: z.string()
+  }),
+  price_monthly: z.object({
+    net: z.string(),
+    gross: z.string()
+  })
+});
+var HetznerServerTypeExtendedSchema = HetznerServerTypeSchema.extend({
+  deprecated: z.boolean().optional(),
+  prices: z.array(HetznerServerTypePricingSchema),
+  storage_type: z.enum(["local", "network"]),
+  cpu_type: z.enum(["shared", "dedicated"])
+});
+var HetznerListServerTypesResponseSchema = z.object({
+  server_types: z.array(HetznerServerTypeExtendedSchema)
+});
+var HetznerCertificateSchema = z.object({
+  id: z.number().positive(),
+  name: z.string().min(1).max(64),
+  labels: z.record(z.string(), z.any()),
+  certificate: z.string(),
+  not_valid_before: z.string().datetime(),
+  not_valid_after: z.string().datetime(),
+  domain_names: z.array(z.string().url()),
+  fingerprint: z.string(),
+  created: z.string().datetime(),
+  status: z.enum(["pending", "issued", "failed", "revoked"]),
+  failed: z.boolean().optional(),
+  type: z.enum(["uploaded", "managed"]),
+  usage: z.array(z.enum(["dual_stack", "server", "load_balancer", "dns"])).optional()
+});
+var HetznerListCertificatesResponseSchema = z.object({
+  certificates: z.array(HetznerCertificateSchema),
+  meta: HetznerMetaSchema
+});
+function createPaginatedResponseSchema(itemSchema, itemName) {
+  return z.object({
+    [itemName]: z.array(itemSchema),
+    meta: HetznerMetaSchema
+  });
+}
+function createItemResponseSchema(itemSchema, itemName) {
+  return z.object({
+    [itemName]: itemSchema
+  });
+}
+
+// src/pricing.ts
+import { z as z2 } from "zod";
+var DEFAULT_FALLBACK_PRICE_MONTHLY = 5;
+var HOURS_PER_MONTH = 730;
+var ServerTypePriceSchema = z2.object({
+  serverType: z2.string(),
+  priceMonthly: z2.number().nonnegative(),
+  priceHourly: z2.number().nonnegative(),
+  deprecated: z2.boolean().optional().default(false)
+});
+var EnvironmentCostSchema = z2.object({
+  environmentId: z2.string(),
+  environmentName: z2.string(),
+  serverType: z2.string(),
+  isRunning: z2.boolean(),
+  costMonthly: z2.number().nonnegative(),
+  costHourly: z2.number().nonnegative(),
+  priceInfo: ServerTypePriceSchema.optional()
+});
+var CostCalculationResultSchema = z2.object({
+  totalMonthly: z2.number().nonnegative(),
+  totalHourly: z2.number().nonnegative(),
+  runningEnvironmentCount: z2.number().nonnegative().int(),
+  stoppedEnvironmentCount: z2.number().nonnegative().int(),
+  unknownServerTypeCount: z2.number().nonnegative().int(),
+  breakdown: z2.array(EnvironmentCostSchema),
+  priceMap: z2.custom()
+});
+function parseHetznerPrice(priceString) {
+  const parsed = parseFloat(priceString);
+  if (isNaN(parsed)) {
+    console.warn(`Failed to parse Hetzner price string: ${priceString}`);
+    return 0;
+  }
+  return parsed;
+}
+function extractServerTypePrice(serverType) {
+  if (!serverType.prices || serverType.prices.length === 0) {
+    console.warn(`Server type ${serverType.name} has no pricing information`);
+    return;
+  }
+  const priceEntry = serverType.prices[0];
+  const priceMonthly = parseHetznerPrice(priceEntry.price_monthly.gross);
+  const priceHourly = parseHetznerPrice(priceEntry.price_hourly.gross);
+  return {
+    serverType: serverType.name,
+    priceMonthly,
+    priceHourly,
+    deprecated: serverType.deprecated ?? false
+  };
+}
+function buildPriceMap(serverTypes) {
+  const priceMap = new Map;
+  for (const serverType of serverTypes) {
+    const priceInfo = extractServerTypePrice(serverType);
+    if (priceInfo) {
+      priceMap.set(serverType.name, priceInfo);
+    }
+  }
+  return priceMap;
+}
+function getServerTypeMonthlyPrice(serverTypeName, priceMap, fallbackPrice = DEFAULT_FALLBACK_PRICE_MONTHLY) {
+  const priceInfo = priceMap.get(serverTypeName);
+  return priceInfo?.priceMonthly ?? fallbackPrice;
+}
+function calculateHourlyFromMonthly(monthlyPrice) {
+  return monthlyPrice / HOURS_PER_MONTH;
+}
+function calculateCosts(environments, serverTypes, options = {}) {
+  const { fallbackPrice = DEFAULT_FALLBACK_PRICE_MONTHLY, includeStopped = false } = options;
+  const priceMap = buildPriceMap(serverTypes);
+  const breakdown = [];
+  let totalMonthly = 0;
+  let runningCount = 0;
+  let stoppedCount = 0;
+  let unknownTypeCount = 0;
+  for (const env of environments) {
+    const isRunning = env.status === "running";
+    const priceInfo = priceMap.get(env.serverType);
+    const isUnknownType = !priceInfo;
+    if (isRunning) {
+      runningCount++;
+    } else {
+      stoppedCount++;
+    }
+    if (isRunning && isUnknownType) {
+      unknownTypeCount++;
+    }
+    const monthlyPrice = isRunning ? priceInfo?.priceMonthly ?? fallbackPrice : 0;
+    const hourlyPrice = isRunning ? priceInfo?.priceHourly ?? calculateHourlyFromMonthly(fallbackPrice) : 0;
+    if (isRunning) {
+      totalMonthly += monthlyPrice;
+    }
+    if (isRunning || includeStopped) {
+      breakdown.push({
+        environmentId: env.id,
+        environmentName: env.name,
+        serverType: env.serverType,
+        isRunning,
+        costMonthly: monthlyPrice,
+        costHourly: hourlyPrice,
+        priceInfo
+      });
+    }
+  }
+  const totalHourly = calculateHourlyFromMonthly(totalMonthly);
+  return {
+    totalMonthly,
+    totalHourly,
+    runningEnvironmentCount: runningCount,
+    stoppedEnvironmentCount: stoppedCount,
+    unknownServerTypeCount: unknownTypeCount,
+    breakdown,
+    priceMap
+  };
+}
+
+class PricingOperations {
+  client;
+  constructor(client) {
+    this.client = client;
+  }
+  async listServerTypes() {
+    const response = await this.client.request("/server_types");
+    const validated = HetznerListServerTypesResponseSchema.safeParse(response);
+    if (!validated.success) {
+      console.warn("Hetzner list server types validation warning:", validated.error.issues);
+      return response.server_types;
+    }
+    return validated.data.server_types;
+  }
+  async getServerType(name) {
+    const types = await this.listServerTypes();
+    return types.find((t) => t.name === name);
+  }
+  async listLocations() {
+    const response = await this.client.request("/locations");
+    const validated = HetznerListLocationsResponseSchema.safeParse(response);
+    if (!validated.success) {
+      console.warn("Hetzner list locations validation warning:", validated.error.issues);
+      return response.locations;
+    }
+    return validated.data.locations;
+  }
+  async getLocation(name) {
+    const locations = await this.listLocations();
+    return locations.find((l) => l.name === name);
+  }
+  async listDatacenters() {
+    const response = await this.client.request("/datacenters");
+    const validated = HetznerListDatacentersResponseSchema.safeParse(response);
+    if (!validated.success) {
+      console.warn("Hetzner list datacenters validation warning:", validated.error.issues);
+      return response.datacenters;
+    }
+    return validated.data.datacenters;
+  }
+  async calculateEnvironmentCosts(environments, options) {
+    const serverTypes = await this.listServerTypes();
+    return calculateCosts(environments, serverTypes, options);
+  }
+}
+export {
+  parseHetznerPrice,
+  getServerTypeMonthlyPrice,
+  extractServerTypePrice,
+  calculateHourlyFromMonthly,
+  calculateCosts,
+  buildPriceMap,
+  ServerTypePriceSchema,
+  PricingOperations,
+  EnvironmentCostSchema,
+  CostCalculationResultSchema
+};