Refactor drive image creation and ISO download logic; add utility functions for better modularity

deno.json

···
   "imports": {
     "@cliffy/command": "jsr:@cliffy/command@^1.0.0-rc.8",
     "@std/assert": "jsr:@std/assert@1",
-    "chalk": "npm:chalk@^5.6.2"
+    "chalk": "npm:chalk@^5.6.2",
+    "lodash": "npm:lodash@^4.17.21"
   }
 }

deno.lock

···
     "jsr:@std/fmt@~1.0.2": "1.0.8",
     "jsr:@std/internal@^1.0.12": "1.0.12",
     "jsr:@std/text@~1.0.7": "1.0.16",
-    "npm:chalk@^5.6.2": "5.6.2"
+    "npm:chalk@^5.6.2": "5.6.2",
+    "npm:lodash@^4.17.21": "4.17.21"
   },
   "jsr": {
     "@cliffy/command@1.0.0-rc.8": {
···
   "npm": {
     "chalk@5.6.2": {
       "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA=="
+    },
+    "lodash@4.17.21": {
+      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="
     }
   },
   "workspace": {
     "dependencies": [
       "jsr:@cliffy/command@^1.0.0-rc.8",
       "jsr:@std/assert@1",
-      "npm:chalk@^5.6.2"
+      "npm:chalk@^5.6.2",
+      "npm:lodash@^4.17.21"
     ]
   }
 }

main.ts

···
 #!/usr/bin/env -S deno run --allow-run --allow-read --allow-env
 
 import { Command } from "@cliffy/command";
-import chalk from "chalk";
-
-const DEFAULT_VERSION = "20251026";
-
-interface Options {
-  output?: string;
-  cpu: string;
-  cpus: number;
-  memory: string;
-  drive?: string;
-  diskFormat: string;
-  size: string;
-}
-
-async function downloadIso(url: string, outputPath?: string): Promise<string> {
-  const filename = url.split("/").pop()!;
-  outputPath = outputPath ?? filename;
-
-  if (await Deno.stat(outputPath).catch(() => false)) {
-    console.log(
-      chalk.yellowBright(
-        `File ${outputPath} already exists, skipping download.`,
-      ),
-    );
-    return outputPath;
-  }
-
-  const cmd = new Deno.Command("curl", {
-    args: ["-L", "-o", outputPath, url],
-    stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit",
-  });
-
-  const status = await cmd.spawn().status;
-  if (!status.success) {
-    console.error(chalk.redBright("Failed to download ISO image."));
-    Deno.exit(status.code);
-  }
-
-  console.log(chalk.greenBright(`Downloaded ISO to ${outputPath}`));
-  return outputPath;
-}
-
-function constructDownloadUrl(version: string): string {
-  return `https://dlc.openindiana.org/isos/hipster/${version}/OI-hipster-text-${version}.iso`;
-}
-
-async function runQemu(isoPath: string, options: Options): Promise<void> {
-  const cmd = new Deno.Command("qemu-system-x86_64", {
-    args: [
-      "-enable-kvm",
-      "-cpu",
-      options.cpu,
-      "-m",
-      options.memory,
-      "-smp",
-      options.cpus.toString(),
-      "-cdrom",
-      isoPath,
-      "-netdev",
-      "user,id=net0,hostfwd=tcp::2222-:22",
-      "-device",
-      "e1000,netdev=net0",
-      "-nographic",
-      "-monitor",
-      "none",
-      "-chardev",
-      "stdio,id=con0,signal=off",
-      "-serial",
-      "chardev:con0",
-      ...(options.drive
-        ? [
-          "-drive",
-          `file=${options.drive},format=${options.diskFormat},if=virtio`,
-        ]
-        : []),
-    ],
-    stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit",
-  });
-
-  const status = await cmd.spawn().status;
-
-  if (!status.success) {
-    Deno.exit(status.code);
-  }
-}
-
-function handleInput(input?: string): string {
-  if (!input) {
-    console.log(
-      `No ISO path provided, defaulting to ${chalk.cyan("OpenIndiana")} ${
-        chalk.cyan(DEFAULT_VERSION)
-      }...`,
-    );
-    return constructDownloadUrl(DEFAULT_VERSION);
-  }
-
-  const versionRegex = /^\d{8}$/;
-
-  if (versionRegex.test(input)) {
-    console.log(
-      `Detected version ${chalk.cyan(input)}, constructing download URL...`,
-    );
-    return constructDownloadUrl(input);
-  }
-
-  return input;
-}
-
-async function createDriveImageIfNeeded(
-  {
-    drive: path,
-    diskFormat: format,
-    size,
-  }: Options,
-): Promise<void> {
-  if (await Deno.stat(path!).catch(() => false)) {
-    console.log(
-      chalk.yellowBright(
-        `Drive image ${path} already exists, skipping creation.`,
-      ),
-    );
-    return;
-  }
-
-  const cmd = new Deno.Command("qemu-img", {
-    args: ["create", "-f", format, path!, size],
-    stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit",
-  });
-
-  const status = await cmd.spawn().status;
-  if (!status.success) {
-    console.error(chalk.redBright("Failed to create drive image."));
-    Deno.exit(status.code);
-  }
-
-  console.log(chalk.greenBright(`Created drive image at ${path}`));
-}
+import {
+  createDriveImageIfNeeded,
+  downloadIso,
+  emptyDiskImage,
+  handleInput,
+  Options,
+  runQemu,
+} from "./utils.ts";
 
 if (import.meta.main) {
   await new Command()
···
     )
     .action(async (options: Options, input?: string) => {
       const resolvedInput = handleInput(input);
-      let isoPath = resolvedInput;
+      let isoPath: string | null = resolvedInput;
 
       if (
         resolvedInput.startsWith("https://") ||
         resolvedInput.startsWith("http://")
       ) {
-        isoPath = await downloadIso(resolvedInput, options.output);
+        isoPath = await downloadIso(resolvedInput, options);
       }
 
       if (options.drive) {
         await createDriveImageIfNeeded(options);
       }
 
-      await runQemu(isoPath, {
-        cpu: options.cpu,
-        memory: options.memory,
-        cpus: options.cpus,
-        drive: options.drive,
-        diskFormat: options.diskFormat,
-        size: options.size,
-      });
+      if (!input && options.drive && !await emptyDiskImage(options.drive)) {
+        isoPath = null;
+      }
+
+      await runQemu(isoPath, options);
     })
     .parse(Deno.args);
 }

