underpost 2.8.48 → 2.8.51

package/bin/build.js

@@ -36,7 +36,7 @@ if (process.argv.includes('clean')) {
 
 if (process.argv.includes('conf')) {
   for (const _confName of (confName === 'dd'
-    ? fs.readFileSync(`./engine-private/deploy/dd-router`, 'utf8')
+    ? fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8')
     : confName
   ).split(',')) {
     const _repoName = `engine-${_confName.split('dd-')[1]}`;
@@ -52,6 +52,12 @@ if (process.argv.includes('conf')) {
     fs.removeSync(toPath);
     fs.mkdirSync(toPath, { recursive: true });
     fs.copySync(`./engine-private/conf/${_confName}`, toPath);
+    if (fs.existsSync(`./engine-private/replica`)) {
+      const replicas = await fs.readdir(`./engine-private/replica`);
+      for (const replica of replicas)
+        if (replica.match(_confName))
+          fs.copySync(`./engine-private/replica/${replica}`, `../${privateRepoName}/replica/${replica}`);
+    }
     shellExec(
       `cd ../${privateRepoName}` +
         ` && git add .` +

package/bin/deploy.js

@@ -141,28 +141,7 @@ try {
       loadConf(process.argv[3], process.argv[4]);
       break;
     }
-    case 'run':
-      {
-        if (process.argv.includes('replicas')) {
-          const deployGroupId = getDeployGroupId();
-          const dataDeploy = getDataDeploy({
-            deployId: process.argv[3],
-            buildSingleReplica: true,
-            deployGroupId,
-          });
-          if (fs.existsSync(`./tmp/await-deploy`)) fs.remove(`./tmp/await-deploy`);
-          await deployRun(dataDeploy);
-        } else {
-          loadConf(process.argv[3]);
-          shellExec(`npm start ${process.argv.includes('maintenance') ? 'maintenance' : ''}`);
-        }
-      }
-      break;
 
-    case 'remove-await-deploy': {
-      if (fs.existsSync(`./tmp/await-deploy`)) fs.remove(`./tmp/await-deploy`);
-      break;
-    }
     case 'new-nodejs-app':
       {
         const deployId = process.argv[3];
@@ -229,6 +208,7 @@ try {
       break;
     case 'build-full-client':
       {
+        dotenv.config({ override: true });
         if (!process.argv[3]) process.argv[3] = 'default';
         const { deployId, folder } = loadConf(process.argv[3]);
 
@@ -254,7 +234,7 @@ try {
                   serverConf[host][path].replicas.map((replica) => buildReplicaId({ deployId, replica })),
                 );
 
-                shellExec(Cmd.replica(deployId, host, path));
+                // shellExec(Cmd.replica(deployId, host, path));
               }
             }
           }
@@ -263,7 +243,7 @@ try {
         await buildClient();
 
         for (const replicaDeployId of deployIdSingleReplicas) {
-          shellExec(Cmd.conf(replicaDeployId));
+          shellExec(Cmd.conf(replicaDeployId, process.env.NODE_ENV));
           shellExec(Cmd.build(replicaDeployId));
         }
       }
@@ -456,12 +436,13 @@ try {
     case 'run-macro':
       {
         if (fs.existsSync(`./tmp/await-deploy`)) fs.remove(`./tmp/await-deploy`);
-        const dataDeploy = getDataDeploy({ deployGroupId: process.argv[3], buildSingleReplica: true });
+        const dataDeploy = getDataDeploy({
+          deployGroupId: process.argv[3],
+          buildSingleReplica: true,
+          deployIdConcat: ['dd-proxy', 'dd-cron'],
+        });
         if (!process.argv[4]) await setUpProxyMaintenanceServer({ deployGroupId: process.argv[3] });
-        await deployRun(
-          process.argv[4] ? dataDeploy.filter((d) => d.deployId.match(process.argv[4])) : dataDeploy,
-          true,
-        );
+        await deployRun(process.argv[4] ? dataDeploy.filter((d) => d.deployId.match(process.argv[4])) : dataDeploy);
       }
       break;
 

package/bin/index.js

@@ -8,8 +8,8 @@ import { getNpmRootPath, loadConf } from '../src/server/conf.js';
 import fs from 'fs-extra';
 import { commitData } from '../src/client/components/core/CommonJs.js';
 import UnderpostScript from '../src/cli/script.js';
-import { shellExec } from '../src/server/process.js';
 import UnderpostDB from '../src/cli/db.js';
+import UnderpostCron from '../src/cli/cron.js';
 
 const npmRoot = getNpmRootPath();
 const underpostRoot = `${npmRoot}/underpost/.env`;
@@ -63,7 +63,7 @@ program
 
 program
   .command('env')
-  .argument('<deploy-id>', 'deploy configuration id')
+  .argument('<deploy-id>', `deploy configuration id, if 'clean' restore default`)
   .argument('[env]', 'Optional environment, for default is production')
   .description('Set environment variables files and conf related to <deploy-id>')
   .action(loadConf);
@@ -99,7 +99,7 @@ program
 
 program
   .command('deploy')
-  .argument('<deploy-list>', 'Deploy id list, e.g. default-a, default-b')
+  .argument('<deploy-list>', 'Deploy id list, e.g. default-a,default-b')
   .argument('[env]', 'Optional environment, for default is development')
   .option('--remove', 'Delete deployments and services')
   .option('--sync', 'Sync deployments env, ports, and replicas')
@@ -127,6 +127,7 @@ program
   .command('dockerfile-node-script')
   .argument('<deploy-id>', 'Deploy configuration id')
   .argument('[env]', 'Optional environment, for default is development')
+  .option('--run', 'Run custom entry point script')
   .description('Dockerfile custom node build script')
   .action(Underpost.image.dockerfile.script);
 
@@ -153,7 +154,7 @@ program
 
 program
   .command('db')
-  .argument('<deploy-list>', 'Deploy id list, e.g. default-a, default-b')
+  .argument('<deploy-list>', 'Deploy id list, e.g. default-a,default-b')
   .option('--import', 'Import container backups from repositories')
   .option('--export', 'Export container backups to repositories')
   .description('Manage databases')
@@ -169,12 +170,22 @@ program
   )
   .action((...args) => Underpost.script[args[0]](args[1], args[2]));
 
+program
+  .command('cron')
+  .argument('[deploy-list]', 'Deploy id list, e.g. default-a,default-b')
+  .argument('[job-list]', `Deploy id list, e.g. ${Object.keys(UnderpostCron.JOB)}, for default all available jobs`)
+  .option('--disable-kind-cluster', 'Disable kind cluster configuration')
+  .option('--init', 'Init cron jobs for cron job default deploy id')
+  .description('Cron jobs management')
+  .action(Underpost.cron.callback);
+
 program
   .command('test')
-  .argument('[deploy-list]', 'Deploy id list, e.g. default-a, default-b')
+  .argument('[deploy-list]', 'Deploy id list, e.g. default-a,default-b')
   .description('Manage Test, for default run current underpost default test')
   .option('--inside-container', 'Inside container execution context')
   .option('--sh', 'Copy to clipboard, container entrypoint shell command')
+  .option('--logs', 'Display container logs')
   .action(Underpost.test.callback);
 
 program.parse();

package/bin/util.js

@@ -112,14 +112,6 @@ try {
       fs.writeFileSync('b64-image', `data:image/jpg;base64,${fs.readFileSync(process.argv[3]).toString('base64')}`);
       break;
 
-    case 'clean-env': {
-      shellExec(`git checkout package.json`);
-      shellExec(`git checkout .env.production`);
-      shellExec(`git checkout .env.development`);
-      shellExec(`git checkout .env.test`);
-      shellExec(`git checkout jsdoc.json`);
-      break;
-    }
     case 'get-keys': {
       const sentence = fs.existsSync('./_')
         ? fs.readFileSync('./_', 'utf8')

package/docker-compose.yml

@@ -58,7 +58,7 @@ services:
           cpus: '0.25'
           memory: 20M
     labels: # labels in Compose file instead of Dockerfile
-      engine.version: '2.8.48'
+      engine.version: '2.8.51'
     networks:
       - load-balancer
 

package/manifests/mongodb/backup-cronjob.yaml

@@ -16,25 +16,27 @@ spec:
                 - -c
                 - |
                   # Perform backup
-                  mongodump -u $MONGO_INITDB_ROOT_USERNAME -p $MONGO_INITDB_ROOT_PASSWORD --host=mongodb-service --port=27017 --out=/backup/$(date +\%Y-\%m-\%dT\%H-\%M-\%S)
+                  mongodump --host=mongodb-service --port=27017 --out=/backup/$(date +\%Y-\%m-\%dT\%H-\%M-\%S)
                   # Remove backups older than 7 days
                   find /backup -type d -mtime +7 -exec rm -rf {} +
               volumeMounts:
                 - name: backup-storage
                   mountPath: /backup
-              env:
-                - name: MONGO_INITDB_ROOT_USERNAME
-                  valueFrom:
-                    secretKeyRef:
-                      name: mongodb-secret
-                      key: username
-                - name: MONGO_INITDB_ROOT_PASSWORD
-                  valueFrom:
-                    secretKeyRef:
-                      name: mongodb-secret
-                      key: password
           restartPolicy: Never
           volumes:
             - name: backup-storage
               persistentVolumeClaim:
                 claimName: backup-pvc
+#     mongodump -u $MONGO_INITDB_ROOT_USERNAME -p $MONGO_INITDB_ROOT_PASSWORD --host=mongodb-service --port=27017 --out=/backup/$(date +\%Y-\%m-\%dT\%H-\%M-\%S)
+
+# env:
+#   - name: MONGO_INITDB_ROOT_USERNAME
+#     valueFrom:
+#       secretKeyRef:
+#         name: mongodb-secret
+#         key: username
+#   - name: MONGO_INITDB_ROOT_PASSWORD
+#     valueFrom:
+#       secretKeyRef:
+#         name: mongodb-secret
+#         key: password

package/package.json

@@ -2,7 +2,7 @@
     "type": "module",
     "main": "src/index.js",
     "name": "underpost",
-    "version": "2.8.48",
+    "version": "2.8.51",
     "description": "pwa api rest template",
     "scripts": {
         "start": "env-cmd -f .env.production node --max-old-space-size=8192 src/server",

package/src/api/core/core.service.js

@@ -9,7 +9,7 @@ const CoreService = {
     /** @type {import('./core.model.js').CoreModel} */
     const Core = DataBaseProvider.instance[`${options.host}${options.path}`].mongoose.models.Core;
     if (req.path.startsWith('/sh')) {
-      if (req.body.print) return shellExec(req.body.sh, { stdout: true });
+      if (req.body.stdout) return shellExec(req.body.sh, { stdout: true });
       shellExec(req.body.sh, { async: true });
       return 'Command "' + req.body.sh + '" running';
     }

package/src/cli/cron.js

@@ -0,0 +1,90 @@
+/**
+ * UnderpostCron CLI index module
+ * @module src/cli/cron.js
+ * @namespace UnderpostCron
+ */
+
+import Underpost from '../index.js';
+import BackUp from '../server/backup.js';
+import { Cmd } from '../server/conf.js';
+import Dns from '../server/dns.js';
+import { netWorkCron, saveRuntimeCron } from '../server/network.js';
+import { shellExec } from '../server/process.js';
+import fs from 'fs-extra';
+
+/**
+ * UnderpostCron main module methods
+ * @class
+ * @memberof UnderpostCron
+ */
+class UnderpostCron {
+  static JOB = {
+    /**
+     * DNS cli API
+     * @static
+     * @type {Dns}
+     * @memberof UnderpostCron
+     */
+    dns: Dns,
+    /**
+     * BackUp cli API
+     * @static
+     * @type {BackUp}
+     * @memberof UnderpostCron
+     */
+    backup: BackUp,
+  };
+  static API = {
+    /**
+     * Run the cron jobs
+     * @static
+     * @param {String} deployList - Comma separated deploy ids
+     * @param {String} jobList - Comma separated job ids
+     * @return {void}
+     * @memberof UnderpostCron
+     */
+    callback: async function (
+      deployList = 'default',
+      jobList = Object.keys(UnderpostCron.JOB),
+      options = { disableKindCluster: false, init: false },
+    ) {
+      if (options.init === true) {
+        await Underpost.test.setUpInfo();
+        const jobDeployId = fs.readFileSync('./engine-private/deploy/dd.cron', 'utf8').trim();
+        deployList = fs.readFileSync('./engine-private/deploy/dd.router', 'utf8').trim();
+        const confCronConfig = JSON.parse(fs.readFileSync(`./engine-private/conf/${jobDeployId}/conf.cron.json`));
+        if (confCronConfig.jobs && Object.keys(confCronConfig.jobs).length > 0) {
+          for (const job of Object.keys(confCronConfig.jobs)) {
+            const name = `${jobDeployId}-${job}`;
+            let deployId;
+            shellExec(Cmd.delete(name));
+            switch (job) {
+              case 'dns':
+                deployId = jobDeployId;
+                break;
+
+              default:
+                deployId = deployList;
+                break;
+            }
+            shellExec(Cmd.cron(deployId, job, name, confCronConfig.jobs[job].expression, options));
+            netWorkCron.push({
+              deployId,
+              jobId: job,
+              expression: confCronConfig.jobs[job].expression,
+            });
+          }
+        }
+        await saveRuntimeCron();
+        if (fs.existsSync(`./tmp/await-deploy`)) fs.remove(`./tmp/await-deploy`);
+        return;
+      }
+      for (const _jobId of jobList.split(',')) {
+        const jobId = _jobId.trim();
+        if (UnderpostCron.JOB[jobId]) await UnderpostCron.JOB[jobId].callback(deployList, options);
+      }
+    },
+  };
+}
+
+export default UnderpostCron;

package/src/cli/deploy.js

@@ -17,8 +17,8 @@ const logger = loggerFactory(import.meta);
 class UnderpostDeploy {
   static API = {
     sync(deployList) {
-      const deployGroupId = '_dd';
-      fs.writeFileSync(`./engine-private/deploy/${deployGroupId}.json`, JSON.stringify(deployList.split(',')), 'utf8');
+      const deployGroupId = 'dd.tmp';
+      fs.writeFileSync(`./engine-private/deploy/${deployGroupId}`, deployList, 'utf8');
       return getDataDeploy({
         buildSingleReplica: true,
         deployGroupId,
@@ -182,8 +182,8 @@ spec:
       env = 'development',
       options = { remove: false, infoRouter: false, sync: false, buildManifest: false },
     ) {
-      if (deployList === 'dd' && fs.existsSync(`./engine-private/deploy/dd-router`))
-        deployList = fs.readFileSync(`./engine-private/deploy/dd-router`, 'utf8');
+      if (deployList === 'dd' && fs.existsSync(`./engine-private/deploy/dd.router`))
+        deployList = fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8');
       if (options.sync) UnderpostDeploy.API.sync(deployList);
       if (options.buildManifest === true) await UnderpostDeploy.API.buildManifest(deployList, env);
       if (options.infoRouter === true)

package/src/cli/image.js

@@ -3,6 +3,7 @@ import Underpost from '../index.js';
 import { shellExec } from '../server/process.js';
 import dotenv from 'dotenv';
 import { getNpmRootPath } from '../server/conf.js';
+import { timer } from '../client/components/core/CommonJs.js';
 
 dotenv.config();
 
@@ -12,7 +13,7 @@ class UnderpostImage {
       pullBaseImages() {
         shellExec(`sudo podman pull docker.io/library/debian:buster`);
       },
-      build(deployId = 'default', env = 'development', path = '.', imageArchive = false) {
+      build(deployId = 'default', env = 'development', path = '.', options = { imageArchive: false }) {
         const imgName = `${deployId}-${env}:${Underpost.version}`;
         const podManImg = `localhost/${imgName}`;
         const imagesStoragePath = `./images`;
@@ -29,7 +30,7 @@ class UnderpostImage {
           secretDockerInput += ` --secret id=${key},env=${key} \ `;
         }
         // --rm --no-cache
-        if (imageArchive !== true) {
+        if (options.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}`,
@@ -39,7 +40,7 @@ class UnderpostImage {
         }
         shellExec(`cd ${path} && sudo kind load image-archive ${tarFile}`);
       },
-      async script(deployId = 'default', env = 'development') {
+      async script(deployId = 'default', env = 'development', options = { run: false }) {
         switch (deployId) {
           case 'dd-lampp':
             {
@@ -99,6 +100,24 @@ class UnderpostImage {
         }
         shellExec(`node bin/deploy conf ${deployId} ${env}`);
         shellExec(`node bin/deploy build-full-client ${deployId}`);
+        if (options.run === true) {
+          const runCmd = env === 'production' ? 'prod-img' : 'dev-img';
+          if (fs.existsSync(`./engine-private/replica`)) {
+            const replicas = await fs.readdir(`./engine-private/replica`);
+            for (const replica of replicas) {
+              shellExec(`node bin/deploy conf ${replica} ${env}`);
+              shellExec(`npm run ${runCmd} ${replica} deploy`, { async: true });
+              fs.writeFileSync(`./tmp/await-deploy`, '', 'utf8');
+              const monitor = async () => {
+                await timer(1000);
+                if (fs.existsSync(`./tmp/await-deploy`)) return await monitor();
+              };
+              await monitor();
+            }
+            shellExec(`node bin/deploy conf ${deployId} ${env}`);
+          }
+          shellExec(`npm run ${runCmd} ${deployId} deploy`);
+        }
       },
     },
   };

package/src/cli/repository.js

@@ -15,7 +15,7 @@ class UnderpostRepository {
     clone(gitUri = 'underpostnet/pwa-microservices-template', options = { bare: false }) {
       const repoName = gitUri.split('/').pop();
       if (fs.existsSync(`./${repoName}`)) fs.removeSync(`./${repoName}`);
-      return shellExec(
+      shellExec(
         `git clone ${options?.bare === true ? ` --bare ` : ''}https://${
           process.env.GITHUB_TOKEN ? `${process.env.GITHUB_TOKEN}@` : ''
         }github.com/${gitUri}.git`,
@@ -23,16 +23,6 @@ class UnderpostRepository {
           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(

package/src/cli/test.js

@@ -1,6 +1,6 @@
 import { MariaDB } from '../db/mariadb/MariaDB.js';
 import { getNpmRootPath } from '../server/conf.js';
-import { actionInitLog, loggerFactory } from '../server/logger.js';
+import { actionInitLog, loggerFactory, setUpInfo } from '../server/logger.js';
 import { pbcopy, shellExec } from '../server/process.js';
 import UnderpostDeploy from './deploy.js';
 
@@ -28,10 +28,13 @@ class UnderpostTest {
       actionInitLog();
       shellExec(`cd ${getNpmRootPath()}/underpost && npm run test`);
     },
-    async callback(deployList = '', options = { insideContainer: false, sh: false }) {
-      if (options.sh === true) {
+    async callback(deployList = '', options = { insideContainer: false, sh: false, logs: false }) {
+      if (options.sh === true || options.logs === true) {
         const [pod] = UnderpostDeploy.API.getPods(deployList);
-        if (pod) return pbcopy(`sudo kubectl exec -it ${pod.NAME} -- sh`);
+        if (pod) {
+          if (options.sh) return pbcopy(`sudo kubectl exec -it ${pod.NAME} -- sh`);
+          if (options.logs) return shellExec(`sudo kubectl logs -f ${pod.NAME}`);
+        }
         return logger.warn(`Couldn't find pods in deployment`, deployList);
       }
       if (deployList) {

package/src/client/components/core/Css.js

@@ -761,6 +761,7 @@ const renderWave = ({ id }) => {
 const cssTokensEffect = {};
 const cssTokensContainer = {};
 const cssEffect = async (containerSelector, event) => {
+  return;
   // Array.from(event.target.classList)
   let offsetX, offsetY;
   if (Array.from(event.srcElement.classList).includes('ripple') && cssTokensContainer[containerSelector]) {

package/src/index.js

@@ -5,6 +5,7 @@
  */
 
 import UnderpostCluster from './cli/cluster.js';
+import UnderpostCron from './cli/cron.js';
 import UnderpostDB from './cli/db.js';
 import UnderpostDeploy from './cli/deploy.js';
 import UnderpostRootEnv from './cli/env.js';
@@ -26,7 +27,7 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v2.8.48';
+  static version = 'v2.8.51';
   /**
    * Repository cli API
    * @static
@@ -90,6 +91,13 @@ class Underpost {
    * @memberof Underpost
    */
   static deploy = UnderpostDeploy.API;
+  /**
+   * Cron cli API
+   * @static
+   * @type {UnderpostCron.API}
+   * @memberof Underpost
+   */
+  static cron = UnderpostCron.API;
 }
 
 const up = Underpost;

package/src/server/backup.js

@@ -1,120 +1,76 @@
 import fs from 'fs-extra';
 import { loggerFactory } from './logger.js';
-import { shellCd, shellExec } from './process.js';
-import { getCronBackUpFolder, getDataDeploy } from './conf.js';
+import { shellExec } from './process.js';
+import { getCronBackUpFolder } from './conf.js';
 import dotenv from 'dotenv';
 
 dotenv.config();
 
 const logger = loggerFactory(import.meta);
 
-const BackUpManagement = {
-  repoUrl: `https://${process.env.GITHUB_TOKEN}@github.com/${process.env.GITHUB_USERNAME}/${process.env.GITHUB_BACKUP_REPO}.git`,
-  Init: async function ({ deployId }) {
-    const Callback = async function () {
-      const privateCronConfPath = `./engine-private/conf/${deployId}/conf.cron.json`;
+class BackUp {
+  static callback = async function (deployList, options = { disableKindCluster: false }) {
+    if ((!deployList || deployList === 'dd') && fs.existsSync(`./engine-private/deploy/dd.router`))
+      deployList = fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8');
 
-      const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
+    logger.info('init backups callback', deployList);
+    await logger.setUpInfo();
+    const currentDate = new Date().getTime();
+    const maxBackupRetention = 5;
 
-      const { backups } = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
+    if (!fs.existsSync('./engine-private/cron-backups'))
+      fs.mkdirSync('./engine-private/cron-backups', { recursive: true });
 
-      if (!backups) return;
+    for (const _deployId of deployList.split(',')) {
+      const deployId = _deployId.trim();
+      if (!deployId) continue;
 
-      logger.info('init backups callback');
-      await logger.setUpInfo();
-
-      const currentDate = new Date().getTime();
-
-      if (!fs.existsSync('./engine-private/cron-backups'))
-        fs.mkdirSync('./engine-private/cron-backups', { recursive: true });
-
-      for (const deployGroupData of backups) {
-        const { deployGroupId } = deployGroupData;
-        const dataDeploy = getDataDeploy({ deployGroupId });
-
-        for (const deployObj of dataDeploy) {
-          const { deployId, replicaHost } = deployObj;
-
-          if (replicaHost) continue;
-
-          const confServer = JSON.parse(
-            fs.existsSync(`./engine-private/replica/${deployId}/conf.server.json`)
-              ? fs.readFileSync(`./engine-private/replica/${deployId}/conf.server.json`, 'utf8')
-              : fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'),
-          );
-
-          for (const host of Object.keys(confServer))
-            for (const path of Object.keys(confServer[host])) {
-              // retention policy
-              let { db, backupFrequency, maxBackupRetention, singleReplica, wp, git, directory } =
-                confServer[host][path];
-
-              if (!db || singleReplica) continue;
-
-              if (!backupFrequency) backupFrequency = 'daily';
-              if (!maxBackupRetention) maxBackupRetention = 5;
-
-              const backUpPath = `${process.cwd()}/engine-private/cron-backups/${getCronBackUpFolder(host, path)}`;
-              if (!fs.existsSync(backUpPath)) fs.mkdirSync(`${backUpPath}`, { recursive: true });
-              // .isDirectory()
-              const files = await fs.readdir(backUpPath, { withFileTypes: true });
-
-              const currentBackupsDirs = files
-                .map((fileObj) => parseInt(fileObj.name))
-                .sort((a, b) => a - b)
-                .reverse();
+      if (options.disableKindCluster !== true) {
+        shellExec(`underpost db --export ${deployId}`);
+        continue;
+      }
 
-              switch (backupFrequency) {
-                case 'daily':
+      const confServer = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'));
 
-                default:
-                  // if (currentBackupsDirs[0] && currentDate - currentBackupsDirs[0] < 1000 * 60 * 60 * 24) continue;
-                  break;
-              }
+      for (const host of Object.keys(confServer))
+        for (const path of Object.keys(confServer[host])) {
+          // retention policy
+          const { db } = confServer[host][path];
+          if (!db) continue;
+          logger.info('Init backup', { host, path, db });
 
-              for (const retentionPath of currentBackupsDirs.filter((t, i) => i >= maxBackupRetention - 1)) {
-                const removePathRetention = `${backUpPath}/${retentionPath}`;
-                logger.info('Remove backup folder', removePathRetention);
-                fs.removeSync(removePathRetention);
-              }
+          const backUpPath = `${process.cwd()}/engine-private/cron-backups/${getCronBackUpFolder(host, path)}`;
+          if (!fs.existsSync(backUpPath)) fs.mkdirSync(`${backUpPath}`, { recursive: true });
+          // .isDirectory()
+          const files = await fs.readdir(backUpPath, { withFileTypes: true });
 
-              fs.mkdirSync(`${backUpPath}/${currentDate}`, { recursive: true });
+          const currentBackupsDirs = files
+            .map((fileObj) => parseInt(fileObj.name))
+            .sort((a, b) => a - b)
+            .reverse();
 
-              shellExec(`node bin/db ${host}${path} export ${deployId} ${backUpPath}/${currentDate}`);
+          for (const retentionPath of currentBackupsDirs.filter((t, i) => i >= maxBackupRetention - 1)) {
+            const removePathRetention = `${backUpPath}/${retentionPath}`;
+            logger.info('Remove backup folder', removePathRetention);
+            fs.removeSync(removePathRetention);
+          }
 
-              if (wp) {
-                const repoUrl = `https://${process.env.GITHUB_TOKEN}@github.com/${process.env.GITHUB_USERNAME}/${git
-                  .split('/')
-                  .pop()}.git`;
+          fs.mkdirSync(`${backUpPath}/${currentDate}`, { recursive: true });
 
-                shellExec(
-                  `cd ${directory}` +
-                    ` && git pull ${repoUrl}` +
-                    ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
-                    ` && git push ${repoUrl}`,
-                  {
-                    disableLog: true,
-                  },
-                );
-              }
-            }
+          shellExec(`node bin/db ${host}${path} export ${deployId} ${backUpPath}/${currentDate}`);
         }
-      }
       shellExec(
         `cd ./engine-private/cron-backups` +
-          ` && git pull ${BackUpManagement.repoUrl}` +
-          ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
-          ` && git push ${BackUpManagement.repoUrl}`,
+          ` && underpost pull . underpostnet/cron-backups` +
+          ` && git add .` +
+          ` && underpost cmt . backup cron-job '${new Date().toLocaleDateString()}'` +
+          ` && underpost push . underpostnet/cron-backups`,
         {
           disableLog: true,
         },
       );
-    };
-    await Callback();
-    BackUpManagement.Callback = Callback;
-    return Callback;
-  },
-  Callback: async function (params) {},
-};
+    }
+  };
+}
 
-export { BackUpManagement };
+export default BackUp;

package/src/server/conf.js

@@ -98,6 +98,14 @@ const Config = {
 };
 
 const loadConf = (deployId, envInput, subConf) => {
+  if (deployId === 'clean') {
+    shellExec(`git checkout package.json`);
+    shellExec(`git checkout .env.production`);
+    shellExec(`git checkout .env.development`);
+    shellExec(`git checkout .env.test`);
+    shellExec(`git checkout jsdoc.json`);
+    return;
+  }
   const folder = fs.existsSync(`./engine-private/replica/${deployId}`)
     ? `./engine-private/replica/${deployId}`
     : `./engine-private/conf/${deployId}`;
@@ -590,9 +598,25 @@ const cliSpinner = async (time = 5000, message0, message1, color, type = 'dots')
 const buildReplicaId = ({ deployId, replica }) => `${deployId}-${replica.slice(1)}`;
 
 const getDataDeploy = (
-  options = { buildSingleReplica: false, deployGroupId: '', deployId: '', disableSyncEnvPort: false },
+  options = {
+    buildSingleReplica: false,
+    deployGroupId: '',
+    deployId: '',
+    disableSyncEnvPort: false,
+    deployIdConcat: [],
+  },
 ) => {
-  let dataDeploy = JSON.parse(fs.readFileSync(`./engine-private/deploy/${options.deployGroupId}.json`, 'utf8'));
+  let dataDeploy =
+    options.deployGroupId === 'dd'
+      ? fs.readFileSync(`./engine-private/deploy/${options.deployGroupId}.router`, 'utf8')
+      : fs.readFileSync(`./engine-private/deploy/${options.deployGroupId}`, 'utf8');
+
+  dataDeploy = dataDeploy
+    .split(',')
+    .map((deployId) => deployId.trim())
+    .filter((deployId) => deployId);
+
+  if (options.deployIdConcat) dataDeploy = dataDeploy.concat(options.deployIdConcat);
 
   if (options.deployId) dataDeploy = dataDeploy.filter((d) => d === options.deployId);
 
@@ -827,7 +851,7 @@ const deployRun = async (dataDeploy, currentAttempt = 1) => {
   if (failed.length > 0) {
     for (const deploy of failed) logger.error(deploy.deployId, Cmd.run(deploy.deployId));
     if (currentAttempt === maxAttempts) return logger.error(`max deploy attempts exceeded`);
-    if (process.argv.includes('manual')) await read({ prompt: 'Press enter to retry failed processes\n' });
+    await read({ prompt: 'Press enter to retry failed processes\n' });
     currentAttempt++;
     await deployRun(failed, currentAttempt);
   } else logger.info(`Deploy process successfully`);
@@ -973,15 +997,15 @@ const getPathsSSR = (conf) => {
 
 const Cmd = {
   delete: (deployId) => `pm2 delete ${deployId}`,
-  run: (deployId) => `node bin/deploy run ${deployId}`,
+  run: () => `npm start`,
   build: (deployId) => `node bin/deploy build-full-client ${deployId}${process.argv.includes('l') ? ' l' : ''}`,
   conf: (deployId, env) => `node bin/deploy conf ${deployId} ${env ? env : 'production'}`,
   replica: (deployId, host, path) => `node bin/deploy build-single-replica ${deployId} ${host} ${path}`,
   syncPorts: (deployGroupId) => `node bin/deploy sync-env-port ${deployGroupId}`,
-  cron: (deployId, job, expression) => {
-    shellExec(Cmd.delete(`${deployId}-${job}`));
-    return `env-cmd -f .env.production pm2 start bin/cron.js --no-autorestart --instances 1 --cron "${expression}" --name ${deployId}-${job} -- ${job} ${deployId}`;
-  },
+  cron: (deployList, jobList, name, expression, options) =>
+    `pm2 start ./bin/index.js --no-autorestart --instances 1 --cron "${expression}" --name ${name} -- cron ${
+      options?.disableKindCluster ? `--disable-kind-cluster ` : ''
+    }${deployList} ${jobList}`,
 };
 
 const fixDependencies = async () => {
@@ -1048,7 +1072,7 @@ const setUpProxyMaintenanceServer = ({ deployGroupId }) => {
   shellExec(`node bin/deploy valkey-service`);
   const proxyDeployId = fs.readFileSync(`./engine-private/deploy/${deployGroupId}.proxy`, 'utf8').trim();
   shellExec(`node bin/deploy conf ${proxyDeployId} production`);
-  shellExec(`node bin/deploy run ${proxyDeployId} maintenance`);
+  shellExec(`npm start ${proxyDeployId} maintenance`);
 };
 
 const getNpmRootPath = () =>

package/src/server/dns.js

@@ -17,10 +17,8 @@ dotenv.config();
 
 const logger = loggerFactory(import.meta);
 
-const Dns = {
-  repoUrl: `https://${process.env.GITHUB_TOKEN}@github.com/${process.env.GITHUB_USERNAME}/${process.env.GITHUB_DNS_REPO}.git`,
-  callback: () => null,
-  InitIpDaemon: async function ({ deployId }) {
+class Dns {
+  static callback = async function (deployList) {
     // NAT-VPS modem/router device configuration:
     // LAN --> [NAT-VPS] --> WAN
     // enabled DMZ Host to proxy IP 80-443 (79-444) sometimes router block first port
@@ -30,56 +28,55 @@ const Dns = {
     // LAN server or device's local servers port ->  3000-3100 (2999-3101)
     // DNS Records: [ANAME](Address Dynamic) -> [A](ipv4) host | [AAAA](ipv6) host -> [public-ip]
     // Forward the router's TCP/UDP ports to the LAN device's IP address
-
+    for (const _deployId of deployList.split(',')) {
+      const deployId = _deployId.trim();
     const privateCronConfPath = `./engine-private/conf/${deployId}/conf.cron.json`;
-
     const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
-    let confCronData = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
-    if (confCronData.ipDaemon.disabled) return;
-    Dns.ip = confCronData.ipDaemon.ip;
-    logger.info(`Current ip`, Dns.ip);
-    const callback = async () => {
-      logger.info('init dns ip callback');
-      await logger.setUpInfo();
-      let testIp;
-      try {
-        testIp = await ip.public.ipv4();
-      } catch (error) {
-        logger.error(error, { testIp, stack: error.stack });
-      }
-      if (testIp && typeof testIp === 'string' && validator.isIP(testIp) && Dns.ip !== testIp) {
-        logger.info(`New ip`, testIp);
-        for (const recordType of Object.keys(confCronData.records)) {
-          switch (recordType) {
-            case 'A':
-              for (const dnsProvider of confCronData.records[recordType]) {
-                if (typeof Dns.services.updateIp[dnsProvider.dns] === 'function')
-                  await Dns.services.updateIp[dnsProvider.dns]({ ...dnsProvider, ip: testIp });
-              }
-              break;
+    const confCronData = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
+
+    let testIp;
+
+    try {
+      testIp = await ip.public.ipv4();
+    } catch (error) {
+      logger.error(error, { testIp, stack: error.stack });
+    }
+      const ipFileName = `${deployId}.ip`;
+      const currentIp = fs.existsSync(`./engine-private/deploy/${ipFileName}`)
+        ? fs.readFileSync(`./engine-private/deploy/${ipFileName}`, 'utf8')
+      : undefined;
 
-            default:
-              break;
-          }
+    if (testIp && typeof testIp === 'string' && validator.isIP(testIp) && currentIp !== testIp) {
+      logger.info(`new ip`, testIp);
+      for (const recordType of Object.keys(confCronData.records)) {
+        switch (recordType) {
+          case 'A':
+            for (const dnsProvider of confCronData.records[recordType]) {
+              if (typeof Dns.services.updateIp[dnsProvider.dns] === 'function')
+                await Dns.services.updateIp[dnsProvider.dns]({ ...dnsProvider, ip: testIp });
+            }
+            break;
+
+          default:
+            break;
         }
-        try {
-          const ipUrlTest = `https://${process.env.DEFAULT_DEPLOY_HOST}`;
-          const response = await axios.get(ipUrlTest);
-          const verifyIp = response.request.socket.remoteAddress;
-          logger.info(ipUrlTest + ' IP', verifyIp);
-          if (verifyIp === testIp) {
-            await this.saveIp(confCronPath, confCronData, testIp);
-          } else logger.error('ip not updated');
-        } catch (error) {
-          logger.error(error), 'ip not updated';
+      }
+      try {
+        const ipUrlTest = `https://${process.env.DEFAULT_DEPLOY_HOST}`;
+        const response = await axios.get(ipUrlTest);
+        const verifyIp = response.request.socket.remoteAddress;
+        logger.info(ipUrlTest + ' IP', verifyIp);
+        if (verifyIp === testIp) {
+            fs.writeFileSync(`./engine-private/deploy/${ipFileName}`, testIp, 'utf8');
+        } else logger.error('ip not updated');
+      } catch (error) {
+        logger.error(error), 'ip not updated';
         }
       }
-    };
-    await callback();
-    this.callback = callback;
-    return callback;
-  },
-  services: {
+    }
+  };
+
+  static services = {
     updateIp: {
       dondominio: (options) => {
         const { user, api_key, host, dns, ip } = options;
@@ -100,21 +97,7 @@ const Dns = {
         });
       },
     },
-  },
-  saveIp: async (confCronPath, confCronData, ip) => {
-    Dns.ip = ip;
-    confCronData.ipDaemon.ip = ip;
-    fs.writeFileSync(confCronPath, JSON.stringify(confCronData, null, 4), 'utf8');
-    shellExec(
-      `cd ./engine-private` +
-        ` && git pull ${Dns.repoUrl}` +
-        ` && git add . && git commit -m "update ip ${new Date().toLocaleDateString()}"` +
-        ` && git push ${Dns.repoUrl}`,
-      {
-        disableLog: true,
-      },
-    );
-  },
-};
+  };
+}
 
-export { Dns };
+export default Dns;

package/src/dns.js

@@ -1,22 +0,0 @@
-'use strict';
-
-// https://nodejs.org/api
-// https://expressjs.com/en/4x/api.html
-
-import dotenv from 'dotenv';
-import { loggerFactory } from './server/logger.js';
-import { Dns } from './server/dns.js';
-import { ProcessController } from './server/process.js';
-import { Config } from './server/conf.js';
-
-dotenv.config();
-
-await Config.build();
-
-const logger = loggerFactory(import.meta);
-
-await logger.setUpInfo();
-
-await Dns.InitIpDaemon();
-
-ProcessController.init(logger);