@nanoforge-dev/cli 1.1.1 → 1.3.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,83 @@ 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?",
+  INSTALL_PACKAGES_IN_PROGRESS: "Install Nanoforge Packages",
+  // --- Login ---
+  LOGIN_START: "NanoForge Login",
+  LOGIN_SUCCESS: success("Login completed!"),
+  LOGIN_FAILED: failure("Login failed!"),
+  LOGIN_API_KEY_QUESTION: "What is your registry api key?",
+  // --- Logout ---
+  LOGOUT_START: "NanoForge Logout",
+  LOGOUT_SUCCESS: success("Logout completed!"),
+  LOGOUT_FAILED: failure("Logout failed!"),
+  // --- 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"),
+  // --- Publish ---
+  PUBLISH_START: "NanoForge Publish",
+  PUBLISH_SUCCESS: success("Publish completed!"),
+  PUBLISH_FAILED: failure("Publish failed!"),
+  PUBLISH_IN_PROGRESS: /* @__PURE__ */ __name((name) => `Publishing ${name}...`, "PUBLISH_IN_PROGRESS"),
+  // --- Unpublish ---
+  UNPUBLISH_START: "NanoForge Unpublish",
+  UNPUBLISH_SUCCESS: success("Unpublish completed!"),
+  UNPUBLISH_FAILED: failure("Unpublish failed!"),
+  UNPUBLISH_IN_PROGRESS: /* @__PURE__ */ __name((name) => `Unpublishing ${name}...`, "UNPUBLISH_IN_PROGRESS"),
+  // --- 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,10 +127,12 @@ 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 join3 } from "path";
 
 // src/lib/input/base-inputs.ts
@@ -155,16 +192,40 @@ var getDevGenerateInput = /* @__PURE__ */ __name((inputs) => {
   return getBooleanInputWithDefault(inputs, "generate", false);
 }, "getDevGenerateInput");
 
+// src/lib/input/inputs/install/lib.input.ts
+function getInstallLibInput(inputs) {
+  return getBooleanInputWithDefault(inputs, "lib", false);
+}
+__name(getInstallLibInput, "getInstallLibInput");
+
 // src/lib/question/questions/confirm.question.ts
 import { confirm } from "@inquirer/prompts";
 
 // src/lib/utils/errors.ts
+import { red } from "ansis";
+var getErrorMessage = /* @__PURE__ */ __name((error) => {
+  if (error instanceof Error) return getErrorString(error);
+  if (typeof error === "string") return error;
+  return void 0;
+}, "getErrorMessage");
+var getErrorString = /* @__PURE__ */ __name((error) => {
+  const stack = error.stack ? error.stack : error.message;
+  const cause = error.cause && typeof error.cause === "object" ? JSON.stringify(error.cause, null, 2) : error.cause;
+  return `${stack}${cause ? `
+${cause}` : ""}`;
+}, "getErrorString");
+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,79 +297,155 @@ var getInstallNamesInputOrAsk = /* @__PURE__ */ __name((inputs) => {
   );
 }, "getInstallNamesInputOrAsk");
 
-// src/lib/package-manager/package-manager.factory.ts
-import fs2 from "fs";
-import { resolve as resolve2 } from "path";
+// src/lib/input/inputs/install/server.input.ts
+function getInstallServerInput(inputs) {
+  return getBooleanInputWithDefault(inputs, "server", false);
+}
+__name(getInstallServerInput, "getInstallServerInput");
 
-// src/lib/runner/runner.factory.ts
-import { yellow } from "ansis";
+// src/lib/input/inputs/login-out/api-key.input.ts
+var getApiKeyInput = /* @__PURE__ */ __name((inputs) => {
+  return getStringInput(inputs, "apiKey");
+}, "getApiKeyInput");
+var getLoginApiKeyInputOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getApiKeyInput(inputs),
+    () => askInput(Messages.LOGIN_API_KEY_QUESTION, {
+      required: true
+    })
+  );
+}, "getLoginApiKeyInputOrAsk");
 
-// 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;
-  }
-  static {
-    __name(this, "AbstractRunner");
-  }
-  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/input/inputs/login-out/local.input.ts
+function getLocalInput(inputs) {
+  return getBooleanInputWithDefault(inputs, "local", false);
+}
+__name(getLocalInput, "getLocalInput");
 
-// src/lib/runner/runners/bun.runner.ts
-var BunRunner = class extends AbstractRunner {
-  static {
-    __name(this, "BunRunner");
+// src/lib/input/inputs/new/docker.input.ts
+var getNewDockerInput = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInput(inputs, "docker");
+}, "getNewDockerInput");
+var getNewDockerOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getNewDockerInput(inputs),
+    () => askConfirm(Messages.NEW_DOCKER_QUESTION, { default: true })
+  );
+}, "getNewDockerOrAsk");
+
+// src/lib/input/inputs/new/init-functions.input.ts
+var getNewInitFunctionsWithDefault = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInputWithDefault(inputs, "initFunctions", false);
+}, "getNewInitFunctionsWithDefault");
+
+// src/lib/input/inputs/new/language.input.ts
+var getLanguageInput = /* @__PURE__ */ __name((inputs) => {
+  return getStringInput(inputs, "language");
+}, "getLanguageInput");
+var getNewLanguageInputOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getLanguageInput(inputs),
+    () => askSelect(Messages.NEW_LANGUAGE_QUESTION, [{ value: "ts" }, { value: "js" }], {
+      default: "ts"
+    })
+  );
+}, "getNewLanguageInputOrAsk");
+
+// src/lib/input/inputs/new/lint.input.ts
+var getNewLintInput = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInputWithDefault(inputs, "lint", true);
+}, "getNewLintInput");
+
+// src/lib/input/inputs/new/name.input.ts
+var getNameInput = /* @__PURE__ */ __name((inputs) => {
+  return getStringInput(inputs, "name");
+}, "getNameInput");
+var getNewNameInputOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getNameInput(inputs),
+    () => askInput(Messages.NEW_NAME_QUESTION, {
+      required: true,
+      default: "nanoforge-app"
+    })
+  );
+}, "getNewNameInputOrAsk");
+
+// src/lib/input/inputs/new/package-manager.input.ts
+var getPackageManagerInput = /* @__PURE__ */ __name((inputs) => {
+  return getStringInput(inputs, "packageManager");
+}, "getPackageManagerInput");
+var getNewPackageManagerInputOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getPackageManagerInput(inputs),
+    () => askSelect(
+      Messages.NEW_PACKAGE_MANAGER_QUESTION,
+      [{ value: "npm" }, { value: "yarn" }, { value: "pnpm" }, { value: "bun" }],
+      {
+        default: "npm"
+      }
+    )
+  );
+}, "getNewPackageManagerInputOrAsk");
+
+// src/lib/input/inputs/new/path.input.ts
+var getNewPathInput = /* @__PURE__ */ __name((inputs) => {
+  return getStringInput(inputs, "path");
+}, "getNewPathInput");
+
+// src/lib/input/inputs/new/server.input.ts
+var getNewServerInput = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInput(inputs, "server");
+}, "getNewServerInput");
+var getNewServerOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getNewServerInput(inputs),
+    () => askConfirm(Messages.NEW_SERVER_QUESTION, { default: false })
+  );
+}, "getNewServerOrAsk");
+
+// src/lib/input/inputs/new/skip-install.input.ts
+var getNewSkipInstallInput = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInput(inputs, "skipInstall");
+}, "getNewSkipInstallInput");
+var getNewSkipInstallOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getNewSkipInstallInput(inputs),
+    () => askConfirm(Messages.NEW_SKIP_INSTALL_QUESTION, { default: false })
+  );
+}, "getNewSkipInstallOrAsk");
+
+// src/lib/input/inputs/new/strict.input.ts
+var getNewStrictInput = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInput(inputs, "strict");
+}, "getNewStrictInput");
+var getNewStrictOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getNewStrictInput(inputs),
+    () => askConfirm(Messages.NEW_STRICT_QUESTION, { default: true })
+  );
+}, "getNewStrictOrAsk");
+
+// src/lib/package-manager/package-manager.ts
+import { bold, red as red3 } from "ansis";
+
+// 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}`);
   }
