@modexvpn/hcloud/dist/index.mjs

SDK for Hetzner Cloud API

// client.ts
import axios from "axios";
var HCLOUD_API_URL = "https://api.hetzner.cloud/v1";
var HCLOUD_API_TOKEN = process.env.HCLOUD_API_TOKEN;
if (!HCLOUD_API_TOKEN) {
  throw new Error("HCLOUD_API_TOKEN is missing. Set it in your .env file");
}
var hcloudClient = axios.create({
  baseURL: HCLOUD_API_URL,
  headers: {
    Authorization: `Bearer ${HCLOUD_API_TOKEN}`,
    "Content-Type": "application/json"
  }
});

// utils/formatError.ts
function formatHcloudError(error, context) {
  const err = error;
  const baseMessage = err?.response?.data?.error?.message || err?.message || "Unknown error";
  const details = err?.response?.data?.error?.details;
  let extraMessage = "";
  if (details?.fields?.length) {
    const fieldMessages = details.fields.map((field) => {
      const issues = field.messages?.join(", ") || "invalid";
      return `${field.name}: ${issues}`;
    });
    extraMessage += `
Fields: ${fieldMessages.join("; ")}`;
  }
  if (details?.limits?.length) {
    const limitNames = details.limits.map((limit) => limit.name);
    extraMessage += `
Limits hit: ${limitNames.join(", ")}`;
  }
  return new Error(`${context}: ${baseMessage}${extraMessage}`);
}

// sdk/servers/getServerById.ts
async function getServerById(serverId) {
  try {
    const res = await hcloudClient.get(`/servers/${serverId}`);
    return res.data.server;
  } catch (error) {
    throw formatHcloudError(error, `Failed to fetch server ${serverId}`);
  }
}

// sdk/servers/getServers.ts
var getServers = {
  async list(query) {
    try {
      const res = await hcloudClient.get("/servers", {
        params: query
      });
      return res.data;
    } catch (error) {
      throw formatHcloudError(error, "Failed to list servers");
    }
  }
};

// sdk/servers/deleteServer.ts
async function deleteServer(serverId) {
  try {
    const res = await hcloudClient.delete(`/servers/${serverId}`);
    return res.data.action;
  } catch (error) {
    throw formatHcloudError(error, "Failed to delete server");
  }
}

// sdk/servers/createServer.ts
async function createServer(options) {
  try {
    const res = await hcloudClient.post("/servers", options);
    return res.data.server;
  } catch (error) {
    throw formatHcloudError(error, "Failed to create server");
  }
}

// sdk/servers/getServerMetrics.ts
async function getServerMetrics(serverId, params = {
  type: "cpu",
  start: new Date(Date.now() - 5 * 60 * 1e3).toISOString(),
  end: (/* @__PURE__ */ new Date()).toISOString()
}) {
  try {
    const res = await hcloudClient.get(`/servers/${serverId}/metrics`, {
      params
    });
    return res.data.metrics;
  } catch (error) {
    throw formatHcloudError(error, `Failed to fetch metrics for server ${serverId}`);
  }
}

// sdk/servers/updateServer.ts
async function updateServer(serverId, options) {
  try {
    const res = await hcloudClient.put(`/servers/${serverId}`, options);
    return res.data.server;
  } catch (error) {
    throw formatHcloudError(error, "Failed to create server");
  }
}

// sdk/servers/actions/attachIso.ts
async function attachIso(serverId, iso) {
  try {
    const res = await hcloudClient.post(`/servers/${serverId}/actions/attach_iso`, { iso });
    return res.data;
  } catch (error) {
    throw formatHcloudError(error, `Could not attach ISO to server: ${serverId}`);
  }
}

// sdk/servers/actions/detachIso.ts
async function detachIso(serverId) {
  try {
    const res = await hcloudClient.post(`/servers/${serverId}/actions/detach_iso`);
    return res.data;
  } catch (error) {
    throw formatHcloudError(error, `Could not detach ISO from server: ${serverId}`);
  }
}

// sdk/servers/actions/rebuild.ts
async function rebuild(serverId, imageId) {
  try {
    const res = await hcloudClient.post(`/servers/${serverId}/actions/rebuild`, { image: imageId });
    return res.data;
  } catch (error) {
    throw formatHcloudError(error, `Could not rebuild server: ${serverId}`);
  }
}

