feat: add support for Gentoo image handling and URL construction

main.ts

···
 import * as volumes from "./src/subcommands/volume.ts";
 import {
   constructFedoraImageURL,
+  constructGentooImageURL,
   constructNixOSImageURL,
   createDriveImageIfNeeded,
   downloadIso,
···
               isoPath = yield* downloadIso(fedoraImageURL, options);
             } else {
               isoPath = basename(fedoraImageURL);
+            }
+          }
+
+          const gentooImageURL = yield* pipe(
+            constructGentooImageURL(input),
+            Effect.catchAll(() => Effect.succeed(null)),
+          );
+
+          if (gentooImageURL) {
+            const cached = yield* pipe(
+              basename(gentooImageURL),
+              fileExists,
+              Effect.flatMap(() => Effect.succeed(true)),
+              Effect.catchAll(() => Effect.succeed(false)),
+            );
+            if (!cached) {
+              isoPath = yield* downloadIso(gentooImageURL, options);
+            } else {
+              isoPath = basename(gentooImageURL);
             }
           }
         }

src/constants.ts

···
 
 export const FEDORA_IMG_URL: string =
   `https://download.fedoraproject.org/pub/fedora/linux/releases/43/Server/${Deno.build.arch}/images/Fedora-Server-Guest-Generic-43-1.6.${Deno.build.arch}.qcow2`;
+
+export const GENTOO_IMG_URL: string = Deno.build.arch === "aarch64"
+  ? "https://distfiles.gentoo.org/releases/arm64/autobuilds/20251116T233105Z/di-arm64-console-20251116T233105Z.qcow2"
+  : "https://distfiles.gentoo.org/releases/amd64/autobuilds/20251116T161545Z/di-amd64-console-20251116T161545Z.qcow2";

src/utils.ts

···
   FEDORA_COREOS_DEFAULT_VERSION,
   FEDORA_COREOS_IMG_URL,
   FEDORA_IMG_URL,
+  GENTOO_IMG_URL,
   LOGS_DIR,
   NIXOS_DEFAULT_VERSION,
   NIXOS_ISO_URL,
···
 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);
       }
···
     return [];
   });
 
+export const setupGentooArgs = (imagePath?: string | null) =>
+  Effect.sync(() => {
+    if (
+      imagePath &&
+      imagePath.endsWith(".qcow2") &&
+      imagePath.startsWith(
+        `di-${Deno.build.arch === "aarch64" ? "arm64" : "amd64"}-console-`
+      )
+    ) {
+      return ["-drive", `file=${imagePath},format=qcow2,if=virtio`];
+    }
+
+    return [];
+  });
+
 export const runQemu = (isoPath: string | null, options: Options) =>
   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);
+    let gentooArgs: string[] = yield* setupGentooArgs(isoPath || options.image);
 
     if (coreosArgs.length > 0 && !isoPath) {
       coreosArgs = coreosArgs.slice(2);
···
 
     if (fedoraArgs.length > 0 && !isoPath) {
       fedoraArgs = [];
+    }
+
+    if (gentooArgs.length > 0 && !isoPath) {
+      gentooArgs = [];
     }
 
     const qemuArgs = [
···
       ...firmwareFiles,
       ...coreosArgs,
       ...fedoraArgs,
+      ...gentooArgs,
       ..._.compact(
         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
+): 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))?$/;
+  const match = image.match(gentooRegex);
+  if (match?.[3]) {
+    return Effect.succeed(
+      GENTOO_IMG_URL.replaceAll("20251116T161545Z", match[3]).replaceAll(
+        "20251116T233105Z",
+        match[3]
+      )
+    );
+  }
+
+  if (match) {
+    return Effect.succeed(GENTOO_IMG_URL);
+  }
+
+  return Effect.fail(
+    new InvalidImageNameError({
+      image,
+      cause: "Image name does not match Gentoo naming conventions.",
+    })
   );
 };

src/utils_test.ts

···
 import { assertEquals } from "@std/assert";
 import { Effect, pipe } from "effect";
