feat: implement HTTP API with image and machine management endpoints

deno.json

···
     "chalk": "npm:chalk@^5.6.2",
     "dayjs": "npm:dayjs@^1.11.19",
     "effect": "npm:effect@^3.19.2",
+    "hono": "npm:hono@^4.10.6",
     "kysely": "npm:kysely@0.27.6",
     "moniker": "npm:moniker@^0.1.2"
   }

deno.lock

···
     "npm:chalk@^5.6.2": "5.6.2",
     "npm:dayjs@^1.11.19": "1.11.19",
     "npm:effect@^3.19.2": "3.19.2",
+    "npm:hono@^4.10.6": "4.10.6",
     "npm:kysely@0.27.6": "0.27.6",
     "npm:kysely@~0.27.2": "0.27.6",
     "npm:moniker@~0.1.2": "0.1.2"
···
         "pure-rand"
       ]
     },
+    "hono@4.10.6": {
+      "integrity": "sha512-BIdolzGpDO9MQ4nu3AUuDwHZZ+KViNm+EZ75Ae55eMXMqLVhDFqEMXxtUe9Qh8hjL+pIna/frs2j6Y2yD5Ua/g=="
+    },
     "kysely@0.27.6": {
       "integrity": "sha512-FIyV/64EkKhJmjgC0g2hygpBv5RNWVPyNCqSAD7eTCv6eFWNIi4PN1UvdSJGicN/o35bnevgis4Y0UDC0qi8jQ=="
     },
···
       "npm:chalk@^5.6.2",
       "npm:dayjs@^1.11.19",
       "npm:effect@^3.19.2",
+      "npm:hono@^4.10.6",
       "npm:kysely@0.27.6",
       "npm:moniker@~0.1.2"
     ]

main.ts

···
 import stop from "./src/subcommands/stop.ts";
 import tag from "./src/subcommands/tag.ts";
 import * as volumes from "./src/subcommands/volume.ts";
-
+import serve from "./src/api/mod.ts";
 import { getImage } from "./src/images.ts";
 import { getImageArchivePath } from "./src/mod.ts";
 import {
···
         }),
     )
     .description("Manage volumes")
+    .command("serve", "Start the dflybsd-up HTTP API server")
+    .option("-p, --port <port:number>", "Port to listen on", { default: 8893 })
+    .action(() => {
+      serve();
+    })
     .parse(Deno.args);
 }

src/api/images.ts

···
+import { Hono } from "hono";
+import { Effect, pipe } from "effect";
+import { parseParams, presentation } from "./utils.ts";
+import { getImage, listImages } from "../images.ts";
+
+const app = new Hono();
+
+app.get("/", (c) =>
+  Effect.runPromise(
+    pipe(
+      listImages(),
+      presentation(c),
+    ),
+  ));
+
+app.get("/:id", (c) =>
+  Effect.runPromise(
+    pipe(
+      parseParams(c),
+      Effect.flatMap(({ id }) => getImage(id)),
+      presentation(c),
+    ),
+  ));
+
+app.post("/", (c) => {
+  return c.json({ message: "New image created" });
+});
+
+app.delete("/:id", (c) => {
+  const { id } = c.req.param();
+  return c.json({ message: `Image with ID ${id} deleted` });
+});
+
+export default app;

src/api/machines.ts

