underpost 2.8.0 → 2.8.6

package/src/server/client-build.js

@@ -21,6 +21,7 @@ import swaggerAutoGen from 'swagger-autogen';
 import { SitemapStream, streamToPromise } from 'sitemap';
 import { Readable } from 'stream';
 import { buildIcons, buildTextImg, getBufferPngText } from './client-icons.js';
+import Underpost from '../index.js';
 
 dotenv.config();
 
@@ -50,10 +51,10 @@ const fullBuild = async ({
   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(`/home/dd/html-website-templates/`))
+      shellExec(`cd /home/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);
+      fs.copySync(`/home/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');
@@ -191,8 +192,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
 
       if (redirect || disabledRebuild) continue;
 
-      if (fullBuildEnabled) {
-        //  !(confServer[host]['/'] && confServer[host]['/'].liteBuild)
+      if (fullBuildEnabled)
         await fullBuild({
           path,
           logger,
@@ -205,14 +205,6 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
           iconsBuild,
           metadata,
         });
-        if (apis && false)
-          for (const apiBuildScript of apis) {
-            const scriptPath = `src/api/${apiBuildScript}/${apiBuildScript}.build.js`;
-            if (fs.existsSync(`./${scriptPath}`)) {
-              shellExec(`node ${scriptPath}`);
-            }
-          }
-      }
 
       if (components)
         for (const module of Object.keys(components)) {
@@ -259,20 +251,6 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
               'services',
               baseHost,
             );
-            if (module === 'core' && (process.env.NODE_ENV === 'production' || process.argv.includes('static'))) {
-              if (apiBaseHost)
-                jsSrc = jsSrc.replace(
-                  'const getBaseHost = () => location.host;',
-                  `const getBaseHost = () => '${apiBaseHost}';`,
-                );
-              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,
               minifyBuild || process.env.NODE_ENV === 'production' ? UglifyJS.minify(jsSrc).code : jsSrc,
@@ -465,10 +443,11 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                   case 'DefaultSplashScreen':
                     if (backgroundImage) {
                       ssrHeadComponents += SrrComponent({
-                        base64BackgroundImage: `data:image/${backgroundImage.split('.').pop()};base64,${fs
-                          .readFileSync(backgroundImage)
-                          .toString('base64')}`,
+                        backgroundImage: (path === '/' ? path : `${path}/`) + backgroundImage,
                       });
+                      // `data:image/${backgroundImage.split('.').pop()};base64,${fs
+                      //     .readFileSync()
+                      //     .toString('base64')}`,
                       break;
                     } else {
                       ssrHeadComponents += SrrComponent({ metadata });
@@ -480,7 +459,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                         bgColor: metadata?.themeColor ? metadata.themeColor : '#ececec',
                       });
                       ssrHeadComponents += SrrComponent({
-                        base64BackgroundImage: `data:image/png;base64,${bufferBackgroundImage.toString('base64')}`,
+                        backgroundImage: `data:image/png;base64,${bufferBackgroundImage.toString('base64')}`,
                       });
                     }
 
@@ -495,7 +474,13 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                   }
 
                   default:
-                    ssrBodyComponents += SrrComponent({ ssrPath, host, path, ttiLoadTimeLimit });
+                    ssrBodyComponents += SrrComponent({
+                      ssrPath,
+                      host,
+                      path,
+                      ttiLoadTimeLimit,
+                      version: Underpost.version,
+                    });
                     break;
                 }
               }
@@ -515,6 +500,15 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
               ssrPath,
               ssrHeadComponents,
               ssrBodyComponents,
