@rollupdate/hctl 0.0.0-stage → 3.0.0

package/dist/robot/commands/order.js

@@ -0,0 +1,33 @@
+import { asyncAction, output, } from "../../shared/helpers.js";
+import { formatServerMarketProductList, formatServerProductList, formatTransactionList, } from "../formatter.js";
+export function registerOrderCommands(parent) {
+    const order = parent.command("order").description("Server ordering");
+    order
+        .command("products")
+        .description("List available server products")
+        .action(asyncAction(async (client, options) => {
+        const products = await client.listServerProducts();
+        output(products, formatServerProductList, options);
+    }));
+    order
+        .command("market")
+        .description("List server market (auction) products")
+        .action(asyncAction(async (client, options) => {
+        const products = await client.listServerMarketProducts();
+        output(products, formatServerMarketProductList, options);
+    }));
+    order
+        .command("transactions")
+        .description("List order transactions")
+        .action(asyncAction(async (client, options) => {
+        const transactions = await client.listServerTransactions();
+        output(transactions, formatTransactionList, options);
+    }));
+    order
+        .command("transaction <id>")
+        .description("Get order transaction details")
+        .action(asyncAction(async (client, transactionId, options) => {
+        const { transaction } = await client.getServerTransaction(transactionId);
+        output(transaction, (t) => formatTransactionList([{ transaction: t }]), options);
+    }));
+}

package/dist/robot/commands/rdns.d.ts

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

package/dist/robot/commands/rdns.js

@@ -0,0 +1,41 @@
+import { success } from "../../shared/formatter.js";
+import { asyncAction, output, } from "../../shared/helpers.js";
+import { formatRdnsList } from "../formatter.js";
+export function registerRdnsCommands(parent) {
+    const rdns = parent.command("rdns").description("Reverse DNS management");
+    rdns
+        .command("list")
+        .alias("ls")
+        .description("List all reverse DNS entries")
+        .action(asyncAction(async (client, options) => {
+        const entries = await client.listRdns();
+        output(entries, formatRdnsList, options);
+    }));
+    rdns
+        .command("get <ip>")
+        .alias("show")
+        .description("Get reverse DNS entry for IP")
+        .action(asyncAction(async (client, ipAddr, options) => {
+        const { rdns: entry } = await client.getRdns(ipAddr);
+        output(entry, (e) => `IP: ${e.ip}\nPTR: ${e.ptr}`, options);
+    }));
+    rdns
+        .command("set <ip> <ptr>")
+        .description("Create or update reverse DNS entry")
+        .action(asyncAction(async (client, ipAddr, ptr) => {
+        try {
+            await client.createRdns(ipAddr, ptr);
+        }
+        catch {
+            await client.updateRdns(ipAddr, ptr);
+        }
+        console.log(success(`rDNS set: ${ipAddr} -> ${ptr}`));
+    }));
+    rdns
+        .command("delete <ip>")
+        .description("Delete reverse DNS entry")
+        .action(asyncAction(async (client, ipAddr) => {
+        await client.deleteRdns(ipAddr);
+        console.log(success("rDNS entry deleted."));
+    }));
+}

package/dist/robot/commands/reset.d.ts

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

package/dist/robot/commands/reset.js

