run format

src/subcommands/restart.ts

···
     getInstanceState(name),
     Effect.flatMap((vm) =>
       vm ? Effect.succeed(vm) : Effect.fail(new VmNotFoundError({ name }))
-    )
+    ),
   );
 
 const killQemu = (vm: VirtualMachine) =>
···
       success
         ? Effect.succeed(vm)
         : Effect.fail(new KillQemuError({ vmName: vm.name }))
-    )
+    ),
   );
 
 const sleep = (ms: number) =>
···
 const setupFirmware = () => setupFirmwareFilesIfNeeded();
 
 const buildQemuArgs = (vm: VirtualMachine, firmwareArgs: string[]) => {
-  const qemu =
-    Deno.build.arch === "aarch64"
-      ? "qemu-system-aarch64"
-      : "qemu-system-x86_64";
+  const qemu = Deno.build.arch === "aarch64"
+    ? "qemu-system-aarch64"
+    : "qemu-system-x86_64";
 
   let coreosArgs: string[] = Effect.runSync(setupCoreOSArgs(vm.drivePath));
   let alpineArgs: string[] = Effect.runSync(setupAlpineArgs(vm.isoPath));
···
       vm.drivePath && [
         "-drive",
         `file=${vm.drivePath},format=${vm.diskFormat},if=virtio`,
-      ]
+      ],
     ),
     ...coreosArgs,
     ...alpineArgs,
···
 };
 
 const startQemu = (vm: VirtualMachine, qemuArgs: string[]) => {
-  const qemu =
-    Deno.build.arch === "aarch64"
-      ? "qemu-system-aarch64"
-      : "qemu-system-x86_64";
+  const qemu = Deno.build.arch === "aarch64"
+    ? "qemu-system-aarch64"
+    : "qemu-system-x86_64";
 
   const logPath = `${LOGS_DIR}/${vm.name}.log`;
 
   const fullCommand = vm.bridge
-    ? `sudo ${qemu} ${qemuArgs
+    ? `sudo ${qemu} ${
+      qemuArgs
         .slice(1)
-        .join(" ")} >> "${logPath}" 2>&1 & echo $!`
+        .join(" ")
+    } >> "${logPath}" 2>&1 & echo $!`
     : `${qemu} ${qemuArgs.join(" ")} >> "${logPath}" 2>&1 & echo $!`;
 
   return Effect.tryPromise({
···
 const logSuccess = (vm: VirtualMachine, qemuPid: number, logPath: string) =>
   Effect.sync(() => {
     console.log(
-      `${chalk.greenBright(vm.name)} restarted with PID ${chalk.greenBright(
-        qemuPid
-      )}.`
+      `${chalk.greenBright(vm.name)} restarted with PID ${
+        chalk.greenBright(
+          qemuPid,
+        )
+      }.`,
     );
     console.log(`Logs are being written to ${chalk.blueBright(logPath)}`);
   });
 
 const handleError = (
-  error: VmNotFoundError | KillQemuError | CommandError | Error
+  error: VmNotFoundError | KillQemuError | CommandError | Error,
 ) =>
   Effect.sync(() => {
     if (error instanceof VmNotFoundError) {
       console.error(
-        `Virtual machine with name or ID ${chalk.greenBright(
-          error.name
-        )} not found.`
+        `Virtual machine with name or ID ${
+          chalk.greenBright(
+            error.name,
+          )
+        } not found.`,
       );
     } else if (error instanceof KillQemuError) {
       console.error(
-        `Failed to stop virtual machine ${chalk.greenBright(error.vmName)}.`
+        `Failed to stop virtual machine ${chalk.greenBright(error.vmName)}.`,
       );
     } else {
       console.error(`An error occurred: ${error}`);
···
           pipe(
             updateInstanceState(vm.id, "RUNNING", qemuPid),
             Effect.flatMap(() => logSuccess(vm, qemuPid, logPath)),
-            Effect.flatMap(() => sleep(2000))
+            Effect.flatMap(() => sleep(2000)),
           )
-        )
+        ),
       )
     ),
-    Effect.catchAll(handleError)
+    Effect.catchAll(handleError),
   );
 
 export default async function (name: string) {

src/subcommands/run.ts

···
           pulledImg
             ? Effect.succeed(pulledImg)
             : Effect.fail(new PullImageError({ cause: "Failed to pull image" }))
-        )
+        ),
       );
