proxmox-sdk 0.0.1

package/src/http-proxmox.repository.ts

@@ -0,0 +1,362 @@
+import axios from "axios";
+import { Logger } from "nestjs-pino";
+
+import { encodeSSHKey } from "./tools/encode-ssh-key";
+import { CloneQemuMachinePayload } from "./types/clone-qemu-machine";
+import { CreateQemuMachinePayload, CreateQemuMachineProxmoxPayload } from "./types/create-qemu-machine";
+import { DeleteQemuMachinePayload } from "./types/delete-qemu-machine";
+import { DownloadIsoImagePayload } from "./types/download-iso-image";
+import { ListQemuMachinesAnswer } from "./types/list-qemu-machines";
+import { StartQemuMachinePayload } from "./types/start-qemu-machine";
+import { StopQemuMachinePayload } from "./types/stop-qemu-machine";
+import { UpdateQemuMachinePayload, UpdateQemuMachineProxmoxPayload } from "./types/update-qemu-machine";
+import { IP } from "./types/ip";
+import { UPID } from "./types";
+
+export type AuthConfig = {
+  host: string;
+  password: string;
+  username: string;
+}
+
+// authorize self signed cert if you do not use a valid SSL certificat
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+
+// https://pve.proxmox.com/wiki/Proxmox_VE_API#Authentication
+export class HttpProxmoxRepository {
+  constructor (
+    private readonly parameters: AuthConfig,
+    private readonly logger: Logger,
+  ) {}
+
+  async getProxmoxVersion (): Promise<string> {
+    let data;
+    try {
+      data = await axios({
+        url: this.computeUrl("/api2/json/version"),
+        headers: await this.prepareHeaders(),
+      });
+    } catch (err) {
+      console.log(err);
+    }
+
+    return (data as unknown as any).data.data.version;
+  }
+
+  async listQemuMachines (node: string): Promise<ListQemuMachinesAnswer> {
+    let data;
+    try {
+      data = await axios({
+        url: this.computeUrl(`/api2/json/nodes/${node}/qemu`),
+        headers: await this.prepareHeaders(),
+      });
+    } catch (err) {
+      console.log(err);
+    }
+
+    return (data as unknown as any).data.data;
+  }
+
+  async getQemuMachineVlanTag (node: string, vmid: number): Promise<number> {
+    let data;
+    try {
+      data = await axios({
+        url: this.computeUrl(`/api2/json/nodes/${node}/qemu/${vmid}/config`),
+        headers: await this.prepareHeaders(),
+      });
+    } catch (err) {
+      this.logger.error(err);
+      return 1;
+    }
+
+    const tag = data.data.data.net0.split(",").find((e: string) => e.startsWith("tag"));
+    if (tag) {
+      return parseInt(tag.split("=").at(1), 10);
+    }
+
+    return 1;
+  }
+
+  async listQemuMachineIps (node: string, vmid: number): Promise<Array<IP>> {
+    let data;
+    try {
+      data = await axios({
+        url: this.computeUrl(`/api2/json/nodes/${node}/qemu/${vmid}/agent/network-get-interfaces`),
+        headers: await this.prepareHeaders(),
+      });
+    } catch (err) {
+      this.logger.error(err);
+      return [];
+    }
+
+    type PAYLOAD = {
+      result: Array<{
+        "hardware-address": string;
+        "ip-addresses": Array<{ "ip-address": IP, "ip-address-type": "ipv4"|"ipv6", prefix: number }>,
+        name: string;
+        statistics: {
+          "rx-bytes": number,
+          "rx-dropped": number,
+          "rx-errs": number,
+          "rx-packets": number,
+          "tx-bytes": number,
+          "tx-dropped": number,
+          "tx-errs": number,
+          "tx-packets": number,
+        }
+      }>
+    }
+
+    const payload = (data as unknown as any)?.data?.data as PAYLOAD;
+    console.log(payload);
+    const answer = payload.result
+      .map(
+        eth => eth["ip-addresses"]
+          .filter(ip => ip["ip-address-type"] === "ipv4")
+          .map(ip => ip["ip-address"]),
+      )
+      .flat()
+      .filter(ip => !["127.0.0.1"].includes(ip));
+
+    return answer;
+  }
+
+  async createQemuMachine (payload: CreateQemuMachinePayload): Promise<string> {
+    let data;
+
+    // According to this answer https://forum.proxmox.com/threads/can-not-create-vm-with-qcow2-format.114881/post-496759
+    // when your Proxmox uses a local-lvm, the logical block storage does not support qcow2, only raw.
+    const FORMAT = payload.localStorageName === "local" ? "qcow2" : "raw";
+
+    const proxmoxPayload: CreateQemuMachineProxmoxPayload = {
+      autostart: payload.autostart,
+      bios: payload.bios,
+      cores: payload.coreCount,
+      efidisk0: `${payload.localStorageName}:1,efitype=4m,pre-enrolled-keys=1,format=${FORMAT}`,
+      memory: payload.memory,
+      name: payload.name,
+      net0: "virtio,bridge=vmbr0,firewall=1,vlanid=10",
+      node: payload.node,
+      numa: 0,
+      ostype: payload.ostype,
+      scsi0: `${payload.localStorageName}:32,format=${FORMAT},iothread=on`,
+      scsihw: "virtio-scsi-single",
+      sockets: 1,
+      vmid: payload.vmid,
+    };
+
+    if (payload.isoName) {
+      proxmoxPayload.scsi2 = `${payload.localStorageName}:iso/${payload.isoName},media=cdrom`;
+    }
+
+    try {
+      data = await axios({
+        data: proxmoxPayload,
+        headers: await this.prepareHeaders(),
+        method: "POST",
+        url: this.computeUrl(`/api2/json/nodes/${payload.node}/qemu`),
+      });
+    } catch (err) {
+      this.logger.error({ status: (err as unknown as any).response.status, vmid: payload.vmid, errors: (err as unknown as any).response.data.errors }, (err as unknown as any).response.statusText);
+    }
+
+    return (data as unknown as any)?.data?.data as string;
+  }
+
+  async updateQemuMachine (payload: UpdateQemuMachinePayload): Promise<string> {
+    let data;
+
+    // @ts-ignore
+    const proxmoxPayload: UpdateQemuMachineProxmoxPayload = {
+      cores: payload.coreCount,
+      memory: payload.memory,
+      name: payload.name,
+      tags: payload.tags,
+      ipconfig0: "ip=dhcp",
+      // ide2: `local:${payload.vmid}/vm-${payload.vmid}-cloudinit.qcow2,media=cdrom`,
+      // overridenUsername: "toto",
+      // overridenPassword: "toto",
+      ciuser: payload.overridenUser,
+      cipassword: payload.overridenPassword,
+    };
+
+    if (payload.sshkey) {
+      proxmoxPayload.sshkeys = encodeSSHKey(payload.sshkey);
+    }
+
+    if (payload.networks?.[0]) {
+      proxmoxPayload.net0 = `model=${payload.networks[0].model},bridge=${payload.networks[0].bridge},firewall=${payload.networks[0].firewall}`;
+      if (payload.networks[0].tag) {
+        proxmoxPayload.net0 += `,tag=${payload.networks[0].tag}`;
+      }
+    }
+
+    try {
+      data = await axios({
+        data: proxmoxPayload,
+        headers: await this.prepareHeaders(),
+        method: "PUT",
+        url: this.computeUrl(`/api2/json/nodes/${payload.node}/qemu/${payload.vmid}/config`),
+      });
+    } catch (err) {
+      this.logger.error({ status: (err as unknown as any).response.status, vmid: payload.vmid, errors: (err as unknown as any).response.data.errors }, (err as unknown as any).response.statusText);
+    }
+
+    return (data as unknown as any)?.data?.data as string;
+  }
+
+  async deleteQemuMachine (port: DeleteQemuMachinePayload): Promise<UPID> {
+    let data;
+    try {
+      data = await axios({
+        headers: await this.prepareHeaders(),
+        method: "DELETE",
+        url: this.computeUrl(`/api2/json/nodes/${port.node}/qemu/${port.vmid}`),
+      });
+    } catch (err) {
+      this.logger.error({ status: (err as unknown as any).response.status, vmid: port.vmid, errors: (err as unknown as any).response.data.errors }, (err as unknown as any).response.statusText);
+    }
+
+    const payload = (data as unknown as any)?.data?.data as UPID;
+
+    return payload;
+  }
+
+  async downloadISOImage (payload: DownloadIsoImagePayload): Promise<string> {
+    const params = new URLSearchParams({
+      url: payload.url,
+      content: payload.content,
+      filename: payload.filename,
+    });
+
+    let data;
+    try {
+      data = await axios({
+        headers: await this.prepareHeaders(),
+        method: "POST",
+        url: this.computeUrl(`/api2/json/nodes/${payload.node}/storage/${payload.storage}/download-url?${params.toString()}`),
+      });
+    } catch (err) {
+      this.logger.error({ status: (err as unknown as any).response.status, ...payload, errors: (err as unknown as any).response.data.errors }, (err as unknown as any).response.statusText);
+    }
+
+    return (data as unknown as any)?.data?.data as string;
+  }
+
+  async startQemuMachine (payload: StartQemuMachinePayload) {
+    let data;
+    try {
+      data = await axios({
+        method: "POST",
+        url: this.computeUrl(`/api2/json/nodes/${payload.node}/qemu/${payload.vmid}/status/start`),
+        headers: await this.prepareHeaders(),
+      });
+    } catch (err) {
+      this.logger.error({ status: (err as unknown as any).response.status, ...payload, errors: (err as unknown as any).response.data.errors }, (err as unknown as any).response.statusText);
+    }
+
+    return (data as unknown as any)?.data?.data as string;
+  }
+
+  async stopQemuMachine (payload: StopQemuMachinePayload) {
+    let data;
+    try {
+      data = await axios({
+        method: "POST",
+        url: this.computeUrl(`/api2/json/nodes/${payload.node}/qemu/${payload.vmid}/status/stop`),
+        headers: await this.prepareHeaders(),
+      });
+    } catch (err) {
+      this.logger.error({ status: (err as unknown as any).response.status, ...payload, errors: (err as unknown as any).response.data.errors }, (err as unknown as any).response.statusText);
+    }
+    return (data as unknown as any)?.data?.data as string;
+  }
+
+  async cloneQemuMarchine (payload: CloneQemuMachinePayload) {
+    let data;
+    try {
+      data = await axios({
+        method: "POST",
+        url: this.computeUrl(`/api2/json/nodes/${payload.node}/qemu/${payload.vmid}/clone`),
+        headers: {
+          ...await this.prepareHeaders(),
+        },
+        data: {
+          full: 1,
+          name: "azdzfaef2233",
+          newid: payload.newid,
+          target: payload.node,
+        },
+      });
+    } catch (err) {
+      this.logger.error({ status: (err as unknown as any).response.status, ...payload, errors: (err as unknown as any).response.data.errors }, (err as unknown as any).response.statusText);
+    }
+
+    return (data as unknown as any)?.data?.data as string;
+  }
+
+  async resizeDisk (
+    payload: { node: string; vmid: number, size: number, disk: string, unit: "G" }
+  ) {
+    let data;
+    try {
+      data = await axios({
+        method: "PUT",
+        url: this.computeUrl(`/api2/json/nodes/${payload.node}/qemu/${payload.vmid}/resize`),
+        headers: await this.prepareHeaders(),
+        data: {
+          disk: payload.disk,
+          size: `+${payload.size}G`
+        }
+      });
+    } catch (err) {
+      this.logger.error({ status: (err as unknown as any).response.status, ...payload, errors: (err as unknown as any).response.data.errors }, (err as unknown as any).response.statusText);
+    }
+
+    return (data as unknown as any)?.data?.data as string;
+  }
+
+  private computeUrl (path: string) {
+    return `${this.parameters.host}${path}`;
+  }
+
+  private async prepareHeaders () {
+    const ticket = await this.getTicket();
+    return {
+      CSRFPreventionToken: ticket.CSRFPreventionToken,
+      Cookie: `PVEAuthCookie=${ticket.ticket}`,
+    };
+  }
+
+  private async getTicket (): Promise<{
+    CSRFPreventionToken: string;
+    cap: {
+      dc: any;
+      nodes: any;
+    },
+    ticket: string;
+    username: string;
+  }> {
+    const params = new URLSearchParams({
+      username: this.parameters.username,
+      password: this.parameters.password,
+    });
+
+    let data;
+    try {
+      const url = this.computeUrl(`/api2/json/access/ticket?${params.toString()}`);
+      ({ data } = await axios({
+        url,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+        },
+      }));
+    } catch (err) {
+      console.log((err as unknown as any).response.status);
+      console.log((err as unknown as any).response.statusText);
+    }
+
+    return (data as unknown as any).data;
+  }
+}