@@ -0,0 +1,77 @@
+import { confirm, select } from "@inquirer/prompts";
+import { Option } from "commander";
+import { error as fmtError, formatJson, warning, } from "../../shared/formatter.js";
+import { asyncAction, output, } from "../../shared/helpers.js";
+import { formatResetOptions, formatResetResult } from "../formatter.js";
+export function registerResetCommands(parent) {
+    const reset = parent.command("reset").description("Server reset operations");
+    reset
+        .command("options [server]")
+        .description("Show reset options for server(s)")
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        if (serverIdOrIp) {
+            const { reset: rst } = await client.getResetOptions(serverIdOrIp);
+            output(rst, formatResetOptions, options);
+        }
+        else {
+            const resets = await client.listResetOptions();
+            if (options.json) {
+                console.log(formatJson(resets));
+            }
+            else {
+                for (const { reset: rst } of resets) {
+                    console.log(formatResetOptions(rst));
+                    console.log("");
+                }
+            }
+        }
+    }));
+    reset
+        .command("execute <servers...>")
+        .alias("run")
+        .description("Reset one or more servers")
+        .addOption(new Option("-t, --type <type>", "Reset type")
+        .choices(["sw", "hw", "man", "power", "power_long"])
+        .default("sw"))
+        .option("-i, --interactive", "Interactively select reset type")
+        .option("-y, --yes", "Skip confirmation")
+        .action(asyncAction(async (client, servers, options) => {
+        let resetType = options.type;
+        if (options.interactive) {
+            resetType = await select({
+                message: "Select reset type:",
+                choices: [
+                    { value: "sw", name: "Software reset (ACPI) - Recommended" },
+                    { value: "hw", name: "Hardware reset (forced)" },
+                    { value: "power", name: "Power cycle" },
+                    { value: "power_long", name: "Long power cycle (10+ seconds)" },
+                    { value: "man", name: "Manual reset (technician)" },
+                ],
+            });
+        }
+        if (!options.yes) {
+            console.log("");
+            console.log(warning(`About to reset ${servers.length} server(s) with type: ${resetType}`));
+            console.log(`Servers: ${servers.join(", ")}`);
+            console.log("");
+            const confirmed = await confirm({
+                message: "Are you sure you want to proceed?",
+                default: false,
+            });
+            if (!confirmed) {
+                console.log("Aborted.");
+                return;
+            }
+        }
+        console.log("");
+        for (const srv of servers) {
+            try {
+                const { reset: rst } = await client.resetServer(srv, resetType);
+                console.log(formatResetResult(rst, resetType));
+            }
+            catch (error) {
+                console.log(fmtError(`Failed to reset ${srv}: ${error instanceof Error ? error.message : "Unknown error"}`));
+            }
+        }
+    }));
+}

package/dist/robot/commands/server.d.ts

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

package/dist/robot/commands/server.js

@@ -0,0 +1,32 @@
+import { success } from "../../shared/formatter.js";
+import { asyncAction, output, } from "../../shared/helpers.js";
+import { formatServerDetails, formatServerList } from "../formatter.js";
+export function registerServerCommands(parent) {
+    const server = parent
+        .command("server")
+        .alias("servers")
+        .description("Server management");
+    server
+        .command("list")
+        .alias("ls")
+        .description("List all servers")
+        .action(asyncAction(async (client, options) => {
+        const servers = await client.listServers();
+        output(servers, formatServerList, options);
+    }));
+    server
+        .command("get <server>")
+        .alias("show")
+        .description("Get server details")
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        const { server: srv } = await client.getServer(serverIdOrIp);
+        output(srv, formatServerDetails, options);
+    }));
+    server
+        .command("rename <server> <name>")
+        .description("Rename a server")
+        .action(asyncAction(async (client, serverIdOrIp, name) => {
+        await client.updateServerName(serverIdOrIp, name);
+        console.log(success(`Server renamed to: ${name}`));
+    }));
+}

package/dist/robot/commands/storagebox.d.ts

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

package/dist/robot/commands/storagebox.js

