underpost 2.8.531 → 2.8.611

package/src/cli/db.js

@@ -2,14 +2,28 @@ 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 }) {
+    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 = 'default';
+      const nameSpace = options.ns && typeof options.ns === 'string' ? options.ns : 'default';
       for (const _deployId of deployList.split(',')) {
         const deployId = _deployId.trim();
         if (!deployId) continue;
@@ -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,57 +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 = `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 = `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;
                 }
@@ -129,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;
@@ -69,7 +69,18 @@ spec:
     spec:
       containers:
         - name: ${deployId}-${env}
-          image: localhost/${deployId}-${env}:${Underpost.version}
+          image: localhost/underpost-engine:${version && typeof version === 'string' ? version : Underpost.version}
+          lifecycle:
+            postStart:
+              exec:
+                command:
+                  - /bin/sh
+                  - -c
+                  - >
+                    sleep 60 &&
+                    underpost config set deploy-id ${deployId} &&
+                    underpost config set deploy-env ${env}
+# image: localhost/${deployId}-${env}:${version && typeof version === 'string' ? version : Underpost.version}
 ---
 apiVersion: v1
 kind: Service
@@ -180,32 +191,55 @@ spec:
     async callback(
       deployList = 'default',
       env = 'development',
-      options = { remove: false, infoRouter: false, sync: false, buildManifest: false },
+      options = {
+        remove: false,
+        infoRouter: false,
+        sync: false,
+        buildManifest: false,
+        infoUtil: false,
+        expose: false,
+        cert: false,
+        version: '',
+      },
     ) {
+      if (options.infoUtil === true)
+        return logger.info(`
+kubectl rollout restart deployment/deployment-name
+kubectl rollout undo deployment/deployment-name
+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));
+      const etcHost = (
+        concat,
+      ) => `127.0.0.1  ${concat} localhost localhost.localdomain localhost4 localhost4.localdomain4
+::1         localhost localhost.localdomain localhost6 localhost6.localdomain6`;
+      let concatHots = '';
 
       for (const _deployId of deployList.split(',')) {
         const deployId = _deployId.trim();
         if (!deployId) continue;
-
+        if (options.expose === true) {
+          const svc = UnderpostDeploy.API.get(deployId, 'svc')[0];
+          const port = parseInt(svc[`PORT(S)`].split('/TCP')[0]);
+          logger.info(deployId, {
+            svc,
+            port,
+          });
+          shellExec(`sudo kubectl port-forward -n default svc/${svc.NAME} ${port}:${port}`, { async: true });
+          continue;
+        }
         shellExec(`sudo kubectl delete svc ${deployId}-${env}-service`);
         shellExec(`sudo kubectl delete deployment ${deployId}-${env}`);
 
-        const etcHost = (
-          concat,
-        ) => `127.0.0.1  ${concat} localhost localhost.localdomain localhost4 localhost4.localdomain4
-::1         localhost localhost.localdomain localhost6 localhost6.localdomain6`;
-        let concatHots = '';
-
         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}`;
         }
 
@@ -217,39 +251,38 @@ spec:
         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;
+      switch (process.platform) {
+        case 'linux':
+          {
+            switch (env) {
+              case 'development':
+                renderHosts = etcHost(concatHots);
+                fs.writeFileSync(`/etc/hosts`, renderHosts, 'utf8');
 
-        let renderHosts;
-
-        switch (process.platform) {
-          case 'linux':
-            {
-              switch (env) {
-                case 'development':
-                  renderHosts = etcHost(concatHots);
-                  fs.writeFileSync(`/etc/hosts`, renderHosts, 'utf8');
-
-                  break;
+                break;
 
-                default:
-                  break;
-              }
+              default:
+                break;
             }
-            break;
+          }
+          break;
 
-          default:
-            break;
-        }
-        if (renderHosts)
-          logger.info(
-            `
-` + renderHosts,
-          );
+        default:
+          break;
       }
+      if (renderHosts)
+        logger.info(
+          `
+` + renderHosts,
+        );
     },
-    getPods(deployId) {
-      const raw = shellExec(`sudo kubectl get pods --all-namespaces -o wide`, {
+    get(deployId, kindType = 'pods') {
+      const raw = shellExec(`sudo kubectl get ${kindType} --all-namespaces -o wide`, {
         stdout: true,
         disableLog: true,
         silent: true,

package/src/cli/fs.js

@@ -0,0 +1,149 @@
+import { v2 as cloudinary } from 'cloudinary';
+import { loggerFactory } from '../server/logger.js';
+import dotenv from 'dotenv';
+import AdmZip from 'adm-zip';
+import * as dir from 'path';
+import fs from 'fs-extra';
+import { Downloader } from '../server/downloader.js';
+import UnderpostRepository from './repository.js';
+import { shellExec } from '../server/process.js';
+dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+class UnderpostFileStorage {
+  static API = {
+    cloudinaryConfig() {
+      // https://console.cloudinary.com/
+      cloudinary.config({
+        cloud_name: process.env.CLOUDINARY_CLOUD_NAME,
+        api_key: process.env.CLOUDINARY_API_KEY,
+        api_secret: process.env.CLOUDINARY_API_SECRET,
+      });
+    },
+    getStorageConf(options) {
+      let storage, storageConf;
+      if (options.deployId && typeof options.deployId === 'string') {
+        storageConf = `./engine-private/conf/${options.deployId}/storage.json`;
+        if (!fs.existsSync(storageConf)) fs.writeFileSync(storageConf, JSON.stringify({}), 'utf8');
+        storage = JSON.parse(fs.readFileSync(storageConf, 'utf8'));
+      }
+      return { storage, storageConf };
+    },
+    writeStorageConf(storage, storageConf) {
+      if (storage) fs.writeFileSync(storageConf, JSON.stringify(storage, null, 4), 'utf8');
+    },
+    async recursiveCallback(
+      path,
+      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 });
+      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);
+        }
+      UnderpostFileStorage.API.writeStorageConf(storage, storageConf);
+      if (options.git === true) {
+        shellExec(`cd ${path} && git add .`);
+        shellExec(`underpost cmt ${path} feat`);
+      }
+    },
+    async callback(
+      path,
+      options = { rm: false, recursive: false, deployId: '', force: false, pull: false, git: false },
+    ) {
+      if (options.recursive === true || options.git === true)
+        return await UnderpostFileStorage.API.recursiveCallback(path, options);
+      if (options.pull === true) return await UnderpostFileStorage.API.pull(path, options);
+      if (options.rm === true) return await UnderpostFileStorage.API.delete(path, options);
+      return await UnderpostFileStorage.API.upload(path, options);
+    },
+    async upload(path, options = { rm: false, recursive: false, deployId: '', force: false, pull: false }) {
+      UnderpostFileStorage.API.cloudinaryConfig();
+      const { storage, storageConf } = UnderpostFileStorage.API.getStorageConf(options);
+      // path = UnderpostFileStorage.API.file2Zip(path);
+      const uploadResult = await cloudinary.uploader
+        .upload(path, {
+          public_id: path,
+          resource_type: 'raw',
+          overwrite: options.force === true ? true : false,
+        })
+        .catch((error) => {
+          logger.error(error, { path, stack: error.stack });
+        });
+      logger.info('upload result', uploadResult);
+      if (storage) storage[path] = {};
+      UnderpostFileStorage.API.writeStorageConf(storage, storageConf);
+      return uploadResult;
+    },
+    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',
+      });
+      logger.info('download result', downloadResult);
+      await Downloader(downloadResult, path + '.zip');
+      path = UnderpostFileStorage.API.zip2File(path + '.zip');
+      fs.removeSync(path + '.zip');
+    },
+    async delete(path) {
+      UnderpostFileStorage.API.cloudinaryConfig();
+      const deleteResult = await cloudinary.api
+        .delete_resources([path], { type: 'upload', resource_type: 'raw' })
+        .catch((error) => {
+          logger.error(error, { path, stack: error.stack });
+        });
+      logger.info('delete result', deleteResult);
+      return deleteResult;
+    },
+    file2Zip(path) {
+      const zip = new AdmZip();
+      zip.addLocalFile(path, '/');
+      path = path + '.zip';
+      zip.writeZip(path);
+      return path;
+    },
+    zip2File(path) {
+      const zip = new AdmZip(path);
+      path = path.replaceAll('.zip', '');
+      zip.extractEntryTo(
+        /*entry name*/ path.split('/').pop(),
+        /*target path*/ dir.dirname(path),
+        /*maintainEntryPath*/ false,
+        /*overwrite*/ true,
+      );
+      return path;
+    },
+  };
+}
+
+export default UnderpostFileStorage;

package/src/cli/image.js

@@ -1,9 +1,10 @@
 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';
 
 dotenv.config();
 
@@ -17,9 +18,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.imageVersions === 'string' ? options.imageVersion : Underpost.version
+        }`;
         const podManImg = `localhost/${imgName}`;
         const imagesStoragePath = `/images`;
         if (!fs.existsSync(`${path}${imagesStoragePath}`))
@@ -48,7 +53,32 @@ class UnderpostImage {
           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 (deployId === 'deploy') {
+          const _deployId = UnderpostRootEnv.API.get('deploy-id');
+          const _env = UnderpostRootEnv.API.get('deploy-env');
+          if (_deployId) {
+            deployId = _deployId;
+            if (_env) env = _env;
+          } else {
+            await timer(30 * 1000);
+            return await UnderpostImage.API.dockerfile.script(deployId, env, options);
+          }
+        }
+        if (options.build === true) {
+          const buildBasePath = `/home/dd`;
+          const repoName = `engine-${deployId.split('-')[1]}`;
+          fs.mkdirSync(buildBasePath, { recursive: true });
+          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(`npm 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':
             {
@@ -97,7 +127,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 +137,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

@@ -98,6 +98,27 @@ 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))
+        .filter((f) => !deleteFiles.includes(f));
+    },
   };
 }
 

