feat: implement volume management with commands for listing, creating, inspecting, and removing volumes

main.ts

···
 import start from "./src/subcommands/start.ts";
 import stop from "./src/subcommands/stop.ts";
 import tag from "./src/subcommands/tag.ts";
+import * as volumes from "./src/subcommands/volume.ts";
 
 import { getImage } from "./src/images.ts";
 import { getImageArchivePath } from "./src/mod.ts";
···
       "-p, --port-forward <mappings:string>",
       "Port forwarding rules in the format hostPort:guestPort (comma-separated for multiple)",
     )
+    .option(
+      "-v, --volume <name:string>",
+      "Name of the volume to attach to the VM, will be created if it doesn't exist",
+    )
     .action(async (options: unknown, vmName: string) => {
       await start(vmName, Boolean((options as { detach: boolean }).detach));
     })
···
       "-p, --port-forward <mappings:string>",
       "Port forwarding rules in the format hostPort:guestPort (comma-separated for multiple)",
     )
+    .option(
+      "-v, --volume <name:string>",
+      "Name of the volume to attach to the VM, will be created if it doesn't exist",
+    )
     .action(async (_options: unknown, image: string) => {
       await run(image);
     })
+    .command("volumes", "List all volumes")
+    .action(async () => {
+      await volumes.list();
+    })
+    .command(
+      "volume",
+      new Command()
+        .command("rm", "Remove a volume")
+        .arguments("<volume-name:string>")
+        .action(async (_options: unknown, volumeName: string) => {
+          await volumes.remove(volumeName);
+        })
+        .command("inspect", "Inspect a volume")
+        .arguments("<volume-name:string>")
+        .action(async (_options: unknown, volumeName: string) => {
+          await volumes.inspect(volumeName);
+        }),
+    )
+    .description("Manage volumes")
     .parse(Deno.args);
 }

src/constants.ts

···
 export const EMPTY_DISK_THRESHOLD_KB = 100;
 export const CONFIG_FILE_NAME: string = "vmconfig.toml";
 export const IMAGE_DIR: string = `${CONFIG_DIR}/images`;
+export const VOLUME_DIR: string = `${CONFIG_DIR}/volumes`;

src/db.ts

···
 export type DatabaseSchema = {
   virtual_machines: VirtualMachine;
   images: Image;
+  volumes: Volume;
 };
 
 export type VirtualMachine = {
···
   version: string;
   status: STATUS;
   pid: number;
+  volume?: string;
   createdAt?: string;
   updatedAt?: string;
 };

src/migrations.ts

···
   },
 };
 
