@rollupdate/hctl 0.0.0-stage → 3.1.0

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

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

package/dist/robot/commands/auth.js

@@ -0,0 +1,54 @@
+import { clearConfig, getCredentials, promptLogin, } from "../../shared/config.js";
+import { info, success, warning } from "../../shared/formatter.js";
+import { asyncAction } from "../../shared/helpers.js";
+export function registerAuthCommands(parent) {
+    const auth = parent.command("auth").description("Authentication management");
+    auth
+        .command("login")
+        .description("Interactively configure credentials")
+        .action(async () => {
+        try {
+            await promptLogin();
+            console.log("");
+            console.log(success("Authentication configured successfully."));
+        }
+        catch (error) {
+            if (error instanceof Error && error.name === "ExitPromptError") {
+                process.exit(0);
+            }
+            throw error;
+        }
+    });
+    auth
+        .command("logout")
+        .description("Clear saved credentials")
+        .action(async () => {
+        await clearConfig();
+        console.log(success("Credentials cleared."));
+    });
+    auth
+        .command("status")
+        .description("Check authentication status")
+        .action(async () => {
+        const creds = await getCredentials();
+        if (creds) {
+            console.log(success(`Authenticated as: ${creds.user}`));
+            const sourceLabels = {
+                environment: "environment variables",
+                keychain: "keychain",
+                file: "config file",
+            };
+            console.log(info(`Stored in: ${sourceLabels[creds.source ?? ""] ?? "unknown"}`));
+        }
+        else {
+            console.log(warning("Not authenticated. Run: hctl auth login"));
+        }
+    });
+    auth
+        .command("test")
+        .description("Test API credentials")
+        .action(asyncAction(async (client) => {
+        const servers = await client.listServers();
+        console.log(success(`Authenticated successfully. Found ${servers.length} server(s).`));
+    }));
+}

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

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

package/dist/robot/commands/boot.js

@@ -0,0 +1,76 @@
+import { heading, info, success } from "../../shared/formatter.js";
+import { asyncAction, output, } from "../../shared/helpers.js";
+import { formatBootConfig, formatLinuxActivation, formatRescueActivation, } from "../formatter.js";
+export function registerBootCommands(parent) {
+    const boot = parent
+        .command("boot")
+        .description("Boot configuration (rescue, linux, vnc, windows)");
+    boot
+        .command("status <server>")
+        .description("Show boot configuration status")
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        const { boot: bootConfig } = await client.getBootConfig(serverIdOrIp);
+        output(bootConfig, (b) => formatBootConfig(b, Number.parseInt(serverIdOrIp, 10) || 0), options);
+    }));
+    const rescue = boot.command("rescue").description("Rescue system management");
+    rescue
+        .command("activate <server>")
+        .description("Activate rescue system")
+        .option("-o, --os <os>", "Operating system (linux, linuxold, vkvm)", "linux")
+        .option("-a, --arch <arch>", "Architecture (64 or 32)", "64")
+        .option("-k, --keys <fingerprints...>", "SSH key fingerprints")
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        const { rescue: rsc } = await client.activateRescue(serverIdOrIp, options.os, Number.parseInt(options.arch, 10), options.keys);
+        console.log(formatRescueActivation(rsc));
+    }));
+    rescue
+        .command("deactivate <server>")
+        .description("Deactivate rescue system")
+        .action(asyncAction(async (client, serverIdOrIp) => {
+        await client.deactivateRescue(serverIdOrIp);
+        console.log(success("Rescue system deactivated."));
+    }));
+    rescue
+        .command("last <server>")
+        .description("Show last rescue activation details")
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        const { rescue: rsc } = await client.getLastRescue(serverIdOrIp);
+        output(rsc, formatRescueActivation, options);
+    }));
+    const linux = boot
+        .command("linux")
+        .description("Linux installation management");
+    linux
+        .command("activate <server>")
+        .description("Activate Linux installation")
+        .requiredOption("-d, --dist <dist>", "Distribution (e.g., Debian-1210-bookworm-amd64-base)")
+        .option("-a, --arch <arch>", "Architecture (64 or 32)", "64")
+        .option("-l, --lang <lang>", "Language", "en")
+        .option("-k, --keys <fingerprints...>", "SSH key fingerprints")
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        const { linux: lnx } = await client.activateLinux(serverIdOrIp, options.dist, Number.parseInt(options.arch, 10), options.lang, options.keys);
+        console.log(formatLinuxActivation(lnx));
+    }));
+    linux
+        .command("deactivate <server>")
+        .description("Deactivate Linux installation")
+        .action(asyncAction(async (client, serverIdOrIp) => {
+        await client.deactivateLinux(serverIdOrIp);
+        console.log(success("Linux installation deactivated."));
+    }));
+    linux
+        .command("options <server>")
+        .description("Show available Linux distributions")
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        const { linux: lnx } = await client.getLinux(serverIdOrIp);
+        output(lnx, (l) => {
+            const lines = [heading("Available Linux Distributions"), ""];
+            for (const dist of l.dist) {
+                lines.push(`  ${dist}`);
+            }
+            lines.push("", info(`Languages: ${l.lang.join(", ")}`));
+            lines.push(info(`Architectures: ${l.arch.join(", ")}-bit`));
+            return lines.join("\n");
+        }, options);
+    }));
+}

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

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

