@rollupdate/hctl 0.0.0-stage → 3.0.0

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

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

package/dist/cloud/commands/certificate.js

@@ -0,0 +1,108 @@
+import { readFileSync } from "node:fs";
+import { error, success } from "../../shared/formatter.js";
+import { confirmAction, output } from "../../shared/helpers.js";
+import { formatCertificateDetails, formatCertificateList, } from "../formatter.js";
+import { cloudAction, resolveIdOrName, } from "../helpers.js";
+export function registerCertificateCommands(parent) {
+    const cert = parent
+        .command("certificate")
+        .description("Certificate management");
+    cert
+        .command("list")
+        .alias("ls")
+        .description("List all certificates")
+        .option("-l, --label-selector <selector>", "Label selector")
+        .option("-s, --sort <field>", "Sort by field")
+        .option("--type <type>", "Filter by type (uploaded, managed)")
+        .action(cloudAction(async (client, options) => {
+        const certs = await client.listCertificates({
+            label_selector: options.labelSelector,
+            sort: options.sort,
+            type: options.type,
+        });
+        output(certs, formatCertificateList, options);
+    }));
+    cert
+        .command("describe <id-or-name>")
+        .description("Show certificate details")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "certificate", (name) => client.listCertificates({ name }));
+        const certificate = await client.getCertificate(id);
+        output(certificate, formatCertificateDetails, options);
+    }));
+    cert
+        .command("create")
+        .description("Create a certificate")
+        .requiredOption("--name <name>", "Certificate name")
+        .option("--type <type>", "Certificate type (uploaded, managed)", "uploaded")
+        .option("--cert-file <path>", "Path to certificate PEM file (for uploaded)")
+        .option("--key-file <path>", "Path to private key PEM file (for uploaded)")
+        .option("--domain <domains...>", "Domain names (for managed)")
+        .action(cloudAction(async (client, options) => {
+        const createOpts = {
+            name: options.name,
+            type: options.type,
+        };
+        if (options.type === "managed") {
+            if (!options.domain || options.domain.length === 0) {
+                console.error(error("Managed certificates require --domain"));
+                process.exit(1);
+            }
+            createOpts.domain_names = options.domain;
+        }
+        else {
+            if (!(options.certFile && options.keyFile)) {
+                console.error(error("Uploaded certificates require --cert-file and --key-file"));
+                process.exit(1);
+            }
+            createOpts.certificate = readFileSync(options.certFile, "utf-8");
+            createOpts.private_key = readFileSync(options.keyFile, "utf-8");
+        }
+        const { certificate: created } = await client.createCertificate(createOpts);
+        console.log(success(`Certificate '${created.name}' created (ID: ${created.id})`));
+    }));
+    cert
+        .command("delete <id-or-name>")
+        .description("Delete a certificate")
+        .option("-y, --yes", "Skip confirmation")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "certificate", (name) => client.listCertificates({ name }));
+        const certificate = await client.getCertificate(id);
+        if (!(await confirmAction(`Delete certificate '${certificate.name}' (ID: ${id})?`, options))) {
+            return;
+        }
+        await client.deleteCertificate(id);
+        console.log(success(`Certificate '${certificate.name}' (ID: ${id}) deleted.`));
+    }));
+    cert
+        .command("update <id-or-name>")
+        .description("Update certificate")
+        .option("--name <name>", "New name")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "certificate", (name) => client.listCertificates({ name }));
+        await client.updateCertificate(id, { name: options.name });
+        console.log(success(`Certificate ${id} updated.`));
+    }));
+    cert
+        .command("add-label <id-or-name> <label>")
+        .description("Add a label (key=value)")
+        .action(cloudAction(async (client, idOrName, label) => {
+        const id = await resolveIdOrName(idOrName, "certificate", (name) => client.listCertificates({ name }));
+        const certificate = await client.getCertificate(id);
+        const [key, value] = label.split("=");
+        await client.updateCertificate(id, {
+            labels: { ...certificate.labels, [key]: value || "" },
+        });
+        console.log(success(`Label '${key}' added.`));
+    }));
+    cert
+        .command("remove-label <id-or-name> <key>")
+        .description("Remove a label")
+        .action(cloudAction(async (client, idOrName, key) => {
+        const id = await resolveIdOrName(idOrName, "certificate", (name) => client.listCertificates({ name }));
+        const certificate = await client.getCertificate(id);
+        const labels = Object.fromEntries(Object.entries(certificate.labels).filter(([k]) => k !== key));
+        await client.updateCertificate(id, { labels });
+        console.log(success(`Label '${key}' removed.`));
+    }));
+}

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

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

