@devbro/pashmak 0.1.8 → 0.1.10

package/dist/app/console/project/CreateProjectCommand.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/app/console/project/CreateProjectCommand.mts"],"sourcesContent":["import { Command, Option } from \"clipanion\";\nimport { Case } from \"change-case-all\";\nimport path from \"path\";\nimport * as fs from \"fs/promises\";\nimport { fileURLToPath } from \"url\";\nimport handlebars from \"handlebars\";\nimport { execSync } from \"child_process\";\n\nexport class CreateProjectCommand extends Command {\n  static paths = [[`create`, `project`]];\n\n  static usage = Command.Usage({\n    category: `Project`,\n    description: `Create a new project`,\n    details: `\n      This command creates a new project with the specified name at the given path.\n      If no path is provided, the project will be created in the current directory.\n    `,\n    examples: [\n      [\n        `Create a new project in specified directory`,\n        `create project --path /path/to/my-project --git`,\n      ],\n      [\n        `Create a new project at a specific path with git initialized`,\n        `create project --path /path/to/my-project --git`,\n      ],\n    ],\n  });\n\n  projectPath = Option.String(\"--path\", { required: true });\n\n  git = Option.Boolean(`--git`, false, {\n    description: `Initialize a git repository in the new project`,\n  });\n\n  async folderExists(folderPath: string): Promise<boolean> {\n    try {\n      const stats = await fs.stat(folderPath);\n      return stats.isDirectory();\n    } catch (error: any) {\n      if (error.code === \"ENOENT\") {\n        return false; // Folder does not exist\n      }\n      throw error; // Other errors (e.g., permission issues)\n    }\n  }\n\n  async execute() {\n    // Create the project directory path by joining the specified path and project name\n    const projectPath = path.join(this.projectPath);\n    // Check if directory already exists\n    try {\n      await fs.access(projectPath);\n      console.error(`Error: Directory ${projectPath} already exists.`);\n      return 1;\n    } catch {\n      // Directory doesn't exist, we can proceed\n    }\n\n    await fs.mkdir(projectPath, { recursive: true });\n    console.log(`Created project directory at: ${projectPath}`);\n\n    const dirname =\n      typeof __dirname === \"undefined\"\n        ? path.dirname(fileURLToPath(import.meta.url))\n        : __dirname;\n\n    let basePath = path.join(dirname, `./base_project`);\n    if ((await this.folderExists(basePath)) === false) {\n      // we are running a compiled code that was bundled and the code is running from ./dist/bin/ folder.\n      basePath = path.join(dirname, `../app/console/project/base_project`);\n    }\n\n    console.log(`Using base project path: ${basePath}`);\n    //copy content of ./base_project to the new project directory\n    const baseProjectPath = basePath;\n\n    await this.processTplFolder(baseProjectPath, projectPath, {});\n    console.log(`Copied base project files to: ${projectPath}`);\n\n    //modify package.json with foldername\n    const packageJsonPath = path.join(projectPath, `package.json`);\n    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, `utf-8`));\n    packageJson.name = Case.snake(path.basename(projectPath));\n    await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2));\n    console.log(`Updated package.json with project name: ${packageJson.name}`);\n\n    if (this.git) {\n      try {\n        execSync(\n          'git init; git add --all; git commit --allow-empty -m \"chore: first commit for pashmak\"',\n          {\n            cwd: projectPath,\n          },\n        );\n      } catch (error) {\n        console.error(`Failed to create project.`, error);\n        return 1;\n      }\n    }\n  }\n\n  async processTplFolder(src: string, dest: string, data: any = {}) {\n    const files = await fs.readdir(src, { withFileTypes: true });\n    for (const file of files) {\n      const srcPath = path.join(src, file.name);\n      const destPath =\n        file.isFile() && file.name.endsWith(\".tpl\")\n          ? path.join(dest, file.name.substring(0, file.name.length - 4))\n          : path.join(dest, file.name);\n\n      if (file.isDirectory()) {\n        await fs.mkdir(destPath, { recursive: true });\n        await this.processTplFolder(srcPath, destPath, data);\n      } else if (file.name.endsWith(\".tpl\")) {\n        await this.processTplFile(srcPath, destPath, {});\n      } else {\n        throw new Error(\n          \"unexpected non tpl file: \" + srcPath + \" \" + file.name,\n        );\n      }\n    }\n  }\n\n  async processTplFile(src: string, dest: string, data: any = {}) {\n    const compiledTemplate = handlebars.compile(\n      (await fs.readFile(src)).toString(),\n    );\n    const template = await compiledTemplate(data);\n    await fs.writeFile(dest, template);\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/bin/DatabaseServiceProvider.cjs

