run format

deno.json

···
     "kysely": "npm:kysely@0.27.6",
     "moniker": "npm:moniker@^0.1.2"
   }
-}
+}

src/api/machines.ts

···
       Effect.flatMap((params) =>
         listInstances(params.all === "true" || params.all === "1")
       ),
-      presentation(c)
-    )
-  )
-);
+      presentation(c),
+    ),
+  ));
 
 app.post("/", (c) =>
   Effect.runPromise(
···
           const image = yield* getImage(params.image);
           if (!image) {
             return yield* Effect.fail(
-              new ImageNotFoundError({ id: params.image })
+              new ImageNotFoundError({ id: params.image }),
             );
           }
 
···
                   sshPwauth: false,
                 },
               },
-              tempDir
+              tempDir,
             );
           }
 
···
             seed: _.get(
               params,
               "seed",
-              params.users ? `${SEED_DIR}/seed-${name}.iso` : undefined
+              params.users ? `${SEED_DIR}/seed-${name}.iso` : undefined,
             ),
             pid: 0,
           });
···
         })
       ),
       presentation(c),
-      Effect.catchAll((error) => handleError(error, c))
-    )
-  )
-);
+      Effect.catchAll((error) => handleError(error, c)),
+    ),
+  ));
 
 app.get("/:id", (c) =>
   Effect.runPromise(
     pipe(
       parseParams(c),
       Effect.flatMap(({ id }) => getInstanceState(id)),
-      presentation(c)
-    )
-  )
-);
+      presentation(c),
+    ),
+  ));
 
 app.delete("/:id", (c) =>
   Effect.runPromise(
···
         })
       ),
       presentation(c),
-      Effect.catchAll((error) => handleError(error, c))
-    )
-  )
-);
+      Effect.catchAll((error) => handleError(error, c)),
+    ),
+  ));
 
 app.post("/:id/start", (c) =>
   Effect.runPromise(
···
                 ? startRequest.portForward.join(",")
                 : vm.portForward,
             },
-            firmwareArgs
+            firmwareArgs,
           );
           yield* createLogsDir();
           yield* startDetachedQemu(vm.id, vm, qemuArgs);
···
         })
       ),
       presentation(c),
-      Effect.catchAll((error) => handleError(error, c))
-    )
-  )
-);
+      Effect.catchAll((error) => handleError(error, c)),
+    ),
+  ));
 
 app.post("/:id/stop", (c) =>
   Effect.runPromise(
···
       Effect.flatMap(killProcess),
       Effect.flatMap(updateToStopped),
       presentation(c),
-      Effect.catchAll((error) => handleError(error, c))
-    )
-  )
-);
+      Effect.catchAll((error) => handleError(error, c)),
+    ),
+  ));
 
 app.post("/:id/restart", (c) =>
   Effect.runPromise(
···
                 ? startRequest.portForward.join(",")
                 : vm.portForward,
             },
-            firmwareArgs
+            firmwareArgs,
           );
           yield* createLogsDir();
           yield* startDetachedQemu(vm.id, vm, qemuArgs);
···
         })
       ),
       presentation(c),
-      Effect.catchAll((error) => handleError(error, c))
-    )
-  )
-);
+      Effect.catchAll((error) => handleError(error, c)),
+    ),
+  ));
 
 export default app;

src/migrations.ts

···
       .addColumn("isoPath", "varchar")
       .addColumn("status", "varchar", (col) => col.notNull())
       .addColumn("pid", "integer")
-      .addColumn("createdAt", "varchar", (col) =>
-        col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`)
+      .addColumn(
+        "createdAt",
+        "varchar",
+        (col) => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`),
       )
-      .addColumn("updatedAt", "varchar", (col) =>
-        col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`)
+      .addColumn(
+        "updatedAt",
+        "varchar",
+        (col) => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`),
       )
       .execute();
   },
···
       .addColumn("size", "integer", (col) => col.notNull())
       .addColumn("path", "varchar", (col) => col.notNull())
       .addColumn("format", "varchar", (col) => col.notNull().defaultTo("qcow2"))
-      .addColumn("createdAt", "varchar", (col) =>
-        col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`)
+      .addColumn(
+        "createdAt",
+        "varchar",
+        (col) => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`),
       )
       .addUniqueConstraint("images_repository_tag_unique", [
         "repository",
···
       .createTable("volumes")
       .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(
+        "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`)
+      .addColumn(
+        "createdAt",
+        "varchar",
+        (col) => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`),
       )
       .execute();
   },
···
       .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(
+        "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`)
+      .addColumn(
+        "createdAt",
+        "varchar",
+        (col) => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`),
       )
       .execute();
 
···
       .addColumn("pid", "integer")
       .addColumn("volume", "varchar")
       .addColumn("seed", "varchar")
-      .addColumn("createdAt", "varchar", (col) =>
-        col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`)
+      .addColumn(
+        "createdAt",
+        "varchar",
+        (col) => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`),
       )
-      .addColumn("updatedAt", "varchar", (col) =>
-        col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`)
+      .addColumn(
+        "updatedAt",
+        "varchar",
+        (col) => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`),
       )
       .execute();
 
···
     `.execute(db);
 
     await db.schema.dropTable("virtual_machines").execute();
-    await sql`ALTER TABLE virtual_machines_new RENAME TO virtual_machines`.execute(
-      db
-    );
+    await sql`ALTER TABLE virtual_machines_new RENAME TO virtual_machines`
+      .execute(
+        db,
+      );
   },
 
   async down(db: Kysely<unknown>): Promise<void> {
···
       .addColumn("pid", "integer")
       .addColumn("volume", "varchar")
       .addColumn("seed", "varchar")
-      .addColumn("createdAt", "varchar", (col) =>
-        col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`)
+      .addColumn(
+        "createdAt",
+        "varchar",
+        (col) => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`),
       )
-      .addColumn("updatedAt", "varchar", (col) =>
-        col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`)
+      .addColumn(
+        "updatedAt",
+        "varchar",
+        (col) => col.notNull().defaultTo(sql`CURRENT_TIMESTAMP`),
       )
       .execute();
 
···
     `.execute(db);
 
     await db.schema.dropTable("virtual_machines").execute();
-    await sql`ALTER TABLE virtual_machines_old RENAME TO virtual_machines`.execute(
-      db
-    );
+    await sql`ALTER TABLE virtual_machines_old RENAME TO virtual_machines`
+      .execute(
+        db,
+      );
   },
 };
 

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: almalinux, almalinux
   const almaLinuxRegex = /^(almalinux|alma)$/;
···
     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: rocky. rockylinux
   const rockyLinuxRegex = /^(rockylinux|rocky)$/;
···
     new InvalidImageNameError({
       image,
       cause: "Image name does not match RockyLinux naming conventions.",
-    })
+    }),
   );
 };