···
+import { Hono } from "hono";
+import { Data, Effect, pipe } from "effect";
+import {
+  createVolumeIfNeeded,
+  handleError,
+  parseCreateMachineRequest,
+  parseParams,
+  parseQueryParams,
+  parseStartRequest,
+  presentation,
+} from "./utils.ts";
+import { DEFAULT_VERSION, getInstanceState, LOGS_DIR } from "../mod.ts";
+import {
+  listInstances,
+  removeInstanceState,
+  saveInstanceState,
+  updateInstanceState,
+} from "../state.ts";
+import { findVm, killProcess, updateToStopped } from "../subcommands/stop.ts";
+import {
+  buildDetachedCommand,
+  buildQemuArgs,
+  createLogsDir,
+  failIfVMRunning,
+  startDetachedQemu,
+} from "../subcommands/start.ts";
+import type { NewMachine } from "../types.ts";
+import { createId } from "@paralleldrive/cuid2";
+import { generateRandomMacAddress } from "../network.ts";
+import Moniker from "moniker";
+import { getImage } from "../images.ts";
+
+export class ImageNotFoundError extends Data.TaggedError("ImageNotFoundError")<{
+  id: string;
+}> {}
+
+export class RemoveRunningVmError extends Data.TaggedError(
+  "RemoveRunningVmError",
+)<{
+  id: string;
+}> {}
+
+const app = new Hono();
+
+app.get("/", (c) =>
+  Effect.runPromise(
+    pipe(
+      parseQueryParams(c),
+      Effect.flatMap((params) =>
+        listInstances(
+          params.all === "true" || params.all === "1",
+        )
+      ),
+      presentation(c),
+    ),
+  ));
+
+app.post("/", (c) =>
+  Effect.runPromise(
+    pipe(
+      parseCreateMachineRequest(c),
+      Effect.flatMap((params: NewMachine) =>
+        Effect.gen(function* () {
+          const image = yield* getImage(params.image);
+          if (!image) {
+            return yield* Effect.fail(
+              new ImageNotFoundError({ id: params.image }),
+            );
+          }
+
+          const volume = params.volume
+            ? yield* createVolumeIfNeeded(image, params.volume)
+            : undefined;
+
+          const macAddress = yield* generateRandomMacAddress();
+          const id = createId();
+          yield* saveInstanceState({
+            id,
+            name: Moniker.choose(),
+            bridge: params.bridge,
+            macAddress,
+            memory: params.memory || "2G",
+            cpus: params.cpus || 8,
+            cpu: params.cpu || "host",
+            diskSize: "20G",
+            diskFormat: volume ? "qcow2" : "raw",
+            portForward: params.portForward
+              ? params.portForward.join(",")
+              : undefined,
+            drivePath: volume ? volume.path : image.path,
+            version: image.tag ?? DEFAULT_VERSION,
+            status: "STOPPED",
+            pid: 0,
+          });
+
+          const createdVm = yield* findVm(id);
+          return createdVm;
+        })
+      ),
+      presentation(c),
+      Effect.catchAll((error) => handleError(error, c)),
+    ),
+  ));
+
+app.get("/:id", (c) =>
+  Effect.runPromise(
+    pipe(
+      parseParams(c),
+      Effect.flatMap(({ id }) => getInstanceState(id)),
+      presentation(c),
+    ),
+  ));
+
+app.delete("/:id", (c) =>
+  Effect.runPromise(
+    pipe(
+      parseParams(c),
+      Effect.flatMap(({ id }) => findVm(id)),
+      Effect.flatMap((vm) =>
+        vm.status === "RUNNING"
+          ? Effect.fail(new RemoveRunningVmError({ id: vm.id }))
+          : Effect.succeed(vm)
+      ),
+      Effect.flatMap((vm) =>
+        Effect.gen(function* () {
+          yield* removeInstanceState(vm.id);
+          return vm;
+        })
+      ),
+      presentation(c),
+      Effect.catchAll((error) => handleError(error, c)),
+    ),
+  ));
+
+app.post("/:id/start", (c) =>
+  Effect.runPromise(
+    pipe(
+      Effect.all([parseParams(c), parseStartRequest(c)]),
+      Effect.flatMap((
+        [{ id }, startRequest],
+      ) => Effect.all([findVm(id), Effect.succeed(startRequest)])),
+      Effect.flatMap(([vm, startRequest]) =>
+        Effect.gen(function* () {
+          yield* failIfVMRunning(vm);
+          const mergedVm = {
+            ...vm,
+            cpu: String(startRequest.cpu ?? vm.cpu),
+            cpus: startRequest.cpus ?? vm.cpus,
+            memory: startRequest.memory ?? vm.memory,
+            portForward: startRequest.portForward
+              ? startRequest.portForward.join(",")
+              : vm.portForward,
+          };
+          const qemuArgs = buildQemuArgs(mergedVm);
+          const logPath = `${LOGS_DIR}/${vm.name}.log`;
+          const fullCommand = buildDetachedCommand(vm, qemuArgs, logPath);
+
+          yield* createLogsDir();
+          const qemuPid = yield* startDetachedQemu(fullCommand);
+          yield* updateInstanceState(vm.id, "RUNNING", qemuPid);
+          return { ...vm, status: "RUNNING" };
+        })
+      ),
+      presentation(c),
+      Effect.catchAll((error) => handleError(error, c)),
+    ),
+  ));
+
+app.post("/:id/stop", (c) =>
+  Effect.runPromise(
+    pipe(
+      parseParams(c),
+      Effect.flatMap(({ id }) => findVm(id)),
+      Effect.flatMap(killProcess),
+      Effect.flatMap(updateToStopped),
+      presentation(c),
+      Effect.catchAll((error) => handleError(error, c)),
+    ),
+  ));
+
+app.post("/:id/restart", (c) =>
+  Effect.runPromise(
+    pipe(
+      parseParams(c),
+      Effect.flatMap(({ id }) => findVm(id)),
+      Effect.flatMap(killProcess),
+      Effect.flatMap(updateToStopped),
+      Effect.flatMap(() => Effect.all([parseParams(c), parseStartRequest(c)])),
+      Effect.flatMap((
+        [{ id }, startRequest],
+      ) => Effect.all([findVm(id), Effect.succeed(startRequest)])),
+      Effect.flatMap(([vm, startRequest]) =>
+        Effect.gen(function* () {
+          yield* failIfVMRunning(vm);
+          const mergedVm = {
+            ...vm,
+            cpu: String(startRequest.cpu ?? vm.cpu),
+            cpus: startRequest.cpus ?? vm.cpus,
+            memory: startRequest.memory ?? vm.memory,
+            portForward: startRequest.portForward
+              ? startRequest.portForward.join(",")
+              : vm.portForward,
+          };
+          const qemuArgs = buildQemuArgs(mergedVm);
+          const logPath = `${LOGS_DIR}/${vm.name}.log`;
+          const fullCommand = buildDetachedCommand(vm, qemuArgs, logPath);
+
+          yield* createLogsDir();
+          const qemuPid = yield* startDetachedQemu(fullCommand);
+          yield* updateInstanceState(vm.id, "RUNNING", qemuPid);
+          return { ...vm, status: "RUNNING" };
+        })
+      ),
+      presentation(c),
+      Effect.catchAll((error) => handleError(error, c)),
+    ),
+  ));
+
+export default app;