package/src/tools/encode-ssh-key.ts

@@ -0,0 +1,3 @@
+export function encodeSSHKey (key: string): string {
+  return encodeURIComponent(key);
+}

package/src/types/clone-qemu-machine.ts

@@ -0,0 +1,6 @@
+// https://pve.proxmox.com/pve-docs/api-viewer/#/nodes/{node}/qemu/{vmid}/clone
+export type CloneQemuMachinePayload = {
+  newid: number;
+  node: string;
+  vmid: number;
+}

package/src/types/create-qemu-machine.ts

@@ -0,0 +1,149 @@
+// https://pve.proxmox.com/pve-docs/api-viewer/#/nodes/{node}/qemu
+type CreateQemuMachineBasePayload = {
+  /**
+   * Automatic restart after crash (currently ignored).
+   */
+  autostart?: boolean;
+  /**
+   * Select BIOS implementation.
+   *
+   * default = seabios.
+   */
+  bios?: "seabios" | "ovmf";
+  /**
+   * Memory quantity.
+   *
+   * default = 512(MB)
+   */
+  memory?: number;
+  /**
+   * The name of the VM.
+   */
+  name: string;
+  /**
+   * The cluster node name.
+   */
+  node: string;
+  /**
+   * Specify guest operating system. This is used to enable special
+   * optimization/features for specific operating systems:
+   *
+   * - l24: Linux 2.4 Kernel
+   * - l26: Linux 2.6 - 6.X Kernel
+   * - other: unspecified OS
+   * - solaris: Solaris/OpenSolaris/OpenIndiania kernel
+   * - w2k3: Microsoft Windows 2003
+   * - w2k8: Microsoft Windows 2008
+   * - w2k: Microsoft Windows 2000
+   * - win10: Microsoft Windows 10/2016/2019
+   * - win11: Microsoft Windows 11/2022
+   * - win7: Microsoft Windows 7
+   * - win8: Microsoft Windows 8/2012/2012r2
+   * - wvista: Microsoft Windows Vista
+   * - wxp: Microsoft Windows XP
+   */
+  ostype?: OS;
+  /**
+   * The (unique) ID of the VM.
+   * It should be between 100 and 999999999.
+   */
+  vmid: number;
+}
+
+export type CreateQemuMachinePayload = CreateQemuMachineBasePayload & {
+  /**
+   * The number of cores per socket.
+   *
+   * default = 1
+   */
+  coreCount?: number;
+  /**
+   * ISO name
+   *
+   * The name of the filename you gave to the ISO.
+   * (e.g: debian.iso)
+   */
+  isoName?: string;
+  /**
+   * Specify the name of the storage, according to the Proxmox installation
+   * it can be different
+   *
+   * It's the storage where you have a section "VM Disks"
+   */
+  localStorageName: "local" | "local-lvm";
+  /**
+   * Networks configurations
+   */
+  networks?: Array<QemuNetwork>;
+}
+
+export type CreateQemuMachineProxmoxPayload = CreateQemuMachineBasePayload & {
+  /**
+   * The number of cores per socket.
+   *
+   * default = 1
+   */
+  cores?: number;
+  efidisk0: string;
+  /**
+   * cloud-init: Specify IP addresses and gateways for the corresponding interface.
+   *
+   * IP addresses use CIDR notation, gateways are optional but need an IP of the same type specified.
+   * The special string 'dhcp' can be used for IP addresses to use DHCP, in which case no explicit
+   * gateway should be provided.
+   *
+   * For IPv6 the special string 'auto' can be used to use stateless autoconfiguration. This requires
+   * cloud-init 19.4 or newer.
+   *
+   * If cloud-init is enabled and neither an IPv4 nor an IPv6 address is specified, it defaults to using
+   * dhcp on IPv4.
+   *
+   * [gw=<GatewayIPv4>] [,gw6=<GatewayIPv6>] [,ip=<IPv4Format/CIDR>] [,ip6=<IPv6Format/CIDR>]
+   */
+  ipconfig0?: string;
+    /**
+   * cloud-init: Specify IP addresses and gateways for the corresponding interface.
+   *
+   * IP addresses use CIDR notation, gateways are optional but need an IP of the same type specified.
+   * The special string 'dhcp' can be used for IP addresses to use DHCP, in which case no explicit
+   * gateway should be provided.
+   *
+   * For IPv6 the special string 'auto' can be used to use stateless autoconfiguration. This requires
+   * cloud-init 19.4 or newer.
+   *
+   * If cloud-init is enabled and neither an IPv4 nor an IPv6 address is specified, it defaults to using
+   * dhcp on IPv4.
+   *
+   * [gw=<GatewayIPv4>] [,gw6=<GatewayIPv6>] [,ip=<IPv4Format/CIDR>] [,ip6=<IPv6Format/CIDR>]
+   */
+  ipconfig1?: string;
+  net0: string;
+  numa: number;
+  /**
+   * scsi[n]
+   * Use volume as SCSI hard disk or CD-ROM (n is 0 to 30).
+   * Use the special syntax STORAGE_ID:SIZE_IN_GiB to allocate a new volume.
+   * Use STORAGE_ID:0 and the 'import-from' parameter to import
+   * from an existing volume.
+   */
+  scsi0?: string;
+  /**
+   * scsi[n]
+   * Use volume as SCSI hard disk or CD-ROM (n is 0 to 30).
+   * Use the special syntax STORAGE_ID:SIZE_IN_GiB to allocate a new volume.
+   * Use STORAGE_ID:0 and the 'import-from' parameter to import
+   * from an existing volume.
+   */
+  scsi2?: string;
+  scsihw?: "virtio-scsi-single";
+
+  sockets: number;
+}
+
+export type OS = "other" | "wxp" | "w2k" | "w2k3" | "w2k8" | "wvista" | "win7" | "win8" | "win10" | "win11" | "l24" | "l26" | "solaris";
+
+export type QemuNetwork = {
+  bridge: "vmbr0";
+  firewall: boolean;
+  model: "virtio";
+}

