kiwivm-cli 0.1.0 → 0.2.0

package/src/commands/snapshot.ts

@@ -1,40 +1,92 @@
 import type { KiwiVMClient } from "../client.ts";
-import type { KiwiVMResponse, Snapshot } from "../types.ts";
 
-export async function run(
-  action: string,
+export async function list(
+  _args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  return client.call("snapshot/list");
+}
+
+export async function create(
+  _args: string[],
   flags: Record<string, string>,
   client: KiwiVMClient,
 ): Promise<unknown> {
-  switch (action) {
-    case "create":
-      return client.call("snapshot/create", {
-        description: flags["description"],
-      });
-    case "list":
-      return client.call<KiwiVMResponse & { snapshots: Snapshot[] }>(
-        "snapshot/list",
-      );
-    case "delete":
-      return client.call("snapshot/delete", { snapshot: flags["snapshot"] });
-    case "restore":
-      return client.call("snapshot/restore", { snapshot: flags["snapshot"] });
-    case "sticky":
-      return client.call("snapshot/toggleSticky", {
-        snapshot: flags["snapshot"],
-        sticky:
-          flags["sticky"] !== undefined ? Number(flags["sticky"]) : undefined,
-      });
-    case "export":
-      return client.call("snapshot/export", { snapshot: flags["snapshot"] });
-    case "import":
-      return client.call("snapshot/import", {
-        sourceVeid: flags["sourceVeid"],
-        sourceToken: flags["sourceToken"],
-      });
-    default:
-      throw new Error(
-        `Unknown snapshot action: ${action}. Valid: create, list, delete, restore, sticky, export, import`,
-      );
+  return client.call("snapshot/create", {
+    description: flags["desc"] || flags["description"],
+  });
+}
+
+export async function deleteSnapshot(
+  args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  const token = args[0];
+  if (!token) {
+    throw new Error("snapshot delete requires a <token> argument");
+  }
+  return client.call("snapshot/delete", { snapshot: token });
+}
+
+export async function restore(
+  args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  const token = args[0];
+  if (!token) {
+    throw new Error("snapshot restore requires a <token> argument");
+  }
+  return client.call("snapshot/restore", { snapshot: token });
+}
+
+export async function sticky(
+  args: string[],
+  flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  const token = args[0];
+  if (!token) {
+    throw new Error("snapshot sticky requires a <token> argument");
+  }
+  if (flags["on"] !== undefined && flags["off"] !== undefined) {
+    throw new Error("snapshot sticky requires exactly one of --on or --off");
+  }
+  if (flags["on"] === undefined && flags["off"] === undefined) {
+    throw new Error("snapshot sticky requires exactly one of --on or --off");
+  }
+  const stickyVal = flags["on"] !== undefined ? 1 : 0;
+  return client.call("snapshot/toggleSticky", {
+    snapshot: token,
+    sticky: stickyVal,
+  });
+}
+
+export async function exportSnapshot(
+  args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  const token = args[0];
+  if (!token) {
+    throw new Error("snapshot export requires a <token> argument");
+  }
+  return client.call("snapshot/export", { snapshot: token });
+}
+
+export async function importSnapshot(
+  args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  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 });
 }

