Add VM configuration management and improve command handling

- Introduced `src/config.ts` for VM configuration schema and file handling.
- Updated `src/constants.ts` to define `CONFIG_FILE_NAME`.
- Enhanced `main.ts` to support VM initialization and configuration merging.
- Improved ISO URL validation in `src/utils.ts`.
- Refactored `inspect.ts` to log VM state more effectively.
- Updated `.gitignore` to include `vmconfig.toml`.
- Added new dependencies in `deno.json` for TOML parsing and validation.

.gitignore

···
 *.iso
-*.img
+*.img
+vmconfig.toml

deno.json

···
     "@paralleldrive/cuid2": "npm:@paralleldrive/cuid2@^3.0.4",
     "@soapbox/kysely-deno-sqlite": "jsr:@soapbox/kysely-deno-sqlite@^2.2.0",
     "@std/assert": "jsr:@std/assert@1",
+    "@std/toml": "jsr:@std/toml@^1.0.11",
+    "@zod/zod": "jsr:@zod/zod@^4.1.12",
     "chalk": "npm:chalk@^5.6.2",
     "dayjs": "npm:dayjs@^1.11.19",
     "effect": "npm:effect@^3.19.2",

deno.lock

···
     "jsr:@soapbox/kysely-deno-sqlite@^2.2.0": "2.2.0",
     "jsr:@std/assert@0.217": "0.217.0",
     "jsr:@std/assert@1": "1.0.15",
+    "jsr:@std/collections@^1.1.3": "1.1.3",
     "jsr:@std/encoding@1": "1.0.10",
     "jsr:@std/fmt@1": "1.0.8",
     "jsr:@std/fmt@~1.0.2": "1.0.8",
···
     "jsr:@std/path@1": "1.1.2",
     "jsr:@std/path@^1.1.1": "1.1.2",
     "jsr:@std/text@~1.0.7": "1.0.16",
+    "jsr:@std/toml@^1.0.11": "1.0.11",
+    "jsr:@zod/zod@^4.1.12": "4.1.12",
     "npm:@paralleldrive/cuid2@^3.0.4": "3.0.4",
+    "npm:@types/node@*": "24.2.0",
     "npm:chalk@^5.6.2": "5.6.2",
     "npm:dayjs@^1.11.19": "1.11.19",
     "npm:effect@^3.19.2": "3.19.2",
···
         "jsr:@std/internal@^1.0.12"
       ]
     },
+    "@std/collections@1.1.3": {
+      "integrity": "bf8b0818886df6a32b64c7d3b037a425111f28278d69fd0995aeb62777c986b0"
+    },
     "@std/encoding@1.0.10": {
       "integrity": "8783c6384a2d13abd5e9e87a7ae0520a30e9f56aeeaa3bdf910a3eaaf5c811a1"
     },
