@nanoforge-dev/cli 1.2.0 → 1.4.0

package/dist/nf.js

@@ -40,7 +40,7 @@ var require_package = __commonJS({
     module.exports = {
       $schema: "https://json.schemastore.org/package.json",
       name: "@nanoforge-dev/cli",
-      version: "1.2.0",
+      version: "1.4.0",
       description: "NanoForge CLI",
       keywords: [
         "nanoforge",
@@ -73,6 +73,7 @@ var require_package = __commonJS({
       funding: "",
       scripts: {
         build: "tsc --noEmit && tsup",
+        "build:dev": "tsc --noEmit && NODE_ENV=development tsup",
         start: "node dist/nf.js",
         lint: "prettier --check . && eslint --format=pretty src",
         format: "prettier --write . && eslint --fix --format=pretty src",
@@ -100,8 +101,10 @@ var require_package = __commonJS({
         "class-transformer": "catalog:libs",
         "class-validator": "catalog:libs",
         commander: "catalog:cli",
+        dotenv: "catalog:libs",
         "node-emoji": "catalog:cli",
         ora: "catalog:cli",
+        rc9: "catalog:libs",
         "reflect-metadata": "catalog:libs"
       },
       devDependencies: {
@@ -146,6 +149,110 @@ var require_package = __commonJS({
 import { program } from "commander";
 import "reflect-metadata";
 
+// src/lib/tree-kill/tree-kill.ts
+import { execSync, spawn } from "child_process";
+var treeKill = /* @__PURE__ */ __name((pid, signal) => {
+  function extracted(resolve4) {
+    const tree = {};
+    const pidsToProcess = {};
+    tree[pid] = [];
+    pidsToProcess[pid] = 1;
+    switch (process.platform) {
+      case "win32":
+        execSync("taskkill /pid " + pid + " /T /F");
+        resolve4();
+        break;
+      case "darwin":
+        buildProcessTree(
+          pid,
+          tree,
+          pidsToProcess,
+          function(parentPid) {
+            return spawn("pgrep", ["-P", parentPid]);
+          },
+          function() {
+            killAll(tree, signal);
+            resolve4();
+          }
+        );
+        break;
+      default:
+        buildProcessTree(
+          pid,
+          tree,
+          pidsToProcess,
+          function(parentPid) {
+            return spawn("ps", ["-o", "pid", "--no-headers", "--ppid", parentPid]);
+          },
+          function() {
+            killAll(tree, signal);
+            resolve4();
+          }
+        );
+        break;
+    }
+  }
+  __name(extracted, "extracted");
+  return new Promise((resolve4) => {
+    extracted(resolve4);
+  });
+}, "treeKill");
+function killAll(tree, signal) {
+  const killed = {};
+  Object.keys(tree).reverse().forEach(function(pidStr) {
+    const pid = Number(pidStr);
+    tree[pid]?.forEach(function(pidpid) {
+      if (!killed[pidpid]) {
+        killPid(pidpid, signal);
+        killed[pidpid] = true;
+      }
+    });
+    if (!killed[pid]) {
+      killPid(pid, signal);
+      killed[pid] = true;
+    }
+  });
+}
+__name(killAll, "killAll");
+function killPid(pid, signal) {
+  try {
+    process.kill(pid, signal);
+  } catch (err) {
+    const e = err;
+    if (e.code !== "ESRCH") throw err;
+  }
+}
+__name(killPid, "killPid");
+function buildProcessTree(parentPid, tree, pidsToProcess, spawnChildProcessesList, cb) {
+  const ps = spawnChildProcessesList(parentPid.toString());
+  let allData = "";
+  ps.stdout.on("data", function(data) {
+    allData += data.toString("ascii");
+  });
+  const onClose = /* @__PURE__ */ __name(function(code) {
+    delete pidsToProcess[parentPid];
+    if (code != 0) {
+      if (Object.keys(pidsToProcess).length == 0) {
+        cb();
+      }
+      return;
+    }
+    if (allData)
+      allData.match(/\d+/g)?.forEach(function(pid) {
+        const intPid = Number(pid);
+        if (tree[parentPid] === void 0) {
+          tree[parentPid] = [];
+        }
+        tree[parentPid].push(intPid);
+        tree[intPid] = [];
+        pidsToProcess[intPid] = 1;
+        buildProcessTree(intPid, tree, pidsToProcess, spawnChildProcessesList, cb);
+      });
+  }, "onClose");
+  ps.on("close", onClose);
+}
+__name(buildProcessTree, "buildProcessTree");
+
 // src/lib/utils/local-binaries.ts
 import { existsSync } from "fs";
 import { join, posix } from "path";
@@ -204,6 +311,16 @@ Try running manually: ${command}`), "BUILD_PART_FAILED"),
   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: success("Project successfully created!"),
@@ -215,6 +332,11 @@ Try running manually: ${command}`), "BUILD_PART_FAILED"),
   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?",
+  // --- Create ---
+  CREATE_START: "NanoForge Component/System Creation",
+  CREATE_SUCCESS: success("Element successfully created!"),
+  CREATE_FAILED: failure("Creation failed!"),
+  CREATE_NAME_QUESTION: "What is the name of your component/system?",
   // --- Generate ---
   GENERATE_START: "NanoForge Generate",
   GENERATE_SUCCESS: success("Generation succeeded!"),
@@ -231,6 +353,16 @@ Try running manually: ${command}`), "BUILD_PART_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"),
@@ -261,7 +393,7 @@ var getSpinner = /* @__PURE__ */ __name((message) => ora({ text: message }), "ge
 
 // src/action/actions/build.action.ts
 import { watch } from "chokidar";
-import { dirname, join as join4 } from "path";
+import { dirname, join as join5 } from "path";
 
 // src/lib/input/base-inputs.ts
 var getStringInput = /* @__PURE__ */ __name((input2, field) => {
@@ -310,15 +442,10 @@ var getConfigInput = /* @__PURE__ */ __name((inputs) => {
   return getStringInputWithDefault(inputs, "config", ".");
 }, "getConfigInput");
 
-// src/lib/input/inputs/watch.input.ts
-var getWatchInput = /* @__PURE__ */ __name((inputs) => {
-  return getBooleanInputWithDefault(inputs, "watch", false);
-}, "getWatchInput");
-
-// src/lib/input/inputs/dev/generate.input.ts
-var getDevGenerateInput = /* @__PURE__ */ __name((inputs) => {
-  return getBooleanInputWithDefault(inputs, "generate", false);
-}, "getDevGenerateInput");
+// src/lib/input/inputs/editor.input.ts
+var getEditorInput = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInputWithDefault(inputs, "editor", false);
+}, "getEditorInput");
 
 // src/lib/question/questions/confirm.question.ts
 import { confirm } from "@inquirer/prompts";
@@ -326,10 +453,16 @@ import { confirm } from "@inquirer/prompts";
 // src/lib/utils/errors.ts
 import { red } from "ansis";
 var getErrorMessage = /* @__PURE__ */ __name((error) => {
-  if (error instanceof Error) return error.message;
+  if (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));
@@ -402,6 +535,66 @@ var askSelect = /* @__PURE__ */ __name(async (question, choices, baseOptions) =>
   }).catch(promptError);
 }, "askSelect");
 
+// src/lib/input/inputs/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");
+var getCreateNameInputOrAsk = /* @__PURE__ */ __name((inputs) => {
+  return getInputOrAsk(
+    getNameInput(inputs),
+    () => askInput(Messages.CREATE_NAME_QUESTION, {
+      required: true,
+      default: "example"
+    })
+  );
+}, "getCreateNameInputOrAsk");
+
+// src/lib/input/inputs/path.input.ts
+var getPathInput = /* @__PURE__ */ __name((inputs) => {
+  return getStringInput(inputs, "path");
+}, "getPathInput");
+var getPathInputWithDefault = /* @__PURE__ */ __name((inputs, defaultValue) => {
+  return getStringInputWithDefault(inputs, "path", defaultValue);
+}, "getPathInputWithDefault");
+
+// src/lib/input/inputs/server.input.ts
+function getServerInput(inputs) {
+  return getBooleanInputWithDefault(inputs, "server", false);
+}
+__name(getServerInput, "getServerInput");
+
+// src/lib/input/inputs/watch.input.ts
+var getWatchInput = /* @__PURE__ */ __name((inputs) => {
+  return getBooleanInputWithDefault(inputs, "watch", false);
+}, "getWatchInput");
+
+// src/lib/input/inputs/create/type.input.ts
+var getCreateTypeInput = /* @__PURE__ */ __name((inputs) => {
+  const res = getStringInput(inputs, "type");
+  if (res && ["component", "system"].includes(res)) return res;
+  throw new Error("Invalid type. Please enter 'component' or 'system'.");
+}, "getCreateTypeInput");
+
+// src/lib/input/inputs/dev/generate.input.ts
+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/input/inputs/install/names.input.ts
 var getNamesInput = /* @__PURE__ */ __name((inputs) => {
   return getArrayInput(inputs, "names");
@@ -413,6 +606,109 @@ var getInstallNamesInputOrAsk = /* @__PURE__ */ __name((inputs) => {
   );
 }, "getInstallNamesInputOrAsk");
 
+// 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/input/inputs/login-out/local.input.ts
+function getLocalInput(inputs) {
+  return getBooleanInputWithDefault(inputs, "local", false);
+}
+__name(getLocalInput, "getLocalInput");
+
+// 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/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/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";
 
@@ -460,6 +756,21 @@ var resolveCLINodeBinaryPath = /* @__PURE__ */ __name((name) => {
   throw new Error("Could not find module path");
 }, "resolveCLINodeBinaryPath");
 
+// 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) {
@@ -467,12 +778,15 @@ var PackageManager = class {
     this.commands = commands;
     this.runner = runner;
   }
+  name;
+  commands;
+  runner;
   static {
     __name(this, "PackageManager");
   }
   async install(directory) {
     const args = [this.commands.install, this.commands.silentFlag];
-    const result = await this.withSpinner(
+    const result = await withSpinner(
       Messages.PACKAGE_MANAGER_INSTALLATION_IN_PROGRESS,
       async (spinner) => {
         await this.exec(args, directory, { onFail: /* @__PURE__ */ __name(() => spinner.fail(), "onFail") });
@@ -500,7 +814,7 @@ var PackageManager = class {
       output,
       ...flags
     ];
-    const result = await this.withSpinner(
+    const result = await withSpinner(
       message,
       async (spinner) => {
         await this.exec(args, directory, { onFail: /* @__PURE__ */ __name(() => spinner.fail(), "onFail") });
@@ -509,10 +823,10 @@ var PackageManager = class {
     );
     return result.success;
   }
-  async run(name, directory, script, env2 = {}, flags = [], silent = false) {
+  async run(name, directory, script, params, env2 = {}, flags = [], silent = false) {
     console.info(Messages.START_PART_IN_PROGRESS(name));
     try {
-      const args = this.buildRunArgs(script, flags, silent);
+      const args = this.buildRunArgs(script, params, flags, silent);
       await this.exec(args, directory, {
         env: env2,
         listeners: {
@@ -529,32 +843,21 @@ var PackageManager = class {
   }
   async runDev(directory, command, env2 = {}, flags = [], collect = true) {
     try {
-      await this.exec([this.commands.run, command, ...flags], directory, { collect, env: 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 withSpinner(message, task, onError) {
-    const spinner = getSpinner(message);
-    spinner.start();
-    try {
-      const value = await task(spinner);
-      spinner.succeed();
-      return { success: true, value };
-    } catch {
-      spinner.fail();
-      if (onError) onError();
-      return { success: false };
-    }
-  }
   async addDependencies(saveFlag, directory, dependencies) {
     if (!dependencies.length) {
       this.logEmpty(Messages.PACKAGE_MANAGER_INSTALLATION_NOTHING);
       return true;
     }
     const args = [this.commands.add, saveFlag, ...dependencies];
-    const result = await this.withSpinner(
+    const result = await withSpinner(
       Messages.PACKAGE_MANAGER_INSTALLATION_IN_PROGRESS,
       async (spinner) => {
         await this.exec(args, directory, { onFail: /* @__PURE__ */ __name(() => spinner.fail(), "onFail") });
@@ -569,11 +872,13 @@ var PackageManager = class {
       throw new Error(`Package manager "${this.name}" does not support "${feature}"`);
     }
   }
-  buildRunArgs(script, flags, silent) {
+  buildRunArgs(script, params, flags, silent) {
     const args = [...flags, this.commands.run];
     if (silent) args.push(this.commands.silentFlag);
     args.push(script);
-    return args;
+    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, {
@@ -612,13 +917,15 @@ import { resolve as resolve2 } from "path";
 
 // src/lib/runner/runner.ts
 import { red as red4 } from "ansis";
-import { spawn } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import * as process2 from "process";
 var Runner = class {
   constructor(binary, baseArgs = []) {
     this.binary = binary;
     this.baseArgs = baseArgs;
   }
+  binary;
+  baseArgs;
   static {
     __name(this, "Runner");
   }
@@ -626,12 +933,12 @@ var Runner = class {
     const { collect = false, cwd: cwd2 = process2.cwd(), env: env2, listeners, onFail } = options;
     const spawnOpts = this.buildSpawnOptions(collect, cwd2, env2);
     const fullArgs = [...this.baseArgs, ...args];
-    return new Promise((resolve3, reject) => {
-      const child = spawn(`${this.binary} ${fullArgs.join(" ")}`, spawnOpts);
+    return new Promise((resolve4, reject) => {
+      const child = spawn2(`${this.binary} ${fullArgs.join(" ")}`, spawnOpts);
       const output = this.attachOutputHandlers(child, listeners);
       child.on("close", (code) => {
         if (code === 0) {
-          resolve3(this.formatOutput(output, collect));
+          resolve4(this.formatOutput(output, collect));
         } else {
           this.handleFailure(output, fullArgs, onFail);
           reject(this.createError(fullArgs, code));
@@ -746,6 +1053,7 @@ var PM_CONFIGS = {
       remove: "uninstall",
       exec: "exec",
       run: "run",
+      runArgsFlag: "--",
       saveFlag: "--save",
       saveDevFlag: "--save-dev",
       silentFlag: "--silent"
@@ -822,6 +1130,21 @@ var PackageManagerFactory = class {
   }
 };
 
+// src/lib/utils/files.ts
+import fs3 from "fs";
+import { join as join3 } from "path";
+var copyFiles = /* @__PURE__ */ __name((from, to) => {
+  if (!fs3.existsSync(from)) return;
+  if (!fs3.existsSync(to)) throw new Error(`Directory ${to} does not exist`);
+  fs3.readdirSync(from, { recursive: true }).forEach((file) => {
+    fs3.copyFileSync(join3(from, file.toString()), join3(to, file.toString()));
+  });
+}, "copyFiles");
+var resetFolder = /* @__PURE__ */ __name((folder) => {
+  if (fs3.existsSync(folder)) fs3.rmSync(folder, { recursive: true, force: true });
+  fs3.mkdirSync(folder);
+}, "resetFolder");
+
 // src/lib/utils/run-safe.ts
 import { red as red5 } from "ansis";
 var runSafe = /* @__PURE__ */ __name(async (fn, fallback) => {
@@ -841,47 +1164,77 @@ var BuildConfig = class {
   static {
     __name(this, "BuildConfig");
   }
-  entryFile;
-  outDir;
+  entry;
+  staticDir;
+};
+__decorateClass([
+  Expose(),
+  IsString(),
+  IsNotEmpty()
+], BuildConfig.prototype, "entry", 2);
+__decorateClass([
+  Expose(),
+  IsString(),
+  IsNotEmpty()
+], BuildConfig.prototype, "staticDir", 2);
+var EditorConfig = class {
+  static {
+    __name(this, "EditorConfig");
+  }
+  entry;
+  save;
 };
 __decorateClass([
   Expose(),
   IsString(),
   IsNotEmpty()
-], BuildConfig.prototype, "entryFile", 2);
+], EditorConfig.prototype, "entry", 2);
 __decorateClass([
   Expose(),
   IsString(),
   IsNotEmpty()
-], BuildConfig.prototype, "outDir", 2);
-var RunConfig = class {
+], EditorConfig.prototype, "save", 2);
+var DirsConfig = class {
   static {
-    __name(this, "RunConfig");
+    __name(this, "DirsConfig");
   }
-  dir;
+  components;
+  systems;
 };
 __decorateClass([
   Expose(),
   IsString(),
   IsNotEmpty()
-], RunConfig.prototype, "dir", 2);
+], DirsConfig.prototype, "components", 2);
+__decorateClass([
+  Expose(),
+  IsString(),
+  IsNotEmpty()
+], DirsConfig.prototype, "systems", 2);
 var ClientConfig = class {
   static {
     __name(this, "ClientConfig");
   }
+  enable;
   port;
-  gameExposurePort;
+  outDir;
   build;
-  runtime;
+  editor;
+  dirs;
 };
+__decorateClass([
+  Expose(),
+  IsBoolean()
+], ClientConfig.prototype, "enable", 2);
 __decorateClass([
   Expose(),
   IsPort()
 ], ClientConfig.prototype, "port", 2);
 __decorateClass([
   Expose(),
-  IsPort()
-], ClientConfig.prototype, "gameExposurePort", 2);
+  IsString(),
+  IsNotEmpty()
+], ClientConfig.prototype, "outDir", 2);
 __decorateClass([
   Expose(),
   Type(() => BuildConfig),
@@ -889,17 +1242,23 @@ __decorateClass([
 ], ClientConfig.prototype, "build", 2);
 __decorateClass([
   Expose(),
-  Type(() => RunConfig),
+  Type(() => EditorConfig),
   ValidateNested()
-], ClientConfig.prototype, "runtime", 2);
+], ClientConfig.prototype, "editor", 2);
+__decorateClass([
+  Expose(),
+  Type(() => DirsConfig),
+  ValidateNested()
+], ClientConfig.prototype, "dirs", 2);
 var ServerConfig = class {
   static {
     __name(this, "ServerConfig");
   }
   enable;
-  port;
+  outDir;
   build;
-  runtime;
+  editor;
+  dirs;
 };
 __decorateClass([
   Expose(),
@@ -907,8 +1266,9 @@ __decorateClass([
 ], ServerConfig.prototype, "enable", 2);
 __decorateClass([
   Expose(),
-  IsPort()
-], ServerConfig.prototype, "port", 2);
+  IsString(),
+  IsNotEmpty()
+], ServerConfig.prototype, "outDir", 2);
 __decorateClass([
   Expose(),
   Type(() => BuildConfig),
@@ -916,9 +1276,14 @@ __decorateClass([
 ], ServerConfig.prototype, "build", 2);
 __decorateClass([
   Expose(),
-  Type(() => RunConfig),
+  Type(() => EditorConfig),
   ValidateNested()
-], ServerConfig.prototype, "runtime", 2);
+], ServerConfig.prototype, "editor", 2);
+__decorateClass([
+  Expose(),
+  Type(() => DirsConfig),
+  ValidateNested()
+], ServerConfig.prototype, "dirs", 2);
 var Config = class {
   static {
     __name(this, "Config");
@@ -957,11 +1322,13 @@ __decorateClass([
 import { plainToInstance } from "class-transformer";
 import { validate } from "class-validator";
 import { existsSync as existsSync2, readFileSync } from "fs";
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 
 // src/lib/constants.ts
 var CONFIG_FILE_NAME = "nanoforge.config.json";
-var NANOFORGE_DIR = ".nanoforge";
+var MANIFEST_FILE_NAME = "nanoforge.manifest.json";
+var GLOBAL_CONFIG_FILE_NAME = ".nanoforgerc";
+var REGISTRY_URL = "https://api.nanoforge.dev";
 
 // src/lib/utils/object.ts
 var isObject = /* @__PURE__ */ __name((item) => {
@@ -982,6 +1349,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 = {
@@ -989,25 +1357,36 @@ var CONFIG_DEFAULTS = {
   language: "ts",
   initFunctions: true,
   client: {
+    enable: true,
     port: "3000",
-    gameExposurePort: "3001",
+    outDir: ".nanoforge/client",
     build: {
-      entryFile: "client/main.ts",
-      outDir: ".nanoforge/client"
+      entry: "client/main.ts",
+      staticDir: "client/static"
     },
-    runtime: {
-      dir: ".nanoforge/client"
+    editor: {
+      entry: ".nanoforge/editor/client/main.ts",
+      save: ".nanoforge/client.save.json"
+    },
+    dirs: {
+      components: "client/components",
+      systems: "client/systems"
     }
   },
   server: {
     enable: false,
-    port: "3002",
+    outDir: ".nanoforge/server",
     build: {
-      entryFile: "server/main.ts",
-      outDir: ".nanoforge/server"
+      entry: "server/main.ts",
+      staticDir: "server/static"
+    },
+    editor: {
+      entry: ".nanoforge/editor/server/main.ts",
+      save: ".nanoforge/server.save.json"
     },
-    runtime: {
-      dir: ".nanoforge/server"
+    dirs: {
+      components: "server/components",
+      systems: "server/systems"
     }
   }
 };
@@ -1016,23 +1395,23 @@ var CONFIG_DEFAULTS = {
 var config;
 var getConfigPath = /* @__PURE__ */ __name((directory, name) => {
   if (name) {
-    return join3(directory, name);
+    return join4(directory, name);
   } else {
     for (const n of [CONFIG_FILE_NAME]) {
-      const path = join3(directory, n);
+      const path = join4(directory, n);
       if (existsSync2(path)) return path;
     }
     throw new Error(`No config file found in directory: ${directory}`);
   }
 }, "getConfigPath");
-var loadConfig = /* @__PURE__ */ __name(async (directory, name) => {
+var loadConfig = /* @__PURE__ */ __name(async (directory, name, noThrow = false) => {
   if (config) return config;
   let rawData;
   const path = getConfigPath(directory, name);
   try {
     rawData = deepMerge(CONFIG_DEFAULTS, JSON.parse(readFileSync(path, "utf-8")));
   } catch {
-    rawData = null;
+    rawData = noThrow ? CONFIG_DEFAULTS : null;
   }
   if (!rawData) throw new Error(`Not able to read config file : ${path}`);
   const data = plainToInstance(Config, rawData, {
@@ -1047,8 +1426,8 @@ ${errors.toString().replace(/,/g, "\n")}`);
 }, "loadConfig");
 
 // src/action/common/config.ts
-var getConfig = /* @__PURE__ */ __name((inputs, dir) => {
-  return loadConfig(dir, getConfigInput(inputs));
+var getConfig = /* @__PURE__ */ __name((inputs, dir, noThrow) => {
+  return loadConfig(dir, getConfigInput(inputs), noThrow);
 }, "getConfig");
 
 // src/action/abstract.action.ts
@@ -1076,7 +1455,7 @@ var AbstractAction = class {
     if (keepAlive) return;
     console.info();
     if (!success2) {
-      if (this.failureMessage) console.error(this.failureMessage);
+      handleActionError(this.failureMessage, result.error);
       process.exit(1);
     }
     if (this.successMessage) console.info(this.successMessage);
@@ -1095,40 +1474,53 @@ var BuildAction = class extends AbstractAction {
   async handle(_args, options) {
     const directory = getDirectoryInput(options);
     const config2 = await getConfig(options, directory);
+    const isEditor = getEditorInput(options);
     const isWatch = getWatchInput(options);
-    const targets = this.resolveTargets(config2, options);
+    const targets = this.resolveTargets(config2, options, isEditor);
     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,
-        "browser",
-        getStringInput(options, "clientDirectory")
-      )
-    ];
-    if (config2.server.enable) {
+  resolveTargets(config2, options, isEditor) {
+    const targets = [];
+    if (config2.client.enable)
+      targets.push(
+        this.createTarget(
+          "Client",
+          "browser",
+          getStringInputWithDefault(
+            options,
+            "clientEntry",
+            !isEditor ? config2.client.build.entry : config2.client.editor.entry
+          ),
+          getStringInputWithDefault(options, "clientStaticDir", config2.client.build.staticDir),
+          getStringInputWithDefault(options, "clientOutDir", config2.client.outDir)
+        )
+      );
+    if (config2.server.enable)
       targets.push(
         this.createTarget(
           "Server",
-          config2.server.build,
           "node",
-          getStringInput(options, "serverDirectory")
+          getStringInputWithDefault(
+            options,
+            "serverEntry",
+            !isEditor ? config2.server.build.entry : config2.server.editor.entry
+          ),
+          getStringInputWithDefault(options, "serverStaticDir", config2.server.build.staticDir),
+          getStringInputWithDefault(options, "serverOutDir", config2.server.outDir)
         )
       );
-    }
     return targets;
   }
-  createTarget(name, config2, platform, outDirOverride) {
+  createTarget(name, platform, entryFile, staticDir, outDir) {
     return {
       name,
-      entry: config2.entryFile,
-      output: outDirOverride || config2.outDir,
+      entry: entryFile,
+      static: staticDir,
+      output: outDir,
       platform
     };
   }
@@ -1142,17 +1534,18 @@ var BuildAction = class extends AbstractAction {
   }
   async buildTarget(target, directory, isWatch) {
     const packageManager = PackageManagerFactory.create("local_bun" /* LOCAL_BUN */);
-    const executeBuild = /* @__PURE__ */ __name((rebuild = false) => runSafe(
-      () => packageManager.build(
+    const executeBuild = /* @__PURE__ */ __name((rebuild = false) => runSafe(() => {
+      this.resetOut(target.output, directory);
+      this.copyFiles(target, directory);
+      return packageManager.build(
         target.name,
         directory,
         target.entry,
         target.output,
         ["--asset-naming", "[name].[ext]", "--target", target.platform],
         rebuild
-      ),
-      false
-    ), "executeBuild");
+      );
+    }, false), "executeBuild");
     if (isWatch) {
       this.watchDirectory(directory, target.entry, () => executeBuild(true));
     }
@@ -1160,7 +1553,7 @@ var BuildAction = class extends AbstractAction {
     return result !== false;
   }
   watchDirectory(directory, entry, onChange) {
-    const watchPath = dirname(join4(getCwd(directory), entry));
+    const watchPath = dirname(join5(getCwd(directory), entry));
     watch(watchPath).on("change", onChange);
   }
   enterWatchMode() {
@@ -1169,43 +1562,16 @@ var BuildAction = class extends AbstractAction {
     console.info();
     return { keepAlive: true };
   }
-};
-
-// src/action/actions/dev.action.ts
-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) {
-    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;
+  resetOut(outDir, directory) {
+    resetFolder(getCwd(join5(directory, outDir)));
   }
-  async runSubCommand(command, directory, options) {
-    await runSafe(async () => {
-      const packageManager = await PackageManagerFactory.find(directory);
-      await packageManager.runDev(directory, "nf", {}, [command, "--watch"], options.silent);
-    });
+  copyFiles(target, directory) {
+    const from = getCwd(join5(directory, target.static));
+    const to = getCwd(join5(directory, target.output));
+    copyFiles(from, to);
   }
 };
 
-// src/action/actions/generate.action.ts
-import { join as join5 } from "path";
-
 // src/lib/schematics/abstract.collection.ts
 var AbstractCollection = class {
   constructor(collection, runner, cwd2) {
@@ -1213,6 +1579,9 @@ var AbstractCollection = class {
     this.runner = runner;
     this.cwd = cwd2;
   }
+  collection;
+  runner;
+  cwd;
   static {
     __name(this, "AbstractCollection");
   }
@@ -1262,6 +1631,16 @@ var NanoforgeCollection = class _NanoforgeCollection extends AbstractCollection
       name: "docker",
       alias: "docker",
       description: "Generate a Dockerfile for the application"
+    },
+    {
+      name: "component",
+      alias: "component",
+      description: "Generate a Component for an application"
+    },
+    {
+      name: "system",
+      alias: "system",
+      description: "Generate a System for an application"
     }
   ];
   constructor(runner, cwd2) {
@@ -1305,6 +1684,7 @@ var CollectionFactory = class {
 var toKebabCase = /* @__PURE__ */ __name((str) => {
   return str.replace(/([a-z0-9]|(?=[A-Z]))([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
 }, "toKebabCase");
+var capitalize = /* @__PURE__ */ __name((str) => str.charAt(0).toUpperCase() + str.slice(1), "capitalize");
 
 // src/lib/schematics/schematic.option.ts
 var SchematicOption = class {
@@ -1312,6 +1692,8 @@ var SchematicOption = class {
     this.name = name;
     this.value = value;
   }
+  name;
+  value;
   static {
     __name(this, "SchematicOption");
   }
@@ -1382,64 +1764,131 @@ var mapSchematicOptions = /* @__PURE__ */ __name((inputs) => {
   }, []);
 }, "mapSchematicOptions");
 
-// src/action/actions/generate.action.ts
-var GenerateAction = class extends AbstractAction {
+// src/action/actions/create.action.ts
+var CreateAction = class extends AbstractAction {
   static {
-    __name(this, "GenerateAction");
+    __name(this, "CreateAction");
   }
-  startMessage = Messages.GENERATE_START;
-  successMessage = Messages.GENERATE_SUCCESS;
-  failureMessage = Messages.GENERATE_FAILED;
-  async handle(_args, options) {
+  startMessage = Messages.CREATE_START;
+  successMessage = Messages.CREATE_SUCCESS;
+  failureMessage = Messages.CREATE_FAILED;
+  async handle(args, options) {
     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();
-    }
+    const config2 = await getConfig(options, directory, true);
+    const type = getCreateTypeInput(args);
+    const name = await getCreateNameInputOrAsk(options);
+    const isServer = getServerInput(options);
+    const path = getPathInputWithDefault(
+      options,
+      config2[isServer ? "server" : "client"].dirs[type === "component" ? "components" : "systems"]
+    );
+    await this.generateElement(directory, type, {
+      name,
+      directory: path,
+      part: isServer ? "server" : "client",
+      language: config2.language
+    });
+    return {};
+  }
+  async generateElement(directory, type, values) {
+    const collection = CollectionFactory.create("@nanoforge-dev/schematics" /* NANOFORGE */, directory);
+    await executeSchematic(capitalize(type), collection, type, values);
+  }
+};
+
+// src/action/actions/dev.action.ts
+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) {
+    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);
+    });
+  }
+};
+
+// src/action/actions/generate.action.ts
+import { join as join6 } from "path";
+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) {
+    const directory = getDirectoryInput(options);
+    const config2 = await getConfig(options, directory);
+    const isEditor = getEditorInput(options);
+    const isWatch = getWatchInput(options);
+    await this.generateParts(config2, directory, isEditor, isWatch);
+    if (isWatch) {
+      return this.enterWatchMode();
+    }
     return {};
   }
   extractValues(config2) {
     return {
-      name: config2.name,
       directory: ".",
       language: config2.language,
-      server: config2.server.enable,
       initFunctions: config2.initFunctions
     };
   }
-  async generateParts(values, directory, watch3) {
+  async generateParts(config2, directory, isEditor, watch3) {
     const collection = CollectionFactory.create("@nanoforge-dev/schematics" /* NANOFORGE */, directory);
-    const baseOptions = this.baseSchematicOptions(values);
-    await executeSchematic(
-      "Client main file",
-      collection,
-      "part-main",
-      { ...baseOptions, part: "client" },
-      watch3 ? this.watchPath(directory, values.directory, "client") : void 0
-    );
-    if (values.server) {
+    const values = this.extractValues(config2);
+    if (config2.client.enable)
+      await executeSchematic(
+        "Client main file",
+        collection,
+        "part-main",
+        {
+          ...values,
+          part: "client",
+          outFile: !isEditor ? config2.client.build.entry : config2.client.editor.entry,
+          saveFile: config2.client.editor.save,
+          editor: isEditor
+        },
+        watch3 ? this.watchPath(directory, values.directory, config2.client.editor.save) : void 0
+      );
+    if (config2.server.enable)
       await executeSchematic(
         "Server main file",
         collection,
         "part-main",
-        { ...baseOptions, part: "server" },
-        this.watchPath(directory, values.directory, "server")
+        {
+          ...values,
+          part: "server",
+          outFile: !isEditor ? config2.server.build.entry : config2.server.editor.entry,
+          saveFile: config2.server.editor.save,
+          editor: isEditor
+        },
+        this.watchPath(directory, values.directory, config2.server.editor.save)
       );
-    }
   }
-  baseSchematicOptions(values) {
-    return {
-      name: values.name,
-      directory: values.directory,
-      language: values.language,
-      initFunctions: values.initFunctions
-    };
-  }
-  watchPath(directory, subDir, part) {
-    return join5(getCwd(directory), subDir, NANOFORGE_DIR, `${part}.save.json`);
+  watchPath(directory, subDir, saveFile) {
+    return join6(getCwd(directory), subDir, saveFile);
   }
   enterWatchMode() {
     console.info();
@@ -1449,6 +1898,310 @@ var GenerateAction = class extends AbstractAction {
   }
 };
 
+// src/action/actions/install.action.ts
+import { join as join8 } 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, "GlobalConfigHandler");
+  }
+  static read(dir) {
+    const localConfig = this._readConfig(read, false, dir);
+    if (localConfig) return localConfig;
+    return this._readConfig(readUser, true);
+  }
+  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;
+    }
+    return deepMerge(GLOBAL_CONFIG_DEFAULTS, res);
+  }
+};
+
+// 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/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/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
+      }
+    })
+  );
+}, "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)
+  );
+}, "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/registry/registry.ts
+import fs4 from "fs";
+import { join as join7 } 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 = join7(dir, this.getTypeSubFolder(manifest.type));
+    fs4.mkdirSync(path, { recursive: true });
+    fs4.writeFileSync(join7(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 = join7(getCwd(dir ?? "."), filename);
+    if (!fs4.existsSync(path))
+      throw new Error(
+        "Package not found, please specify path in the nanoforge.manifest.json : `publish.paths.package`!"
+      );
+    try {
+      fs4.accessSync(path, fs4.constants.R_OK);
+      return fs4.openAsBlob(path);
+    } catch {
+      throw new Error("Cannot read package file, please verify your file permissions!");
+    }
+  }
+};
+
 // src/action/actions/install.action.ts
 var InstallAction = class extends AbstractAction {
   static {
@@ -1460,114 +2213,78 @@ var InstallAction = class extends AbstractAction {
   async handle(args, options) {
     const names = await getInstallNamesInputOrAsk(args);
     const directory = getDirectoryInput(options);
+    const isLib = getInstallLibInput(options);
+    const isServer = getServerInput(options);
+    return isLib ? this._installLibs(directory, names) : this._installNfPackages(directory, names, isServer);
+  }
+  async _installLibs(directory, names) {
     const packageManager = await PackageManagerFactory.find(directory);
-    const success2 = await packageManager.addProduction(directory, names);
-    return { success: success2 };
+    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),
+        join8(directory, isServer ? "server" : "client")
+      );
+    });
   }
 };
 