-    })
+    }),
   );
 
 const createVolumeIfNeeded = (
-  image: Image
+  image: Image,
 ): Effect.Effect<[Image, Volume?], Error, never> =>
   parseFlags(Deno.args).flags.volume
     ? Effect.gen(function* () {
-        const size = parseFlags(Deno.args).flags.size as string | undefined;
-        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, size);
-        return [image, newVolume];
-      })
+      const size = parseFlags(Deno.args).flags.size as string | undefined;
+      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, size);
+      return [image, newVolume];
+    })
     : Effect.succeed([image]);
 
 const runImage = ([image, volume]: [Image, Volume?]) =>
···
           console.error(`Failed to run image: ${error.cause} ${image}`);
           Deno.exit(1);
         })
-      )
-    )
+      ),
+    ),
   );
 }
 

src/subcommands/start.ts

···
 }> {}
 
 export class VmAlreadyRunningError extends Data.TaggedError(
-  "VmAlreadyRunningError"
+  "VmAlreadyRunningError",
 )<{
   name: string;
 }> {}
···
     getInstanceState(name),
     Effect.flatMap((vm) =>
       vm ? Effect.succeed(vm) : Effect.fail(new VmNotFoundError({ name }))
-    )
+    ),
   );
 
 const logStarting = (vm: VirtualMachine) =>
···
 export const setupFirmware = () => setupFirmwareFilesIfNeeded();
 
 export const buildQemuArgs = (vm: VirtualMachine, firmwareArgs: string[]) => {
-  const qemu =
-    Deno.build.arch === "aarch64"
-      ? "qemu-system-aarch64"
-      : "qemu-system-x86_64";
+  const qemu = Deno.build.arch === "aarch64"
+    ? "qemu-system-aarch64"
+    : "qemu-system-x86_64";
 
   let coreosArgs: string[] = Effect.runSync(setupCoreOSArgs(vm.drivePath));
   let alpineArgs: string[] = Effect.runSync(setupAlpineArgs(vm.isoPath));
···
       vm.drivePath && [
         "-drive",
         `file=${vm.drivePath},format=${vm.diskFormat},if=virtio`,
-      ]
+      ],
     ),
     ...coreosArgs,
     ...alpineArgs,
···
 export const startDetachedQemu = (
   name: string,
   vm: VirtualMachine,
-  qemuArgs: string[]
+  qemuArgs: string[],
 ) => {
-  const qemu =
-    Deno.build.arch === "aarch64"
-      ? "qemu-system-aarch64"
-      : "qemu-system-x86_64";
+  const qemu = Deno.build.arch === "aarch64"
+    ? "qemu-system-aarch64"
+    : "qemu-system-x86_64";
 
   const logPath = `${LOGS_DIR}/${vm.name}.log`;
 
   const fullCommand = vm.bridge
-    ? `sudo ${qemu} ${qemuArgs
+    ? `sudo ${qemu} ${
+      qemuArgs
         .slice(1)
-        .join(" ")} >> "${logPath}" 2>&1 & echo $!`
+        .join(" ")
+    } >> "${logPath}" 2>&1 & echo $!`
     : `${qemu} ${qemuArgs.join(" ")} >> "${logPath}" 2>&1 & echo $!`;
 
   return Effect.tryPromise({
···
     Effect.flatMap(({ qemuPid, logPath }) =>
       pipe(
         updateInstanceState(name, "RUNNING", qemuPid),
-        Effect.map(() => ({ vm, qemuPid, logPath }))
+        Effect.map(() => ({ vm, qemuPid, logPath })),
       )
-    )
+    ),
   );
 };
 
···
 }) =>
   Effect.sync(() => {
     console.log(
-      `Virtual machine ${vm.name} started in background (PID: ${qemuPid})`
+      `Virtual machine ${vm.name} started in background (PID: ${qemuPid})`,
     );
     console.log(`Logs will be written to: ${logPath}`);
   });