package/src/types/delete-qemu-machine.ts

@@ -0,0 +1,26 @@
+// https://pve.proxmox.com/pve-docs/api-viewer/#/nodes/{node}/qemu/{vmid}
+export type DeleteQemuMachinePayload = {
+  /**
+   * If set, destroy additionally all disks not referenced in the config but with a matching VMID from all enabled storages.
+   *
+   * default = false
+   */
+  "destroy-unreferenced-disks"?: boolean;
+  /**
+   * The cluster node name.
+   */
+  node: string;
+  /**
+   * Remove VMID from configurations, like backup & replication jobs and HA.
+   */
+  purge?: boolean;
+  /**
+   * ignore locks - only root is allowed to use this option.
+   */
+  skiplock?: boolean;
+  /**
+   * The (unique) ID of the VM.
+   * It should be between 100 and 999999999.
+   */
+  vmid: number;
+}

package/src/types/download-iso-image.ts

@@ -0,0 +1,23 @@
+// https://pve.proxmox.com/pve-docs/api-viewer/#/nodes/{node}/storage/{storage}/download-url
+export type DownloadIsoImagePayload = {
+  /**
+   * Content type.
+   */
+  content: "iso" | "vztmpl";
+  /**
+   * The name of the file to create. Caution: This will be normalized!
+   */
+  filename: string;
+  /**
+   * The cluster node name.
+   */
+  node: string;
+  /**
+   * The storage identifier.
+   */
+  storage: string;
+  /**
+   * The URL to download the file from.
+   */
+  url: string;
+}

