kiwivm-cli 0.1.0 → 0.2.0

package/src/commands/network.ts

@@ -1,24 +1,62 @@
 import type { KiwiVMClient } from "../client.ts";
 
-export async function run(
-  action: string,
-  flags: Record<string, string>,
+export async function rdnsSet(
+  args: 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`,
-      );
+  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 });
+}
+
+export async function ipv6Add(
+  _args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  return client.call("ipv6/add");
+}
+
+export async function ipv6Delete(
+  args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  const ip = args[0];
+  if (!ip) {
+    throw new Error("ipv6 delete requires a <subnet> argument");
+  }
+  return client.call("ipv6/delete", { ip });
+}
+
+export async function privateIpList(
+  _args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  return client.call("privateIp/getAvailableIps");
+}
+
+export async function privateIpAssign(
+  args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  return client.call("privateIp/assign", { ip: args[0] });
+}
+
+export async function privateIpDelete(
+  args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  const ip = args[0];
+  if (!ip) {
+    throw new Error("private-ip delete requires an <ip> argument");
+  }
+  return client.call("privateIp/delete", { ip });
 }

package/src/commands/power.test.ts

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

package/src/commands/power.ts

@@ -1,22 +1,33 @@
 import type { KiwiVMClient } from "../client.ts";
 
-export async function run(
-  action: string,
+export async function start(
+  _args: 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`,
-      );
-  }
+  return client.call("start");
+}
+
+export async function stop(
+  _args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  return client.call("stop");
+}
+
+export async function restart(
+  _args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  return client.call("restart");
+}
+
+export async function kill(
+  _args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  return client.call("kill");
 }

package/src/commands/shell.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, it, vi } from "vitest";
+import type { KiwiVMClient } from "../client.ts";
+import { exec, script } from "./shell.ts";
+
+function mockClient() {
+  const call = vi.fn();
+  return { client: { call } as unknown as KiwiVMClient, call };
+}
+
+describe("shell handlers", () => {
+  describe("exec", () => {
+    it("calls basicShell/exec with command from args", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({ error: 0 });
+
+      const result = await exec(["uptime"], {}, client);
+
+      expect(call).toHaveBeenCalledExactlyOnceWith("basicShell/exec", {
+        command: "uptime",
+      });
+      expect(result).toEqual({ error: 0 });
+    });
+
+    it("throws when no command provided", async () => {
+      const { client } = mockClient();
+
+      await expect(exec([], {}, client)).rejects.toThrow("command");
+    });
+
+    it("propagates errors from the client", async () => {
+      const { client, call } = mockClient();
+      call.mockRejectedValueOnce(new Error("Exec failed"));
+
+      await expect(exec(["uptime"], {}, client)).rejects.toThrow("Exec failed");
+    });
+  });
+
+  describe("script", () => {
+    it("calls shellScript/exec with script from args", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({ error: 0 });
+
+      const result = await script(["apt update"], {}, client);
+
+      expect(call).toHaveBeenCalledExactlyOnceWith("shellScript/exec", {
+        script: "apt update",
+      });
+      expect(result).toEqual({ error: 0 });
+    });
+
+    it("throws when no script provided", async () => {
+      const { client } = mockClient();
+
+      await expect(script([], {}, client)).rejects.toThrow("script");
+    });
+
+    it("propagates errors from the client", async () => {
+      const { client, call } = mockClient();
+      call.mockRejectedValueOnce(new Error("Script failed"));
+
+      await expect(script(["apt update"], {}, client)).rejects.toThrow(
+        "Script failed",
+      );
+    });
+  });
+});

package/src/commands/shell.ts

@@ -0,0 +1,25 @@
+import type { KiwiVMClient } from "../client.ts";
+
+export async function exec(
+  args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  const command = args[0];
+  if (!command) {
+    throw new Error("shell exec requires a <command> argument");
+  }
+  return client.call("basicShell/exec", { command });
+}
+
+export async function script(
+  args: string[],
+  _flags: Record<string, string>,
+  client: KiwiVMClient,
+): Promise<unknown> {
+  const scriptContent = args[0];
+  if (!scriptContent) {
+    throw new Error("shell script requires a <script> argument");
+  }
+  return client.call("shellScript/exec", { script: scriptContent });
+}

package/src/commands/snapshot.test.ts