// sdk/servers/actions/disableBackup.ts
async function disableBackup(serverId) {
  try {
    const res = await hcloudClient.post(`/servers/${serverId}/actions/disable_backup`);
    return res.data;
  } catch (error) {
    throw formatHcloudError(error, `Could not disable backup for server: ${serverId}`);
  }
}

// sdk/servers/actions/disableRescue.ts
async function disableRescue(serverId) {
  try {
    const res = await hcloudClient.post(`/servers/${serverId}/actions/disable_rescue`);
    return res.data;
  } catch (error) {
    throw formatHcloudError(error, `Could not disable rescue mode for server: ${serverId}`);
  }
}

// sdk/servers/actions/powerControl.ts
var powerControl = {
  async on(serverId) {
    try {
      const res = await hcloudClient.post(`/servers/${serverId}/actions/poweron`);
      return res.data;
    } catch (error) {
      throw formatHcloudError(error, `Failed to power on server: ${serverId}`);
    }
  },
  async powerOff(serverId) {
    try {
      const res = await hcloudClient.post(`/servers/${serverId}/actions/poweroff`);
      return res.data;
    } catch (error) {
      throw formatHcloudError(error, `Failed to power off server: ${serverId}`);
    }
  },
  async reboot(serverId) {
    try {
      const res = await hcloudClient.post(`/servers/${serverId}/actions/reboot`);
      return res.data;
    } catch (error) {
      throw formatHcloudError(error, `Failed to reboot server: ${serverId}`);
    }
  },
  async reset(serverId) {
    try {
      const res = await hcloudClient.post(`/servers/${serverId}/actions/reset`);
      return res.data;
    } catch (error) {
      throw formatHcloudError(error, `Failed to reset server: ${serverId}`);
    }
  },
  async shutdown(serverId) {
    try {
      const res = await hcloudClient.post(`/servers/${serverId}/actions/shutdown`);
      return res.data;
    } catch (error) {
      throw formatHcloudError(error, `Failed to shut down server: ${serverId}`);
    }
  }
};

// sdk/servers/actions/resetPassword.ts
async function resetPassword(serverId) {
  try {
    const res = await hcloudClient.post(`/servers/${serverId}/actions/reset_password`);
    return res.data;
  } catch (error) {
    throw formatHcloudError(error, `Could not reset password of server: ${serverId}`);
  }
}

// sdk/servers/actions/changeProtection.ts
async function changeProtection(serverId, deleteServer2, rebuild2) {
  try {
    const res = await hcloudClient.post(`/servers/${serverId}/actions/change_protection`, { delete: deleteServer2, rebuild: rebuild2 });
    return res.data;
  } catch (error) {
    throw formatHcloudError(error, `Could not change protection for server: ${serverId}`);
  }
}

// sdk/servers/actions/getActions.ts
async function getActions() {
  try {
    const res = await hcloudClient.get("/servers/actions");
    return res.data;
  } catch (error) {
    throw formatHcloudError(error, `Could get all actions.`);
  }
}

// sdk/locations/getLocations.ts
async function getLocations(query) {
  try {
    const res = await hcloudClient.get("/locations", {
      params: query
    });
    return res.data;
  } catch (error) {
    throw formatHcloudError(error, "Failed to list locations");
  }
}

// sdk/locations/getLocation.ts
async function getLocation(locationId) {
  try {
    const res = await hcloudClient.get(`/locations/${locationId}`);
    return res.data.location;
  } catch (error) {
    throw formatHcloudError(error, `Coult not get location: ${locationId}`);
  }
}

// sdk/servers/actions/sshIntoServer.ts
import { NodeSSH } from "node-ssh";
var ssh = new NodeSSH();
async function sshIntoServer(ip, command, username, privateKey = process.env.SSH_PRIVATE_KEY) {
  try {
    await ssh.connect({ host: ip, username, privateKey });
    const result = await ssh.execCommand(command);
    return {
      stdout: result.stdout,
      stderr: result.stderr
    };
  } catch (error) {
    throw formatHcloudError(error, `Could not SSH into server: ${ip}`);
  } finally {
    ssh.dispose();
  }
}

