underpost 2.7.83 → 2.7.91

package/src/server/backup.js

@@ -9,100 +9,112 @@ dotenv.config();
 const logger = loggerFactory(import.meta);
 
 const BackUpManagement = {
-  repoUrl: `https://${process.env.GITHUB_BACKUP_TOKEN}@github.com/${process.env.GITHUB_BACKUP_USERNAME}/${process.env.GITHUB_BACKUP_REPO}.git`,
-  Init: async function () {
-    await this.Callback();
-    return this.Callback;
-  },
-  Callback: async function () {
-    const privateCronConfPath = `./engine-private/conf/${process.argv[2]}/conf.cron.json`;
+  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`;
 
-    const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
+      const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
 
-    const { backups } = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
+      const { backups } = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
 
-    if (!backups) return;
+      if (!backups) return;
 
-    const currentDate = new Date().getTime();
+      logger.info('init backups callback');
+      await logger.setUpInfo();
 
-    if (!fs.existsSync('./engine-private/cron-backups'))
-      fs.mkdirSync('./engine-private/cron-backups', { recursive: true });
+      const currentDate = new Date().getTime();
 
-    for (const deployGroupData of backups) {
-      const { deployGroupId } = deployGroupData;
-      const dataDeploy = getDataDeploy({ deployGroupId });
+      if (!fs.existsSync('./engine-private/cron-backups'))
+        fs.mkdirSync('./engine-private/cron-backups', { recursive: true });
 
-      for (const deployObj of dataDeploy) {
-        const { deployId, replicaHost } = deployObj;
+      for (const deployGroupData of backups) {
+        const { deployGroupId } = deployGroupData;
+        const dataDeploy = getDataDeploy({ deployGroupId });
 
-        if (replicaHost) continue;
+        for (const deployObj of dataDeploy) {
+          const { deployId, replicaHost } = deployObj;
 
-        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'),
-        );
+          if (replicaHost) continue;
 
-        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];
+          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'),
+          );
 
-            if (!db || singleReplica) continue;
+          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 (!backupFrequency) backupFrequency = 'daily';
-            if (!maxBackupRetention) maxBackupRetention = 5;
+              if (!db || singleReplica) continue;
 
-            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 });
+              if (!backupFrequency) backupFrequency = 'daily';
+              if (!maxBackupRetention) maxBackupRetention = 5;
 
-            const currentBackupsDirs = files
-              .map((fileObj) => parseInt(fileObj.name))
-              .sort((a, b) => a - b)
-              .reverse();
+              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 });
 
-            switch (backupFrequency) {
-              case 'daily':
+              const currentBackupsDirs = files
+                .map((fileObj) => parseInt(fileObj.name))
+                .sort((a, b) => a - b)
+                .reverse();
 
-              default:
-                // if (currentBackupsDirs[0] && currentDate - currentBackupsDirs[0] < 1000 * 60 * 60 * 24) continue;
-                break;
-            }
+              switch (backupFrequency) {
+                case 'daily':
 
-            for (const retentionPath of currentBackupsDirs.filter((t, i) => i >= maxBackupRetention - 1)) {
-              const removePathRetention = `${backUpPath}/${retentionPath}`;
-              logger.info('Remove backup folder', removePathRetention);
-              fs.removeSync(removePathRetention);
-            }
+                default:
+                  // if (currentBackupsDirs[0] && currentDate - currentBackupsDirs[0] < 1000 * 60 * 60 * 24) continue;
+                  break;
+              }
+
+              for (const retentionPath of currentBackupsDirs.filter((t, i) => i >= maxBackupRetention - 1)) {
+                const removePathRetention = `${backUpPath}/${retentionPath}`;
+                logger.info('Remove backup folder', removePathRetention);
+                fs.removeSync(removePathRetention);
+              }
 
-            fs.mkdirSync(`${backUpPath}/${currentDate}`, { recursive: true });
+              fs.mkdirSync(`${backUpPath}/${currentDate}`, { recursive: true });
 
-            shellExec(`node bin/db ${host}${path} export ${deployId} ${backUpPath}/${currentDate}`);
+              shellExec(`node bin/db ${host}${path} export ${deployId} ${backUpPath}/${currentDate}`);
 
-            if (wp) {
-              const repoUrl = `https://${process.env.GITHUB_BACKUP_TOKEN}@github.com/${
-                process.env.GITHUB_BACKUP_USERNAME
-              }/${git.split('/').pop()}.git`;
+              if (wp) {
+                const repoUrl = `https://${process.env.GITHUB_TOKEN}@github.com/${process.env.GITHUB_USERNAME}/${git
+                  .split('/')
+                  .pop()}.git`;
 
-              shellExec(
-                `cd ${directory}` +
-                  ` && git pull ${repoUrl}` +
-                  ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
-                  ` && git push ${repoUrl}`,
-              );
+                shellExec(
+                  `cd ${directory}` +
+                    ` && git pull ${repoUrl}` +
+                    ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
+                    ` && git push ${repoUrl}`,
+                  {
+                    disableLog: true,
+                  },
+                );
+              }
             }
-          }
+        }
       }
-    }
-    shellExec(
-      `cd ./engine-private/cron-backups` +
-        ` && git pull ${BackUpManagement.repoUrl}` +
-        ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
-        ` && git push ${BackUpManagement.repoUrl}`,
-    );
+      shellExec(
+        `cd ./engine-private/cron-backups` +
+          ` && git pull ${BackUpManagement.repoUrl}` +
+          ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
+          ` && git push ${BackUpManagement.repoUrl}`,
+        {
+          disableLog: true,
+        },
+      );
+    };
+    await Callback();
+    BackUpManagement.Callback = Callback;
+    return Callback;
   },
+  Callback: async function (params) {},
 };
 
 export { BackUpManagement };

package/src/server/client-build.js

@@ -40,10 +40,22 @@ const fullBuild = async ({
 }) => {
   logger.warn('Full build', rootClientPath);
 
-  fs.removeSync(rootClientPath);
-
   buildAcmeChallengePath(acmeChallengeFullPath);
 
+  if (publicClientId && publicClientId.startsWith('html-website-templates')) {
+    if (!fs.existsSync(`/dd/html-website-templates/`))
+      shellExec(`cd /dd && git clone https://github.com/designmodo/html-website-templates.git`);
+    if (!fs.existsSync(`${rootClientPath}/index.php`)) {
+      fs.copySync(`/dd/html-website-templates/${publicClientId.split('-publicClientId-')[1]}`, rootClientPath);
+      shellExec(`cd ${rootClientPath} && git init && git add . && git commit -m "Base template implementation"`);
+      // git remote add origin git@github.com:<username>/<repo>.git
+      fs.writeFileSync(`${rootClientPath}/.git/.htaccess`, `Deny from all`, 'utf8');
+    }
+    return;
+  }
+
+  fs.removeSync(rootClientPath);
+
   if (fs.existsSync(`./src/client/public/${publicClientId}`)) {
     if (iconsBuild) {
       const defaultBaseIconFolderPath = `src/client/public/${publicClientId}/assets/logo`;
@@ -52,7 +64,7 @@ const fullBuild = async ({
       if (!fs.existsSync(defaultBaseIconPath))
         await buildTextImg(metadata.title, { debugFilename: defaultBaseIconPath });
 
-      if (path === '/' && !fs.existsSync(`./src/client/public/${publicClientId}/site.webmanifest`))
+      if (!fs.existsSync(`./src/client/public/${publicClientId}/site.webmanifest`))
         await buildIcons({ publicClientId, metadata });
     }
     fs.copySync(
@@ -89,8 +101,15 @@ const fullBuild = async ({
   if (dists)
     for (const dist of dists) {
       if ('folder' in dist) {
-        fs.mkdirSync(`${rootClientPath}${dist.public_folder}`, { recursive: true });
-        fs.copySync(dist.folder, `${rootClientPath}${dist.public_folder}`);
+        if (fs.statSync(dist.folder).isDirectory()) {
+          fs.mkdirSync(`${rootClientPath}${dist.public_folder}`, { recursive: true });
+          fs.copySync(dist.folder, `${rootClientPath}${dist.public_folder}`);
+        } else {
+          const folder = dist.public_folder.split('/');
+          folder.pop();
+          fs.mkdirSync(`${rootClientPath}${folder.join('/')}`, { recursive: true });
+          fs.copyFileSync(dist.folder, `${rootClientPath}${dist.public_folder}`);
+        }
       }
       if ('styles' in dist) {
         fs.mkdirSync(`${rootClientPath}${dist.public_styles_folder}`, { recursive: true });
@@ -188,7 +207,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
           iconsBuild,
           metadata,
         });
-        if (apis)
+        if (apis && false)
           for (const apiBuildScript of apis) {
             const scriptPath = `src/api/${apiBuildScript}/${apiBuildScript}.build.js`;
             if (fs.existsSync(`./${scriptPath}`)) {
@@ -248,8 +267,13 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                   'const getBaseHost = () => location.host;',
                   `const getBaseHost = () => '${apiBaseHost}';`,
                 );
-              if (apiBaseProxyPath)
+              if (apiBaseProxyPath) {
                 jsSrc = jsSrc.replace('${getProxyPath()}api/', `${apiBaseProxyPath}${process.env.BASE_API}/`);
+                jsSrc = jsSrc.replace(
+                  "const getWsBasePath = () => (getProxyPath() !== '/' ? `${getProxyPath()}socket.io/` : undefined);",
+                  `const getWsBasePath = () => '${apiBaseProxyPath}socket.io/';`,
+                );
+              }
             }
             fs.writeFileSync(
               jsPublicPath,
@@ -288,11 +312,11 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
       eval(await srcFormatted(fs.readFileSync(`./src/client/ssr/Render.js`, 'utf8')));
 
       if (views) {
-        const buildJsSrcPage = async (jsSrcPath, jsPublicPath) => {
+        const buildJsSrcPage = async (jsSrcPath, jsPublicPath, filter) => {
           if (!(enableLiveRebuild && !options.liveClientBuildPaths.find((p) => p.srcBuildPath === jsSrcPath))) {
             let jsSrc = viewFormatted(await srcFormatted(fs.readFileSync(jsSrcPath, 'utf8')), dists, path, baseHost);
             if (jsSrc.split('/*imports*/')[1]) jsSrc = jsSrc.split('/*imports*/')[1];
-
+            if (filter) jsSrc = await filter(jsSrc);
             fs.writeFileSync(
               jsPublicPath,
               minifyBuild || process.env.NODE_ENV === 'production' ? UglifyJS.minify(jsSrc).code : jsSrc,
@@ -301,47 +325,17 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
           }
         };
 
-        if (path === '/') {
-          // service woker
-          await buildJsSrcPage(
-            fs.existsSync(`./src/client/sw/${publicClientId}.sw.js`)
-              ? `./src/client/sw/${publicClientId}.sw.js`
-              : `./src/client/sw/default.sw.js`,
-            `${rootClientPath}/sw.js`,
-          );
-        }
-
-        // offline html
-        {
-          await buildJsSrcPage(
-            fs.existsSync(`./src/client/ssr/offline/${publicClientId}.index.js`)
-              ? `./src/client/ssr/offline/${publicClientId}.index.js`
-              : `./src/client/ssr/offline/default.index.js`,
-            `${rootClientPath}/offline.js`,
-          );
-
-          const htmlSrc = Render({
-            title: metadata?.title ? metadata.title : cap(client),
-            ssrPath: '/',
-            ssrHeadComponents: '',
-            ssrBodyComponents: '',
-            baseSsrLib: jsSsrCommonComponents + fs.readFileSync(`${rootClientPath}/offline.js`, 'utf8'),
-          });
+        // service woker
+        await buildJsSrcPage(
+          fs.existsSync(`./src/client/sw/${publicClientId}.sw.js`)
+            ? `./src/client/sw/${publicClientId}.sw.js`
+            : `./src/client/sw/default.sw.js`,
+          `${rootClientPath}/sw.js`,
+          path !== '/'
+            ? (jsSrc) => jsSrc.replaceAll(`const PROXY_PATH = '/';`, `const PROXY_PATH = '${path}/';`)
+            : undefined,
+        );
 
-          fs.writeFileSync(
-            `${rootClientPath}offline.html`,
-            minifyBuild || process.env.NODE_ENV === 'production'
-              ? await minify(htmlSrc, {
-                  minifyCSS: true,
-                  minifyJS: true,
-                  collapseBooleanAttributes: true,
-                  collapseInlineTagWhitespace: true,
-                  collapseWhitespace: true,
-                })
-              : htmlSrc,
-            'utf8',
-          );
-        }
         // ssr pages
         for (const page of await fs.readdir('./src/client/ssr/pages')) {
           await buildJsSrcPage(`./src/client/ssr/pages/${page}`, `${rootClientPath}/${page}`);
@@ -355,7 +349,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
           });
 
           fs.writeFileSync(
-            `${rootClientPath}${page.slice(0, -3)}.html`,
+            `${rootClientPath}/${page.slice(0, -3)}.html`,
             minifyBuild || process.env.NODE_ENV === 'production'
               ? await minify(htmlSrc, {
                   minifyCSS: true,
@@ -432,7 +426,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                       fs.existsSync(`./src/client/public/${publicClientId}/browserconfig.xml`) &&
                       fs.existsSync(`./src/client/public/${publicClientId}/site.webmanifest`);
 
-                    if (view.path === '/' && validPwaBuild) {
+                    if (validPwaBuild) {
                       // build webmanifest
                       const webmanifestJson = JSON.parse(
                         fs.readFileSync(`./src/client/public/${publicClientId}/site.webmanifest`, 'utf8'),
@@ -540,48 +534,6 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                       host,
                       path,
                       ttiLoadTimeLimit,
-                      storage: {
-                        // 'space-background': fs.readFileSync('./src/client/public/cyberia/space-background', 'utf8'),
-                        lore0: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore0.jpeg')
-                          .toString('base64')}`,
-                        lore1: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore1.jpeg')
-                          .toString('base64')}`,
-                        lore2: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore2.jpeg')
-                          .toString('base64')}`,
-                        lore3: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore3.jpeg')
-                          .toString('base64')}`,
-                        lore4: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore4.jpeg')
-                          .toString('base64')}`,
-                        lore5: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore5.jpeg')
-                          .toString('base64')}`,
-                        lore6: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore6.jpeg')
-                          .toString('base64')}`,
-                        lore7: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore7.jpeg')
-                          .toString('base64')}`,
-                        lore8: `data:image/jpeg;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/lore/lore8.jpeg')
-                          .toString('base64')}`,
-                        ['arrow-left']: `data:image/png;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/ui-icons/arrow-left.png')
-                          .toString('base64')}`,
-                        ['arrow-right']: `data:image/png;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/ui-icons/arrow-right.png')
-                          .toString('base64')}`,
-                        ['fullscreen']: `data:image/png;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/ui-icons/fullscreen.png')
-                          .toString('base64')}`,
-                        ['cyberia-logo']: `data:image/png;base64,${fs
-                          .readFileSync('./src/client/public/cyberia/assets/util/cyberia-retro-banner.png')
-                          .toString('base64')}`,
-                      },
                     });
                     break;
                   }
@@ -686,7 +638,7 @@ Sitemap: https://${host}${path === '/' ? '' : path}/sitemap.xml`,
         fs.copySync(`./coverage`, coverageBuildPath);
 
         // uml
-        shellExec(`node bin/deploy uml ${host} ${path}`);
+        // shellExec(`node bin/deploy uml ${host} ${path}`);
 
         // https://swagger-autogen.github.io/docs/
 

package/src/server/conf.js

@@ -7,7 +7,7 @@ import cliSpinners from 'cli-spinners';
 import logUpdate from 'log-update';
 import colors from 'colors';
 import { loggerFactory } from './logger.js';
-import { shellExec, shellCd } from './process.js';
+import { shellExec, shellCd, getRootDirectory } from './process.js';
 import { DefaultConf } from '../../conf.js';
 import ncp from 'copy-paste';
 import read from 'read';
@@ -44,7 +44,9 @@ const Config = {
       this.default.server = {};
       for (const deployId of process.argv[3].split(',')) {
         let confPath = `./engine-private/conf/${deployId}/conf.server.json`;
-        const privateConfDevPath = `./engine-private/conf/${deployId}/conf.server.dev.${process.argv[4]}.json`;
+        const privateConfDevPath = fs.existsSync(`./engine-private/replica/${deployId}/conf.server.json`)
+          ? `./engine-private/replica/${deployId}/conf.server.json`
+          : `./engine-private/conf/${deployId}/conf.server.dev.${process.argv[4]}.json`;
         const confDevPath = fs.existsSync(privateConfDevPath)
           ? privateConfDevPath
           : `./engine-private/conf/${deployId}/conf.server.dev.json`;
@@ -89,6 +91,11 @@ const loadConf = (deployId) => {
   if (!fs.existsSync(`./conf`)) fs.mkdirSync(`./conf`);
   if (!fs.existsSync(`./tmp`)) fs.mkdirSync(`./tmp`, { recursive: true });
   const isValidDeployId = fs.existsSync(`${folder}`);
+  if (!isValidDeployId) {
+    logger.info(`Save new deploy conf: '${deployId}'`);
+    shellExec(`node bin/deploy save ${deployId}`);
+    return loadConf(deployId);
+  }
   for (const typeConf of Object.keys(Config.default)) {
     let srcConf = isValidDeployId
       ? fs.readFileSync(`${folder}/conf.${typeConf}.json`, 'utf8')
@@ -100,7 +107,6 @@ const loadConf = (deployId) => {
     if (typeConf === 'server') srcConf = JSON.stringify(loadReplicas(JSON.parse(srcConf)), null, 4);
     fs.writeFileSync(`./conf/conf.${typeConf}.json`, srcConf, 'utf8');
   }
-  if (!isValidDeployId) return {};
   fs.writeFileSync(`./.env.production`, fs.readFileSync(`${folder}/.env.production`, 'utf8'), 'utf8');
   fs.writeFileSync(`./.env.development`, fs.readFileSync(`${folder}/.env.development`, 'utf8'), 'utf8');
   fs.writeFileSync(`./.env.test`, fs.readFileSync(`${folder}/.env.test`, 'utf8'), 'utf8');
@@ -120,10 +126,16 @@ const loadReplicas = (confServer) => {
   for (const host of Object.keys(confServer)) {
     for (const path of Object.keys(confServer[host])) {
       const { replicas, singleReplica } = confServer[host][path];
-      if (replicas && (process.argv[2] === 'proxy' || !singleReplica))
+      if (
+        replicas &&
+        (process.argv[2] === 'proxy' ||
+          !singleReplica ||
+          (singleReplica && process.env.NODE_ENV === 'development' && !process.argv[3]))
+      )
         for (const replicaPath of replicas) {
           confServer[host][replicaPath] = newInstance(confServer[host][path]);
           delete confServer[host][replicaPath].replicas;
+          delete confServer[host][replicaPath].singleReplica;
         }
     }
   }
@@ -246,8 +258,8 @@ const buildClientSrc = async (
   );
 
   fs.writeFileSync(
-    `./src/client/${toClientVariableName}.js`,
-    formattedSrc(fs.readFileSync(`./src/client/${fromClientVariableName}.js`, 'utf8')),
+    `./src/client/${toClientVariableName}.index.js`,
+    formattedSrc(fs.readFileSync(`./src/client/${fromClientVariableName}.index.js`, 'utf8')),
     'utf8',
   );
 
@@ -624,7 +636,7 @@ const deployTest = async (dataDeploy) => {
         if (singleReplica) continue;
         const urlTest = `https://${host}${path}`;
         try {
-          const result = await axios.get(urlTest);
+          const result = await axios.get(urlTest, { timeout: 10000 });
           const test = result.data.split('<title>');
           if (test[1])
             logger.info('Success deploy', {
@@ -660,19 +672,29 @@ const getDeployGroupId = () => {
   return 'dd';
 };
 
+const getDeployId = () => {
+  const deployIndexArg = process.argv.findIndex((a) => a.match(`deploy-id:`));
+  if (deployIndexArg > -1) return process.argv[deployIndexArg].split(':')[1].trim();
+  for (const deployId of process.argv) {
+    if (fs.existsSync(`./engine-private/conf/${deployId}`)) return deployId;
+    else if (fs.existsSync(`./engine-private/replica/${deployId}`)) return deployId;
+  }
+  return 'default';
+};
+
 const getCronBackUpFolder = (host = '', path = '') => {
   return `${host}${path.replace(/\\/g, '/').replace(`/`, '-')}`;
 };
 
-const execDeploy = async (options = { deployId: 'default' }) => {
+const execDeploy = async (options = { deployId: 'default' }, currentAttempt = 1) => {
   const { deployId } = options;
   shellExec(Cmd.delete(deployId));
   shellExec(Cmd.conf(deployId));
   shellExec(Cmd.run(deployId));
+  const maxTime = 1000 * 60;
+  const minTime = 20 * 1000;
+  const intervalTime = 1000;
   return await new Promise(async (resolve) => {
-    const maxTime = 1000 * 60 * 5;
-    const minTime = 10000 * 2;
-    const intervalTime = 1000;
     let currentTime = 0;
     const attempt = () => {
       if (currentTime >= minTime && !fs.existsSync(`./tmp/await-deploy`)) {
@@ -682,27 +704,40 @@ const execDeploy = async (options = { deployId: 'default' }) => {
       cliSpinner(
         intervalTime,
         `[deploy.js] `,
-        ` Load instance | elapsed time ${currentTime / 1000}s / ${maxTime / 1000}s`,
+        ` Load instance | attempt:${currentAttempt} | elapsed time ${currentTime / 1000}s / ${maxTime / 1000}s`,
         'yellow',
         'material',
       );
       currentTime += intervalTime;
-      if (currentTime >= maxTime) return resolve(false);
+      if (currentTime >= maxTime) {
+        clearInterval(processMonitor);
+        return resolve(false);
+      }
     };
     const processMonitor = setInterval(attempt, intervalTime);
   });
 };
 
-const deployRun = async (dataDeploy, reset) => {
+const deployRun = async (dataDeploy, currentAttempt = 1) => {
   if (!fs.existsSync(`./tmp`)) fs.mkdirSync(`./tmp`, { recursive: true });
-  if (reset) fs.writeFileSync(`./tmp/runtime-router.json`, '{}', 'utf8');
   await fixDependencies();
-  for (const deploy of dataDeploy) await execDeploy(deploy);
+  const maxAttempts = 3;
+  for (const deploy of dataDeploy) {
+    let currentAttempt = 1;
+    const attempt = async () => {
+      const success = await execDeploy(deploy, currentAttempt);
+      currentAttempt++;
+      if (!success && currentAttempt <= maxAttempts) await attempt();
+    };
+    await attempt();
+  }
   const { failed } = await deployTest(dataDeploy);
   if (failed.length > 0) {
     for (const deploy of failed) logger.error(deploy.deployId, Cmd.run(deploy.deployId));
-    await read({ prompt: 'Press enter to retry failed processes\n' });
-    await deployRun(failed);
+    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' });
+    currentAttempt++;
+    await deployRun(failed, currentAttempt);
   } else logger.info(`Deploy process successfully`);
 };
 
@@ -833,6 +868,10 @@ const Cmd = {
   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}`;
+  },
 };
 
 const fixDependencies = async () => {
@@ -852,6 +891,27 @@ const fixDependencies = async () => {
   );
 };
 
+const maintenancePath = `${getRootDirectory()}/public/${process.env.DEFAULT_DEPLOY_HOST}${
+  process.env.DEFAULT_DEPLOY_PATH
+}/maintenance.html`;
+
+const maintenanceMiddleware = (req, res, port, proxyRouter) => {
+  if (process.argv.includes('maintenance') && fs.existsSync(maintenancePath)) {
+    if (req.method.toUpperCase() === 'GET') return res.status(503).sendFile(maintenancePath);
+    return res.status(503).json({
+      status: 'error',
+      message: 'Server is under maintenance',
+    });
+  }
+};
+
+const setUpProxyMaintenanceServer = ({ deployGroupId }) => {
+  shellExec(`pm2 kill`);
+  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`);
+};
+
 export {
   Cmd,
   Config,
@@ -880,4 +940,8 @@ export {
   getRestoreCronCmd,
   mergeBackUp,
   fixDependencies,
+  getDeployId,
+  maintenancePath,
+  maintenanceMiddleware,
+  setUpProxyMaintenanceServer,
 };