package/src/types/index.ts

@@ -0,0 +1,10 @@
+export * from './clone-qemu-machine';
+export * from './create-qemu-machine';
+export * from './delete-qemu-machine';
+export * from './download-iso-image';
+export * from './index';
+export * from './ip';
+export * from './list-qemu-machines';
+export * from './start-qemu-machine';
+export * from './stop-qemu-machine';
+export * from './upid';

package/src/types/ip.ts

@@ -0,0 +1 @@
+export type IP = string & { readonly "": unique symbol };

package/src/types/list-qemu-machines.ts

@@ -0,0 +1,39 @@
+// https://pve.proxmox.com/pve-docs/api-viewer/#/nodes/{node}/qemu/{vmid}
+export type ListQemuMachinesPayload = {
+}
+
+export type QemuMachine = {
+  /**
+   * Maximum usable CPUs.
+   */
+  cpus: number;
+  /**
+   * Root disk size in bytes.
+   */
+  maxdisk: number;
+  /**
+   * Maximum memory in bytes.
+   */
+  maxmem: number;
+  name: string;
+  /**
+   * Current state of the VM.
+   *
+   * QEMU process status.
+   */
+  status: "running" | "stopped";
+  /**
+   * The current configured tags, if any
+   * Splitted by ;
+   */
+  tags: string;
+  /**
+   * Uptime duration in second.
+   */
+  uptime: string;
+  /**
+   * The (unique) ID of the VM.
+   */
+  vmid: number;
+}
+export type ListQemuMachinesAnswer = Array<QemuMachine>;

package/src/types/start-qemu-machine.ts

@@ -0,0 +1,5 @@
+// https://pve.proxmox.com/pve-docs/api-viewer/#/nodes/{node}/qemu/{vmid}/status/start
+export type StartQemuMachinePayload = {
+  node: string;
+  vmid: number;
+}

package/src/types/stop-qemu-machine.ts

@@ -0,0 +1,5 @@
+// https://pve.proxmox.com/pve-docs/api-viewer/#/nodes/{node}/qemu/{vmid}/status/start
+export type StopQemuMachinePayload = {
+  node: string;
+  vmid: number;
+}