package/dist/robot/commands/cancel.js

@@ -0,0 +1,37 @@
+import { success, warning } from "../../shared/formatter.js";
+import { asyncAction, confirmAction, output, } from "../../shared/helpers.js";
+import { formatCancellation } from "../formatter.js";
+export function registerCancelCommands(parent) {
+    const cancel = parent.command("cancel").description("Server cancellation");
+    cancel
+        .command("status <server>")
+        .description("Get cancellation status")
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        const { cancellation } = await client.getCancellation(serverIdOrIp);
+        output(cancellation, formatCancellation, options);
+    }));
+    cancel
+        .command("request <server>")
+        .description("Request server cancellation")
+        .option("--date <date>", "Cancellation date (YYYY-MM-DD)")
+        .option("--reason <reasons...>", "Cancellation reasons")
+        .option("-y, --yes", "Skip confirmation")
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        if (!options.yes) {
+            console.log(warning("This will cancel your server!"));
+        }
+        if (!(await confirmAction("Are you sure you want to cancel this server?", options))) {
+            return;
+        }
+        const { cancellation } = await client.cancelServer(serverIdOrIp, options.date, options.reason);
+        console.log(success("Cancellation requested."));
+        console.log(formatCancellation(cancellation));
+    }));
+    cancel
+        .command("revoke <server>")
+        .description("Revoke server cancellation")
+        .action(asyncAction(async (client, serverIdOrIp) => {
+        await client.revokeCancellation(serverIdOrIp);
+        console.log(success("Cancellation revoked."));
+    }));
+}

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

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

package/dist/robot/commands/failover.js

@@ -0,0 +1,46 @@
+import { success } from "../../shared/formatter.js";
+import { asyncAction, confirmAction, output, } from "../../shared/helpers.js";
+import { formatFailoverList, formatFailoverSwitch } from "../formatter.js";
+export function registerFailoverCommands(parent) {
+    const failover = parent
+        .command("failover")
+        .description("Failover IP management");
+    failover
+        .command("list")
+        .alias("ls")
+        .description("List all failover IPs")
+        .action(asyncAction(async (client, options) => {
+        const failovers = await client.listFailovers();
+        output(failovers, formatFailoverList, options);
+    }));
+    failover
+        .command("get <ip>")
+        .alias("show")
+        .description("Get failover IP details")
+        .action(asyncAction(async (client, failoverIp, options) => {
+        const { failover: fo } = await client.getFailover(failoverIp);
+        output(fo, (f) => formatFailoverList([{ failover: f }]), options);
+    }));
+    failover
+        .command("switch <failover-ip> <target-server-ip>")
+        .description("Switch failover IP routing to another server")
+        .option("-y, --yes", "Skip confirmation")
+        .action(asyncAction(async (client, failoverIp, targetServerIp, options) => {
+        if (!(await confirmAction(`Route ${failoverIp} to ${targetServerIp}?`, options, true))) {
+            return;
+        }
+        const { failover: fo } = await client.switchFailover(failoverIp, targetServerIp);
+        console.log(formatFailoverSwitch(fo));
+    }));
+    failover
+        .command("delete <ip>")
+        .description("Delete failover IP routing")
+        .option("-y, --yes", "Skip confirmation")
+        .action(asyncAction(async (client, failoverIp, options) => {
+        if (!(await confirmAction(`Delete routing for ${failoverIp}?`, options))) {
+            return;
+        }
+        await client.deleteFailoverRouting(failoverIp);
+        console.log(success("Failover routing deleted."));
+    }));
+}

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

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