-  constructor() {
-    super("bun");
+}, "createStdoutLogger");
+var createStderrLogger = /* @__PURE__ */ __name((name) => (chunk) => {
+  const prefix = red2(`(${name}) ERROR -`);
+  for (const line of formatLines(chunk)) {
+    console.error(`${timestamp()} ${prefix} ${line}`);
   }
-};
+}, "createStderrLogger");
 
 // src/lib/utils/path.ts
 import fs from "fs";
@@ -335,268 +472,262 @@ var resolveCLINodeBinaryPath = /* @__PURE__ */ __name((name) => {
   throw new Error("Could not find module path");
 }, "resolveCLINodeBinaryPath");
 
-// src/lib/runner/runners/local-bun.runner.ts
-var LocalBunRunner = class extends AbstractRunner {
-  static {
-    __name(this, "LocalBunRunner");
-  }
-  constructor() {
-    super(resolveCLINodeBinaryPath("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() {
-    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}`);
-    }
-  }
-};
-
-// 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/utils/spinner.ts
+var withSpinner = /* @__PURE__ */ __name(async (message, task, onError) => {
+  const spinner = getSpinner(message);
+  spinner.start();
+  try {
+    const value = await task(spinner);
+    spinner.succeed();
+    return { success: true, value };
+  } catch (error) {
+    spinner.fail();
+    if (onError) onError();
+    return { success: false, error };
+  }
+}, "withSpinner");
+
+// 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 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 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, params, 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, params, 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.exec, command, ...flags];
-      await this.runner.run(commandArgs, collect, getCwd(directory), env2);
+      const base = [this.commands.exec, command];
+      if (this.commands.runArgsFlag) base.push(this.commands.runArgsFlag);
+      await this.exec([...base, ...flags], directory, { collect, env: env2 });
       return true;
     } catch {
       return false;
     }
   }
-  async add(args, directory, dependencies) {
+  async addDependencies(saveFlag, directory, dependencies) {
     if (!dependencies.length) {
-      console.info();
-      console.info(Messages.PACKAGE_MANAGER_INSTALLATION_NOTHING);
-      console.info();
+      this.logEmpty(Messages.PACKAGE_MANAGER_INSTALLATION_NOTHING);
       return true;
     }
-    const commandArguments = [...args, ...dependencies];
-    const spinner = SPINNER(Messages.PACKAGE_MANAGER_INSTALLATION_IN_PROGRESS);
-    spinner.start();
-    try {
-      const collect = true;
-      await this.runner.run(
-        commandArguments,
-        collect,
-        getCwd(directory),
-        void 0,
-        void 0,
-        FAIL_SPINNER(spinner)
-      );
-      spinner.succeed();
-      this.printInstallSuccess(dependencies);
-      return true;
-    } catch {
-      spinner.fail();
-      const commandToRun = this.runner.rawFullCommand(commandArguments);
-      this.printInstallFailure(commandToRun);
-      return false;
+    const args = [this.commands.add, saveFlag, ...dependencies];
+    const result = await 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}"`);
     }
   }
-  printInstallSuccess(dependencies) {
+  buildRunArgs(script, params, flags, silent) {
+    const args = [...flags, this.commands.run];
+    if (silent) args.push(this.commands.silentFlag);
+    args.push(script);
+    if (params.length === 0) return args;
+    if (this.commands.runArgsFlag) args.push(this.commands.runArgsFlag);
+    return args.concat(params);
+  }
+  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))));
   }