···
 const startInteractiveQemu = (
   name: string,
   vm: VirtualMachine,
-  qemuArgs: string[]
+  qemuArgs: string[],
 ) => {
-  const qemu =
-    Deno.build.arch === "aarch64"
-      ? "qemu-system-aarch64"
-      : "qemu-system-x86_64";
+  const qemu = Deno.build.arch === "aarch64"
+    ? "qemu-system-aarch64"
+    : "qemu-system-x86_64";
 
   return Effect.tryPromise({
     try: async () => {
···
   });
 
 export const createVolumeIfNeeded = (
-  vm: VirtualMachine
+  vm: VirtualMachine,
 ): Effect.Effect<[VirtualMachine, Volume?], Error, never> =>
   Effect.gen(function* () {
     const { flags } = parseFlags(Deno.args);
···
 
     if (!vm.drivePath) {
       throw new Error(
-        `Cannot create volume: Virtual machine ${vm.name} has no drivePath defined.`
+        `Cannot create volume: Virtual machine ${vm.name} has no drivePath defined.`,
       );
     }
 
···
               diskFormat: volume ? "qcow2" : vm.diskFormat,
               volume: volume?.path,
             },
-            firmwareArgs
+            firmwareArgs,
           )
         ),
         Effect.flatMap((qemuArgs) =>
···
               startDetachedQemu(name, { ...vm, volume: volume?.path }, qemuArgs)
             ),
             Effect.tap(logDetachedSuccess),
-            Effect.map(() => 0) // Exit code 0
+            Effect.map(() => 0), // Exit code 0
           )
-        )
+        ),
       )
     ),
-    Effect.catchAll(handleError)
+    Effect.catchAll(handleError),
   );
 
 const startInteractiveEffect = (name: string) =>
···
               diskFormat: volume ? "qcow2" : vm.diskFormat,
               volume: volume?.path,
             },
-            firmwareArgs
+            firmwareArgs,
           )
         ),
         Effect.flatMap((qemuArgs) =>
           startInteractiveQemu(name, { ...vm, volume: volume?.path }, qemuArgs)
         ),
-        Effect.map((status) => (status.success ? 0 : status.code || 1))
+        Effect.map((status) => (status.success ? 0 : status.code || 1)),
       )
     ),
-    Effect.catchAll(handleError)
+    Effect.catchAll(handleError),
   );
 
 export default async function (name: string, detach: boolean = false) {
   const exitCode = await Effect.runPromise(
-    detach ? startDetachedEffect(name) : startInteractiveEffect(name)
+    detach ? startDetachedEffect(name) : startInteractiveEffect(name),
   );
 
   if (detach) {
···
   const { flags } = parseFlags(Deno.args);
   return {
     ...vm,
-    memory:
-      flags.memory || flags.m ? String(flags.memory || flags.m) : vm.memory,
+    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 || 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,
+    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/utils.ts

···
 export const isValidISOurl = (url?: string): boolean => {
   return Boolean(
     (url?.startsWith("http://") || url?.startsWith("https://")) &&
-      url?.endsWith(".iso")
+      url?.endsWith(".iso"),
   );
 };
 
···
   });
 
 export const validateImage = (
-  image: string
+  image: string,
 ): Effect.Effect<string, InvalidImageNameError, never> => {
   const regex =
     /^(?:[a-zA-Z0-9.-]+(?:\.[a-zA-Z0-9.-]+)*\/)?[a-z0-9]+(?:[._-][a-z0-9]+)*\/[a-z0-9]+(?:[._-][a-z0-9]+)*(?::[a-zA-Z0-9._-]+)?$/;
···
         image,
         cause:
           "Image name does not conform to expected format. Should be in the format 'repository/name:tag'.",
-      })
+      }),
     );
   }
   return Effect.succeed(image);
···
 export const extractTag = (name: string) =>
   pipe(
     validateImage(name),
-    Effect.flatMap((image) => Effect.succeed(image.split(":")[1] || "latest"))
+    Effect.flatMap((image) => Effect.succeed(image.split(":")[1] || "latest")),
   );
 
 export const failOnMissingImage = (
-  image: Image | undefined
+  image: Image | undefined,
 ): Effect.Effect<Image, Error, never> =>
   image
     ? Effect.succeed(image)
     : Effect.fail(new NoSuchImageError({ cause: "No such image" }));
 
 export const du = (
-  path: string
+  path: string,
 ): Effect.Effect<number, LogCommandError, never> =>
   Effect.tryPromise({
     try: async () => {
···
       exists
         ? Effect.succeed(true)
         : du(path).pipe(Effect.map((size) => size < EMPTY_DISK_THRESHOLD_KB))
-    )
+    ),
   );
 
 export const downloadIso = (url: string, options: Options) =>
···
         if (driveSize > EMPTY_DISK_THRESHOLD_KB) {
           console.log(
             chalk.yellowBright(
-              `Drive image ${options.image} is not empty (size: ${driveSize} KB), skipping ISO download to avoid overwriting existing data.`
-            )
+              `Drive image ${options.image} is not empty (size: ${driveSize} KB), skipping ISO download to avoid overwriting existing data.`,
+            ),
           );
           return null;
         }
