underpost 2.8.56 → 2.8.62

package/.vscode/settings.json

@@ -119,5 +119,8 @@
   "docwriter.hotkey.mac": "⌘ + .",
   "[dotenv]": {
     "editor.defaultFormatter": "foxundermoon.shell-format"
+  },
+  "[shellscript]": {
+    "editor.defaultFormatter": "foxundermoon.shell-format"
   }
 }

package/bin/index.js

@@ -6,9 +6,6 @@ import Underpost from '../src/index.js';
 import { getUnderpostRootPath, 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 UnderpostDB from '../src/cli/db.js';
-import UnderpostCron from '../src/cli/cron.js';
 
 const underpostRootPath = getUnderpostRootPath();
 fs.existsSync(`${underpostRootPath}/.env`)
@@ -106,7 +103,9 @@ program
   .option('--info-router', 'Display router structure')
   .option('--expose', 'Expose service match deploy-list')
   .option('--info-util', 'Display kubectl util management commands')
+  .option('--cert', 'Reset tls/ssl certificate secrets')
   .option('--build-manifest', 'Build kind yaml manifests: deployments, services, proxy and secrets')
+  .option('--version', 'Set custom version')
   .description('Manage deployment, for default deploy development pods')
   .action(Underpost.deploy.callback);
 
@@ -130,6 +129,7 @@ program
   .argument('<deploy-id>', 'Deploy configuration id')
   .argument('[env]', 'Optional environment, for default is development')
   .option('--run', 'Run custom entry point script')
+  .option('--build', 'Build custom image container scripts')
   .description('Dockerfile custom node build script')
   .action(Underpost.image.dockerfile.script);
 
@@ -140,6 +140,8 @@ program
   .argument('[path]', 'Absolute or relative directory, for default is current')
   .option('--image-archive', 'Only load tar image from ./images')
   .option('--podman-save', 'Save image from podman to ./images')
+  .option('--image-name <image-name>', 'Set custom image name')
+  .option('--image-version <image-version>', 'Set custom image version')
   .description('Build image from Dockerfile')
   .action(Underpost.image.dockerfile.build);
 
@@ -161,13 +163,18 @@ program
   .option('--import', 'Import container backups from repositories')
   .option('--export', 'Export container backups to repositories')
   .option('--pod-name <pod-name>', 'Optional pod context')
+  .option('--collection <collection>', 'Collection')
+  .option('--out-path <out-path>', 'Custom out path backup')
+  .option('--drop', 'Drop databases')
+  .option('--preserveUUID', 'Preserve Ids')
+  .option('--git', 'Upload to github')
   .option('--ns <ns-name>', 'Optional name space context')
   .description('Manage databases')
-  .action(UnderpostDB.API.callback);
+  .action(Underpost.db.callback);
 
 program
   .command('script')
-  .argument('operator', `Options: ${Object.keys(UnderpostScript.API)}`)
+  .argument('operator', `Options: ${Object.keys(Underpost.script)}`)
   .argument('<script-name>', 'Script name')
   .argument('[script-value]', 'Literal command, or path')
   .option('--itc', 'Inside container execution context')
@@ -182,9 +189,10 @@ program
 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`)
+  .argument('[job-list]', `Deploy id list, e.g. ${Object.keys(Underpost.cron)}, for default all available jobs`)
   .option('--itc', 'Inside container execution context')
   .option('--init', 'Init cron jobs for cron job default deploy id')
+  .option('--git', 'Upload to github')
   .description('Cron jobs management')
   .action(Underpost.cron.callback);
 

package/bin/vs.js

@@ -20,6 +20,7 @@ switch (process.argv[2]) {
     logger.info('Open new vs windows', 'Ctrl Shift N');
     logger.info('Close current vs windows', 'Ctrl Shift W');
     logger.info('Preview md', 'Ctrl shift V');
+    logger.info('Open git changes', 'Ctrl G + G');
     logger.warn('Terminal shortcut configure with command pallette', 'Ctl shift T');
     break;
   }

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.56'
+      engine.version: '2.8.62'
     networks:
       - load-balancer
 

package/manifests/mongodb/kustomization.yaml

@@ -7,5 +7,5 @@ resources:
   - headless-service.yaml
   - statefulset.yaml
   - backup-pv-pvc.yaml
-  - backup-cronjob.yaml
-  - backup-access.yaml
+  # - backup-cronjob.yaml
+  # - backup-access.yaml

package/package.json

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

package/src/cli/cron.js

@@ -46,7 +46,7 @@ class UnderpostCron {
     callback: async function (
       deployList = 'default',
       jobList = Object.keys(UnderpostCron.JOB),
-      options = { itc: false, init: false },
+      options = { itc: false, init: false, git: false },
     ) {
       if (options.init === true) {
         await Underpost.test.setUpInfo();

package/src/cli/db.js

@@ -2,12 +2,26 @@ import { mergeFile, splitFileFactory } from '../server/conf.js';
 import { loggerFactory } from '../server/logger.js';
 import { shellExec } from '../server/process.js';
 import fs from 'fs-extra';
+import UnderpostDeploy from './deploy.js';
 
 const logger = loggerFactory(import.meta);
 
 class UnderpostDB {
   static API = {
-    async callback(deployList = 'default', options = { import: false, export: false, podName: false, ns: false }) {
+    async callback(
+      deployList = 'default',
+      options = {
+        import: false,
+        export: false,
+        podName: false,
+        ns: false,
+        collection: '',
+        outPath: '',
+        drop: false,
+        preserveUUID: false,
+        git: false,
+      },
+    ) {
       const newBackupTimestamp = new Date().getTime();
       const nameSpace = options.ns && typeof options.ns === 'string' ? options.ns : 'default';
       for (const _deployId of deployList.split(',')) {
@@ -43,10 +57,12 @@ class UnderpostDB {
               logger.info('', { hostFolder, provider, dbName });
 
               const backUpPath = `../${repoName}/${hostFolder}`;
+              if (!fs.existsSync(backUpPath)) fs.mkdirSync(backUpPath, { recursive: true });
+              shellExec(`cd ${backUpPath} && find . -type d -empty -delete`); // delete empty folders
               const times = await fs.readdir(backUpPath);
-              const currentBackupTimestamp = Math.max(...times.map((t) => parseInt(t)));
+              const currentBackupTimestamp = Math.max(...times.map((t) => parseInt(t)).filter((t) => !isNaN(t)));
               dbs[provider][dbName].currentBackupTimestamp = currentBackupTimestamp;
-              const removeBackupTimestamp = Math.min(...times.map((t) => parseInt(t)));
+              const removeBackupTimestamp = Math.min(...times.map((t) => parseInt(t)).filter((t) => !isNaN(t)));
 
               const sqlContainerPath = `/home/${dbName}.sql`;
               const _fromPartsParts = `../${repoName}/${hostFolder}/${currentBackupTimestamp}/${dbName}-parths.json`;
@@ -68,59 +84,105 @@ class UnderpostDB {
               }
 
               if (options.export === true && times.length >= 5) {
+                logger.info('remove', `../${repoName}/${hostFolder}/${removeBackupTimestamp}`);
                 fs.removeSync(`../${repoName}/${hostFolder}/${removeBackupTimestamp}`);
+                logger.info('create', `../${repoName}/${hostFolder}/${newBackupTimestamp}`);
                 fs.mkdirSync(`../${repoName}/${hostFolder}/${newBackupTimestamp}`, { recursive: true });
               }
 
               switch (provider) {
                 case 'mariadb': {
-                  const podName =
-                    options.podName && typeof options.podName === 'string' ? options.podName : `mariadb-statefulset-0`;
+                  const podNames =
+                    options.podName && typeof options.podName === 'string'
+                      ? options.podName.split(',')
+                      : UnderpostDeploy.API.get('mariadb'); // `mariadb-statefulset-0`;
                   const serviceName = 'mariadb';
-                  if (options.import === true) {
-                    shellExec(`sudo kubectl cp ${_toSqlPath} ${nameSpace}/${podName}:/${dbName}.sql`);
-                    const cmd = `mariadb -u ${user} -p${password} ${dbName} < /${dbName}.sql`;
-                    shellExec(
-                      `kubectl exec -i ${podName} -- ${serviceName} -p${password} -e 'CREATE DATABASE ${dbName};'`,
-                    );
-                    shellExec(`sudo kubectl exec -i ${podName} -- sh -c "${cmd}"`);
-                  }
-                  if (options.export === true) {
-                    const cmd = `mariadb-dump --user=${user} --password=${password} --lock-tables ${dbName} > ${sqlContainerPath}`;
-                    shellExec(`sudo kubectl exec -i ${podName} -- sh -c "${cmd}"`);
-                    shellExec(`sudo kubectl cp ${nameSpace}/${podName}:${sqlContainerPath} ${_toNewSqlPath}`);
-                    await splitFileFactory(dbName, _toNewSqlPath);
+                  for (const podNameData of [podNames[0]]) {
+                    const podName = podNameData.NAME;
+                    if (options.import === true) {
+                      shellExec(`sudo kubectl exec -i ${podName} -- sh -c "rm -rf /${dbName}.sql"`);
+                      shellExec(`sudo kubectl cp ${_toSqlPath} ${nameSpace}/${podName}:/${dbName}.sql`);
+                      const cmd = `mariadb -u ${user} -p${password} ${dbName} < /${dbName}.sql`;
+                      shellExec(
+                        `kubectl exec -i ${podName} -- ${serviceName} -p${password} -e 'CREATE DATABASE ${dbName};'`,
+                      );
+                      shellExec(`sudo kubectl exec -i ${podName} -- sh -c "${cmd}"`);
+                    }
+                    if (options.export === true) {
+                      shellExec(`sudo kubectl exec -i ${podName} -- sh -c "rm -rf ${sqlContainerPath}"`);
+                      const cmd = `mariadb-dump --user=${user} --password=${password} --lock-tables ${dbName} > ${sqlContainerPath}`;
+                      shellExec(`sudo kubectl exec -i ${podName} -- sh -c "${cmd}"`);
+                      shellExec(
+                        `sudo kubectl cp ${nameSpace}/${podName}:${sqlContainerPath} ${
+                          options.outPath ? options.outPath : _toNewSqlPath
+                        }`,
+                      );
+                      await splitFileFactory(dbName, options.outPath ? options.outPath : _toNewSqlPath);
+                    }
                   }
                   break;
                 }
 
                 case 'mongoose': {
                   if (options.import === true) {
-                    const podName =
-                      options.podName && typeof options.podName === 'string' ? options.podName : `mongodb-0`;
-                    shellExec(`sudo kubectl cp ${_toBsonPath} ${nameSpace}/${podName}:/${dbName}`);
-                    const cmd = `mongorestore -d ${dbName} /${dbName}`;
-                    shellExec(`sudo kubectl exec -i ${podName} -- sh -c "${cmd}"`);
+                    const podNames =
+                      options.podName && typeof options.podName === 'string'
+                        ? options.podName.split(',')
+                        : UnderpostDeploy.API.get('mongo');
+                    // `mongodb-0`;
+                    for (const podNameData of [podNames[0]]) {
+                      const podName = podNameData.NAME;
+                      shellExec(`sudo kubectl exec -i ${podName} -- sh -c "rm -rf /${dbName}"`);
+                      shellExec(
+                        `sudo kubectl cp ${
+                          options.outPath ? options.outPath : _toBsonPath
+                        } ${nameSpace}/${podName}:/${dbName}`,
+                      );
+                      const cmd = `mongorestore -d ${dbName} /${dbName}${options.drop ? ' --drop' : ''}${
+                        options.preserveUUID ? ' --preserveUUID' : ''
+                      }`;
+                      shellExec(`sudo kubectl exec -i ${podName} -- sh -c "${cmd}"`);
+                    }
                   }
                   if (options.export === true) {
-                    const podName = `backup-access`;
-                    const containerBaseBackupPath = '/backup';
-                    let timeFolder = shellExec(
-                      `sudo kubectl exec -i ${podName} -- sh -c "cd ${containerBaseBackupPath} && ls -a"`,
-                      {
-                        stdout: true,
-                        disableLog: false,
-                        silent: true,
-                      },
-                    ).split(`\n`);
-                    timeFolder = timeFolder[timeFolder.length - 2];
-                    if (timeFolder === '..') {
-                      logger.warn(`Cannot backup available`, { timeFolder });
-                    } else {
+                    const podNames =
+                      options.podName && typeof options.podName === 'string'
+                        ? options.podName.split(',')
+                        : UnderpostDeploy.API.get('mongo'); // `backup-access`;
+                    for (const podNameData of [podNames[0]]) {
+                      const podName = podNameData.NAME;
+                      shellExec(`sudo kubectl exec -i ${podName} -- sh -c "rm -rf /${dbName}"`);
+                      if (options.collections)
+                        for (const collection of options.collections)
+                          shellExec(
+                            `sudo kubectl exec -i ${podName} -- sh -c "mongodump -d ${dbName} --collection ${collection} -o /"`,
+                          );
+                      else shellExec(`sudo kubectl exec -i ${podName} -- sh -c "mongodump -d ${dbName} -o /"`);
                       shellExec(
-                        `sudo kubectl cp ${nameSpace}/${podName}:${containerBaseBackupPath}/${timeFolder}/${dbName} ${_toNewBsonPath}`,
+                        `sudo kubectl cp ${nameSpace}/${podName}:/${dbName} ${
+                          options.outPath ? options.outPath : _toNewBsonPath
+                        }`,
                       );
                     }
+                    if (false) {
+                      const containerBaseBackupPath = '/backup';
+                      let timeFolder = shellExec(
+                        `sudo kubectl exec -i ${podName} -- sh -c "cd ${containerBaseBackupPath} && ls -a"`,
+                        {
+                          stdout: true,
+                          disableLog: false,
+                          silent: true,
+                        },
+                      ).split(`\n`);
+                      timeFolder = timeFolder[timeFolder.length - 2];
+                      if (timeFolder === '..') {
+                        logger.warn(`Cannot backup available`, { timeFolder });
+                      } else {
+                        shellExec(
+                          `sudo kubectl cp ${nameSpace}/${podName}:${containerBaseBackupPath}/${timeFolder}/${dbName} ${_toNewBsonPath}`,
+                        );
+                      }
+                    }
                   }
                   break;
                 }
@@ -131,7 +193,7 @@ class UnderpostDB {
             }
           }
         }
-        if (options.export === true) {
+        if (options.export === true && options.git === true) {
           shellExec(`cd ../${repoName} && git add .`);
           shellExec(
             `underpost cmt ../${repoName} backup '' '${new Date(newBackupTimestamp).toLocaleDateString()} ${new Date(

package/src/cli/deploy.js

@@ -32,7 +32,7 @@ class UnderpostDeploy {
       await Config.build(undefined, 'proxy', deployList);
       return buildPortProxyRouter(env === 'development' ? 80 : 443, buildProxyRouter());
     },
-    async buildManifest(deployList, env) {
+    async buildManifest(deployList, env, version) {
       for (const _deployId of deployList.split(',')) {
         const deployId = _deployId.trim();
         if (!deployId) continue;
@@ -50,7 +50,7 @@ class UnderpostDeploy {
         if (env === 'development') fs.mkdirSync(`./manifests/deployment/${deployId}-${env}`, { recursive: true });
 
         logger.info('port range', { deployId, fromPort, toPort });
-
+        // const customImg = `underpost-engine:${version && typeof version === 'string' ? version : Underpost.version}`;
         const deploymentYamlParts = `apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -69,7 +69,30 @@ spec:
     spec:
       containers:
         - name: ${deployId}-${env}
-          image: localhost/${deployId}-${env}:${Underpost.version}
+          image: localhost/debian:underpost
+          command:
+            - /bin/sh
+            - -c
+            - >
+              underpost dockerfile-node-script --build --run ${deployId} ${env}
+          lifecycle:
+            postStart:
+              exec:
+                command:
+                  - /bin/sh
+                  - -c
+                  - >
+                    sleep 20 &&
+                    npm install -g underpost
+                    underpost secret underpost --create-from-file /etc/config/.env.${env}
+          volumeMounts:
+            - name: config-volume
+              mountPath: /etc/config
+      volumes:
+        - name: config-volume
+          configMap:
+            name: underpost-config
+# image: localhost/${deployId}-${env}:${version && typeof version === 'string' ? version : Underpost.version}
 ---
 apiVersion: v1
 kind: Service
@@ -180,7 +203,16 @@ spec:
     async callback(
       deployList = 'default',
       env = 'development',
-      options = { remove: false, infoRouter: false, sync: false, buildManifest: false, infoUtil: false, expose: false },
+      options = {
+        remove: false,
+        infoRouter: false,
+        sync: false,
+        buildManifest: false,
+        infoUtil: false,
+        expose: false,
+        cert: false,
+        version: '',
+      },
     ) {
       if (options.infoUtil === true)
         return logger.info(`
@@ -191,9 +223,13 @@ kubectl scale statefulsets <stateful-set-name> --replicas=<new-replicas>
       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.buildManifest === true) await UnderpostDeploy.API.buildManifest(deployList, env, options.version);
       if (options.infoRouter === true)
         return logger.info('router', await UnderpostDeploy.API.routerFactory(deployList, env));
+      shellExec(`kubectl delete configmap underpost-config`);
+      shellExec(
+        `kubectl create configmap underpost-config --from-file=/home/dd/engine/engine-private/conf/dd-cron/.env.${env}`,
+      );
       const etcHost = (
         concat,
       ) => `127.0.0.1  ${concat} localhost localhost.localdomain localhost4 localhost4.localdomain4
@@ -219,7 +255,7 @@ kubectl scale statefulsets <stateful-set-name> --replicas=<new-replicas>
         const confServer = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'));
         for (const host of Object.keys(confServer)) {
           shellExec(`sudo kubectl delete HTTPProxy ${host}`);
-          if (env === 'production') shellExec(`sudo kubectl delete Certificate ${host}`);
+          if (env === 'production' && options.cert === true) shellExec(`sudo kubectl delete Certificate ${host}`);
           if (!options.remove === true && env === 'development') concatHots += ` ${host}`;
         }
 
@@ -231,7 +267,8 @@ kubectl scale statefulsets <stateful-set-name> --replicas=<new-replicas>
         if (!options.remove === true) {
           shellExec(`sudo kubectl apply -f ./${manifestsPath}/deployment.yaml`);
           shellExec(`sudo kubectl apply -f ./${manifestsPath}/proxy.yaml`);
-          if (env === 'production') shellExec(`sudo kubectl apply -f ./${manifestsPath}/secret.yaml`);
+          if (env === 'production' && options.cert === true)
+            shellExec(`sudo kubectl apply -f ./${manifestsPath}/secret.yaml`);
         }
       }
       let renderHosts;

package/src/cli/env.js

@@ -28,15 +28,21 @@ class UnderpostRootEnv {
     get(key) {
       const exeRootPath = `${getNpmRootPath()}/underpost`;
       const envPath = `${exeRootPath}/.env`;
-      if (!fs.existsSync(envPath)) return logger.error(`Unable to find underpost root environment`);
+      if (!fs.existsSync(envPath)) {
+        logger.error(`Unable to find underpost root environment`);
+        return undefined;
+      }
       const env = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
-      logger.info('underpost root', { [key]: env[key] });
+      logger.info(`${key}(${typeof env[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`);
+      if (!fs.existsSync(envPath)) {
+        logger.error(`Unable to find underpost root environment`);
+        return {};
+      }
       const env = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
       logger.info('underpost root', env);
       return env;

package/src/cli/fs.js

@@ -38,23 +38,36 @@ class UnderpostFileStorage {
       options = { rm: false, recursive: false, deployId: '', force: false, pull: false, git: false },
     ) {
       const { storage, storageConf } = UnderpostFileStorage.API.getStorageConf(options);
+      const deleteFiles = UnderpostRepository.API.getDeleteFiles(path);
+      for (const relativePath of deleteFiles) {
+        const _path = path + '/' + relativePath;
+        if (_path in storage) {
+          await UnderpostFileStorage.API.delete(_path);
+          delete storage[_path];
+        }
+      }
       const files =
         options.git === true
           ? UnderpostRepository.API.getChangedFiles(path)
           : await fs.readdir(path, { recursive: true });
-      for (const relativePath of files) {
-        const _path = path + '/' + relativePath;
-        if (fs.statSync(_path).isDirectory()) {
-          if (options.pull === true && !fs.existsSync(_path)) fs.mkdirSync(_path, { recursive: true });
-          continue;
+      if (options.pull === true) {
+        for (const _path of Object.keys(storage)) {
+          if (!fs.existsSync(_path) || options.force === true) {
+            if (options.force === true && fs.existsSync(_path)) fs.removeSync(_path);
+            await UnderpostFileStorage.API.pull(_path, options);
+          } else logger.warn(`Pull path already exists`, _path);
+        }
+      } else
+        for (const relativePath of files) {
+          const _path = path + '/' + relativePath;
+          if (fs.statSync(_path).isDirectory()) {
+            if (options.pull === true && !fs.existsSync(_path)) fs.mkdirSync(_path, { recursive: true });
+            continue;
+          } else if (!(_path in storage) || options.force === true) {
+            await UnderpostFileStorage.API.upload(_path, options);
+            if (storage) storage[_path] = {};
+          } else logger.warn('File already exists', _path);
         }
-        if (options.pull === true) {
-          await UnderpostFileStorage.API.pull(_path, options);
-        } else if (!(_path in storage) || options.force === true) {
-          await UnderpostFileStorage.API.upload(_path, options);
-          if (storage) storage[_path] = {};
-        } else logger.warn('File already exists', _path);
-      }
       UnderpostFileStorage.API.writeStorageConf(storage, storageConf);
       if (options.git === true) {
         shellExec(`cd ${path} && git add .`);
@@ -91,6 +104,8 @@ class UnderpostFileStorage {
     },
     async pull(path) {
       UnderpostFileStorage.API.cloudinaryConfig();
+      const folder = dir.dirname(path);
+      if (!fs.existsSync(folder)) fs.mkdirSync(folder, { recursive: true });
       const downloadResult = await cloudinary.utils.download_archive_url({
         public_ids: [path],
         resource_type: 'raw',

package/src/cli/image.js

@@ -1,12 +1,16 @@
 import fs from 'fs-extra';
 import Underpost from '../index.js';
-import { shellExec } from '../server/process.js';
+import { shellCd, shellExec } from '../server/process.js';
 import dotenv from 'dotenv';
 import { getNpmRootPath } from '../server/conf.js';
 import { timer } from '../client/components/core/CommonJs.js';
+import UnderpostRootEnv from './env.js';
+import { loggerFactory } from '../server/logger.js';
 
 dotenv.config();
 
+const logger = loggerFactory(import.meta);
+
 class UnderpostImage {
   static API = {
     dockerfile: {
@@ -17,9 +21,13 @@ class UnderpostImage {
         deployId = 'default',
         env = 'development',
         path = '.',
-        options = { imageArchive: false, podmanSave: false },
+        options = { imageArchive: false, podmanSave: false, imageName: '', imageVersion: '' },
       ) {
-        const imgName = `${deployId}-${env}:${Underpost.version}`;
+        const imgName = `${
+          options.imageName && typeof options.imageName === 'string' ? options.imageName : `${deployId}-${env}`
+        }:${
+          options.imageVersion && typeof options.imageVersion === 'string' ? options.imageVersion : Underpost.version
+        }`;
         const podManImg = `localhost/${imgName}`;
         const imagesStoragePath = `/images`;
         if (!fs.existsSync(`${path}${imagesStoragePath}`))
@@ -38,25 +46,29 @@ class UnderpostImage {
         }
         // --rm --no-cache
         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}`,
           );
-          fs.removeSync(`${path}/.env.underpost`);
         }
         if (options.imageArchive !== true || options.podmanSave === true)
           shellExec(`cd ${path} && podman save -o ${tarFile} ${podManImg}`);
         shellExec(`cd ${path} && sudo kind load image-archive ${tarFile}`);
       },
-      async script(deployId = 'default', env = 'development', options = { run: false }) {
+      async script(deployId = 'default', env = 'development', options = { run: false, build: false }) {
+        if (options.build === true) {
+          const buildBasePath = `/home/dd`;
+          const repoName = `engine-${deployId.split('-')[1]}`;
+          shellExec(`cd ${buildBasePath} && underpost clone underpostnet/${repoName}`);
+          shellExec(`cd ${buildBasePath} && sudo mv ./${repoName} ./engine`);
+          shellExec(`cd ${buildBasePath}/engine && underpost clone underpostnet/${repoName}-private`);
+          shellExec(`cd ${buildBasePath}/engine && sudo mv ./${repoName}-private ./engine-private`);
+          shellCd(`${buildBasePath}/engine`);
+          shellExec(`underpost install`);
+          const itcScripts = fs.readdir('./engine-private/itc-scripts');
+          for (const itcScript of itcScripts)
+            if (itcScript.match(deployId)) shellExec(`node ./engine-private/itc-scripts/${itcScript}`);
+        }
         switch (deployId) {
-          case 'dd-lampp':
-            {
-              const lamppPublicPath = '/xampp/htdocs/online';
-              shellExec(`sudo mkdir -p ${lamppPublicPath}`);
-            }
-            break;
-
           default:
             {
               {
@@ -97,7 +109,7 @@ class UnderpostImage {
             const replicas = await fs.readdir(`./engine-private/replica`);
             for (const replica of replicas) {
               shellExec(`node bin/deploy conf ${replica} ${env}`);
-              shellExec(`npm ${runCmd} ${replica} deploy`, { async: true });
+              shellExec(`npm ${runCmd} deploy deploy-id:${replica}`, { async: true });
               fs.writeFileSync(`./tmp/await-deploy`, '', 'utf8');
               const monitor = async () => {
                 await timer(1000);
@@ -107,7 +119,7 @@ class UnderpostImage {
             }
             shellExec(`node bin/deploy conf ${deployId} ${env}`);
           }
-          shellExec(`npm ${runCmd} ${deployId} deploy`);
+          shellExec(`npm ${runCmd} deploy deploy-id:${deployId}`);
         }
       },
     },

package/src/cli/repository.js

@@ -99,17 +99,25 @@ class UnderpostRepository {
       });
     },
 
+    getDeleteFiles(path = '.') {
+      const commandUntrack = `cd ${path} && git ls-files --deleted`;
+      const diffUntrackOutput = shellExec(commandUntrack, { stdout: true, silent: true });
+      return diffUntrackOutput.toString().split('\n').filter(Boolean);
+    },
+
     getChangedFiles(path = '.', extension = '', head = false) {
       const extensionFilter = extension ? `-- '***.${extension}'` : '';
       const command = `cd ${path} && git diff ${head ? 'HEAD^ HEAD ' : ''}--name-only ${extensionFilter}`;
       const commandUntrack = `cd ${path} && git ls-files --others --exclude-standard`;
       const diffOutput = shellExec(command, { stdout: true, silent: true });
       const diffUntrackOutput = shellExec(commandUntrack, { stdout: true, silent: true });
+      const deleteFiles = UnderpostRepository.API.getDeleteFiles(path);
       return diffOutput
         .toString()
         .split('\n')
         .filter(Boolean)
-        .concat(diffUntrackOutput.toString().split('\n').filter(Boolean));
+        .concat(diffUntrackOutput.toString().split('\n').filter(Boolean))
+        .filter((f) => !deleteFiles.includes(f));
     },
   };
 }

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

@@ -404,7 +404,15 @@ const CalendarCore = {
         <div class="in" style="margin-bottom: 100px"></div>`;
     };
 
+    let delayBlock = false;
     this.Data[options.idModal].updatePanel = async () => {
+      if (delayBlock) return;
+      else {
+        delayBlock = true;
+        setTimeout(() => {
+          delayBlock = false;
+        }, 500);
+      }
       const cid = getQueryParams().cid ? getQueryParams().cid : '';
       if (options.route === 'home') Modal.homeCid = newInstance(cid);
       if (s(`.main-body-calendar-${options.idModal}`)) {
@@ -426,7 +434,10 @@ const CalendarCore = {
         },
       });
 
-    if (options.route === 'home') setTimeout(CalendarCore.Data[options.idModal].updatePanel);
+    // if (options.route === 'home')
+    setTimeout(() => {
+      CalendarCore.Data[options.idModal].updatePanel();
+    });
 
     return html`
       <style>