package/dist/cloud/commands/context.js

@@ -0,0 +1,133 @@
+import { password as passwordPrompt } from "@inquirer/prompts";
+import { error as fmtError, success as fmtSuccess, warning as fmtWarning, } from "../../shared/formatter.js";
+import { normalizePermission, runCloudTokenBootstrap, } from "../browser-bootstrap.js";
+import { createContext, deleteContext, getActiveContext, listContexts, resolveToken, useContext, validateCloudToken, } from "../context.js";
+import { formatContextList } from "../formatter.js";
+import { printCloudTokenInstructions } from "../token-instructions.js";
+export function registerContextCommands(parent) {
+    const context = parent
+        .command("context")
+        .description("Cloud context (token) management");
+    context
+        .command("create <name>")
+        .description("Create a new cloud context")
+        .option("-t, --token <token>", "API token (will prompt if not provided)")
+        .option("--no-verify", "Skip validating the token with api.hetzner.cloud")
+        .action(async (name, options) => {
+        try {
+            let token = options.token;
+            if (!token) {
+                printCloudTokenInstructions();
+                token = await passwordPrompt({
+                    message: `Paste your Cloud API token for '${name}':`,
+                    validate: (v) => v.length > 0 || "Token is required",
+                });
+            }
+            await createContext(name, token, { verify: options.verify });
+            console.log(fmtSuccess(`Context '${name}' created and activated.`));
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "ExitPromptError") {
+                process.exit(0);
+            }
+            console.error(fmtError(error instanceof Error ? error.message : "Unknown error"));
+            process.exit(1);
+        }
+    });
+    context
+        .command("use <name>")
+        .description("Switch to a different cloud context")
+        .action((name) => {
+        try {
+            useContext(name);
+            console.log(fmtSuccess(`Switched to context '${name}'.`));
+        }
+        catch (error) {
+            console.error(fmtError(error instanceof Error ? error.message : "Unknown error"));
+            process.exit(1);
+        }
+    });
+    context
+        .command("delete <name>")
+        .alias("rm")
+        .description("Delete a cloud context")
+        .action(async (name) => {
+        try {
+            await deleteContext(name);
+            console.log(fmtSuccess(`Context '${name}' deleted.`));
+        }
+        catch (error) {
+            console.error(fmtError(error instanceof Error ? error.message : "Unknown error"));
+            process.exit(1);
+        }
+    });
+    context
+        .command("list")
+        .alias("ls")
+        .description("List all cloud contexts")
+        .action(() => {
+        const contexts = listContexts();
+        console.log(formatContextList(contexts));
+    });
+    context
+        .command("active")
+        .description("Show the active cloud context")
+        .action(() => {
+        const active = getActiveContext();
+        if (active) {
+            console.log(fmtSuccess(`Active context: ${active}`));
+        }
+        else {
+            console.log(fmtWarning("No active context. Run: hctl cloud context create"));
+        }
+    });
+    context
+        .command("test")
+        .description("Validate the resolved Cloud API token")
+        .option("-t, --token <token>", "API token to validate")
+        .action(async (options) => {
+        try {
+            const token = await resolveToken(options.token);
+            await validateCloudToken(token);
+            console.log(fmtSuccess("Cloud token is accepted by api.hetzner.cloud."));
+            console.log(fmtWarning("Hetzner does not expose the project name through this API; verify the context name matches the Cloud Console project."));
+        }
+        catch (error) {
+            console.error(fmtError(error instanceof Error ? error.message : "Unknown error"));
+            process.exit(1);
+        }
+    });
+    context
+        .command("bootstrap <name>")
+        .description("Open an explicit browser-assisted flow to create and save a Cloud API token")
+        .requiredOption("--project <name>", "Cloud project name")
+        .option("--create-project", "Guide through creating the project first")
+        .option("--token-name <name>", "API token name to use in Hetzner Console")
+        .option("--permission <permission>", "Token permission: read or read-write", "read-write")
+        .option("--write-env [path]", "Also write HETZNER_CLOUD_TOKEN to .env or the provided env file path")
+        .option("--no-verify", "Skip validating the token with api.hetzner.cloud")
+        .action(async (name, options) => {
+        try {
+            const permission = normalizePermission(options.permission);
+            const created = await runCloudTokenBootstrap({
+                contextName: name,
+                createProject: options.createProject,
+                envFile: options.writeEnv,
+                permission,
+                projectName: options.project,
+                tokenName: options.tokenName,
+                verify: options.verify,
+            });
+            if (created) {
+                console.log(fmtSuccess(`Context '${name}' created and activated.`));
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "ExitPromptError") {
+                process.exit(0);
+            }
+            console.error(fmtError(error instanceof Error ? error.message : "Unknown error"));
+            process.exit(1);
+        }
+    });
+}

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

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