-  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}`);
+  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();
+  }
+};
+
+// 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, "Runner");
+  }
+  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((resolve4, reject) => {
+      const child = spawn(`${this.binary} ${fullArgs.join(" ")}`, spawnOpts);
+      const output = this.attachOutputHandlers(child, listeners);
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve4(this.formatOutput(output, collect));
+        } else {
+          this.handleFailure(output, fullArgs, onFail);
+          reject(this.createError(fullArgs, code));
+        }
+      });
     });
-  }, "onRunStderr");
+  }
+  fullCommand(args) {
+    return [this.binary, ...this.baseArgs, ...args].join(" ");
+  }
+  buildSpawnOptions(collect, cwd2, env2) {
+    return {
+      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/bun.package-manager.ts
-var BunPackageManager = class extends AbstractPackageManager {
+// src/lib/runner/runner.factory.ts
+var RunnerFactory = class {
   static {
-    __name(this, "BunPackageManager");
+    __name(this, "RunnerFactory");
   }
-  constructor() {
-    super(RunnerFactory.create(0 /* BUN */));
+  static create(binary, args) {
+    return new Runner(binary, args);
   }
-  get name() {
-    return "bun" /* 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",
@@ -606,23 +737,11 @@ var BunPackageManager = class extends AbstractPackageManager {
       saveFlag: "--save",
       saveDevFlag: "--dev",
       silentFlag: "--silent"
-    };
-  }
-};
-
-// src/lib/package-manager/package-managers/local-bun.package-manager.ts
-var LocalBunPackageManager = class extends AbstractPackageManager {
-  static {
-    __name(this, "LocalBunPackageManager");
-  }
-  constructor() {
-    super(RunnerFactory.create(1 /* LOCAL_BUN */));
-  }
-  get name() {
-    return "local_bun" /* LOCAL_BUN */.toUpperCase();
-  }
-  get cli() {
-    return {
+    }
+  },
+  ["local_bun" /* LOCAL_BUN */]: {
+    binary: "bun",
+    commands: {
       install: "install",
       add: "add",
       update: "update",
@@ -634,49 +753,26 @@ var LocalBunPackageManager = class extends AbstractPackageManager {
       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",
+      runArgsFlag: "--",
       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",
@@ -686,23 +782,11 @@ var PnpmPackageManager = class extends AbstractPackageManager {
       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",
@@ -712,54 +796,63 @@ var YarnPackageManager = class extends AbstractPackageManager {
       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 fs2.promises.readdir(resolve2(directory));
-      if (files.includes("bun.lock")) {
-        return this.create("bun" /* BUN */);
+      for (const [lockFile, pmName] of Object.entries(LOCK_FILE_MAP)) {
+        if (files.includes(lockFile)) return pmName;
       }
-      if (files.includes("package-lock.json")) {
-        return this.create("npm" /* NPM */);
-      }
-      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";
@@ -796,7 +889,6 @@ var ClientConfig = class {
     __name(this, "ClientConfig");
   }
   port;
-  gameExposurePort;
   build;
   runtime;
 };
@@ -804,10 +896,6 @@ __decorateClass([
   Expose(),
   IsPort()
 ], ClientConfig.prototype, "port", 2);
-__decorateClass([
-  Expose(),
-  IsPort()
-], ClientConfig.prototype, "gameExposurePort", 2);
 __decorateClass([
   Expose(),
   Type(() => BuildConfig),
@@ -823,7 +911,6 @@ var ServerConfig = class {
     __name(this, "ServerConfig");
   }
   enable;
-  port;
   build;
   runtime;
 };
@@ -831,10 +918,6 @@ __decorateClass([
   Expose(),
   IsBoolean()
 ], ServerConfig.prototype, "enable", 2);
-__decorateClass([
-  Expose(),
-  IsPort()
-], ServerConfig.prototype, "port", 2);
 __decorateClass([
   Expose(),
   Type(() => BuildConfig),
@@ -885,6 +968,13 @@ import { validate } from "class-validator";
 import { existsSync, readFileSync } from "fs";
 import { join as join2 } from "path";
 
+// src/lib/constants.ts
+var CONFIG_FILE_NAME = "nanoforge.config.json";
+var MANIFEST_FILE_NAME = "nanoforge.manifest.json";
+var GLOBAL_CONFIG_FILE_NAME = ".nanoforgerc";
+var NANOFORGE_DIR = ".nanoforge";
+var REGISTRY_URL = "https://api.nanoforge.dev";
+
 // src/lib/utils/object.ts
 var isObject = /* @__PURE__ */ __name((item) => {
   return item && typeof item === "object" && !Array.isArray(item);
@@ -904,6 +994,7 @@ var deepMerge = /* @__PURE__ */ __name((target, ...sources) => {
   }
   return deepMerge(target, ...sources);
 }, "deepMerge");
+var isEmpty = /* @__PURE__ */ __name((target) => Object.keys(target).length === 0, "isEmpty");
 
 // src/lib/config/config-defaults.ts
 var CONFIG_DEFAULTS = {
@@ -912,7 +1003,6 @@ var CONFIG_DEFAULTS = {
   initFunctions: true,
   client: {
     port: "3000",
-    gameExposurePort: "3001",
     build: {
       entryFile: "client/main.ts",
       outDir: ".nanoforge/client"
@@ -923,7 +1013,6 @@ var CONFIG_DEFAULTS = {
   },
   server: {
     enable: false,
-    port: "3002",
     build: {
       entryFile: "server/main.ts",
       outDir: ".nanoforge/server"
@@ -940,18 +1029,17 @@ var getConfigPath = /* @__PURE__ */ __name((directory, name) => {
   if (name) {
     return join2(directory, name);
   } else {
-    for (const n of ["nanoforge.config.json"]) {
+    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 {
@@ -979,6 +1067,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) {
+      handleActionError(this.failureMessage, result.error);
+      process.exit(1);
+    }
+    if (this.successMessage) console.info(this.successMessage);
+    process.exit(0);
+  }
 };
 
 // src/action/actions/build.action.ts
@@ -986,121 +1100,121 @@ 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);
-        process.exit(1);
-      }
-      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(join3(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 join4 } from "path";
 
 // src/lib/schematics/abstract.collection.ts
@@ -1113,25 +1227,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());
   }
 };
 
@@ -1160,6 +1268,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) {
@@ -1191,12 +1304,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}`);
   }
 };
 
@@ -1254,19 +1366,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,
@@ -1276,16 +1379,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");
 
