underpost 2.8.44 → 2.8.451

package/manifests/valkey/statefulset.yaml

@@ -0,0 +1,39 @@
+---
+apiVersion: apps/v1
+kind: StatefulSet
+metadata:
+  name: service-valkey
+  namespace: default
+spec:
+  serviceName: service-valkey
+  replicas: 1
+  selector:
+    matchLabels:
+      app: service-valkey
+  template:
+    metadata:
+      labels:
+        app: service-valkey
+    spec:
+      containers:
+        - name: service-valkey
+          image: docker.io/valkey/valkey:latest
+          env:
+            - name: TZ
+              value: Europe/Zurich
+          ports:
+            - containerPort: 6379
+          startupProbe:
+            tcpSocket:
+              port: 6379
+            failureThreshold: 30
+            periodSeconds: 5
+            timeoutSeconds: 5
+          livenessProbe:
+            tcpSocket:
+              port: 6379
+            failureThreshold: 2
+            periodSeconds: 30
+            timeoutSeconds: 5
+      restartPolicy: Always
+      automountServiceAccountToken: false

package/package.json

@@ -2,20 +2,26 @@
     "type": "module",
     "main": "src/index.js",
     "name": "underpost",
-    "version": "2.8.44",
+    "version": "2.8.451",
     "description": "pwa api rest template",
     "scripts": {
         "start": "env-cmd -f .env.production node --max-old-space-size=8192 src/server",
-        "build": "node bin/deploy build-full-client",
+        "test": "env-cmd -f .env.test c8 mocha",
+        "pm2": "env-cmd -f .env.production pm2 start src/server.js --node-args=\"--max-old-space-size=8192\" --name engine",
         "dev": "env-cmd -f .env.development node src/client.dev default",
+        "dev-img": "env-cmd -f .env.development node src/server",
         "dev-api": "env-cmd -f .env.development nodemon --watch src --ignore src/client src/api",
+        "dev-client": "env-cmd -f .env.development node src/client.dev",
+        "proxy": "node src/proxy proxy",
         "docs": "jsdoc -c jsdoc.json",
         "install-global": "npm install -g pm2 && npm install -g jsdoc && npm install -g prettier && npm install -g env-cmd && npm install -g yarn && npm install -g auto-changelog",
         "install-test": "npm install -g mocha && npm install -g c8 && npm install -g nyc && npm install -g coveralls",
         "install": "npm run install-global && npm run install-test",
         "docker:start": "docker-compose up",
         "prettier": "prettier --write .",
-        "test": "env-cmd -f .env.test c8 mocha"
+        "fix": "npm audit fix --force && npm audit",
+        "changelog": "auto-changelog",
+        "build": "node bin/deploy build-full-client"
     },
     "bin": {
         "underpost": "bin/index.js"

package/src/cli/cluster.js

@@ -0,0 +1,154 @@
+import { timer } from '../client/components/core/CommonJs.js';
+import { cliSpinner } from '../server/conf.js';
+import { loggerFactory } from '../server/logger.js';
+import { shellExec } from '../server/process.js';
+
+const logger = loggerFactory(import.meta);
+
+class UnderpostCluster {
+  static API = {
+    async init(options = { valkey: false, mariadb: false, valkey: false, full: false, info: false, nsUse: '' }) {
+      if (options.nsUse) {
+        shellExec(`kubectl config set-context --current --namespace=${options.nsUse}`);
+        return;
+      }
+      if (options.info) {
+        shellExec(`kubectl config get-contexts`); // config env persisente for manage multiple clusters
+        shellExec(`kubectl config get-clusters`);
+        shellExec(`kubectl get nodes -o wide`); // set of nodes of a cluster
+        shellExec(`kubectl config view | grep namespace`);
+        shellExec(`kubectl get ns -o wide`); // A namespace can have pods of different nodes
+        shellExec(`kubectl get pvc --all-namespaces -o wide`); // PersistentVolumeClaim -> request storage service
+        shellExec(`kubectl get pv --all-namespaces -o wide`); // PersistentVolume -> real storage
+        shellExec(`kubectl get cronjob --all-namespaces -o wide`);
+        shellExec(`kubectl get svc --all-namespaces -o wide`); // proxy dns gate way -> deployments, statefulsets, pods
+        shellExec(`kubectl get statefulsets --all-namespaces -o wide`); // set pods with data/volume persistence
+        shellExec(`kubectl get deployments --all-namespaces -o wide`); // set pods
+        shellExec(`kubectl get configmap --all-namespaces -o wide`);
+        shellExec(`kubectl get pods --all-namespaces -o wide`);
+        shellExec(
+          `kubectl get pod --all-namespaces -o="custom-columns=NAME:.metadata.name,INIT-CONTAINERS:.spec.initContainers[*].name,CONTAINERS:.spec.containers[*].name"`,
+        );
+        shellExec(
+          `kubectl get pods --all-namespaces -o=jsonpath='{range .items[*]}{"\\n"}{.metadata.name}{":\\t"}{range .spec.containers[*]}{.image}{", "}{end}{end}'`,
+        );
+        console.log();
+        logger.info('contour -------------------------------------------------');
+        for (const _k of ['Cluster', 'HTTPProxy', 'ClusterIssuer', 'Certificate']) {
+          shellExec(`kubectl get ${_k} --all-namespaces -o wide`);
+        }
+        logger.info('----------------------------------------------------------------');
+        shellExec(`kubectl get secrets --all-namespaces -o wide`);
+        shellExec(`docker secret ls`);
+        return;
+      }
+      const testClusterInit = shellExec(`kubectl get pods --all-namespaces -o wide`, {
+        disableLogging: true,
+        silent: true,
+        stdout: true,
+      });
+      if (!(testClusterInit.match('kube-system') && testClusterInit.match('kube-proxy'))) {
+        shellExec(`containerd config default > /etc/containerd/config.toml`);
+        shellExec(`sed -i -e "s/SystemdCgroup = false/SystemdCgroup = true/g" /etc/containerd/config.toml`);
+        // shellExec(`cp /etc/kubernetes/admin.conf ~/.kube/config`);
+        shellExec(`sudo systemctl restart kubelet`);
+        shellExec(`sudo service docker restart`);
+        shellExec(`cd ./manifests && kind create cluster --config kind-config.yaml`);
+        shellExec(`sudo chown $(id -u):$(id -g) $HOME/.kube/config**`);
+      } else logger.warn('Cluster already initialized');
+
+      if (options.full || options.valkey) {
+        shellExec(`kubectl delete statefulset service-valkey`);
+        shellExec(`kubectl apply -k ./manifests/valkey`);
+      }
+      if (options.full || options.mariadb) {
+        shellExec(
+          `sudo kubectl create secret generic mariadb-secret --from-file=username=/home/dd/engine/engine-private/mariadb-username --from-file=password=/home/dd/engine/engine-private/mariadb-password`,
+        );
+        shellExec(
+          `sudo kubectl create secret generic github-secret --from-literal=GITHUB_TOKEN=${process.env.GITHUB_TOKEN}`,
+        );
+        shellExec(`kubectl delete statefulset mariadb-statefulset`);
+        shellExec(`kubectl apply -k ./manifests/mariadb`);
+      }
+      if (options.full || options.mongodb) {
+        shellExec(
+          `sudo kubectl create secret generic mongodb-keyfile --from-file=/home/dd/engine/engine-private/mongodb-keyfile`,
+        );
+        shellExec(
+          `sudo kubectl create secret generic mongodb-secret --from-file=username=/home/dd/engine/engine-private/mongodb-username --from-file=password=/home/dd/engine/engine-private/mongodb-password`,
+        );
+        shellExec(`kubectl delete statefulset mongodb`);
+        shellExec(`kubectl apply -k ./manifests/mongodb`);
+
+        await new Promise(async (resolve) => {
+          cliSpinner(3000, `[cluster.js] `, ` Load mongodb instance`, 'yellow', 'material');
+          await timer(3000);
+
+          const monitor = async () => {
+            cliSpinner(1000, `[cluster.js] `, ` Load mongodb instance`, 'yellow', 'material');
+            await timer(1000);
+            if (
+              shellExec(`kubectl get pods --all-namespaces -o wide`, {
+                silent: true,
+                stdout: true,
+                disableLog: true,
+              }).match(`mongodb-0                                    1/1     Running`)
+            )
+              return resolve();
+            return monitor();
+          };
+          await monitor();
+        });
+
+        const mongoConfig = {
+          _id: 'rs0',
+          members: [
+            { _id: 0, host: 'mongodb-0.mongodb-service:27017', priority: 1 },
+            { _id: 1, host: 'mongodb-1.mongodb-service:27017', priority: 1 },
+          ],
+        };
+
+        shellExec(
+          `kubectl exec -i mongodb-0 -- mongosh --quiet --json=relaxed \
+          --eval 'use admin' \
+          --eval 'rs.initiate(${JSON.stringify(mongoConfig)})' \
+          --eval 'rs.status()'`,
+        );
+      }
+
+      if (options.full || options.contour)
+        shellExec(`kubectl apply -f https://projectcontour.io/quickstart/contour.yaml`);
+    },
+    reset() {
+      shellExec(`kind get clusters | xargs -t -n1 kind delete cluster --name`);
+      shellExec(`sudo kubeadm reset -f`);
+      shellExec('sudo rm -f /etc/cni/net.d/10-flannel.conflist');
+      shellExec('sudo iptables -F && sudo iptables -t nat -F && sudo iptables -t mangle -F && sudo iptables -X');
+      shellExec('sudo rm -f $HOME/.kube/config');
+      shellExec('sudo rm -rf /root/.local/share/Trash/files/*');
+      shellExec('sudo docker system prune -a -f');
+      shellExec('sudo service docker stop');
+      shellExec(`sudo rm -rf /var/lib/containers/storage/*`);
+      shellExec(`sudo rm -rf /var/lib/docker/volumes/*`);
+      shellExec(`sudo rm -rf /var/lib/docker~/*`);
+      shellExec(`sudo rm -rf /home/containers/storage/*`);
+      shellExec(`sudo rm -rf /home/docker/*`);
+      shellExec('sudo mv /var/lib/docker /var/lib/docker~');
+      shellExec('sudo mkdir /home/docker');
+      shellExec('sudo chmod 0711 /home/docker');
+      shellExec('sudo ln -s /home/docker /var/lib/docker');
+      shellExec(`sudo podman system prune -a -f`);
+      shellExec(`sudo podman system prune --all --volumes --force`);
+      shellExec(`sudo podman system prune --external --force`);
+      shellExec(`sudo podman system prune --all --volumes --force`);
+      shellExec(`sudo mkdir -p /home/containers/storage`);
+      shellExec('sudo chmod 0711 /home/containers/storage');
+      shellExec(
+        `sudo sed -i -e "s@/var/lib/containers/storage@/home/containers/storage@g" /etc/containers/storage.conf`,
+      );
+      shellExec(`sudo podman system reset -f`);
+    },
+  };
+}
+export default UnderpostCluster;

package/src/cli/env.js

@@ -0,0 +1,52 @@
+import { getNpmRootPath, writeEnv } from '../server/conf.js';
+import fs from 'fs-extra';
+import { loggerFactory } from '../server/logger.js';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+class UnderpostRootEnv {
+  static API = {
+    set(key, value) {
+      const exeRootPath = `${getNpmRootPath()}/underpost`;
+      const envPath = `${exeRootPath}/.env`;
+      let env = {};
+      if (fs.existsSync(envPath)) env = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
+      env[key] = value;
+      writeEnv(envPath, env);
+    },
+    delete(key) {
+      const exeRootPath = `${getNpmRootPath()}/underpost`;
+      const envPath = `${exeRootPath}/.env`;
+      let env = {};
+      if (fs.existsSync(envPath)) env = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
+      delete env[key];
+      writeEnv(envPath, env);
+    },
+    get(key) {
+      const exeRootPath = `${getNpmRootPath()}/underpost`;
+      const envPath = `${exeRootPath}/.env`;
+      if (!fs.existsSync(envPath)) return logger.error(`Unable to find underpost root environment`);
+      const env = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
+      logger.info('underpost root', { [key]: env[key] });
+      return env[key];
+    },
+    list() {
+      const exeRootPath = `${getNpmRootPath()}/underpost`;
+      const envPath = `${exeRootPath}/.env`;
+      if (!fs.existsSync(envPath)) return logger.error(`Unable to find underpost root environment`);
+      const env = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
+      logger.info('underpost root', env);
+      return env;
+    },
+    clean() {
+      const exeRootPath = `${getNpmRootPath()}/underpost`;
+      const envPath = `${exeRootPath}/.env`;
+      fs.removeSync(envPath);
+    },
+  };
+}
+
+export default UnderpostRootEnv;

package/src/cli/image.js

@@ -0,0 +1,118 @@
+import fs from 'fs-extra';
+import Underpost from '../index.js';
+import { shellExec } from '../server/process.js';
+import { MariaDB } from '../db/mariadb/MariaDB.js';
+import dotenv from 'dotenv';
+import { getNpmRootPath } from '../server/conf.js';
+
+dotenv.config();
+
+class UnderpostImage {
+  static API = {
+    dockerfile: {
+      pullBaseImages() {
+        shellExec(`sudo podman pull docker.io/library/debian:buster`);
+      },
+      build(deployId = 'default', env = 'development', path = '.', imageArchive = false) {
+        const imgName = `${deployId}-${env}:${Underpost.version}`;
+        const podManImg = `localhost/${imgName}`;
+        const imagesStoragePath = `./images`;
+        const tarFile = `${imagesStoragePath}/${imgName.replace(':', '_')}.tar`;
+
+        let secrets = '';
+        let secretDockerInput = '';
+
+        const envObj = dotenv.parse(fs.readFileSync(`${getNpmRootPath()}/underpost/.env`, 'utf8'));
+
+        for (const key of Object.keys(envObj)) {
+          continue;
+          secrets += ` && export ${key}="${envObj[key]}" `; // $(cat gitlab-token.txt)
+          secretDockerInput += ` --secret id=${key},env=${key} \ `;
+        }
+        // --rm --no-cache
+        if (imageArchive !== true) {
+          fs.copyFile(`${getNpmRootPath()}/underpost/.env`, `${path}/.env.underpost`);
+          shellExec(
+            `cd ${path}${secrets}&& sudo podman build -f ./Dockerfile -t ${imgName} --pull=never --cap-add=CAP_AUDIT_WRITE${secretDockerInput}`,
+          );
+          fs.removeSync(`${path}/.env.underpost`);
+          shellExec(`cd ${path} && podman save -o ${tarFile} ${podManImg}`);
+        }
+        shellExec(`cd ${path} && sudo kind load image-archive ${tarFile}`);
+      },
+      async script(deployId = 'default', env = 'development') {
+        switch (deployId) {
+          case 'dd-lampp':
+            {
+              const lamppPublicPath = '/xampp/htdocs/online';
+              if (process.argv.includes('test')) {
+                const { MARIADB_HOST, MARIADB_USER, MARIADB_PASSWORD, DD_LAMPP_TEST_DB_0 } = process.env;
+
+                await MariaDB.query({
+                  host: MARIADB_HOST,
+                  user: MARIADB_USER,
+                  password: MARIADB_PASSWORD,
+                  query: `SHOW TABLES FROM ${DD_LAMPP_TEST_DB_0}`,
+                });
+                process.exit(0);
+              }
+              shellExec(`sudo mkdir -p ${lamppPublicPath}`);
+
+              {
+                shellExec(
+                  `cd ${lamppPublicPath} && git clone https://${process.env.GITHUB_TOKEN}@github.com/${process.env.DD_LAMPP_REPO_0}`,
+                );
+
+                shellExec(`cd ${lamppPublicPath} && sudo ${process.env.DD_LAMPP_SCRIPT_0}`);
+
+                shellExec(
+                  `sudo sed -i -e "s@define( 'DB_HOST', 'localhost' );@define( 'DB_HOST', '${process.env.MARIADB_HOST}' );@g" ${lamppPublicPath}/${process.env.DD_LAMPP_REPO_0_FOLDER}/wp-config.php`,
+                );
+              }
+              {
+                shellExec(
+                  `cd ${lamppPublicPath} && git clone https://${process.env.GITHUB_TOKEN}@github.com/${process.env.DD_LAMPP_REPO_1}`,
+                );
+              }
+            }
+            break;
+
+          default:
+            {
+              {
+                const originPath = `./src/db/mongo/MongooseDB.js`;
+                fs.writeFileSync(
+                  originPath,
+                  fs.readFileSync(originPath, 'utf8').replaceAll(
+                    `connect: async (host, name) => {`,
+                    `connect: async (host, name) => {
+    host = 'mongodb://mongodb-0.mongodb-service:27017';
+        `,
+                  ),
+                  'utf8',
+                );
+              }
+
+              {
+                const originPath = `./src/server/valkey.js`;
+                fs.writeFileSync(
+                  originPath,
+                  fs.readFileSync(originPath, 'utf8').replaceAll(
+                    `    // port: 6379,
+    // host: 'service-valkey.default.svc.cluster.local',`,
+                    `     port: 6379,
+    host: 'service-valkey.default.svc.cluster.local',`,
+                  ),
+                  'utf8',
+                );
+              }
+            }
+            break;
+        }
+        shellExec(`node bin/deploy conf ${deployId} ${env}`);
+        shellExec(`node bin/deploy build-full-client ${deployId}`);
+      },
+    },
+  };
+}
+export default UnderpostImage;

package/src/cli/repository.js

@@ -0,0 +1,108 @@
+import { commitData } from '../client/components/core/CommonJs.js';
+import dotenv from 'dotenv';
+import { pbcopy, shellExec } from '../server/process.js';
+import { actionInitLog, loggerFactory } from '../server/logger.js';
+import fs from 'fs-extra';
+import { getNpmRootPath } from '../server/conf.js';
+
+dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+class UnderpostRepository {
+  static API = {
+    clone(gitUri = 'underpostnet/pwa-microservices-template') {
+      const repoName = gitUri.split('/').pop();
+      if (fs.existsSync(`./${repoName}`)) fs.removeSync(`./${repoName}`);
+      return shellExec(
+        `git clone https://${process.env.GITHUB_TOKEN ? `${process.env.GITHUB_TOKEN}@` : ''}github.com/${gitUri}.git`,
+        {
+          disableLog: true,
+        },
+      );
+      if (process.env.GITHUB_TOKEN) {
+        shellExec(
+          `git clone https://${
+            process.env.GITHUB_TOKEN ? `${process.env.GITHUB_TOKEN}@` : ''
+          }github.com/${gitUri}-private.git`,
+        );
+        fs.moveSync(`./${repoName}-private`, `./${repoName}/engine-private`, {
+          overwrite: true,
+        });
+      }
+    },
+    pull(repoPath = './', gitUri = 'underpostnet/pwa-microservices-template') {
+      shellExec(
+        `cd ${repoPath} && git pull https://${
+          process.env.GITHUB_TOKEN ? `${process.env.GITHUB_TOKEN}@` : ''
+        }github.com/${gitUri}.git`,
+        {
+          disableLog: true,
+        },
+      );
+    },
+    commit(
+      repoPath = './',
+      commitType = 'feat',
+      subModule = '',
+      message = '',
+      options = {
+        copy: false,
+        info: false,
+        empty: false,
+      },
+    ) {
+      if (options.info) return logger.info('', commitData);
+      const _message = `${commitType}${subModule ? `(${subModule})` : ''}${process.argv.includes('!') ? '!' : ''}: ${
+        commitData[commitType].emoji
+      } ${message ? message : commitData[commitType].description}`;
+      if (options.copy) return pbcopy(_message);
+      shellExec(`cd ${repoPath} && git commit ${options?.empty ? `--allow-empty ` : ''}-m "${_message}"`);
+    },
+
+    push(repoPath = './', gitUri = 'underpostnet/pwa-microservices-template', options = { f: false }) {
+      shellExec(
+        `cd ${repoPath} && git push https://${process.env.GITHUB_TOKEN}@github.com/${gitUri}.git${
+          options?.f === true ? ' --force' : ''
+        }`,
+        {
+          disableLog: true,
+        },
+      );
+      logger.info(
+        'commit url',
+        `http://github.com/${gitUri}/commit/${shellExec(`cd ${repoPath} && git rev-parse --verify HEAD`, {
+          stdout: true,
+        }).trim()}`,
+      );
+    },
+
+    new(repositoryName) {
+      return new Promise(async (resolve, reject) => {
+        try {
+          const exeRootPath = `${getNpmRootPath()}/underpost`;
+          // const exeRootPath = '/home/dd/pwa-microservices-template';
+          actionInitLog();
+          await logger.setUpInfo();
+          const destFolder = `${process.cwd()}/${repositoryName}`;
+          logger.info('Note: This process may take several minutes to complete');
+          logger.info('build app', { destFolder });
+          fs.mkdirSync(destFolder, { recursive: true });
+          fs.copySync(exeRootPath, destFolder);
+          if (fs.existsSync(`${destFolder}/node_modules`)) fs.removeSync(`${destFolder}/node_modules`);
+          fs.writeFileSync(`${destFolder}/.gitignore`, fs.readFileSync(`${exeRootPath}/.dockerignore`, 'utf8'), 'utf8');
+          shellExec(`cd ${destFolder} && git init && git add . && git commit -m "Base template implementation"`);
+          shellExec(`cd ${destFolder} && npm install`);
+          shellExec(`cd ${destFolder} && npm run build`);
+          shellExec(`cd ${destFolder} && npm run dev`);
+          return resolve();
+        } catch (error) {
+          logger.error(error, error.stack);
+          return reject(error.message);
+        }
+      });
+    },
+  };
+}
+
+export default UnderpostRepository;

package/src/cli/script.js

@@ -0,0 +1,29 @@
+import { getNpmRootPath } from '../server/conf.js';
+import { loggerFactory } from '../server/logger.js';
+import { shellExec } from '../server/process.js';
+import fs from 'fs-extra';
+
+const logger = loggerFactory(import.meta);
+
+class UnderpostScript {
+  static API = {
+    set(key, value) {
+      const npmRoot = `${getNpmRootPath()}/underpost`;
+      const packageJson = JSON.parse(fs.readFileSync(`${npmRoot}/package.json`, 'utf8'));
+      packageJson.scripts[key] = value;
+      fs.writeFileSync(`${npmRoot}/package.json`, JSON.stringify(packageJson, null, 4));
+    },
+    run(key) {
+      const npmRoot = `${getNpmRootPath()}/underpost`;
+      shellExec(`cd ${npmRoot} && npm run ${key}`);
+    },
+    get(key) {
+      const npmRoot = `${getNpmRootPath()}/underpost`;
+      const packageJson = JSON.parse(fs.readFileSync(`${npmRoot}/package.json`, 'utf8'));
+      logger.info('[get] ' + key, packageJson.scripts[key]);
+      return packageJson.scripts[key];
+    },
+  };
+}
+
+export default UnderpostScript;

package/src/cli/secrets.js

@@ -0,0 +1,37 @@
+import dotenv from 'dotenv';
+import { shellExec } from '../server/process.js';
+import fs from 'fs-extra';
+import UnderpostRootEnv from './env.js';
+
+class UnderpostSecret {
+  static API = {
+    docker: {
+      init() {
+        shellExec(`docker swarm init`);
+      },
+      createFromEnvFile(envPath) {
+        const envObj = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
+        for (const key of Object.keys(envObj)) {
+          UnderpostSecret.API.docker.set(key, envObj[key]);
+        }
+      },
+      set(key, value) {
+        shellExec(`docker secret rm ${key}`);
+        shellExec(`echo "${value}" | docker secret create ${key} -`);
+      },
+      list() {
+        shellExec(`docker secret ls`);
+      },
+    },
+    underpost: {
+      createFromEnvFile(envPath) {
+        const envObj = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
+        for (const key of Object.keys(envObj)) {
+          UnderpostRootEnv.API.set(key, envObj[key]);
+        }
+      },
+    },
+  };
+}
+
+export default UnderpostSecret;

package/src/cli/test.js

@@ -0,0 +1,32 @@
+import { getNpmRootPath } from '../server/conf.js';
+import { actionInitLog, loggerFactory } from '../server/logger.js';
+import { shellExec } from '../server/process.js';
+
+const logger = loggerFactory(import.meta);
+
+class UnderpostTest {
+  static API = {
+    /**
+     * Logs information about the current process environment to the console.
+     *
+     * This function is used to log details about
+     * the execution context, such as command-line arguments,
+     * environment variables, the process's administrative privileges,
+     * and the maximum available heap space size.
+     *
+     * @static
+     * @method setUpInfo
+     * @returns {Promise<void>}
+     * @memberof Underpost
+     */
+    async setUpInfo() {
+      return await setUpInfo(logger);
+    },
+    run() {
+      actionInitLog();
+      shellExec(`cd ${getNpmRootPath()}/underpost && npm run test`);
+    },
+  };
+}
+
+export default UnderpostTest;