-import { FEDORA_COREOS_IMG_URL, NIXOS_ISO_URL } from "./constants.ts";
-import { constructCoreOSImageURL, constructNixOSImageURL } from "./utils.ts";
+import {
+  FEDORA_COREOS_IMG_URL,
+  GENTOO_IMG_URL,
+  NIXOS_ISO_URL,
+} from "./constants.ts";
+import {
+  constructCoreOSImageURL,
+  constructGentooImageURL,
+  constructNixOSImageURL,
+} from "./utils.ts";
 
 Deno.test("Test Default Fedora CoreOS Image URL", () => {
   const url = Effect.runSync(
     pipe(
       constructCoreOSImageURL("fedora-coreos"),
-      Effect.catchAll((_error) => Effect.succeed(null as string | null)),
-    ),
+      Effect.catchAll((_error) => Effect.succeed(null as string | null))
+    )
   );
 
   assertEquals(url, FEDORA_COREOS_IMG_URL);
···
   const url = Effect.runSync(
     pipe(
       constructCoreOSImageURL("coreos"),
-      Effect.catchAll((_error) => Effect.succeed(null as string | null)),
-    ),
+      Effect.catchAll((_error) => Effect.succeed(null as string | null))
+    )
   );
 
   assertEquals(url, FEDORA_COREOS_IMG_URL);
···
   const url = Effect.runSync(
     pipe(
       constructCoreOSImageURL("fedora-coreos-43.20251024.2.0"),
-      Effect.catchAll((_error) => Effect.succeed(null as string | null)),
-    ),
+      Effect.catchAll((_error) => Effect.succeed(null as string | null))
+    )
   );
 
   assertEquals(
     url,
     "https://builds.coreos.fedoraproject.org/prod/streams/stable/builds/43.20251024.2.0/" +
-      `${Deno.build.arch}/fedora-coreos-43.20251024.2.0-qemu.${Deno.build.arch}.qcow2.xz`,
+      `${Deno.build.arch}/fedora-coreos-43.20251024.2.0-qemu.${Deno.build.arch}.qcow2.xz`
   );
 });
 
···
   const url = Effect.runSync(
     pipe(
       constructCoreOSImageURL("fedora-coreos-latest"),
-      Effect.catchAll((_error) => Effect.succeed(null as string | null)),
-    ),
+      Effect.catchAll((_error) => Effect.succeed(null as string | null))
+    )
   );
 
   assertEquals(url, null);
···
   const url = Effect.runSync(
     pipe(
       constructNixOSImageURL("nixos"),
-      Effect.catchAll((_error) => Effect.succeed(null as string | null)),
-    ),
+      Effect.catchAll((_error) => Effect.succeed(null as string | null))
+    )
   );
 
   assertEquals(url, NIXOS_ISO_URL);
···
   const url = Effect.runSync(
     pipe(
       constructNixOSImageURL("nixos-24.05"),
-      Effect.catchAll((_error) => Effect.succeed(null as string | null)),
-    ),
+      Effect.catchAll((_error) => Effect.succeed(null as string | null))
+    )
   );
 
   assertEquals(
     url,
-    `https://channels.nixos.org/nixos-24.05/latest-nixos-minimal-${Deno.build.arch}-linux.iso`,
+    `https://channels.nixos.org/nixos-24.05/latest-nixos-minimal-${Deno.build.arch}-linux.iso`
   );
 });
 
···
   const url = Effect.runSync(
     pipe(
       constructNixOSImageURL("nixos-latest"),
-      Effect.catchAll((_error) => Effect.succeed(null as string | null)),
-    ),
+      Effect.catchAll((_error) => Effect.succeed(null as string | null))
+    )
+  );
+
+  assertEquals(url, null);
+});
+
+Deno.test("Test valid Gentoo Image Name", () => {
+  const url = Effect.runSync(
+    pipe(
+      constructGentooImageURL("gentoo-20251116T161545Z"),
+      Effect.catchAll((_error) => Effect.succeed(null as string | null))
+    )
+  );
+
+  const arch = Deno.build.arch === "aarch64" ? "arm64" : "amd64";
+  assertEquals(
+    url,
+    `https://distfiles.gentoo.org/releases/${arch}/autobuilds/20251116T161545Z/di-${arch}-console-20251116T161545Z.qcow2`
+  );
+});
+
+Deno.test("Test valid Gentoo Image Name", () => {
+  const url = Effect.runSync(
+    pipe(
+      constructGentooImageURL("gentoo"),
+      Effect.catchAll((_error) => Effect.succeed(null as string | null))
+    )
+  );
+
+  assertEquals(url, GENTOO_IMG_URL);
+});
+
+Deno.test("Test invalid Gentoo Image Name", () => {
+  const url = Effect.runSync(
+    pipe(
+      constructGentooImageURL("gentoo-latest"),
+      Effect.catchAll((_error) => Effect.succeed(null as string | null))
+    )
   );
 
   assertEquals(url, null);