+              renderPayload: {
+                apiBaseProxyPath,
+                apiBaseHost,
+                apiBasePath: process.env.BASE_API,
+                version: Underpost.version,
+              },
+              renderApi: {
+                JSONweb,
+              },
             });
 
             fs.writeFileSync(
@@ -544,17 +538,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
         let siteMapSrc = await new Promise((resolve) =>
           streamToPromise(Readable.from(siteMapLinks).pipe(siteMapStream)).then((data) => resolve(data.toString())),
         );
-        switch (publicClientId) {
-          case 'underpost':
-            siteMapSrc = siteMapSrc.replaceAll(
-              `</urlset>`,
-              `${fs.readFileSync(`./src/client/public/underpost/sitemap-template.txt`, 'utf8')} </urlset>`,
-            );
-            break;
 
-          default:
-            break;
-        }
         // Return a promise that resolves with your XML string
         fs.writeFileSync(`${rootClientPath}/sitemap.xml`, siteMapSrc, 'utf8');
         if (xslUrl)
@@ -725,6 +709,15 @@ root file where the route starts, such as index.js, app.js, routes.js, etc ... *
                 ssrPath,
                 ssrHeadComponents: '',
                 ssrBodyComponents: SsrComponent(),
+                renderPayload: {
+                  apiBaseProxyPath,
+                  apiBaseHost,
+                  apiBasePath: process.env.BASE_API,
+                  version: Underpost.version,
+                },
+                renderApi: {
+                  JSONweb,
+                },
               });
 
               const buildPath = `${
@@ -757,16 +750,14 @@ root file where the route starts, such as index.js, app.js, routes.js, etc ... *
         }
 
         {
-          const PRE_CACHED_JSON = `PRE_CACHED_RESOURCES = ${JSONweb(uniqueArray(PRE_CACHED_RESOURCES))}`;
-          const PROXY_PATH = `PROXY_PATH = '${path}'`;
+          const renderPayload = {
+            PRE_CACHED_RESOURCES: uniqueArray(PRE_CACHED_RESOURCES),
+            PROXY_PATH: path,
+          };
           fs.writeFileSync(
             `${rootClientPath}/sw.js`,
-            fs
-              .readFileSync(`${rootClientPath}/sw.js`, 'utf8')
-              .replaceAll(`PRE_CACHED_RESOURCES = []`, PRE_CACHED_JSON)
-              .replaceAll(`PRE_CACHED_RESOURCES=[]`, PRE_CACHED_JSON)
-              .replaceAll(`PROXY_PATH = '/'`, PROXY_PATH)
-              .replaceAll(`PROXY_PATH='/'`, PROXY_PATH),
+            `self.renderPayload = ${JSONweb(renderPayload)};
+${fs.readFileSync(`${rootClientPath}/sw.js`, 'utf8')}`,
             'utf8',
           );
         }

package/src/server/client-formatted.js

@@ -1,6 +1,8 @@
 'use strict';
 
 import fs from 'fs-extra';
+import vm from 'node:vm';
+import Underpost from '../index.js';
 
 const srcFormatted = (src) =>
   src
@@ -48,9 +50,10 @@ const viewFormatted = (src, dists, proxyPath, baseHost = '') => {
 };
 
 const ssrFactory = async (componentPath = `./src/client/ssr/Render.js`) => {
-  let SrrComponent = () => {};
-  eval(await srcFormatted(fs.readFileSync(componentPath, 'utf8')));
-  return SrrComponent;
+  const context = { SrrComponent: () => {}, npm_package_version: Underpost.version };
+  vm.createContext(context);
+  vm.runInContext(await srcFormatted(fs.readFileSync(componentPath, 'utf8')), context);
+  return context.SrrComponent;
 };
 
 export { srcFormatted, JSONweb, componentFormatted, viewFormatted, ssrFactory };

package/src/server/client-icons.js

@@ -141,7 +141,7 @@ const buildIcons = async ({
     for (const file of response.files)
       fs.writeFileSync(`./src/client/public/${publicClientId}/${file.name}`, file.contents, 'utf8');
 
-    const ssrPath = `./src/client/ssr/components/head/Pwa${getCapVariableName(publicClientId)}.js`;
+    const ssrPath = `./src/client/ssr/head/Pwa${getCapVariableName(publicClientId)}.js`;
     if (!fs.existsSync(ssrPath))
       fs.writeFileSync(ssrPath, 'SrrComponent = () => html`' + response.html.join(`\n`) + '`;', 'utf8');
   } catch (error) {

package/src/server/conf.js

@@ -1,6 +1,13 @@
 import fs from 'fs-extra';
 import dotenv from 'dotenv';
-import { capFirst, getCapVariableName, newInstance, range, timer } from '../client/components/core/CommonJs.js';
+import {
+  capFirst,
+  getCapVariableName,
+  newInstance,
+  orderArrayFromAttrInt,
+  range,
+  timer,
+} from '../client/components/core/CommonJs.js';
 import * as dir from 'path';
 import cliProgress from 'cli-progress';
 import cliSpinners from 'cli-spinners';
@@ -9,22 +16,13 @@ import colors from 'colors';
 import { loggerFactory } from './logger.js';
 import { shellExec } from './process.js';
 import { DefaultConf } from '../../conf.js';
-import ncp from 'copy-paste';
 import read from 'read';
 import splitFile from 'split-file';
 import axios from 'axios';
-import https from 'https';
 import { ssrFactory } from './client-formatted.js';
 
-// axios.defaults.baseURL = BASE_URL;
-
-const httpsAgent = new https.Agent({
-  rejectUnauthorized: false,
-});
-
-axios.defaults.httpsAgent = httpsAgent;
-
 colors.enable();
+
 dotenv.config();
 
 const logger = loggerFactory(import.meta);
@@ -33,21 +31,26 @@ const logger = loggerFactory(import.meta);
 
 const Config = {
   default: DefaultConf,
-  build: async function (options = { folder: '' }) {
+  build: async function (options = { folder: '' }, deployContext, deployList, subConf) {
+    if (!deployContext) deployContext = process.argv[2];
     if (!fs.existsSync(`./tmp`)) fs.mkdirSync(`./tmp`, { recursive: true });
     fs.writeFileSync(`./tmp/await-deploy`, '', 'utf8');
-    if (fs.existsSync(`./engine-private/conf/${process.argv[2]}`)) return loadConf(process.argv[2]);
-    if (fs.existsSync(`./engine-private/replica/${process.argv[2]}`)) return loadConf(process.argv[2]);
+    if (fs.existsSync(`./engine-private/conf/${deployContext}`))
+      return loadConf(deployContext, process.env.NODE_ENV, subConf);
+    if (fs.existsSync(`./engine-private/replica/${deployContext}`))
+      return loadConf(deployContext, process.env.NODE_ENV, subConf);
 
-    if (process.argv[2] === 'deploy') return;
+    if (deployContext === 'deploy') return;
 
-    if (process.argv[2] === 'proxy') {
+    if (deployContext === 'proxy') {
+      if (!deployList) deployList = process.argv[3];
+      if (!subConf) subConf = process.argv[4];
       this.default.server = {};
-      for (const deployId of process.argv[3].split(',')) {
+      for (const deployId of deployList.split(',')) {
         let confPath = `./engine-private/conf/${deployId}/conf.server.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`;
+          : `./engine-private/conf/${deployId}/conf.server.dev.${subConf}.json`;
         const confDevPath = fs.existsSync(privateConfDevPath)
           ? privateConfDevPath
           : `./engine-private/conf/${deployId}/conf.server.dev.json`;
@@ -55,7 +58,7 @@ const Config = {
         if (process.env.NODE_ENV === 'development' && fs.existsSync(confDevPath)) confPath = confDevPath;
         const serverConf = JSON.parse(fs.readFileSync(confPath, 'utf8'));
 
-        for (const host of Object.keys(loadReplicas(serverConf))) {
+        for (const host of Object.keys(loadReplicas(serverConf, deployContext, subConf))) {
           if (serverConf[host]['/'])
             this.default.server[host] = {
               ...this.default.server[host],
@@ -85,7 +88,15 @@ const Config = {
   },
 };
 
-const loadConf = (deployId) => {
+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}`;
@@ -102,7 +113,8 @@ const loadConf = (deployId) => {
       ? fs.readFileSync(`${folder}/conf.${typeConf}.json`, 'utf8')
       : JSON.stringify(Config.default[typeConf]);
     if (process.env.NODE_ENV === 'development' && typeConf === 'server') {
-      const devConfPath = `${folder}/conf.${typeConf}.dev${process.argv[3] ? `.${process.argv[3]}` : ''}.json`;
+      if (!subConf) subConf = process.argv[3];
+      const devConfPath = `${folder}/conf.${typeConf}.dev${subConf ? `.${subConf}` : ''}.json`;
       if (fs.existsSync(devConfPath)) srcConf = fs.readFileSync(devConfPath, 'utf8');
     }
     if (typeConf === 'server') srcConf = JSON.stringify(loadReplicas(JSON.parse(srcConf)), null, 4);
@@ -111,27 +123,34 @@ const loadConf = (deployId) => {
   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');
-  if (process.env.NODE_ENV) {
-    fs.writeFileSync(`./.env`, fs.readFileSync(`${folder}/.env.${process.env.NODE_ENV}`, 'utf8'), 'utf8');
-    const env = dotenv.parse(fs.readFileSync(`${folder}/.env.${process.env.NODE_ENV}`, 'utf8'));
+  const NODE_ENV = envInput || process.env.NODE_ENV;
+  if (NODE_ENV) {
+    fs.writeFileSync(`./.env`, fs.readFileSync(`${folder}/.env.${NODE_ENV}`, 'utf8'), 'utf8');
+    const env = dotenv.parse(fs.readFileSync(`${folder}/.env.${NODE_ENV}`, 'utf8'));
     process.env = {
       ...process.env,
       ...env,
     };
   }
-  fs.writeFileSync(`./package.json`, fs.readFileSync(`${folder}/package.json`, 'utf8'), 'utf8');
+  const originPackageJson = JSON.parse(fs.readFileSync(`./package.json`, 'utf8'));
+  const packageJson = JSON.parse(fs.readFileSync(`${folder}/package.json`, 'utf8'));
+  originPackageJson.scripts.start = packageJson.scripts.start;
+  packageJson.scripts = originPackageJson.scripts;
+  fs.writeFileSync(`./package.json`, JSON.stringify(packageJson, null, 4), 'utf8');
   return { folder, deployId };
 };
 
-const loadReplicas = (confServer) => {
+const loadReplicas = (confServer, deployContext, subConf) => {
+  if (!deployContext) deployContext = process.argv[2];
+  if (!subConf) subConf = process.argv[3];
   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' ||
+        (deployContext === 'proxy' ||
           !singleReplica ||
-          (singleReplica && process.env.NODE_ENV === 'development' && !process.argv[3]))
+          (singleReplica && process.env.NODE_ENV === 'development' && !subConf))
       )
         for (const replicaPath of replicas) {
           confServer[host][replicaPath] = newInstance(confServer[host][path]);
@@ -253,8 +272,8 @@ const buildClientSrc = async (
   }
 
   fs.writeFileSync(
-    `./src/client/ssr/components/head/${toClientVariableName}Scripts.js`,
-    formattedSrc(fs.readFileSync(`./src/client/ssr/components/head/${fromClientVariableName}Scripts.js`, 'utf8')),
+    `./src/client/ssr/head/${toClientVariableName}Scripts.js`,
+    formattedSrc(fs.readFileSync(`./src/client/ssr/head/${fromClientVariableName}Scripts.js`, 'utf8')),
     'utf8',
   );
 
@@ -473,13 +492,55 @@ const buildProxyRouter = () => {
         title: 'Site in maintenance',
         ssrPath: '/',
         ssrHeadComponents: '',
-        ssrBodyComponents: (await ssrFactory(`./src/client/ssr/body/Maintenance.js`))(),
+        ssrBodyComponents: (await ssrFactory(`./src/client/ssr/offline/Maintenance.js`))(),
       });
     })();
 
   return proxyRouter;
 };
 