@@ -1294,370 +1398,816 @@ 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 ? join4(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
-      },
-      join4(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 {
+import { join as join6 } from "path";
+
+// src/lib/global-config/global-config-handler.ts
+import { read, readUser, write, writeUser } from "rc9";
+
+// src/lib/global-config/global-config-defaults.ts
+var GLOBAL_CONFIG_DEFAULTS = {};
+
+// src/lib/global-config/global-config-handler.ts
+var GlobalConfigHandler = class {
   static {
-    __name(this, "InstallAction");
+    __name(this, "GlobalConfigHandler");
   }
-  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);
-    }
+  static read(dir) {
+    const localConfig = this._readConfig(read, false, dir);
+    if (localConfig) return localConfig;
+    return this._readConfig(readUser, true);
   }
-};
-var installPackages = /* @__PURE__ */ __name(async (names, directory) => {
-  try {
-    const packageManager = await PackageManagerFactory.find(directory);
-    const res = await packageManager.addProduction(directory, names);
-    if (!res) process3.exit(1);
-  } catch (error4) {
-    if (error4 && error4.message) {
-      console.error(ansis3.red(error4.message));
+  static write(config2, local = false, dir) {
+    const options = {
+      name: GLOBAL_CONFIG_FILE_NAME,
+      dir
+    };
+    if (local) write(config2, options);
+    else writeUser(config2, options);
+  }
+  static _readConfig(func, force, dir) {
+    const res = func({
+      name: GLOBAL_CONFIG_FILE_NAME,
+      dir
+    });
+    if (!force) {
+      if (isEmpty(res)) return null;
     }
-    process3.exit(1);
+    return deepMerge(GLOBAL_CONFIG_DEFAULTS, res);
   }
-}, "installPackages");
-
-// src/action/actions/new.action.ts
-import * as ansis4 from "ansis";
-import console4 from "console";
-import * as process4 from "process";
+};
 
-// src/lib/input/inputs/new/init-functions.input.ts
-var getNewInitFunctionsWithDefault = /* @__PURE__ */ __name((inputs) => {
-  return getBooleanInputWithDefault(inputs, "initFunctions", false);
-}, "getNewInitFunctionsWithDefault");
+// src/lib/http/http-client.ts
+var HttpClient = class {
+  static {
+    __name(this, "HttpClient");
+  }
+  _baseUrl;
+  _baseOptions;
+  _middlewares;
+  constructor(baseUrl, options) {
+    this._baseUrl = baseUrl;
+    this._baseOptions = options ?? {
+      headers: {
+        "Content-Type": "application/json"
+      }
+    };
+    this._middlewares = [];
+  }
+  get(path, options) {
+    return this._applyMiddlewares(path, options, (newPath, newOptions) => {
+      return this._request(newPath, {
+        ...newOptions,
+        method: "GET"
+      });
+    });
+  }
+  post(path, body, options) {
+    return this._applyMiddlewares(path, options, (newPath, newOptions) => {
+      return this._request(newPath, {
+        ...newOptions,
+        method: "POST",
+        body
+      });
+    });
+  }
+  put(path, body, options) {
+    return this._applyMiddlewares(path, options, (newPath, newOptions) => {
+      return this._request(newPath, {
+        ...newOptions,
+        method: "PUT",
+        body
+      });
+    });
+  }
+  patch(path, body, options) {
+    return this._applyMiddlewares(path, options, async (newPath, newOptions) => {
+      return this._request(newPath, {
+        ...newOptions,
+        method: "PATCH",
+        body
+      });
+    });
+  }
+  delete(path, options) {
+    return this._applyMiddlewares(path, options, (newPath, newOptions) => {
+      return this._request(newPath, {
+        ...newOptions,
+        method: "DELETE",
+        body: "{}"
+      });
+    });
+  }
+  useMiddlewares(...middlewares) {
+    for (const middleware of middlewares) this._middlewares.push(middleware);
+    return this;
+  }
+  async _request(path, request) {
+    const res = await fetch(path, request);
+    res.content = null;
+    return res;
+  }
+  _applyMiddlewares(path, options, callback) {
+    const baseParams = {
+      path,
+      fullPath: this._getUrl(path),
+      options: {
+        ...this._baseOptions,
+        ...options,
+        headers: {
+          ...this._baseOptions.headers,
+          ...options?.headers
+        }
+      }
+    };
+    const middlewares = this._middlewares.slice();
+    let response;
+    const execution = /* @__PURE__ */ __name(async (params) => {
+      if (!params) params = baseParams;
+      const middleware = middlewares.shift();
+      if (!middleware) response = await callback(params.fullPath, params.options);
+      else response = await middleware(params, execution) ?? response;
+      return response;
+    }, "execution");
+    return execution(baseParams);
+  }
+  _getUrl(path) {
+    return `${this._baseUrl}${path}`;
+  }
+};
 
-// src/lib/input/inputs/new/language.input.ts
-var getLanguageInput = /* @__PURE__ */ __name((inputs) => {
-  return getStringInput(inputs, "language");
-}, "getLanguageInput");
-var getNewLanguageInputOrAsk = /* @__PURE__ */ __name((inputs) => {
-  return getInputOrAsk(
-    getLanguageInput(inputs),
-    () => askSelect(Messages.NEW_LANGUAGE_QUESTION, [{ value: "ts" }, { value: "js" }], {
-      default: "ts"
-    })
-  );
-}, "getNewLanguageInputOrAsk");
+// src/lib/http/repository.ts
+var Repository = class {
+  static {
+    __name(this, "Repository");
+  }
+  _client;
+  constructor(client2) {
+    this._client = client2;
+  }
+  get(path, options) {
+    return this.runRequest("get", path, options);
+  }
+  getFile(path, options) {
+    return this.runFileRequest("get", path, options);
+  }
+  post(path, body, options) {
+    return this.runRequestBody("post", path, body ?? {}, options);
+  }
+  put(path, body, options) {
+    return this.runRequestBody("put", path, body ?? {}, options);
+  }
+  patch(path, body, options) {
+    return this.runRequestBody("patch", path, body ?? {}, options);
+  }
+  delete(path, options) {
+    return this.runRequest("delete", path, options);
+  }
+  async runRequest(request, path, options) {
+    const res = await this._client[request](path, options);
+    const data = await res.json();
+    if (!res.ok)
+      throw new Error(`Request failed with status code ${res.status}`, {
+        cause: data["error"]
+      });
+    return data;
+  }
+  async runFileRequest(request, path, options) {
+    const res = await this._client[request](path, options);
+    if (!res.ok)
+      throw new Error(`Request failed with status code ${res.status}`, {
+        cause: (await res.json())["error"]
+      });
+    return await res.blob();
+  }
+  async runRequestBody(request, path, body, options) {
+    const res = await this._client[request](
+      path,
+      body === void 0 ? void 0 : body instanceof FormData ? body : JSON.stringify(body),
+      options
+    );
+    const data = await res.json();
+    if (!res.ok)
+      throw new Error(`Request failed with status code ${res.status}`, {
+        cause: data["error"]
+      });
+    return data;
+  }
+};
 
-// src/lib/input/inputs/new/name.input.ts
-var getNameInput = /* @__PURE__ */ __name((inputs) => {
-  return getStringInput(inputs, "name");
-}, "getNameInput");
-var getNewNameInputOrAsk = /* @__PURE__ */ __name((inputs) => {
-  return getInputOrAsk(
-    getNameInput(inputs),
-    () => askInput(Messages.NEW_NAME_QUESTION, {
-      required: true,
-      default: "nanoforge-app"
+// src/lib/http/client.ts
+var client = new HttpClient(REGISTRY_URL ?? "");
+var api = new Repository(client);
+var withAuth = /* @__PURE__ */ __name((apiKey, force = false, headers = {
+  "Content-Type": "application/json"
+}) => {
+  if (!apiKey && force) {
+    console.error("No registry key found. Please use `nf login` to login");
+    throw new Error("No apikey found. Please use `nf login` to login");
+  }
+  return new Repository(
+    new HttpClient(REGISTRY_URL ?? "", {
+      headers: {
+        Authorization: apiKey,
+        ...headers
+      }
     })
   );
-}, "getNewNameInputOrAsk");
-
-// src/lib/input/inputs/new/package-manager.input.ts
-var getPackageManagerInput = /* @__PURE__ */ __name((inputs) => {
-  return getStringInput(inputs, "packageManager");
-}, "getPackageManagerInput");
-var getNewPackageManagerInputOrAsk = /* @__PURE__ */ __name((inputs) => {
-  return getInputOrAsk(
-    getPackageManagerInput(inputs),
-    () => askSelect(
-      Messages.NEW_PACKAGE_MANAGER_QUESTION,
-      [{ value: "npm" }, { value: "yarn" }, { value: "pnpm" }, { value: "bun" }],
-      {
-        default: "npm"
-      }
-    )
+}, "withAuth");
+
+// src/lib/manifest/manifest-resolver.ts
+var resolveManifestDependencies = /* @__PURE__ */ __name(async (names, dir) => {
+  const client2 = withAuth(GlobalConfigHandler.read(dir).apiKey, false);
+  return concatDeps(await Promise.all(names.map(async (d) => resolveDeps(d, client2))));
+}, "resolveManifestDependencies");
+var resolveManifest = /* @__PURE__ */ __name(async (name, client2) => {
+  return await client2.get(`/registry/${name}`);
+}, "resolveManifest");
+var resolveDeps = /* @__PURE__ */ __name(async (name, client2) => {
+  const manifest = await resolveManifest(name, client2);
+  const baseDeps = manifest.dependencies ?? [];
+  const deps = await Promise.all(baseDeps.map(async (d) => resolveDeps(d, client2)));
+  return concatDeps(
+    [{ nf: { [manifest.name]: manifest }, npm: getNpmDeps(manifest) }].concat(deps)
   );
-}, "getNewPackageManagerInputOrAsk");
+}, "resolveDeps");
+var getNpmDeps = /* @__PURE__ */ __name((manifest) => {
+  return Object.entries(manifest.npmDependencies ?? {});
+}, "getNpmDeps");
+var concatDeps = /* @__PURE__ */ __name((deps) => {
+  return {
+    npm: deps.map(({ npm }) => npm).flat(),
+    nf: Object.fromEntries(deps.map(({ nf }) => Object.entries(nf)).flat())
+  };
+}, "concatDeps");
 
-// src/lib/input/inputs/new/path.input.ts
-var getNewPathInput = /* @__PURE__ */ __name((inputs) => {
-  return getStringInput(inputs, "path");
-}, "getNewPathInput");
+// src/lib/registry/registry.ts
+import fs3 from "fs";
+import { join as join5 } from "path";
+var Registry = class {
+  static {
+    __name(this, "Registry");
+  }
+  static async publish(manifest, dir) {
+    const client2 = this._getClient(dir, true, false);
+    const filename = manifest.publish?.paths?.package ?? "index.ts";
+    const file = await this._getPackageFile(filename, dir);
+    const data = new FormData();
+    for (const key of Object.keys(manifest)) {
+      const value = manifest[key];
+      if (!value) continue;
+      data.append(key, typeof value === "string" ? value : JSON.stringify(value));
+    }
+    data.append("_packageFile", file, filename);
+    await client2.put(`/registry/${manifest.name}`, data);
+  }
+  static async unpublish(manifest, dir) {
+    const client2 = this._getClient(dir, true);
+    await client2.delete(`/registry/${manifest.name}`);
+  }
+  static async install(manifests, dir) {
+    const cwd2 = getCwd(dir);
+    const client2 = this._getClient(dir, false);
+    for (const manifest of manifests) {
+      await this.installPackage(client2, manifest, cwd2);
+    }
+  }
+  static async installPackage(client2, manifest, dir) {
+    const file = await client2.getFile(`/registry/${manifest.name}/-/${manifest._file}`);
+    const path = join5(dir, this.getTypeSubFolder(manifest.type));
+    fs3.mkdirSync(path, { recursive: true });
+    fs3.writeFileSync(join5(path, manifest._file), await file.bytes());
+  }
+  static getTypeSubFolder(type) {
+    if (type === "component") return "components";
+    if (type === "system") return "systems";
+    return ".";
+  }
+  static _getClient(dir, force, headers = true) {
+    const config2 = GlobalConfigHandler.read(dir);
+    return withAuth(config2.apiKey, force, !headers ? {} : void 0);
+  }
+  static _getPackageFile(filename, dir) {
+    const path = join5(getCwd(dir ?? "."), filename);
+    if (!fs3.existsSync(path))
+      throw new Error(
+        "Package not found, please specify path in the nanoforge.manifest.json : `publish.paths.components`!"
+      );
+    try {
+      fs3.accessSync(path, fs3.constants.R_OK);
+      return fs3.openAsBlob(path);
+    } catch {
+      throw new Error("Cannot read package file, please verify your file permissions!");
+    }
+  }
+};
 
-// src/lib/input/inputs/new/server.input.ts
-var getNewServerInput = /* @__PURE__ */ __name((inputs) => {
-  return getBooleanInput(inputs, "server");
-}, "getNewServerInput");
-var getNewServerOrAsk = /* @__PURE__ */ __name((inputs) => {
-  return getInputOrAsk(
-    getNewServerInput(inputs),
-    () => askConfirm(Messages.NEW_SERVER_QUESTION, { default: false })
-  );
-}, "getNewServerOrAsk");
+// src/action/actions/install.action.ts
+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) {
+    const names = await getInstallNamesInputOrAsk(args);
+    const directory = getDirectoryInput(options);
+    const isLib = getInstallLibInput(options);
+    const isServer = getInstallServerInput(options);
+    return isLib ? this._installLibs(directory, names) : this._installNfPackages(directory, names, isServer);
+  }
+  async _installLibs(directory, names) {
+    const packageManager = await PackageManagerFactory.find(directory);
+    return { success: await packageManager.addDevelopment(directory, names) };
+  }
+  async _installNfPackages(directory, names, isServer) {
+    const deps = await resolveManifestDependencies(names, directory);
+    const libSuccess = await this._installLibs(
+      directory,
+      deps.npm.map(([name, version]) => `${name}@${version}`)
+    );
+    if (!libSuccess) return { success: false };
+    return withSpinner(Messages.INSTALL_PACKAGES_IN_PROGRESS, async () => {
+      await Registry.install(
+        Object.values(deps.nf),
+        join6(directory, isServer ? "server" : "client")
+      );
+    });
+  }
+};
 
-// src/lib/input/inputs/new/skip-install.input.ts
-var getNewSkipInstallInput = /* @__PURE__ */ __name((inputs) => {
-  return getBooleanInput(inputs, "skipInstall");
-}, "getNewSkipInstallInput");
-var getNewSkipInstallOrAsk = /* @__PURE__ */ __name((inputs) => {
-  return getInputOrAsk(
-    getNewSkipInstallInput(inputs),
-    () => askConfirm(Messages.NEW_SKIP_INSTALL_QUESTION, { default: false })
-  );
-}, "getNewSkipInstallOrAsk");
+// src/action/actions/login.action.ts
+var LoginAction = class extends AbstractAction {
+  static {
+    __name(this, "LoginAction");
+  }
+  startMessage = Messages.LOGIN_START;
+  successMessage = Messages.LOGIN_SUCCESS;
+  failureMessage = Messages.LOGIN_FAILED;
+  async handle(_args, options) {
+    const directory = getDirectoryInput(options);
+    const isLocal = getLocalInput(options);
+    const apiKey = await getLoginApiKeyInputOrAsk(options);
+    await withAuth(apiKey, true).post("/registry-key/verify");
+    GlobalConfigHandler.write(
+      {
+        apiKey
+      },
+      isLocal,
+      directory
+    );
+    return { success: true };
+  }
+};
 
-// src/lib/input/inputs/new/strict.input.ts
-var getNewStrictInput = /* @__PURE__ */ __name((inputs) => {
-  return getBooleanInput(inputs, "strict");
-}, "getNewStrictInput");
-var getNewStrictOrAsk = /* @__PURE__ */ __name((inputs) => {
-  return getInputOrAsk(
-    getNewStrictInput(inputs),
-    () => askConfirm(Messages.NEW_STRICT_QUESTION, { default: true })
-  );
-}, "getNewStrictOrAsk");
+// src/action/actions/logout.action.ts
+var LogoutAction = class extends AbstractAction {
+  static {
+    __name(this, "LogoutAction");
+  }
+  startMessage = Messages.LOGOUT_START;
+  successMessage = Messages.LOGOUT_SUCCESS;
+  failureMessage = Messages.LOGOUT_FAILED;
+  async handle(_args, options) {
+    const directory = getDirectoryInput(options);
+    const isLocal = getLocalInput(options);
+    GlobalConfigHandler.write(
+      {
+        apiKey: void 0
+      },
+      isLocal,
+      directory
+    );
+    return { success: true };
+  }
+};
 
 // src/action/actions/new.action.ts
+import { join as join7 } from "path";
 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);
-      process4.exit(0);
-    } catch {
-      console4.error(Messages.NEW_FAILED);
-      process4.exit(1);
+    const cwdDirectory = getDirectoryInput(options);
+    const values = await this.collectValues(options);
+    await this.scaffold(values, cwdDirectory);
+    let res = true;
+    if (!values.skipInstall) {
+      res = await this.installDependencies(
+        values.packageManager,
+        join7(cwdDirectory, values.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 getNewDockerOrAsk(inputs),
+      lint: getNewLintInput(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,
+      lint: values.lint
     });
-    await executeSchematic("Server main file", collection, "part-main", {
+  }
+  generateConfiguration(collection, values) {
+    return executeSchematic("Configuration", collection, "configuration", {
       name: values.name,
-      part: "server",
+      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
+    });
+  }
+  partOptions(values, part) {
+    return {
+      name: values.name,
+      part,
       directory: values.directory,
       language: values.language,
       initFunctions: values.initFunctions
-    });
+    };
+  }
+  async installDependencies(packageManagerName, directory) {
+    const packageManager = PackageManagerFactory.create(packageManagerName);
+    return await packageManager.install(directory);
   }
-}, "generateApplicationFiles");
-var runInstall = /* @__PURE__ */ __name(async (directory, pkgManagerName) => {
+};
+
+// src/lib/manifest/manifest.type.ts
+import { Expose as Expose2, Type as Type2 } from "class-transformer";
+import {
+  IsEnum as IsEnum2,
+  IsNotEmpty as IsNotEmpty2,
+  IsObject,
+  IsOptional,
+  IsString as IsString2,
+  Matches,
+  ValidateNested as ValidateNested2
+} from "class-validator";
+var ManifestPackageTypeEnum = /* @__PURE__ */ ((ManifestPackageTypeEnum2) => {
+  ManifestPackageTypeEnum2["COMPONENT"] = "component";
+  ManifestPackageTypeEnum2["SYSTEM"] = "system";
+  return ManifestPackageTypeEnum2;
+})(ManifestPackageTypeEnum || {});
+var PathsPublishManifest = class {
+  static {
+    __name(this, "PathsPublishManifest");
+  }
+  package;
+};
+__decorateClass([
+  Expose2(),
+  IsString2(),
+  IsNotEmpty2(),
+  IsOptional()
+], PathsPublishManifest.prototype, "package", 2);
+var PublishManifest = class {
+  static {
+    __name(this, "PublishManifest");
+  }
+  paths;
+};
+__decorateClass([
+  Expose2(),
+  IsOptional(),
+  ValidateNested2(),
+  Type2(() => PathsPublishManifest)
+], PublishManifest.prototype, "paths", 2);
+var Manifest = class {
+  static {
+    __name(this, "Manifest");
+  }
+  name;
+  type;
+  description;
+  dependencies;
+  publish;
+  npmDependencies;
+};
+__decorateClass([
+  Expose2(),
+  IsString2(),
+  Matches(/^[A-Za-z0-9-]+\/[A-Za-z0-9-]+$/),
+  IsNotEmpty2()
+], Manifest.prototype, "name", 2);
+__decorateClass([
+  Expose2(),
+  IsString2(),
+  IsEnum2(ManifestPackageTypeEnum),
+  IsNotEmpty2()
+], Manifest.prototype, "type", 2);
+__decorateClass([
+  Expose2(),
+  IsString2(),
+  IsOptional()
+], Manifest.prototype, "description", 2);
+__decorateClass([
+  Expose2(),
+  IsString2({ each: true }),
+  IsNotEmpty2({ each: true }),
+  IsOptional()
+], Manifest.prototype, "dependencies", 2);
+__decorateClass([
+  Expose2(),
+  IsOptional(),
+  ValidateNested2(),
+  Type2(() => PublishManifest)
+], Manifest.prototype, "publish", 2);
+__decorateClass([
+  Expose2(),
+  IsObject(),
+  IsOptional()
+], Manifest.prototype, "npmDependencies", 2);
+
+// src/lib/manifest/manifest-loader.ts
+import { plainToInstance as plainToInstance2 } from "class-transformer";
+import { validate as validate2 } from "class-validator";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join8 } from "path";
+var getManifestPath = /* @__PURE__ */ __name((directory) => {
+  for (const n of [MANIFEST_FILE_NAME]) {
+    const path = join8(directory, n);
+    if (existsSync2(path)) return path;
+  }
+  throw new Error(`No manifest file found in directory: ${directory}`);
+}, "getManifestPath");
+var loadManifest = /* @__PURE__ */ __name(async (directory) => {
+  let rawData;
+  const path = getManifestPath(directory);
   try {
-    const packageManager = PackageManagerFactory.create(pkgManagerName);
-    await packageManager.install(directory);
-  } catch (error4) {
-    if (error4 && error4.message) {
-      console4.error(ansis4.red(error4.message));
-    }
-    process4.exit(1);
+    rawData = deepMerge({}, JSON.parse(readFileSync2(path, "utf-8")));
+  } catch {
+    rawData = null;
+  }
+  if (!rawData) throw new Error(`Not able to read manifest file : ${path}`);
+  const data = plainToInstance2(Manifest, rawData, {
+    excludeExtraneousValues: true
+  });
+  const errors = await validate2(data);
+  if (errors.length > 0)
+    throw new Error(`Invalid manifest
+${errors.toString().replace(/,/g, "\n")}`);
+  return data;
+}, "loadManifest");
+
+// src/action/actions/publish.action.ts
+var PublishAction = class extends AbstractAction {
+  static {
+    __name(this, "PublishAction");
+  }
+  startMessage = Messages.PUBLISH_START;
+  successMessage = Messages.PUBLISH_SUCCESS;
+  failureMessage = Messages.PUBLISH_FAILED;
+  async handle(_args, options) {
+    const directory = getDirectoryInput(options);
+    const manifest = await loadManifest(directory);
+    return withSpinner(Messages.PUBLISH_IN_PROGRESS(manifest.name), async () => {
+      await Registry.publish(manifest, directory);
+    });
   }
-}, "runInstall");
+};
 
 // src/action/actions/start.action.ts
