@rollupdate/hctl 0.0.0-stage → 3.0.0

package/dist/cloud/commands/image.js

@@ -0,0 +1,98 @@
+import { success } from "../../shared/formatter.js";
+import { confirmAction, output } from "../../shared/helpers.js";
+import { formatImageDetails, formatImageList } from "../formatter.js";
+import { cloudAction, resolveIdOrName, } from "../helpers.js";
+export function registerImageCommands(parent) {
+    const image = parent.command("image").description("Image management");
+    image
+        .command("list")
+        .alias("ls")
+        .description("List all images")
+        .option("-l, --label-selector <selector>", "Label selector")
+        .option("-s, --sort <field>", "Sort by field")
+        .option("--type <type>", "Filter by type (system, snapshot, backup, app)")
+        .option("--architecture <arch>", "Filter by architecture (x86, arm)")
+        .option("--status <status>", "Filter by status")
+        .action(cloudAction(async (client, options) => {
+        const images = await client.listImages({
+            label_selector: options.labelSelector,
+            sort: options.sort,
+            type: options.type,
+            architecture: options.architecture,
+            status: options.status,
+        });
+        output(images, formatImageList, options);
+    }));
+    image
+        .command("describe <id-or-name>")
+        .description("Show image details")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "image", (name) => client.listImages({ name }));
+        const img = await client.getImage(id);
+        output(img, formatImageDetails, options);
+    }));
+    image
+        .command("update <id-or-name>")
+        .description("Update image")
+        .option("--description <desc>", "New description")
+        .option("--type <type>", "New type (snapshot)")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "image", (name) => client.listImages({ name }));
+        await client.updateImage(id, {
+            description: options.description,
+            type: options.type,
+        });
+        console.log(success(`Image ${id} updated.`));
+    }));
+    image
+        .command("delete <id-or-name>")
+        .description("Delete an image")
+        .option("-y, --yes", "Skip confirmation")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "image", (name) => client.listImages({ name }));
+        const img = await client.getImage(id);
+        if (!(await confirmAction(`Delete image '${img.description}' (ID: ${id})?`, options))) {
+            return;
+        }
+        await client.deleteImage(id);
+        console.log(success(`Image '${img.description}' (ID: ${id}) deleted.`));
+    }));
+    image
+        .command("enable-protection <id-or-name>")
+        .description("Enable delete protection")
+        .action(cloudAction(async (client, idOrName) => {
+        const id = await resolveIdOrName(idOrName, "image", (name) => client.listImages({ name }));
+        await client.changeImageProtection(id, true);
+        console.log(success(`Protection enabled for image ${id}.`));
+    }));
+    image
+        .command("disable-protection <id-or-name>")
+        .description("Disable delete protection")
+        .action(cloudAction(async (client, idOrName) => {
+        const id = await resolveIdOrName(idOrName, "image", (name) => client.listImages({ name }));
+        await client.changeImageProtection(id, false);
+        console.log(success(`Protection disabled for image ${id}.`));
+    }));
+    image
+        .command("add-label <id-or-name> <label>")
+        .description("Add a label (key=value)")
+        .action(cloudAction(async (client, idOrName, label) => {
+        const id = await resolveIdOrName(idOrName, "image", (name) => client.listImages({ name }));
+        const img = await client.getImage(id);
+        const [key, value] = label.split("=");
+        await client.updateImage(id, {
+            labels: { ...img.labels, [key]: value || "" },
+        });
+        console.log(success(`Label '${key}' added.`));
+    }));
+    image
+        .command("remove-label <id-or-name> <key>")
+        .description("Remove a label")
+        .action(cloudAction(async (client, idOrName, key) => {
+        const id = await resolveIdOrName(idOrName, "image", (name) => client.listImages({ name }));
+        const img = await client.getImage(id);
+        const labels = Object.fromEntries(Object.entries(img.labels).filter(([k]) => k !== key));
+        await client.updateImage(id, { labels });
+        console.log(success(`Label '${key}' removed.`));
+    }));
+}