···
     },
     "@std/text@1.0.16": {
       "integrity": "ddb9853b75119a2473857d691cf1ec02ad90793a2e8b4a4ac49d7354281a0cf8"
+    },
+    "@std/toml@1.0.11": {
+      "integrity": "e084988b872ca4bad6aedfb7350f6eeed0e8ba88e9ee5e1590621c5b5bb8f715",
+      "dependencies": [
+        "jsr:@std/collections"
+      ]
+    },
+    "@zod/zod@4.1.12": {
+      "integrity": "5876ed4c6d44673faf5120f0a461a2ada2eb6c735329d3ebaf5ba1fc08387695"
     }
   },
   "npm": {
···
     "@standard-schema/spec@1.0.0": {
       "integrity": "sha512-m2bOd0f2RT9k8QJx1JN85cZYyH1RqFBdlwtkSlf4tBDYLCiiZnv1fIIwacK6cqwXavOydf0NPToMQgpKq+dVlA=="
     },
+    "@types/node@24.2.0": {
+      "integrity": "sha512-3xyG3pMCq3oYCNg7/ZP+E1ooTaGB4cG8JWRsqqOYQdbWNY4zbaV0Ennrd7stjiJEFZCaybcIgpTjJWHRfBSIDw==",
+      "dependencies": [
+        "undici-types"
+      ]
+    },
     "bignumber.js@9.3.1": {
       "integrity": "sha512-Ko0uX15oIUS7wJ3Rb30Fs6SkVbLmPBAKdlm7q9+ak9bbIeFf0MwuBsQV6z7+X768/cHsfg+WlysDWJcmthjsjQ=="
     },
···
     },
     "pure-rand@6.1.0": {
       "integrity": "sha512-bVWawvoZoBYpp6yIoQtQXHZjmz35RSVHnUOTefl8Vcjr8snTPY1wnpSPMWekcFwbxI6gtmT7rSYPFvz71ldiOA=="
+    },
+    "undici-types@7.10.0": {
+      "integrity": "sha512-t5Fy/nfn+14LuOc2KNYg75vZqClpAiqscVvMygNnlsHBFpSXdJaYtXMcdNLpl/Qvc3P2cB3s6lOV51nqsFq4ag=="
     }
   },
   "workspace": {
···
       "jsr:@es-toolkit/es-toolkit@^1.41.0",
       "jsr:@soapbox/kysely-deno-sqlite@^2.2.0",
       "jsr:@std/assert@1",
+      "jsr:@std/toml@^1.0.11",
+      "jsr:@zod/zod@^4.1.12",
       "npm:@paralleldrive/cuid2@^3.0.4",
       "npm:chalk@^5.6.2",
       "npm:dayjs@^1.11.19",

main.ts

···
 #!/usr/bin/env -S deno run --allow-run --allow-read --allow-env
 
 import { Command } from "@cliffy/command";
-import { Effect } from "effect";
+import chalk from "chalk";
+import { Effect, pipe } from "effect";
 import pkg from "./deno.json" with { type: "json" };
+import { initVmFile, mergeConfig, parseVmFile } from "./src/config.ts";
+import { CONFIG_FILE_NAME } from "./src/constants.ts";
 import { createBridgeNetworkIfNeeded } from "./src/network.ts";
 import inspect from "./src/subcommands/inspect.ts";
 import logs from "./src/subcommands/logs.ts";
···
   downloadIso,
   emptyDiskImage,
   handleInput,
+  isValidISOurl,
   type Options,
   runQemu,
 } from "./src/utils.ts";
