@nanoforge-dev/cli 1.1.0 → 1.2.0

package/dist/command.loader.js

@@ -11,7 +11,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 
 // src/command/command.loader.ts
-import { red as red8 } from "ansis";
+import { red as red6 } from "ansis";
 
 // src/lib/ui/messages.ts
 import { green } from "ansis";
@@ -39,48 +39,63 @@ var Emojis = {
 };
 
 // src/lib/ui/messages.ts
+var success = /* @__PURE__ */ __name((text) => `${Emojis.ROCKET}  ${text}`, "success");
+var failure = /* @__PURE__ */ __name((text) => `${Emojis.SCREAM}  ${text}`, "failure");
 var Messages = {
+  // --- Build ---
   BUILD_START: "NanoForge Build",
-  BUILD_WATCH_START: "Start watching mode",
+  BUILD_SUCCESS: success("Build succeeded!"),
+  BUILD_FAILED: failure("Build failed!"),
+  BUILD_WATCH_START: "Watching for changes...",
   BUILD_PART_IN_PROGRESS: /* @__PURE__ */ __name((part) => `Building ${part}`, "BUILD_PART_IN_PROGRESS"),
-  BUILD_PART_WATCH_IN_PROGRESS: /* @__PURE__ */ __name((part) => `${part} updated. Rebuilding`, "BUILD_PART_WATCH_IN_PROGRESS"),
-  BUILD_NOTHING: "Nothing to build, terminated.",
-  BUILD_SUCCESS: `${Emojis.ROCKET}  Build succeeded !`,
-  BUILD_PART_FAILED: /* @__PURE__ */ __name((part, commandToRunManually) => `${Emojis.SCREAM}  Build of ${part} failed !
-In case you don't see any errors above, consider manually running the failed command ${commandToRunManually} to see more details on why it errored out.`, "BUILD_PART_FAILED"),
-  BUILD_FAILED: `${Emojis.SCREAM}  Build failed !`,
+  BUILD_PART_WATCH_IN_PROGRESS: /* @__PURE__ */ __name((part) => `${part} updated, rebuilding`, "BUILD_PART_WATCH_IN_PROGRESS"),
+  BUILD_PART_FAILED: /* @__PURE__ */ __name((part, command) => failure(`Build of ${part} failed!
+Try running manually: ${command}`), "BUILD_PART_FAILED"),
+  // --- Install ---
   INSTALL_START: "NanoForge Installation",
-  INSTALL_NAMES_QUESTION: "Witch libraries do you want to install ?",
+  INSTALL_SUCCESS: success("Installation completed!"),
+  INSTALL_FAILED: failure("Installation failed!"),
+  INSTALL_NAMES_QUESTION: "Which libraries do you want to install?",
+  // --- New Project ---
   NEW_START: "NanoForge Project Creation",
-  NEW_SUCCESS: `${Emojis.ROCKET}  Project successfully created !`,
-  NEW_FAILED: `${Emojis.SCREAM}  Project creation failed !`,
-  NEW_NAME_QUESTION: "What is the name of your project ?",
-  NEW_PACKAGE_MANAGER_QUESTION: "Which package manager do you want to use ?",
-  NEW_LANGUAGE_QUESTION: "Which language do you want to use ?",
-  NEW_STRICT_QUESTION: "Do you want to use types strict mode ?",
-  NEW_SERVER_QUESTION: "Do you want generate a server to create a multiplayer game ?",
-  NEW_SKIP_INSTALL_QUESTION: "Do you want to skip installation ?",
+  NEW_SUCCESS: success("Project successfully created!"),
+  NEW_FAILED: failure("Project creation failed!"),
+  NEW_NAME_QUESTION: "What is the name of your project?",
+  NEW_PACKAGE_MANAGER_QUESTION: "Which package manager do you want to use?",
+  NEW_LANGUAGE_QUESTION: "Which language do you want to use?",
+  NEW_STRICT_QUESTION: "Do you want to use strict type checking?",
+  NEW_SERVER_QUESTION: "Do you want to generate a server for multiplayer?",
+  NEW_SKIP_INSTALL_QUESTION: "Do you want to skip dependency installation?",
+  NEW_DOCKER_QUESTION: "Do you want to add a Dockerfile for containerization?",
+  // --- Generate ---
   GENERATE_START: "NanoForge Generate",
-  GENERATE_WATCH_START: "Start watching mode",
-  GENERATE_SUCCESS: `${Emojis.ROCKET}  Generate succeeded !`,
-  GENERATE_FAILED: `${Emojis.SCREAM}  Generate failed !`,
-  DEV_START: "NanoForge Dev mode",
+  GENERATE_SUCCESS: success("Generation succeeded!"),
+  GENERATE_FAILED: failure("Generation failed!"),
+  GENERATE_WATCH_START: "Watching for changes...",
+  // --- Dev ---
+  DEV_START: "NanoForge Dev Mode",
   DEV_SUCCESS: "Dev mode ended",
-  DEV_FAILED: `${Emojis.SCREAM}  Dev failed !`,
-  SCHEMATICS_START: "Schematics execution",
-  SCHEMATIC_IN_PROGRESS: /* @__PURE__ */ __name((name) => `Executing schematic ${name}...`, "SCHEMATIC_IN_PROGRESS"),
-  SCHEMATIC_WATCH_IN_PROGRESS: /* @__PURE__ */ __name((name) => `Update watched. Executing schematic ${name}...`, "SCHEMATIC_WATCH_IN_PROGRESS"),
-  SCHEMATIC_SUCCESS: /* @__PURE__ */ __name((name) => `${Emojis.ROCKET}  Schematic ${name} executed successfully !`, "SCHEMATIC_SUCCESS"),
-  SCHEMATIC_FAILED: /* @__PURE__ */ __name((name) => `${Emojis.SCREAM}  Schematic ${name} execution failed. See error below for more details.`, "SCHEMATIC_FAILED"),
-  PACKAGE_MANAGER_INSTALLATION_IN_PROGRESS: `Installation in progress... ${Emojis.COFFEE}`,
-  PACKAGE_MANAGER_INSTALLATION_NOTHING: "Nothing to install, terminated.",
-  PACKAGE_MANAGER_INSTALLATION_SUCCEED: /* @__PURE__ */ __name((names) => names ? `${Emojis.ROCKET}  Packages successfully installed : ${names.map((name) => green(name)).join(", ")} !` : `${Emojis.ROCKET}  Packages successfully installed !`, "PACKAGE_MANAGER_INSTALLATION_SUCCEED"),
-  PACKAGE_MANAGER_INSTALLATION_FAILED: /* @__PURE__ */ __name((commandToRunManually) => `${Emojis.SCREAM}  Packages installation failed !
-In case you don't see any errors above, consider manually running the failed command ${commandToRunManually} to see more details on why it errored out.`, "PACKAGE_MANAGER_INSTALLATION_FAILED"),
-  RUN_START: "NanoForge Run",
-  RUN_PART_IN_PROGRESS: /* @__PURE__ */ __name((part) => `Running ${part}...`, "RUN_PART_IN_PROGRESS"),
-  RUN_PART_SUCCESS: /* @__PURE__ */ __name((part) => `${Emojis.ROCKET}  Run of ${part} terminated.`, "RUN_PART_SUCCESS"),
-  RUN_PART_FAILED: /* @__PURE__ */ __name((part) => `${Emojis.SCREAM}  Run of ${part} failed !`, "RUN_PART_FAILED"),
+  DEV_FAILED: failure("Dev mode failed!"),
+  // --- Start ---
+  START_START: "NanoForge Start",
+  START_SUCCESS: success("Start completed!"),
+  START_FAILED: failure("Start failed!"),
+  START_PART_IN_PROGRESS: /* @__PURE__ */ __name((part) => `Starting ${part}...`, "START_PART_IN_PROGRESS"),
+  START_PART_SUCCESS: /* @__PURE__ */ __name((part) => success(`${part} terminated.`), "START_PART_SUCCESS"),
+  START_PART_FAILED: /* @__PURE__ */ __name((part) => failure(`${part} failed!`), "START_PART_FAILED"),
+  // --- Schematics ---
+  SCHEMATICS_START: "Running schematics",
+  SCHEMATIC_IN_PROGRESS: /* @__PURE__ */ __name((name) => `Generating ${name}...`, "SCHEMATIC_IN_PROGRESS"),
+  SCHEMATIC_WATCH_IN_PROGRESS: /* @__PURE__ */ __name((name) => `Change detected, regenerating ${name}...`, "SCHEMATIC_WATCH_IN_PROGRESS"),
+  SCHEMATIC_SUCCESS: /* @__PURE__ */ __name((name) => success(`${name} generated successfully!`), "SCHEMATIC_SUCCESS"),
+  SCHEMATIC_FAILED: /* @__PURE__ */ __name((name) => failure(`${name} generation failed.`), "SCHEMATIC_FAILED"),
+  // --- Package Manager ---
+  PACKAGE_MANAGER_INSTALLATION_IN_PROGRESS: `Installing dependencies... ${Emojis.COFFEE}`,
+  PACKAGE_MANAGER_INSTALLATION_NOTHING: "Nothing to install.",
+  PACKAGE_MANAGER_INSTALLATION_SUCCEED: /* @__PURE__ */ __name((names) => names ? success(`Packages installed: ${names.map((n) => green(n)).join(", ")}`) : success("Packages installed!"), "PACKAGE_MANAGER_INSTALLATION_SUCCEED"),
+  PACKAGE_MANAGER_INSTALLATION_FAILED: /* @__PURE__ */ __name((command) => failure(`Package installation failed!
+Try running manually: ${command}`), "PACKAGE_MANAGER_INSTALLATION_FAILED"),
+  // --- Runner ---
   RUNNER_EXECUTION_ERROR: /* @__PURE__ */ __name((command) => `
 Failed to execute command: ${command}`, "RUNNER_EXECUTION_ERROR")
 };
@@ -92,11 +107,13 @@ var Prefixes = {
   ERROR: bgRgb(210, 0, 75).bold.rgb(0, 0, 0)(" Error ")
 };
 
+// src/lib/ui/spinner.ts
+import ora from "ora";
+var getSpinner = /* @__PURE__ */ __name((message) => ora({ text: message }), "getSpinner");
+
 // src/action/actions/build.action.ts