@@ -0,0 +1,126 @@
+import { colorize, success, warning } from "../../shared/formatter.js";
+import { asyncAction, confirmAction, output, } from "../../shared/helpers.js";
+import { formatStorageBoxDetails, formatStorageBoxList, formatStorageBoxSnapshots, formatStorageBoxSubaccounts, } from "../formatter.js";
+export function registerStorageBoxCommands(parent) {
+    const storagebox = parent
+        .command("storagebox")
+        .alias("storage")
+        .description("Storage Box management");
+    storagebox
+        .command("list")
+        .alias("ls")
+        .description("List all storage boxes")
+        .action(asyncAction(async (client, options) => {
+        const boxes = await client.listStorageBoxes();
+        output(boxes, formatStorageBoxList, options);
+    }));
+    storagebox
+        .command("get <id>")
+        .alias("show")
+        .description("Get storage box details")
+        .action(asyncAction(async (client, boxId, options) => {
+        const { storagebox: box } = await client.getStorageBox(Number.parseInt(boxId, 10));
+        output(box, formatStorageBoxDetails, options);
+    }));
+    storagebox
+        .command("update <id>")
+        .description("Update storage box settings")
+        .option("-n, --name <name>", "Storage box name")
+        .option("--webdav <enabled>", "Enable/disable WebDAV")
+        .option("--samba <enabled>", "Enable/disable Samba/CIFS")
+        .option("--ssh <enabled>", "Enable/disable SSH/SFTP")
+        .option("--external <enabled>", "Enable/disable external reachability")
+        .option("--zfs <enabled>", "Enable/disable ZFS")
+        .action(asyncAction(async (client, boxId, options) => {
+        await client.updateStorageBox(Number.parseInt(boxId, 10), options.name, options.webdav ? options.webdav === "true" : undefined, options.samba ? options.samba === "true" : undefined, options.ssh ? options.ssh === "true" : undefined, options.external ? options.external === "true" : undefined, options.zfs ? options.zfs === "true" : undefined);
+        console.log(success("Storage box updated."));
+    }));
+    storagebox
+        .command("reset-password <id>")
+        .description("Reset storage box password")
+        .action(asyncAction(async (client, boxId) => {
+        const { password } = await client.resetStorageBoxPassword(Number.parseInt(boxId, 10));
+        console.log(success("Password reset."));
+        console.log(`New password: ${colorize(password, "yellow")}`);
+    }));
+    const snapshot = storagebox
+        .command("snapshot")
+        .description("Storage box snapshot management");
+    snapshot
+        .command("list <box-id>")
+        .alias("ls")
+        .description("List storage box snapshots")
+        .action(asyncAction(async (client, boxId, options) => {
+        const snapshots = await client.listStorageBoxSnapshots(Number.parseInt(boxId, 10));
+        output(snapshots, formatStorageBoxSnapshots, options);
+    }));
+    snapshot
+        .command("create <box-id>")
+        .description("Create a new snapshot")
+        .action(asyncAction(async (client, boxId) => {
+        const { snapshot: snap } = await client.createStorageBoxSnapshot(Number.parseInt(boxId, 10));
+        console.log(success(`Snapshot created: ${snap.name}`));
+    }));
+    snapshot
+        .command("delete <box-id> <name>")
+        .alias("rm")
+        .description("Delete a snapshot")
+        .option("-y, --yes", "Skip confirmation")
+        .action(asyncAction(async (client, boxId, snapshotName, options) => {
+        if (!(await confirmAction(`Delete snapshot ${snapshotName}?`, options))) {
+            return;
+        }
+        await client.deleteStorageBoxSnapshot(Number.parseInt(boxId, 10), snapshotName);
+        console.log(success("Snapshot deleted."));
+    }));
+    snapshot
+        .command("revert <box-id> <name>")
+        .description("Revert to a snapshot")
+        .option("-y, --yes", "Skip confirmation")
+        .action(asyncAction(async (client, boxId, snapshotName, options) => {
+        if (!options.yes) {
+            console.log(warning("This will revert your storage box to the snapshot state."));
+        }
+        if (!(await confirmAction(`Revert to snapshot ${snapshotName}?`, options))) {
+            return;
+        }
+        await client.revertStorageBoxSnapshot(Number.parseInt(boxId, 10), snapshotName);
+        console.log(success("Reverted to snapshot."));
+    }));
+    const subaccount = storagebox
+        .command("subaccount")
+        .description("Storage box subaccount management");
+    subaccount
+        .command("list <box-id>")
+        .alias("ls")
+        .description("List storage box subaccounts")
+        .action(asyncAction(async (client, boxId, options) => {
+        const subaccounts = await client.listStorageBoxSubaccounts(Number.parseInt(boxId, 10));
+        output(subaccounts, formatStorageBoxSubaccounts, options);
+    }));
+    subaccount
+        .command("create <box-id> <home-directory>")
+        .description("Create a new subaccount")
+        .option("--samba <enabled>", "Enable Samba")
+        .option("--ssh <enabled>", "Enable SSH")
+        .option("--webdav <enabled>", "Enable WebDAV")
+        .option("--external <enabled>", "Enable external reachability")
+        .option("--readonly <enabled>", "Read-only access")
+        .option("--comment <comment>", "Comment")
+        .action(asyncAction(async (client, boxId, homeDir, options) => {
+        const { subaccount: sub } = await client.createStorageBoxSubaccount(Number.parseInt(boxId, 10), homeDir, options.samba ? options.samba === "true" : undefined, options.ssh ? options.ssh === "true" : undefined, options.external ? options.external === "true" : undefined, options.webdav ? options.webdav === "true" : undefined, options.readonly ? options.readonly === "true" : undefined, options.comment);
+        console.log(success(`Subaccount created: ${sub.username}`));
+    }));
+    subaccount
+        .command("delete <box-id> <username>")
+        .alias("rm")
+        .description("Delete a subaccount")
+        .option("-y, --yes", "Skip confirmation")
+        .action(asyncAction(async (client, boxId, username, options) => {
+        if (!(await confirmAction(`Delete subaccount ${username}?`, options))) {
+            return;
+        }
+        await client.deleteStorageBoxSubaccount(Number.parseInt(boxId, 10), username);
+        console.log(success("Subaccount deleted."));
+    }));
+}

package/dist/robot/commands/subnet.d.ts

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

package/dist/robot/commands/subnet.js