src/api/mod.ts

···
+import machines from "./machines.ts";
+import images from "./images.ts";
+import volumes from "./volumes.ts";
+import { Hono } from "hono";
+import { logger } from "hono/logger";
+import { cors } from "hono/cors";
+import { bearerAuth } from "hono/bearer-auth";
+import { parseFlags } from "@cliffy/flags";
+
+export { images, machines, volumes };
+
+export default function () {
+  const token = Deno.env.get("DFLYBSD_UP_API_TOKEN") ||
+    crypto.randomUUID();
+  const { flags } = parseFlags(Deno.args);
+
+  if (!Deno.env.get("DFLYBSD_UP_API_TOKEN")) {
+    console.log(`Using API token: ${token}`);
+  } else {
+    console.log(
+      `Using provided API token from environment variable DFLYBSD_UP_API_TOKEN`,
+    );
+  }
+
+  const app = new Hono();
+
+  app.use(logger());
+  app.use(cors());
+
+  app.use("/images/*", bearerAuth({ token }));
+  app.use("/machines/*", bearerAuth({ token }));
+  app.use("/volumes/*", bearerAuth({ token }));
+
+  app.route("/images", images);
+  app.route("/machines", machines);
+  app.route("/volumes", volumes);
+
+  const port = Number(
+    flags.port || flags.p ||
+      (Deno.env.get("DFLYBSD_UP_PORT")
+        ? Number(Deno.env.get("DFLYBSD_UP_PORT"))
+        : 8893),
+  );
+
+  Deno.serve({ port }, app.fetch);
+}

src/api/utils.ts