-import * as ansis5 from "ansis";
-import * as console5 from "console";
-import * as process5 from "process";
-import { join as join5 } from "path";
+import dotenv from "dotenv";
+import { join as join9, resolve as resolve3 } 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 cert = getStringInput(options, "cert");
-      const key = getStringInput(options, "key");
-      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
-          },
-          cert,
-          key
-        )
-      ]);
-      process5.exit(0);
-    } catch (e) {
-      console5.error(e);
-      process5.exit(1);
+    const directory = getDirectoryInput(options);
+    const config2 = await getConfig(options, directory);
+    const watch3 = getWatchInput(options);
+    const port = getStringInputWithDefault(options, "port", config2.client.port);
+    const ssl = this.resolveSSL(options);
+    const tasks = this.buildStartTasks(config2, directory, watch3, port, ssl);
+    await Promise.all(tasks);
+    return { keepAlive: true };
+  }
+  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
+    };
+  }
+  buildStartTasks(config2, directory, watch3, port, ssl) {
+    const env2 = this.parseEnv(directory);
+    const tasks = [];
+    if (config2.server.enable) {
+      tasks.push(this.startServer(directory, config2, { watch: watch3 }, env2));
     }
+    tasks.push(this.startClient(directory, config2, { watch: watch3, port, ssl }, env2));
+    return tasks;
+  }
+  async startClient(directory, config2, options, env2) {
+    const loaderPath = getModulePath("@nanoforge-dev/loader-client/package.json", true);
+    const params = this.buildClientParams(directory, config2, options);
+    await this.runLoader("Client", loaderPath, params, env2.client);
   }
