kiwivm-cli 0.1.0 → 0.2.0

package/README.md

@@ -36,7 +36,7 @@ npx kiwivm-cli help
 ## Usage
 
 ```bash
-kiwivm-cli <category> <action> [--flags...]
+kiwivm-cli <command> [<subcommand>] [args...] [--flags...]
 ```
 
 ### Examples
@@ -45,53 +45,79 @@ kiwivm-cli <category> <action> [--flags...]
 # Get service info
 kiwivm-cli info
 
-# Get live service info (CPU, RAM, disk, uptime)
-kiwivm-cli info live
+# Get live status (CPU, RAM, disk, uptime)
+kiwivm-cli status
 
 # Power control
-kiwivm-cli power start
-kiwivm-cli power stop
-kiwivm-cli power restart
-kiwivm-cli power kill
+kiwivm-cli start
+kiwivm-cli stop
+kiwivm-cli restart
+kiwivm-cli kill
 
 # Snapshots
 kiwivm-cli snapshot list
-kiwivm-cli snapshot create --description "before update"
-kiwivm-cli snapshot delete --snapshot vsb1234567890
-kiwivm-cli snapshot restore --snapshot vsb1234567890
-kiwivm-cli snapshot sticky --snapshot vsb1234567890 --sticky 1
-kiwivm-cli snapshot import --source-veid 87654321 --source-token token123
+kiwivm-cli snapshot create --desc "before update"
+kiwivm-cli snapshot delete vsb1234567890
+kiwivm-cli snapshot restore vsb1234567890
+kiwivm-cli snapshot sticky vsb1234567890 --on
+kiwivm-cli snapshot export vsb1234567890
+kiwivm-cli snapshot import 87654321 token123
 
 # Backups
 kiwivm-cli backup list
-kiwivm-cli backup copy --backup-token abc123
+kiwivm-cli backup copy abc123
 
 # System
-kiwivm-cli system hostname --new-hostname my-vps
-kiwivm-cli system rdns --ip 1.2.3.4 --ptr my.domain.com
-kiwivm-cli system password
-kiwivm-cli system sshkey
-kiwivm-cli system sshkey --ssh-keys "ssh-ed25519 AAAAC3..."
-kiwivm-cli system os
-kiwivm-cli system reinstall --os "ubuntu-22.04"
-
-# Network
-kiwivm-cli network ipv6-add
-kiwivm-cli network ipv6-delete --ip 2001:db8::1
-kiwivm-cli network private-list
-kiwivm-cli network private-assign --ip 10.0.0.5
-kiwivm-cli network private-delete --ip 10.0.0.5
-
-# Monitoring
-kiwivm-cli monitoring usage
-kiwivm-cli monitoring audit
-kiwivm-cli monitoring rate-limit
+kiwivm-cli hostname my-vps
+kiwivm-cli password
+
+# SSH keys
+kiwivm-cli ssh-key
+kiwivm-cli ssh-key set "ssh-ed25519 AAAAC3..."
+
+# OS
+kiwivm-cli os list
+kiwivm-cli os reinstall ubuntu-22.04
+
+# rDNS
+kiwivm-cli rdns set 1.2.3.4 my.domain.com
+
+# IPv6
+kiwivm-cli ipv6 add
+kiwivm-cli ipv6 delete 2001:db8::1
+
+# Private IP
+kiwivm-cli private-ip list
+kiwivm-cli private-ip assign 10.0.0.5
+kiwivm-cli private-ip delete 10.0.0.5
+
+# ISO
+kiwivm-cli iso mount ubuntu-22.04-live
+kiwivm-cli iso unmount
+
+# Shell
+kiwivm-cli shell exec "uptime"
+kiwivm-cli shell script "apt update && apt upgrade -y"
+
+# Migrate
+kiwivm-cli migrate locations
+kiwivm-cli migrate start "Las Vegas"
+kiwivm-cli clone 1.2.3.4 "root-pass" --port 22
+
+# Stats
+kiwivm-cli stats usage
+kiwivm-cli stats audit
+kiwivm-cli stats rate-limit
 
 # Admin