···
+import { Data, Effect } from "effect";
+import type { Context } from "hono";
+import {
+  type CommandError,
+  StopCommandError,
+  VmNotFoundError,
+} from "../subcommands/stop.ts";
+import { VmAlreadyRunningError } from "../subcommands/start.ts";
+import {
+  MachineParamsSchema,
+  NewMachineSchema,
+  NewVolumeSchema,
+} from "../types.ts";
+import type { Image, Volume } from "../db.ts";
+import { createVolume, getVolume } from "../volumes.ts";
+import { ImageNotFoundError, RemoveRunningVmError } from "./machines.ts";
+
+export const parseQueryParams = (c: Context) => Effect.succeed(c.req.query());
+
+export const parseParams = (c: Context) => Effect.succeed(c.req.param());
+
+export const presentation = (c: Context) =>
+  Effect.flatMap((data) => Effect.succeed(c.json(data)));
+
+export class ParseRequestError extends Data.TaggedError("ParseRequestError")<{
+  cause?: unknown;
+  message: string;
+}> {}
+
+export const handleError = (
+  error:
+    | VmNotFoundError
+    | StopCommandError
+    | CommandError
+    | ParseRequestError
+    | VmAlreadyRunningError
+    | ImageNotFoundError
+    | RemoveRunningVmError
+    | Error,
+  c: Context,
+) =>
+  Effect.sync(() => {
+    if (error instanceof VmNotFoundError) {
+      return c.json(
+        { message: "VM not found", code: "VM_NOT_FOUND" },
+        404,
+      );
+    }
+    if (error instanceof StopCommandError) {
+      return c.json(
+        {
+          message: error.message ||
+            `Failed to stop VM ${error.vmName}`,
+          code: "STOP_COMMAND_ERROR",
+        },
+        500,
+      );
+    }
+
+    if (error instanceof ParseRequestError) {
+      return c.json(
+        {
+          message: error.message || "Failed to parse request body",
+          code: "PARSE_BODY_ERROR",
+        },
+        400,
+      );
+    }
+
+    if (error instanceof VmAlreadyRunningError) {
+      return c.json(
+        {
+          message: `VM ${error.name} is already running`,
+          code: "VM_ALREADY_RUNNING",
+        },
+        400,
+      );
+    }
+
+    if (error instanceof ImageNotFoundError) {
+      return c.json(
+        {
+          message: `Image ${error.id} not found`,
+          code: "IMAGE_NOT_FOUND",
+        },
+        404,
+      );
+    }
+
+    if (error instanceof RemoveRunningVmError) {
+      return c.json(
+        {
+          message:
+            `Cannot remove running VM with ID ${error.id}. Please stop it first.`,
+          code: "REMOVE_RUNNING_VM_ERROR",
+        },
+        400,
+      );
+    }
+
+    return c.json(
+      { message: error instanceof Error ? error.message : String(error) },
+      500,
+    );
+  });
+
+export const parseStartRequest = (c: Context) =>
+  Effect.tryPromise({
+    try: async () => {
+      const body = await c.req.json();
+      return MachineParamsSchema.parse(body);
+    },
+    catch: (error) =>
+      new ParseRequestError({
+        cause: error,
+        message: error instanceof Error ? error.message : String(error),
+      }),
+  });
+
+export const parseCreateMachineRequest = (c: Context) =>
+  Effect.tryPromise({
+    try: async () => {
+      const body = await c.req.json();
+      return NewMachineSchema.parse(body);
+    },
+    catch: (error) =>
+      new ParseRequestError({
+        cause: error,
+        message: error instanceof Error ? error.message : String(error),
+      }),
+  });
+
+export const createVolumeIfNeeded = (
+  image: Image,
+  volumeName: string,
+  size?: string,
+): Effect.Effect<Volume, Error, never> =>
+  Effect.gen(function* () {
+    const volume = yield* getVolume(volumeName);
+    if (volume) {
+      return volume;
+    }
+
+    return yield* createVolume(volumeName, image, size);
+  });
+
+export const parseCreateVolumeRequest = (c: Context) =>
+  Effect.tryPromise({
+    try: async () => {
+      const body = await c.req.json();
+      return NewVolumeSchema.parse(body);
+    },
+    catch: (error) =>
+      new ParseRequestError({
+        cause: error,
+        message: error instanceof Error ? error.message : String(error),
+      }),
+  });

src/api/volumes.ts