utils.ts

···
+import chalk from "chalk";
+import _ from "lodash";
+
+const DEFAULT_VERSION = "20251026";
+
+export interface Options {
+  output?: string;
+  cpu: string;
+  cpus: number;
+  memory: string;
+  drive?: string;
+  diskFormat: string;
+  size: string;
+}
+
+async function du(path: string): Promise<number> {
+  const cmd = new Deno.Command("du", {
+    args: [path],
+    stdout: "piped",
+    stderr: "inherit",
+  });
+
+  const { stdout } = await cmd.spawn().output();
+  const output = new TextDecoder().decode(stdout).trim();
+  const size = parseInt(output.split("\t")[0], 10);
+  return size;
+}
+
+export async function emptyDiskImage(path: string): Promise<boolean> {
+  if (!await Deno.stat(path).catch(() => false)) {
+    return true;
+  }
+
+  const size = await du(path);
+  return size < 10;
+}
+
+export async function downloadIso(
+  url: string,
+  options: Options,
+): Promise<string | null> {
+  const filename = url.split("/").pop()!;
+  const outputPath = options.output ?? filename;
+
+  if (options.drive && await Deno.stat(options.drive).catch(() => false)) {
+    const driveSize = await du(options.drive);
+    if (driveSize > 10) {
+      console.log(
+        chalk.yellowBright(
+          `Drive image ${options.drive} is not empty (size: ${driveSize} KB), skipping ISO download to avoid overwriting existing data.`,
+        ),
+      );
+      return null;
+    }
+  }
+
+  if (await Deno.stat(outputPath).catch(() => false)) {
+    console.log(
+      chalk.yellowBright(
+        `File ${outputPath} already exists, skipping download.`,
+      ),
+    );
+    return outputPath;
+  }
+
+  const cmd = new Deno.Command("curl", {
+    args: ["-L", "-o", outputPath, url],
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+
+  const status = await cmd.spawn().status;
+  if (!status.success) {
+    console.error(chalk.redBright("Failed to download ISO image."));
+    Deno.exit(status.code);
+  }
+
+  console.log(chalk.greenBright(`Downloaded ISO to ${outputPath}`));
+  return outputPath;
+}
+
+export function constructDownloadUrl(version: string): string {
+  return `https://dlc.openindiana.org/isos/hipster/${version}/OI-hipster-text-${version}.iso`;
+}
+
+export async function runQemu(
+  isoPath: string | null,
+  options: Options,
+): Promise<void> {
+  const cmd = new Deno.Command("qemu-system-x86_64", {
+    args: [
+      "-enable-kvm",
+      "-cpu",
+      options.cpu,
+      "-m",
+      options.memory,
+      "-smp",
+      options.cpus.toString(),
+      ..._.compact([isoPath && "-cdrom", isoPath]),
+      "-netdev",
+      "user,id=net0,hostfwd=tcp::2222-:22",
+      "-device",
+      "e1000,netdev=net0",
+      "-nographic",
+      "-monitor",
+      "none",
+      "-chardev",
+      "stdio,id=con0,signal=off",
+      "-serial",
+      "chardev:con0",
+      ..._.compact(
+        options.drive && [
+          "-drive",
+          `file=${options.drive},format=${options.diskFormat},if=virtio`,
+        ],
+      ),
+    ],
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+
+  const status = await cmd.spawn().status;
+
+  if (!status.success) {
+    Deno.exit(status.code);
+  }
+}
+
+export function handleInput(input?: string): string {
+  if (!input) {
+    console.log(
+      `No ISO path provided, defaulting to ${chalk.cyan("OpenIndiana")} ${
+        chalk.cyan(DEFAULT_VERSION)
+      }...`,
+    );
+    return constructDownloadUrl(DEFAULT_VERSION);
+  }
+
+  const versionRegex = /^\d{8}$/;
+
+  if (versionRegex.test(input)) {
+    console.log(
+      `Detected version ${chalk.cyan(input)}, constructing download URL...`,
+    );
+    return constructDownloadUrl(input);
+  }
+
+  return input;
+}
+
+export async function createDriveImageIfNeeded(
+  {
+    drive: path,
+    diskFormat: format,
+    size,
+  }: Options,
+): Promise<void> {
+  if (await Deno.stat(path!).catch(() => false)) {
+    console.log(
+      chalk.yellowBright(
+        `Drive image ${path} already exists, skipping creation.`,
+      ),
+    );
+    return;
+  }
+
+  const cmd = new Deno.Command("qemu-img", {
+    args: ["create", "-f", format, path!, size],
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+
+  const status = await cmd.spawn().status;
+  if (!status.success) {
+    console.error(chalk.redBright("Failed to create drive image."));
+    Deno.exit(status.code);
+  }
+
+  console.log(chalk.greenBright(`Created drive image at ${path}`));
+}