@@ -0,0 +1,88 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/DatabaseServiceProvider.mts
+var DatabaseServiceProvider_exports = {};
+__export(DatabaseServiceProvider_exports, {
+  DatabaseServiceProvider: () => DatabaseServiceProvider
+});
+module.exports = __toCommonJS(DatabaseServiceProvider_exports);
+
+// ../neko-router/dist/Middleware.mjs
+var Middleware = class {
+  static {
+    __name(this, "Middleware");
+  }
+  constructor(params = {}) {
+  }
+  static getInstance(params) {
+    throw new Error("Method not implemented. Please implement a static getInstance method.");
+  }
+};
+
+// src/DatabaseServiceProvider.mts
+var import_neko_sql = require("@devbro/neko-sql");
+var import_neko_orm = require("@devbro/neko-orm");
+var import_neko_context = require("@devbro/neko-context");
+var import_neko_config = require("@devbro/neko-config");
+var DatabaseServiceProvider = class _DatabaseServiceProvider extends Middleware {
+  static {
+    __name(this, "DatabaseServiceProvider");
+  }
+  async call(req, res, next) {
+    const db_configs = import_neko_config.config.get("databases");
+    const conns = [];
+    try {
+      for (const [name, db_config] of Object.entries(db_configs)) {
+        const conn = await this.getConnection(db_config);
+        (0, import_neko_context.ctx)().set(["database", name], conn);
+        conns.push(conn);
+      }
+      import_neko_orm.BaseModel.setConnection(
+        () => (0, import_neko_context.ctx)().getOrThrow(["database", "default"])
+      );
+      await next();
+    } finally {
+      for (const conn of conns) {
+        await conn.disconnect();
+      }
+    }
+  }
+  static instance;
+  async register() {
+  }
+  static getInstance() {
+    if (!_DatabaseServiceProvider.instance) {
+      _DatabaseServiceProvider.instance = new _DatabaseServiceProvider();
+    }
+    return _DatabaseServiceProvider.instance;
+  }
+  async getConnection(db_config) {
+    const conn = new import_neko_sql.PostgresqlConnection(db_config);
+    if (!await conn.connect()) {
+      throw new Error("Failed to connect to the database");
+    }
+    return conn;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DatabaseServiceProvider
+});

package/dist/bin/app/console/DefaultCommand.cjs