package/dist/cloud/commands/index.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerCloudCommands(parent: Command): void;

package/dist/cloud/commands/index.js

@@ -0,0 +1,47 @@
+import { registerCertificateCommands } from "./certificate.js";
+import { registerContextCommands } from "./context.js";
+import { registerDatacenterCommands } from "./datacenter.js";
+import { registerCloudFirewallCommands } from "./firewall.js";
+import { registerFloatingIpCommands } from "./floating-ip.js";
+import { registerImageCommands } from "./image.js";
+import { registerInventoryCommands } from "./inventory.js";
+import { registerIsoCommands } from "./iso.js";
+import { registerLoadBalancerCommands } from "./load-balancer.js";
+import { registerLoadBalancerTypeCommands } from "./load-balancer-type.js";
+import { registerLocationCommands } from "./location.js";
+import { registerNetworkCommands } from "./network.js";
+import { registerPlacementGroupCommands } from "./placement-group.js";
+import { registerPricingCommands } from "./pricing.js";
+import { registerPrimaryIpCommands } from "./primary-ip.js";
+import { registerCloudServerCommands } from "./server.js";
+import { registerServerTypeCommands } from "./server-type.js";
+import { registerCloudSshKeyCommands } from "./ssh-key.js";
+import { registerVolumeCommands } from "./volume.js";
+export function registerCloudCommands(parent) {
+    const cloud = parent
+        .command("cloud")
+        .description("Hetzner Cloud API management");
+    cloud.option("--token <token>", "Cloud API token (overrides context)");
+    registerContextCommands(cloud);
+    // Read-only resources
+    registerDatacenterCommands(cloud);
+    registerLocationCommands(cloud);
+    registerServerTypeCommands(cloud);
+    registerLoadBalancerTypeCommands(cloud);
+    registerIsoCommands(cloud);
+    registerPricingCommands(cloud);
+    registerInventoryCommands(cloud);
+    // Core resources
+    registerCloudServerCommands(cloud);
+    registerNetworkCommands(cloud);
+    registerCloudFirewallCommands(cloud);
+    registerFloatingIpCommands(cloud);
+    registerPrimaryIpCommands(cloud);
+    registerVolumeCommands(cloud);
+    registerLoadBalancerCommands(cloud);
+    registerImageCommands(cloud);
+    // Ancillary resources
+    registerCloudSshKeyCommands(cloud);
+    registerCertificateCommands(cloud);
+    registerPlacementGroupCommands(cloud);
+}

package/dist/cloud/commands/inventory.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerInventoryCommands(parent: Command): void;

package/dist/cloud/commands/inventory.js

@@ -0,0 +1,13 @@
+import { output } from "../../shared/helpers.js";
+import { formatInventoryReport } from "../formatter.js";
+import { cloudAction } from "../helpers.js";
+import { buildInventory } from "../inventory.js";
+export function registerInventoryCommands(parent) {
+    parent
+        .command("inventory")
+        .description("Full fleet inventory with estimated monthly costs (list prices x live resources)")
+        .action(cloudAction(async (client, options) => {
+        const report = await buildInventory(client);
+        output(report, formatInventoryReport, options);
+    }));
+}

package/dist/cloud/commands/iso.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerIsoCommands(parent: Command): void;

package/dist/cloud/commands/iso.js

@@ -0,0 +1,27 @@
+import { output } from "../../shared/helpers.js";
+import { formatIsoDetails, formatIsoList } from "../formatter.js";
+import { cloudAction, resolveIdOrName, } from "../helpers.js";
+export function registerIsoCommands(parent) {
+    const iso = parent.command("iso").description("ISO image management");
+    iso
+        .command("list")
+        .alias("ls")
+        .description("List all ISOs")
+        .option("-n, --name <name>", "Filter by name")
+        .option("-a, --architecture <arch>", "Filter by architecture")
+        .action(cloudAction(async (client, options) => {
+        const isos = await client.listIsos({
+            name: options.name,
+            architecture: options.architecture,
+        });
+        output(isos, formatIsoList, options);
+    }));
+    iso
+        .command("describe <id-or-name>")
+        .description("Show ISO details")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "ISO", (name) => client.listIsos({ name }));
+        const iso = await client.getIso(id);
+        output(iso, formatIsoDetails, options);
+    }));
+}

