fix: correct formatting and improve consistency in utils.ts

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;
     }
···
           chalk.blueBright(
             `Downloading ${
               url.endsWith(".iso") ? "ISO" : "image"
-            } from ${url}...`,
-          ),
+            } from ${url}...`
+          )
         );
         const cmd = new Deno.Command("curl", {
           args: ["-L", "-o", outputPath, url],
···
     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 [
···
 
 export const setupAlpineArgs = (
   imagePath?: string | null,
-  seed: string = "seed.iso",
+  seed: string = "seed.iso"
 ) =>
   Effect.sync(() => {
     if (
···
 
 export const setupDebianArgs = (
   imagePath?: string | null,
-  seed: string = "seed.iso",
+  seed: string = "seed.iso"
 ) =>
   Effect.sync(() => {
     if (
···
 
 export const setupUbuntuArgs = (
   imagePath?: string | null,
-  seed: string = "seed.iso",
+  seed: string = "seed.iso"
 ) =>
   Effect.sync(() => {
     if (
···
 
 export const setupAlmaLinuxArgs = (
   imagePath?: string | null,
-  seed: string = "seed.iso",
+  seed: string = "seed.iso"
 ) =>
   Effect.sync(() => {
     if (
···
 
 export const setupRockyLinuxArgs = (
   imagePath?: string | null,
-  seed: string = "seed.iso",
+  seed: string = "seed.iso"
 ) =>
   Effect.sync(() => {
     if (
···
   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);
     let fedoraArgs: string[] = yield* setupFedoraArgs(
       isoPath || options.image,
-      options.seed,
+      options.seed
     );
     let gentooArgs: string[] = yield* setupGentooArgs(
       isoPath || options.image,
-      options.seed,
+      options.seed
     );
     let alpineArgs: string[] = yield* setupAlpineArgs(
       isoPath || options.image,
-      options.seed,
+      options.seed
     );
     let debianArgs: string[] = yield* setupDebianArgs(
       isoPath || options.image,
-      options.seed,
+      options.seed
     );
     let ubuntuArgs: string[] = yield* setupUbuntuArgs(
       isoPath || options.image,
-      options.seed,
+      options.seed
     );
     let almalinuxArgs: string[] = yield* setupAlmaLinuxArgs(
       isoPath || options.image,
-      options.seed,
+      options.seed
     );
     let rockylinuxArgs: string[] = yield* setupRockyLinuxArgs(
       isoPath || options.image,
-      options.seed,
+      options.seed
     );
 
     if (coreosArgs.length > 0 && !isoPath) {
···
         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,
-  cloud: boolean = false,
+  cloud: boolean = false
 ): 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,
-  cloud: boolean = false,
+  cloud: boolean = false
 ): Effect.Effect<string, InvalidImageNameError, never> => {
   if (cloud && image === "debian") {
     return Effect.succeed(DEBIAN_CLOUD_IMG_URL);
···
   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.",
-    }),
+    })
   );
 };
 
 export const constructUbuntuImageURL = (
   image: string,
-  cloud: boolean = false,
+  cloud: boolean = false
 ): Effect.Effect<string, InvalidImageNameError, never> => {
   // detect with regex if image matches ubuntu pattern: ubuntu
   const ubuntuRegex = /^(ubuntu)$/;
···
     new InvalidImageNameError({
       image,
       cause: "Image name does not match Ubuntu naming conventions.",
-    }),
+    })
   );
 };
 
 export const constructAlmaLinuxImageURL = (
   image: string,
-  cloud: boolean = false,
+  cloud: boolean = false
 ): Effect.Effect<string, InvalidImageNameError, never> => {
-  // detect with regex if image matches almalinux pattern: ubuntu
-  const almaLinuxRegex = /^(almalinux)$/;
+  // detect with regex if image matches almalinux pattern: almalinux, almalinux
+  const almaLinuxRegex = /^(almalinux|alma)$/;
   const match = image.match(almaLinuxRegex);
   if (match) {
     if (cloud) {
···
     new InvalidImageNameError({
       image,
       cause: "Image name does not match AlmaLinux naming conventions.",
-    }),
+    })
   );
 };
 
 export const constructRockyLinuxImageURL = (
   image: string,
-  cloud: boolean = false,
+  cloud: boolean = false
 ): Effect.Effect<string, InvalidImageNameError, never> => {
-  // detect with regex if image matches rockylinux pattern: ubuntu
-  const rockyLinuxRegex = /^(rockylinux)$/;
+  // detect with regex if image matches rockylinux pattern: rocky. rockylinux
+  const rockyLinuxRegex = /^(rockylinux|rocky)$/;
   const match = image.match(rockyLinuxRegex);
   if (match) {
     if (cloud) {
···
     new InvalidImageNameError({
       image,
       cause: "Image name does not match RockyLinux naming conventions.",
-    }),
+    })
   );
 };