// sdk/servers/server-type/getServerTypes.ts
var getServersTypes = {
  async list(query) {
    try {
      const res = await hcloudClient.get("/servers", {
        params: query
      });
      return res.data;
    } catch (error) {
      throw formatHcloudError(error, "Failed to list servers");
    }
  }
};

// sdk/servers/server-type/getServerType.ts
async function getServerTypeById(serverId) {
  try {
    const res = await hcloudClient.get(`/server_types/${serverId}`);
    return res.data;
  } catch (error) {
    throw formatHcloudError(error, "Failed to list servers");
  }
}

// types/security/sshkeys.schema.ts
import { z as z2 } from "zod";

// types/common/label.types.ts
import { z } from "zod";
var labelKeyRegex = /^(([a-z0-9]([-a-z0-9]*[a-z0-9])?\.)*[a-z0-9]([-a-z0-9]*[a-z0-9])?\/)?[a-zA-Z0-9]([a-zA-Z0-9._-]{0,61}[a-zA-Z0-9])?$/;
var labelValueRegex = /^([a-zA-Z0-9]([a-zA-Z0-9._-]{0,61}[a-zA-Z0-9])?)?$/;
var LabelSchema = z.record(
  z.string().regex(labelKeyRegex, "Invalid label key").refine((key) => !key.startsWith("hetzner.cloud/"), {
    message: "Keys with 'hetzner.cloud/' prefix are reserved"
  }),
  z.string().regex(labelValueRegex, "Invalid label value")
);

// types/security/sshkeys.schema.ts
var SSHKeySchema = z2.object({
  id: z2.number(),
  name: z2.string(),
  fingerprint: z2.string(),
  public_key: z2.string(),
  labels: LabelSchema,
  created: z2.string()
});

// sdk/security/ssh-keys/getSSHKey.ts
import { z as z3 } from "zod";
var GetSSHKeyResponseSchema = z3.object({
  ssh_key: SSHKeySchema
});
async function getSSHKey(sshKeyId) {
  try {
    const res = await hcloudClient.get(`/ssh_keys/${sshKeyId}`);
    const parsed = GetSSHKeyResponseSchema.parse(res.data);
    return parsed.ssh_key;
  } catch (error) {
    throw formatHcloudError(error, "Failed to get ssh key");
  }
}

// types/common/meta.types.ts
import { z as z4 } from "zod";
var MetaSchema = z4.object({
  pagination: z4.object({
    page: z4.number(),
    per_page: z4.number(),
    previous_page: z4.number().nullable(),
    next_page: z4.number().nullable(),
    last_page: z4.number(),
    total_entries: z4.number()
  })
});

// sdk/security/ssh-keys/getSSHKeys.ts
import { z as z5 } from "zod";
var GetSSHKeyQuerySchema = z5.object({
  name: z5.string().optional(),
  sort: z5.union([z5.string(), z5.array(z5.string())]).optional(),
  page: z5.number().optional(),
  per_page: z5.number().optional(),
  fingerprint: z5.string().optional(),
  label_selector: z5.string().optional()
});
var GetSSHKeyResponseSchema2 = z5.object({
  ssh_keys: z5.array(SSHKeySchema),
  meta: MetaSchema
});
async function getSSHKeys(query) {
  try {
    const res = await hcloudClient.get("/ssh_keys", { params: query });
    const parsed = GetSSHKeyResponseSchema2.parse(res.data);
    return parsed;
  } catch (error) {
    throw formatHcloudError(error, "Failed to list ssh keys");
  }
}

// index.ts
var hcloud = {
  servers: {
    list: getServers.list,
    getById: getServerById,
    delete: deleteServer,
    create: createServer,
    getMetrics: getServerMetrics,
    update: updateServer,
    attachIso,
    detachIso,
    rebuild,
    disableBackup,
    disableRescue,
    powerControl,
    resetPassword,
    changeProtection,
    listActions: getActions,
    sshIntoServer,
    listServerType: getServersTypes.list,
    getServerTypeById
  },
  locations: {
    list: getLocations,
    getById: getLocation
  },
  security: {
    getSSHKey,
    listSSHKeys: getSSHKeys
  }
};
export {
  hcloud
};
//# sourceMappingURL=index.mjs.map