Add logging and port forwarding options for virtual machines; refactor start and runQemu functions

deno.json

···
   },
   "imports": {
     "@cliffy/command": "jsr:@cliffy/command@^1.0.0-rc.8",
+    "@cliffy/flags": "jsr:@cliffy/flags@^1.0.0-rc.8",
     "@cliffy/table": "jsr:@cliffy/table@^1.0.0-rc.8",
     "@db/sqlite": "jsr:@db/sqlite@^0.12.0",
     "@es-toolkit/es-toolkit": "jsr:@es-toolkit/es-toolkit@^1.41.0",

deno.lock

···
   "specifiers": {
     "jsr:@cliffy/command@^1.0.0-rc.8": "1.0.0-rc.8",
     "jsr:@cliffy/flags@1.0.0-rc.8": "1.0.0-rc.8",
+    "jsr:@cliffy/flags@^1.0.0-rc.8": "1.0.0-rc.8",
     "jsr:@cliffy/internal@1.0.0-rc.8": "1.0.0-rc.8",
     "jsr:@cliffy/table@1.0.0-rc.8": "1.0.0-rc.8",
     "jsr:@cliffy/table@^1.0.0-rc.8": "1.0.0-rc.8",
···
     "npm:effect@^3.19.2": "3.19.2",
     "npm:kysely@0.27.6": "0.27.6",
     "npm:kysely@~0.27.2": "0.27.6",
-    "npm:lodash@^4.17.21": "4.17.21",
     "npm:moniker@~0.1.2": "0.1.2"
   },
   "jsr": {
     "@cliffy/command@1.0.0-rc.8": {
       "integrity": "758147790797c74a707e5294cc7285df665422a13d2a483437092ffce40b5557",
       "dependencies": [
-        "jsr:@cliffy/flags",
+        "jsr:@cliffy/flags@1.0.0-rc.8",
         "jsr:@cliffy/internal",
         "jsr:@cliffy/table@1.0.0-rc.8",
         "jsr:@std/fmt@~1.0.2",
···
     "kysely@0.27.6": {
       "integrity": "sha512-FIyV/64EkKhJmjgC0g2hygpBv5RNWVPyNCqSAD7eTCv6eFWNIi4PN1UvdSJGicN/o35bnevgis4Y0UDC0qi8jQ=="
     },
-    "lodash@4.17.21": {
-      "integrity": "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="
-    },
     "moniker@0.1.2": {
       "integrity": "sha512-Uj9iV0QYr6281G+o0TvqhKwHHWB2Q/qUTT4LPQ3qDGc0r8cbMuqQjRXPZuVZ+gcL7APx+iQgE8lcfWPrj1LsLA=="
     },
···
   "workspace": {
     "dependencies": [
       "jsr:@cliffy/command@^1.0.0-rc.8",
+      "jsr:@cliffy/flags@^1.0.0-rc.8",
       "jsr:@cliffy/table@^1.0.0-rc.8",
       "jsr:@db/sqlite@0.12",
       "jsr:@es-toolkit/es-toolkit@^1.41.0",
···
       "npm:dayjs@^1.11.19",
       "npm:effect@^3.19.2",
       "npm:kysely@0.27.6",
-      "npm:lodash@^4.17.21",
       "npm:moniker@~0.1.2"
     ]
   }

main.ts

···
 import pkg from "./deno.json" with { type: "json" };
 import { createBridgeNetworkIfNeeded } from "./src/network.ts";
 import inspect from "./src/subcommands/inspect.ts";
+import logs from "./src/subcommands/logs.ts";
 import ps from "./src/subcommands/ps.ts";
+import restart from "./src/subcommands/restart.ts";
 import rm from "./src/subcommands/rm.ts";
 import start from "./src/subcommands/start.ts";
 import stop from "./src/subcommands/stop.ts";
···
     .option(
       "-b, --bridge <name:string>",
       "Name of the network bridge to use for networking (e.g., br0)",
+    )
+    .option(
+      "-d, --detach",
+      "Run VM in the background and print VM name",
+    )
+    .option(
+      "-p, --port-forward <mappings:string>",
+      "Port forwarding rules in the format hostPort:guestPort (comma-separated for multiple)",
     )
     .example(
       "Default usage",
···
     })
     .command("start", "Start a virtual machine")
     .arguments("<vm-name:string>")
-    .action(async (_options: unknown, vmName: string) => {
-      await start(vmName);
+    .option("-c, --cpu <type:string>", "Type of CPU to emulate", {
+      default: "host",
+    })
+    .option("-C, --cpus <number:number>", "Number of CPU cores", {
+      default: 2,
+    })
+    .option("-m, --memory <size:string>", "Amount of memory for the VM", {
+      default: "2G",
+    })
+    .option("-i, --image <path:string>", "Path to VM disk image")
+    .option(
+      "--disk-format <format:string>",
+      "Disk image format (e.g., qcow2, raw)",
+      {
+        default: "raw",
+      },
+    )
+    .option(
+      "--size <size:string>",
+      "Size of the VM disk image to create if it doesn't exist (e.g., 20G)",
+      {
+        default: "20G",
+      },
+    )
+    .option(
+      "-b, --bridge <name:string>",
+      "Name of the network bridge to use for networking (e.g., br0)",
+    )
+    .option(
+      "-d, --detach",
+      "Run VM in the background and print VM name",
+    )
+    .option(
+      "-p, --port-forward <mappings:string>",
+      "Port forwarding rules in the format hostPort:guestPort (comma-separated for multiple)",
+    )
+    .action(async (options: unknown, vmName: string) => {
+      await start(vmName, Boolean((options as { detach: boolean }).detach));
     })
     .command("stop", "Stop a virtual machine")
     .arguments("<vm-name:string>")
···
     .arguments("<vm-name:string>")
     .action(async (_options: unknown, vmName: string) => {
       await rm(vmName);
+    })
+    .command("logs", "View logs of a virtual machine")
+    .option("--follow, -f", "Follow log output")
+    .arguments("<vm-name:string>")
+    .action(async (options: unknown, vmName: string) => {
+      await logs(vmName, Boolean((options as { follow: boolean }).follow));
+    })
+    .command("restart", "Restart a virtual machine")
+    .arguments("<vm-name:string>")
+    .action(async (_options: unknown, vmName: string) => {
+      await restart(vmName);
     })
     .parse(Deno.args);
 }

src/constants.ts

···
 export const CONFIG_DIR = `${Deno.env.get("HOME")}/.openindiana-up`;
 export const DB_PATH = `${CONFIG_DIR}/state.sqlite`;
+export const LOGS_DIR: string = `${CONFIG_DIR}/logs`;
 export const EMPTY_DISK_THRESHOLD_KB: number = 100;

src/db.ts

···
   drivePath?: string;
   diskFormat: string;
   isoPath?: string;
+  portForward?: string;
   version: string;
   status: STATUS;
   pid: number;
···
       .addColumn("diskFormat", "varchar")
       .addColumn("isoPath", "varchar")
       .addColumn("status", "varchar", (col) => col.notNull())
-      .addColumn("pid", "integer", (col) => col.notNull().unique())
+      .addColumn("pid", "integer")
       .addColumn(
         "createdAt",
         "varchar",
···
   },
 };
 
-export const migrateToLatest = async (db: Database) => {
+migrations["002"] = {
+  async up(db: Kysely<unknown>): Promise<void> {
+    await db.schema
+      .alterTable("virtual_machines")
+      .addColumn("portForward", "varchar")
+      .execute();
+  },
+
+  async down(db: Kysely<unknown>): Promise<void> {
+    await db.schema
+      .alterTable("virtual_machines")
+      .dropColumn("portForward")
+      .execute();
+  },
+};
+
+export const migrateToLatest = async (db: Database): Promise<void> => {
   const migrator = new Migrator({ db, provider: migrationProvider });
   const { error } = await migrator.migrateToLatest();
   if (error) throw error;

src/subcommands/logs.ts

···
+import { LOGS_DIR } from "../constants.ts";
+
+export default async function (name: string, follow: boolean) {
+  await Deno.mkdir(LOGS_DIR, { recursive: true });
+  const logPath = `${LOGS_DIR}/${name}.log`;
+
+  const cmd = new Deno.Command(follow ? "tail" : "cat", {
+    args: [
+      ...(follow ? ["-n", "100", "-f"] : []),
+      logPath,
+    ],
+    stdin: "inherit",
+    stdout: "inherit",
+    stderr: "inherit",
+  });
+
+  const status = await cmd.spawn().status;
+
+  if (!status.success) {
+    console.error(`Failed to view logs for virtual machine ${name}.`);
+    Deno.exit(status.code);
+  }
+}

src/subcommands/restart.ts

···
+import _ from "@es-toolkit/es-toolkit/compat";
+import chalk from "chalk";
+import { LOGS_DIR } from "../constants.ts";
+import { getInstanceState, updateInstanceState } from "../state.ts";
+import { safeKillQemu } from "../utils.ts";
+
+export default async function (name: string) {
+  const vm = await getInstanceState(name);
+  if (!vm) {
+    console.error(
+      `Virtual machine with name or ID ${chalk.greenBright(name)} not found.`,
+    );
+    Deno.exit(1);
+  }
+
+  const success = await safeKillQemu(vm.pid, Boolean(vm.bridge));
+
+  if (!success) {
+    console.error(
+      `Failed to stop virtual machine ${chalk.greenBright(vm.name)}.`,
+    );
+    Deno.exit(1);
+  }
+  await updateInstanceState(vm.id, "STOPPED");
+
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+
+  await Deno.mkdir(LOGS_DIR, { recursive: true });
+  const logPath = `${LOGS_DIR}/${vm.name}.log`;
+
+  const qemuArgs = [
+    ..._.compact([vm.bridge && "qemu-system-x86_64"]),
+    ...Deno.build.os === "linux" ? ["-enable-kvm"] : [],
+    "-cpu",
+    vm.cpu,
+    "-m",
+    vm.memory,
+    "-smp",
+    vm.cpus.toString(),
+    ..._.compact([vm.isoPath && "-cdrom", vm.isoPath]),
+    "-netdev",
+    vm.bridge
+      ? `bridge,id=net0,br=${vm.bridge}`
+      : "user,id=net0,hostfwd=tcp::2222-:22",
+    "-device",
+    `e1000,netdev=net0,mac=${vm.macAddress}`,
+    "-device",
+    "ahci,id=ahci0",
+    "-nographic",
+    "-monitor",
+    "none",
+    "-chardev",
+    "stdio,id=con0,signal=off",
+    "-serial",
+    "chardev:con0",
+    ..._.compact(
+      vm.drivePath && [
+        "-drive",
+        `file=${vm.drivePath},format=${vm.diskFormat},if=none,id=disk0`,
+        "-device",
+        "ide-hd,drive=disk0,bus=ahci0.0",
+      ],
+    ),
+  ];
+
+  const fullCommand = vm.bridge
+    ? `sudo qemu-system-x86_64 ${
+      qemuArgs.slice(1).join(" ")
+    } >> "${logPath}" 2>&1 & echo $!`
+    : `qemu-system-x86_64 ${qemuArgs.join(" ")} >> "${logPath}" 2>&1 & echo $!`;
+
+  const cmd = new Deno.Command("sh", {
+    args: ["-c", fullCommand],
+    stdin: "null",
+    stdout: "piped",
+  });
+
+  const { stdout } = await cmd.spawn().output();
+  const qemuPid = parseInt(new TextDecoder().decode(stdout).trim(), 10);
+
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+
+  await updateInstanceState(vm.id, "RUNNING", qemuPid);
+
+  console.log(
+    `${chalk.greenBright(vm.name)} restarted with PID ${
+      chalk.greenBright(qemuPid)
+    }.`,
+  );
+  console.log(
+    `Logs are being written to ${chalk.blueBright(logPath)}`,
+  );
+
+  await new Promise((resolve) => setTimeout(resolve, 2000));
+
+  Deno.exit(0);
+}

src/subcommands/start.ts

···
+import { parseFlags } from "@cliffy/flags";
 import _ from "@es-toolkit/es-toolkit/compat";
+import { LOGS_DIR } from "../constants.ts";
+import type { VirtualMachine } from "../db.ts";
 import { getInstanceState, updateInstanceState } from "../state.ts";
 
-export default async function (name: string) {
-  const vm = await getInstanceState(name);
+export default async function (name: string, detach: boolean = false) {
+  let vm = await getInstanceState(name);
   if (!vm) {
     console.error(
       `Virtual machine with name or ID ${name} not found.`,
···
 
   console.log(`Starting virtual machine ${vm.name} (ID: ${vm.id})...`);
 
-  const cmd = new Deno.Command(vm.bridge ? "sudo" : "qemu-system-x86_64", {
-    args: [
-      ..._.compact([vm.bridge && "qemu-system-x86_64"]),
-      "-enable-kvm",
-      "-cpu",
-      vm.cpu,
-      "-m",
-      vm.memory,
-      "-smp",
-      vm.cpus.toString(),
-      ..._.compact([vm.isoPath && "-cdrom", vm.isoPath]),
-      "-netdev",
-      vm.bridge
-        ? `bridge,id=net0,br=${vm.bridge}`
-        : "user,id=net0,hostfwd=tcp::2222-:22",
-      "-device",
-      `e1000,netdev=net0,mac=${vm.macAddress}`,
-      "-device",
-      "ahci,id=ahci0",
-      "-nographic",
-      "-monitor",
-      "none",
-      "-chardev",
-      "stdio,id=con0,signal=off",
-      "-serial",
-      "chardev:con0",
-      ..._.compact(
-        vm.drivePath && [
-          "-drive",
-          `file=${vm.drivePath},format=${vm.diskFormat},if=none,id=disk0`,
-          "-device",
-          "ide-hd,drive=disk0,bus=ahci0.0",
-        ],
-      ),
-    ],
-    stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit",
-  })
-    .spawn();
+  vm = mergeFlags(vm);
 
-  await updateInstanceState(name, "RUNNING", cmd.pid);
+  const qemuArgs = [
+    ..._.compact([vm.bridge && "qemu-system-x86_64"]),
+    ...Deno.build.os === "linux" ? ["-enable-kvm"] : [],
+    "-cpu",
+    vm.cpu,
+    "-m",
+    vm.memory,
+    "-smp",
+    vm.cpus.toString(),
+    ..._.compact([vm.isoPath && "-cdrom", vm.isoPath]),
+    "-netdev",
+    vm.bridge
+      ? `bridge,id=net0,br=${vm.bridge}`
+      : "user,id=net0,hostfwd=tcp::2222-:22",
+    "-device",
+    `e1000,netdev=net0,mac=${vm.macAddress}`,
+    "-device",
+    "ahci,id=ahci0",
+    "-nographic",
+    "-monitor",
+    "none",
+    "-chardev",
+    "stdio,id=con0,signal=off",
+    "-serial",
+    "chardev:con0",
+    ..._.compact(
+      vm.drivePath && [
+        "-drive",
+        `file=${vm.drivePath},format=${vm.diskFormat},if=none,id=disk0`,
+        "-device",
+        "ide-hd,drive=disk0,bus=ahci0.0",
+      ],
+    ),
+  ];
 
-  const status = await cmd.status;
+  if (detach) {
+    await Deno.mkdir(LOGS_DIR, { recursive: true });
+    const logPath = `${LOGS_DIR}/${vm.name}.log`;
+
+    const fullCommand = vm.bridge
+      ? `sudo qemu-system-x86_64 ${
+        qemuArgs.slice(1).join(" ")
+      } >> "${logPath}" 2>&1 & echo $!`
+      : `qemu-system-x86_64 ${
+        qemuArgs.join(" ")
+      } >> "${logPath}" 2>&1 & echo $!`;
 
-  await updateInstanceState(name, "STOPPED", cmd.pid);
+    const cmd = new Deno.Command("sh", {
+      args: ["-c", fullCommand],
+      stdin: "null",
+      stdout: "piped",
+    });
 
-  if (!status.success) {
-    Deno.exit(status.code);
+    const { stdout } = await cmd.spawn().output();
+    const qemuPid = parseInt(new TextDecoder().decode(stdout).trim(), 10);
+
+    await updateInstanceState(name, "RUNNING", qemuPid);
+
+    console.log(
+      `Virtual machine ${vm.name} started in background (PID: ${qemuPid})`,
+    );
+    console.log(`Logs will be written to: ${logPath}`);
+
+    // Exit successfully while keeping VM running in background
+    Deno.exit(0);
+  } else {
+    const cmd = new Deno.Command(vm.bridge ? "sudo" : "qemu-system-x86_64", {
+      args: qemuArgs,
+      stdin: "inherit",
+      stdout: "inherit",
+      stderr: "inherit",
+    });
+
+    const child = cmd.spawn();
+    await updateInstanceState(name, "RUNNING", child.pid);
+
+    const status = await child.status;
+
+    await updateInstanceState(name, "STOPPED", child.pid);
+
+    if (!status.success) {
+      Deno.exit(status.code);
+    }
   }
 }
+
+function mergeFlags(vm: VirtualMachine): VirtualMachine {
+  const { flags } = parseFlags(Deno.args);
+  return {
+    ...vm,
+    memory: flags.memory ? String(flags.memory) : vm.memory,
+    cpus: flags.cpus ? Number(flags.cpus) : vm.cpus,
+    cpu: flags.cpu ? String(flags.cpu) : vm.cpu,
+    diskFormat: flags.diskFormat ? String(flags.diskFormat) : vm.diskFormat,
+    portForward: flags.portForward ? String(flags.portForward) : vm.portForward,
+    drivePath: flags.image ? String(flags.image) : vm.drivePath,
+    bridge: flags.bridge ? String(flags.bridge) : vm.bridge,
+    diskSize: flags.size ? String(flags.size) : vm.diskSize,
+  };
+}

src/utils.ts

···
 import { createId } from "@paralleldrive/cuid2";
 import chalk from "chalk";
 import Moniker from "moniker";
-import { EMPTY_DISK_THRESHOLD_KB } from "./constants.ts";
+import { EMPTY_DISK_THRESHOLD_KB, LOGS_DIR } from "./constants.ts";
 import { generateRandomMacAddress } from "./network.ts";
-import { saveInstanceState } from "./state.ts";
+import { saveInstanceState, updateInstanceState } from "./state.ts";
 
 const DEFAULT_VERSION = "20251026";
 
···
   diskFormat: string;
   size: string;
   bridge?: string;
+  portForward?: string;
+  detach?: boolean;
 }
 
 async function du(path: string): Promise<number> {
···
   return `https://dlc.openindiana.org/isos/hipster/${version}/OI-hipster-text-${version}.iso`;
 }
 
+export function setupPortForwardingArgs(portForward?: string): string {
+  if (!portForward) {
+    return "";
+  }
+
+  const forwards = portForward.split(",").map((pair) => {
+    const [hostPort, guestPort] = pair.split(":");
+    return `hostfwd=tcp::${hostPort}-:${guestPort}`;
+  });
+
+  return forwards.join(",");
+}
+
+export function setupNATNetworkArgs(portForward?: string): string {
+  if (!portForward) {
+    return "user,id=net0";
+  }
+
+  const portForwarding = setupPortForwardingArgs(portForward);
+  return `user,id=net0,${portForwarding}`;
+}
+
 export async function runQemu(
   isoPath: string | null,
   options: Options,
 ): Promise<void> {
   const macAddress = generateRandomMacAddress();
-  const cmd = new Deno.Command(options.bridge ? "sudo" : "qemu-system-x86_64", {
-    args: [
-      ..._.compact([options.bridge && "qemu-system-x86_64"]),
-      "-enable-kvm",
-      "-cpu",
-      options.cpu,
-      "-m",
-      options.memory,
-      "-smp",
-      options.cpus.toString(),
-      ..._.compact([isoPath && "-cdrom", isoPath]),
-      "-netdev",
-      options.bridge
-        ? `bridge,id=net0,br=${options.bridge}`
-        : "user,id=net0,hostfwd=tcp::2222-:22",
-      "-device",
-      `e1000,netdev=net0,mac=${macAddress}`,
-      "-device",
-      "ahci,id=ahci0",
-      "-nographic",
-      "-monitor",
-      "none",
-      "-chardev",
-      "stdio,id=con0,signal=off",
-      "-serial",
-      "chardev:con0",
-      ..._.compact(
-        options.image && [
-          "-drive",
-          `file=${options.image},format=${options.diskFormat},if=none,id=disk0`,
-          "-device",
-          "ide-hd,drive=disk0,bus=ahci0.0",
-        ],
-      ),
-    ],
-    stdin: "inherit",
-    stdout: "inherit",
-    stderr: "inherit",
-  }).spawn();
+
+  const qemuArgs = [
+    ..._.compact([options.bridge && "qemu-system-x86_64"]),
+    ...Deno.build.os === "linux" ? ["-enable-kvm"] : [],
+    "-cpu",
+    options.cpu,
+    "-m",
+    options.memory,
+    "-smp",
+    options.cpus.toString(),
+    ..._.compact([isoPath && "-cdrom", isoPath]),
+    "-netdev",
+    options.bridge
+      ? `bridge,id=net0,br=${options.bridge}`
+      : "user,id=net0,hostfwd=tcp::2222-:22",
+    "-device",
+    `e1000,netdev=net0,mac=${macAddress}`,
+    "-device",
+    "ahci,id=ahci0",
+    "-nographic",
+    "-monitor",
+    "none",
+    "-chardev",
+    "stdio,id=con0,signal=off",
+    "-serial",
+    "chardev:con0",
+    ..._.compact(
+      options.image && [
+        "-drive",
+        `file=${options.image},format=${options.diskFormat},if=none,id=disk0`,
+        "-device",
+        "ide-hd,drive=disk0,bus=ahci0.0",
+      ],
+    ),
+  ];
+
+  const name = Moniker.choose();
+
+  if (options.detach) {
+    await Deno.mkdir(LOGS_DIR, { recursive: true });
+    const logPath = `${LOGS_DIR}/${name}.log`;
+
+    const fullCommand = options.bridge
+      ? `sudo qemu-system-x86_64 ${
+        qemuArgs.slice(1).join(" ")
+      } >> "${logPath}" 2>&1 & echo $!`
+      : `qemu-system-x86_64 ${
+        qemuArgs.join(" ")
+      } >> "${logPath}" 2>&1 & echo $!`;
+
+    const cmd = new Deno.Command("sh", {
+      args: ["-c", fullCommand],
+      stdin: "null",
+      stdout: "piped",
+    });
+
+    const { stdout } = await cmd.spawn().output();
+    const qemuPid = parseInt(new TextDecoder().decode(stdout).trim(), 10);
+
+    await saveInstanceState({
+      id: createId(),
+      name,
+      bridge: options.bridge,
+      macAddress,
+      memory: options.memory,
+      cpus: options.cpus,
+      cpu: options.cpu,
+      diskSize: options.size,
+      diskFormat: options.diskFormat,
+      portForward: options.portForward,
+      isoPath: isoPath ? Deno.realPathSync(isoPath) : undefined,
+      drivePath: options.image ? Deno.realPathSync(options.image) : undefined,
+      version: DEFAULT_VERSION,
+      status: "RUNNING",
+      pid: qemuPid,
+    });
+
+    console.log(
+      `Virtual machine ${name} started in background (PID: ${qemuPid})`,
+    );
+    console.log(`Logs will be written to: ${logPath}`);
+
+    // Exit successfully while keeping VM running in background
+    Deno.exit(0);
+  } else {
+    const cmd = new Deno.Command(
+      options.bridge ? "sudo" : "qemu-system-x86_64",
+      {
+        args: qemuArgs,
+        stdin: "inherit",
+        stdout: "inherit",
+        stderr: "inherit",
+      },
+    )
+      .spawn();
+
+    await saveInstanceState({
+      id: createId(),
+      name,
+      bridge: options.bridge,
+      macAddress,
+      memory: options.memory,
+      cpus: options.cpus,
+      cpu: options.cpu,
+      diskSize: options.size,
+      diskFormat: options.diskFormat,
+      portForward: options.portForward,
+      isoPath: isoPath ? Deno.realPathSync(isoPath) : undefined,
+      drivePath: options.image ? Deno.realPathSync(options.image) : undefined,
+      version: DEFAULT_VERSION,
+      status: "RUNNING",
+      pid: cmd.pid,
+    });
 
-  await saveInstanceState({
-    id: createId(),
-    name: Moniker.choose(),
-    bridge: options.bridge,
-    macAddress,
-    memory: options.memory,
-    cpus: options.cpus,
-    cpu: options.cpu,
-    diskSize: options.size,
-    diskFormat: options.diskFormat,
-    isoPath: isoPath ? Deno.realPathSync(isoPath) : undefined,
-    drivePath: options.image ? Deno.realPathSync(options.image) : undefined,
-    version: DEFAULT_VERSION,
-    status: "RUNNING",
-    pid: cmd.pid,
-  });
+    const status = await cmd.status;
 
-  const status = await cmd.status;
+    await updateInstanceState(name, "STOPPED");
 
-  if (!status.success) {
-    Deno.exit(status.code);
+    if (!status.success) {
+      Deno.exit(status.code);
+    }
   }
 }
 
···
   }
 
   return input;
+}
+
+export async function safeKillQemu(
+  pid: number,
+  useSudo: boolean = false,
+): Promise<boolean> {
+  const killArgs = useSudo
+    ? ["sudo", "kill", "-TERM", pid.toString()]
+    : ["kill", "-TERM", pid.toString()];
+
+  const termCmd = new Deno.Command(killArgs[0], {
+    args: killArgs.slice(1),
+    stdout: "null",
+    stderr: "null",
+  });
+
+  const termStatus = await termCmd.spawn().status;
+
+  if (termStatus.success) {
+    await new Promise((resolve) => setTimeout(resolve, 3000));
+
+    const checkCmd = new Deno.Command("kill", {
+      args: ["-0", pid.toString()],
+      stdout: "null",
+      stderr: "null",
+    });
+
+    const checkStatus = await checkCmd.spawn().status;
+    if (!checkStatus.success) {
+      return true;
+    }
+  }
+
+  const killKillArgs = useSudo
+    ? ["sudo", "kill", "-KILL", pid.toString()]
+    : ["kill", "-KILL", pid.toString()];
+
+  const killCmd = new Deno.Command(killKillArgs[0], {
+    args: killKillArgs.slice(1),
+    stdout: "null",
+    stderr: "null",
+  });
+
+  const killStatus = await killCmd.spawn().status;
+  return killStatus.success;
 }
 
 export async function createDriveImageIfNeeded(