-  async startClient(port, directory, gameDir, options, cert, key) {
-    const path = getModulePath("@nanoforge-dev/loader-client/package.json", true);
+  async startServer(directory, config2, options, env2) {
+    const loaderPath = getModulePath("@nanoforge-dev/loader-server/package.json", true);
+    const params = this.buildServerParams(directory, config2, options);
+    await this.runLoader("Server", loaderPath, params, env2.server);
+  }
+  buildClientParams(directory, config2, options) {
     const params = {
-      PORT: port,
-      GAME_DIR: getCwd(join5(directory, gameDir)),
-      CERT: cert ? join5(getCwd(directory), cert) : void 0,
-      KEY: key ? join5(getCwd(directory), key) : void 0
+      "-d": getCwd(join9(directory, config2.client.runtime.dir)),
+      "-p": options.port
     };
-    if (options?.watch) {
-      params["WATCH"] = "true";
-      if (options?.serverGameDir) {
-        params["WATCH_SERVER_GAME_DIR"] = getCwd(join5(directory, options.serverGameDir));
+    if (options.watch) params["--watch"] = true;
+    if (options.watch) {
+      params["--watch"] = true;
+      if (config2.server.enable) {
+        params["--watch-server-dir"] = getCwd(join9(directory, config2.server.runtime.dir));
       }
     }
-    return runPart("Client", path, params);
+    if (options.ssl) {
+      params["--cert"] = options.ssl.cert;
+      params["--key"] = options.ssl.key;
+    }
+    return this.buildParams(params);
   }
-  startServer(directory, gameDir, watch3) {
-    const path = getModulePath("@nanoforge-dev/loader-server/package.json", true);
+  buildServerParams(directory, config2, options) {
     const params = {
-      GAME_DIR: getCwd(join5(directory, gameDir))
+      "-d": getCwd(join9(directory, config2.server.runtime.dir))
+    };
+    if (options.watch) params["--watch"] = true;
+    return this.buildParams(params);
+  }
+  buildParams(params) {
+    return Object.entries(params).map(([key, value]) => typeof value === "string" ? [key, value] : [key]).flat();
+  }
+  parseEnv(dir) {
+    const prefix = "NANOFORGE_";
+    const clientPrefix = `${prefix}CLIENT_`;
+    const serverPrefix = `${prefix}SERVER_`;
+    const rawEnv = {
+      ...process.env
     };
-    if (watch3) params["WATCH"] = "true";
-    return runPart("Server", path, params);
+    dotenv.config({
+      path: resolve3(getCwd(join9(dir, ".env"))),
+      processEnv: rawEnv
+    });
+    const baseEnv = Object.entries(rawEnv).filter(
+      ([key, value]) => key.startsWith(prefix) && !!value
+    );
+    return {
+      client: Object.fromEntries(
+        baseEnv.filter(([key]) => !key.startsWith(serverPrefix)).map(([key, value]) => [key.replace(clientPrefix, prefix), value])
+      ),
+      server: Object.fromEntries(
+        baseEnv.filter(([key]) => !key.startsWith(clientPrefix)).map(([key, value]) => [key.replace(serverPrefix, prefix), value])
+      )
+    };
+  }
+  async runLoader(name, directory, params, env2) {
+    await runSafe(async () => {
+      const packageManager = await PackageManagerFactory.find(directory);
+      await packageManager.run(name, directory, "start", params, 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));
-    }
+
+// src/action/actions/unpublish.action.ts
+var UnpublishAction = class extends AbstractAction {
+  static {
+    __name(this, "UnpublishAction");
   }
-}, "runPart");
+  startMessage = Messages.UNPUBLISH_START;
+  successMessage = Messages.UNPUBLISH_SUCCESS;
+  failureMessage = Messages.UNPUBLISH_FAILED;
+  async handle(_args, options) {
+    const directory = getDirectoryInput(options);
+    const manifest = await loadManifest(directory);
+    return withSpinner(Messages.UNPUBLISH_IN_PROGRESS(manifest.name), async () => {
+      await Registry.unpublish(manifest, directory);
+    });
+  }
+};
 
 // src/command/abstract.command.ts
 var AbstractCommand = class {
@@ -1667,6 +2217,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
@@ -1675,15 +2232,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 working directory of the command").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);
     });
   }
 };
