@rollupdate/hctl 0.0.0-stage → 3.0.0

package/dist/cloud/commands/server.js

@@ -0,0 +1,346 @@
+import { colorize, info, success } from "../../shared/formatter.js";
+import { confirmAction, output } from "../../shared/helpers.js";
+import { formatCloudServerDetails, formatCloudServerList, } from "../formatter.js";
+import { cloudAction, parseLabels, resolveIdOrName, } from "../helpers.js";
+function resolveServerId(client, idOrName) {
+    return resolveIdOrName(idOrName, "server", (name) => client.listServers({ name }));
+}
+async function handleServerList(client, options) {
+    const servers = await client.listServers({
+        label_selector: options.labelSelector,
+        name: options.name,
+        sort: options.sort,
+        status: options.status,
+    });
+    output(servers, formatCloudServerList, options);
+}
+async function handleServerDescribe(client, idOrName, options) {
+    const id = await resolveServerId(client, idOrName);
+    const srv = await client.getServer(id);
+    output(srv, formatCloudServerDetails, options);
+}
+async function handleServerCreate(client, options) {
+    const result = await client.createServer({
+        name: options.name,
+        server_type: options.type,
+        image: options.image,
+        location: options.location,
+        ssh_keys: options.sshKey,
+        user_data: options.userData,
+        labels: options.labels ? parseLabels(options.labels) : undefined,
+        firewalls: options.firewall?.map((id) => ({
+            firewall: Number.parseInt(id, 10),
+        })),
+        placement_group: options.placementGroup
+            ? Number.parseInt(options.placementGroup, 10)
+            : undefined,
+        start_after_create: options.startAfterCreate,
+    });
+    console.log(success(`Server '${result.server.name}' created (ID: ${result.server.id})`));
+    if (result.root_password) {
+        console.log(`Root password: ${colorize(result.root_password, "yellow")}`);
+    }
+    console.log(info(`IPv4: ${result.server.public_net.ipv4?.ip || "pending"}`));
+}
+async function handleServerDelete(client, idOrName, options) {
+    const id = await resolveServerId(client, idOrName);
+    const srv = await client.getServer(id);
+    if (!(await confirmAction(`Delete server '${srv.name}' (ID: ${id})?`, options))) {
+        return;
+    }
+    await client.deleteServer(id);
+    console.log(success(`Server '${srv.name}' (ID: ${id}) deleted.`));
+}
+async function handleServerUpdate(client, idOrName, options) {
+    const id = await resolveServerId(client, idOrName);
+    const { server: srv } = await client.updateServer(id, {
+        name: options.name,
+    });
+    console.log(success(`Server '${srv.name}' updated.`));
+}
+async function handleServerPoweron(client, idOrName) {
+    const id = await resolveServerId(client, idOrName);
+    await client.powerOnServer(id);
+    console.log(success(`Server ${id} powered on.`));
+}
+async function handleServerPoweroff(client, idOrName) {
+    const id = await resolveServerId(client, idOrName);
+    await client.powerOffServer(id);
+    console.log(success(`Server ${id} powered off.`));
+}
+async function handleServerReboot(client, idOrName) {
+    const id = await resolveServerId(client, idOrName);
+    await client.rebootServer(id);
+    console.log(success(`Server ${id} rebooted.`));
+}
+async function handleServerReset(client, idOrName) {
+    const id = await resolveServerId(client, idOrName);
+    await client.resetServer(id);
+    console.log(success(`Server ${id} reset.`));
+}
+async function handleServerShutdown(client, idOrName) {
+    const id = await resolveServerId(client, idOrName);
+    await client.shutdownServer(id);
+    console.log(success(`Server ${id} shutdown initiated.`));
+}
+async function handleServerRebuild(client, idOrName, options) {
+    const id = await resolveServerId(client, idOrName);
+    const result = await client.rebuildServer(id, options.image);
+    console.log(success(`Server ${id} rebuilding.`));
+    if (result.root_password) {
+        console.log(`Root password: ${colorize(result.root_password, "yellow")}`);
+    }
+}
+async function handleServerChangeType(client, idOrName, options) {
+    const id = await resolveServerId(client, idOrName);
+    await client.changeServerType(id, options.type, !!options.upgradeDisk);
+    console.log(success(`Server ${id} type change initiated.`));
+}
+async function handleServerEnableRescue(client, idOrName, options) {
+    const id = await resolveServerId(client, idOrName);
+    const result = await client.enableServerRescue(id, options.type, options.sshKey?.map(Number));
+    console.log(success("Rescue mode enabled."));
+    console.log(`Root password: ${colorize(result.root_password, "yellow")}`);
+}
+async function handleServerDisableRescue(client, idOrName) {
+    const id = await resolveServerId(client, idOrName);
+    await client.disableServerRescue(id);
+    console.log(success("Rescue mode disabled."));
+}
+async function handleServerEnableBackup(client, idOrName) {
+    const id = await resolveServerId(client, idOrName);
+    await client.enableServerBackup(id);
+    console.log(success(`Backups enabled for server ${id}.`));
+}
+async function handleServerDisableBackup(client, idOrName) {
+    const id = await resolveServerId(client, idOrName);
+    await client.disableServerBackup(id);
+    console.log(success(`Backups disabled for server ${id}.`));
+}
+async function handleServerCreateImage(client, idOrName, options) {
+    const id = await resolveServerId(client, idOrName);
+    const result = await client.createServerImage(id, {
+        description: options.description,
+        type: options.type,
+    });
+    console.log(success(`Image created (ID: ${result.image.id})`));
+}
+async function handleServerAttachIso(client, idOrName, options) {
+    const id = await resolveServerId(client, idOrName);
+    await client.attachIsoToServer(id, options.iso);
+    console.log(success(`ISO attached to server ${id}.`));
+}
+async function handleServerDetachIso(client, idOrName) {
+    const id = await resolveServerId(client, idOrName);
+    await client.detachIsoFromServer(id);
+    console.log(success(`ISO detached from server ${id}.`));
+}
+async function handleServerResetPassword(client, idOrName) {
+    const id = await resolveServerId(client, idOrName);
+    const result = await client.resetServerPassword(id);
+    console.log(success("Root password reset."));
+    console.log(`New password: ${colorize(result.root_password, "yellow")}`);
+}
+async function handleServerSetRdns(client, idOrName, options) {
+    const id = await resolveServerId(client, idOrName);
+    await client.setServerRdns(id, options.ip, options.dnsPtr);
+    console.log(success(`rDNS set: ${options.ip} -> ${options.dnsPtr}`));
+}
+async function handleServerEnableProtection(client, idOrName, options) {
+    const id = await resolveServerId(client, idOrName);
+    await client.enableServerProtection(id, {
+        delete: options.delete,
+        rebuild: options.rebuild,
+    });
+    console.log(success(`Protection enabled for server ${id}.`));
+}
+async function handleServerDisableProtection(client, idOrName) {
+    const id = await resolveServerId(client, idOrName);
+    await client.enableServerProtection(id, {
+        delete: false,
+        rebuild: false,
+    });
+    console.log(success(`Protection disabled for server ${id}.`));
+}
+async function handleServerRequestConsole(client, idOrName) {
+    const id = await resolveServerId(client, idOrName);
+    const result = await client.requestServerConsole(id);
+    console.log(success("Console ready."));
+    console.log(`WebSocket URL: ${result.wss_url}`);
+    console.log(`Password: ${colorize(result.password, "yellow")}`);
+}
+async function handleServerAttachToNetwork(client, idOrName, options) {
+    const id = await resolveServerId(client, idOrName);
+    await client.attachServerToNetwork(id, Number.parseInt(options.network, 10), options.ip);
+    console.log(success(`Server ${id} attached to network ${options.network}.`));
+}
+async function handleServerDetachFromNetwork(client, idOrName, options) {
+    const id = await resolveServerId(client, idOrName);
+    await client.detachServerFromNetwork(id, Number.parseInt(options.network, 10));
+    console.log(success(`Server ${id} detached from network ${options.network}.`));
+}
+async function handleServerAddLabel(client, idOrName, label) {
+    const id = await resolveServerId(client, idOrName);
+    const srv = await client.getServer(id);
+    const [key, value] = label.split("=");
+    const labels = { ...srv.labels, [key]: value || "" };
+    await client.updateServer(id, { labels });
+    console.log(success(`Label '${key}' added to server ${id}.`));
+}
+async function handleServerRemoveLabel(client, idOrName, key) {
+    const id = await resolveServerId(client, idOrName);
+    const srv = await client.getServer(id);
+    const labels = Object.fromEntries(Object.entries(srv.labels).filter(([k]) => k !== key));
+    await client.updateServer(id, { labels });
+    console.log(success(`Label '${key}' removed from server ${id}.`));
+}
+export function registerCloudServerCommands(parent) {
+    const server = parent
+        .command("server")
+        .description("Cloud server management");
+    server
+        .command("list")
+        .alias("ls")
+        .description("List all servers")
+        .option("-l, --label-selector <selector>", "Label selector")
+        .option("-n, --name <name>", "Filter by name")
+        .option("-s, --sort <field>", "Sort by field")
+        .option("--status <status>", "Filter by status")
+        .action(cloudAction(handleServerList));
+    server
+        .command("describe <id-or-name>")
+        .description("Show server details")
+        .action(cloudAction(handleServerDescribe));
+    server
+        .command("create")
+        .description("Create a new server")
+        .requiredOption("--name <name>", "Server name")
+        .requiredOption("--type <type>", "Server type")
+        .requiredOption("--image <image>", "Image to use")
+        .option("--location <location>", "Location")
+        .option("--ssh-key <keys...>", "SSH key IDs or names")
+        .option("--user-data <data>", "Cloud-init user data")
+        .option("--labels <labels>", "Labels as key=value pairs (comma-separated)")
+        .option("--firewall <ids...>", "Firewall IDs to apply")
+        .option("--placement-group <id>", "Placement group ID")
+        .option("--start-after-create", "Start server after creation", true)
+        .option("--no-start-after-create", "Do not start server after creation")
+        .action(cloudAction(handleServerCreate));
+    server
+        .command("delete <id-or-name>")
+        .description("Delete a server")
+        .option("-y, --yes", "Skip confirmation")
+        .action(cloudAction(handleServerDelete));
+    server
+        .command("update <id-or-name>")
+        .description("Update server")
+        .option("--name <name>", "New name")
+        .action(cloudAction(handleServerUpdate));
+    server
+        .command("poweron <id-or-name>")
+        .description("Power on a server")
+        .action(cloudAction(handleServerPoweron));
+    server
+        .command("poweroff <id-or-name>")
+        .description("Power off a server (hard)")
+        .action(cloudAction(handleServerPoweroff));
+    server
+        .command("reboot <id-or-name>")
+        .description("Soft reboot a server")
+        .action(cloudAction(handleServerReboot));
+    server
+        .command("reset <id-or-name>")
+        .description("Hard reset a server")
+        .action(cloudAction(handleServerReset));
+    server
+        .command("shutdown <id-or-name>")
+        .description("Gracefully shutdown a server (ACPI)")
+        .action(cloudAction(handleServerShutdown));
+    server
+        .command("rebuild <id-or-name>")
+        .description("Rebuild a server with a new image")
+        .requiredOption("--image <image>", "Image to rebuild with")
+        .action(cloudAction(handleServerRebuild));
+    server
+        .command("change-type <id-or-name>")
+        .description("Change server type (resize)")
+        .requiredOption("--type <type>", "New server type")
+        .option("--upgrade-disk", "Upgrade disk size (irreversible)", false)
+        .action(cloudAction(handleServerChangeType));
+    server
+        .command("enable-rescue <id-or-name>")
+        .description("Enable rescue mode")
+        .option("--type <type>", "Rescue system type", "linux64")
+        .option("--ssh-key <keys...>", "SSH key IDs")
+        .action(cloudAction(handleServerEnableRescue));
+    server
+        .command("disable-rescue <id-or-name>")
+        .description("Disable rescue mode")
+        .action(cloudAction(handleServerDisableRescue));
+    server
+        .command("enable-backup <id-or-name>")
+        .description("Enable automatic backups")
+        .action(cloudAction(handleServerEnableBackup));
+    server
+        .command("disable-backup <id-or-name>")
+        .description("Disable automatic backups")
+        .action(cloudAction(handleServerDisableBackup));
+    server
+        .command("create-image <id-or-name>")
+        .description("Create an image (snapshot) from server")
+        .option("--description <desc>", "Image description")
+        .option("--type <type>", "Image type (snapshot or backup)", "snapshot")
+        .action(cloudAction(handleServerCreateImage));
+    server
+        .command("attach-iso <id-or-name>")
+        .description("Attach an ISO to a server")
+        .requiredOption("--iso <iso>", "ISO name or ID")
+        .action(cloudAction(handleServerAttachIso));
+    server
+        .command("detach-iso <id-or-name>")
+        .description("Detach ISO from a server")
+        .action(cloudAction(handleServerDetachIso));
+    server
+        .command("reset-password <id-or-name>")
+        .description("Reset server root password")
+        .action(cloudAction(handleServerResetPassword));
+    server
+        .command("set-rdns <id-or-name>")
+        .description("Set reverse DNS for server")
+        .requiredOption("--ip <ip>", "IP address")
+        .requiredOption("--dns-ptr <ptr>", "DNS pointer")
+        .action(cloudAction(handleServerSetRdns));
+    server
+        .command("enable-protection <id-or-name>")
+        .description("Enable server protection")
+        .option("--delete", "Enable delete protection", true)
+        .option("--rebuild", "Enable rebuild protection", false)
+        .action(cloudAction(handleServerEnableProtection));
+    server
+        .command("disable-protection <id-or-name>")
+        .description("Disable server protection")
+        .action(cloudAction(handleServerDisableProtection));
+    server
+        .command("request-console <id-or-name>")
+        .description("Request a WebSocket VNC console")
+        .action(cloudAction(handleServerRequestConsole));
+    server
+        .command("attach-to-network <id-or-name>")
+        .description("Attach server to a network")
+        .requiredOption("--network <network>", "Network ID")
+        .option("--ip <ip>", "IP address in network")
+        .action(cloudAction(handleServerAttachToNetwork));
+    server
+        .command("detach-from-network <id-or-name>")
+        .description("Detach server from a network")
+        .requiredOption("--network <network>", "Network ID")
+        .action(cloudAction(handleServerDetachFromNetwork));
+    server
+        .command("add-label <id-or-name> <label>")
+        .description("Add a label (key=value)")
+        .action(cloudAction(handleServerAddLabel));
+    server
+        .command("remove-label <id-or-name> <key>")
+        .description("Remove a label by key")
+        .action(cloudAction(handleServerRemoveLabel));
+}