···
     if (outputExists) {
       console.log(
         chalk.yellowBright(
-          `File ${outputPath} already exists, skipping download.`
-        )
+          `File ${outputPath} already exists, skipping download.`,
+        ),
       );
       return outputPath;
     }
···
     if (!success) {
       console.error(
         chalk.redBright(
-          "Failed to get QEMU prefix from Homebrew. Ensure QEMU is installed via Homebrew."
-        )
+          "Failed to get QEMU prefix from Homebrew. Ensure QEMU is installed via Homebrew.",
+        ),
       );
       Deno.exit(1);
     }
···
       try: () =>
         Deno.copyFile(
           `${brewPrefix}/share/qemu/edk2-arm-vars.fd`,
-          edk2VarsAarch64
+          edk2VarsAarch64,
         ),
       catch: (error) => new LogCommandError({ cause: error }),
     });
···
       const configOK = yield* pipe(
         fileExists("config.ign"),
         Effect.flatMap(() => Effect.succeed(true)),
-        Effect.catchAll(() => Effect.succeed(false))
+        Effect.catchAll(() => Effect.succeed(false)),
       );
       if (!configOK) {
         console.error(
           chalk.redBright(
-            "CoreOS image requires a config.ign file in the current directory."
-          )
+            "CoreOS image requires a config.ign file in the current directory.",
+          ),
         );
         Deno.exit(1);
       }
···
       imagePath &&
       imagePath.endsWith(".qcow2") &&
       imagePath.startsWith(
-        `di-${Deno.build.arch === "aarch64" ? "arm64" : "amd64"}-console-`
+        `di-${Deno.build.arch === "aarch64" ? "arm64" : "amd64"}-console-`,
       )
     ) {
       return ["-drive", `file=${imagePath},format=qcow2,if=virtio`];
···
   Effect.gen(function* () {
     const macAddress = yield* generateRandomMacAddress();
 
-    const qemu =
-      Deno.build.arch === "aarch64"
-        ? "qemu-system-aarch64"
-        : "qemu-system-x86_64";
+    const qemu = Deno.build.arch === "aarch64"
+      ? "qemu-system-aarch64"
+      : "qemu-system-x86_64";
 
     const firmwareFiles = yield* setupFirmwareFilesIfNeeded();
     let coreosArgs: string[] = yield* setupCoreOSArgs(isoPath || options.image);
···
         options.image && [
           "-drive",
           `file=${options.image},format=${options.diskFormat},if=virtio`,
-        ]
+        ],
       ),
     ];
 
···
       const logPath = `${LOGS_DIR}/${name}.log`;
 
       const fullCommand = options.bridge
-        ? `sudo ${qemu} ${qemuArgs
+        ? `sudo ${qemu} ${
+          qemuArgs
             .slice(1)
-            .join(" ")} >> "${logPath}" 2>&1 & echo $!`
+            .join(" ")
+        } >> "${logPath}" 2>&1 & echo $!`
         : `${qemu} ${qemuArgs.join(" ")} >> "${logPath}" 2>&1 & echo $!`;
 
       const { stdout } = yield* Effect.tryPromise({
···
         cpus: options.cpus,
         cpu: options.cpu,
         diskSize: options.size || "20G",
-        diskFormat:
-          (isoPath?.endsWith(".qcow2") ? "qcow2" : undefined) ||
+        diskFormat: (isoPath?.endsWith(".qcow2") ? "qcow2" : undefined) ||
           options.diskFormat ||
           "raw",
         portForward: options.portForward,
···
       });
 
       console.log(
-        `Virtual machine ${name} started in background (PID: ${qemuPid})`
+        `Virtual machine ${name} started in background (PID: ${qemuPid})`,
       );
       console.log(`Logs will be written to: ${logPath}`);
 
···
         cpus: options.cpus,
         cpu: options.cpu,
         diskSize: options.size || "20G",
-        diskFormat:
-          (isoPath?.endsWith(".qcow2") ? "qcow2" : undefined) ||
+        diskFormat: (isoPath?.endsWith(".qcow2") ? "qcow2" : undefined) ||
           options.diskFormat ||
           "raw",
         portForward: options.portForward,
···
     if (pathExists) {
       console.log(
         chalk.yellowBright(
-          `Drive image ${path} already exists, skipping creation.`
-        )
+          `Drive image ${path} already exists, skipping creation.`,
+        ),
       );
       return;
     }