-kiwivm-cli admin suspensions
-kiwivm-cli admin unsuspend --record-id 123
-kiwivm-cli admin resolve
-kiwivm-cli admin resolve-violation --record-id 456
+kiwivm-cli suspensions
+kiwivm-cli unsuspend 123
+kiwivm-cli violations
+kiwivm-cli violations resolve 456
+
+# Notifications
+kiwivm-cli notifications
+kiwivm-cli notifications set '{"1":1,"2":0}'
 ```
 
 Output is JSON to stdout. Errors go to stderr with exit code 1.

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";iBAoEe,IAAA,CAAA,GAAI,OAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";iBAwFe,IAAA,CAAA,GAAI,OAAA"}

package/dist/index.mjs

@@ -37,6 +37,288 @@ var KiwiVMClient = class {
 	}
 };
 //#endregion
+//#region src/commands/admin.ts
+async function suspensions(_args, _flags, client) {
+	return client.call("getSuspensionDetails");
+}
+async function unsuspend(args, _flags, client) {
+	const recordId = args[0];
+	if (!recordId) throw new Error("unsuspend requires a <record-id> argument");
+	return client.call("unsuspend", { record_id: recordId });
+}
+async function violationsList(_args, _flags, client) {
+	return client.call("getPolicyViolations");
+}
+async function violationsResolve(args, _flags, client) {
+	const recordId = args[0];
+	if (!recordId) throw new Error("violations resolve requires a <record-id> argument");
+	return client.call("resolvePolicyViolation", { record_id: recordId });
+}
+async function notificationsGet(_args, _flags, client) {
+	return client.call("kiwivm/getNotificationPreferences");
+}
+async function notificationsSet(args, _flags, client) {
+	const prefs = args[0];
+	if (!prefs) throw new Error("notifications set requires a <json> argument");
+	return client.call("kiwivm/setNotificationPreferences", { json_notification_preferences: prefs });
+}
+//#endregion
+//#region src/commands/backup.ts
+async function list$1(_args, _flags, client) {
+	return client.call("backup/list");
+}
+async function copy(args, _flags, client) {
+	const token = args[0];
+	if (!token) throw new Error("backup copy requires a <token> argument");
+	return client.call("backup/copyToSnapshot", { backupToken: token });
+}
+//#endregion
+//#region src/commands/help.ts
+const HELP = `Usage: kiwivm-cli <command> [<subcommand>] [args...] [--flags...]
+
+Auth: --veid <VEID> --api-key <KEY>  (or KIWIVM_VEID / KIWIVM_API_KEY env vars)
+
+Commands:
+
+  start                         Start the VPS
+  stop                          Stop the VPS
+  restart                       Reboot the VPS
+  kill                          Force-stop a stuck VPS
+
+  info                          Get service info (plan, IPs, bandwidth, etc.)
+  status                        Get live status (CPU, RAM, disk, uptime)
+
+  snapshot list                 List all snapshots
+  snapshot create [--desc]      Create a new snapshot
+  snapshot delete <token>       Delete a snapshot
+  snapshot restore <token>      Restore from snapshot
+  snapshot sticky <token>       Toggle sticky (--on | --off)
+  snapshot export <token>       Generate transfer token
+  snapshot import <veid> <token> Import snapshot from another instance
+
+  backup list                   List automatic backups
+  backup copy <token>           Convert backup to restorable snapshot
+
+  os list                       List available OS templates
+  os reinstall <template>       Reinstall OS
+
+  hostname <name>               Set new hostname
+  password                      Reset root password
+
+  ssh-key                       Show SSH keys
+  ssh-key set <keys>            Set SSH keys
+
+  rdns set <ip> <ptr>           Set reverse DNS record
+
+  ipv6 add                      Assign new IPv6 /64 subnet
+  ipv6 delete <subnet>          Release IPv6 subnet
+
+  private-ip list               List available private IPs
+  private-ip assign [<ip>]      Assign private IP (random if omitted)
+  private-ip delete <ip>        Release private IP
+
+  iso mount <name>              Mount ISO for boot (VM must be off)
+  iso unmount                   Unmount ISO, boot from disk
+
+  shell exec <command>          Execute command synchronously
+  shell script <script>         Execute script asynchronously
+
+  migrate locations             List available migration locations
+  migrate start <location>      Start migration to new location
+  clone <ip> <password> [--port] Clone from external server (OVZ only)
+
+  stats usage                   Get detailed usage statistics
+  stats audit                   Get audit log
+  stats rate-limit              Check API rate limit status
+
+  suspensions                   View suspension details
+  unsuspend <record-id>         Clear abuse issue and unsuspend
+  violations                    View policy violations
+  violations resolve <record-id> Resolve policy violation
+
+  notifications                 Get notification preferences
+  notifications set <json>      Update notification preferences
+
+Output: JSON to stdout. Errors to stderr with exit code 1.
+`;
+async function run() {
+	return HELP;
+}
+//#endregion
+//#region src/commands/info.ts
+async function info(_args, _flags, client) {
+	return client.call("getServiceInfo");
+}
+async function status(_args, _flags, client) {
+	return client.call("getLiveServiceInfo");
+}
+//#endregion
+//#region src/commands/iso.ts
+async function mount(args, _flags, client) {
+	const iso = args[0];
+	if (!iso) throw new Error("iso mount requires a <name> argument");
+	return client.call("iso/mount", { iso });
+}
+async function unmount(_args, _flags, client) {
+	return client.call("iso/unmount");
+}
+//#endregion
+//#region src/commands/migrate.ts
+async function locations(_args, _flags, client) {
+	return client.call("migrate/getLocations");
+}
+async function migrateStart(args, _flags, client) {
+	const location = args[0];
+	if (!location) throw new Error("migrate start requires a <location> argument");
+	return client.call("migrate/start", { location });
+}
+async function clone(args, flags, client) {
+	const ip = args[0];
+	const password = args[1];
+	if (!ip || !password) throw new Error("clone requires both <ip> and <password> arguments");
+	return client.call("cloneFromExternalServer", {
+		externalServerIP: ip,
+		externalServerSSHport: flags["port"] || "22",
+		externalServerRootPassword: password
+	});
+}
+//#endregion
+//#region src/commands/network.ts
+async function rdnsSet(args, _flags, client) {
+	const ip = args[0];
+	const ptr = args[1];
+	if (!ip || !ptr) throw new Error("rdns set requires both <ip> and <ptr> arguments");
+	return client.call("setPTR", {
+		ip,
+		ptr
+	});
+}
+async function ipv6Add(_args, _flags, client) {
+	return client.call("ipv6/add");
+}
+async function ipv6Delete(args, _flags, client) {
+	const ip = args[0];
+	if (!ip) throw new Error("ipv6 delete requires a <subnet> argument");
+	return client.call("ipv6/delete", { ip });
+}
+async function privateIpList(_args, _flags, client) {
+	return client.call("privateIp/getAvailableIps");
+}
+async function privateIpAssign(args, _flags, client) {
+	return client.call("privateIp/assign", { ip: args[0] });
+}
+async function privateIpDelete(args, _flags, client) {
+	const ip = args[0];
+	if (!ip) throw new Error("private-ip delete requires an <ip> argument");
+	return client.call("privateIp/delete", { ip });
+}
+//#endregion
+//#region src/commands/power.ts
+async function start(_args, _flags, client) {
+	return client.call("start");
+}
+async function stop(_args, _flags, client) {
+	return client.call("stop");
+}
+async function restart(_args, _flags, client) {
+	return client.call("restart");
+}
+async function kill(_args, _flags, client) {
+	return client.call("kill");
+}
+//#endregion
+//#region src/commands/shell.ts
+async function exec(args, _flags, client) {
+	const command = args[0];
+	if (!command) throw new Error("shell exec requires a <command> argument");
+	return client.call("basicShell/exec", { command });
+}
+async function script(args, _flags, client) {
+	const scriptContent = args[0];
+	if (!scriptContent) throw new Error("shell script requires a <script> argument");
+	return client.call("shellScript/exec", { script: scriptContent });
+}
+//#endregion
+//#region src/commands/snapshot.ts
+async function list(_args, _flags, client) {
+	return client.call("snapshot/list");
+}
+async function create(_args, flags, client) {
+	return client.call("snapshot/create", { description: flags["desc"] || flags["description"] });
+}
+async function deleteSnapshot(args, _flags, client) {
+	const token = args[0];
+	if (!token) throw new Error("snapshot delete requires a <token> argument");
+	return client.call("snapshot/delete", { snapshot: token });
+}
+async function restore(args, _flags, client) {
+	const token = args[0];
+	if (!token) throw new Error("snapshot restore requires a <token> argument");
+	return client.call("snapshot/restore", { snapshot: token });
+}
+async function sticky(args, flags, client) {
+	const token = args[0];
+	if (!token) throw new Error("snapshot sticky requires a <token> argument");
+	if (flags["on"] !== void 0 && flags["off"] !== void 0) throw new Error("snapshot sticky requires exactly one of --on or --off");
+	if (flags["on"] === void 0 && flags["off"] === void 0) throw new Error("snapshot sticky requires exactly one of --on or --off");
+	const stickyVal = flags["on"] !== void 0 ? 1 : 0;
+	return client.call("snapshot/toggleSticky", {
+		snapshot: token,
+		sticky: stickyVal
+	});
+}
+async function exportSnapshot(args, _flags, client) {
+	const token = args[0];
+	if (!token) throw new Error("snapshot export requires a <token> argument");
+	return client.call("snapshot/export", { snapshot: token });
+}
+async function importSnapshot(args, _flags, client) {
+	const sourceVeid = args[0];
+	const sourceToken = args[1];
+	if (!sourceVeid || !sourceToken) throw new Error("snapshot import requires both <sourceVeid> and <sourceToken> arguments");
+	return client.call("snapshot/import", {
+		sourceVeid,
+		sourceToken
+	});
+}
+//#endregion
+//#region src/commands/stats.ts
+async function usage(_args, _flags, client) {
+	return client.call("getRawUsageStats");
+}
+async function audit(_args, _flags, client) {
+	return client.call("getAuditLog");
+}
+async function rateLimit(_args, _flags, client) {
+	return client.call("getRateLimitStatus");
+}
+//#endregion
+//#region src/commands/system.ts
+async function hostname(args, _flags, client) {
+	const name = args[0];
+	if (!name) throw new Error("hostname requires a <name> argument");
+	return client.call("setHostname", { newHostname: name });
+}
+async function password(_args, _flags, client) {
+	return client.call("resetRootPassword");
+}
+async function osList(_args, _flags, client) {
+	return client.call("getAvailableOS");
+}
+async function osReinstall(args, _flags, client) {
+	const os = args[0];
+	if (!os) throw new Error("os reinstall requires a <template> argument");
+	return client.call("reinstallOS", { os });
+}
+async function sshKeyShow(_args, _flags, client) {
+	return client.call("getSshKeys");
+}
+async function sshKeySet(args, _flags, client) {
+	const keys = args[0];
+	if (!keys) throw new Error("ssh-key set requires a <keys> argument");
+	return client.call("updateSshKeys", { ssh_keys: keys });
+}
+//#endregion
 //#region src/index.ts
 function parseFlags(args) {
 	const flags = {};
@@ -56,7 +338,7 @@ function parseFlags(args) {
 				i++;
 			} else {
 				const key = arg.slice(2);
-				flags[toCamelCase(key)] = "";
+				flags[toCamelCase(key)] = "1";
 			}
 		}
 	}
@@ -92,12 +374,9 @@ function getCommandFromArgs(args) {
 }
 async function main() {
 	const { positional, flags } = getCommandFromArgs(process.argv.slice(2));
-	const category = positional[0] ?? "";
-	const action = positional[1] ?? "";
-	if (category === "" || category === "help") {
-		const { run } = await import("./help-Dk-WApoi.mjs");
-		const text = await run();
-		console.log(text);
+	const command = positional[0] ?? "";
+	if (command === "" || command === "help") {
+		console.log(await run());
 		return;
 	}
 	const flagVeid = flags["veid"];
@@ -117,51 +396,92 @@ async function main() {
 	});
 	try {
 		let result;
-		switch (category) {
-			case "power": {
-				const { run } = await import("./power-CDg0Mx1A.mjs");
-				result = await run(action, handlerFlags, client);
-				break;
-			}
-			case "info": {
-				const { run } = await import("./info-DKExtFYH.mjs");
-				result = await run(action, handlerFlags, client);
-				break;
-			}
-			case "snapshot": {
-				const { run } = await import("./snapshot-LO_ufoj5.mjs");
-				result = await run(action, handlerFlags, client);
-				break;
-			}
-			case "backup": {
-				const { run } = await import("./backup-D1UJ4aap.mjs");
-				result = await run(action, handlerFlags, client);
-				break;
-			}
-			case "system": {
-				const { run } = await import("./system-Bl-dsqX9.mjs");
-				result = await run(action, handlerFlags, client);
-				break;
+		const route = {
+			start,
+			stop,
+			restart,
+			kill,
+			info,
+			status,
+			hostname,
+			password,
+			suspensions,
+			unsuspend,
+			clone,
+			snapshot: {
+				list,
+				create,
+				delete: deleteSnapshot,
+				restore,
+				sticky,
+				export: exportSnapshot,
+				import: importSnapshot
+			},
+			backup: {
+				list: list$1,
+				copy
+			},
+			os: {
+				list: osList,
+				reinstall: osReinstall
+			},
+			"ssh-key": {
+				default: sshKeyShow,
+				set: sshKeySet
+			},
+			rdns: { set: rdnsSet },
+			ipv6: {
+				add: ipv6Add,
+				delete: ipv6Delete
+			},
+			"private-ip": {
+				list: privateIpList,
+				assign: privateIpAssign,
+				delete: privateIpDelete
+			},
+			iso: {
+				mount,
+				unmount
+			},
+			shell: {
+				exec,
+				script
+			},
+			migrate: {
+				locations,
+				start: migrateStart
+			},
+			stats: {
+				usage,
+				audit,
+				"rate-limit": rateLimit
+			},
+			violations: {
+				default: violationsList,
+				resolve: violationsResolve
+			},
+			notifications: {
+				default: notificationsGet,
+				set: notificationsSet
 			}
-			case "network": {
-				const { run } = await import("./network-1ycEIJqT.mjs");
-				result = await run(action, handlerFlags, client);
-				break;
-			}
-			case "monitoring": {
-				const { run } = await import("./monitoring-BSuv8fj9.mjs");
-				result = await run(action, handlerFlags, client);
-				break;
-			}
-			case "admin": {
-				const { run } = await import("./admin-fOud1ZmX.mjs");
-				result = await run(action, handlerFlags, client);
-				break;
-			}
-			default:
-				console.error(`Unknown category: ${category}`);
-				console.error("Run 'kiwivm-cli help' for usage.");
+		}[command];
+		if (!route) {
+			console.error(`Unknown command: ${command}`);
+			console.error("Run 'kiwivm-cli help' for usage.");
+			process.exit(1);
+		}
+		if (typeof route === "function") result = await route(positional.slice(1), handlerFlags, client);
+		else {
+			const subcommand = positional[1];
+			let handler;
+			if (subcommand && subcommand in route) handler = route[subcommand];
+			else if (!subcommand && route.default) handler = route.default;
+			if (!handler) {
+				const valid = Object.keys(route).filter((k) => k !== "default").join(", ");
+				console.error(`Unknown subcommand for ${command}: ${subcommand || "(none)"}. Valid: ${valid}`);
 				process.exit(1);
+			}
+			result = await handler(positional.slice(2), handlerFlags, client);
 		}
 		console.log(JSON.stringify(result));
 	} catch (error) {