package/dist/cloud/commands/ssh-key.d.ts

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

package/dist/cloud/commands/ssh-key.js

@@ -0,0 +1,94 @@
+import { readFileSync } from "node:fs";
+import { error, success } from "../../shared/formatter.js";
+import { confirmAction, output } from "../../shared/helpers.js";
+import { formatCloudSshKeyDetails, formatCloudSshKeyList, } from "../formatter.js";
+import { cloudAction, resolveIdOrName, } from "../helpers.js";
+export function registerCloudSshKeyCommands(parent) {
+    const sshKey = parent.command("ssh-key").description("SSH key management");
+    sshKey
+        .command("list")
+        .alias("ls")
+        .description("List all SSH keys")
+        .option("-l, --label-selector <selector>", "Label selector")
+        .option("-s, --sort <field>", "Sort by field")
+        .action(cloudAction(async (client, options) => {
+        const keys = await client.listSshKeys({
+            label_selector: options.labelSelector,
+            sort: options.sort,
+        });
+        output(keys, formatCloudSshKeyList, options);
+    }));
+    sshKey
+        .command("describe <id-or-name>")
+        .description("Show SSH key details")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "SSH key", (name) => client.listSshKeys({ name }));
+        const key = await client.getSshKey(id);
+        output(key, formatCloudSshKeyDetails, options);
+    }));
+    sshKey
+        .command("create")
+        .description("Create an SSH key")
+        .requiredOption("--name <name>", "Key name")
+        .option("--public-key <key>", "Public key string")
+        .option("--public-key-from-file <path>", "Read public key from file")
+        .action(cloudAction(async (client, options) => {
+        let pubKey = options.publicKey;
+        if (options.publicKeyFromFile) {
+            pubKey = readFileSync(options.publicKeyFromFile, "utf-8").trim();
+        }
+        if (!pubKey) {
+            console.error(error("Provide --public-key or --public-key-from-file"));
+            process.exit(1);
+        }
+        const { ssh_key: key } = await client.createSshKey({
+            name: options.name,
+            public_key: pubKey,
+        });
+        console.log(success(`SSH key '${key.name}' created (ID: ${key.id})`));
+    }));
+    sshKey
+        .command("delete <id-or-name>")
+        .description("Delete an SSH key")
+        .option("-y, --yes", "Skip confirmation")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "SSH key", (name) => client.listSshKeys({ name }));
+        const key = await client.getSshKey(id);
+        if (!(await confirmAction(`Delete SSH key '${key.name}' (ID: ${id})?`, options))) {
+            return;
+        }
+        await client.deleteSshKey(id);
+        console.log(success(`SSH key '${key.name}' (ID: ${id}) deleted.`));
+    }));
+    sshKey
+        .command("update <id-or-name>")
+        .description("Update SSH key")
+        .option("--name <name>", "New name")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "SSH key", (name) => client.listSshKeys({ name }));
+        await client.updateSshKey(id, { name: options.name });
+        console.log(success(`SSH key ${id} updated.`));
+    }));
+    sshKey
+        .command("add-label <id-or-name> <label>")
+        .description("Add a label (key=value)")
+        .action(cloudAction(async (client, idOrName, label) => {
+        const id = await resolveIdOrName(idOrName, "SSH key", (name) => client.listSshKeys({ name }));
+        const key = await client.getSshKey(id);
+        const [k, v] = label.split("=");
+        await client.updateSshKey(id, {
+            labels: { ...key.labels, [k]: v || "" },
+        });
+        console.log(success(`Label '${k}' added.`));
+    }));
+    sshKey
+        .command("remove-label <id-or-name> <key>")
+        .description("Remove a label")
+        .action(cloudAction(async (client, idOrName, key) => {
+        const id = await resolveIdOrName(idOrName, "SSH key", (name) => client.listSshKeys({ name }));
+        const sshKeyData = await client.getSshKey(id);
+        const labels = Object.fromEntries(Object.entries(sshKeyData.labels).filter(([k]) => k !== key));
+        await client.updateSshKey(id, { labels });
+        console.log(success(`Label '${key}' removed.`));
+    }));
+}

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

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