package/dist/cloud/commands/datacenter.js

@@ -0,0 +1,24 @@
+import { output } from "../../shared/helpers.js";
+import { formatDatacenterDetails, formatDatacenterList } from "../formatter.js";
+import { cloudAction, resolveIdOrName, } from "../helpers.js";
+export function registerDatacenterCommands(parent) {
+    const datacenter = parent
+        .command("datacenter")
+        .description("Datacenter information");
+    datacenter
+        .command("list")
+        .alias("ls")
+        .description("List all datacenters")
+        .action(cloudAction(async (client, options) => {
+        const datacenters = await client.listDatacenters();
+        output(datacenters, formatDatacenterList, options);
+    }));
+    datacenter
+        .command("describe <id-or-name>")
+        .description("Show datacenter details")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "datacenter", (name) => client.listDatacenters({ name }));
+        const datacenter = await client.getDatacenter(id);
+        output(datacenter, formatDatacenterDetails, options);
+    }));
+}

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

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

package/dist/cloud/commands/firewall.js

@@ -0,0 +1,142 @@
+import { success } from "../../shared/formatter.js";
+import { confirmAction, output } from "../../shared/helpers.js";
+import { formatCloudFirewallDetails, formatCloudFirewallList, } from "../formatter.js";
+import { cloudAction, parseLabels, readJsonFile, resolveIdOrName, } from "../helpers.js";
+export function registerCloudFirewallCommands(parent) {
+    const firewall = parent
+        .command("firewall")
+        .description("Cloud firewall management");
+    firewall
+        .command("list")
+        .alias("ls")
+        .description("List all firewalls")
+        .option("-l, --label-selector <selector>", "Label selector")
+        .action(cloudAction(async (client, options) => {
+        const firewalls = await client.listFirewalls({
+            label_selector: options.labelSelector,
+        });
+        output(firewalls, formatCloudFirewallList, options);
+    }));
+    firewall
+        .command("describe <id-or-name>")
+        .description("Show firewall details")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "firewall", (name) => client.listFirewalls({ name }));
+        const fw = await client.getFirewall(id);
+        output(fw, formatCloudFirewallDetails, options);
+    }));
+    firewall
+        .command("create")
+        .description("Create a firewall")
+        .requiredOption("--name <name>", "Firewall name")
+        .option("--rules-file <file>", "JSON file with firewall rules array")
+        .option("--labels <labels>", "Labels as key=value pairs (comma-separated)")
+        .action(cloudAction(async (client, options) => {
+        const { firewall: fw } = await client.createFirewall({
+            name: options.name,
+            rules: options.rulesFile
+                ? readJsonFile(options.rulesFile)
+                : undefined,
+            labels: options.labels ? parseLabels(options.labels) : undefined,
+        });
+        console.log(success(`Firewall '${fw.name}' created (ID: ${fw.id}, ${fw.rules.length} rules)`));
+    }));
+    firewall
+        .command("delete <id-or-name>")
+        .description("Delete a firewall")
+        .option("-y, --yes", "Skip confirmation")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "firewall", (name) => client.listFirewalls({ name }));
+        const fw = await client.getFirewall(id);
+        if (!(await confirmAction(`Delete firewall '${fw.name}' (ID: ${id})?`, options))) {
+            return;
+        }
+        await client.deleteFirewall(id);
+        console.log(success(`Firewall '${fw.name}' (ID: ${id}) deleted.`));
+    }));
+    firewall
+        .command("update <id-or-name>")
+        .description("Update firewall")
+        .option("--name <name>", "New name")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "firewall", (name) => client.listFirewalls({ name }));
+        await client.updateFirewall(id, { name: options.name });
+        console.log(success(`Firewall ${id} updated.`));
+    }));
+    firewall
+        .command("apply-to-resource <id-or-name>")
+        .description("Apply firewall to resource")
+        .requiredOption("--type <type>", "Resource type (server, label_selector)")
+        .option("--server <server>", "Server ID")
+        .option("--label-selector <selector>", "Label selector")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "firewall", (name) => client.listFirewalls({ name }));
+        const applyTo = [
+            {
+                type: options.type,
+                ...(options.server
+                    ? { server: { id: Number.parseInt(options.server, 10) } }
+                    : {}),
+                ...(options.labelSelector
+                    ? { label_selector: { selector: options.labelSelector } }
+                    : {}),
+            },
+        ];
+        await client.applyFirewall(id, applyTo);
+        console.log(success(`Firewall ${id} applied.`));
+    }));
+    firewall
+        .command("remove-from-resource <id-or-name>")
+        .description("Remove firewall from resource")
+        .requiredOption("--type <type>", "Resource type (server, label_selector)")
+        .option("--server <server>", "Server ID")
+        .option("--label-selector <selector>", "Label selector")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "firewall", (name) => client.listFirewalls({ name }));
+        const removeFrom = [
+            {
+                type: options.type,
+                ...(options.server
+                    ? { server: { id: Number.parseInt(options.server, 10) } }
+                    : {}),
+                ...(options.labelSelector
+                    ? { label_selector: { selector: options.labelSelector } }
+                    : {}),
+            },
+        ];
+        await client.removeFirewallFromResources(id, removeFrom);
+        console.log(success(`Firewall ${id} removed from resource.`));
+    }));
+    firewall
+        .command("add-label <id-or-name> <label>")
+        .description("Add a label (key=value)")
+        .action(cloudAction(async (client, idOrName, label) => {
+        const id = await resolveIdOrName(idOrName, "firewall", (name) => client.listFirewalls({ name }));
+        const fw = await client.getFirewall(id);
+        const [key, value] = label.split("=");
+        await client.updateFirewall(id, {
+            labels: { ...fw.labels, [key]: value || "" },
+        });
+        console.log(success(`Label '${key}' added.`));
+    }));
+    firewall
+        .command("remove-label <id-or-name> <key>")
+        .description("Remove a label")
+        .action(cloudAction(async (client, idOrName, key) => {
+        const id = await resolveIdOrName(idOrName, "firewall", (name) => client.listFirewalls({ name }));
+        const fw = await client.getFirewall(id);
+        const labels = Object.fromEntries(Object.entries(fw.labels).filter(([k]) => k !== key));
+        await client.updateFirewall(id, { labels });
+        console.log(success(`Label '${key}' removed.`));
+    }));
+    firewall
+        .command("set-rules <id-or-name>")
+        .description("Set firewall rules from a JSON file")
+        .requiredOption("--rules-file <file>", "JSON file with firewall rules array")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "firewall", (name) => client.listFirewalls({ name }));
+        const rules = readJsonFile(options.rulesFile);
+        await client.setFirewallRules(id, rules);
+        console.log(success(`Firewall ${id} rules updated.`));
+    }));
+}