package/dist/cloud/commands/load-balancer-type.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerLoadBalancerTypeCommands(parent: Command): void;

package/dist/cloud/commands/load-balancer-type.js

@@ -0,0 +1,24 @@
+import { output } from "../../shared/helpers.js";
+import { formatLoadBalancerTypeDetails, formatLoadBalancerTypeList, } from "../formatter.js";
+import { cloudAction, resolveIdOrName, } from "../helpers.js";
+export function registerLoadBalancerTypeCommands(parent) {
+    const lbType = parent
+        .command("load-balancer-type")
+        .description("Load balancer type information");
+    lbType
+        .command("list")
+        .alias("ls")
+        .description("List all load balancer types")
+        .action(cloudAction(async (client, options) => {
+        const types = await client.listLoadBalancerTypes();
+        output(types, formatLoadBalancerTypeList, options);
+    }));
+    lbType
+        .command("describe <id-or-name>")
+        .description("Show load balancer type details")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "load balancer type", (name) => client.listLoadBalancerTypes({ name }));
+        const type = await client.getLoadBalancerType(id);
+        output(type, formatLoadBalancerTypeDetails, options);
+    }));
+}

package/dist/cloud/commands/load-balancer.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerLoadBalancerCommands(parent: Command): void;

package/dist/cloud/commands/load-balancer.js