package/dist/robot/commands/firewall.js

@@ -0,0 +1,72 @@
+import { success } from "../../shared/formatter.js";
+import { asyncAction, confirmAction, output, } from "../../shared/helpers.js";
+import { formatFirewall, formatFirewallTemplateList } from "../formatter.js";
+export function registerFirewallCommands(parent) {
+    const firewall = parent
+        .command("firewall")
+        .description("Firewall management");
+    firewall
+        .command("get <server>")
+        .alias("show")
+        .description("Get firewall configuration")
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        const { firewall: fw } = await client.getFirewall(serverIdOrIp);
+        output(fw, formatFirewall, options);
+    }));
+    firewall
+        .command("enable <server>")
+        .description("Enable firewall")
+        .action(asyncAction(async (client, serverIdOrIp) => {
+        await client.updateFirewall(serverIdOrIp, "active");
+        console.log(success("Firewall enabled."));
+    }));
+    firewall
+        .command("disable <server>")
+        .description("Disable firewall")
+        .action(asyncAction(async (client, serverIdOrIp) => {
+        await client.updateFirewall(serverIdOrIp, "disabled");
+        console.log(success("Firewall disabled."));
+    }));
+    firewall
+        .command("delete <server>")
+        .description("Delete all firewall rules")
+        .option("-y, --yes", "Skip confirmation")
+        .action(asyncAction(async (client, serverIdOrIp, options) => {
+        if (!(await confirmAction("Delete all firewall rules?", options))) {
+            return;
+        }
+        await client.deleteFirewall(serverIdOrIp);
+        console.log(success("Firewall rules deleted."));
+    }));
+    const fwTemplate = firewall
+        .command("template")
+        .description("Firewall template management");
+    fwTemplate
+        .command("list")
+        .alias("ls")
+        .description("List firewall templates")
+        .action(asyncAction(async (client, options) => {
+        const templates = await client.listFirewallTemplates();
+        output(templates, formatFirewallTemplateList, options);
+    }));
+    fwTemplate
+        .command("get <id>")
+        .alias("show")
+        .description("Get firewall template details")
+        .action(asyncAction(async (client, templateId, options) => {
+        const { firewall_template: tmpl } = await client.getFirewallTemplate(Number.parseInt(templateId, 10));
+        output(tmpl, (t) => formatFirewallTemplateList([{ firewall_template: t }]), options);
+    }));
+    fwTemplate
+        .command("delete <id>")
+        .alias("rm")
+        .description("Delete firewall template")
+        .option("-y, --yes", "Skip confirmation")
+        .action(asyncAction(async (client, templateId, options) => {
+        if (!(await confirmAction(`Delete firewall template ${templateId}?`, options))) {
+            return;
+        }
+        await client.deleteFirewallTemplate(Number.parseInt(templateId, 10));
+        console.log(success("Firewall template deleted."));
+    }));
+}

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

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

package/dist/robot/commands/index.js

