kiwivm-cli 0.1.0

package/src/commands/network.ts

@@ -0,0 +1,24 @@
+import type { KiwiVMClient } from "../client.ts";
+
+export async function run(
+  action: string,
+  flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  switch (action) {
+    case "ipv6-add":
+      return client.call("ipv6/add");
+    case "ipv6-delete":
+      return client.call("ipv6/delete", { ip: flags["ip"] });
+    case "private-list":
+      return client.call("privateIp/getAvailableIps");
+    case "private-assign":
+      return client.call("privateIp/assign", { ip: flags["ip"] });
+    case "private-delete":
+      return client.call("privateIp/delete", { ip: flags["ip"] });
+    default:
+      throw new Error(
+        `Unknown network action: ${action}. Valid: ipv6-add, ipv6-delete, private-list, private-assign, private-delete`,
+      );
+  }
+}

package/src/commands/power.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, it, vi } from "vitest";
+import type { KiwiVMClient } from "../client.ts";
+import { run } from "./power.ts";
+
+function mockClient() {
+  const call = vi.fn();
+  return { client: { call } as unknown as KiwiVMClient, call };
+}
+
+describe("power command", () => {
+  it("start calls client.call('start')", async () => {
+    const { client, call } = mockClient();
+    call.mockResolvedValueOnce({ error: 0 });
+
+    const result = await run("start", {}, client);
+
+    expect(client.call).toHaveBeenCalledExactlyOnceWith("start");
+    expect(result).toEqual({ error: 0 });
+  });
+
+  it("stop calls client.call('stop')", async () => {
+    const { client, call } = mockClient();
+    call.mockResolvedValueOnce({ error: 0 });
+
+    const result = await run("stop", {}, client);
+
+    expect(client.call).toHaveBeenCalledExactlyOnceWith("stop");
+    expect(result).toEqual({ error: 0 });
+  });
+
+  it("restart calls client.call('restart')", async () => {
+    const { client, call } = mockClient();
+    call.mockResolvedValueOnce({ error: 0 });
+
+    const result = await run("restart", {}, client);
+
+    expect(client.call).toHaveBeenCalledExactlyOnceWith("restart");
+    expect(result).toEqual({ error: 0 });
+  });
+
+  it("kill calls client.call('kill')", async () => {
+    const { client, call } = mockClient();
+    call.mockResolvedValueOnce({ error: 0 });
+
+    const result = await run("kill", {}, client);
+
+    expect(client.call).toHaveBeenCalledExactlyOnceWith("kill");
+    expect(result).toEqual({ error: 0 });
+  });
+
+  it("returns the raw API response", async () => {
+    const { client, call } = mockClient();
+    const apiResponse = { error: 0, message: "Virtual server is running." };
+    call.mockResolvedValueOnce(apiResponse);
+
+    const result = await run("start", {}, client);
+
+    expect(result).toBe(apiResponse);
+  });
+
+  it("propagates errors from the client", async () => {
+    const { client, call } = mockClient();
+    const apiError = new Error("API failure");
+    call.mockRejectedValueOnce(apiError);
+
+    await expect(run("restart", {}, client)).rejects.toThrow("API failure");
+  });
+});

package/src/commands/power.ts

@@ -0,0 +1,22 @@
+import type { KiwiVMClient } from "../client.ts";
+
+export async function run(
+  action: string,
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  switch (action) {
+    case "start":
+      return client.call("start");
+    case "stop":
+      return client.call("stop");
+    case "restart":
+      return client.call("restart");
+    case "kill":
+      return client.call("kill");
+    default:
+      throw new Error(
+        `Unknown power action: ${action}. Valid: start, stop, restart, kill`,
+      );
+  }
+}

package/src/commands/snapshot.test.ts