-import * as ansis from "ansis";
 import { watch } from "chokidar";
-import * as console2 from "console";
-import { dirname, join as join2 } from "path";
+import { dirname, join as join3 } from "path";
 
 // src/lib/input/base-inputs.ts
 var getStringInput = /* @__PURE__ */ __name((input2, field) => {
@@ -159,12 +176,24 @@ var getDevGenerateInput = /* @__PURE__ */ __name((inputs) => {
 import { confirm } from "@inquirer/prompts";
 
 // src/lib/utils/errors.ts
+import { red } from "ansis";
+var getErrorMessage = /* @__PURE__ */ __name((error) => {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  return void 0;
+}, "getErrorMessage");
+var handleActionError = /* @__PURE__ */ __name((context, error) => {
+  console.error();
+  console.error(red(context));
+  const msg = getErrorMessage(error);
+  if (msg) console.error(msg);
+  process.exit(1);
+}, "handleActionError");
 var promptError = /* @__PURE__ */ __name((err) => {
   if (err.name === "ExitPromptError") {
     process.exit(1);
-  } else {
-    throw err;
   }
+  throw err;
 }, "promptError");
 
 // src/lib/question/questions/confirm.question.ts
@@ -236,82 +265,31 @@ var getInstallNamesInputOrAsk = /* @__PURE__ */ __name((inputs) => {
   );
 }, "getInstallNamesInputOrAsk");
 
-// src/lib/package-manager/package-manager.factory.ts
-import fs from "fs";
-import { resolve as resolve2 } from "path";
+// src/lib/package-manager/package-manager.ts
+import { bold, red as red3 } from "ansis";
 
-// src/lib/runner/runner.factory.ts
-import { yellow } from "ansis";
-
-// src/lib/runner/abstract.runner.ts
-import { red } from "ansis";
-import { spawn } from "child_process";
-import * as process2 from "process";
-var AbstractRunner = class {
-  constructor(binary, args = []) {
-    this.binary = binary;
-    this.args = args;
+// src/lib/runner/process-logger.ts
+import { green as green2, red as red2, yellow } from "ansis";
+var formatLines = /* @__PURE__ */ __name((chunk) => {
+  return chunk.toString().replace(/\r\n|\n/g, "\n").replace(/^\n+|\n+$/g, "").split("\n");
+}, "formatLines");
+var timestamp = /* @__PURE__ */ __name(() => yellow(`[${(/* @__PURE__ */ new Date()).toISOString()}]`), "timestamp");
+var createStdoutLogger = /* @__PURE__ */ __name((name) => (chunk) => {
+  const prefix = green2(`(${name}) INFO -`);
+  for (const line of formatLines(chunk)) {
+    console.info(`${timestamp()} ${prefix} ${line}`);
   }
-  static {
-    __name(this, "AbstractRunner");
+}, "createStdoutLogger");
+var createStderrLogger = /* @__PURE__ */ __name((name) => (chunk) => {
+  const prefix = red2(`(${name}) ERROR -`);
+  for (const line of formatLines(chunk)) {
+    console.error(`${timestamp()} ${prefix} ${line}`);
   }
-  async run(args, collect = false, cwd2 = process2.cwd(), env2, listeners, failSpinner) {
-    const options = {
-      cwd: cwd2,
-      stdio: collect ? "pipe" : "inherit",
-      shell: true,
-      env: { ...process2.env, ...env2 }
-    };
-    return new Promise((resolve3, reject) => {
-      const child = spawn(
-        `${this.binary} ${[...this.args, ...args].join(" ")}`,
-        options
-      );
-      const res = [];
-      child.stdout?.on(
-        "data",
-        listeners?.onStdout ?? ((data) => res.push(data.toString().replace(/\r\n|\n/, "")))
-      );
-      child.stderr?.on(
-        "data",
-        listeners?.onStderr ?? ((data) => res.push(data.toString().replace(/\r\n|\n/, "")))
-      );
-      child.on("close", (code) => {
-        if (code === 0) {
-          resolve3(collect && res.length ? res.join("\n") : null);
-        } else {
-          if (failSpinner) failSpinner();
-          console.error(
-            red(Messages.RUNNER_EXECUTION_ERROR([this.binary, ...this.args, ...args].join(" ")))
-          );
-          if (res.length) {
-            console.error();
-            console.error(res.join("\n"));
-            console.error();
-          }
-          reject();
-        }
-      });
-    });
-  }
-  rawFullCommand(args) {
-    const commandArgs = [...this.args, ...args];
-    return `${this.binary} ${commandArgs.join(" ")}`;
-  }
-};
-
-// src/lib/runner/runners/bun.runner.ts
-var BunRunner = class extends AbstractRunner {
-  static {
-    __name(this, "BunRunner");
-  }
-  constructor() {
-    super("bun");
-  }
-};
+}, "createStderrLogger");
 
 // src/lib/utils/path.ts
-import { resolve } from "path";
+import fs from "fs";
+import { join, resolve } from "path";
 var getCwd = /* @__PURE__ */ __name((directory) => {
   return resolve(directory);
 }, "getCwd");
@@ -320,430 +298,394 @@ var getModulePath = /* @__PURE__ */ __name((name, removeLast = false) => {
   if (removeLast) return path.split("/").slice(0, -1).join("/");
   return path;
 }, "getModulePath");
-var getNodeBinaryPath = /* @__PURE__ */ __name((name) => {
-  return resolve("node_modules", ".bin", name);
-}, "getNodeBinaryPath");
-
-// src/lib/runner/runners/local-bun.runner.ts
-var LocalBunRunner = class extends AbstractRunner {
-  static {
-    __name(this, "LocalBunRunner");
-  }
-  constructor() {
-    super(getNodeBinaryPath("bun"));
-  }
-};
-
-// src/lib/runner/runners/npm.runner.ts
-var NpmRunner = class extends AbstractRunner {
-  static {
-    __name(this, "NpmRunner");
-  }
-  constructor() {
-    super("npm");
-  }
-};
-
-// src/lib/runner/runners/pnpm.runner.ts
-var PnpmRunner = class extends AbstractRunner {
-  static {
-    __name(this, "PnpmRunner");
-  }
-  constructor() {
-    super("pnpm");
-  }
-};
-
-// src/lib/runner/runners/schematic.runner.ts
-var SchematicRunner = class _SchematicRunner extends AbstractRunner {
-  static {
-    __name(this, "SchematicRunner");
-  }
-  static getModulePaths() {
-    return module.paths;
-  }
-  static findClosestSchematicsBinary() {
+var resolveCLINodeBinaryPath = /* @__PURE__ */ __name((name) => {
+  let base = join(getModulePath(".", true), "..");
+  while (base.length >= 1) {
+    const path = join(base, "node_modules", ".bin", name);
     try {
-      return getModulePath("@angular-devkit/schematics-cli/bin/schematics.js");
-    } catch (e) {
-      console.error(e);
-      throw new Error("'schematics' binary path could not be found!");
-    }
-  }
-  constructor() {
-    super(`node`, [`"${_SchematicRunner.findClosestSchematicsBinary()}"`]);
-  }
-};
-
-// src/lib/runner/runners/yarn.runner.ts
-var YarnRunner = class extends AbstractRunner {
-  static {
-    __name(this, "YarnRunner");
-  }
-  constructor() {
-    super("yarn");
-  }
-};
-
-// src/lib/runner/runner.factory.ts
-var RunnerFactory = class {
-  static {
-    __name(this, "RunnerFactory");
-  }
-  static create(runner) {
-    switch (runner) {
-      case 0 /* BUN */:
-        return new BunRunner();
-      case 1 /* LOCAL_BUN */:
-        return new LocalBunRunner();
-      case 2 /* NPM */:
-        return new NpmRunner();
-      case 3 /* PNPM */:
-        return new PnpmRunner();
-      case 4 /* SCHEMATIC */:
-        return new SchematicRunner();
-      case 5 /* YARN */:
-        return new YarnRunner();
-      default:
-        console.info(yellow`[WARN] Unsupported runner: ${runner}`);
-        throw Error(`Unsupported runner: ${runner}`);
+      fs.accessSync(path);
+      return path;
+    } catch {
+      base = join(base, "..");
     }
   }
-};
+  throw new Error("Could not find module path");
+}, "resolveCLINodeBinaryPath");
 
-// src/lib/package-manager/abstract.package-manager.ts
-import { bold, green as green2, red as red2, yellow as yellow2 } from "ansis";
-import ora from "ora";
-var SPINNER = /* @__PURE__ */ __name((message) => ora({
-  text: message
-}), "SPINNER");
-var FAIL_SPINNER = /* @__PURE__ */ __name((spinner) => () => spinner.fail(), "FAIL_SPINNER");
-var AbstractPackageManager = class {
-  constructor(runner) {
+// src/lib/package-manager/package-manager.ts
+var PackageManager = class {
+  constructor(name, commands, runner) {
+    this.name = name;
+    this.commands = commands;
     this.runner = runner;
   }
   static {
-    __name(this, "AbstractPackageManager");
+    __name(this, "PackageManager");
   }
   async install(directory) {
-    const spinner = SPINNER(Messages.PACKAGE_MANAGER_INSTALLATION_IN_PROGRESS);
-    spinner.start();
-    try {
-      const commandArgs = [this.cli.install, this.cli.silentFlag];
-      const collect = true;
-      await this.runner.run(
-        commandArgs,
-        collect,
-        getCwd(directory),
-        void 0,
-        void 0,
-        () => spinner.fail()
-      );
-      spinner.succeed();
-      this.printInstallSuccess();
-    } catch {
-      const commandArgs = [this.cli.install];
-      const commandToRun = this.runner.rawFullCommand(commandArgs);
-      this.printInstallFailure(commandToRun);
-    }
-  }
-  version() {
-    const commandArguments = ["--version"];
-    const collect = true;
-    return this.runner.run(commandArguments, collect);
-  }
-  addProduction(directory, dependencies) {
-    const command = [this.cli.add, this.cli.saveFlag];
-    return this.add(command, directory, dependencies);
-  }
-  addDevelopment(directory, dependencies) {
-    const command = [this.cli.add, this.cli.saveDevFlag];
-    return this.add(command, directory, dependencies);
-  }
-  async build(name, directory, entry, output, flags, watch3) {
-    if (!this.cli.build) throw new Error(`Package manager ${this.name} does not support building`);
-    const spinner = SPINNER(
-      (watch3 ? Messages.BUILD_PART_WATCH_IN_PROGRESS : Messages.BUILD_PART_IN_PROGRESS)(name)
+    const args = [this.commands.install, this.commands.silentFlag];
+    const result = await this.withSpinner(
+      Messages.PACKAGE_MANAGER_INSTALLATION_IN_PROGRESS,
+      async (spinner) => {
+        await this.exec(args, directory, { onFail: /* @__PURE__ */ __name(() => spinner.fail(), "onFail") });
+        this.logSuccess(Messages.PACKAGE_MANAGER_INSTALLATION_SUCCEED());
+      },
+      () => this.logFailure(this.formatFailCommand([this.commands.install]))
     );
-    spinner.start();
-    try {
-      const commandArgs = [
-        this.cli.build,
-        this.cli.silentFlag,
-        entry,
-        "--outdir",
-        output,
-        ...flags ?? []
-      ];
-      const collect = true;
-      await this.runner.run(
-        commandArgs,
-        collect,
-        getCwd(directory),
-        void 0,
-        void 0,
-        FAIL_SPINNER(spinner)
-      );
-      spinner.succeed();
-      return true;
-    } catch {
-      const commandArgs = [this.cli.install];
-      const commandToRun = this.runner.rawFullCommand(commandArgs);
-      console.error(red2(Messages.BUILD_PART_FAILED(name, bold(commandToRun))));
-      return false;
-    }
+    return result.success;
+  }
+  async addProduction(directory, dependencies) {
+    return this.addDependencies(this.commands.saveFlag, directory, dependencies);
+  }
+  async addDevelopment(directory, dependencies) {
+    return this.addDependencies(this.commands.saveDevFlag, directory, dependencies);
+  }
+  async build(name, directory, entry, output, flags = [], watch3 = false) {
+    this.assertSupports("build");
+    const message = watch3 ? Messages.BUILD_PART_WATCH_IN_PROGRESS(name) : Messages.BUILD_PART_IN_PROGRESS(name);
+    const args = [
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      this.commands.build,
+      this.commands.silentFlag,
+      entry,
+      "--outdir",
+      output,
+      ...flags
+    ];
+    const result = await this.withSpinner(
+      message,
+      async (spinner) => {
+        await this.exec(args, directory, { onFail: /* @__PURE__ */ __name(() => spinner.fail(), "onFail") });
+      },
+      () => this.logBuildFailure(name)
+    );
+    return result.success;
   }
-  async run(name, directory, file, env2 = {}, flags = [], silent = false) {
+  async run(name, directory, script, env2 = {}, flags = [], silent = false) {
+    console.info(Messages.START_PART_IN_PROGRESS(name));
     try {
-      console.info(Messages.RUN_PART_IN_PROGRESS(name));
-      const commandArgs = [...flags, this.cli.run];
-      if (silent) commandArgs.push(this.cli.silentFlag);
-      commandArgs.push(file);
-      await this.runner.run(commandArgs, true, getCwd(directory), env2, {
-        onStdout: this.onRunStdout(name),
-        onStderr: this.onRunStderr(name)
+      const args = this.buildRunArgs(script, flags, silent);
+      await this.exec(args, directory, {
+        env: env2,
+        listeners: {
+          onStdout: createStdoutLogger(name),
+          onStderr: createStderrLogger(name)
+        }
       });
-      console.info(Messages.RUN_PART_SUCCESS(name));
+      console.info(Messages.START_PART_SUCCESS(name));
       return true;
     } catch {
-      console.error(red2(Messages.RUN_PART_FAILED(name)));
+      console.error(red3(Messages.START_PART_FAILED(name)));
       return false;
     }
   }
   async runDev(directory, command, env2 = {}, flags = [], collect = true) {
     try {
-      const commandArgs = [this.cli.run, command, ...flags];
-      await this.runner.run(commandArgs, collect, getCwd(directory), env2);
+      await this.exec([this.commands.run, command, ...flags], directory, { collect, env: env2 });
       return true;
     } catch {
       return false;
     }
   }
-  async add(args, directory, dependencies) {
-    if (!dependencies.length) {
-      console.info();
-      console.info(Messages.PACKAGE_MANAGER_INSTALLATION_NOTHING);
-      console.info();
-      return true;
-    }
-    const commandArguments = [...args, ...dependencies];
-    const spinner = SPINNER(Messages.PACKAGE_MANAGER_INSTALLATION_IN_PROGRESS);
+  async withSpinner(message, task, onError) {
+    const spinner = getSpinner(message);
     spinner.start();
     try {
-      const collect = true;
-      await this.runner.run(
-        commandArguments,
-        collect,
-        getCwd(directory),
-        void 0,
-        void 0,
-        FAIL_SPINNER(spinner)
-      );
+      const value = await task(spinner);
       spinner.succeed();
-      this.printInstallSuccess(dependencies);
-      return true;
+      return { success: true, value };
     } catch {
       spinner.fail();
-      const commandToRun = this.runner.rawFullCommand(commandArguments);
-      this.printInstallFailure(commandToRun);
-      return false;
+      if (onError) onError();
+      return { success: false };
     }
   }
-  printInstallSuccess(dependencies) {
+  async addDependencies(saveFlag, directory, dependencies) {
+    if (!dependencies.length) {
+      this.logEmpty(Messages.PACKAGE_MANAGER_INSTALLATION_NOTHING);
+      return true;
+    }
+    const args = [this.commands.add, saveFlag, ...dependencies];
+    const result = await this.withSpinner(
+      Messages.PACKAGE_MANAGER_INSTALLATION_IN_PROGRESS,
+      async (spinner) => {
+        await this.exec(args, directory, { onFail: /* @__PURE__ */ __name(() => spinner.fail(), "onFail") });
+        this.logSuccess(Messages.PACKAGE_MANAGER_INSTALLATION_SUCCEED(dependencies));
+      },
+      () => this.logFailure(this.formatFailCommand(args))
+    );
+    return result.success;
+  }
+  assertSupports(feature) {
+    if (!this.commands[feature]) {
+      throw new Error(`Package manager "${this.name}" does not support "${feature}"`);
+    }
+  }
+  buildRunArgs(script, flags, silent) {
+    const args = [...flags, this.commands.run];
+    if (silent) args.push(this.commands.silentFlag);
+    args.push(script);
+    return args;
+  }
+  exec(args, directory, options = {}) {
+    return this.runner.run(args, {
+      collect: options.collect ?? true,
+      cwd: getCwd(directory),
+      env: options.env,
+      listeners: options.listeners,
+      onFail: options.onFail
+    });
+  }
+  formatFailCommand(args) {
+    return this.runner.fullCommand(args);
+  }
+  logSuccess(message) {
     console.info();
-    console.info(Messages.PACKAGE_MANAGER_INSTALLATION_SUCCEED(dependencies));
+    console.info(message);
     console.info();
   }
-  printInstallFailure(command) {
-    console.error(red2(Messages.PACKAGE_MANAGER_INSTALLATION_FAILED(bold(command))));
+  logFailure(command) {
+    console.error(red3(Messages.PACKAGE_MANAGER_INSTALLATION_FAILED(bold(command))));
+  }
+  logBuildFailure(name) {
+    const command = this.formatFailCommand([this.commands.install]);
+    console.error(red3(Messages.BUILD_PART_FAILED(name, bold(command))));
+  }
+  logEmpty(message) {
+    console.info();
+    console.info(message);
+    console.info();
   }
-  onRunStdout = /* @__PURE__ */ __name((name) => (chunk) => {
-    chunk.toString().replace(/\r\n|\n/g, "\n").replace(/^\n+|\n+$/g, "").split("\n").forEach((line) => {
-      const date = yellow2(`[${(/* @__PURE__ */ new Date()).toISOString()}]`);
-      const prompt = green2(`(${name}) INFO -`);
-      console.info(`${date} ${prompt} ${line}`);
-    });
-  }, "onRunStdout");
-  onRunStderr = /* @__PURE__ */ __name((name) => (chunk) => {
-    chunk.toString().replace(/\r\n|\n/g, "\n").replace(/^\n+|\n+$/g, "").split("\n").forEach((line) => {
-      const date = yellow2(`[${(/* @__PURE__ */ new Date()).toISOString()}]`);
-      const prompt = red2(`(${name}) ERROR -`);
-      console.error(`${date} ${prompt} ${line}`);
-    });
-  }, "onRunStderr");
 };
 
-// src/lib/package-manager/package-managers/bun.package-manager.ts
-var BunPackageManager = class extends AbstractPackageManager {
+// src/lib/package-manager/package-manager.factory.ts
+import fs2 from "fs";
+import { resolve as resolve2 } from "path";
+
+// src/lib/runner/runner.ts
+import { red as red4 } from "ansis";
+import { spawn } from "child_process";
+import * as process2 from "process";
+var Runner = class {
+  constructor(binary, baseArgs = []) {
+    this.binary = binary;
+    this.baseArgs = baseArgs;
+  }
   static {
-    __name(this, "BunPackageManager");
+    __name(this, "Runner");
   }
-  constructor() {
-    super(RunnerFactory.create(0 /* BUN */));
+  async run(args, options = {}) {
+    const { collect = false, cwd: cwd2 = process2.cwd(), env: env2, listeners, onFail } = options;
+    const spawnOpts = this.buildSpawnOptions(collect, cwd2, env2);
+    const fullArgs = [...this.baseArgs, ...args];
+    return new Promise((resolve3, reject) => {
+      const child = spawn(`${this.binary} ${fullArgs.join(" ")}`, spawnOpts);
+      const output = this.attachOutputHandlers(child, listeners);
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve3(this.formatOutput(output, collect));
+        } else {
+          this.handleFailure(output, fullArgs, onFail);
+          reject(this.createError(fullArgs, code));
+        }
+      });
+    });
   }
-  get name() {
-    return "bun" /* BUN */.toUpperCase();
+  fullCommand(args) {
+    return [this.binary, ...this.baseArgs, ...args].join(" ");
   }
-  get cli() {
+  buildSpawnOptions(collect, cwd2, env2) {
     return {
-      install: "install",
-      add: "add",
-      update: "update",
-      remove: "remove",
-      run: "run",
-      saveFlag: "--save",
-      saveDevFlag: "--dev",
-      silentFlag: "--silent"
+      cwd: cwd2,
+      stdio: collect ? "pipe" : "inherit",
+      shell: true,
+      env: { ...process2.env, ...env2 }
     };
   }
+  attachOutputHandlers(child, listeners) {
+    const output = [];
+    const defaultHandler = /* @__PURE__ */ __name((data) => output.push(data.toString().replace(/\r\n|\n/, "")), "defaultHandler");
+    child.stdout?.on("data", listeners?.onStdout ?? defaultHandler);
+    child.stderr?.on("data", listeners?.onStderr ?? defaultHandler);
+    return output;
+  }
+  formatOutput(output, collect) {
+    return collect && output.length ? output.join("\n") : null;
+  }
+  handleFailure(output, args, onFail) {
+    if (onFail) onFail();
+    this.logFailedCommand(args);
+    this.logCapturedOutput(output);
+  }
+  logFailedCommand(args) {
+    console.error(red4(`
+Failed to execute command: ${this.binary} ${args.join(" ")}`));
+  }
+  logCapturedOutput(output) {
+    if (output.length) {
+      console.error();
+      console.error(output.join("\n"));
+      console.error();
+    }
+  }
+  createError(args, code) {
+    return new Error(`Command "${this.binary} ${args.join(" ")}" exited with code ${code}`);
+  }
 };
 
-// src/lib/package-manager/package-managers/local-bun.package-manager.ts
-var LocalBunPackageManager = class extends AbstractPackageManager {
+// src/lib/runner/runner.factory.ts
+var RunnerFactory = class {
   static {
-    __name(this, "LocalBunPackageManager");
+    __name(this, "RunnerFactory");
   }
-  constructor() {
-    super(RunnerFactory.create(1 /* LOCAL_BUN */));
+  static create(binary, args) {
+    return new Runner(binary, args);
   }
-  get name() {
-    return "local_bun" /* LOCAL_BUN */.toUpperCase();
+  static createLocal(binary, args) {
+    return new Runner(resolveCLINodeBinaryPath(binary), args);
   }
-  get cli() {
-    return {
+  static createSchematic() {
+    const binaryPath = this.resolveSchematicBinary();
+    return new Runner("node", [`"${binaryPath}"`]);
+  }
+  static resolveSchematicBinary() {
+    try {
+      return getModulePath("@angular-devkit/schematics-cli/bin/schematics.js");
+    } catch {
+      throw new Error("'schematics' binary path could not be found!");
+    }
+  }
+};
+
+// src/lib/package-manager/package-manager-configs.ts
+var PM_CONFIGS = {
+  ["bun" /* BUN */]: {
+    binary: "bun",
+    commands: {
+      install: "install",
+      add: "add",
+      update: "update",
+      remove: "remove",
+      exec: "exec",
+      run: "run",
+      saveFlag: "--save",
+      saveDevFlag: "--dev",
+      silentFlag: "--silent"
+    }
+  },
+  ["local_bun" /* LOCAL_BUN */]: {
+    binary: "bun",
+    commands: {
       install: "install",
       add: "add",
       update: "update",
       remove: "remove",
+      exec: "exec",
       run: "run",
       build: "build",
       runFile: "run",
       saveFlag: "--save",
       saveDevFlag: "--dev",
       silentFlag: "--silent"
-    };
-  }
-};
-
-// src/lib/package-manager/package-managers/npm.package-manager.ts
-var NpmPackageManager = class extends AbstractPackageManager {
-  static {
-    __name(this, "NpmPackageManager");
-  }
-  constructor() {
-    super(RunnerFactory.create(2 /* NPM */));
-  }
-  get name() {
-    return "npm" /* NPM */.toUpperCase();
-  }
-  get cli() {
-    return {
+    }
+  },
+  ["npm" /* NPM */]: {
+    binary: "npm",
+    commands: {
       install: "install",
       add: "install",
       update: "update",
       remove: "uninstall",
+      exec: "exec",
       run: "run",
       saveFlag: "--save",
       saveDevFlag: "--save-dev",
       silentFlag: "--silent"
-    };
-  }
-};
-
-// src/lib/package-manager/package-managers/pnpm.package-manager.ts
-var PnpmPackageManager = class extends AbstractPackageManager {
-  static {
-    __name(this, "PnpmPackageManager");
-  }
-  constructor() {
-    super(RunnerFactory.create(3 /* PNPM */));
-  }
-  get name() {
-    return "pnpm" /* PNPM */.toUpperCase();
-  }
-  get cli() {
-    return {
+    }
+  },
+  ["pnpm" /* PNPM */]: {
+    binary: "pnpm",
+    commands: {
       install: "install",
       add: "add",
       update: "update",
       remove: "remove",
+      exec: "exec",
       run: "run",
       saveFlag: "-P",
       saveDevFlag: "-D",
       silentFlag: "--silent"
-    };
-  }
-};
-
-// src/lib/package-manager/package-managers/yarn.package-manager.ts
-var YarnPackageManager = class extends AbstractPackageManager {
-  static {
-    __name(this, "YarnPackageManager");
-  }
-  constructor() {
-    super(RunnerFactory.create(5 /* YARN */));
-  }
-  get name() {
-    return "yarn" /* YARN */.toUpperCase();
-  }
-  get cli() {
-    return {
+    }
+  },
+  ["yarn" /* YARN */]: {
+    binary: "yarn",
+    commands: {
       install: "install",
       add: "add",
       update: "update",
       remove: "remove",
+      exec: "exec",
       run: "run",
       saveFlag: "",
       saveDevFlag: "-D",
       silentFlag: "--silent"
-    };
+    }
   }
 };
 
 // src/lib/package-manager/package-manager.factory.ts
+var LOCK_FILE_MAP = {
+  "bun.lock": "bun" /* BUN */,
+  "package-lock.json": "npm" /* NPM */,
+  "pnpm-lock.yaml": "pnpm" /* PNPM */,
+  "yarn.lock": "yarn" /* YARN */
+};
 var PackageManagerFactory = class {
   static {
     __name(this, "PackageManagerFactory");
   }
   static create(name) {
-    switch (name) {
-      case "bun" /* BUN */:
-        return new BunPackageManager();
-      case "local_bun" /* LOCAL_BUN */:
-        return new LocalBunPackageManager();
-      case "npm" /* NPM */:
-        return new NpmPackageManager();
-      case "pnpm" /* PNPM */:
-        return new PnpmPackageManager();
-      case "yarn" /* YARN */:
-        return new YarnPackageManager();
-      default:
-        throw new Error(`Package manager ${name} is not managed.`);
+    const config2 = PM_CONFIGS[name];
+    if (!config2) {
+      throw new Error(`Package manager ${name} is not managed.`);
     }
+    const runner = this.createRunner(name, config2.binary);
+    return new PackageManager(name, config2.commands, runner);
   }
   static async find(directory = ".") {
-    const DEFAULT_PACKAGE_MANAGER = "npm" /* NPM */;
+    const detected = await this.detectFromLockFile(directory);
+    return this.create(detected);
+  }
+  static createRunner(name, binary) {
+    if (name === "local_bun" /* LOCAL_BUN */) {
+      return RunnerFactory.createLocal("bun");
+    }
+    return RunnerFactory.create(binary);
+  }
+  static async detectFromLockFile(directory) {
     try {
-      const files = await fs.promises.readdir(resolve2(directory));
-      if (files.includes("bun.lock")) {
-        return this.create("bun" /* BUN */);
-      }
-      if (files.includes("package-lock.json")) {
-        return this.create("npm" /* NPM */);
+      const files = await fs2.promises.readdir(resolve2(directory));
+      for (const [lockFile, pmName] of Object.entries(LOCK_FILE_MAP)) {
+        if (files.includes(lockFile)) return pmName;
       }
-      if (files.includes("pnpm-lock.yaml")) {
-        return this.create("pnpm" /* PNPM */);
-      }
-      if (files.includes("yarn.lock")) {
-        return this.create("yarn" /* YARN */);
-      }
-      return this.create(DEFAULT_PACKAGE_MANAGER);
     } catch {
-      return this.create(DEFAULT_PACKAGE_MANAGER);
     }
+    return "npm" /* NPM */;
   }
 };
 
+// src/lib/utils/run-safe.ts
+import { red as red5 } from "ansis";
+var runSafe = /* @__PURE__ */ __name(async (fn, fallback) => {
+  try {
+    return await fn();
+  } catch (error) {
+    const msg = getErrorMessage(error);
+    if (msg) console.error(red5(msg));
+    return fallback;
+  }
+}, "runSafe");
+
 // src/lib/config/config.type.ts
 import { Expose, Type } from "class-transformer";
 import { IsBoolean, IsEnum, IsNotEmpty, IsPort, IsString, ValidateNested } from "class-validator";
@@ -867,7 +809,11 @@ __decorateClass([
 import { plainToInstance } from "class-transformer";
 import { validate } from "class-validator";
 import { existsSync, readFileSync } from "fs";
-import { join } from "path";
+import { join as join2 } from "path";
+
+// src/lib/constants.ts
+var CONFIG_FILE_NAME = "nanoforge.config.json";
+var NANOFORGE_DIR = ".nanoforge";
 
 // src/lib/utils/object.ts
 var isObject = /* @__PURE__ */ __name((item) => {
@@ -922,20 +868,19 @@ var CONFIG_DEFAULTS = {
 var config;
 var getConfigPath = /* @__PURE__ */ __name((directory, name) => {
   if (name) {
-    return join(directory, name);
+    return join2(directory, name);
   } else {
-    for (const n of ["nanoforge.config.json"]) {
-      const path = join(directory, n);
+    for (const n of [CONFIG_FILE_NAME]) {
+      const path = join2(directory, n);
       if (existsSync(path)) return path;
     }
-    throw new Error(`Unsupported config: ${name}`);
+    throw new Error(`No config file found in directory: ${directory}`);
   }
 }, "getConfigPath");
 var loadConfig = /* @__PURE__ */ __name(async (directory, name) => {
   if (config) return config;
   let rawData;
   const path = getConfigPath(directory, name);
-  if (!path) throw new Error("No config file found");
   try {
     rawData = deepMerge(CONFIG_DEFAULTS, JSON.parse(readFileSync(path, "utf-8")));
   } catch {
@@ -963,6 +908,32 @@ var AbstractAction = class {
   static {
     __name(this, "AbstractAction");
   }
+  async run(args, options, extraFlags) {
+    this.logStart();
+    try {
+      const result = await this.handle(args, options, extraFlags);
+      this.resolveResult(result);
+    } catch (error) {
+      handleActionError(this.failureMessage, error);
+    }
+  }
+  logStart() {
+    console.info();
+    console.info(`${Prefixes.INFO} ${this.startMessage}`);
+    console.info();
+  }
+  resolveResult(result) {
+    const success2 = result?.success !== false;
+    const keepAlive = result?.keepAlive === true;
+    if (keepAlive) return;
+    console.info();
+    if (!success2) {
+      if (this.failureMessage) console.error(this.failureMessage);
+      process.exit(1);
+    }
+    if (this.successMessage) console.info(this.successMessage);
+    process.exit(0);
+  }
 };
 
 // src/action/actions/build.action.ts
@@ -970,119 +941,122 @@ var BuildAction = class extends AbstractAction {
   static {
     __name(this, "BuildAction");
   }
+  startMessage = Messages.BUILD_START;
+  successMessage = Messages.BUILD_SUCCESS;
+  failureMessage = Messages.BUILD_FAILED;
   async handle(_args, options) {
-    console2.info(Messages.BUILD_START);
-    console2.info();
-    try {
-      const directory = getDirectoryInput(options);
-      const config2 = await getConfig(options, directory);
-      const watch3 = getWatchInput(options);
-      const client = getPart(
+    const directory = getDirectoryInput(options);
+    const config2 = await getConfig(options, directory);
+    const isWatch = getWatchInput(options);
+    const targets = this.resolveTargets(config2, options);
+    const results = await this.buildAll(targets, directory, isWatch);
+    if (isWatch) {
+      return this.enterWatchMode();
+    }
+    return { success: results.every(Boolean) };
+  }
+  resolveTargets(config2, options) {
+    const targets = [
+      this.createTarget(
+        "Client",
         config2.client.build,
-        options.get("clientDirectory")?.value,
-        "client"
-      );
-      let res = await buildPart("Client", client, directory, { watch: watch3 });
-      if (config2.server.enable) {
-        const server = getPart(
+        "browser",
+        getStringInput(options, "clientDirectory")
+      )
+    ];
+    if (config2.server.enable) {
+      targets.push(
+        this.createTarget(
+          "Server",
           config2.server.build,
-          options.get("serverDirectory")?.value,
-          "server"
-        );
-        res = await buildPart("Server", server, directory, { watch: watch3 }) ? res : false;
-      }
-      console2.info();
-      if (watch3) {
-        console2.info(Messages.BUILD_WATCH_START);
-        console2.info();
-        return;
-      }
-      if (!res) console2.info(Messages.BUILD_FAILED);
-      else console2.info(Messages.BUILD_SUCCESS);
-      process.exit(0);
-    } catch (e) {
-      console2.error(e);
-      process.exit(1);
+          "node",
+          getStringInput(options, "serverDirectory")
+        )
+      );
     }
+    return targets;
   }
-};
-var getPart = /* @__PURE__ */ __name((config2, directoryOption, target) => {
-  return {
-    entry: config2.entryFile,
-    output: directoryOption || config2.outDir,
-    target
-  };
-}, "getPart");
-var buildPart = /* @__PURE__ */ __name(async (name, part, directory, options) => {
-  const packageManagerName = "local_bun" /* LOCAL_BUN */;
-  const packageManager = PackageManagerFactory.create(packageManagerName);
-  const build = /* @__PURE__ */ __name(async (watch3 = false) => {
-    try {
-      return await packageManager.build(
-        name,
+  createTarget(name, config2, platform, outDirOverride) {
+    return {
+      name,
+      entry: config2.entryFile,
+      output: outDirOverride || config2.outDir,
+      platform
+    };
+  }
+  async buildAll(targets, directory, isWatch) {
+    const results = [];
+    for (const target of targets) {
+      const result = await this.buildTarget(target, directory, isWatch);
+      results.push(result);
+    }
+    return results;
+  }
+  async buildTarget(target, directory, isWatch) {
+    const packageManager = PackageManagerFactory.create("local_bun" /* LOCAL_BUN */);
+    const executeBuild = /* @__PURE__ */ __name((rebuild = false) => runSafe(
+      () => packageManager.build(
+        target.name,
         directory,
-        part.entry,
-        part.output,
-        [
-          "--asset-naming",
-          "[name].[ext]",
-          "--target",
-          part.target === "client" ? "browser" : "node"
-        ],
-        watch3
-      );
-    } catch (error4) {
-      if (error4 && error4.message) {
-        console2.error(ansis.red(error4.message));
-      }
-      return false;
+        target.entry,
+        target.output,
+        ["--asset-naming", "[name].[ext]", "--target", target.platform],
+        rebuild
+      ),
+      false
+    ), "executeBuild");
+    if (isWatch) {
+      this.watchDirectory(directory, target.entry, () => executeBuild(true));
     }
-  }, "build");
-  if (options?.watch)
-    watch(dirname(join2(getCwd(directory), part.entry))).on("change", () => build(true));
-  return await build();
-}, "buildPart");
+    const result = await executeBuild();
+    return result !== false;
+  }
+  watchDirectory(directory, entry, onChange) {
+    const watchPath = dirname(join3(getCwd(directory), entry));
+    watch(watchPath).on("change", onChange);
+  }
+  enterWatchMode() {
+    console.info();
+    console.info(Messages.BUILD_WATCH_START);
+    console.info();
+    return { keepAlive: true };
+  }
+};
 
 // src/action/actions/dev.action.ts
-import * as ansis2 from "ansis";
 var DevAction = class extends AbstractAction {
   static {
     __name(this, "DevAction");
   }
+  startMessage = Messages.DEV_START;
+  successMessage = Messages.DEV_SUCCESS;
+  failureMessage = Messages.DEV_FAILED;
   async handle(_args, options) {
-    console.info(Messages.DEV_START);
-    console.info();
-    try {
-      const directory = getDirectoryInput(options);
-      const generate = getDevGenerateInput(options);
-      await Promise.all([
-        generate ? runAction("generate", [], directory, false) : void 0,
-        runAction("build", [], directory, false),
-        runAction("start", [], directory, true)
-      ]);
-      console.info(Messages.DEV_SUCCESS);
-      process.exit(0);
-    } catch (e) {
-      console.error(Messages.DEV_FAILED);
-      console.error(e);
-      process.exit(1);
+    const directory = getDirectoryInput(options);
+    const generate = getDevGenerateInput(options);
+    const tasks = this.buildTaskList(directory, generate);
+    await Promise.all(tasks);
+    return { keepAlive: true };
+  }
+  buildTaskList(directory, generate) {
+    const tasks = [];
+    if (generate) {
+      tasks.push(this.runSubCommand("generate", directory, { silent: true }));
     }
+    tasks.push(this.runSubCommand("build", directory, { silent: true }));
+    tasks.push(this.runSubCommand("start", directory, { silent: false }));
+    return tasks;
+  }
+  async runSubCommand(command, directory, options) {
+    await runSafe(async () => {
+      const packageManager = await PackageManagerFactory.find(directory);
+      await packageManager.runDev(directory, "nf", {}, [command, "--watch"], options.silent);
+    });
   }
 };
-var runAction = /* @__PURE__ */ __name(async (command, params, directory, stdout = false) => {
-  try {
-    const packageManager = await PackageManagerFactory.find(directory);
-    await packageManager.runDev(directory, "nf", {}, [command, ...params, "--watch"], !stdout);
-  } catch (error4) {
-    if (error4 && error4.message) {
-      console.error(ansis2.red(error4.message));
-    }
-  }
-}, "runAction");
 
 // src/action/actions/generate.action.ts
-import * as console3 from "console";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 
 // src/lib/schematics/abstract.collection.ts
 var AbstractCollection = class {
@@ -1094,25 +1068,19 @@ var AbstractCollection = class {
   static {
     __name(this, "AbstractCollection");
   }
-  async execute(name, options, flags, failSpinner) {
+  async execute(name, options, flags, onFail) {
     const command = this.buildCommandLine(name, options, flags);
-    await this.runner.run(
-      command,
-      true,
-      this.cwd ? getCwd(this.cwd) : void 0,
-      void 0,
-      void 0,
-      failSpinner
-    );
+    await this.runner.run(command, {
+      collect: true,
+      cwd: this.cwd ? getCwd(this.cwd) : void 0,
+      onFail
+    });
   }
   buildCommandLine(name, options, flags = []) {
-    return [`${this.collection}:${name}`, ...flags, ...this.buildOptions(options)];
+    return [`${this.collection}:${name}`, ...flags, ...this.serializeOptions(options)];
   }
-  buildOptions(options) {
-    return options.reduce(
-      (old, option) => [...old, ...option.toCommandString()],
-      []
-    );
+  serializeOptions(options) {
+    return options.flatMap((option) => option.toCommandString());
   }
 };
 
@@ -1141,6 +1109,11 @@ var NanoforgeCollection = class _NanoforgeCollection extends AbstractCollection
       name: "part-main",
       alias: "main",
       description: "Generate a NanoForge Part Main file"
+    },
+    {
+      name: "docker",
+      alias: "docker",
+      description: "Generate a Dockerfile for the application"
     }
   ];
   constructor(runner, cwd2) {
@@ -1172,12 +1145,11 @@ var CollectionFactory = class {
     __name(this, "CollectionFactory");
   }
   static create(collection, directory) {
-    const schematicRunner = RunnerFactory.create(4 /* SCHEMATIC */);
+    const schematicRunner = RunnerFactory.createSchematic();
     if (collection === "@nanoforge-dev/schematics" /* NANOFORGE */) {
       return new NanoforgeCollection(schematicRunner, directory);
-    } else {
-      return new NanoforgeCollection(schematicRunner, directory);
     }
+    throw new Error(`Unknown collection: ${collection}`);
   }
 };
 
@@ -1210,7 +1182,7 @@ var SchematicOption = class {
       }
     } else if (typeof this.value === "boolean") {
       const str = normalizedName;
-      return this.value ? [`--${str}`] : [`--no-${str}`];
+      return this.value ? [`--${str}=true`] : [`--${str}=false`];
     } else if (Array.isArray(this.value)) {
       return this.value.reduce(
         (old, option) => [
@@ -1235,19 +1207,10 @@ var SchematicOption = class {
 
 // src/action/common/schematics.ts
 import { watch as watch2 } from "chokidar";
-
-// src/action/common/spinner.ts
-import ora2 from "ora";
-var getSpinner = /* @__PURE__ */ __name((message) => ora2({
-  text: message
-}), "getSpinner");
-
-// src/action/common/schematics.ts
 var executeSchematic = /* @__PURE__ */ __name(async (name, collection, schematicName, options, fileToWatch) => {
-  const execute = /* @__PURE__ */ __name(async (watch3 = false) => {
-    const spinner = getSpinner(
-      (watch3 ? Messages.SCHEMATIC_WATCH_IN_PROGRESS : Messages.SCHEMATIC_IN_PROGRESS)(name)
-    );
+  const execute = /* @__PURE__ */ __name(async (isRebuild = false) => {
+    const message = isRebuild ? Messages.SCHEMATIC_WATCH_IN_PROGRESS(name) : Messages.SCHEMATIC_IN_PROGRESS(name);
+    const spinner = getSpinner(message);
     spinner.start();
     await collection.execute(
       schematicName,
@@ -1257,16 +1220,17 @@ var executeSchematic = /* @__PURE__ */ __name(async (name, collection, schematic
     );
     spinner.succeed(Messages.SCHEMATIC_SUCCESS(name));
   }, "execute");
-  if (fileToWatch) watch2(fileToWatch).on("change", () => execute(true));
-  return await execute();
+  if (fileToWatch) {
+    watch2(fileToWatch).on("change", () => execute(true));
+  }
+  await execute();
 }, "executeSchematic");
 var mapSchematicOptions = /* @__PURE__ */ __name((inputs) => {
-  return Object.entries(inputs).reduce((old, [key, value]) => {
-    if (value === void 0) return old;
-    return [
-      ...old,
-      new SchematicOption(key, typeof value === "object" ? mapSchematicOptions(value) : value)
-    ];
+  return Object.entries(inputs).reduce((acc, [key, value]) => {
+    if (value === void 0) return acc;
+    const mapped = typeof value === "object" ? new SchematicOption(key, mapSchematicOptions(value)) : new SchematicOption(key, value);
+    acc.push(mapped);
+    return acc;
   }, []);
 }, "mapSchematicOptions");
 
@@ -1275,108 +1239,98 @@ var GenerateAction = class extends AbstractAction {
   static {
     __name(this, "GenerateAction");
   }
+  startMessage = Messages.GENERATE_START;
+  successMessage = Messages.GENERATE_SUCCESS;
+  failureMessage = Messages.GENERATE_FAILED;
   async handle(_args, options) {
-    console3.info(Messages.GENERATE_START);
-    console3.info();
-    try {
-      const directory = getDirectoryInput(options);
-      const config2 = await getConfig(options, directory);
-      const watch3 = getWatchInput(options);
-      const values = await getSchemaValues(config2);
-      await generateFiles(values, directory, watch3);
-      console3.info();
-      if (watch3) {
-        console3.info(Messages.GENERATE_WATCH_START);
-        console3.info();
-        return;
-      }
-      console3.info(Messages.GENERATE_SUCCESS);
-      process.exit(0);
-    } catch (e) {
-      console3.error(Messages.GENERATE_FAILED);
-      console3.error(e);
-      process.exit(1);
+    const directory = getDirectoryInput(options);
+    const config2 = await getConfig(options, directory);
+    const isWatch = getWatchInput(options);
+    const values = this.extractValues(config2);
+    await this.generateParts(values, directory, isWatch);
+    if (isWatch) {
+      return this.enterWatchMode();
     }
+    return {};
   }
-};
-var getSchemaValues = /* @__PURE__ */ __name(async (config2) => {
-  return {
-    name: config2.name,
-    directory: ".",
-    language: config2.language,
-    server: config2.server.enable,
-    initFunctions: config2.initFunctions
-  };
-}, "getSchemaValues");
-var generateFiles = /* @__PURE__ */ __name(async (values, directory, watch3) => {
-  const collection = CollectionFactory.create("@nanoforge-dev/schematics" /* NANOFORGE */, directory);
-  console3.info(Messages.SCHEMATICS_START);
-  console3.info();
-  await executeSchematic(
-    "Client main file",
-    collection,
-    "part-main",
-    {
-      name: values.name,
-      part: "client",
-      directory: values.directory,
-      language: values.language,
-      initFunctions: values.initFunctions
-    },
-    watch3 ? join3(getCwd(directory), values.directory, ".nanoforge", "client.save.json") : void 0
-  );
-  if (values.server) {
+  extractValues(config2) {
+    return {
+      name: config2.name,
+      directory: ".",
+      language: config2.language,
+      server: config2.server.enable,
+      initFunctions: config2.initFunctions
+    };
+  }
+  async generateParts(values, directory, watch3) {
+    const collection = CollectionFactory.create("@nanoforge-dev/schematics" /* NANOFORGE */, directory);
+    const baseOptions = this.baseSchematicOptions(values);
     await executeSchematic(
-      "Server main file",
+      "Client main file",
       collection,
       "part-main",
-      {
-        name: values.name,
-        part: "server",
-        directory: values.directory,
-        language: values.language,
-        initFunctions: values.initFunctions
-      },
-      join3(getCwd(directory), values.directory, ".nanoforge", "server.save.json")
+      { ...baseOptions, part: "client" },
+      watch3 ? this.watchPath(directory, values.directory, "client") : void 0
     );
+    if (values.server) {
+      await executeSchematic(
+        "Server main file",
+        collection,
+        "part-main",
+        { ...baseOptions, part: "server" },
+        this.watchPath(directory, values.directory, "server")
+      );
+    }
   }
-}, "generateFiles");
+  baseSchematicOptions(values) {
+    return {
+      name: values.name,
+      directory: values.directory,
+      language: values.language,
+      initFunctions: values.initFunctions
+    };
+  }
+  watchPath(directory, subDir, part) {
+    return join4(getCwd(directory), subDir, NANOFORGE_DIR, `${part}.save.json`);
+  }
+  enterWatchMode() {
+    console.info();
+    console.info(Messages.GENERATE_WATCH_START);
+    console.info();
+    return { keepAlive: true };
+  }
+};
 
 // src/action/actions/install.action.ts
-import * as ansis3 from "ansis";
-import * as process3 from "process";
 var InstallAction = class extends AbstractAction {
   static {
     __name(this, "InstallAction");
   }
+  startMessage = Messages.INSTALL_START;
+  successMessage = Messages.INSTALL_SUCCESS;
+  failureMessage = Messages.INSTALL_FAILED;
   async handle(args, options) {
-    console.info(Messages.INSTALL_START);
-    console.info();
-    try {
-      const names = await getInstallNamesInputOrAsk(args);
-      const directory = getDirectoryInput(options);
-      await installPackages(names, directory);
-      process3.exit(0);
-    } catch (e) {
-      console.error(e);
-      process3.exit(1);
-    }
-  }
-};
-var installPackages = /* @__PURE__ */ __name(async (names, directory) => {
-  try {
+    const names = await getInstallNamesInputOrAsk(args);
+    const directory = getDirectoryInput(options);
     const packageManager = await PackageManagerFactory.find(directory);
-    await packageManager.addProduction(directory, names);
-  } catch (error4) {
-    if (error4 && error4.message) {
-      console.error(ansis3.red(error4.message));
-    }
+    const success2 = await packageManager.addProduction(directory, names);
+    return { success: success2 };
   }
-}, "installPackages");
+};
 
 // src/action/actions/new.action.ts
-import * as ansis4 from "ansis";
-import console4 from "console";
+import { join as join5 } from "path";
+
+// src/lib/input/inputs/new/docker.input.ts
+var getDockerInput = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInput(inputs, "docker");
+}, "getDockerInput");
+var getDockerOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getDockerInput(inputs),
+    () => askConfirm(Messages.NEW_DOCKER_QUESTION, { default: true })
+  );
+}, "getDockerOrAsk");
 
 // src/lib/input/inputs/new/init-functions.input.ts
 var getNewInitFunctionsWithDefault = /* @__PURE__ */ __name((inputs) => {
@@ -1470,159 +1424,186 @@ var NewAction = class extends AbstractAction {
   static {
     __name(this, "NewAction");
   }
+  startMessage = Messages.NEW_START;
+  successMessage = Messages.NEW_SUCCESS;
+  failureMessage = Messages.NEW_FAILED;
   async handle(_args, options) {
-    console4.info(Messages.NEW_START);
-    try {
-      const directory = getDirectoryInput(options);
-      const values = await getSchemaValues2(options);
-      await generateApplicationFiles(values, directory);
-      if (!values.skipInstall) await runInstall(directory, values.packageManager);
-      console4.info();
-      console4.info(Messages.NEW_SUCCESS);
-      process.exit(0);
-    } catch {
-      console4.error(Messages.NEW_FAILED);
-      process.exit(1);
+    const directory = getDirectoryInput(options);
+    const values = await this.collectValues(options);
+    await this.scaffold(values, directory);
+    let res = true;
+    if (!values.skipInstall) {
+      res = await this.installDependencies(values.packageManager, join5(directory, values.name));
     }
+    return { success: res };
   }
-};
-var getSchemaValues2 = /* @__PURE__ */ __name(async (inputs) => {
-  return {
-    name: await getNewNameInputOrAsk(inputs),
-    directory: getNewPathInput(inputs),
-    packageManager: await getNewPackageManagerInputOrAsk(inputs),
-    language: await getNewLanguageInputOrAsk(inputs),
-    strict: await getNewStrictOrAsk(inputs),
-    server: await getNewServerOrAsk(inputs),
-    initFunctions: getNewInitFunctionsWithDefault(inputs),
-    skipInstall: await getNewSkipInstallOrAsk(inputs)
-  };
-}, "getSchemaValues");
-var generateApplicationFiles = /* @__PURE__ */ __name(async (values, directory) => {
-  console4.info();
-  const collection = CollectionFactory.create("@nanoforge-dev/schematics" /* NANOFORGE */, directory);
-  console4.info();
-  console4.info(Messages.SCHEMATICS_START);
-  console4.info();
-  await executeSchematic("Application", collection, "application", {
-    name: values.name,
-    directory: values.directory,
-    packageManager: values.packageManager,
-    language: values.language,
-    strict: values.strict,
-    server: values.server
-  });
-  await executeSchematic("Configuration", collection, "configuration", {
-    name: values.name,
-    directory: values.directory,
-    server: values.server
-  });
-  await executeSchematic("Base Client", collection, "part-base", {
-    name: values.name,
-    part: "client",
-    directory: values.directory,
-    language: values.language,
-    initFunctions: values.initFunctions
-  });
-  await executeSchematic("Client main file", collection, "part-main", {
-    name: values.name,
-    part: "client",
-    directory: values.directory,
-    language: values.language,
-    initFunctions: values.initFunctions
-  });
-  if (values.server) {
-    await executeSchematic("Base server", collection, "part-base", {
+  async collectValues(inputs) {
+    return {
+      name: await getNewNameInputOrAsk(inputs),
+      directory: getNewPathInput(inputs),
+      packageManager: await getNewPackageManagerInputOrAsk(inputs),
+      language: await getNewLanguageInputOrAsk(inputs),
+      strict: await getNewStrictOrAsk(inputs),
+      server: await getNewServerOrAsk(inputs),
+      initFunctions: getNewInitFunctionsWithDefault(inputs),
+      skipInstall: await getNewSkipInstallOrAsk(inputs),
+      docker: await getDockerOrAsk(inputs)
+    };
+  }
+  async scaffold(values, directory) {
+    const collection = CollectionFactory.create("@nanoforge-dev/schematics" /* NANOFORGE */, directory);
+    console.info(Messages.SCHEMATICS_START);
+    console.info();
+    await this.generateApplication(collection, values);
+    await this.generateConfiguration(collection, values);
+    await this.generateClientParts(collection, values);
+    await this.generateDocker(collection, values);
+    if (values.server) {
+      await this.generateServerParts(collection, values);
+    }
+  }
+  generateApplication(collection, values) {
+    return executeSchematic("Application", collection, "application", {
       name: values.name,
-      part: "server",
       directory: values.directory,
+      packageManager: values.packageManager,
       language: values.language,
-      initFunctions: values.initFunctions
+      strict: values.strict,
+      server: values.server
+    });
+  }
+  generateConfiguration(collection, values) {
+    return executeSchematic("Configuration", collection, "configuration", {
+      name: values.name,
+      directory: values.directory,
+      server: values.server
+    });
+  }
+  async generateClientParts(collection, values) {
+    const partOptions = this.partOptions(values, "client");
+    await executeSchematic("Client base", collection, "part-base", {
+      ...partOptions,
+      server: values.server
+    });
+    await executeSchematic("Client main file", collection, "part-main", partOptions);
+  }
+  async generateServerParts(collection, values) {
+    const partOptions = this.partOptions(values, "server");
+    await executeSchematic("Server base", collection, "part-base", {
+      ...partOptions,
+      server: values.server
+    });
+    await executeSchematic("Server main file", collection, "part-main", partOptions);
+  }
+  async generateDocker(collection, values) {
+    await executeSchematic("Docker", collection, "docker", {
+      name: values.name,
+      directory: values.directory,
+      packageManager: values.packageManager
     });
-    await executeSchematic("Server main file", collection, "part-main", {
+  }
+  partOptions(values, part) {
+    return {
       name: values.name,
-      part: "server",
+      part,
       directory: values.directory,
       language: values.language,
       initFunctions: values.initFunctions
-    });
+    };
   }
-}, "generateApplicationFiles");
-var runInstall = /* @__PURE__ */ __name(async (directory, pkgManagerName) => {
-  try {
-    const packageManager = PackageManagerFactory.create(pkgManagerName);
-    await packageManager.install(directory);
-  } catch (error4) {
-    if (error4 && error4.message) {
-      console4.error(ansis4.red(error4.message));
-    }
+  async installDependencies(packageManagerName, directory) {
+    const packageManager = PackageManagerFactory.create(packageManagerName);
+    return await packageManager.install(directory);
   }
-}, "runInstall");
+};
 
 // src/action/actions/start.action.ts
-import * as ansis5 from "ansis";
-import * as console5 from "console";
-import { join as join4 } from "path";
+import { join as join6 } from "path";
 var StartAction = class extends AbstractAction {
   static {
     __name(this, "StartAction");
   }
+  startMessage = Messages.START_START;
+  successMessage = Messages.START_SUCCESS;
+  failureMessage = Messages.START_FAILED;
   async handle(_args, options) {
-    console5.info(Messages.RUN_START);
-    console5.info();
-    try {
-      const directory = getDirectoryInput(options);
-      const config2 = await getConfig(options, directory);
-      const clientDir = config2.client.runtime.dir;
-      const serverDir = config2.server.runtime.dir;
-      const clientPort = getStringInputWithDefault(options, "clientPort", config2.client.port);
-      const watch3 = getWatchInput(options);
-      await Promise.all([
-        config2.server.enable ? this.startServer(directory, serverDir, watch3) : void 0,
-        this.startClient(clientPort, directory, clientDir, {
-          watch: watch3,
-          serverGameDir: config2.server.enable ? serverDir : void 0
-        })
-      ]);
-      process.exit(0);
-    } catch (e) {
-      console5.error(e);
-      process.exit(1);
-    }
+    const directory = getDirectoryInput(options);
+    const config2 = await getConfig(options, directory);
+    const watch3 = getWatchInput(options);
+    const ports = this.resolvePorts(options, config2);
+    const ssl = this.resolveSSL(options);
+    const tasks = this.buildStartTasks(config2, directory, watch3, ports, ssl);
+    await Promise.all(tasks);
+    return { keepAlive: true };
+  }
+  resolvePorts(options, config2) {
+    return {
+      clientPort: getStringInputWithDefault(options, "clientPort", config2.client.port),
+      gameExposurePort: getStringInput(options, "gameExposurePort"),
+      serverPort: getStringInput(options, "serverPort")
+    };
+  }
+  resolveSSL(options) {
+    const cert = getStringInput(options, "cert");
+    const key = getStringInput(options, "key");
+    if (!cert && !key) return void 0;
+    if (!cert) throw new Error("No cert entered for SSL. Please enter a key with --cert.");
+    if (!key) throw new Error("No key entered for SSL. Please enter a key with --key.");
+    return {
+      cert,
+      key
+    };
   }
-  async startClient(port, directory, gameDir, options) {
-    const path = getModulePath("@nanoforge-dev/loader-client/package.json", true);
-    const params = {
-      PORT: port,
-      GAME_DIR: getCwd(join4(directory, gameDir))
+  buildStartTasks(config2, directory, watch3, ports, ssl) {
+    const tasks = [];
+    if (config2.server.enable) {
+      tasks.push(this.startServer(directory, config2.server.runtime.dir, watch3, ports.serverPort));
+    }
+    tasks.push(this.startClient(directory, config2, watch3, ports, ssl));
+    return tasks;
+  }
+  async startClient(directory, config2, watch3, ports, ssl) {
+    const loaderPath = getModulePath("@nanoforge-dev/loader-client/package.json", true);
+    const gameDir = config2.client.runtime.dir;
+    const env2 = this.buildClientEnv(directory, gameDir, watch3, config2, ports, ssl);
+    await this.runLoader("Client", loaderPath, env2);
+  }
+  buildClientEnv(directory, gameDir, watch3, config2, ports, ssl) {
+    const env2 = {
+      PORT: ports.clientPort,
+      GAME_DIR: getCwd(join6(directory, gameDir))
     };
-    if (options?.watch) {
-      params["WATCH"] = "true";
-      if (options?.serverGameDir) {
-        params["WATCH_SERVER_GAME_DIR"] = getCwd(join4(directory, options.serverGameDir));
+    if (ports.gameExposurePort) {
+      env2["GAME_EXPOSURE_PORT"] = ports.gameExposurePort;
+    }
+    if (watch3) {
+      env2["WATCH"] = "true";
+      if (config2.server.enable) {
+        env2["WATCH_SERVER_GAME_DIR"] = getCwd(join6(directory, config2.server.runtime.dir));
       }
     }
-    return runPart("Client", path, params);
+    if (ssl) {
+      env2["CERT"] = ssl.cert;
+      env2["KEY"] = ssl.key;
+    }
+    return env2;
   }
-  startServer(directory, gameDir, watch3) {
-    const path = getModulePath("@nanoforge-dev/loader-server/package.json", true);
-    const params = {
-      GAME_DIR: getCwd(join4(directory, gameDir))
+  async startServer(directory, gameDir, watch3, port) {
+    const loaderPath = getModulePath("@nanoforge-dev/loader-server/package.json", true);
+    const env2 = {
+      GAME_DIR: getCwd(join6(directory, gameDir))
     };
-    if (watch3) params["WATCH"] = "true";
-    return runPart("Server", path, params);
+    if (port) env2["PORT"] = port;
+    if (watch3) env2["WATCH"] = "true";
+    await this.runLoader("Server", loaderPath, env2);
+  }
+  async runLoader(name, directory, env2) {
+    await runSafe(async () => {
+      const packageManager = await PackageManagerFactory.find(directory);
+      await packageManager.run(name, directory, "start", env2, [], true);
+    });
   }
 };
-var runPart = /* @__PURE__ */ __name(async (part, directory, env2, flags) => {
-  try {
-    const packageManager = await PackageManagerFactory.find(directory);
-    await packageManager.run(part, directory, "start", env2, flags, true);
-  } catch (error4) {
-    if (error4 && error4.message) {
-      console5.error(ansis5.red(error4.message));
-    }
-  }
-}, "runPart");
 
 // src/command/abstract.command.ts
 var AbstractCommand = class {
@@ -1632,6 +1613,13 @@ var AbstractCommand = class {
   static {
     __name(this, "AbstractCommand");
   }
+  static mapToInput(mapping) {
+    const input2 = /* @__PURE__ */ new Map();
+    for (const [key, value] of Object.entries(mapping)) {
+      input2.set(key, { value });
+    }
+    return input2;
+  }
 };
 
 // src/command/commands/build.command.ts
@@ -1640,15 +1628,15 @@ var BuildCommand = class extends AbstractCommand {
     __name(this, "BuildCommand");
   }
   load(program) {
-    program.command("build").description("build your game").option("-d, --directory [directory]", "specify the directory of your project").option("-c, --config [config]", "path to the config file", "nanoforge.config.json").option("--client-outDir [clientDirectory]", "specify the output directory of the client").option("--server-outDir [serverDirectory]", "specify the output directory of the server").option("--watch", "build app in watching mode", false).action(async (rawOptions) => {
-      const options = /* @__PURE__ */ new Map();
-      options.set("directory", { value: rawOptions.directory });
-      options.set("config", { value: rawOptions.config });
-      options.set("clientDirectory", { value: rawOptions.clientOutDir });
-      options.set("serverDirectory", { value: rawOptions.serverOutDir });
-      options.set("watch", { value: rawOptions.watch });
-      const args = /* @__PURE__ */ new Map();
-      await this.action.handle(args, options);
+    program.command("build").description("build your game").option("-d, --directory [directory]", "specify the directory of your project").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("--client-outDir [clientDirectory]", "specify the output directory of the client").option("--server-outDir [serverDirectory]", "specify the output directory of the server").option("--watch", "build app in watching mode", false).action(async (rawOptions) => {
+      const options = AbstractCommand.mapToInput({
+        directory: rawOptions.directory,
+        config: rawOptions.config,
+        clientDirectory: rawOptions.clientOutDir,
+        serverDirectory: rawOptions.serverOutDir,
+        watch: rawOptions.watch
+      });
+      await this.action.run(/* @__PURE__ */ new Map(), options);
     });
   }
 };
@@ -1659,13 +1647,13 @@ var DevCommand = class extends AbstractCommand {
     __name(this, "DevCommand");
   }
   load(program) {
-    program.command("dev").description("run your game in dev mode").option("-d, --directory [directory]", "specify the directory of your project").option("--generate", "generate app from config", false).action(async (rawOptions) => {
-      const options = /* @__PURE__ */ new Map();
-      options.set("directory", { value: rawOptions.directory });
-      options.set("config", { value: rawOptions.config });
-      options.set("generate", { value: rawOptions.generate });
-      const args = /* @__PURE__ */ new Map();
-      await this.action.handle(args, options);
+    program.command("dev").description("run your game in dev mode").option("-d, --directory [directory]", "specify the directory of your project").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("--generate", "generate app from config", false).action(async (rawOptions) => {
+      const options = AbstractCommand.mapToInput({
+        directory: rawOptions.directory,
+        config: rawOptions.config,
+        generate: rawOptions.generate
+      });
+      await this.action.run(/* @__PURE__ */ new Map(), options);
     });
   }
 };
@@ -1676,13 +1664,13 @@ var GenerateCommand = class extends AbstractCommand {
     __name(this, "GenerateCommand");
   }
   load(program) {
-    program.command("generate").description("generate nanoforge files from config").option("-d, --directory [directory]", "specify the directory of your project").option("-c, --config [config]", "path to the config file", "nanoforge.config.json").option("--watch", "generate app in watching mode", false).action(async (rawOptions) => {
-      const options = /* @__PURE__ */ new Map();
-      options.set("directory", { value: rawOptions.directory });
-      options.set("config", { value: rawOptions.config });
-      options.set("watch", { value: rawOptions.watch });
-      const args = /* @__PURE__ */ new Map();
-      await this.action.handle(args, options);
+    program.command("generate").description("generate nanoforge files from config").option("-d, --directory [directory]", "specify the directory of your project").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("--watch", "generate app in watching mode", false).action(async (rawOptions) => {
+      const options = AbstractCommand.mapToInput({
+        directory: rawOptions.directory,
+        config: rawOptions.config,
+        watch: rawOptions.watch
+      });
+      await this.action.run(/* @__PURE__ */ new Map(), options);
     });
   }
 };
@@ -1694,11 +1682,13 @@ var InstallCommand = class extends AbstractCommand {
   }
   load(program) {
     program.command("install [names...]").alias("add").description("add NanoForge library to your project").option("-d, --directory [directory]", "specify the directory of your project").action(async (names, rawOptions) => {
-      const options = /* @__PURE__ */ new Map();
-      options.set("directory", { value: rawOptions.directory });
-      const args = /* @__PURE__ */ new Map();
-      args.set("names", { value: names.length ? names : void 0 });
-      await this.action.handle(args, options);
+      const options = AbstractCommand.mapToInput({
+        directory: rawOptions.directory
+      });
+      const args = AbstractCommand.mapToInput({
+        names: names.length ? names : void 0
+      });
+      await this.action.run(args, options);
     });
   }
 };
@@ -1709,19 +1699,20 @@ var NewCommand = class extends AbstractCommand {
     __name(this, "NewCommand");
   }
   load(program) {
-    program.command("new").description("create a new nanoforge project").option("-d, --directory [directory]", "specify the directory of your project").option("--name [name]", "specify the name of your project").option("--path [path]", "specify the path of your project").option("--package-manager [packageManager]", "specify the package manager of your project").option("--language [language]", "specify the language of your project").option("--strict", "use strict mode").option("--no-strict", "do not use strict mode").option("--server", "create a server").option("--no-server", "do not create a server").option("--init-functions", "initialize functions").option("--no-init-functions", "do not initialize functions").option("--skip-install", "skip installing dependencies").option("--no-skip-install", "do not skip installing dependencies").action(async (rawOptions) => {
-      const options = /* @__PURE__ */ new Map();
-      options.set("directory", { value: rawOptions.directory });
-      options.set("name", { value: rawOptions.name });
-      options.set("path", { value: rawOptions.path });
-      options.set("packageManager", { value: rawOptions.packageManager });
-      options.set("language", { value: rawOptions.language });
-      options.set("strict", { value: rawOptions.strict });
-      options.set("server", { value: rawOptions.server });
-      options.set("initFunctions", { value: rawOptions.initFunctions });
-      options.set("skipInstall", { value: rawOptions.skipInstall });
-      const args = /* @__PURE__ */ new Map();
-      await this.action.handle(args, options);
+    program.command("new").description("create a new nanoforge project").option("-d, --directory [directory]", "specify the directory of your project").option("--name [name]", "specify the name of your project").option("--path [path]", "specify the path of your project").option("--package-manager [packageManager]", "specify the package manager of your project").option("--language [language]", "specify the language of your project").option("--strict", "use strict mode").option("--no-strict", "do not use strict mode").option("--server", "create a server").option("--no-server", "do not create a server").option("--init-functions", "initialize functions").option("--no-init-functions", "do not initialize functions").option("--skip-install", "skip installing dependencies").option("--no-skip-install", "do not skip installing dependencies").option("--docker", "generate docker files").option("--no-docker", "do not generate docker files").action(async (rawOptions) => {
+      const options = AbstractCommand.mapToInput({
+        directory: rawOptions.directory,
+        name: rawOptions.name,
+        path: rawOptions.path,
+        packageManager: rawOptions.packageManager,
+        language: rawOptions.language,
+        strict: rawOptions.strict,
+        server: rawOptions.server,
+        initFunctions: rawOptions.initFunctions,
+        skipInstall: rawOptions.skipInstall,
+        docker: rawOptions.docker
+      });
+      await this.action.run(/* @__PURE__ */ new Map(), options);
     });
   }
 };
@@ -1732,21 +1723,21 @@ var StartCommand = class extends AbstractCommand {
     __name(this, "StartCommand");
   }
   load(program) {
-    program.command("start").description("start your game").option("-d, --directory [directory]", "specify the directory of your project").option("-c, --config [config]", "path to the config file", "nanoforge.config.json").option(
+    program.command("start").description("start your game").option("-d, --directory [directory]", "specify the directory of your project").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option(
       "-p, --client-port [clientPort]",
       "specify the port of the loader (the website to load the game)"
-    ).option("--game-exposure-port [gameExposurePort]", "specify the port of the game exposure").option("--server-port [serverPort]", "specify the port of the server").option("--watch", "run app in watching mode", false).action(async (rawOptions) => {
-      const options = /* @__PURE__ */ new Map();
-      options.set("directory", { value: rawOptions.directory });
-      options.set("config", { value: rawOptions.config });
-      options.set("clientPort", { value: rawOptions.clientPort });
-      options.set("gameExposurePort", {
-        value: rawOptions.gameExposurePort
+    ).option("--game-exposure-port [gameExposurePort]", "specify the port of the game exposure").option("--server-port [serverPort]", "specify the port of the server").option("--watch", "run app in watching mode", false).option("--cert [cert]", "path to the SSL certificate for HTTPS").option("--key [key]", "path to the SSL key for HTTPS").action(async (rawOptions) => {
+      const options = AbstractCommand.mapToInput({
+        directory: rawOptions.directory,
+        config: rawOptions.config,
+        clientPort: rawOptions.clientPort,
+        gameExposurePort: rawOptions.gameExposurePort,
+        serverPort: rawOptions.serverPort,
+        watch: rawOptions.watch,
+        cert: rawOptions.cert,
+        key: rawOptions.key
       });
-      options.set("serverPort", { value: rawOptions.serverPort });
-      options.set("watch", { value: rawOptions.watch });
-      const args = /* @__PURE__ */ new Map();
-      await this.action.handle(args, options);
+      await this.action.run(/* @__PURE__ */ new Map(), options);
     });
   }
 };
@@ -1768,8 +1759,8 @@ var CommandLoader = class {
   static handleInvalidCommand(program) {
     program.on("command:*", () => {
       console.error(`
-${Prefixes.ERROR} Invalid command: ${red8`%s`}`, program.args.join(" "));
-      console.log(`See ${red8`--help`} for a list of available commands.
+${Prefixes.ERROR} Invalid command: ${red6`%s`}`, program.args.join(" "));
+      console.log(`See ${red6`--help`} for a list of available commands.
 `);
       process.exit(1);
     });