@@ -0,0 +1,24 @@
+import { asyncAction, output, } from "../../shared/helpers.js";
+import { formatSubnetList } from "../formatter.js";
+export function registerSubnetCommands(parent) {
+    const subnet = parent
+        .command("subnet")
+        .alias("subnets")
+        .description("Subnet management");
+    subnet
+        .command("list")
+        .alias("ls")
+        .description("List all subnets")
+        .action(asyncAction(async (client, options) => {
+        const subnets = await client.listSubnets();
+        output(subnets, formatSubnetList, options);
+    }));
+    subnet
+        .command("get <subnet>")
+        .alias("show")
+        .description("Get subnet details")
+        .action(asyncAction(async (client, netIp, options) => {
+        const { subnet: subnetData } = await client.getSubnet(netIp);
+        output(subnetData, (s) => formatSubnetList([{ subnet: s }]), options);
+    }));
+}

package/dist/robot/commands/traffic.d.ts

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

package/dist/robot/commands/traffic.js

@@ -0,0 +1,23 @@
+import { asyncAction, output, } from "../../shared/helpers.js";
+import { formatTraffic } from "../formatter.js";
+export function registerTrafficCommands(parent) {
+    const traffic = parent.command("traffic").description("Traffic analytics");
+    traffic
+        .command("query")
+        .description("Query traffic data")
+        .option("-i, --ip <ips...>", "IP addresses to query")
+        .option("-s, --subnet <subnets...>", "Subnets to query")
+        .option("--from <date>", "Start date (YYYY-MM-DD)")
+        .option("--to <date>", "End date (YYYY-MM-DD)")
+        .option("-t, --type <type>", "Query type (day, month, year)", "month")
+        .action(asyncAction(async (client, options) => {
+        const now = new Date();
+        const from = options.from ||
+            new Date(now.getFullYear(), now.getMonth(), 1)
+                .toISOString()
+                .split("T")[0];
+        const to = options.to || now.toISOString().split("T")[0];
+        const { traffic: trafficData } = await client.getTraffic(options.ip || [], options.subnet || [], from, to, options.type);
+        output(trafficData, formatTraffic, options);
+    }));
+}

package/dist/robot/commands/vswitch.d.ts

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

package/dist/robot/commands/vswitch.js

@@ -0,0 +1,65 @@
+import { success } from "../../shared/formatter.js";
+import { asyncAction, confirmAction, output, } from "../../shared/helpers.js";
+import { formatVSwitchDetails, formatVSwitchList } from "../formatter.js";
+export function registerVSwitchCommands(parent) {
+    const vswitch = parent.command("vswitch").description("vSwitch management");
+    vswitch
+        .command("list")
+        .alias("ls")
+        .description("List all vSwitches")
+        .action(asyncAction(async (client, options) => {
+        const vswitches = await client.listVSwitches();
+        output(vswitches, formatVSwitchList, options);
+    }));
+    vswitch
+        .command("get <id>")
+        .alias("show")
+        .description("Get vSwitch details")
+        .action(asyncAction(async (client, vswitchId, options) => {
+        const vs = await client.getVSwitch(Number.parseInt(vswitchId, 10));
+        output(vs, formatVSwitchDetails, options);
+    }));
+    vswitch
+        .command("create <name> <vlan>")
+        .description("Create a new vSwitch")
+        .action(asyncAction(async (client, name, vlan) => {
+        const vs = await client.createVSwitch(name, Number.parseInt(vlan, 10));
+        console.log(success(`vSwitch created: ID ${vs.id}`));
+    }));
+    vswitch
+        .command("update <id>")
+        .description("Update vSwitch")
+        .option("-n, --name <name>", "New name")
+        .option("-v, --vlan <vlan>", "New VLAN ID")
+        .action(asyncAction(async (client, vswitchId, options) => {
+        await client.updateVSwitch(Number.parseInt(vswitchId, 10), options.name, options.vlan ? Number.parseInt(options.vlan, 10) : undefined);
+        console.log(success("vSwitch updated."));
+    }));
+    vswitch
+        .command("delete <id>")
+        .alias("rm")
+        .description("Delete vSwitch")
+        .option("-y, --yes", "Skip confirmation")
+        .option("--date <date>", "Cancellation date (YYYY-MM-DD)")
+        .action(asyncAction(async (client, vswitchId, options) => {
+        if (!(await confirmAction(`Delete vSwitch ${vswitchId}?`, options))) {
+            return;
+        }
+        await client.deleteVSwitch(Number.parseInt(vswitchId, 10), options.date);
+        console.log(success("vSwitch deleted."));
+    }));
+    vswitch
+        .command("add-server <vswitch-id> <server>")
+        .description("Add server to vSwitch")
+        .action(asyncAction(async (client, vswitchId, serverIdOrIp) => {
+        await client.addServerToVSwitch(Number.parseInt(vswitchId, 10), serverIdOrIp);
+        console.log(success("Server added to vSwitch."));
+    }));
+    vswitch
+        .command("remove-server <vswitch-id> <server>")
+        .description("Remove server from vSwitch")
+        .action(asyncAction(async (client, vswitchId, serverIdOrIp) => {
+        await client.removeServerFromVSwitch(Number.parseInt(vswitchId, 10), serverIdOrIp);
+        console.log(success("Server removed from vSwitch."));
+    }));
+}