@@ -0,0 +1,159 @@
+import { describe, expect, it, vi } from "vitest";
+import type { KiwiVMClient } from "../client.ts";
+import { run } from "./snapshot.ts";
+
+function mockClient() {
+  const call = vi.fn();
+  return { client: { call } as unknown as KiwiVMClient, call };
+}
+
+describe("snapshot command", () => {
+  describe("create", () => {
+    it("calls snapshot/create with description flag", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({ error: 0 });
+
+      const result = await run(
+        "create",
+        { description: "pre-upgrade" },
+        client,
+      );
+
+      expect(client.call).toHaveBeenCalledExactlyOnceWith("snapshot/create", {
+        description: "pre-upgrade",
+      });
+      expect(result).toEqual({ error: 0 });
+    });
+
+    it("calls snapshot/create without description when flag is omitted", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({ error: 0 });
+
+      await run("create", {}, client);
+
+      expect(client.call).toHaveBeenCalledExactlyOnceWith("snapshot/create", {
+        description: undefined,
+      });
+    });
+  });
+
+  describe("list", () => {
+    it("calls snapshot/list", async () => {
+      const { client, call } = mockClient();
+      const snapshots = {
+        error: 0,
+        snapshots: [
+          {
+            fileName: "snap1",
+            os: "Ubuntu",
+            description: "",
+            size: 1024,
+            md5: "",
+            sticky: 0,
+            purgesIn: 0,
+            downloadLink: "",
+            downloadLinkSSL: "",
+          },
+        ],
+      };
+      call.mockResolvedValueOnce(snapshots);
+
+      const result = await run("list", {}, client);
+
+      expect(client.call).toHaveBeenCalledExactlyOnceWith("snapshot/list");
+      expect(result).toEqual(snapshots);
+    });
+  });
+
+  describe("delete", () => {
+    it("calls snapshot/delete with snapshot flag", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({ error: 0 });
+
+      await run("delete", { snapshot: "snap1" }, client);
+
+      expect(client.call).toHaveBeenCalledExactlyOnceWith("snapshot/delete", {
+        snapshot: "snap1",
+      });
+    });
+  });
+
+  describe("restore", () => {
+    it("calls snapshot/restore with snapshot flag", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({ error: 0 });
+
+      await run("restore", { snapshot: "snap1" }, client);
+
+      expect(client.call).toHaveBeenCalledExactlyOnceWith("snapshot/restore", {
+        snapshot: "snap1",
+      });
+    });
+  });
+
+  describe("sticky", () => {
+    it("calls snapshot/toggleSticky with snapshot and sticky flags", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({ error: 0 });
+
+      await run("sticky", { snapshot: "snap1", sticky: "1" }, client);
+
+      expect(client.call).toHaveBeenCalledExactlyOnceWith(
+        "snapshot/toggleSticky",
+        { snapshot: "snap1", sticky: 1 },
+      );
+    });
+
+    it("converts sticky flag string '0' to number 0", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({ error: 0 });
+
+      await run("sticky", { snapshot: "snap1", sticky: "0" }, client);
+
+      expect(client.call).toHaveBeenCalledExactlyOnceWith(
+        "snapshot/toggleSticky",
+        { snapshot: "snap1", sticky: 0 },
+      );
+    });
+  });
+
+  describe("export", () => {
+    it("calls snapshot/export with snapshot flag", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({ error: 0 });
+
+      await run("export", { snapshot: "snap1" }, client);
+
+      expect(client.call).toHaveBeenCalledExactlyOnceWith("snapshot/export", {
+        snapshot: "snap1",
+      });
+    });
+  });
+
+  describe("import", () => {
+    it("calls snapshot/import with sourceVeid and sourceToken", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({ error: 0 });
+
+      await run(
+        "import",
+        { sourceVeid: "67890", sourceToken: "abc123" },
+        client,
+      );
+
+      expect(client.call).toHaveBeenCalledExactlyOnceWith("snapshot/import", {
+        sourceVeid: "67890",
+        sourceToken: "abc123",
+      });
+    });
+  });
+
+  it("propagates errors from the client", async () => {
+    const { client, call } = mockClient();
+    call.mockRejectedValueOnce(new Error("Snapshot not found"));
+
+    await expect(
+      run("delete", { snapshot: "nonexistent" }, client),
+    ).rejects.toThrow("Snapshot not found");
+  });
+});

