underpost 2.7.8 → 2.7.9

package/src/server/client-build.js

@@ -52,7 +52,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(
@@ -188,7 +188,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 +248,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 +293,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 +306,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 +330,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 +407,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 +515,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 +619,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')
@@ -246,8 +253,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',
   );
 
@@ -660,6 +667,16 @@ 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(`/`, '-')}`;
 };
@@ -671,7 +688,7 @@ const execDeploy = async (options = { deployId: 'default' }) => {
   shellExec(Cmd.run(deployId));
   return await new Promise(async (resolve) => {
     const maxTime = 1000 * 60 * 5;
-    const minTime = 10000 * 2;
+    const minTime = 7 * 1000;
     const intervalTime = 1000;
     let currentTime = 0;
     const attempt = () => {
@@ -833,6 +850,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 +873,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 +922,8 @@ export {
   getRestoreCronCmd,
   mergeBackUp,
   fixDependencies,
+  getDeployId,
+  maintenancePath,
+  maintenanceMiddleware,
+  setUpProxyMaintenanceServer,
 };

package/src/server/crypto.js

@@ -0,0 +1,91 @@
+import crypto from 'crypto';
+import fs from 'fs-extra';
+
+const CryptoBuilder = {
+  symmetric: {
+    instance: function (options = { iv: '', encryptionKey: '' }) {
+      // Generate a random 32-byte encryption key
+      const encryptionKey = option?.encryptionKey ? options.encryptionKey : crypto.randomBytes(32);
+      const iv = option?.iv ? options.iv : crypto.randomBytes(16); // Generate a new Initialization Vector (IV) for each encryption
+
+      // Function to encrypt data
+      function encryptData(plaintext = '') {
+        const cipher = crypto.createCipheriv('aes-256-cbc', encryptionKey, iv);
+        let encrypted = cipher.update(plaintext, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+        return `${iv.toString('hex')}:${encrypted}`;
+      }
+
+      // Function to decrypt data
+      function decryptData(ciphertext = '') {
+        const [ivHex, encrypted] = ciphertext.split(':');
+        const _iv = Buffer.from(ivHex, 'hex');
+        const decipher = crypto.createDecipheriv('aes-256-cbc', encryptionKey, _iv);
+        let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+        return decrypted;
+      }
+
+      return {
+        encryptionKey,
+        iv,
+        encryptData,
+        decryptData,
+      };
+    },
+  },
+  asymmetric: {
+    instance: function (
+      options = {
+        publicKey: '', // fs.readFileSync('./key.pem', 'utf8')
+        privateKey: '', // fs.readFileSync('./key.pem', 'utf8')
+      },
+    ) {
+      // Generate a new key pair
+      const { privateKey, publicKey } = options
+        ? options
+        : crypto.generateKeyPairSync('rsa', {
+            modulusLength: 2048, // Key size in bits
+            publicKeyEncoding: {
+              type: 'spki',
+              format: 'pem',
+            },
+            privateKeyEncoding: {
+              type: 'pkcs8',
+              format: 'pem',
+            },
+          });
+
+      // Function to encrypt data
+      function encryptData(plaintext) {
+        const buffer = Buffer.from(plaintext, 'utf8');
+        const encrypted = crypto.publicEncrypt(publicKey, buffer);
+        return encrypted.toString('hex');
+      }
+
+      // Function to decrypt data
+      function decryptData(ciphertext) {
+        const buffer = Buffer.from(ciphertext, 'hex');
+        const decrypted = crypto.privateDecrypt(privateKey, buffer);
+        return decrypted.toString('utf8');
+      }
+
+      fs.writeFileSync('./public.pem', publicKey);
+      fs.writeFileSync('./private.pem', privateKey);
+
+      const result = {
+        privateKey: fs.readFileSync('./public.pem', 'utf8'),
+        publicKey: fs.readFileSync('./private.pem', 'utf8'),
+        encryptData,
+        decryptData,
+      };
+
+      fs.removeSync('./public.pem');
+      fs.removeSync('./private.pem');
+
+      return result;
+    },
+  },
+};
+
+export { CryptoBuilder };

package/src/server/dns.js

@@ -1,21 +1,27 @@
 import axios from 'axios';
 import dotenv from 'dotenv';
 import fs from 'fs';
-import cron from 'node-cron';
+import https from 'https';
 
 import { ip } from './network.js';
 import { loggerFactory } from './logger.js';
 import { isIPv4 } from 'is-ip';
+import { shellExec } from './process.js';
+
+const httpsAgent = new https.Agent({
+  rejectUnauthorized: false,
+});
+
+axios.defaults.httpsAgent = httpsAgent;
 
 dotenv.config();
 
 const logger = loggerFactory(import.meta);
 
 const Dns = {
-  ip: null,
-  ipDaemon: null,
+  repoUrl: `https://${process.env.GITHUB_TOKEN}@github.com/${process.env.GITHUB_USERNAME}/${process.env.GITHUB_DNS_REPO}.git`,
   callback: () => null,
