@nanoforge-dev/cli 1.2.0 → 1.3.0

package/dist/command.loader.js

@@ -56,6 +56,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!"),
@@ -83,6 +93,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"),
@@ -172,16 +192,28 @@ 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 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));
@@ -265,6 +297,134 @@ var getInstallNamesInputOrAsk = /* @__PURE__ */ __name((inputs) => {
   );
 }, "getInstallNamesInputOrAsk");
 
+// src/lib/input/inputs/install/server.input.ts
+function getInstallServerInput(inputs) {
+  return getBooleanInputWithDefault(inputs, "server", false);
+}
+__name(getInstallServerInput, "getInstallServerInput");
+
+// 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/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";
 
@@ -312,6 +472,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) {
@@ -324,7 +499,7 @@ var PackageManager = class {
   }
   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") });
@@ -352,7 +527,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") });
@@ -361,10 +536,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: {
@@ -381,32 +556,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") });
@@ -421,11 +585,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, {
@@ -478,12 +644,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) => {
+    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) {
-          resolve3(this.formatOutput(output, collect));
+          resolve4(this.formatOutput(output, collect));
         } else {
           this.handleFailure(output, fullArgs, onFail);
           reject(this.createError(fullArgs, code));
@@ -598,6 +764,7 @@ var PM_CONFIGS = {
       remove: "uninstall",
       exec: "exec",
       run: "run",
+      runArgsFlag: "--",
       saveFlag: "--save",
       saveDevFlag: "--save-dev",
       silentFlag: "--silent"
@@ -722,7 +889,6 @@ var ClientConfig = class {
     __name(this, "ClientConfig");
   }
   port;
-  gameExposurePort;
   build;
   runtime;
 };
@@ -730,10 +896,6 @@ __decorateClass([
   Expose(),
   IsPort()
 ], ClientConfig.prototype, "port", 2);
-__decorateClass([
-  Expose(),
-  IsPort()
-], ClientConfig.prototype, "gameExposurePort", 2);
 __decorateClass([
   Expose(),
   Type(() => BuildConfig),
@@ -749,7 +911,6 @@ var ServerConfig = class {
     __name(this, "ServerConfig");
   }
   enable;
-  port;
   build;
   runtime;
 };
@@ -757,10 +918,6 @@ __decorateClass([
   Expose(),
   IsBoolean()
 ], ServerConfig.prototype, "enable", 2);
-__decorateClass([
-  Expose(),
-  IsPort()
-], ServerConfig.prototype, "port", 2);
 __decorateClass([
   Expose(),
   Type(() => BuildConfig),
@@ -813,7 +970,10 @@ 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) => {
@@ -834,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 = {
@@ -842,7 +1003,6 @@ var CONFIG_DEFAULTS = {
   initFunctions: true,
   client: {
     port: "3000",
-    gameExposurePort: "3001",
     build: {
       entryFile: "client/main.ts",
       outDir: ".nanoforge/client"
@@ -853,7 +1013,6 @@ var CONFIG_DEFAULTS = {
   },
   server: {
     enable: false,
-    port: "3002",
     build: {
       entryFile: "server/main.ts",
       outDir: ".nanoforge/server"
@@ -928,7 +1087,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);
@@ -1301,6 +1460,310 @@ var GenerateAction = class extends AbstractAction {
   }
 };
 
+// src/action/actions/install.action.ts
+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, "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 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/action/actions/install.action.ts
 var InstallAction = class extends AbstractAction {
   static {
@@ -1312,114 +1775,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 = getInstallServerInput(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),
+        join6(directory, isServer ? "server" : "client")
+      );
+    });
   }
 };
 
-// src/action/actions/new.action.ts
-import { join as join5 } from "path";
-
-// src/lib/input/inputs/new/docker.input.ts
-var getDockerInput = /* @__PURE__ */ __name((inputs) => {
-  return getBooleanInput(inputs, "docker");
-}, "getDockerInput");
-var getDockerOrAsk = /* @__PURE__ */ __name((inputs) => {
-  return getInputOrAsk(
-    getDockerInput(inputs),
-    () => askConfirm(Messages.NEW_DOCKER_QUESTION, { default: true })
-  );
-}, "getDockerOrAsk");
-
-// src/lib/input/inputs/new/init-functions.input.ts
-var getNewInitFunctionsWithDefault = /* @__PURE__ */ __name((inputs) => {
-  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 join7 } from "path";
 var NewAction = class extends AbstractAction {
   static {
     __name(this, "NewAction");
@@ -1428,12 +1855,15 @@ 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, join5(directory, values.name));
+      res = await this.installDependencies(
+        values.packageManager,
+        join7(cwdDirectory, values.directory ?? values.name)
+      );
     }
     return { success: res };
   }
@@ -1447,7 +1877,8 @@ var NewAction = class extends AbstractAction {
       server: await getNewServerOrAsk(inputs),
       initFunctions: getNewInitFunctionsWithDefault(inputs),
       skipInstall: await getNewSkipInstallOrAsk(inputs),
-      docker: await getDockerOrAsk(inputs)
+      docker: await getNewDockerOrAsk(inputs),
+      lint: getNewLintInput(inputs)
     };
   }
   async scaffold(values, directory) {
@@ -1469,7 +1900,8 @@ var NewAction = class extends AbstractAction {
       packageManager: values.packageManager,
       language: values.language,
       strict: values.strict,
-      server: values.server
+      server: values.server,
+      lint: values.lint
     });
   }
   generateConfiguration(collection, values) {
@@ -1517,8 +1949,143 @@ 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;
+  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 {
+    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 join6 } from "path";
+import dotenv from "dotenv";
+import { join as join9, resolve as resolve3 } from "path";
 var StartAction = class extends AbstractAction {
   static {
     __name(this, "StartAction");
@@ -1530,19 +2097,12 @@ var StartAction = class extends AbstractAction {
     const directory = getDirectoryInput(options);
     const config2 = await getConfig(options, directory);
     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, 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");
@@ -1554,53 +2114,97 @@ var StartAction = class extends AbstractAction {
       key
     };
   }
-  buildStartTasks(config2, directory, watch3, ports, ssl) {
+  buildStartTasks(config2, directory, watch3, port, ssl) {
+    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.startServer(directory, config2, { watch: watch3 }, env2));
     }
-    tasks.push(this.startClient(directory, config2, watch3, ports, ssl));
+    tasks.push(this.startClient(directory, config2, { 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(join6(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(join9(directory, config2.client.runtime.dir)),
+      "-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(join6(directory, config2.server.runtime.dir));
+        params["--watch-server-dir"] = getCwd(join9(directory, config2.server.runtime.dir));
       }
     }
-    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(join6(directory, gameDir))
+  buildServerParams(directory, config2, options) {
+    const params = {
+      "-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
+    };
+    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])
+      )
     };
-    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);
     });
   }
 };
@@ -1628,7 +2232,7 @@ 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", 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) => {
+    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,
@@ -1647,7 +2251,7 @@ 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("-c, --config [config]", "path to the config file", CONFIG_FILE_NAME).option("--generate", "generate app from config", false).action(async (rawOptions) => {
+    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,
@@ -1664,7 +2268,7 @@ 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", CONFIG_FILE_NAME).option("--watch", "generate app in watching mode", false).action(async (rawOptions) => {
+    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,
@@ -1681,9 +2285,15 @@ 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) => {
+    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
+        directory: rawOptions.directory,
+        lib: rawOptions.lib,
+        server: rawOptions.server
       });
       const args = AbstractCommand.mapToInput({
         names: names.length ? names : void 0
@@ -1693,13 +2303,49 @@ var InstallCommand = class extends AbstractCommand {
   }
 };
 
+// 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);
+    });
+  }
+};
+
 // src/command/commands/new.command.ts
 var NewCommand = class extends AbstractCommand {
   static {
     __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").option("--docker", "generate docker files").option("--no-docker", "do not generate docker files").action(async (rawOptions) => {
+    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,
@@ -1710,7 +2356,23 @@ var NewCommand = class extends AbstractCommand {
         server: rawOptions.server,
         initFunctions: rawOptions.initFunctions,
         skipInstall: rawOptions.skipInstall,
-        docker: rawOptions.docker
+        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);
     });
@@ -1723,16 +2385,11 @@ 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", 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) => {
+    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,
-        clientPort: rawOptions.clientPort,
-        gameExposurePort: rawOptions.gameExposurePort,
-        serverPort: rawOptions.serverPort,
+        port: rawOptions.port,
         watch: rawOptions.watch,
         cert: rawOptions.cert,
         key: rawOptions.key
@@ -1742,18 +2399,37 @@ var StartCommand = class extends AbstractCommand {
   }
 };
 
+// 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);
+    });
+  }
+};
+
 // src/command/command.loader.ts
 var CommandLoader = class {
   static {
     __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) {