@@ -1694,13 +2251,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 working directory of the command").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);
     });
   }
 };
@@ -1711,13 +2268,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 working directory of the command").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);
     });
   }
 };
@@ -1728,12 +2285,53 @@ var InstallCommand = class extends AbstractCommand {
     __name(this, "InstallCommand");
   }
   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);
+    program.command("install [names...]").alias("add").description("add Nanoforge components and systems to your project").option("-d, --directory [directory]", "specify the working directory of the command").option("-l, --lib", "install library instead of component/system", false).option(
+      "-s, --server",
+      "install components/systems on server (default install on client)",
+      false
+    ).action(async (names, rawOptions) => {
+      const options = AbstractCommand.mapToInput({
+        directory: rawOptions.directory,
+        lib: rawOptions.lib,
+        server: rawOptions.server
+      });
+      const args = AbstractCommand.mapToInput({
+        names: names.length ? names : void 0
+      });
+      await this.action.run(args, options);
+    });
+  }
+};
+
+// src/command/commands/login.command.ts
+var LoginCommand = class extends AbstractCommand {
+  static {
+    __name(this, "LoginCommand");
+  }
+  load(program) {
+    program.command("login").description("login to Nanoforge registry").option("-d, --directory [directory]", "specify the working directory of the command").option("-l, --local", "login only for the project", false).option("-k, --api-key <key>", "api key for Nanoforge registry").action(async (rawOptions) => {
+      const options = AbstractCommand.mapToInput({
+        directory: rawOptions.directory,
+        local: rawOptions.local,
+        apiKey: rawOptions.apiKey
+      });
+      await this.action.run(/* @__PURE__ */ new Map(), options);
+    });
+  }
+};
+
+// src/command/commands/logout.command.ts
+var LogoutCommand = class extends AbstractCommand {
+  static {
+    __name(this, "LogoutCommand");
+  }
+  load(program) {
+    program.command("logout").description("logout from Nanoforge registry").option("-d, --directory [directory]", "specify the working directory of the command").option("-l, --local", "logout only for the project").action(async (rawOptions) => {
+      const options = AbstractCommand.mapToInput({
+        directory: rawOptions.directory,
+        local: rawOptions.local
+      });
+      await this.action.run(/* @__PURE__ */ new Map(), options);
     });
   }
 };