@@ -0,0 +1,36 @@
+import { registerAuthCommands } from "./auth.js";
+import { registerBootCommands } from "./boot.js";
+import { registerCancelCommands } from "./cancel.js";
+import { registerFailoverCommands } from "./failover.js";
+import { registerFirewallCommands } from "./firewall.js";
+import { registerInteractiveCommands } from "./interactive.js";
+import { registerIpCommands } from "./ip.js";
+import { registerKeyCommands } from "./key.js";
+import { registerOrderCommands } from "./order.js";
+import { registerRdnsCommands } from "./rdns.js";
+import { registerResetCommands } from "./reset.js";
+import { registerServerCommands } from "./server.js";
+import { registerStorageBoxCommands } from "./storagebox.js";
+import { registerSubnetCommands } from "./subnet.js";
+import { registerTrafficCommands } from "./traffic.js";
+import { registerVSwitchCommands } from "./vswitch.js";
+import { registerWolCommands } from "./wol.js";
+export function registerRobotCommands(parent) {
+    registerAuthCommands(parent);
+    registerServerCommands(parent);
+    registerResetCommands(parent);
+    registerBootCommands(parent);
+    registerIpCommands(parent);
+    registerSubnetCommands(parent);
+    registerFailoverCommands(parent);
+    registerRdnsCommands(parent);
+    registerKeyCommands(parent);
+    registerFirewallCommands(parent);
+    registerVSwitchCommands(parent);
+    registerStorageBoxCommands(parent);
+    registerTrafficCommands(parent);
+    registerWolCommands(parent);
+    registerCancelCommands(parent);
+    registerOrderCommands(parent);
+    registerInteractiveCommands(parent);
+}

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

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

package/dist/robot/commands/interactive.js