-  InitIpDaemon: async function () {
+  InitIpDaemon: async function ({ deployId }) {
     // WAN | NAT-VPS | LAN
     // enabled DMZ Host to proxy IP 80-443 (79-444) sometimes router block first port
     // LAN server or device's local servers port ->  3000-3100 (2999-3101)
@@ -23,16 +29,16 @@ const Dns = {
     // DHCP (Dynamic Host Configuration Protocol) LAN reserver IP -> MAC ID
     // Forward the router's TCP/UDP ports to the LAN device's IP address
 
-    const privateCronConfPath = `./engine-private/conf/${process.argv[2]}/conf.cron.json`;
+    const privateCronConfPath = `./engine-private/conf/${deployId}/conf.cron.json`;
 
     const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
-
     let confCronData = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
     if (confCronData.ipDaemon.disabled) return;
     Dns.ip = confCronData.ipDaemon.ip;
     logger.info(`Current ip`, Dns.ip);
-    if (Dns.ipDaemon) clearInterval(Dns.ipDaemon);
     const callback = async () => {
+      logger.info('init dns ip callback');
+      await logger.setUpInfo();
       let testIp;
       try {
         testIp = await ip.public.ipv4();
@@ -41,15 +47,12 @@ const Dns = {
       }
       if (testIp && typeof testIp === 'string' && isIPv4(testIp) && Dns.ip !== testIp) {
         logger.info(`New ip`, testIp);
-        Dns.ip = testIp;
-        confCronData.ipDaemon.ip = Dns.ip;
-        fs.writeFileSync(confCronPath, JSON.stringify(confCronData, null, 4), 'utf8');
         for (const recordType of Object.keys(confCronData.records)) {
           switch (recordType) {
             case 'A':
               for (const dnsProvider of confCronData.records[recordType]) {
                 if (typeof Dns.services.updateIp[dnsProvider.dns] === 'function')
-                  await Dns.services.updateIp[dnsProvider.dns](dnsProvider);
+                  await Dns.services.updateIp[dnsProvider.dns]({ ...dnsProvider, ip: testIp });
               }
               break;
 
@@ -57,16 +60,28 @@ const Dns = {
               break;
           }
         }
+        try {
+          const ipUrlTest = `https://${process.env.DEFAULT_DEPLOY_HOST}`;
+          const response = await axios.get(ipUrlTest);
+          const verifyIp = response.request.socket.remoteAddress;
+          logger.info(ipUrlTest + ' IP', verifyIp);
+          if (verifyIp === testIp) {
+            await this.saveIp(confCronPath, confCronData, testIp);
+          } else logger.error('ip not updated');
+        } catch (error) {
+          logger.error(error), 'ip not updated';
+        }
       }
     };
+    await callback();
     this.callback = callback;
     return callback;
   },
   services: {
     updateIp: {
       dondominio: (options) => {
-        const { user, api_key, host, dns } = options;
-        const url = `https://dondns.dondominio.com/json/?user=${user}&password=${api_key}&host=${host}&ip=${Dns.ip}`;
+        const { user, api_key, host, dns, ip } = options;
+        const url = `https://dondns.dondominio.com/json/?user=${user}&password=${api_key}&host=${host}&ip=${ip}`;
         logger.info(`${dns} update ip url`, url);
         if (process.env.NODE_ENV !== 'production') return false;
         return new Promise((resolve) => {
@@ -84,6 +99,20 @@ const Dns = {
       },
     },
   },
+  saveIp: async (confCronPath, confCronData, ip) => {
+    Dns.ip = ip;
+    confCronData.ipDaemon.ip = ip;
+    fs.writeFileSync(confCronPath, JSON.stringify(confCronData, null, 4), 'utf8');
+    shellExec(
+      `cd ./engine-private` +
+        ` && git pull ${Dns.repoUrl}` +
+        ` && git add . && git commit -m "update ip ${new Date().toLocaleDateString()}"` +
+        ` && git push ${Dns.repoUrl}`,
+      {
+        disableLog: true,
+      },
+    );
+  },
 };
 
 export { Dns };

package/src/server/network.js

@@ -5,6 +5,8 @@ import { publicIp, publicIpv4, publicIpv6 } from 'public-ip';
 import { killPortProcess } from 'kill-port-process';
 import { loggerFactory } from './logger.js';
 import { orderArrayFromAttrInt } from '../client/components/core/CommonJs.js';
+import { DataBaseProvider } from '../db/DataBaseProvider.js';
+import { getDeployId } from './conf.js';
 
 // Network Address Translation Management
 
@@ -66,12 +68,86 @@ const logRuntimeRouter = () => {
   logger.info('Runtime network', displayLog);
 };
 
-const saveRuntimeRouter = () =>
-  fs.writeFileSync(
-    `./tmp/runtime-router.${process.argv[3] ? process.argv[3] : 'default'}.json`,
-    JSON.stringify(networkRouter, null, 4),
-    'utf-8',
-  );
+const saveRuntimeRouter = async () => {
+  try {
+    const deployId = process.env.DEFAULT_DEPLOY_ID;
+    const host = process.env.DEFAULT_DEPLOY_HOST;
+    const path = process.env.DEFAULT_DEPLOY_PATH;
+    const confServerPath = `./engine-private/conf/${deployId}/conf.server.json`;
+    const confServer = JSON.parse(fs.readFileSync(confServerPath, 'utf8'));
+    const { db } = confServer[host][path];
+
+    let closeConn;
+    if (!DataBaseProvider.instance[`${host}${path}`]) {
+      await DataBaseProvider.load({ apis: ['instance'], host, path, db });
+      closeConn = true;
+    }
+
+    /** @type {import('../api/instance/instance.model.js').InstanceModel} */
+    const Instance = DataBaseProvider.instance[`${host}${path}`].mongoose.models.Instance;
+
+    for (const _host of Object.keys(networkRouter)) {
+      for (const _path of Object.keys(networkRouter[_host])) {
+        const body = {
+          host: _host,
+          path: _path,
+          deployId: getDeployId(),
+          client: networkRouter[_host][_path].client,
+          runtime: networkRouter[_host][_path].runtime,
+          port: networkRouter[_host][_path].port,
+          apis: networkRouter[_host][_path].apis,
+        };
+        const instance = await Instance.findOne({ deployId: body.deployId, port: body.port });
+        if (instance) {
+          await Instance.findByIdAndUpdate(instance._id, body);
+        } else {
+          await new Instance(body).save();
+        }
+      }
+    }
+
+    if (closeConn) await DataBaseProvider.instance[`${host}${path}`].mongoose.close();
+  } catch (error) {
+    logger.error(error);
+  }
+};
+
+const netWorkCron = [];
+
+const saveRuntimeCron = async () => {
+  try {
+    const deployId = process.env.DEFAULT_DEPLOY_ID;
+    const host = process.env.DEFAULT_DEPLOY_HOST;
+    const path = process.env.DEFAULT_DEPLOY_PATH;
+    const confServerPath = `./engine-private/conf/${deployId}/conf.server.json`;
+    const confServer = JSON.parse(fs.readFileSync(confServerPath, 'utf8'));
+    const { db } = confServer[host][path];
+
+    let closeConn;
+    if (!DataBaseProvider.instance[`${host}${path}`]) {
+      await DataBaseProvider.load({ apis: ['cron'], host, path, db });
+      closeConn = true;
+    }
+
+    /** @type {import('../api/cron/cron.model.js').CronModel} */
+    const Cron = DataBaseProvider.instance[`${host}${path}`].mongoose.models.Cron;
+
+    // await Cron.insertMany(netWorkCron);
+
+    for (const cronInstance of netWorkCron) {
+      const cron = await Cron.findOne({ deployId: cronInstance.deployId, jobId: cronInstance.jobId });
+      if (cron) {
+        await Cron.findByIdAndUpdate(cron._id, cronInstance);
+      } else {
+        await new Cron(cronInstance).save();
+      }
+    }
+
+    if (closeConn) await DataBaseProvider.instance[`${host}${path}`].mongoose.close();
+  } catch (error) {
+    logger.error(error);
+  }
+};
 
 const listenServerFactory = (logic = async () => {}) => {
   return {
@@ -109,6 +185,7 @@ const listenPortController = async (server, port, metadata) =>
               ? `https://${host}${path}`
               : `http://${host}:${port}${path}`,
           local: `http://localhost:${port}${path}`,
+          apis: metadata.apis,
         };
 
         return resolve(true);
@@ -119,4 +196,14 @@ const listenPortController = async (server, port, metadata) =>
     }
   });
 
-export { ip, network, listenPortController, networkRouter, saveRuntimeRouter, logRuntimeRouter, listenServerFactory };
+export {
+  ip,
+  network,
+  listenPortController,
+  networkRouter,
+  netWorkCron,
+  saveRuntimeRouter,
+  logRuntimeRouter,
+  listenServerFactory,
+  saveRuntimeCron,
+};