package/src/cli/script.js

@@ -19,16 +19,22 @@ class UnderpostScript {
       const packageJson = JSON.parse(fs.readFileSync(`${npmRoot}/package.json`, 'utf8'));
       if (options.itc === true) {
         value = packageJson.scripts[key];
-        if (fs.existsSync(`${value}`)) {
-          const podScriptPath = `/${value.split('/').pop()}`;
-          const nameSpace = options.ns && typeof options.ns === 'string' ? options.ns : 'default';
-          const podMatch = options.podName && typeof options.podName === 'string' ? options.podName : key;
+        const podScriptPath = `${options.itcPath && typeof options.itcPath === 'string' ? options.itcPath : '/'}${value
+          .split('/')
+          .pop()}`;
+        const nameSpace = options.ns && typeof options.ns === 'string' ? options.ns : 'default';
+        const podMatch = options.podName && typeof options.podName === 'string' ? options.podName : key;
 
-          for (const pod of UnderpostDeploy.API.getPods(podMatch)) {
+        if (fs.existsSync(`${value}`)) {
+          for (const pod of UnderpostDeploy.API.get(podMatch)) {
             shellExec(`sudo kubectl cp ${value} ${nameSpace}/${pod.NAME}:${podScriptPath}`);
-            const cmd = `cd / && node ${podScriptPath}`;
+            const cmd = `node ${podScriptPath}`;
             shellExec(`sudo kubectl exec -i ${pod.NAME} -- sh -c "${cmd}"`);
           }
+        } else {
+          for (const pod of UnderpostDeploy.API.get(podMatch)) {
+            shellExec(`sudo kubectl exec -i ${pod.NAME} -- sh -c "${value}"`);
+          }
         }
 
         return;