@underpostnet/underpost 2.8.5 → 2.8.7

package/src/index.js

@@ -9,11 +9,14 @@ import UnderpostCron from './cli/cron.js';
 import UnderpostDB from './cli/db.js';
 import UnderpostDeploy from './cli/deploy.js';
 import UnderpostRootEnv from './cli/env.js';
+import UnderpostFileStorage from './cli/fs.js';
 import UnderpostImage from './cli/image.js';
+import UnderpostMonitor from './cli/monitor.js';
 import UnderpostRepository from './cli/repository.js';
 import UnderpostScript from './cli/script.js';
 import UnderpostSecret from './cli/secrets.js';
 import UnderpostTest from './cli/test.js';
+import UnderpostStartUp from './server/start.js';
 
 /**
  * Underpost main module methods
@@ -27,7 +30,7 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v2.8.5';
+  static version = 'v2.8.7';
   /**
    * Repository cli API
    * @static
@@ -49,6 +52,13 @@ class Underpost {
    * @memberof Underpost
    */
   static test = UnderpostTest.API;
+  /**
+   * Underpost Start Up cli API
+   * @static
+   * @type {UnderpostStartUp.API}
+   * @memberof Underpost
+   */
+  static start = UnderpostStartUp.API;
   /**
    * Cluster cli API
    * @static
@@ -98,6 +108,20 @@ class Underpost {
    * @memberof Underpost
    */
   static cron = UnderpostCron.API;
+  /**
+   * File Storage cli API
+   * @static
+   * @type {UnderpostFileStorage.API}
+   * @memberof Underpost
+   */
+  static fs = UnderpostFileStorage.API;
+  /**
+   * Monitor cli API
+   * @static
+   * @type {UnderpostMonitor.API}
+   * @memberof Underpost
+   */
+  static monitor = UnderpostMonitor.API;
 }
 
 const up = Underpost;

package/src/mailer/MailerProvider.js