@@ -0,0 +1,152 @@
+import { checkbox, confirm, select } from "@inquirer/prompts";
+import { error as fmtError, info } from "../../shared/formatter.js";
+import { asyncAction } from "../../shared/helpers.js";
+import { formatFailoverSwitch, formatRescueActivation, formatResetResult, formatServerList, formatSshKeyList, } from "../formatter.js";
+async function handleServers(client) {
+    const servers = await client.listServers();
+    console.log("");
+    console.log(formatServerList(servers));
+    console.log("");
+}
+async function handleReset(client) {
+    const servers = await client.listServers();
+    if (servers.length === 0) {
+        console.log(info("No servers found."));
+        return false;
+    }
+    const selected = await checkbox({
+        message: "Select servers to reset:",
+        choices: servers.map(({ server }) => ({
+            value: server.server_ip,
+            name: `${server.server_number} - ${server.server_ip} (${server.server_name || "unnamed"})`,
+        })),
+    });
+    if (selected.length === 0) {
+        console.log("No servers selected.");
+        return false;
+    }
+    const resetType = (await select({
+        message: "Select reset type:",
+        choices: [
+            { value: "sw", name: "Software reset (ACPI)" },
+            { value: "hw", name: "Hardware reset (forced)" },
+            { value: "power", name: "Power cycle" },
+        ],
+    }));
+    const confirmed = await confirm({
+        message: `Reset ${selected.length} server(s) with ${resetType}?`,
+        default: false,
+    });
+    if (confirmed) {
+        for (const srv of selected) {
+            try {
+                const { reset: rst } = await client.resetServer(srv, resetType);
+                console.log(formatResetResult(rst, resetType));
+            }
+            catch (err) {
+                console.log(fmtError(`Failed to reset ${srv}: ${err instanceof Error ? err.message : "Unknown"}`));
+            }
+        }
+    }
+    return true;
+}
+async function handleRescue(client) {
+    const servers = await client.listServers();
+    if (servers.length === 0) {
+        console.log(info("No servers found."));
+        return false;
+    }
+    const serverIp = await select({
+        message: "Select server:",
+        choices: servers.map(({ server }) => ({
+            value: server.server_ip,
+            name: `${server.server_number} - ${server.server_ip} (${server.server_name || "unnamed"})`,
+        })),
+    });
+    const os = await select({
+        message: "Select rescue OS:",
+        choices: [
+            { value: "linux", name: "Linux (64-bit)" },
+            { value: "linuxold", name: "Linux (32-bit)" },
+            { value: "vkvm", name: "vKVM" },
+        ],
+    });
+    const { rescue } = await client.activateRescue(serverIp, os, 64);
+    console.log("");
+    console.log(formatRescueActivation(rescue));
+    return true;
+}
+async function handleFailover(client) {
+    const failovers = await client.listFailovers();
+    if (failovers.length === 0) {
+        console.log(info("No failover IPs found."));
+        return false;
+    }
+    const failoverIp = await select({
+        message: "Select failover IP:",
+        choices: failovers.map(({ failover }) => ({
+            value: failover.ip,
+            name: `${failover.ip} -> ${failover.active_server_ip}`,
+        })),
+    });
+    const servers = await client.listServers();
+    const targetIp = await select({
+        message: "Route to server:",
+        choices: servers.map(({ server }) => ({
+            value: server.server_ip,
+            name: `${server.server_number} - ${server.server_ip}`,
+        })),
+    });
+    const { failover: fo } = await client.switchFailover(failoverIp, targetIp);
+    console.log("");
+    console.log(formatFailoverSwitch(fo));
+    return true;
+}
+async function handleKeys(client) {
+    const keys = await client.listSshKeys();
+    console.log("");
+    console.log(formatSshKeyList(keys));
+    console.log("");
+}
+export function registerInteractiveCommands(parent) {
+    parent
+        .command("interactive")
+        .alias("i")
+        .description("Interactive mode for common operations")
+        .action(asyncAction(async (client) => {
+        while (true) {
+            const action = await select({
+                message: "What would you like to do?",
+                choices: [
+                    { value: "servers", name: "List servers" },
+                    { value: "reset", name: "Reset a server" },
+                    { value: "rescue", name: "Activate rescue mode" },
+                    { value: "failover", name: "Switch failover IP" },
+                    { value: "keys", name: "Manage SSH keys" },
+                    { value: "exit", name: "Exit" },
+                ],
+                pageSize: 10,
+            });
+            if (action === "exit") {
+                console.log("Goodbye!");
+                break;
+            }
+            if (action === "servers") {
+                await handleServers(client);
+            }
+            else if (action === "reset") {
+                await handleReset(client);
+            }
+            else if (action === "rescue") {
+                await handleRescue(client);
+            }
+            else if (action === "failover") {
+                await handleFailover(client);
+            }
+            else if (action === "keys") {
+                await handleKeys(client);
+            }
+            console.log("");
+        }
+    }));
+}

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

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

package/dist/robot/commands/ip.js