package/dist/cloud/commands/floating-ip.d.ts

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

package/dist/cloud/commands/floating-ip.js

@@ -0,0 +1,138 @@
+import { success } from "../../shared/formatter.js";
+import { confirmAction, output } from "../../shared/helpers.js";
+import { formatFloatingIpDetails, formatFloatingIpList } from "../formatter.js";
+import { cloudAction, resolveIdOrName, } from "../helpers.js";
+export function registerFloatingIpCommands(parent) {
+    const fip = parent
+        .command("floating-ip")
+        .description("Floating IP management");
+    fip
+        .command("list")
+        .alias("ls")
+        .description("List all floating IPs")
+        .option("-l, --label-selector <selector>", "Label selector")
+        .action(cloudAction(async (client, options) => {
+        const ips = await client.listFloatingIps({
+            label_selector: options.labelSelector,
+        });
+        output(ips, formatFloatingIpList, options);
+    }));
+    fip
+        .command("describe <id-or-name>")
+        .description("Show floating IP details")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "floating IP", (name) => client.listFloatingIps({ name }));
+        const ip = await client.getFloatingIp(id);
+        output(ip, formatFloatingIpDetails, options);
+    }));
+    fip
+        .command("create")
+        .description("Create a floating IP")
+        .requiredOption("--type <type>", "IP type (ipv4, ipv6)")
+        .option("--name <name>", "Name")
+        .option("--description <desc>", "Description")
+        .option("--home-location <loc>", "Home location")
+        .option("--server <id>", "Server to assign to")
+        .action(cloudAction(async (client, options) => {
+        const { floating_ip: ip } = await client.createFloatingIp({
+            type: options.type,
+            name: options.name,
+            description: options.description,
+            home_location: options.homeLocation,
+            server: options.server
+                ? Number.parseInt(options.server, 10)
+                : undefined,
+        });
+        console.log(success(`Floating IP created (ID: ${ip.id}, IP: ${ip.ip})`));
+    }));
+    fip
+        .command("delete <id-or-name>")
+        .description("Delete a floating IP")
+        .option("-y, --yes", "Skip confirmation")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "floating IP", (name) => client.listFloatingIps({ name }));
+        const ip = await client.getFloatingIp(id);
+        if (!(await confirmAction(`Delete floating IP '${ip.name}' (ID: ${id})?`, options))) {
+            return;
+        }
+        await client.deleteFloatingIp(id);
+        console.log(success(`Floating IP '${ip.name}' (ID: ${id}) deleted.`));
+    }));
+    fip
+        .command("update <id-or-name>")
+        .description("Update floating IP")
+        .option("--name <name>", "New name")
+        .option("--description <desc>", "New description")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "floating IP", (name) => client.listFloatingIps({ name }));
+        await client.updateFloatingIp(id, {
+            name: options.name,
+            description: options.description,
+        });
+        console.log(success(`Floating IP ${id} updated.`));
+    }));
+    fip
+        .command("assign <id-or-name> <server>")
+        .description("Assign floating IP to server")
+        .action(cloudAction(async (client, idOrName, server) => {
+        const id = await resolveIdOrName(idOrName, "floating IP", (name) => client.listFloatingIps({ name }));
+        await client.assignFloatingIp(id, Number.parseInt(server, 10));
+        console.log(success(`Floating IP ${id} assigned to server ${server}.`));
+    }));
+    fip
+        .command("unassign <id-or-name>")
+        .description("Unassign floating IP")
+        .action(cloudAction(async (client, idOrName) => {
+        const id = await resolveIdOrName(idOrName, "floating IP", (name) => client.listFloatingIps({ name }));
+        await client.unassignFloatingIp(id);
+        console.log(success(`Floating IP ${id} unassigned.`));
+    }));
+    fip
+        .command("enable-protection <id-or-name>")
+        .description("Enable delete protection")
+        .action(cloudAction(async (client, idOrName) => {
+        const id = await resolveIdOrName(idOrName, "floating IP", (name) => client.listFloatingIps({ name }));
+        await client.changeFloatingIpProtection(id, true);
+        console.log(success(`Protection enabled for floating IP ${id}.`));
+    }));
+    fip
+        .command("disable-protection <id-or-name>")
+        .description("Disable delete protection")
+        .action(cloudAction(async (client, idOrName) => {
+        const id = await resolveIdOrName(idOrName, "floating IP", (name) => client.listFloatingIps({ name }));
+        await client.changeFloatingIpProtection(id, false);
+        console.log(success(`Protection disabled for floating IP ${id}.`));
+    }));
+    fip
+        .command("set-rdns <id-or-name>")
+        .description("Set reverse DNS")
+        .requiredOption("--ip <ip>", "IP address")
+        .requiredOption("--dns-ptr <ptr>", "DNS pointer (empty to reset)")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "floating IP", (name) => client.listFloatingIps({ name }));
+        await client.changeFloatingIpDnsPtr(id, options.ip, options.dnsPtr || null);
+        console.log(success("rDNS updated."));
+    }));
+    fip
+        .command("add-label <id-or-name> <label>")
+        .description("Add a label (key=value)")
+        .action(cloudAction(async (client, idOrName, label) => {
+        const id = await resolveIdOrName(idOrName, "floating IP", (name) => client.listFloatingIps({ name }));
+        const ip = await client.getFloatingIp(id);
+        const [key, value] = label.split("=");
+        await client.updateFloatingIp(id, {
+            labels: { ...ip.labels, [key]: value || "" },
+        });
+        console.log(success(`Label '${key}' added.`));
+    }));
+    fip
+        .command("remove-label <id-or-name> <key>")
+        .description("Remove a label")
+        .action(cloudAction(async (client, idOrName, key) => {
+        const id = await resolveIdOrName(idOrName, "floating IP", (name) => client.listFloatingIps({ name }));
+        const ip = await client.getFloatingIp(id);
+        const labels = Object.fromEntries(Object.entries(ip.labels).filter(([k]) => k !== key));
+        await client.updateFloatingIp(id, { labels });
+        console.log(success(`Label '${key}' removed.`));
+    }));
+}

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

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