+const buildKindPorts = (from, to) =>
+  range(parseInt(from), parseInt(to))
+    .map(
+      (port) => `    - name: 'tcp-${port}'
+      protocol: TCP
+      port: ${port}
+      targetPort: ${port}
+    - name: 'udp-${port}'
+      protocol: UDP
+      port: ${port}
+      targetPort: ${port}
+`,
+    )
+    .join('\n');
+
+const buildPortProxyRouter = (port, proxyRouter) => {
+  const hosts = proxyRouter[port];
+  const router = {};
+  // build router
+  Object.keys(hosts).map((hostKey) => {
+    let { host, path, target, proxy, peer } = hosts[hostKey];
+    if (process.argv.includes('localhost') && process.env.NODE_ENV === 'development') host = `localhost`;
+
+    if (!proxy.includes(port)) return;
+    const absoluteHost = [80, 443].includes(port)
+      ? `${host}${path === '/' ? '' : path}`
+      : `${host}:${port}${path === '/' ? '' : path}`;
+
+    if (process.argv.includes('localhost')) {
+      if (!(absoluteHost in router)) router[absoluteHost] = target;
+    } else router[absoluteHost] = target;
+  }); // order router
+
+  if (Object.keys(router).length === 0) return router;
+
+  const reOrderRouter = {};
+  for (const absoluteHostKey of orderArrayFromAttrInt(Object.keys(router), 'length'))
+    reOrderRouter[absoluteHostKey] = router[absoluteHostKey];
+
+  return reOrderRouter;
+};
+
 const cliBar = async (time = 5000) => {
   // create new progress bar
   const b = new cliProgress.SingleBar({
@@ -528,9 +589,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);
 
@@ -588,6 +665,7 @@ const validateTemplatePath = (absolutePath = '') => {
   if (absolutePath.match('src/api') && !confServer.apis.find((p) => absolutePath.match(`src/api/${p}/`))) {
     return false;
   }
+  if (absolutePath.match('conf.dd-') && absolutePath.match('.js')) return false;
   if (
     absolutePath.match('src/client/services/') &&
     !clients.find((p) => absolutePath.match(`src/client/services/${p}/`))
@@ -764,15 +842,16 @@ 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`);
 };
 
-const restoreMacroDb = async (deployGroupId = '') => {
+const restoreMacroDb = async (deployGroupId = '', deployId = null) => {
   const dataDeploy = await getDataDeploy({ deployGroupId, buildSingleReplica: false });
   for (const deployGroup of dataDeploy) {
+    if (deployId && deployGroup.deployId !== deployId) continue;
     if (!deployGroup.replicaHost) {
       const deployServerConfPath = `./engine-private/conf/${deployGroup.deployId}/conf.server.json`;
       const serverConf = JSON.parse(fs.readFileSync(deployServerConfPath, 'utf8'));
@@ -790,13 +869,10 @@ const restoreMacroDb = async (deployGroupId = '') => {
   }
 };
 
-const mergeBackUp = async (baseBackJsonPath, outputFilePath) => {
-  const names = JSON.parse(fs.readFileSync(baseBackJsonPath, 'utf8')).map((p) =>
-    p.replaceAll(`\\`, '/').replaceAll('C:/', '/').replaceAll('c:/', '/'),
-  );
+const mergeFile = async (parts = [], outputFilePath) => {
   await new Promise((resolve) => {
     splitFile
-      .mergeFiles(names, outputFilePath)
+      .mergeFiles(parts, outputFilePath)
       .then(() => {
         resolve();
       })
@@ -848,11 +924,13 @@ const getRestoreCronCmd = async (options = { host: '', path: '', conf: {}, deplo
       {
         if (process.argv.includes('cron')) {
           cmd = `mysql -u ${user} -p${password} ${name} < ${baseBackUpPath}/${currentBackupTimestamp}/${name}.sql`;
-          if (fs.existsSync(`${baseBackUpPath}/${currentBackupTimestamp}/${name}-parths.json`))
-            await mergeBackUp(
-              `${baseBackUpPath}/${currentBackupTimestamp}/${name}-parths.json`,
-              `${baseBackUpPath}/${currentBackupTimestamp}/${name}.sql`,
-            );
+          if (fs.existsSync(`${baseBackUpPath}/${currentBackupTimestamp}/${name}-parths.json`)) {
+            const names = JSON.parse(
+              fs.readFileSync(`${baseBackUpPath}/${currentBackupTimestamp}/${name}-parths.json`, 'utf8'),
+            ).map((p) => p.replaceAll(`\\`, '/').replaceAll('C:/', '/').replaceAll('c:/', '/'));
+
+            await mergeFile(names, `${baseBackUpPath}/${currentBackupTimestamp}/${name}.sql`);
+          }
         } else {
           cmd = `mysql -u ${user} -p${password} ${name} < ${
             backupPath ? backupPath : `./engine-private/sql-backups/${name}.sql`
@@ -863,15 +941,23 @@ const getRestoreCronCmd = async (options = { host: '', path: '', conf: {}, deplo
                 backupPath ? backupPath.split('/').slice(0, -1).join('/') : `./engine-private/sql-backups`
               }/${name}-parths.json`,
             )
-          )
-            await mergeBackUp(
-              `${
-                backupPath ? backupPath.split('/').slice(0, -1).join('/') : `./engine-private/sql-backups`
-              }/${name}-parths.json`,
+          ) {
+            const names = JSON.parse(
+              fs.readFileSync(
+                `${
+                  backupPath ? backupPath.split('/').slice(0, -1).join('/') : `./engine-private/sql-backups`
+                }/${name}-parths.json`,
+                'utf8',
+              ),
+            ).map((p) => p.replaceAll(`\\`, '/').replaceAll('C:/', '/').replaceAll('c:/', '/'));
+
+            await mergeFile(
+              names,
               `${
                 backupPath ? backupPath.split('/').slice(0, -1).join('/') : `./engine-private/sql-backups`
               }/${name}.sql`,
             );
+          }
         }
       }
       break;
@@ -890,20 +976,31 @@ const getRestoreCronCmd = async (options = { host: '', path: '', conf: {}, deplo
   return cmd;
 };
 
+const getPathsSSR = (conf) => {
+  const paths = ['src/client/ssr/Render.js'];
+  for (const o of conf.head) paths.push(`src/client/ssr/head/${o}.js`);
+  for (const o of conf.body) paths.push(`src/client/ssr/body/${o}.js`);
+  for (const o of Object.keys(conf.mailer)) paths.push(`src/client/ssr/mailer/${conf.mailer[o]}.js`);
+  for (const o of conf.offline) paths.push(`src/client/ssr/mailer/${o.client}.js`);
+  for (const o of conf.pages) paths.push(`src/client/ssr/pages/${o.client}.js`);
+  return paths;
+};
+
 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?.itc ? `--itc ` : ''
+    }${options?.git ? `--git ` : ''}${deployList} ${jobList}`,
 };
 
 const fixDependencies = async () => {
+  return;
   // sed -i "$line_number s,.*,$new_text," "$file"
   // sed -i "$line_number c \\$new_text" "$file"
   const dep = fs.readFileSync(`./node_modules/peer/dist/module.mjs`, 'utf8');
@@ -933,14 +1030,60 @@ const maintenanceMiddleware = (req, res, port, proxyRouter) => {
   }
 };
 
+const splitFileFactory = async (name, _path) => {
+  const stats = fs.statSync(_path);
+  const maxSizeInBytes = 1024 * 1024 * 50; // 50 mb
+  const fileSizeInBytes = stats.size;
+  if (fileSizeInBytes > maxSizeInBytes) {
+    logger.info('splitFileFactory input', { name, from: _path });
+    return await new Promise((resolve) => {
+      splitFile
+        .splitFileBySize(_path, maxSizeInBytes) // 50 mb
+        .then((names) => {
+          logger.info('splitFileFactory output', { parts: names });
+          fs.writeFileSync(
+            `${_path.split('/').slice(0, -1).join('/')}/${name}-parths.json`,
+            JSON.stringify(names, null, 4),
+            'utf8',
+          );
+          fs.removeSync(_path);
+          return resolve(true);
+        })
+        .catch((err) => {
+          console.log('Error: ', err);
+          return resolve(false);
+        });
+    });
+  }
+  return false;
+};
+
 const setUpProxyMaintenanceServer = ({ deployGroupId }) => {
   shellExec(`pm2 kill`);
   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 = () =>
+  shellExec(`npm root -g`, {
+    stdout: true,
+    disableLog: true,
+    silent: true,
+  }).trim();
+
+const getUnderpostRootPath = () => `${getNpmRootPath()}/underpost`;
+
+const writeEnv = (envPath, envObj) =>
+  fs.writeFileSync(
+    envPath,
+    Object.keys(envObj)
+      .map((key) => `${key}=${envObj[key]}`)
+      .join(`\n`),
+    'utf8',
+  );
+
 export {
   Cmd,
   Config,
@@ -967,9 +1110,16 @@ export {
   deployRun,
   getCronBackUpFolder,
   getRestoreCronCmd,
-  mergeBackUp,
+  mergeFile,
   fixDependencies,
   getDeployId,
   maintenanceMiddleware,
   setUpProxyMaintenanceServer,
+  getPathsSSR,
+  buildKindPorts,
+  buildPortProxyRouter,
+  splitFileFactory,
+  getNpmRootPath,
+  getUnderpostRootPath,
+  writeEnv,
 };