···
     )
     .option("-o, --output <path:string>", "Output path for downloaded ISO")
     .option("-c, --cpu <type:string>", "Type of CPU to emulate", {
-      default: "host",
+      default: Deno.build.os === "darwin" && Deno.build.arch === "aarch64"
+        ? "max"
+        : "host",
     })
     .option("-C, --cpus <number:number>", "Number of CPU cores", {
       default: 2,
···
     .option(
       "-p, --port-forward <mappings:string>",
       "Port forwarding rules in the format hostPort:guestPort (comma-separated for multiple)",
+    )
+    .example(
+      "Create a default VM configuration file",
+      "dflybsd-up init",
     )
     .example(
       "Default usage",
···
         const resolvedInput = handleInput(input);
         let isoPath: string | null = resolvedInput;
 
-        if (
-          resolvedInput.startsWith("https://") ||
-          resolvedInput.startsWith("http://")
-        ) {
+        const config = yield* pipe(
+          parseVmFile(CONFIG_FILE_NAME),
+          Effect.tap(() => Effect.log("Parsed VM configuration file.")),
+          Effect.catchAll(() => Effect.succeed(null)),
+        );
+
+        if (!input && (isValidISOurl(config?.vm?.iso))) {
+          isoPath = yield* downloadIso(config!.vm!.iso!, options);
+        }
+
+        options = yield* mergeConfig(config, options);
+
+        if (input && isValidISOurl(resolvedInput)) {
           isoPath = yield* downloadIso(resolvedInput, options);
         }
 
···
           yield* createDriveImageIfNeeded(options);
         }
 
-        if (
-          !input && options.image &&
-          !(yield* emptyDiskImage(options.image))
-        ) {
-          isoPath = null;
+        if (!input && options.image) {
+          const isEmpty = yield* emptyDiskImage(options.image);
+          if (!isEmpty) {
+            isoPath = null;
+          }
         }
 
         if (options.bridge) {
           yield* createBridgeNetworkIfNeeded(options.bridge);
         }
+
+        if (!input && !config?.vm?.iso && isValidISOurl(isoPath!)) {
+          isoPath = null;
+        }
+
         yield* runQemu(isoPath, options);
       });
 
···
     .command("start", "Start a virtual machine")
     .arguments("<vm-name:string>")
     .option("-c, --cpu <type:string>", "Type of CPU to emulate", {
-      default: "host",
+      default: Deno.build.os === "darwin" && Deno.build.arch === "aarch64"
+        ? "max"
+        : "host",
     })
     .option("-C, --cpus <number:number>", "Number of CPU cores", {
       default: 2,
···
     .arguments("<vm-name:string>")
     .action(async (_options: unknown, vmName: string) => {
       await restart(vmName);
+    })
+    .command("init", "Initialize a default VM configuration file")
+    .action(async () => {
+      await Effect.runPromise(initVmFile(CONFIG_FILE_NAME));
+      console.log(
+        `New VM configuration file created at ${
+          chalk.greenBright("./") +
+          chalk.greenBright(CONFIG_FILE_NAME)
+        }`,
+      );
+      console.log(
+        `You can edit this file to customize your VM settings and then start the VM with:`,
+      );
+      console.log(`  ${chalk.greenBright(`dflybsd-up`)}`);
     })
     .parse(Deno.args);
 }

src/config.ts

···
+import { parseFlags } from "@cliffy/flags";
+import _ from "@es-toolkit/es-toolkit/compat";
+import * as toml from "@std/toml";
+import z from "@zod/zod";
+import { Data, Effect } from "effect";
+import {
+  constructDownloadUrl,
+  DEFAULT_VERSION,
+  type Options,
+} from "./utils.ts";
+
+export const VmConfigSchema = z.object({
+  vm: z.object({
+    iso: z.string(),
+    output: z.string(),
+    cpu: z.string(),
+    cpus: z.number(),
+    memory: z.string(),
+    image: z.string(),
+    disk_format: z.enum(["qcow2", "raw"]),
+    size: z.string(),
+  }).partial(),
+  network: z.object({
+    bridge: z.string(),
+    port_forward: z.string(),
+  }).partial(),
+  options: z.object({
+    detach: z.boolean(),
+  }).partial(),
+});
+
+export type VmConfig = z.infer<typeof VmConfigSchema>;
+
+class VmConfigError extends Data.TaggedError("VmConfigError")<{
+  cause?: string;
+}> {}
+
+export const initVmFile = (
+  path: string,
+): Effect.Effect<void, VmConfigError, never> =>
+  Effect.tryPromise({
+    try: async () => {
+      const defaultConfig: VmConfig = {
+        vm: {
+          iso: constructDownloadUrl(DEFAULT_VERSION),
+          cpu: Deno.build.os === "darwin" && Deno.build.arch === "aarch64"
+            ? "max"
+            : "host",
+          cpus: 2,
+          memory: "2G",
+        },
+        network: {
+          port_forward: "2222:22",
+        },
+        options: {
+          detach: false,
+        },
+      };
+      const tomlString = toml.stringify(defaultConfig);
+      await Deno.writeTextFile(path, tomlString);
+    },
+    catch: (error) => new VmConfigError({ cause: String(error) }),
+  });
+
+export const parseVmFile = (
+  path: string,
+): Effect.Effect<VmConfig, VmConfigError, never> =>
+  Effect.tryPromise({
+    try: async () => {
+      const fileContent = await Deno.readTextFile(path);
+      const parsedToml = toml.parse(fileContent);
+      return VmConfigSchema.parse(parsedToml);
+    },
+    catch: (error) => new VmConfigError({ cause: String(error) }),
+  });
+
+export const mergeConfig = (
+  config: VmConfig | null,
+  options: Options,
+): Effect.Effect<Options, never, never> => {
+  const { flags } = parseFlags(Deno.args);
+  const defaultConfig: VmConfig = {
+    vm: {
+      iso: _.get(config, "vm.iso"),
+      cpu: _.get(
+        config,
+        "vm.cpu",
+        Deno.build.os === "darwin" && Deno.build.arch === "aarch64"
+          ? "max"
+          : "host",
+      ),
+      cpus: _.get(config, "vm.cpus", 2),
+      memory: _.get(config, "vm.memory", "2G"),
+      image: _.get(config, "vm.image", options.image),
+      disk_format: _.get(config, "vm.disk_format", "raw"),
+      size: _.get(config, "vm.size", "20G"),
+    },
+    network: {
+      bridge: _.get(config, "network.bridge"),
+      port_forward: _.get(config, "network.port_forward", "2222:22"),
+    },
+    options: {
+      detach: _.get(config, "options.detach", false),
+    },
+  };
+  return Effect.succeed({
+    memory: _.get(flags, "memory", defaultConfig.vm.memory!) as string,
+    cpus: _.get(flags, "cpus", defaultConfig.vm.cpus!) as number,
+    cpu: _.get(flags, "cpu", defaultConfig.vm.cpu!) as string,
+    diskFormat: _.get(
+      flags,
+      "diskFormat",
+      defaultConfig.vm.disk_format!,
+    ) as string,
+    portForward: _.get(
+      flags,
+      "portForward",
+      defaultConfig.network.port_forward!,
+    ) as string,
+    image: _.get(flags, "image", defaultConfig.vm.image!) as string,
+    bridge: _.get(flags, "bridge", defaultConfig.network.bridge!) as string,
+    size: _.get(flags, "size", defaultConfig.vm.size!) as string,
+  });
+};

src/constants.ts

···
 export const DB_PATH: string = `${CONFIG_DIR}/state.sqlite`;
 export const LOGS_DIR: string = `${CONFIG_DIR}/logs`;
 export const EMPTY_DISK_THRESHOLD_KB = 100;
+export const CONFIG_FILE_NAME: string = "vmconfig.toml";

src/mod.ts

···
+export * from "./config.ts";
 export * from "./constants.ts";
 export * from "./context.ts";
 export * from "./db.ts";

src/subcommands/inspect.ts

···
 const inspectVirtualMachine = (name: string) =>
   pipe(
     getInstanceStateOrFail(name),
-    Effect.flatMap(Effect.log),
+    Effect.tap((vm) =>
+      Effect.sync(() => {
+        console.log(vm);
+      })
+    ),
   );
 
 export default async function (name: string) {

src/utils.ts

···
   pid: number;
 }> {}
 
-const DEFAULT_VERSION = "6.4.2";
+export const DEFAULT_VERSION = "6.4.2";
 
 export interface Options {
   output?: string;
···
   portForward?: string;
   detach?: boolean;
 }
+
+export const isValidISOurl = (url?: string): boolean => {
+  return Boolean(
+    (url?.startsWith("http://") || url?.startsWith("https://")) &&
+      url?.endsWith(".iso"),
+  );
+};
 
 const du = (path: string) =>
   Effect.tryPromise({
···
           catch: (cause) =>
             new CommandExecutionError({
               cause,
-              message: "Failed to start detached QEMU process",
+              message: `Failed to start detached QEMU process: ${cause}`,
             }),
         }),
         Effect.flatMap((qemuPid) =>