package/src/commands/stats.test.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it, vi } from "vitest";
+import type { KiwiVMClient } from "../client.ts";
+import { audit, rateLimit, usage } from "./stats.ts";
+
+function mockClient() {
+  const call = vi.fn();
+  return { client: { call } as unknown as KiwiVMClient, call };
+}
+
+describe("stats handlers", () => {
+  describe("usage", () => {
+    it("calls getRawUsageStats", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({
+        error: 0,
+        data: [{ month: "2025-01", usage: 100 }],
+      });
+
+      const result = await usage([], {}, client);
+
+      expect(call).toHaveBeenCalledExactlyOnceWith("getRawUsageStats");
+      expect(result).toMatchObject({
+        data: [{ month: "2025-01", usage: 100 }],
+      });
+    });
+
+    it("propagates errors from the client", async () => {
+      const { client, call } = mockClient();
+      call.mockRejectedValueOnce(new Error("API failure"));
+
+      await expect(usage([], {}, client)).rejects.toThrow("API failure");
+    });
+  });
+
+  describe("audit", () => {
+    it("calls getAuditLog", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({
+        error: 0,
+        logs: [{ timestamp: 1700000000, action: "restart" }],
+      });
+
+      const result = await audit([], {}, client);
+
+      expect(call).toHaveBeenCalledExactlyOnceWith("getAuditLog");
+      expect(result).toMatchObject({
+        logs: [{ timestamp: 1700000000, action: "restart" }],
+      });
+    });
+
+    it("propagates errors from the client", async () => {
+      const { client, call } = mockClient();
+      call.mockRejectedValueOnce(new Error("API failure"));
+
+      await expect(audit([], {}, client)).rejects.toThrow("API failure");
+    });
+  });
+
+  describe("rateLimit", () => {
+    it("calls getRateLimitStatus", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({
+        error: 0,
+        remaining: 950,
+        limit: 1000,
+      });
+
+      const result = await rateLimit([], {}, client);
+
+      expect(call).toHaveBeenCalledExactlyOnceWith("getRateLimitStatus");
+      expect(result).toMatchObject({ remaining: 950, limit: 1000 });
+    });
+
+    it("propagates errors from the client", async () => {
+      const { client, call } = mockClient();
+      call.mockRejectedValueOnce(new Error("Rate limited"));
+
+      await expect(rateLimit([], {}, client)).rejects.toThrow("Rate limited");
+    });
+  });
+});

package/src/commands/stats.ts

@@ -0,0 +1,25 @@
+import type { KiwiVMClient } from "../client.ts";
+
+export async function usage(
+  _args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  return client.call("getRawUsageStats");
+}
+
+export async function audit(
+  _args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  return client.call("getAuditLog");
+}
+
+export async function rateLimit(
+  _args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  return client.call("getRateLimitStatus");
+}

package/src/commands/system.test.ts

@@ -1,37 +1,45 @@
 import { describe, expect, it, vi } from "vitest";
 import type { KiwiVMClient } from "../client.ts";
-import { run } from "./system.ts";
+import {
+  hostname,
+  osList,
+  osReinstall,
+  password,
+  sshKeySet,
+  sshKeyShow,
+} from "./system.ts";
 
 function mockClient() {
   const call = vi.fn();
   return { client: { call } as unknown as KiwiVMClient, call };
 }
 