+migrations["009"] = {
+  async up(db: Kysely<unknown>): Promise<void> {
+    await db.schema
+      .createTable("volumes_new")
+      .addColumn("id", "varchar", (col) => col.primaryKey())
+      .addColumn("name", "varchar", (col) => col.notNull().unique())
+      .addColumn(
+        "baseImageId",
+        "varchar",
+        (col) => col.notNull().references("images.id").onDelete("cascade"),
+      )
+      .addColumn("path", "varchar", (col) => col.notNull())
+      .addColumn(
+        "createdAt",
+        "varchar",
+        (col) => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`),
+      )
+      .execute();
+
+    await sql`
+      INSERT INTO volumes_new (id, name, baseImageId, path, createdAt)
+      SELECT id, name, baseImageId, path, createdAt FROM volumes
+    `.execute(db);
+
+    await db.schema.dropTable("volumes").execute();
+    await sql`ALTER TABLE volumes_new RENAME TO volumes`.execute(db);
+  },
+
+  async down(db: Kysely<unknown>): Promise<void> {
+    await db.schema.dropTable("volumes").execute();
+  },
+};
+
+migrations["010"] = {
+  async up(db: Kysely<unknown>): Promise<void> {
+    await db.schema
+      .alterTable("virtual_machines")
+      .addColumn("volume", "varchar")
+      .execute();
+  },
+
+  async down(db: Kysely<unknown>): Promise<void> {
+    await db.schema
+      .alterTable("virtual_machines")
+      .dropColumn("volume")
+      .execute();
+  },
+};
+
 export const migrateToLatest = async (db: Database): Promise<void> => {
   const migrator = new Migrator({ db, provider: migrationProvider });
   const { error } = await migrator.migrateToLatest();

src/mod.ts

···
 export * from "./state.ts";
 export * from "./types.ts";
 export * from "./utils.ts";
-export * from "./volume.ts";
+export * from "./volumes.ts";

src/subcommands/inspect.ts

···
 import { Data, Effect, pipe } from "effect";
-import type { Image, VirtualMachine } from "../db.ts";
+import type { Image, VirtualMachine, Volume } from "../db.ts";
 import { getImage } from "../images.ts";
 import { getInstanceState } from "../state.ts";
+import { getVolume } from "../volumes.ts";
 
 class ItemNotFoundError extends Data.TaggedError("ItemNotFoundError")<{
   name: string;
···
 
 const find = (name: string) =>
   pipe(
-    Effect.all([getInstanceState(name), getImage(name)]),
-    Effect.flatMap(([vm, image]) =>
-      vm || image
-        ? Effect.succeed(vm || image)
+    Effect.all([getInstanceState(name), getImage(name), getVolume(name)]),
+    Effect.flatMap(([vm, image, volume]) =>
+      vm || image || volume
+        ? Effect.succeed(vm || image || volume)
         : Effect.fail(new ItemNotFoundError({ name }))
     ),
   );
 
-const display = (vm: VirtualMachine | Image | undefined) =>
+const display = (vm: VirtualMachine | Image | Volume | undefined) =>
   Effect.sync(() => {
     console.log(vm);
   });

src/subcommands/run.ts

···
 import { parseFlags } from "@cliffy/flags";
 import { Effect, pipe } from "effect";
-import type { Image } from "../db.ts";
+import type { Image, Volume } from "../db.ts";
 import { getImage } from "../images.ts";
 import { createBridgeNetworkIfNeeded } from "../network.ts";
 import { pullImage, PullImageError, setupOrasBinary } from "../oras.ts";
 import { type Options, runQemu, validateImage } from "../utils.ts";
+import { createVolume, getVolume } from "../volumes.ts";
 
 const pullImageOnMissing = (
   name: string,
···
     }),
   );
 
-const runImage = (image: Image) =>
+const createVolumeIfNeeded = (
+  image: Image,
+): Effect.Effect<[Image, Volume?], Error, never> =>
+  parseFlags(Deno.args).flags.volume
+    ? Effect.gen(function* () {
+      const volumeName = parseFlags(Deno.args).flags.volume as string;
+      const volume = yield* getVolume(volumeName);
+      if (volume) {
+        return [image, volume];
+      }
+      const newVolume = yield* createVolume(volumeName, image);
+      return [image, newVolume];
+    })
+    : Effect.succeed([image]);
+
+const runImage = ([image, volume]: [Image, Volume?]) =>
   Effect.gen(function* () {
     console.log(`Running image ${image.repository}...`);
     const options = mergeFlags(image);
     if (options.bridge) {
       yield* createBridgeNetworkIfNeeded(options.bridge);
     }
+
+    if (volume) {
+      options.image = volume.path;
+      options.install = true;
+      options.diskFormat = "qcow2";
+    }
+
     yield* runQemu(null, options);
   });
 
···
       Effect.promise(() => setupOrasBinary()),
       Effect.tap(() => validateImage(image)),
       Effect.flatMap(() => pullImageOnMissing(image)),
+      Effect.flatMap(createVolumeIfNeeded),
       Effect.flatMap(runImage),
       Effect.catchAll((error) =>
         Effect.sync(() => {
-          console.error(`Failed to run image: ${error.cause} ${image}`);
+          console.error(`Failed to run image: ${error.message} ${image}`);
           Deno.exit(1);
         })
       ),
···
 function mergeFlags(image: Image): Options {
   const { flags } = parseFlags(Deno.args);
   return {
-    cpu: flags.cpu ? flags.cpu : "host",
+    cpu: flags.cpu ? flags.cpu : Deno.build.arch === "aarch64" ? "max" : "host",
     cpus: flags.cpus ? flags.cpus : 2,
     memory: flags.memory ? flags.memory : "2G",
     image: image.path,
···
     install: false,
     diskFormat: image.format,
     size: flags.size ? flags.size : "20G",
+    volume: flags.volume,
   };
 }

src/subcommands/volume.ts

···
+import { Table } from "@cliffy/table";
+import dayjs from "dayjs";
+import relativeTime from "dayjs/plugin/relativeTime.js";
+import utc from "dayjs/plugin/utc.js";
+import { Effect, pipe } from "effect";
+import type { Volume } from "../db.ts";
+import type { DbError } from "../mod.ts";
+import { deleteVolume, getVolume, listVolumes } from "../volumes.ts";
+
+dayjs.extend(relativeTime);
+dayjs.extend(utc);
+
+const createTable = () =>
+  Effect.succeed(
+    new Table(
+      ["NAME", "VOLUME ID", "CREATED"],
+    ),
+  );
+
+const populateTable = (table: Table, volumes: Volume[]) =>
+  Effect.sync(() => {
+    for (const volume of volumes) {
+      table.push([
+        volume.name,
+        volume.id,
+        dayjs.utc(volume.createdAt).local().fromNow(),
+      ]);
+    }
+    return table;
+  });
+
+const displayTable = (table: Table) =>
+  Effect.sync(() => {
+    console.log(table.padding(2).toString());
+  });
+
+const handleError = (error: DbError | Error) =>
+  Effect.sync(() => {
+    console.error(`Failed to fetch volumes: ${error}`);
+    Deno.exit(1);
+  });
+
+const lsEffect = () =>
+  pipe(
+    Effect.all([listVolumes(), createTable()]),
+    Effect.flatMap(([volumes, table]) => populateTable(table, volumes)),
+    Effect.flatMap(displayTable),
+    Effect.catchAll(handleError),
+  );
+
+export async function list() {
+  await Effect.runPromise(lsEffect());
+}
+
+export async function remove(name: string) {
+  await Effect.runPromise(
+    pipe(
+      getVolume(name),
+      Effect.flatMap((volume) =>
+        volume
+          ? deleteVolume(volume.id)
+          : Effect.fail(new Error(`Volume with name or ID ${name} not found.`))
+      ),
+      Effect.tap(() =>
+        Effect.sync(() => {
+          console.log(`Volume ${name} deleted successfully.`);
+        })
+      ),
+      Effect.catchAll((error) =>
+        Effect.sync(() => {
+          console.error(`An error occurred: ${error}`);
+          Deno.exit(1);
+        })
+      ),
+    ),
+  );
+}
+
+export async function inspect(name: string) {
+  await Effect.runPromise(
+    pipe(
+      getVolume(name),
+      Effect.flatMap((volume) =>
+        volume
+          ? Effect.sync(() => {
+            console.log(volume);
+          })
+          : Effect.fail(new Error(`Volume with name or ID ${name} not found.`))
+      ),
+      Effect.catchAll((error) =>
+        Effect.sync(() => {
+          console.error(`An error occurred: ${error}`);
+          Deno.exit(1);
+        })
+      ),
+    ),
+  );
+}

src/utils.ts

···
   portForward?: string;
   detach?: boolean;
   install?: boolean;
+  volume?: string;
 }
 
 export const getCurrentArch = (): string => {

src/volumes.ts

···
+import { createId } from "@paralleldrive/cuid2";
+import { Data, Effect } from "effect";
+import type { DeleteResult, InsertResult } from "kysely";
+import { VOLUME_DIR } from "./constants.ts";
+import { ctx } from "./context.ts";
+import type { Image, Volume } from "./db.ts";
+
+export class VolumeError extends Data.TaggedError("VolumeError")<{
+  message?: unknown;
+}> {}
+
+export const listVolumes = () =>
+  Effect.tryPromise({
+    try: () => ctx.db.selectFrom("volumes").selectAll().execute(),
+    catch: (error) =>
+      new VolumeError({
+        message: error instanceof Error ? error.message : String(error),
+      }),
+  });
+
+export const getVolume = (
+  id: string,
+): Effect.Effect<Volume | undefined, VolumeError, never> =>
+  Effect.tryPromise({
+    try: () =>
+      ctx.db
+        .selectFrom("volumes")
+        .selectAll()
+        .where((eb) =>
+          eb.or([
+            eb("name", "=", id),
+            eb("id", "=", id),
+          ])
+        )
+        .executeTakeFirst(),
+    catch: (error) =>
+      new VolumeError({
+        message: error instanceof Error ? error.message : String(error),
+      }),
+  });
+
+export const saveVolume = (
+  volume: Volume,
+): Effect.Effect<InsertResult[], VolumeError, never> =>
+  Effect.tryPromise({
+    try: () =>
+      ctx.db.insertInto("volumes")
+        .values(volume)
+        .execute(),
+    catch: (error) =>
+      new VolumeError({
+        message: error instanceof Error ? error.message : String(error),
+      }),
+  });
+
+export const deleteVolume = (
+  id: string,
+): Effect.Effect<DeleteResult[], VolumeError, never> =>
+  Effect.tryPromise({
+    try: () =>
+      ctx.db.deleteFrom("volumes").where((eb) =>
+        eb.or([
+          eb("name", "=", id),
+          eb("id", "=", id),
+        ])
+      ).execute(),
+    catch: (error) =>
+      new VolumeError({
+        message: error instanceof Error ? error.message : String(error),
+      }),
+  });
+
+export const createVolume = (
+  name: string,
+  baseImage: Image,
+): Effect.Effect<Volume, VolumeError, never> =>
+  Effect.tryPromise({
+    try: async () => {
+      const path = `${VOLUME_DIR}/${name}.qcow2`;
+
+      if ((await Deno.stat(path).catch(() => false))) {
+        throw new Error(`Volume with name ${name} already exists`);
+      }
+
+      await Deno.mkdir(VOLUME_DIR, { recursive: true });
+      const qemu = new Deno.Command("qemu-img", {
+        args: [
+          "create",
+          "-F",
+          "raw",
+          "-f",
+          "qcow2",
+          "-b",
+          baseImage.path,
+          path,
+        ],
+        stdout: "inherit",
+        stderr: "inherit",
+      })
+        .spawn();
+      const status = await qemu.status;
+      if (!status.success) {
+        throw new Error(
+          `Failed to create volume: qemu-img exited with code ${status.code}`,
+        );
+      }
+      ctx.db.insertInto("volumes").values({
+        id: createId(),
+        name,
+        path,
+        baseImageId: baseImage.id,
+      }).execute();
+      const volume = await ctx.db
+        .selectFrom("volumes")
+        .selectAll()
+        .where("name", "=", name)
+        .executeTakeFirst();
+      if (!volume) {
+        throw new Error("Failed to create volume");
+      }
+      return volume;
+    },
+    catch: (error) =>
+      new VolumeError({
+        message: error instanceof Error ? error.message : String(error),
+      }),
+  });