package/src/commands/snapshot.ts

@@ -0,0 +1,40 @@
+import type { KiwiVMClient } from "../client.ts";
+import type { KiwiVMResponse, Snapshot } from "../types.ts";
+
+export async function run(
+  action: 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`,
+      );
+  }
+}

package/src/commands/system.test.ts

@@ -0,0 +1,98 @@
+import { describe, expect, it, vi } from "vitest";
+import type { KiwiVMClient } from "../client.ts";
+import { run } from "./system.ts";
+
+function mockClient() {
+  const call = vi.fn();
+  return { client: { call } as unknown as KiwiVMClient, call };
+}
+
+describe("system command", () => {
+  describe("hostname", () => {
+    it("calls setHostname with new-hostname flag", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({ error: 0 });
+
+      await run("hostname", { newHostname: "my-vps.example.com" }, client);
+
+      expect(client.call).toHaveBeenCalledExactlyOnceWith("setHostname", {
+        newHostname: "my-vps.example.com",
+      });
+    });
+  });
+
+  describe("rdns", () => {
+    it("calls setPTR with ip and ptr flags", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({ error: 0 });
+
+      await run("rdns", { ip: "1.2.3.4", ptr: "my-vps.example.com" }, client);
+
+      expect(client.call).toHaveBeenCalledExactlyOnceWith("setPTR", {
+        ip: "1.2.3.4",
+        ptr: "my-vps.example.com",
+      });
+    });
+  });
+
+  describe("password", () => {
+    it("calls resetRootPassword with no params", async () => {
+      const { client, call } = mockClient();
+      const pwResponse = { error: 0, message: "Password reset successfully" };
+      call.mockResolvedValueOnce(pwResponse);
+
+      const result = await run("password", {}, client);
+
+      expect(client.call).toHaveBeenCalledExactlyOnceWith("resetRootPassword");
+      expect(result).toEqual(pwResponse);
+    });
+  });
+
+  describe("sshkey", () => {
+    it("calls getSshKeys when --ssh-keys flag is not provided", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({
+        error: 0,
+        sshKeys: ["ssh-rsa AAA..."],
+      });
+
+      const result = await run("sshkey", {}, client);
+
+      expect(client.call).toHaveBeenCalledExactlyOnceWith("getSshKeys");
+      expect(result).toMatchObject({ sshKeys: ["ssh-rsa AAA..."] });
+    });
+
+    it("calls updateSshKeys when --ssh-keys flag is provided", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({ error: 0 });
+
+      await run("sshkey", { sshKeys: "ssh-rsa AAA..." }, client);
+
+      expect(client.call).toHaveBeenCalledExactlyOnceWith("updateSshKeys", {
+        sshKeys: "ssh-rsa AAA...",
+      });
+    });
+  });
+
+  describe("reinstall", () => {
+    it("calls reinstallOS with os flag", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({ error: 0 });
+
+      await run("reinstall", { os: "ubuntu-22.04" }, client);
+
+      expect(client.call).toHaveBeenCalledExactlyOnceWith("reinstallOS", {
+        os: "ubuntu-22.04",
+      });
+    });
+  });
+
+  it("propagates errors from the client", async () => {
+    const { client, call } = mockClient();
+    call.mockRejectedValueOnce(new Error("Invalid hostname"));
+
+    await expect(run("hostname", { newHostname: "" }, client)).rejects.toThrow(
+      "Invalid hostname",
+    );
+  });
+});

package/src/commands/system.ts

@@ -0,0 +1,29 @@
+import type { KiwiVMClient } from "../client.ts";
+
+export async function run(
+  action: 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`,
+      );
+  }
+}