package/dist/cloud/commands/volume.js

@@ -0,0 +1,138 @@
+import { success } from "../../shared/formatter.js";
+import { confirmAction, output } from "../../shared/helpers.js";
+import { formatVolumeDetails, formatVolumeList } from "../formatter.js";
+import { cloudAction, resolveIdOrName, } from "../helpers.js";
+export function registerVolumeCommands(parent) {
+    const volume = parent.command("volume").description("Volume management");
+    volume
+        .command("list")
+        .alias("ls")
+        .description("List all volumes")
+        .option("-l, --label-selector <selector>", "Label selector")
+        .option("-s, --sort <field>", "Sort by field")
+        .option("--status <status>", "Filter by status")
+        .action(cloudAction(async (client, options) => {
+        const volumes = await client.listVolumes({
+            label_selector: options.labelSelector,
+            sort: options.sort,
+            status: options.status,
+        });
+        output(volumes, formatVolumeList, options);
+    }));
+    volume
+        .command("describe <id-or-name>")
+        .description("Show volume details")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "volume", (name) => client.listVolumes({ name }));
+        const vol = await client.getVolume(id);
+        output(vol, formatVolumeDetails, options);
+    }));
+    volume
+        .command("create")
+        .description("Create a volume")
+        .requiredOption("--name <name>", "Volume name")
+        .requiredOption("--size <size>", "Size in GB")
+        .option("--location <loc>", "Location")
+        .option("--server <id>", "Server to attach to")
+        .option("--format <format>", "Filesystem format (ext4, xfs)")
+        .option("--automount", "Auto-mount on server")
+        .action(cloudAction(async (client, options) => {
+        const { volume: vol } = await client.createVolume({
+            name: options.name,
+            size: Number.parseInt(options.size, 10),
+            location: options.location,
+            server: options.server
+                ? Number.parseInt(options.server, 10)
+                : undefined,
+            format: options.format,
+            automount: options.automount,
+        });
+        console.log(success(`Volume '${vol.name}' created (ID: ${vol.id}, ${vol.size} GB)`));
+    }));
+    volume
+        .command("delete <id-or-name>")
+        .description("Delete a volume")
+        .option("-y, --yes", "Skip confirmation")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "volume", (name) => client.listVolumes({ name }));
+        const vol = await client.getVolume(id);
+        if (!(await confirmAction(`Delete volume '${vol.name}' (ID: ${id})?`, options))) {
+            return;
+        }
+        await client.deleteVolume(id);
+        console.log(success(`Volume '${vol.name}' (ID: ${id}) deleted.`));
+    }));
+    volume
+        .command("update <id-or-name>")
+        .description("Update volume")
+        .option("--name <name>", "New name")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "volume", (name) => client.listVolumes({ name }));
+        await client.updateVolume(id, { name: options.name });
+        console.log(success(`Volume ${id} updated.`));
+    }));
+    volume
+        .command("attach <id-or-name> <server>")
+        .description("Attach volume to server")
+        .option("--automount", "Auto-mount on server")
+        .action(cloudAction(async (client, idOrName, server, options) => {
+        const id = await resolveIdOrName(idOrName, "volume", (name) => client.listVolumes({ name }));
+        await client.attachVolume(id, Number.parseInt(server, 10), options.automount);
+        console.log(success(`Volume ${id} attached to server ${server}.`));
+    }));
+    volume
+        .command("detach <id-or-name>")
+        .description("Detach volume from server")
+        .action(cloudAction(async (client, idOrName) => {
+        const id = await resolveIdOrName(idOrName, "volume", (name) => client.listVolumes({ name }));
+        await client.detachVolume(id);
+        console.log(success(`Volume ${id} detached.`));
+    }));
+    volume
+        .command("resize <id-or-name>")
+        .description("Resize a volume")
+        .requiredOption("--size <size>", "New size in GB")
+        .action(cloudAction(async (client, idOrName, options) => {
+        const id = await resolveIdOrName(idOrName, "volume", (name) => client.listVolumes({ name }));
+        await client.resizeVolume(id, Number.parseInt(options.size, 10));
+        console.log(success(`Volume ${id} resized to ${options.size} GB.`));
+    }));
+    volume
+        .command("enable-protection <id-or-name>")
+        .description("Enable delete protection")
+        .action(cloudAction(async (client, idOrName) => {
+        const id = await resolveIdOrName(idOrName, "volume", (name) => client.listVolumes({ name }));
+        await client.changeVolumeProtection(id, true);
+        console.log(success(`Protection enabled for volume ${id}.`));
+    }));
+    volume
+        .command("disable-protection <id-or-name>")
+        .description("Disable delete protection")
+        .action(cloudAction(async (client, idOrName) => {
+        const id = await resolveIdOrName(idOrName, "volume", (name) => client.listVolumes({ name }));
+        await client.changeVolumeProtection(id, false);
+        console.log(success(`Protection disabled for volume ${id}.`));
+    }));
+    volume
+        .command("add-label <id-or-name> <label>")
+        .description("Add a label (key=value)")
+        .action(cloudAction(async (client, idOrName, label) => {
+        const id = await resolveIdOrName(idOrName, "volume", (name) => client.listVolumes({ name }));
+        const vol = await client.getVolume(id);
+        const [key, value] = label.split("=");
+        await client.updateVolume(id, {
+            labels: { ...vol.labels, [key]: value || "" },
+        });
+        console.log(success(`Label '${key}' added.`));
+    }));
+    volume
+        .command("remove-label <id-or-name> <key>")
+        .description("Remove a label")
+        .action(cloudAction(async (client, idOrName, key) => {
+        const id = await resolveIdOrName(idOrName, "volume", (name) => client.listVolumes({ name }));
+        const vol = await client.getVolume(id);
+        const labels = Object.fromEntries(Object.entries(vol.labels).filter(([k]) => k !== key));
+        await client.updateVolume(id, { labels });
+        console.log(success(`Label '${key}' removed.`));
+    }));
+}

package/dist/cloud/context.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Create a new cloud context.
+ */
+export declare function createContext(name: string, token: string, options?: {
+    verify?: boolean;
+}): Promise<void>;
+/**
+ * Set the active context.
+ */
+export declare function useContext(name: string): void;
+/**
+ * Delete a context.
+ */
+export declare function deleteContext(name: string): Promise<void>;
+/**
+ * List all contexts.
+ */
+export declare function listContexts(): {
+    name: string;
+    active: boolean;
+}[];
+/**
+ * Get the active context name.
+ */
+export declare function getActiveContext(): string | null;
+/**
+ * Resolve the cloud API token.
+ * Priority: --token flag > HETZNER_CLOUD_TOKEN env > active context
+ */
+export declare function resolveToken(flagToken?: string): Promise<string>;
+/**
+ * Validate that a token authenticates against the Hetzner Cloud API.
+ */
+export declare function validateCloudToken(token: string): Promise<void>;