-describe("system command", () => {
+describe("system handlers", () => {
   describe("hostname", () => {
-    it("calls setHostname with new-hostname flag", async () => {
+    it("calls setHostname with newHostname from args", async () => {
       const { client, call } = mockClient();
       call.mockResolvedValueOnce({ error: 0 });
 
-      await run("hostname", { newHostname: "my-vps.example.com" }, client);
+      await hostname(["my-vps"], {}, client);
 
-      expect(client.call).toHaveBeenCalledExactlyOnceWith("setHostname", {
-        newHostname: "my-vps.example.com",
+      expect(call).toHaveBeenCalledExactlyOnceWith("setHostname", {
+        newHostname: "my-vps",
       });
     });
-  });
 
-  describe("rdns", () => {
-    it("calls setPTR with ip and ptr flags", async () => {
-      const { client, call } = mockClient();
-      call.mockResolvedValueOnce({ error: 0 });
+    it("throws when no hostname provided", async () => {
+      const { client } = mockClient();
 
-      await run("rdns", { ip: "1.2.3.4", ptr: "my-vps.example.com" }, client);
+      await expect(hostname([], {}, client)).rejects.toThrow("hostname");
+    });
 
-      expect(client.call).toHaveBeenCalledExactlyOnceWith("setPTR", {
-        ip: "1.2.3.4",
-        ptr: "my-vps.example.com",
-      });
+    it("propagates errors from the client", async () => {
+      const { client, call } = mockClient();
+      call.mockRejectedValueOnce(new Error("Invalid hostname"));
+
+      await expect(hostname(["my-vps"], {}, client)).rejects.toThrow(
+        "Invalid hostname",
+      );
     });
   });
 
@@ -41,58 +49,119 @@ describe("system command", () => {
       const pwResponse = { error: 0, message: "Password reset successfully" };
       call.mockResolvedValueOnce(pwResponse);
 
-      const result = await run("password", {}, client);
+      const result = await password([], {}, client);
 
-      expect(client.call).toHaveBeenCalledExactlyOnceWith("resetRootPassword");
+      expect(call).toHaveBeenCalledExactlyOnceWith("resetRootPassword");
       expect(result).toEqual(pwResponse);
     });
+
+    it("propagates errors from the client", async () => {
+      const { client, call } = mockClient();
+      call.mockRejectedValueOnce(new Error("API failure"));
+
+      await expect(password([], {}, client)).rejects.toThrow("API failure");
+    });
   });
 
-  describe("sshkey", () => {
-    it("calls getSshKeys when --ssh-keys flag is not provided", async () => {
+  describe("osList", () => {
+    it("calls getAvailableOS", async () => {
       const { client, call } = mockClient();
       call.mockResolvedValueOnce({
         error: 0,
-        sshKeys: ["ssh-rsa AAA..."],
+        templates: ["ubuntu-22.04", "debian-12"],
       });
 
-      const result = await run("sshkey", {}, client);
+      const result = await osList([], {}, client);
 
-      expect(client.call).toHaveBeenCalledExactlyOnceWith("getSshKeys");
-      expect(result).toMatchObject({ sshKeys: ["ssh-rsa AAA..."] });
+      expect(call).toHaveBeenCalledExactlyOnceWith("getAvailableOS");
+      expect(result).toMatchObject({
+        templates: ["ubuntu-22.04", "debian-12"],
+      });
+    });
+
+    it("propagates errors from the client", async () => {
+      const { client, call } = mockClient();
+      call.mockRejectedValueOnce(new Error("API failure"));
+
+      await expect(osList([], {}, client)).rejects.toThrow("API failure");
     });
+  });
 
-    it("calls updateSshKeys when --ssh-keys flag is provided", async () => {
+  describe("osReinstall", () => {
+    it("calls reinstallOS with os from args", async () => {
       const { client, call } = mockClient();
       call.mockResolvedValueOnce({ error: 0 });
 
-      await run("sshkey", { sshKeys: "ssh-rsa AAA..." }, client);
+      await osReinstall(["ubuntu-22.04"], {}, client);
 
-      expect(client.call).toHaveBeenCalledExactlyOnceWith("updateSshKeys", {
-        sshKeys: "ssh-rsa AAA...",
+      expect(call).toHaveBeenCalledExactlyOnceWith("reinstallOS", {
+        os: "ubuntu-22.04",
       });
     });
+
+    it("throws when no OS provided", async () => {
+      const { client } = mockClient();
+
+      await expect(osReinstall([], {}, client)).rejects.toThrow("os");
+    });
+
+    it("propagates errors from the client", async () => {
+      const { client, call } = mockClient();
+      call.mockRejectedValueOnce(new Error("Invalid OS"));
+
+      await expect(osReinstall(["ubuntu-22.04"], {}, client)).rejects.toThrow(
+        "Invalid OS",
+      );
+    });
+  });
+
+  describe("sshKeyShow", () => {
+    it("calls getSshKeys", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({
+        error: 0,
+        sshKeys: ["ssh-rsa AAA..."],
+      });
+
+      const result = await sshKeyShow([], {}, client);
+
+      expect(call).toHaveBeenCalledExactlyOnceWith("getSshKeys");
+      expect(result).toMatchObject({ sshKeys: ["ssh-rsa AAA..."] });
+    });
+
+    it("propagates errors from the client", async () => {
+      const { client, call } = mockClient();
+      call.mockRejectedValueOnce(new Error("API failure"));
+
+      await expect(sshKeyShow([], {}, client)).rejects.toThrow("API failure");
+    });
   });
 
-  describe("reinstall", () => {
-    it("calls reinstallOS with os flag", async () => {
+  describe("sshKeySet", () => {
+    it("calls updateSshKeys with sshKey from args", async () => {
       const { client, call } = mockClient();
       call.mockResolvedValueOnce({ error: 0 });
 
-      await run("reinstall", { os: "ubuntu-22.04" }, client);
+      await sshKeySet(["ssh-ed25519 AAAAC3..."], {}, client);
 
-      expect(client.call).toHaveBeenCalledExactlyOnceWith("reinstallOS", {
-        os: "ubuntu-22.04",
+      expect(call).toHaveBeenCalledExactlyOnceWith("updateSshKeys", {
+        ssh_keys: "ssh-ed25519 AAAAC3...",
       });
     });
-  });
 
-  it("propagates errors from the client", async () => {
-    const { client, call } = mockClient();
-    call.mockRejectedValueOnce(new Error("Invalid hostname"));
+    it("throws when no SSH key provided", async () => {
+      const { client } = mockClient();
+
+      await expect(sshKeySet([], {}, client)).rejects.toThrow(/keys/);
+    });
+
+    it("propagates errors from the client", async () => {
+      const { client, call } = mockClient();
+      call.mockRejectedValueOnce(new Error("API failure"));
 
-    await expect(run("hostname", { newHostname: "" }, client)).rejects.toThrow(
-      "Invalid hostname",
-    );
+      await expect(
+        sshKeySet(["ssh-ed25519 AAAAC3..."], {}, client),
+      ).rejects.toThrow("API failure");
+    });
   });
 });

package/src/commands/system.ts

@@ -1,29 +1,61 @@
 import type { KiwiVMClient } from "../client.ts";
 
-export async function run(
-  action: string,
-  flags: Record<string, string>,
+export async function hostname(
+  args: string[],
+  _flags: Record<string, string>,
   client: KiwiVMClient,
 ): Promise<unknown> {
-  switch (action) {
-    case "hostname":
-      return client.call("setHostname", { newHostname: flags["newHostname"] });
-    case "rdns":
-      return client.call("setPTR", { ip: flags["ip"], ptr: flags["ptr"] });
-    case "password":
-      return client.call("resetRootPassword");
-    case "sshkey":
-      if (flags["sshKeys"] !== undefined) {
-        return client.call("updateSshKeys", { sshKeys: flags["sshKeys"] });
-      }
-      return client.call("getSshKeys");
-    case "os":
-      return client.call("getAvailableOS");
-    case "reinstall":
-      return client.call("reinstallOS", { os: flags["os"] });
-    default:
-      throw new Error(
-        `Unknown system action: ${action}. Valid: hostname, rdns, password, sshkey, os, reinstall`,
-      );
+  const name = args[0];
+  if (!name) {
+    throw new Error("hostname requires a <name> argument");
   }
+  return client.call("setHostname", { newHostname: name });
+}
+
+export async function password(
+  _args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  return client.call("resetRootPassword");
+}
+
+export async function osList(
+  _args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  return client.call("getAvailableOS");
+}
+
+export async function osReinstall(
+  args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  const os = args[0];
+  if (!os) {
+    throw new Error("os reinstall requires a <template> argument");
+  }
+  return client.call("reinstallOS", { os });
+}
+
+export async function sshKeyShow(
+  _args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  return client.call("getSshKeys");
+}
+
+export async function sshKeySet(
+  args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  const keys = args[0];
+  if (!keys) {
+    throw new Error("ssh-key set requires a <keys> argument");
+  }
+  return client.call("updateSshKeys", { ssh_keys: keys });
 }