···
+import { Hono } from "hono";
+import { Effect, pipe } from "effect";
+import {
+  createVolumeIfNeeded,
+  handleError,
+  parseCreateVolumeRequest,
+  parseParams,
+  presentation,
+} from "./utils.ts";
+import { listVolumes } from "../mod.ts";
+import { deleteVolume, getVolume } from "../volumes.ts";
+import type { NewVolume } from "../types.ts";
+import { getImage } from "../images.ts";
+import { ImageNotFoundError } from "./machines.ts";
+
+const app = new Hono();
+
+app.get("/", (c) =>
+  Effect.runPromise(
+    pipe(
+      listVolumes(),
+      presentation(c),
+    ),
+  ));
+
+app.get("/:id", (c) =>
+  Effect.runPromise(
+    pipe(
+      parseParams(c),
+      Effect.flatMap(({ id }) => getVolume(id)),
+      presentation(c),
+    ),
+  ));
+
+app.delete("/:id", (c) =>
+  Effect.runPromise(
+    pipe(
+      parseParams(c),
+      Effect.flatMap(({ id }) =>
+        Effect.gen(function* () {
+          const volume = yield* getVolume(id);
+          yield* deleteVolume(id);
+          return volume;
+        })
+      ),
+      presentation(c),
+    ),
+  ));
+
+app.post("/", (c) =>
+  Effect.runPromise(
+    pipe(
+      parseCreateVolumeRequest(c),
+      Effect.flatMap((params: NewVolume) =>
+        Effect.gen(function* () {
+          const image = yield* getImage(params.baseImage);
+          if (!image) {
+            return yield* Effect.fail(
+              new ImageNotFoundError({ id: params.baseImage }),
+            );
+          }
+
+          return yield* createVolumeIfNeeded(image, params.name, params.size);
+        })
+      ),
+      presentation(c),
+      Effect.catchAll((error) => handleError(error, c)),
+    ),
+  ));
+
+export default app;

src/mod.ts

···
 export * from "./types.ts";
 export * from "./utils.ts";
 export * from "./volumes.ts";
+export * from "./api/mod.ts";

src/state.ts

···
         }),
       ),
   );
+
+export const listInstances = (
+  all: boolean,
+): Effect.Effect<VirtualMachine[], DbError, never> =>
+  Effect.tryPromise({
+    try: () =>
+      ctx.db.selectFrom("virtual_machines")
+        .selectAll()
+        .where((eb) => {
+          if (all) {
+            return eb("id", "!=", "");
+          }
+          return eb("status", "=", "RUNNING");
+        })
+        .execute(),
+    catch: (error) => new DbError({ cause: error }),
+  });

src/subcommands/run.ts

···
 function mergeFlags(image: Image): Options {
   const { flags } = parseFlags(Deno.args);
   return {
-    cpu: flags.cpu ? flags.cpu : Deno.build.arch === "aarch64" ? "max" : "host",
-    cpus: flags.cpus ? flags.cpus : 2,
-    memory: flags.memory ? flags.memory : "2G",
+    cpu: (flags.cpu || flags.c) ? (flags.cpu || flags.c) : "host",
+    cpus: (flags.cpus || flags.C) ? (flags.cpus || flags.C) : 2,
+    memory: (flags.memory || flags.m) ? (flags.memory || flags.m) : "2G",
     image: image.path,
-    bridge: flags.bridge,
-    portForward: flags.portForward,
-    detach: flags.detach,
+    bridge: flags.bridge || flags.b,
+    portForward: flags.portForward || flags.p,
+    detach: flags.detach || flags.d,
     install: false,
     diskFormat: image.format,
-    size: flags.size ? flags.size : "20G",
-    volume: flags.volume,
+    volume: flags.volume || flags.v,
+    size: flags.size || flags.s,
   };
 }

src/subcommands/start.ts

···
 import { parseFlags } from "@cliffy/flags";
 import _ from "@es-toolkit/es-toolkit/compat";
-import { Effect, pipe } from "effect";
+import { Data, Effect, pipe } from "effect";
 import { LOGS_DIR } from "../constants.ts";
 import type { VirtualMachine } from "../db.ts";
 import { getImage } from "../images.ts";
···
 import { setupNATNetworkArgs } from "../utils.ts";
 import { createVolume, getVolume } from "../volumes.ts";
 
+export class VmAlreadyRunningError
+  extends Data.TaggedError("VmAlreadyRunningError")<{
+    name: string;
+  }> {}
+
 const logStartingMessage = (vm: VirtualMachine) =>
   Effect.sync(() => {
     console.log(`Starting virtual machine ${vm.name} (ID: ${vm.id})...`);
   });
 