-// src/action/actions/new.action.ts
-import { join as join6 } from "path";
-
-// src/lib/input/inputs/new/docker.input.ts
-var getDockerInput = /* @__PURE__ */ __name((inputs) => {
-  return getBooleanInput(inputs, "docker");
-}, "getDockerInput");
-var getDockerOrAsk = /* @__PURE__ */ __name((inputs) => {
-  return getInputOrAsk(
-    getDockerInput(inputs),
-    () => askConfirm(Messages.NEW_DOCKER_QUESTION, { default: true })
-  );
-}, "getDockerOrAsk");
-
-// src/lib/input/inputs/new/init-functions.input.ts
-var getNewInitFunctionsWithDefault = /* @__PURE__ */ __name((inputs) => {
-  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/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" }],
+// 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(
       {
-        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");
+        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 join9 } from "path";
 var NewAction = class extends AbstractAction {
   static {
     __name(this, "NewAction");
@@ -1576,26 +2293,31 @@ var NewAction = class extends AbstractAction {
   successMessage = Messages.NEW_SUCCESS;
   failureMessage = Messages.NEW_FAILED;
   async handle(_args, options) {
-    const directory = getDirectoryInput(options);
+    const cwdDirectory = getDirectoryInput(options);
     const values = await this.collectValues(options);
-    await this.scaffold(values, directory);
+    await this.scaffold(values, cwdDirectory);
     let res = true;
     if (!values.skipInstall) {
-      res = await this.installDependencies(values.packageManager, join6(directory, values.name));
+      res = await this.installDependencies(
+        values.packageManager,
+        join9(cwdDirectory, values.directory ?? values.name)
+      );
     }
     return { success: res };
   }
   async collectValues(inputs) {
     return {
       name: await getNewNameInputOrAsk(inputs),
-      directory: getNewPathInput(inputs),
+      directory: getPathInput(inputs),
       packageManager: await getNewPackageManagerInputOrAsk(inputs),
       language: await getNewLanguageInputOrAsk(inputs),
       strict: await getNewStrictOrAsk(inputs),
       server: await getNewServerOrAsk(inputs),
       initFunctions: getNewInitFunctionsWithDefault(inputs),
       skipInstall: await getNewSkipInstallOrAsk(inputs),
-      docker: await getDockerOrAsk(inputs)
+      docker: await getNewDockerOrAsk(inputs),
+      lint: getNewLintInput(inputs),
+      editor: getEditorInput(inputs)
     };
   }
   async scaffold(values, directory) {
@@ -1617,14 +2339,18 @@ var NewAction = class extends AbstractAction {
       packageManager: values.packageManager,
       language: values.language,
       strict: values.strict,
-      server: values.server
+      server: values.server,
+      lint: values.lint,
+      editor: values.editor
     });
   }
   generateConfiguration(collection, values) {
     return executeSchematic("Configuration", collection, "configuration", {
       name: values.name,
-      directory: values.directory,
-      server: values.server
+      directory: values.directory ?? values.name,
+      server: values.server,
+      language: values.language,
+      initFunctions: values.initFunctions
     });
   }
   async generateClientParts(collection, values) {
@@ -1633,7 +2359,9 @@ var NewAction = class extends AbstractAction {
       ...partOptions,
       server: values.server
     });
-    await executeSchematic("Client main file", collection, "part-main", partOptions);
+    await executeSchematic("Client main file", collection, "part-main", {
+      ...partOptions
+    });
   }
   async generateServerParts(collection, values) {
     const partOptions = this.partOptions(values, "server");
@@ -1641,20 +2369,20 @@ var NewAction = class extends AbstractAction {
       ...partOptions,
       server: values.server
     });
-    await executeSchematic("Server main file", collection, "part-main", partOptions);
+    await executeSchematic("Server main file", collection, "part-main", {
+      ...partOptions
+    });
   }
   async generateDocker(collection, values) {
     await executeSchematic("Docker", collection, "docker", {
-      name: values.name,
-      directory: values.directory,
+      directory: values.directory ?? values.name,
       packageManager: values.packageManager
     });
   }
   partOptions(values, part) {
     return {
-      name: values.name,
       part,
-      directory: values.directory,
+      directory: values.directory ?? values.name,
       language: values.language,
       initFunctions: values.initFunctions
     };
@@ -1665,8 +2393,149 @@ var NewAction = class extends AbstractAction {
   }
 };
 
+// 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;
+  tags;
+  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 }),
+  IsOptional()
+], Manifest.prototype, "tags", 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 existsSync3, readFileSync as readFileSync2 } from "fs";
+import { join as join10 } from "path";
+var getManifestPath = /* @__PURE__ */ __name((directory) => {
+  for (const n of [MANIFEST_FILE_NAME]) {
+    const path = join10(directory, n);
+    if (existsSync3(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 {
+    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);
+    });
+  }
+};
+
 // src/action/actions/start.action.ts
-import { join as join7 } from "path";
+import dotenv from "dotenv";
+import { join as join11, resolve as resolve3 } from "path";
 var StartAction = class extends AbstractAction {
   static {
     __name(this, "StartAction");
@@ -1677,20 +2546,21 @@ var StartAction = class extends AbstractAction {
   async handle(_args, options) {
     const directory = getDirectoryInput(options);
     const config2 = await getConfig(options, directory);
+    const clientDir = getStringInputWithDefault(options, "clientDir", config2.client.outDir);
+    const serverDir = getStringInputWithDefault(options, "serverDir", config2.server.outDir);
     const watch3 = getWatchInput(options);
-    const ports = this.resolvePorts(options, config2);
+    const port = getStringInputWithDefault(options, "port", config2.client.port);
     const ssl = this.resolveSSL(options);
-    const tasks = this.buildStartTasks(config2, directory, watch3, ports, ssl);
+    const tasks = this.buildStartTasks(config2, directory, {
+      clientDir,
+      serverDir,
+      watch: watch3,
+      port,
+      ssl
+    });
     await Promise.all(tasks);
     return { keepAlive: true };
   }
-  resolvePorts(options, config2) {
-    return {
-      clientPort: getStringInputWithDefault(options, "clientPort", config2.client.port),
-      gameExposurePort: getStringInput(options, "gameExposurePort"),
-      serverPort: getStringInput(options, "serverPort")
-    };
-  }
   resolveSSL(options) {
     const cert = getStringInput(options, "cert");
     const key = getStringInput(options, "key");
@@ -1702,53 +2572,100 @@ var StartAction = class extends AbstractAction {
       key
     };
   }
-  buildStartTasks(config2, directory, watch3, ports, ssl) {
+  buildStartTasks(config2, directory, options) {
+    const env2 = this.parseEnv(directory);
     const tasks = [];
-    if (config2.server.enable) {
-      tasks.push(this.startServer(directory, config2.server.runtime.dir, watch3, ports.serverPort));
-    }
-    tasks.push(this.startClient(directory, config2, watch3, ports, ssl));
+    const { clientDir, serverDir, watch: watch3, port, ssl } = options;
+    if (config2.server.enable)
+      tasks.push(this.startServer(directory, config2, { serverDir, watch: watch3 }, env2));
+    if (config2.client.enable)
+      tasks.push(
+        this.startClient(directory, config2, { clientDir, serverDir, watch: watch3, port, ssl }, env2)
+      );
     return tasks;
   }
-  async startClient(directory, config2, watch3, ports, ssl) {
+  async startClient(directory, config2, options, env2) {
     const loaderPath = getModulePath("@nanoforge-dev/loader-client/package.json", true);
-    const gameDir = config2.client.runtime.dir;
-    const env2 = this.buildClientEnv(directory, gameDir, watch3, config2, ports, ssl);
-    await this.runLoader("Client", loaderPath, env2);
-  }
-  buildClientEnv(directory, gameDir, watch3, config2, ports, ssl) {
-    const env2 = {
-      PORT: ports.clientPort,
-      GAME_DIR: getCwd(join7(directory, gameDir))
+    const params = this.buildClientParams(directory, config2, options);
+    await this.runLoader("Client", loaderPath, params, env2.client);
+  }
+  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 = {
+      "-d": getCwd(join11(directory, options.clientDir)),
+      "-p": options.port
     };
-    if (ports.gameExposurePort) {
-      env2["GAME_EXPOSURE_PORT"] = ports.gameExposurePort;
-    }
-    if (watch3) {
-      env2["WATCH"] = "true";
+    if (options.watch) params["--watch"] = true;
+    if (options.watch) {
+      params["--watch"] = true;
       if (config2.server.enable) {
-        env2["WATCH_SERVER_GAME_DIR"] = getCwd(join7(directory, config2.server.runtime.dir));
+        params["--watch-server-dir"] = getCwd(join11(directory, options.serverDir));
       }
     }
-    if (ssl) {
-      env2["CERT"] = ssl.cert;
-      env2["KEY"] = ssl.key;
+    if (options.ssl) {
+      params["--cert"] = options.ssl.cert;
+      params["--key"] = options.ssl.key;
     }
-    return env2;
+    return this.buildParams(params);
   }
-  async startServer(directory, gameDir, watch3, port) {
-    const loaderPath = getModulePath("@nanoforge-dev/loader-server/package.json", true);
-    const env2 = {
-      GAME_DIR: getCwd(join7(directory, gameDir))
+  buildServerParams(directory, _config, options) {
+    const params = {
+      "-d": getCwd(join11(directory, options.serverDir))
+    };
+    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
+    };
+    dotenv.config({
+      path: resolve3(getCwd(join11(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])
+      )
     };
-    if (port) env2["PORT"] = port;
-    if (watch3) env2["WATCH"] = "true";
-    await this.runLoader("Server", loaderPath, env2);
   }
-  async runLoader(name, directory, env2) {
+  async runLoader(name, directory, params, env2) {
     await runSafe(async () => {
       const packageManager = await PackageManagerFactory.find(directory);
-      await packageManager.run(name, directory, "start", env2, [], true);
+      await packageManager.run(name, directory, "start", params, env2, [], true);
+    });
+  }
+};
+
+// src/action/actions/unpublish.action.ts
+var UnpublishAction = class extends AbstractAction {
+  static {
+    __name(this, "UnpublishAction");
+  }
+  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);
     });
   }
 };
@@ -1758,6 +2675,7 @@ var AbstractCommand = class {
   constructor(action) {
     this.action = action;
   }
+  action;
   static {
     __name(this, "AbstractCommand");
   }
@@ -1776,12 +2694,17 @@ var BuildCommand = class extends AbstractCommand {
     __name(this, "BuildCommand");
   }
   load(program2) {
-    program2.command("build").description("build your game").option("-d, --directory [directory]", "specify the directory of your project").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("--client-outDir [clientDirectory]", "specify the output directory of the client").option("--server-outDir [serverDirectory]", "specify the output directory of the server").option("--watch", "build app in watching mode", false).action(async (rawOptions) => {
+    program2.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-entry [clientEntry]", "specify the entry file of the client").option("--server-entry [serverEntry]", "specify the entry file of the server").option("--client-static-dir [clientStaticDir]", "specify the static directory of the client").option("--server-static-dir [serverStaticDir]", "specify the static directory of the server").option("--client-out-dir [clientOutDir]", "specify the output directory of the client").option("--server-out-dir [serverOutDir]", "specify the output directory of the server").option("--editor", "specify if the project must build with editor config").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,
+        clientEntry: rawOptions.clientEntry,
+        serverEntry: rawOptions.serverEntry,
+        clientStaticDir: rawOptions.clientStaticDir,
+        serverStaticDir: rawOptions.serverStaticDir,
+        clientOutDir: rawOptions.clientOutDir,
+        serverOutDir: rawOptions.serverOutDir,
+        editor: rawOptions.editor,
         watch: rawOptions.watch
       });
       await this.action.run(/* @__PURE__ */ new Map(), options);
@@ -1789,13 +2712,42 @@ var BuildCommand = class extends AbstractCommand {
   }
 };
 
+// src/command/commands/create.command.ts
+var CreateCommand = class extends AbstractCommand {
+  static {
+    __name(this, "CreateCommand");
+  }
+  load(program2) {
+    program2.command("create [type]").description("create nanoforge components or systems").option("-d, --directory [directory]", "specify the working directory of the command").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("-n, --name [name]", "name of the component/system").option(
+      "-s, --server",
+      "install components/systems on server (default install on client)",
+      false
+    ).option(
+      "-p, --path [path]",
+      "path to the component/system folder (default: [part]/<components|systems>)"
+    ).action(async (type, rawOptions) => {
+      const args = AbstractCommand.mapToInput({
+        type
+      });
+      const options = AbstractCommand.mapToInput({
+        directory: rawOptions.directory,
+        config: rawOptions.config,
+        name: rawOptions.name,
+        server: rawOptions.server,
+        path: rawOptions.path
+      });
+      await this.action.run(args, options);
+    });
+  }
+};
+
 // src/command/commands/dev.command.ts
 var DevCommand = class extends AbstractCommand {
   static {
     __name(this, "DevCommand");
   }
   load(program2) {
-    program2.command("dev").description("run your game in dev mode").option("-d, --directory [directory]", "specify the directory of your project").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("--generate", "generate app from config", false).action(async (rawOptions) => {
+    program2.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,
@@ -1812,10 +2764,11 @@ var GenerateCommand = class extends AbstractCommand {
     __name(this, "GenerateCommand");
   }
   load(program2) {
-    program2.command("generate").description("generate nanoforge files from config").option("-d, --directory [directory]", "specify the directory of your project").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("--watch", "generate app in watching mode", false).action(async (rawOptions) => {
+    program2.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("--editor", "specify if the project must generate editor main file").option("--watch", "generate app in watching mode", false).action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         config: rawOptions.config,
+        editor: rawOptions.editor,
         watch: rawOptions.watch
       });
       await this.action.run(/* @__PURE__ */ new Map(), options);
@@ -1829,9 +2782,15 @@ var InstallCommand = class extends AbstractCommand {
     __name(this, "InstallCommand");
   }
   load(program2) {
-    program2.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) => {
+    program2.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
+        directory: rawOptions.directory,
+        lib: rawOptions.lib,
+        server: rawOptions.server
       });
       const args = AbstractCommand.mapToInput({
         names: names.length ? names : void 0
@@ -1841,13 +2800,49 @@ var InstallCommand = class extends AbstractCommand {
   }
 };
 
+// src/command/commands/login.command.ts
+var LoginCommand = class extends AbstractCommand {
+  static {
+    __name(this, "LoginCommand");
+  }
+  load(program2) {
+    program2.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(program2) {
+    program2.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);
+    });
+  }
+};
+
 // src/command/commands/new.command.ts
 var NewCommand = class extends AbstractCommand {
   static {
     __name(this, "NewCommand");
   }
   load(program2) {
-    program2.command("new").description("create a new nanoforge project").option("-d, --directory [directory]", "specify the directory of your project").option("--name [name]", "specify the name of your project").option("--path [path]", "specify the path of your project").option("--package-manager [packageManager]", "specify the package manager of your project").option("--language [language]", "specify the language of your project").option("--strict", "use strict mode").option("--no-strict", "do not use strict mode").option("--server", "create a server").option("--no-server", "do not create a server").option("--init-functions", "initialize functions").option("--no-init-functions", "do not initialize functions").option("--skip-install", "skip installing dependencies").option("--no-skip-install", "do not skip installing dependencies").option("--docker", "generate docker files").option("--no-docker", "do not generate docker files").action(async (rawOptions) => {
+    program2.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").option("--editor", "do add editor dependencies").action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         name: rawOptions.name,
@@ -1858,7 +2853,24 @@ var NewCommand = class extends AbstractCommand {
         server: rawOptions.server,
         initFunctions: rawOptions.initFunctions,
         skipInstall: rawOptions.skipInstall,
-        docker: rawOptions.docker
+        docker: rawOptions.docker,
+        lint: rawOptions.lint,
+        editor: rawOptions.editor
+      });
+      await this.action.run(/* @__PURE__ */ new Map(), options);
+    });
+  }
+};
+
+// src/command/commands/publish.command.ts
+var PublishCommand = class extends AbstractCommand {
+  static {
+    __name(this, "PublishCommand");
+  }
+  load(program2) {
+    program2.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);
     });
@@ -1871,16 +2883,13 @@ var StartCommand = class extends AbstractCommand {
     __name(this, "StartCommand");
   }
   load(program2) {
-    program2.command("start").description("start your game").option("-d, --directory [directory]", "specify the directory of your project").option("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option(
-      "-p, --client-port [clientPort]",
-      "specify the port of the loader (the website to load the game)"
-    ).option("--game-exposure-port [gameExposurePort]", "specify the port of the game exposure").option("--server-port [serverPort]", "specify the port of the server").option("--watch", "run app in watching mode", false).option("--cert [cert]", "path to the SSL certificate for HTTPS").option("--key [key]", "path to the SSL key for HTTPS").action(async (rawOptions) => {
+    program2.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("--client-dir [clientDirectory]", "specify the directory of the client").option("--server-dir [serverDirectory]", "specify the directory of the server").option("--watch", "run app in watching mode", false).option("--cert [cert]", "path to the SSL certificate for HTTPS").option("--key [key]", "path to the SSL key for HTTPS").action(async (rawOptions) => {
       const options = AbstractCommand.mapToInput({
         directory: rawOptions.directory,
         config: rawOptions.config,
-        clientPort: rawOptions.clientPort,
-        gameExposurePort: rawOptions.gameExposurePort,
-        serverPort: rawOptions.serverPort,
+        port: rawOptions.port,
+        clientDir: rawOptions.clientDir,
+        serverDir: rawOptions.serverDir,
         watch: rawOptions.watch,
         cert: rawOptions.cert,
         key: rawOptions.key
@@ -1890,18 +2899,38 @@ var StartCommand = class extends AbstractCommand {
   }
 };
 
+// src/command/commands/unpublish.command.ts
+var UnpublishCommand = class extends AbstractCommand {
+  static {
+    __name(this, "UnpublishCommand");
+  }
+  load(program2) {
+    program2.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);
+    });
+  }
+};
+
 // src/command/command.loader.ts
 var CommandLoader = class {
   static {
     __name(this, "CommandLoader");
   }
   static async load(program2) {
+    new NewCommand(new NewAction()).load(program2);
+    new InstallCommand(new InstallAction()).load(program2);
     new BuildCommand(new BuildAction()).load(program2);
+    new StartCommand(new StartAction()).load(program2);
     new DevCommand(new DevAction()).load(program2);
     new GenerateCommand(new GenerateAction()).load(program2);
-    new InstallCommand(new InstallAction()).load(program2);
-    new NewCommand(new NewAction()).load(program2);
-    new StartCommand(new StartAction()).load(program2);
+    new CreateCommand(new CreateAction()).load(program2);
+    new LoginCommand(new LoginAction()).load(program2);
+    new LogoutCommand(new LogoutAction()).load(program2);
+    new PublishCommand(new PublishAction()).load(program2);
+    new UnpublishCommand(new UnpublishAction()).load(program2);
     this.handleInvalidCommand(program2);
   }
   static handleInvalidCommand(program2) {
@@ -1917,6 +2946,14 @@ ${Prefixes.ERROR} Invalid command: ${red6`%s`}`, program2.args.join(" "));
 
 // src/bin/nf.ts
 var bootstrap = /* @__PURE__ */ __name(async () => {
+  const signals = ["SIGINT", "SIGTERM", "SIGHUP", "SIGQUIT", "SIGBREAK"];
+  signals.forEach((signal) => {
+    const listener = /* @__PURE__ */ __name(async () => {
+      process.off(signal, listener);
+      await treeKill(process.pid, signal);
+    }, "listener");
+    process.on(signal, listener);
+  });
   program.version(
     (await Promise.resolve().then(() => __toESM(require_package(), 1))).version ?? "unknown",
     "-v, --version",