package/dist/robot/commands/wol.d.ts

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

package/dist/robot/commands/wol.js

@@ -0,0 +1,20 @@
+import { info } from "../../shared/formatter.js";
+import { asyncAction, output, } from "../../shared/helpers.js";
+import { formatWolResult } from "../formatter.js";
+export function registerWolCommands(parent) {
+    const wol = parent.command("wol").description("Wake on LAN");
+    wol
+        .command("status <server>")
+        .description("Check WoL status for server")
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        const { wol: wolData } = await client.getWol(serverIdOrIp);
+        output(wolData, (w) => `Server: ${w.server_number} (${w.server_ip})\n${info("Wake on LAN is available for this server.")}`, options);
+    }));
+    wol
+        .command("send <server>")
+        .description("Send Wake on LAN packet")
+        .action(asyncAction(async (client, serverIdOrIp) => {
+        const { wol: wolData } = await client.sendWol(serverIdOrIp);
+        console.log(formatWolResult(wolData));
+    }));
+}

package/dist/robot/formatter.d.ts

@@ -0,0 +1,56 @@
+import type { BootConfig, Cancellation, Failover, Firewall, FirewallTemplate, IP, LinuxConfig, Rdns, RescueConfig, Reset, Server, ServerDetails, ServerMarketProduct, ServerProduct, ServerTransaction, SshKey, StorageBox, StorageBoxSnapshot, StorageBoxSubaccount, Subnet, Traffic, VSwitch, VSwitchSummary, Wol } from "./types.js";
+export declare function formatServerList(servers: {
+    server: Server;
+}[]): string;
+export declare function formatServerDetails(server: ServerDetails): string;
+export declare function formatResetOptions(reset: Reset): string;
+export declare function formatResetResult(reset: Reset, type: string): string;
+export declare function formatBootConfig(config: BootConfig, serverNumber: number): string;
+export declare function formatRescueActivation(rescue: RescueConfig): string;
+export declare function formatLinuxActivation(linux: LinuxConfig): string;
+export declare function formatIpList(ips: {
+    ip: IP;
+}[]): string;
+export declare function formatIpDetails(ip: IP): string;
+export declare function formatSubnetList(subnets: {
+    subnet: Subnet;
+}[]): string;
+export declare function formatFailoverList(failovers: {
+    failover: Failover;
+}[]): string;
+export declare function formatFailoverSwitch(failover: Failover): string;
+export declare function formatRdnsList(entries: {
+    rdns: Rdns;
+}[]): string;
+export declare function formatSshKeyList(keys: {
+    key: SshKey;
+}[]): string;
+export declare function formatSshKeyDetails(key: SshKey): string;
+export declare function formatFirewall(firewall: Firewall): string;
+export declare function formatFirewallTemplateList(templates: {
+    firewall_template: FirewallTemplate;
+}[]): string;
+export declare function formatVSwitchList(vswitches: VSwitchSummary[]): string;
+export declare function formatVSwitchDetails(vswitch: VSwitch): string;
+export declare function formatStorageBoxList(boxes: {
+    storagebox: StorageBox;
+}[]): string;
+export declare function formatStorageBoxDetails(box: StorageBox): string;
+export declare function formatStorageBoxSnapshots(snapshots: {
+    snapshot: StorageBoxSnapshot;
+}[]): string;
+export declare function formatStorageBoxSubaccounts(subaccounts: {
+    subaccount: StorageBoxSubaccount;
+}[]): string;
+export declare function formatTraffic(traffic: Traffic): string;
+export declare function formatWolResult(wol: Wol): string;
+export declare function formatServerProductList(products: {
+    product: ServerProduct;
+}[]): string;
+export declare function formatServerMarketProductList(products: {
+    product: ServerMarketProduct;
+}[]): string;
+export declare function formatTransactionList(transactions: {
+    transaction: ServerTransaction;
+}[]): string;
+export declare function formatCancellation(cancellation: Cancellation): string;