@@ -0,0 +1,55 @@
+import { success } from "../../shared/formatter.js";
+import { asyncAction, output, } from "../../shared/helpers.js";
+import { formatIpDetails, formatIpList } from "../formatter.js";
+export function registerIpCommands(parent) {
+    const ip = parent
+        .command("ip")
+        .alias("ips")
+        .description("IP address management");
+    ip.command("list")
+        .alias("ls")
+        .description("List all IPs")
+        .action(asyncAction(async (client, options) => {
+        const ips = await client.listIps();
+        output(ips, formatIpList, options);
+    }));
+    ip.command("get <ip>")
+        .alias("show")
+        .description("Get IP details")
+        .action(asyncAction(async (client, ipAddr, options) => {
+        const { ip: ipData } = await client.getIp(ipAddr);
+        output(ipData, formatIpDetails, options);
+    }));
+    ip.command("update <ip>")
+        .description("Update IP traffic warning settings")
+        .option("--warnings <enabled>", "Enable/disable traffic warnings (true/false)")
+        .option("--hourly <mb>", "Hourly traffic limit in MB")
+        .option("--daily <mb>", "Daily traffic limit in MB")
+        .option("--monthly <gb>", "Monthly traffic limit in GB")
+        .action(asyncAction(async (client, ipAddr, options) => {
+        await client.updateIp(ipAddr, options.warnings ? options.warnings === "true" : undefined, options.hourly ? Number.parseInt(options.hourly, 10) : undefined, options.daily ? Number.parseInt(options.daily, 10) : undefined, options.monthly ? Number.parseInt(options.monthly, 10) : undefined);
+        console.log(success(`IP ${ipAddr} updated.`));
+    }));
+    const mac = ip.command("mac").description("MAC address management");
+    mac
+        .command("get <ip>")
+        .description("Get separate MAC address for IP")
+        .action(asyncAction(async (client, ipAddr, options) => {
+        const { mac: macData } = await client.getIpMac(ipAddr);
+        output(macData, (m) => `IP: ${m.ip}\nMAC: ${m.mac}`, options);
+    }));
+    mac
+        .command("generate <ip>")
+        .description("Generate separate MAC address for IP")
+        .action(asyncAction(async (client, ipAddr) => {
+        const { mac: macData } = await client.generateIpMac(ipAddr);
+        console.log(success(`Generated MAC: ${macData.mac}`));
+    }));
+    mac
+        .command("delete <ip>")
+        .description("Delete separate MAC address")
+        .action(asyncAction(async (client, ipAddr) => {
+        await client.deleteIpMac(ipAddr);
+        console.log(success("MAC address deleted."));
+    }));
+}

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

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

package/dist/robot/commands/key.js

@@ -0,0 +1,68 @@
+import { readFileSync } from "node:fs";
+import { input } from "@inquirer/prompts";
+import { success } from "../../shared/formatter.js";
+import { asyncAction, confirmAction, output, } from "../../shared/helpers.js";
+import { formatSshKeyDetails, formatSshKeyList } from "../formatter.js";
+export function registerKeyCommands(parent) {
+    const key = parent
+        .command("key")
+        .alias("keys")
+        .description("SSH key management");
+    key
+        .command("list")
+        .alias("ls")
+        .description("List all SSH keys")
+        .action(asyncAction(async (client, options) => {
+        const keys = await client.listSshKeys();
+        output(keys, formatSshKeyList, options);
+    }));
+    key
+        .command("get <fingerprint>")
+        .alias("show")
+        .description("Get SSH key details")
+        .action(asyncAction(async (client, fingerprint, options) => {
+        const { key: keyData } = await client.getSshKey(fingerprint);
+        output(keyData, formatSshKeyDetails, options);
+    }));
+    key
+        .command("add <name>")
+        .description("Add a new SSH key")
+        .option("-f, --file <path>", "Path to public key file")
+        .option("-d, --data <key>", "Public key data")
+        .action(asyncAction(async (client, name, options) => {
+        let keyData;
+        if (options.file) {
+            keyData = readFileSync(options.file, "utf-8").trim();
+        }
+        else if (options.data) {
+            keyData = options.data;
+        }
+        else {
+            keyData = await input({
+                message: "Paste public key:",
+                validate: (v) => v.length > 0 || "Key data is required",
+            });
+        }
+        const { key: newKey } = await client.createSshKey(name, keyData);
+        console.log(success(`SSH key added: ${newKey.fingerprint}`));
+    }));
+    key
+        .command("rename <fingerprint> <name>")
+        .description("Rename an SSH key")
+        .action(asyncAction(async (client, fingerprint, name) => {
+        await client.updateSshKey(fingerprint, name);
+        console.log(success(`SSH key renamed to: ${name}`));
+    }));
+    key
+        .command("delete <fingerprint>")
+        .alias("rm")
+        .description("Delete an SSH key")
+        .option("-y, --yes", "Skip confirmation")
+        .action(asyncAction(async (client, fingerprint, options) => {
+        if (!(await confirmAction(`Delete SSH key ${fingerprint}?`, options))) {
+            return;
+        }
+        await client.deleteSshKey(fingerprint);
+        console.log(success("SSH key deleted."));
+    }));
+}

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

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