···
   });
 
 export const fileExists = (
-  path: string
+  path: string,
 ): Effect.Effect<void, NoSuchFileError, never> =>
   Effect.try({
     try: () => Deno.statSync(path),
···
   });
 
 export const constructCoreOSImageURL = (
-  image: string
+  image: string,
 ): Effect.Effect<string, InvalidImageNameError, never> => {
   // detect with regex if image matches coreos pattern: fedora-coreos or fedora-coreos-<version> or coreos or coreos-<version>
   const coreosRegex = /^(fedora-coreos|coreos)(-(\d+\.\d+\.\d+\.\d+))?$/;
···
   if (match) {
     const version = match[3] || FEDORA_COREOS_DEFAULT_VERSION;
     return Effect.succeed(
-      FEDORA_COREOS_IMG_URL.replaceAll(FEDORA_COREOS_DEFAULT_VERSION, version)
+      FEDORA_COREOS_IMG_URL.replaceAll(FEDORA_COREOS_DEFAULT_VERSION, version),
     );
   }
 
···
     new InvalidImageNameError({
       image,
       cause: "Image name does not match CoreOS naming conventions.",
-    })
+    }),
   );
 };
 
···
   });
 
 export const constructNixOSImageURL = (
-  image: string
+  image: string,
 ): Effect.Effect<string, InvalidImageNameError, never> => {
   // detect with regex if image matches NixOS pattern: nixos or nixos-<version>
   const nixosRegex = /^(nixos)(-(\d+\.\d+))?$/;
···
   if (match) {
     const version = match[3] || NIXOS_DEFAULT_VERSION;
     return Effect.succeed(
-      NIXOS_ISO_URL.replaceAll(NIXOS_DEFAULT_VERSION, version)
+      NIXOS_ISO_URL.replaceAll(NIXOS_DEFAULT_VERSION, version),
     );
   }
 
···
     new InvalidImageNameError({
       image,
       cause: "Image name does not match NixOS naming conventions.",
-    })
+    }),
   );
 };
 
 export const constructFedoraImageURL = (
-  image: string
+  image: string,
 ): Effect.Effect<string, InvalidImageNameError, never> => {
   // detect with regex if image matches Fedora pattern: fedora
   const fedoraRegex = /^(fedora)$/;
···
     new InvalidImageNameError({
       image,
       cause: "Image name does not match Fedora naming conventions.",
-    })
+    }),
   );
 };
 
 export const constructGentooImageURL = (
-  image: string
+  image: string,
 ): Effect.Effect<string, InvalidImageNameError, never> => {
   // detect with regex if image matches genroo pattern: gentoo-20251116T161545Z or gentoo
   const gentooRegex = /^(gentoo)(-(\d{8}T\d{6}Z))?$/;
···
     return Effect.succeed(
       GENTOO_IMG_URL.replaceAll("20251116T161545Z", match[3]).replaceAll(
         "20251116T233105Z",
-        match[3]
-      )
+        match[3],
+      ),
     );
   }
 
···
     new InvalidImageNameError({
       image,
       cause: "Image name does not match Gentoo naming conventions.",
-    })
+    }),
   );
 };
 
 export const constructDebianImageURL = (
-  image: string
+  image: string,
 ): Effect.Effect<string, InvalidImageNameError, never> => {
   // detect with regex if image matches debian pattern: debian-<version> or debian
   const debianRegex = /^(debian)(-(\d+\.\d+\.\d+))?$/;
   const match = image.match(debianRegex);
   if (match?.[3]) {
     return Effect.succeed(
-      DEBIAN_ISO_URL.replaceAll(DEBIAN_DEFAULT_VERSION, match[3])
+      DEBIAN_ISO_URL.replaceAll(DEBIAN_DEFAULT_VERSION, match[3]),
     );
   }
 
···
     new InvalidImageNameError({
       image,
       cause: "Image name does not match Debian naming conventions.",
-    })
+    }),
   );
 };
 
 export const constructAlpineImageURL = (
-  image: string
+  image: string,
 ): Effect.Effect<string, InvalidImageNameError, never> => {
   // detect with regex if image matches alpine pattern: alpine-<version> or alpine
   const alpineRegex = /^(alpine)(-(\d+\.\d+(\.\d+)?))?$/;
   const match = image.match(alpineRegex);
   if (match?.[3]) {
     return Effect.succeed(
-      ALPINE_ISO_URL.replaceAll(ALPINE_DEFAULT_VERSION, match[3])
+      ALPINE_ISO_URL.replaceAll(ALPINE_DEFAULT_VERSION, match[3]),
     );
   }
 
···
     new InvalidImageNameError({
       image,
       cause: "Image name does not match Alpine naming conventions.",
-    })
+    }),
   );
 };