-const buildQemuArgs = (vm: VirtualMachine) => [
+export const buildQemuArgs = (vm: VirtualMachine) => [
   ..._.compact([vm.bridge && "qemu-system-x86_64"]),
   ...Deno.build.os === "linux" ? ["-enable-kvm"] : [],
   "-cpu",
···
   ),
 ];
 
-const createLogsDirectory = () =>
+export const createLogsDir = () =>
   Effect.tryPromise({
     try: () => Deno.mkdir(LOGS_DIR, { recursive: true }),
     catch: (cause) => new Error(`Failed to create logs directory: ${cause}`),
   });
 
-const buildDetachedCommand = (
+export const buildDetachedCommand = (
   vm: VirtualMachine,
   qemuArgs: string[],
   logPath: string,
···
     } >> "${logPath}" 2>&1 & echo $!`
     : `qemu-system-x86_64 ${qemuArgs.join(" ")} >> "${logPath}" 2>&1 & echo $!`;
 
-const startDetachedQemu = (fullCommand: string) =>
+export const startDetachedQemu = (fullCommand: string) =>
   Effect.tryPromise({
     try: async () => {
       const cmd = new Deno.Command("sh", {
         args: ["-c", fullCommand],
         stdin: "null",
         stdout: "piped",
-      });
+      }).spawn();
+
+      await new Promise((resolve) => setTimeout(resolve, 2000));
 
-      const { stdout } = await cmd.spawn().output();
+      const { stdout } = await cmd.output();
       return parseInt(new TextDecoder().decode(stdout).trim(), 10);
     },
     catch: (cause) => new Error(`Failed to start QEMU: ${cause}`),
···
 
 const startVirtualMachineDetached = (name: string, vm: VirtualMachine) =>
   Effect.gen(function* () {
+    yield* failIfVMRunning(vm);
     const volume = yield* createVolumeIfNeeded(vm);
     const qemuArgs = buildQemuArgs({
       ...vm,
···
     const logPath = `${LOGS_DIR}/${vm.name}.log`;
     const fullCommand = buildDetachedCommand(vm, qemuArgs, logPath);
 
-    return pipe(
-      createLogsDirectory(),
+    return yield* pipe(
+      createLogsDir(),
       Effect.flatMap(() => startDetachedQemu(fullCommand)),
       Effect.flatMap((qemuPid) =>
         pipe(
···
     }
   });
 
+export const failIfVMRunning = (vm: VirtualMachine) =>
+  Effect.gen(function* () {
+    if (vm.status === "RUNNING") {
+      return yield* Effect.fail(
+        new VmAlreadyRunningError({ name: vm.name }),
+      );
+    }
+    return vm;
+  });
+
 const createVolumeIfNeeded = (vm: VirtualMachine) =>
   Effect.gen(function* () {
     const { flags } = parseFlags(Deno.args);
···
 
 const startVirtualMachineAttached = (name: string, vm: VirtualMachine) => {
   return pipe(
-    createVolumeIfNeeded(vm),
+    failIfVMRunning(vm),
+    Effect.flatMap(() => createVolumeIfNeeded(vm)),
     Effect.flatMap((volume) =>
       Effect.succeed(
         buildQemuArgs({
···
   const { flags } = parseFlags(Deno.args);
   return {
     ...vm,
-    memory: flags.memory ? String(flags.memory) : vm.memory,
-    cpus: flags.cpus ? Number(flags.cpus) : vm.cpus,
-    cpu: flags.cpu ? String(flags.cpu) : vm.cpu,
+    memory: (flags.memory || flags.m)
+      ? String(flags.memory || flags.m)
+      : vm.memory,
+    cpus: (flags.cpus || flags.C) ? Number(flags.cpus || flags.C) : vm.cpus,
+    cpu: (flags.cpu || flags.c) ? String(flags.cpu || flags.c) : vm.cpu,
     diskFormat: flags.diskFormat ? String(flags.diskFormat) : vm.diskFormat,
-    portForward: flags.portForward ? String(flags.portForward) : vm.portForward,
-    drivePath: flags.image ? String(flags.image) : vm.drivePath,
-    bridge: flags.bridge ? String(flags.bridge) : vm.bridge,
-    diskSize: flags.size ? String(flags.size) : vm.diskSize,
+    portForward: (flags.portForward || flags.p)
+      ? String(flags.portForward || flags.p)
+      : vm.portForward,
+    drivePath: (flags.image || flags.i)
+      ? String(flags.image || flags.i)
+      : vm.drivePath,
+    bridge: (flags.bridge || flags.b)
+      ? String(flags.bridge || flags.b)
+      : vm.bridge,
+    diskSize: (flags.size || flags.s)
+      ? String(flags.size || flags.s)
+      : vm.diskSize,
   };
 }

src/subcommands/stop.ts

···
 import type { VirtualMachine } from "../db.ts";
 import { getInstanceState, updateInstanceState } from "../state.ts";
 
-class VmNotFoundError extends Data.TaggedError("VmNotFoundError")<{
+export class VmNotFoundError extends Data.TaggedError("VmNotFoundError")<{
   name: string;
 }> {}
 
-class StopCommandError extends Data.TaggedError("StopCommandError")<{
+export class StopCommandError extends Data.TaggedError("StopCommandError")<{
   vmName: string;
   exitCode: number;
 }> {}
 
-class CommandError extends Data.TaggedError("CommandError")<{
+export class CommandError extends Data.TaggedError("CommandError")<{
   cause?: unknown;
 }> {}
 
-const findVm = (name: string) =>
+export const findVm = (name: string) =>
   pipe(
     getInstanceState(name),
     Effect.flatMap((vm) =>
···
     );
   });
 
-const killProcess = (vm: VirtualMachine) =>
+export const killProcess = (vm: VirtualMachine) =>
   Effect.tryPromise({
     try: async () => {
       const cmd = new Deno.Command(vm.bridge ? "sudo" : "kill", {
···
     ),
   );
 
-const updateToStopped = (vm: VirtualMachine) =>
+export const updateToStopped = (vm: VirtualMachine) =>
   pipe(
     updateInstanceState(vm.name, "STOPPED"),
-    Effect.map(() => vm),
+    Effect.map(() => ({ ...vm, status: "STOPPED" } as VirtualMachine)),
   );
 
 const logSuccess = (vm: VirtualMachine) =>

src/types.ts

···
+import z from "@zod/zod";
+
 export type STATUS = "RUNNING" | "STOPPED";
+
+export const MachineParamsSchema = z.object({
+  portForward: z.array(z.string().regex(/^\d+:\d+$/)).optional(),
+  cpu: z.string().optional(),
+  cpus: z.number().min(1).optional(),
+  memory: z.string().regex(/^\d+(M|G)$/).optional(),
+});
+
+export type MachineParams = z.infer<typeof MachineParamsSchema>;
+
+export const NewMachineSchema = MachineParamsSchema.extend({
+  portForward: z.array(z.string().regex(/^\d+:\d+$/)).optional(),
+  cpu: z.string().default("host").optional(),
+  cpus: z.number().min(1).default(8).optional(),
+  memory: z.string().regex(/^\d+(M|G)$/).default("2G").optional(),
+  image: z.string().regex(
+    /^([a-zA-Z0-9\-\.]+\/)?([a-zA-Z0-9\-\.]+\/)?[a-zA-Z0-9\-\.]+(:[\w\.\-]+)?$/,
+  ),
+  volume: z.string().optional(),
+  bridge: z.string().optional(),
+});
+
+export type NewMachine = z.infer<typeof NewMachineSchema>;
+
+export const NewVolumeSchema = z.object({
+  name: z.string(),
+  baseImage: z.string().regex(
+    /^([a-zA-Z0-9\-\.]+\/)?([a-zA-Z0-9\-\.]+\/)?[a-zA-Z0-9\-\.]+(:[\w\.\-]+)?$/,
+  ),
+  size: z.string().regex(/^\d+(M|G|T)$/).optional(),
+});
+
+export type NewVolume = z.infer<typeof NewVolumeSchema>;

src/volumes.ts

···
 export const createVolume = (
   name: string,
   baseImage: Image,
+  size?: string,
 ): 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`);
+      if (!(await Deno.stat(path).catch(() => false))) {
+        await Deno.mkdir(VOLUME_DIR, { recursive: true });
+        const qemu = new Deno.Command("qemu-img", {
+          args: [
+            "create",
+            "-F",
+            "raw",
+            "-f",
+            "qcow2",
+            "-b",
+            baseImage.path,
+            path,
+            ...(size ? [size] : []),
+          ],
+          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}`,
+          );
+        }
       }
 
-      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,