@@ -32,6 +32,9 @@ const MailerProvider = {
     },
   ) {
     try {
+      options.transport.tls = {
+        rejectUnauthorized: false,
+      };
       const { id } = options;
       // Generate test SMTP service account from ethereal.email
       // Only needed if you don't have a real mail account for testing

package/src/runtime/lampp/Dockerfile

@@ -0,0 +1,65 @@
+ARG BASE_DEBIAN=buster
+
+USER root
+
+FROM debian:${BASE_DEBIAN}
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Set root password to root, format is 'user:password'.
+RUN echo 'root:root' | chpasswd
+
+RUN apt-get update --fix-missing
+RUN apt-get upgrade -y
+# install sudo
+RUN apt-get -y install sudo
+# net-tools provides netstat commands
+RUN apt-get -y install curl net-tools
+RUN apt-get -yq install openssh-server supervisor
+# Few handy utilities which are nice to have
+RUN apt-get -y install nano vim less --no-install-recommends
+RUN apt-get clean
+
+# install ssh
+RUN mkdir -p /var/run/sshd
+# Allow root login via password
+RUN sed -ri 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/g' /etc/ssh/sshd_config
+
+# install open ssl git and others tools
+RUN apt-get install -yq --no-install-recommends libssl-dev curl wget git gnupg
+
+# install lampp
+RUN curl -Lo xampp-linux-installer.run https://sourceforge.net/projects/xampp/files/XAMPP%20Linux/7.4.33/xampp-linux-x64-7.4.33-0-installer.run?from_af=true
+RUN chmod +x xampp-linux-installer.run
+RUN bash -c './xampp-linux-installer.run'
+RUN ln -sf /opt/lampp/lampp /usr/bin/lampp
+# Enable XAMPP web interface(remove security checks)
+RUN sed -i.bak s'/Require local/Require all granted/g' /opt/lampp/etc/extra/httpd-xampp.conf
+# Enable error display in php
+RUN sed -i.bak s'/display_errors=Off/display_errors=On/g' /opt/lampp/etc/php.ini
+# Enable includes of several configuration files
+RUN mkdir /opt/lampp/apache2/conf.d
+RUN echo "IncludeOptional /opt/lampp/apache2/conf.d/*.conf" >>/opt/lampp/etc/httpd.conf
+# Create a /www folder and a symbolic link to it in /opt/lampp/htdocs. It'll be accessible via http://localhost:[port]/www/
+# This is convenient because it doesn't interfere with xampp, phpmyadmin or other tools in /opt/lampp/htdocs
+# /opt/lampp/etc/httpd.conf
+RUN mkdir /www
+RUN ln -s /www /opt/lampp/htdocs
+
+# install nodejs https://github.com/nodesource/distributions/blob/master/README.md#deb
+RUN curl -fsSL https://deb.nodesource.com/setup_23.x | bash -
+RUN apt-get install -y nodejs build-essential
+RUN node --version
+RUN npm --version
+
+WORKDIR /home/dd
+
+EXPOSE 22
+
+EXPOSE 80
+
+EXPOSE 443
+
+EXPOSE 3000-3100
+
+EXPOSE 4000-4100

package/src/server/backup.js

@@ -9,7 +9,7 @@ dotenv.config();
 const logger = loggerFactory(import.meta);
 
 class BackUp {
-  static callback = async function (deployList, options = { disableKindCluster: false }) {
+  static callback = async function (deployList, options = { itc: false, git: false }) {
     if ((!deployList || deployList === 'dd') && fs.existsSync(`./engine-private/deploy/dd.router`))
       deployList = fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8');
 
@@ -25,8 +25,8 @@ class BackUp {
       const deployId = _deployId.trim();
       if (!deployId) continue;
 
-      if (options.disableKindCluster !== true) {
-        shellExec(`underpost db --export ${deployId}`);
+      if (!(options.itc === true)) {
+        shellExec(`node bin db ${options.git ? '--git ' : ''}--export ${deployId}`);
         continue;
       }
 

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();
 
@@ -250,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,
@@ -487,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;
                 }
               }
@@ -507,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(
@@ -681,6 +683,19 @@ Sitemap: https://${host}${path === '/' ? '' : path}/sitemap.xml`,
 root file where the route starts, such as index.js, app.js, routes.js, etc ... */
 
         await swaggerAutoGen({ openapi: '3.0.0' })(outputFile, routes, doc);
+
+        const htmlFiles = await fs.readdir(`./public/${host}/docs/engine/${Underpost.version.replace('v', '')}`);
+        for (const htmlFile of htmlFiles) {
+          if (htmlFile.match('.html')) {
+            fs.writeFileSync(
+              `./public/${host}/docs/engine/${Underpost.version.replace('v', '')}/${htmlFile}`,
+              fs
+                .readFileSync(`./public/${host}/docs/engine/${Underpost.version.replace('v', '')}/${htmlFile}`, 'utf8')
+                .replaceAll('Tutorials', 'References'),
+              'utf8',
+            );
+          }
+        }
       }
 
       if (client) {
@@ -707,6 +722,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 = `${
@@ -739,16 +763,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

@@ -2,6 +2,7 @@
 
 import fs from 'fs-extra';
 import vm from 'node:vm';
+import Underpost from '../index.js';
 
 const srcFormatted = (src) =>
   src
@@ -49,7 +50,7 @@ const viewFormatted = (src, dists, proxyPath, baseHost = '') => {
 };
 
 const ssrFactory = async (componentPath = `./src/client/ssr/Render.js`) => {
-  const context = { SrrComponent: () => {}, npm_package_version: process.env.npm_package_version };
+  const context = { SrrComponent: () => {}, npm_package_version: Underpost.version };
   vm.createContext(context);
   vm.runInContext(await srcFormatted(fs.readFileSync(componentPath, 'utf8')), context);
   return context.SrrComponent;

package/src/server/conf.js

@@ -19,17 +19,8 @@ import { DefaultConf } from '../../conf.js';
 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();
@@ -508,6 +499,40 @@ const buildProxyRouter = () => {
   return proxyRouter;
 };
 
+const pathPortAssignmentFactory = (router, confServer) => {
+  const pathPortAssignmentData = {};
+  for (const host of Object.keys(confServer)) {
+    const pathPortAssignment = [];
+    for (const path of Object.keys(confServer[host])) {
+      const { peer } = confServer[host][path];
+      if (!router[`${host}${path === '/' ? '' : path}`]) continue;
+      const port = parseInt(router[`${host}${path === '/' ? '' : path}`].split(':')[2]);
+      // logger.info('', { host, port, path });
+      pathPortAssignment.push({
+        port,
+        path,
+      });
+
+      if (peer) {
+        //  logger.info('', { host, port: port + 1, path: '/peer' });
+        pathPortAssignment.push({
+          port: port + 1,
+          path: '/peer',
+        });
+      }
+    }
+    pathPortAssignmentData[host] = pathPortAssignment;
+  }
+  return pathPortAssignmentData;
+};
+
+const deployRangePortFactory = (router) => {
+  const ports = Object.values(router).map((p) => parseInt(p.split(':')[2]));
+  const fromPort = Math.min(...ports);
+  const toPort = Math.max(...ports);
+  return { ports, fromPort, toPort };
+};
+
 const buildKindPorts = (from, to) =>
   range(parseInt(from), parseInt(to))
     .map(
@@ -598,7 +623,13 @@ 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 =
     options.deployGroupId === 'dd'
@@ -610,6 +641,8 @@ const getDataDeploy = (
     .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);
 
   dataDeploy = dataDeploy.map((deployId) => {
@@ -730,7 +763,7 @@ const validateTemplatePath = (absolutePath = '') => {
   return true;
 };
 
-const deployTest = async (dataDeploy) => {
+const deployTest = async (dataDeploy = [{ deployId: 'default' }]) => {
   const failed = [];
   for (const deploy of dataDeploy) {
     const deployServerConfPath = fs.existsSync(`./engine-private/replica/${deploy.deployId}/conf.server.json`)
@@ -774,6 +807,12 @@ const deployTest = async (dataDeploy) => {
   return { failed };
 };
 
+const awaitDeployMonitor = async (init = false, deltaMs = 1000) => {
+  if (init) fs.writeFileSync(`./tmp/await-deploy`, '', 'utf8');
+  await timer(deltaMs);
+  if (fs.existsSync(`./tmp/await-deploy`)) return await awaitDeployMonitor();
+};
+
 const getDeployGroupId = () => {
   const deployGroupIndexArg = process.argv.findIndex((a) => a.match(`deploy-group:`));
   if (deployGroupIndexArg > -1) return process.argv[deployGroupIndexArg].split(':')[1].trim();
@@ -843,7 +882,7 @@ 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`);
@@ -884,6 +923,53 @@ const mergeFile = async (parts = [], outputFilePath) => {
   });
 };
 
+const rebuildConfFactory = ({ deployId, valkey, mongo }) => {
+  const confServer = loadReplicas(
+    JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8')),
+  );
+  const hosts = {};
+  for (const host of Object.keys(confServer)) {
+    hosts[host] = {};
+    for (const path of Object.keys(confServer[host])) {
+      if (!confServer[host][path].db) continue;
+      const { singleReplica, replicas, db } = confServer[host][path];
+      const { provider } = db;
+      if (singleReplica) {
+        for (const replica of replicas) {
+          const deployIdReplica = buildReplicaId({ replica, deployId });
+          const confServerReplica = JSON.parse(
+            fs.readFileSync(`./engine-private/replica/${deployIdReplica}/conf.server.json`, 'utf8'),
+          );
+          for (const _host of Object.keys(confServerReplica)) {
+            for (const _path of Object.keys(confServerReplica[_host])) {
+              hosts[host][_path] = { replica: { host, path } };
+              confServerReplica[_host][_path].valkey = valkey;
+              switch (provider) {
+                case 'mongoose':
+                  confServerReplica[_host][_path].db.host = mongo.host;
+                  break;
+              }
+            }
+          }
+          fs.writeFileSync(
+            `./engine-private/replica/${deployIdReplica}/conf.server.json`,
+            JSON.stringify(confServerReplica, null, 4),
+            'utf8',
+          );
+        }
+      } else hosts[host][path] = {};
+      confServer[host][path].valkey = valkey;
+      switch (provider) {
+        case 'mongoose':
+          confServer[host][path].db.host = mongo.host;
+          break;
+      }
+    }
+  }
+  fs.writeFileSync(`./engine-private/conf/${deployId}/conf.server.json`, JSON.stringify(confServer, null, 4), 'utf8');
+  return { hosts };
+};
+
 const getRestoreCronCmd = async (options = { host: '', path: '', conf: {}, deployId: '' }) => {
   const { host, path, conf, deployId } = options;
   const { runtime, db, git, directory } = conf[host][path];
@@ -989,15 +1075,15 @@ const getPathsSSR = (conf) => {
 
 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: (deployList, jobList, name, expression, options) =>
     `pm2 start ./bin/index.js --no-autorestart --instances 1 --cron "${expression}" --name ${name} -- cron ${
-      options?.disableKindCluster ? `--disable-kind-cluster ` : ''
-    }${deployList} ${jobList}`,
+      options?.itc ? `--itc ` : ''
+    }${options?.git ? `--git ` : ''}${deployList} ${jobList}`,
 };
 
 const fixDependencies = async () => {
@@ -1064,7 +1150,7 @@ const setUpProxyMaintenanceServer = ({ deployGroupId }) => {
   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 = () =>
@@ -1074,6 +1160,8 @@ const getNpmRootPath = () =>
     silent: true,
   }).trim();
 
+const getUnderpostRootPath = () => `${getNpmRootPath()}/underpost`;
+
 const writeEnv = (envPath, envObj) =>
   fs.writeFileSync(
     envPath,
@@ -1119,5 +1207,11 @@ export {
   buildPortProxyRouter,
   splitFileFactory,
   getNpmRootPath,
+  getUnderpostRootPath,
   writeEnv,
+  deployTest,
+  pathPortAssignmentFactory,
+  deployRangePortFactory,
+  awaitDeployMonitor,
+  rebuildConfFactory,
 };

package/src/server/dns.js

@@ -1,38 +1,59 @@
 import axios from 'axios';
 import dotenv from 'dotenv';
 import fs from 'fs';
-import https from 'https';
 import validator from 'validator';
-import { ip } from './network.js';
+import { publicIp, publicIpv4, publicIpv6 } from 'public-ip';
 import { loggerFactory } from './logger.js';
+import UnderpostRootEnv from '../cli/env.js';
+import dns from 'node:dns';
+import os from 'node:os';
 import { shellExec } from './process.js';
 
-const httpsAgent = new https.Agent({
-  rejectUnauthorized: false,
-});
-
-axios.defaults.httpsAgent = httpsAgent;
-
 dotenv.config();
 
 const logger = loggerFactory(import.meta);
 
+const ip = {
+  public: {
+    get: async () => await publicIp(), // => 'fe80::200:f8ff:fe21:67cf'
+    ipv4: async () => await publicIpv4(), // => '46.5.21.123'
+    ipv6: async () => await publicIpv6(), // => 'fe80::200:f8ff:fe21:67cf'
+  },
+};
+
+const isInternetConnection = (domain = 'google.com') =>
+  new Promise((resolve) => dns.lookup(domain, {}, (err) => resolve(err ? false : true)));
+
+// export INTERFACE=$(ip route | grep default | cut -d ' ' -f 5)
+// export IP_ADDRESS=$(ip -4 addr show dev $INTERFACE | grep -oP '(?<=inet\s)\d+(\.\d+){3}')
+const getLocalIPv4Address = () =>
+  os.networkInterfaces()[
+    shellExec(`ip route | grep default | cut -d ' ' -f 5`, {
+      stdout: true,
+      silent: true,
+      disableLog: true,
+    }).trim()
+  ].find((i) => i.family === 'IPv4').address;
+
 class Dns {
   static callback = async function (deployList) {
-    // NAT-VPS modem/router device configuration:
-    // LAN --> [NAT-VPS] --> WAN
+    // Network topology configuration:
+    // LAN -> [NAT-VPS](modem/router device) -> WAN
     // enabled DMZ Host to proxy IP 80-443 (79-444) sometimes router block first port
-    // disabled local red DHCP
+
+    // Enabling DHCP
+    // Navigate to Subnets > VLAN > Configure DHCP.
+    // Select the appropriate DHCP options (Managed or Relay).
+    // Save and apply changes.
+
     // verify inet ip proxy server address
     // DHCP (Dynamic Host Configuration Protocol) LAN reserver IP -> MAC ID
     // LAN server or device's local servers port ->  3000-3100 (2999-3101)
     // DNS Records: [ANAME](Address Dynamic) -> [A](ipv4) host | [AAAA](ipv6) host -> [public-ip]
     // Forward the router's TCP/UDP ports to the LAN device's IP address
-    for (const _deployId of deployList.split(',')) {
-      const deployId = _deployId.trim();
-    const privateCronConfPath = `./engine-private/conf/${deployId}/conf.cron.json`;
-    const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
-    const confCronData = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
+    const isOnline = await isInternetConnection();
+
+    if (!isOnline) return;
 
     let testIp;
 
@@ -41,36 +62,44 @@ class Dns {
     } catch (error) {
       logger.error(error, { testIp, stack: error.stack });
     }
-      const ipFileName = `${deployId}.ip`;
-      const currentIp = fs.existsSync(`./engine-private/deploy/${ipFileName}`)
-        ? fs.readFileSync(`./engine-private/deploy/${ipFileName}`, 'utf8')
-      : undefined;
 
-    if (testIp && typeof testIp === 'string' && validator.isIP(testIp) && currentIp !== testIp) {
+    const currentIp = UnderpostRootEnv.API.get('ip');
+
+    if (validator.isIP(testIp) && currentIp !== testIp) {
       logger.info(`new ip`, testIp);
-      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, ip: testIp });
-            }
-            break;
-
-          default:
-            break;
+      UnderpostRootEnv.API.set('monitor-input', 'pause');
+
+      for (const _deployId of deployList.split(',')) {
+        const deployId = _deployId.trim();
+        const privateCronConfPath = `./engine-private/conf/${deployId}/conf.cron.json`;
+        const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
+        const confCronData = JSON.parse(fs.readFileSync(confCronPath, '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, ip: testIp });
+              }
+              break;
+
+            default:
+              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) {
-            fs.writeFileSync(`./engine-private/deploy/${ipFileName}`, testIp, 'utf8');
-        } else logger.error('ip not updated');
-      } catch (error) {
-        logger.error(error), 'ip not updated';
+        try {
+          const ipUrlTest = `https://${process.env.DEFAULT_DEPLOY_HOST}`;
+          const response = await axios.get(ipUrlTest);
+          const verifyIp = response.request.socket.remoteAddress;
+          logger.info(ipUrlTest + ' verify ip', verifyIp);
+          if (verifyIp === testIp) {
+            logger.info('ip updated successfully', testIp);
+            UnderpostRootEnv.API.set('ip', testIp);
+            UnderpostRootEnv.API.delete('monitor-input');
+          } else logger.error('ip not updated', testIp);
+        } catch (error) {
+          logger.error(error, error.stack);
+          logger.error('ip not updated', testIp);
         }
       }
     }
@@ -101,3 +130,5 @@ class Dns {
 }
 
 export default Dns;
+
+export { Dns, ip, isInternetConnection, getLocalIPv4Address };

package/src/server/downloader.js

@@ -2,16 +2,8 @@ import axios from 'axios';
 import fs from 'fs';
 import { loggerFactory } from './logger.js';
 import dotenv from 'dotenv';
-import https from 'https';
-
 dotenv.config();
 
-const httpsAgent = new https.Agent({
-  rejectUnauthorized: false,
-});
-
-axios.defaults.httpsAgent = httpsAgent;
-
 const logger = loggerFactory(import.meta);
 
 const Downloader = (url, fullPath, options = { method: 'get', responseType: 'stream' }) =>