@@ -0,0 +1,269 @@
+import { success } from "../../shared/formatter.js";
+import { confirmAction, output } from "../../shared/helpers.js";
+import { formatLoadBalancerDetails, formatLoadBalancerList, } from "../formatter.js";
+import { cloudAction, resolveIdOrName, } from "../helpers.js";
+function resolveLbId(client, idOrName) {
+    return resolveIdOrName(idOrName, "load balancer", (name) => client.listLoadBalancers({ name }));
+}
+async function handleLbList(client, options) {
+    const lbs = await client.listLoadBalancers({
+        label_selector: options.labelSelector,
+        sort: options.sort,
+    });
+    output(lbs, formatLoadBalancerList, options);
+}
+async function handleLbDescribe(client, idOrName, options) {
+    const id = await resolveLbId(client, idOrName);
+    const loadBalancer = await client.getLoadBalancer(id);
+    output(loadBalancer, formatLoadBalancerDetails, options);
+}
+async function handleLbCreate(client, options) {
+    const { load_balancer: created } = await client.createLoadBalancer({
+        name: options.name,
+        load_balancer_type: options.type,
+        location: options.location,
+        network_zone: options.networkZone,
+        algorithm: options.algorithm ? { type: options.algorithm } : undefined,
+    });
+    console.log(success(`Load balancer '${created.name}' created (ID: ${created.id})`));
+}
+async function handleLbDelete(client, idOrName, options) {
+    const id = await resolveLbId(client, idOrName);
+    const loadBalancer = await client.getLoadBalancer(id);
+    if (!(await confirmAction(`Delete load balancer '${loadBalancer.name}' (ID: ${id})?`, options))) {
+        return;
+    }
+    await client.deleteLoadBalancer(id);
+    console.log(success(`Load balancer '${loadBalancer.name}' (ID: ${id}) deleted.`));
+}
+async function handleLbUpdate(client, idOrName, options) {
+    const id = await resolveLbId(client, idOrName);
+    await client.updateLoadBalancer(id, { name: options.name });
+    console.log(success(`Load balancer ${id} updated.`));
+}
+async function handleLbAddTarget(client, idOrName, options) {
+    const id = await resolveLbId(client, idOrName);
+    const target = {
+        type: options.type,
+        use_private_ip: !!options.usePrivateIp,
+    };
+    if (options.server) {
+        target.server = { id: Number.parseInt(options.server, 10) };
+    }
+    if (options.labelSelector) {
+        target.label_selector = { selector: options.labelSelector };
+    }
+    if (options.ip) {
+        target.ip = { ip: options.ip };
+    }
+    await client.addTargetToLoadBalancer(id, target);
+    console.log(success(`Target added to load balancer ${id}.`));
+}
+async function handleLbRemoveTarget(client, idOrName, options) {
+    const id = await resolveLbId(client, idOrName);
+    const target = { type: options.type };
+    if (options.server) {
+        target.server = { id: Number.parseInt(options.server, 10) };
+    }
+    if (options.labelSelector) {
+        target.label_selector = { selector: options.labelSelector };
+    }
+    if (options.ip) {
+        target.ip = { ip: options.ip };
+    }
+    await client.removeTargetFromLoadBalancer(id, target);
+    console.log(success(`Target removed from load balancer ${id}.`));
+}
+async function handleLbAddService(client, idOrName, options) {
+    const id = await resolveLbId(client, idOrName);
+    await client.addServiceToLoadBalancer(id, {
+        protocol: options.protocol,
+        listen_port: Number.parseInt(options.listenPort, 10),
+        destination_port: Number.parseInt(options.destinationPort, 10),
+        proxyprotocol: !!options.proxyprotocol,
+        health_check: {
+            protocol: options.protocol,
+            port: Number.parseInt(options.destinationPort, 10),
+            interval: 15,
+            timeout: 10,
+            retries: 3,
+        },
+    });
+    console.log(success(`Service added to load balancer ${id}.`));
+}
+async function handleLbUpdateService(client, idOrName, options) {
+    const id = await resolveLbId(client, idOrName);
+    const service = {
+        listen_port: Number.parseInt(options.listenPort, 10),
+    };
+    if (options.protocol) {
+        service.protocol = options.protocol;
+    }
+    if (options.destinationPort) {
+        service.destination_port = Number.parseInt(options.destinationPort, 10);
+    }
+    if (options.proxyprotocol !== undefined) {
+        service.proxyprotocol = options.proxyprotocol === "true";
+    }
+    await client.updateServiceOnLoadBalancer(id, service);
+    console.log(success(`Service on load balancer ${id} updated.`));
+}
+async function handleLbDeleteService(client, idOrName, options) {
+    const id = await resolveLbId(client, idOrName);
+    await client.deleteServiceFromLoadBalancer(id, Number.parseInt(options.listenPort, 10));
+    console.log(success(`Service on port ${options.listenPort} deleted from load balancer ${id}.`));
+}
+async function handleLbChangeAlgorithm(client, idOrName, options) {
+    const id = await resolveLbId(client, idOrName);
+    await client.changeLoadBalancerAlgorithm(id, options.algorithm);
+    console.log(success(`Algorithm changed for load balancer ${id}.`));
+}
+async function handleLbChangeType(client, idOrName, options) {
+    const id = await resolveLbId(client, idOrName);
+    await client.changeLoadBalancerType(id, options.type);
+    console.log(success(`Type changed for load balancer ${id}.`));
+}
+async function handleLbAttachToNetwork(client, idOrName, options) {
+    const id = await resolveLbId(client, idOrName);
+    await client.attachLoadBalancerToNetwork(id, Number.parseInt(options.network, 10), options.ip);
+    console.log(success(`Load balancer ${id} attached to network ${options.network}.`));
+}
+async function handleLbDetachFromNetwork(client, idOrName, options) {
+    const id = await resolveLbId(client, idOrName);
+    await client.detachLoadBalancerFromNetwork(id, Number.parseInt(options.network, 10));
+    console.log(success(`Load balancer ${id} detached from network ${options.network}.`));
+}
+async function handleLbEnablePublicInterface(client, idOrName) {
+    const id = await resolveLbId(client, idOrName);
+    await client.enableLoadBalancerPublicInterface(id);
+    console.log(success(`Public interface enabled for load balancer ${id}.`));
+}
+async function handleLbDisablePublicInterface(client, idOrName) {
+    const id = await resolveLbId(client, idOrName);
+    await client.disableLoadBalancerPublicInterface(id);
+    console.log(success(`Public interface disabled for load balancer ${id}.`));
+}
+async function handleLbEnableProtection(client, idOrName) {
+    const id = await resolveLbId(client, idOrName);
+    await client.changeLoadBalancerProtection(id, true);
+    console.log(success(`Protection enabled for load balancer ${id}.`));
+}
+async function handleLbDisableProtection(client, idOrName) {
+    const id = await resolveLbId(client, idOrName);
+    await client.changeLoadBalancerProtection(id, false);
+    console.log(success(`Protection disabled for load balancer ${id}.`));
+}
+async function handleLbAddLabel(client, idOrName, label) {
+    const id = await resolveLbId(client, idOrName);
+    const loadBalancer = await client.getLoadBalancer(id);
+    const [key, value] = label.split("=");
+    await client.updateLoadBalancer(id, {
+        labels: { ...loadBalancer.labels, [key]: value || "" },
+    });
+    console.log(success(`Label '${key}' added.`));
+}
+async function handleLbRemoveLabel(client, idOrName, key) {
+    const id = await resolveLbId(client, idOrName);
+    const loadBalancer = await client.getLoadBalancer(id);
+    const labels = Object.fromEntries(Object.entries(loadBalancer.labels).filter(([k]) => k !== key));
+    await client.updateLoadBalancer(id, { labels });
+    console.log(success(`Label '${key}' removed.`));
+}
+export function registerLoadBalancerCommands(parent) {
+    const lb = parent
+        .command("load-balancer")
+        .description("Load balancer management");
+    lb.command("list")
+        .alias("ls")
+        .description("List all load balancers")
+        .option("-l, --label-selector <selector>", "Label selector")
+        .option("-s, --sort <field>", "Sort by field")
+        .action(cloudAction(handleLbList));
+    lb.command("describe <id-or-name>")
+        .description("Show load balancer details")
+        .action(cloudAction(handleLbDescribe));
+    lb.command("create")
+        .description("Create a load balancer")
+        .requiredOption("--name <name>", "Load balancer name")
+        .requiredOption("--type <type>", "Load balancer type")
+        .option("--location <loc>", "Location")
+        .option("--network-zone <zone>", "Network zone")
+        .option("--algorithm <algo>", "Algorithm (round_robin, least_connections)", "round_robin")
+        .action(cloudAction(handleLbCreate));
+    lb.command("delete <id-or-name>")
+        .description("Delete a load balancer")
+        .option("-y, --yes", "Skip confirmation")
+        .action(cloudAction(handleLbDelete));
+    lb.command("update <id-or-name>")
+        .description("Update load balancer")
+        .option("--name <name>", "New name")
+        .action(cloudAction(handleLbUpdate));
+    lb.command("add-target <id-or-name>")
+        .description("Add target to load balancer")
+        .requiredOption("--type <type>", "Target type (server, label_selector, ip)")
+        .option("--server <server>", "Server ID")
+        .option("--label-selector <selector>", "Label selector")
+        .option("--ip <ip>", "IP address")
+        .option("--use-private-ip", "Use private IP")
+        .action(cloudAction(handleLbAddTarget));
+    lb.command("remove-target <id-or-name>")
+        .description("Remove target from load balancer")
+        .requiredOption("--type <type>", "Target type (server, label_selector, ip)")
+        .option("--server <server>", "Server ID")
+        .option("--label-selector <selector>", "Label selector")
+        .option("--ip <ip>", "IP address")
+        .action(cloudAction(handleLbRemoveTarget));
+    lb.command("add-service <id-or-name>")
+        .description("Add service to load balancer")
+        .requiredOption("--protocol <protocol>", "Protocol (tcp, http, https)")
+        .requiredOption("--listen-port <port>", "Listen port")
+        .requiredOption("--destination-port <port>", "Destination port")
+        .option("--proxyprotocol", "Enable proxy protocol")
+        .action(cloudAction(handleLbAddService));
+    lb.command("update-service <id-or-name>")
+        .description("Update a service on load balancer")
+        .requiredOption("--listen-port <port>", "Listen port of the service to update")
+        .option("--protocol <protocol>", "New protocol")
+        .option("--destination-port <port>", "New destination port")
+        .option("--proxyprotocol <bool>", "Enable/disable proxy protocol (true/false)")
+        .action(cloudAction(handleLbUpdateService));
+    lb.command("delete-service <id-or-name>")
+        .description("Delete a service from load balancer")
+        .requiredOption("--listen-port <port>", "Listen port of the service to delete")
+        .action(cloudAction(handleLbDeleteService));
+    lb.command("change-algorithm <id-or-name>")
+        .description("Change load balancer algorithm")
+        .requiredOption("--algorithm <type>", "Algorithm type (round_robin, least_connections)")
+        .action(cloudAction(handleLbChangeAlgorithm));
+    lb.command("change-type <id-or-name>")
+        .description("Change load balancer type")
+        .requiredOption("--type <type>", "New load balancer type")
+        .action(cloudAction(handleLbChangeType));
+    lb.command("attach-to-network <id-or-name>")
+        .description("Attach load balancer to network")
+        .requiredOption("--network <network>", "Network ID")
+        .option("--ip <ip>", "IP address in network")
+        .action(cloudAction(handleLbAttachToNetwork));
+    lb.command("detach-from-network <id-or-name>")
+        .description("Detach load balancer from network")
+        .requiredOption("--network <network>", "Network ID")
+        .action(cloudAction(handleLbDetachFromNetwork));
+    lb.command("enable-public-interface <id-or-name>")
+        .description("Enable public interface")
+        .action(cloudAction(handleLbEnablePublicInterface));
+    lb.command("disable-public-interface <id-or-name>")
+        .description("Disable public interface")
+        .action(cloudAction(handleLbDisablePublicInterface));
+    lb.command("enable-protection <id-or-name>")
+        .description("Enable delete protection")
+        .action(cloudAction(handleLbEnableProtection));
+    lb.command("disable-protection <id-or-name>")
+        .description("Disable delete protection")
+        .action(cloudAction(handleLbDisableProtection));
+    lb.command("add-label <id-or-name> <label>")
+        .description("Add a label (key=value)")
+        .action(cloudAction(handleLbAddLabel));
+    lb.command("remove-label <id-or-name> <key>")
+        .description("Remove a label")
+        .action(cloudAction(handleLbRemoveLabel));
+}

package/dist/cloud/commands/location.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerLocationCommands(parent: Command): void;

package/dist/cloud/commands/location.js

@@ -0,0 +1,24 @@
+import { output } from "../../shared/helpers.js";
+import { formatLocationDetails, formatLocationList } from "../formatter.js";
+import { cloudAction, resolveIdOrName, } from "../helpers.js";
+export function registerLocationCommands(parent) {
+    const location = parent
+        .command("location")
+        .description("Location information");
+    location
+        .command("list")
+        .alias("ls")
+        .description("List all locations")
+        .action(cloudAction(async (client, options) => {
+        const locations = await client.listLocations();
+        output(locations, formatLocationList, options);
+    }));
+    location
+        .command("describe <id-or-name>")
+        .description("Show location details")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "location", (name) => client.listLocations({ name }));
+        const location = await client.getLocation(id);
+        output(location, formatLocationDetails, options);
+    }));
+}

package/dist/cloud/commands/network.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerNetworkCommands(parent: Command): void;