@@ -0,0 +1,508 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/app/console/DefaultCommand.mts
+var DefaultCommand_exports = {};
+__export(DefaultCommand_exports, {
+  DefaultCommand: () => DefaultCommand
+});
+module.exports = __toCommonJS(DefaultCommand_exports);
+var import_clipanion2 = require("clipanion");
+
+// src/router.mts
+var import_neko_context = require("@devbro/neko-context");
+var import_errors = require("@devbro/neko-http/errors");
+
+// ../neko-router/dist/Middleware.mjs
+var Middleware = class {
+  static {
+    __name(this, "Middleware");
+  }
+  constructor(params = {}) {
+  }
+  static getInstance(params) {
+    throw new Error("Method not implemented. Please implement a static getInstance method.");
+  }
+};
+
+// ../neko-router/dist/MiddlewareFactory.mjs
+var MiddlewareFactory = class {
+  static {
+    __name(this, "MiddlewareFactory");
+  }
+  static create(func) {
+    const cls = class extends Middleware {
+      static {
+        __name(this, "cls");
+      }
+      call(req, res, next) {
+        return func(req, res, next);
+      }
+      constructor(params = {}) {
+        super(params);
+      }
+    };
+    return new cls();
+  }
+};
+
+// ../neko-router/dist/CompiledRoute.mjs
+var CompiledRoute = class {
+  static {
+    __name(this, "CompiledRoute");
+  }
+  constructor(route, request, response, globalMiddlewares = []) {
+    this.route = route;
+    this.request = request;
+    this.response = response;
+    this.globalMiddlewares = globalMiddlewares;
+    this.prepareMiddlewares();
+  }
+  middlewares = [];
+  getMiddlewares() {
+    return this.middlewares;
+  }
+  prepareMiddlewares() {
+    this.middlewares = [];
+    for (const middleware of [...this.globalMiddlewares, ...this.route.getMiddlewares()]) {
+      if (middleware instanceof Middleware) {
+        this.middlewares.push(middleware);
+      } else if (this.isClass(middleware)) {
+        this.middlewares.push(middleware.getInstance({}));
+      } else if (typeof middleware === "function") {
+        this.middlewares.push(MiddlewareFactory.create(middleware));
+      } else {
+        throw new Error("Invalid middleware type");
+      }
+    }
+  }
+  isClass(func) {
+    return typeof func === "function" && /^class\s/.test(Function.prototype.toString.call(func));
+  }
+  async run() {
+    return await this.runMiddlewares(this.middlewares, this.request, this.response);
+  }
+  prepareOutputJsonFormat(obj) {
+    function traverse(value) {
+      if (!value || typeof value !== "object") {
+        return value;
+      }
+      if (typeof value.toJson === "function") {
+        return traverse(value.toJson());
+      }
+      if (Array.isArray(value)) {
+        return value.map(traverse);
+      }
+      const result = {};
+      for (const key in value) {
+        if (Object.prototype.hasOwnProperty.call(value, key)) {
+          result[key] = traverse(value[key]);
+        }
+      }
+      return result;
+    }
+    __name(traverse, "traverse");
+    return traverse(obj);
+  }
+  convertToString(obj) {
+    if (typeof obj === "string") {
+      return obj;
+    } else if (obj instanceof Buffer) {
+      return obj.toString();
+    } else if (typeof obj === "object") {
+      return JSON.stringify(this.prepareOutputJsonFormat(obj));
+    }
+    return String(obj);
+  }
+  processResponseBody(res, controller_rc) {
+    if (controller_rc && res.writableEnded) {
+      throw new Error("cannot write to response, response has already ended");
+    }
+    if (res.writableEnded) {
+      return;
+    }
+    if (controller_rc) {
+      const header_content_type = res.getHeader("Content-Type");
+      if (!header_content_type && typeof controller_rc === "object") {
+        res.setHeader("Content-Type", "application/json");
+      } else if (!header_content_type) {
+        res.setHeader("Content-Type", "text/plain");
+      }
+      res.end(this.convertToString(controller_rc));
+      return;
+    } else {
+      res.statusCode = [200].includes(res.statusCode) ? 204 : res.statusCode;
+      res.end();
+    }
+  }
+  async runMiddlewares(middlewares, req, res) {
+    let index = 0;
+    const me = this;
+    async function next() {
+      if (index >= middlewares.length) {
+        const controller_rc = await me.route.callHanlder(req, res);
+        await me.processResponseBody(res, controller_rc);
+        return;
+      }
+      const middleware = middlewares[index++];
+      if (middleware instanceof Middleware) {
+        await middleware.call(req, res, next);
+      } else if (typeof middleware === "function") {
+        await middleware(req, res, next);
+      } else {
+        throw new Error("does not know how to run middleware");
+      }
+    }
+    __name(next, "next");
+    await next();
+  }
+};
+
+// ../neko-router/dist/Route.mjs
+var Route = class {
+  static {
+    __name(this, "Route");
+  }
+  constructor(methods, path2, handler) {
+    this.methods = methods;
+    this.path = path2;
+    this.handler = handler;
+    this.urlRegex = this.pathToRegex(path2);
+  }
+  middlewares = [];
+  urlRegex;
+  pathToRegex(path2) {
+    const lex = this.lexUrlPath(path2);
+    return this.tokensToRegex(lex);
+  }
+  lexUrlPath(path2) {
+    const tokens = [];
+    let i = 0;
+    while (i < path2.length) {
+      const char = path2[i];
+      if (char === "/") {
+        tokens.push({ type: "SLASH", value: "/" });
+        i++;
+      } else if (char === ":") {
+        let start = i + 1;
+        while (start < path2.length && /[a-zA-Z0-9_]/.test(path2[start])) {
+          start++;
+        }
+        tokens.push({ type: "PARAM", value: path2.slice(i + 1, start) });
+        i = start;
+      } else if (char === "*") {
+        let start = i + 1;
+        while (start < path2.length && /[a-zA-Z0-9_]/.test(path2[start])) {
+          start++;
+        }
+        tokens.push({ type: "WILDCARD", value: path2.slice(i + 1, start) });
+        i = start;
+      } else {
+        let start = i;
+        while (start < path2.length && !["/", ":", "*"].includes(path2[start])) {
+          start++;
+        }
+        tokens.push({ type: "TEXT", value: path2.slice(i, start) });
+        i = start;
+      }
+    }
+    return tokens;
+  }
+  tokensToRegex(tokens) {
+    const regexParts = [];
+    for (const token of tokens) {
+      if (token.type === "SLASH") {
+        regexParts.push("\\/");
+      } else if (token.type === "PARAM") {
+        regexParts.push(`(?<${token.value}>[^\\/]+)`);
+      } else if (token.type === "WILDCARD") {
+        regexParts.push("(.+)");
+      } else if (token.type === "TEXT") {
+        regexParts.push(token.value.replace(/[-\/\\^$.*+?()[\]{}|]/g, "\\$&"));
+      }
+    }
+    if (regexParts.length > 0 && regexParts[regexParts.length - 1] === "\\/") {
+      regexParts[regexParts.length - 1] = "\\/?";
+    } else {
+      regexParts.push("\\/?");
+    }
+    return new RegExp(`^${regexParts.join("")}$`);
+  }
+  /**
+   * to evaludate if request is a match for this route
+   * @param request http request
+   * @returns return true if route is a match for this request
+   */
+  test(request) {
+    if (this.methods.indexOf(request.method) === -1) {
+      return false;
+    }
+    const url = new URL(request.url || "/", "http://localhost");
+    return this.testPath(url.pathname);
+  }
+  testPath(pathname) {
+    return this.urlRegex.test(pathname);
+  }
+  /**
+   * returns details of the match, otherwise it returns false
+   * @param request the request to match
+   * @returns object cotaining details of match including matched params
+   */
+  match(request) {
+    if (this.methods.indexOf(request.method) === -1) {
+      return false;
+    }
+    const url = new URL(request.url || "/", "http://localhost");
+    const r = this.urlRegex.exec(url.pathname);
+    if (!r) {
+      return false;
+    }
+    return {
+      url,
+      params: r.groups || {}
+    };
+  }
+  addMiddleware(middlewares) {
+    this.middlewares = this.middlewares.concat(middlewares);
+    return this;
+  }
+  getMiddlewares() {
+    return this.middlewares;
+  }
+  callHanlder(request, response) {
+    return this.handler(request, response);
+  }
+};
+
+// ../neko-router/dist/Router.mjs
+var import_path = __toESM(require("path"), 1);
+var Router = class {
+  static {
+    __name(this, "Router");
+  }
+  middlewares = [];
+  routes = [];
+  addRoute(methods, path2, handler) {
+    const route = new Route(methods, path2, handler);
+    this.routes.push(route);
+    return route;
+  }
+  getMiddlewares() {
+    return [...this.middlewares];
+  }
+  addController(controller) {
+    const basePath = controller.basePath || "";
+    for (const route of controller.routes) {
+      const urlPath = import_path.default.join(basePath, route.path);
+      this.addRoute(route.methods, urlPath, async (req, res) => {
+        const controllerInstance = controller.getInstance();
+        return await controllerInstance[route.handler]();
+      }).addMiddleware([...controller.baseMiddlewares, ...route.middlewares]);
+    }
+  }
+  addGlobalMiddleware(middlewares) {
+    this.middlewares = this.middlewares.concat(middlewares);
+  }
+  resolve(request) {
+    for (const route of this.routes) {
+      if (route.test(request)) {
+        return route;
+      }
+    }
+    return void 0;
+  }
+  resolveMultiple(request) {
+    const rc = [];
+    const url = new URL(request.url || "/", "http://localhost");
+    for (const route of this.routes) {
+      if (route.testPath(url.pathname)) {
+        rc.push(route);
+      }
+    }
+    return rc;
+  }
+  getCompiledRoute(request, response) {
+    const route = this.resolve(request);
+    if (!route) {
+      return void 0;
+    }
+    const match = route.match(request);
+    if (!match) {
+      return void 0;
+    }
+    request.params = match.params;
+    return new CompiledRoute(route, request, response, this.middlewares);
+  }
+};
+
+// src/facades.mts
+var import_neko_scheduler = require("@devbro/neko-scheduler");
+var import_neko_helper = require("@devbro/neko-helper");
+var import_neko_context2 = require("@devbro/neko-context");
+var import_neko_storage = require("@devbro/neko-storage");
+var import_neko_mailer = require("@devbro/neko-mailer");
+var import_neko_config = require("@devbro/neko-config");
+var import_clipanion = require("clipanion");
+
+// src/http.mts
+var http_exports = {};
+__reExport(http_exports, require("@devbro/neko-http"));
+
+// src/facades.mts
+var yup = __toESM(require("yup"), 1);
+var import_neko_logger = require("@devbro/neko-logger");
+var router = (0, import_neko_helper.createSingleton)(() => new Router());
+var scheduler = (0, import_neko_helper.createSingleton)(() => {
+  const rc = new import_neko_scheduler.Scheduler();
+  rc.setErrorHandler((err, job) => {
+    logger().error({
+      msg: "Scheduled job error",
+      err,
+      job_name: job.getName()
+    });
+  });
+  return rc;
+});
+var storage = (0, import_neko_helper.createSingleton)(
+  (label = "default") => import_neko_storage.StorageFactory.create(import_neko_config.config.get(["storages", label].join(".")))
+);
+var cli = (0, import_neko_helper.createSingleton)(() => {
+  const [node, app, ...args] = process.argv;
+  return new import_clipanion.Cli({
+    binaryLabel: `My Application`,
+    binaryName: `${node} ${app}`,
+    binaryVersion: `1.0.0`
+  });
+});
+var httpServer = (0, import_neko_helper.createSingleton)(() => {
+  const server = new http_exports.HttpServer();
+  server.setErrorHandler(async (err, req, res) => {
+    if (err instanceof http_exports.HttpError) {
+      res.writeHead(err.statusCode, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ message: err.message, error: err.code }));
+      logger().warn({ msg: "HttpError: " + err.message, err });
+      return;
+    } else if (err instanceof yup.ValidationError) {
+      res.writeHead(422, { "Content-Type": "application/json" });
+      const errs = {};
+      err.inner.forEach((e) => {
+        const sanitizedParams = { ...e.params };
+        if (/passw/i.test(e.path)) {
+          sanitizedParams.value = "******";
+          sanitizedParams.originalValue = "******";
+        }
+        errs[e.path] = {
+          type: e.type,
+          message: e.message,
+          params: sanitizedParams
+        };
+      });
+      res.end(JSON.stringify({ message: "validation error", errors: errs }));
+      logger().warn({ msg: "ValidationError: " + err.message, err });
+      return;
+    } else {
+      logger().error({ msg: "Error: " + err.message, err });
+    }
+    res.writeHead(500, { "Content-Type": "" });
+    res.end(JSON.stringify({ error: "Internal Server Error" }));
+  });
+  server.setRouter(router());
+  return server;
+});
+var logger = (0, import_neko_helper.createSingleton)((label) => {
+  const logger_config = import_neko_config.config.get(["loggers", label].join("."));
+  const rc = new import_neko_logger.Logger(logger_config);
+  rc.setExtrasFunction((message) => {
+    message.requestId = (0, import_neko_context2.ctxSafe)()?.get("requestId") || "N/A";
+    return message;
+  });
+  return rc;
+});
+var mailer = (0, import_neko_helper.createSingleton)((label) => {
+  const mailer_config = import_neko_config.config.get(["mailer", label].join("."));
+  let provider;
+  if (mailer_config.provider === "logger") {
+    provider = new import_neko_mailer.FunctionProvider((mail) => {
+      logger().info({
+        msg: "Sending email",
+        mail
+      });
+    });
+  } else if (mailer_config.provider === "SES") {
+    provider = new import_neko_mailer.SESProvider(mailer_config.config);
+  } else if (mailer_config.provider === "SMTP") {
+    provider = new import_neko_mailer.SMTPProvider(mailer_config.config);
+  } else if (mailer_config.provider === "MEMORY") {
+    provider = new import_neko_mailer.MemoryProvider();
+  }
+  if (!provider) {
+    throw new Error(
+      `cannot initiate mailer provider: ${mailer_config?.provider}`
+    );
+  }
+  const rc = new import_neko_mailer.Mailer(provider);
+  return rc;
+});
+
+// src/app/console/DefaultCommand.mts
+var DefaultCommand = class extends import_clipanion2.Command {
+  static {
+    __name(this, "DefaultCommand");
+  }
+  static usage = import_clipanion2.Command.Usage({
+    category: `Main`,
+    description: `server management command line.`,
+    details: `
+      The base command for running and managing your server.
+
+      Make sure you understand how things work.
+    `,
+    examples: []
+  });
+  async execute() {
+    const commandList = cli().registrations;
+    const paths = [];
+    commandList.forEach(
+      (index, val) => paths.push(index.builder.paths[0]?.join(" ") || "")
+    );
+    console.log("Available commands:");
+    for (const cmd of paths) {
+      if (cmd) {
+        console.log(cmd);
+      }
+    }
+  }
+};
+cli().register(DefaultCommand);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DefaultCommand
+});