@@ -1,44 +1,23 @@
 import { describe, expect, it, vi } from "vitest";
 import type { KiwiVMClient } from "../client.ts";
-import { run } from "./snapshot.ts";
+import {
+  create,
+  deleteSnapshot,
+  exportSnapshot,
+  importSnapshot,
+  list,
+  restore,
+  sticky,
+} 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("snapshot handlers", () => {
   describe("list", () => {
-    it("calls snapshot/list", async () => {
+    it("calls client.call('snapshot/list')", async () => {
       const { client, call } = mockClient();
       const snapshots = {
         error: 0,
@@ -58,102 +37,193 @@ describe("snapshot command", () => {
       };
       call.mockResolvedValueOnce(snapshots);
 
-      const result = await run("list", {}, client);
+      const result = await list([], {}, client);
 
-      expect(client.call).toHaveBeenCalledExactlyOnceWith("snapshot/list");
+      expect(call).toHaveBeenCalledExactlyOnceWith("snapshot/list");
       expect(result).toEqual(snapshots);
     });
+
+    it("propagates errors from the client", async () => {
+      const { client, call } = mockClient();
+      call.mockRejectedValueOnce(new Error("API failure"));
+
+      await expect(list([], {}, client)).rejects.toThrow("API failure");
+    });
   });
 
-  describe("delete", () => {
-    it("calls snapshot/delete with snapshot flag", async () => {
+  describe("create", () => {
+    it("calls snapshot/create with description flag", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({ error: 0 });
+
+      const result = await create([], { desc: "pre-upgrade" }, client);
+
+      expect(call).toHaveBeenCalledExactlyOnceWith("snapshot/create", {
+        description: "pre-upgrade",
+      });
+      expect(result).toEqual({ error: 0 });
+    });
+
+    it("calls snapshot/create with description undefined when flag omitted", async () => {
       const { client, call } = mockClient();
       call.mockResolvedValueOnce({ error: 0 });
 
-      await run("delete", { snapshot: "snap1" }, client);
+      await create([], {}, client);
 
-      expect(client.call).toHaveBeenCalledExactlyOnceWith("snapshot/delete", {
+      expect(call).toHaveBeenCalledExactlyOnceWith("snapshot/create", {
+        description: undefined,
+      });
+    });
+
+    it("propagates errors from the client", async () => {
+      const { client, call } = mockClient();
+      call.mockRejectedValueOnce(new Error("API failure"));
+
+      await expect(create([], {}, client)).rejects.toThrow("API failure");
+    });
+  });
+
+  describe("deleteSnapshot", () => {
+    it("calls snapshot/delete with snapshot token from args", async () => {
+      const { client, call } = mockClient();
+      call.mockResolvedValueOnce({ error: 0 });
+
+      await deleteSnapshot(["snap1"], {}, client);
+
+      expect(call).toHaveBeenCalledExactlyOnceWith("snapshot/delete", {
         snapshot: "snap1",
       });
     });
+
+    it("throws when no snapshot token provided", async () => {
+      const { client } = mockClient();
+
+      await expect(deleteSnapshot([], {}, client)).rejects.toThrow(/token/);
+    });
+
+    it("propagates errors from the client", async () => {
+      const { client, call } = mockClient();
+      call.mockRejectedValueOnce(new Error("Snapshot not found"));
+
+      await expect(deleteSnapshot(["nonexistent"], {}, client)).rejects.toThrow(
+        "Snapshot not found",
+      );
+    });
   });
 
   describe("restore", () => {
-    it("calls snapshot/restore with snapshot flag", async () => {
+    it("calls snapshot/restore with snapshot token from args", async () => {
       const { client, call } = mockClient();
       call.mockResolvedValueOnce({ error: 0 });
 
-      await run("restore", { snapshot: "snap1" }, client);
+      await restore(["snap1"], {}, client);
 
-      expect(client.call).toHaveBeenCalledExactlyOnceWith("snapshot/restore", {
+      expect(call).toHaveBeenCalledExactlyOnceWith("snapshot/restore", {
         snapshot: "snap1",
       });
     });
+
+    it("propagates errors from the client", async () => {
+      const { client, call } = mockClient();
+      call.mockRejectedValueOnce(new Error("Snapshot not found"));
+
+      await expect(restore(["nonexistent"], {}, client)).rejects.toThrow(
+        "Snapshot not found",
+      );
+    });
   });
 
   describe("sticky", () => {
-    it("calls snapshot/toggleSticky with snapshot and sticky flags", async () => {
+    it("calls snapshot/toggleSticky with sticky=1 when --on flag set", async () => {
       const { client, call } = mockClient();
       call.mockResolvedValueOnce({ error: 0 });
 
-      await run("sticky", { snapshot: "snap1", sticky: "1" }, client);
+      await sticky(["snap1"], { on: "1" }, client);
 
-      expect(client.call).toHaveBeenCalledExactlyOnceWith(
-        "snapshot/toggleSticky",
-        { snapshot: "snap1", sticky: 1 },
-      );
+      expect(call).toHaveBeenCalledExactlyOnceWith("snapshot/toggleSticky", {
+        snapshot: "snap1",
+        sticky: 1,
+      });
     });
 
-    it("converts sticky flag string '0' to number 0", async () => {
+    it("calls snapshot/toggleSticky with sticky=0 when --off flag set", async () => {
       const { client, call } = mockClient();
       call.mockResolvedValueOnce({ error: 0 });
 
-      await run("sticky", { snapshot: "snap1", sticky: "0" }, client);
+      await sticky(["snap1"], { off: "1" }, client);
 
-      expect(client.call).toHaveBeenCalledExactlyOnceWith(
-        "snapshot/toggleSticky",
-        { snapshot: "snap1", sticky: 0 },
+      expect(call).toHaveBeenCalledExactlyOnceWith("snapshot/toggleSticky", {
+        snapshot: "snap1",
+        sticky: 0,
+      });
+    });
+
+    it("throws when neither --on nor --off flag provided", async () => {
+      const { client } = mockClient();
+
+      await expect(sticky(["snap1"], {}, client)).rejects.toThrow("--on");
+    });
+
+    it("propagates errors from the client", async () => {
+      const { client, call } = mockClient();
+      call.mockRejectedValueOnce(new Error("API failure"));
+
+      await expect(sticky(["snap1"], { on: "1" }, client)).rejects.toThrow(
+        "API failure",
       );
     });
   });
 
-  describe("export", () => {
-    it("calls snapshot/export with snapshot flag", async () => {
+  describe("exportSnapshot", () => {
+    it("calls snapshot/export with snapshot token from args", async () => {
       const { client, call } = mockClient();
       call.mockResolvedValueOnce({ error: 0 });
 
-      await run("export", { snapshot: "snap1" }, client);
+      await exportSnapshot(["snap1"], {}, client);
 
-      expect(client.call).toHaveBeenCalledExactlyOnceWith("snapshot/export", {
+      expect(call).toHaveBeenCalledExactlyOnceWith("snapshot/export", {
         snapshot: "snap1",
       });
     });
+
+    it("propagates errors from the client", async () => {
+      const { client, call } = mockClient();
+      call.mockRejectedValueOnce(new Error("Export failed"));
+
+      await expect(exportSnapshot(["snap1"], {}, client)).rejects.toThrow(
+        "Export failed",
+      );
+    });
   });
 
-  describe("import", () => {
-    it("calls snapshot/import with sourceVeid and sourceToken", async () => {
+  describe("importSnapshot", () => {
+    it("calls snapshot/import with sourceVeid and sourceToken from args", async () => {
       const { client, call } = mockClient();
       call.mockResolvedValueOnce({ error: 0 });
 
-      await run(
-        "import",
-        { sourceVeid: "67890", sourceToken: "abc123" },
-        client,
-      );
+      await importSnapshot(["67890", "abc123"], {}, client);
 
-      expect(client.call).toHaveBeenCalledExactlyOnceWith("snapshot/import", {
+      expect(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"));
+    it("throws when only sourceVeid provided (missing token)", async () => {
+      const { client } = mockClient();
+
+      await expect(importSnapshot(["67890"], {}, client)).rejects.toThrow(
+        /token/i,
+      );
+    });
 
-    await expect(
-      run("delete", { snapshot: "nonexistent" }, client),
-    ).rejects.toThrow("Snapshot not found");
+    it("propagates errors from the client", async () => {
+      const { client, call } = mockClient();
+      call.mockRejectedValueOnce(new Error("Import failed"));
+
+      await expect(
+        importSnapshot(["67890", "abc123"], {}, client),
+      ).rejects.toThrow("Import failed");
+    });
   });
 });