@@ -1744,19 +2342,39 @@ 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 working directory of the command").option("--name [name]", "specify the name of your project").option(
+      "--path [path]",
+      "specify the relative path where your project will be created (default: name of the 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").option("--no-lint", "do not generate lint 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,
+        lint: rawOptions.lint
+      });
+      await this.action.run(/* @__PURE__ */ new Map(), options);
+    });
+  }
+};
+
+// src/command/commands/publish.command.ts
+var PublishCommand = class extends AbstractCommand {
+  static {
+    __name(this, "PublishCommand");
+  }
+  load(program) {
+    program.command("publish").description("publish package to Nanoforge registry").option("-d, --directory [directory]", "specify the working directory of the command").action(async (rawOptions) => {
+      const options = AbstractCommand.mapToInput({
+        directory: rawOptions.directory
+      });
+      await this.action.run(/* @__PURE__ */ new Map(), options);
     });
   }
 };
@@ -1767,23 +2385,31 @@ 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(
-      "-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).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 = /* @__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
+    program.command("start").description("start your game").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("-p, --port [port]", "specify the port of the loader (the website to load the game)").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,
+        port: rawOptions.port,
+        watch: rawOptions.watch,
+        cert: rawOptions.cert,
+        key: rawOptions.key
       });
-      options.set("serverPort", { value: rawOptions.serverPort });
-      options.set("watch", { value: rawOptions.watch });
-      options.set("cert", { value: rawOptions.cert });
-      options.set("key", { value: rawOptions.key });
-      const args = /* @__PURE__ */ new Map();
-      await this.action.handle(args, options);
+      await this.action.run(/* @__PURE__ */ new Map(), options);
+    });
+  }
+};
+
+// src/command/commands/unpublish.command.ts
+var UnpublishCommand = class extends AbstractCommand {
+  static {
+    __name(this, "UnpublishCommand");
+  }
+  load(program) {
+    program.command("unpublish").description("unpublish package to Nanoforge registry").option("-d, --directory [directory]", "specify the working directory of the command").action(async (rawOptions) => {
+      const options = AbstractCommand.mapToInput({
+        directory: rawOptions.directory
+      });
+      await this.action.run(/* @__PURE__ */ new Map(), options);
     });
   }
 };
@@ -1794,19 +2420,23 @@ var CommandLoader = class {
     __name(this, "CommandLoader");
   }
   static async load(program) {
+    new NewCommand(new NewAction()).load(program);
+    new InstallCommand(new InstallAction()).load(program);
     new BuildCommand(new BuildAction()).load(program);
+    new StartCommand(new StartAction()).load(program);
     new DevCommand(new DevAction()).load(program);
     new GenerateCommand(new GenerateAction()).load(program);
-    new InstallCommand(new InstallAction()).load(program);
-    new NewCommand(new NewAction()).load(program);
-    new StartCommand(new StartAction()).load(program);
+    new LoginCommand(new LoginAction()).load(program);
+    new LogoutCommand(new LogoutAction()).load(program);
+    new PublishCommand(new PublishAction()).load(program);
+    new UnpublishCommand(new UnpublishAction()).load(program);
     this.handleInvalidCommand(program);
   }
   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);
     });