underpost 2.7.83 → 2.7.91

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,38 +1,47 @@
 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 () {
-    // WAN | NAT-VPS | LAN
+  InitIpDaemon: async function ({ deployId }) {
+    // NAT-VPS modem/router device configuration:
+    // LAN --> [NAT-VPS] --> WAN
     // 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)
-    // DNS Records: [ANAME](Address Dynamic) -> [A](ipv4) host | [AAAA](ipv6) host -> [ip]
+    // disabled local red DHCP
+    // 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
 
-    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 +50,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 +63,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 +102,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,
+};

package/src/server/proxy.js

@@ -9,7 +9,8 @@ import { loggerFactory, loggerMiddleware } from './logger.js';
 import { listenPortController, network } from './network.js';
 import { orderArrayFromAttrInt } from '../client/components/core/CommonJs.js';
 import { createSslServer, sslRedirectMiddleware } from './ssl.js';
-import { buildProxyRouter } from './conf.js';
+import { buildProxyRouter, maintenanceMiddleware } from './conf.js';
+import { getRootDirectory } from './process.js';
 
 dotenv.config();
 
@@ -25,6 +26,9 @@ const buildProxy = async () => {
   for (let port of Object.keys(proxyRouter)) {
     port = parseInt(port);
     const hosts = proxyRouter[port];
+    const proxyPath = '/';
+    const proxyHost = 'localhost';
+    const runningData = { host: proxyHost, path: proxyPath, client: null, runtime: 'nodejs', meta: import.meta };
     const app = express();
 
     // set logger
@@ -47,6 +51,7 @@ const buildProxy = async () => {
       onProxyReq: (proxyReq, req, res, options) => {
         // https://wtools.io/check-http-status-code
         // http://nexodev.org
+        maintenanceMiddleware(req, res, port, proxyRouter);
         sslRedirectMiddleware(req, res, port, proxyRouter);
       },
       pathRewrite: {
@@ -54,30 +59,27 @@ const buildProxy = async () => {
         // '^/target-path': '/',
       },
     };
-
-    // build router
-    Object.keys(hosts).map((hostKey) => {
-      let { host, path, target, proxy, peer } = hosts[hostKey];
-      if (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 (!(absoluteHost in options.router)) options.router[absoluteHost] = target;
-    });
-    if (Object.keys(options.router).length === 0) continue;
-
-    // order router
-    const router = {};
-    for (const absoluteHostKey of orderArrayFromAttrInt(Object.keys(options.router), 'length'))
-      router[absoluteHostKey] = options.router[absoluteHostKey];
-    options.router = router;
-
-    // instance proxy server
-    const proxyPath = '/';
-    const proxyHost = 'localhost';
+    if (!process.argv.includes('maintenance')) {
+      // build router
+      Object.keys(hosts).map((hostKey) => {
+        let { host, path, target, proxy, peer } = hosts[hostKey];
+        if (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 (!(absoluteHost in options.router)) options.router[absoluteHost] = target;
+      });
+      if (Object.keys(options.router).length === 0) continue;
+
+      // order router
+      const router = {};
+      for (const absoluteHostKey of orderArrayFromAttrInt(Object.keys(options.router), 'length'))
+        router[absoluteHostKey] = options.router[absoluteHostKey];
+      options.router = router;
+    }
 
     const filter = false
       ? (pathname, req) => {
@@ -88,8 +90,6 @@ const buildProxy = async () => {
     app.use(proxyPath, createProxyMiddleware(filter, options));
     await network.port.portClean(port);
 
-    const runningData = { host: proxyHost, path: proxyPath, client: null, runtime: 'nodejs', meta: import.meta };
-
     switch (process.env.NODE_ENV) {
       case 'production':
         switch (port) {

package/src/server/runtime.js

@@ -18,13 +18,14 @@ import { DataBaseProvider } from '../db/DataBaseProvider.js';
 import { createProxyMiddleware } from 'http-proxy-middleware';
 import { createPeerServer } from './peer.js';
 import { Lampp } from '../runtime/lampp/Lampp.js';
+import { getDeployId } from './conf.js';
 
 dotenv.config();
 
 const logger = loggerFactory(import.meta);
 
 const buildRuntime = async () => {
-  const deployId = `${process.argv[3] ? process.argv[3] : 'default'}`;
+  const deployId = getDeployId();
 
   const collectDefaultMetrics = promClient.collectDefaultMetrics;
   collectDefaultMetrics();
@@ -95,6 +96,7 @@ export PATH=$PATH:/opt/lampp/bin`,
         runtime,
         client,
         meta: import.meta,
+        apis,
       };
 
       let redirectUrl;
@@ -325,7 +327,7 @@ export PATH=$PATH:/opt/lampp/bin`,
               apis && process.env.NODE_ENV === 'development' ? [`http://localhost:${currentPort + 2}`] : [],
             ),
           };
-          logger.info('originPayload', originPayload);
+          // logger.info('originPayload', originPayload);
           app.use(cors(originPayload));
 
           if (redirect) {

package/src/server/ssl.js

@@ -16,7 +16,7 @@ const buildSSL = async (host) => {
   const files = await fs.readdir(sslPath);
 
   for (const folderHost of files)
-    if (folderHost.match(host.split('/')[0])) {
+    if (folderHost.match(host.split('/')[0]) && host.split('.')[0] === folderHost.split('.')[0]) {
       for (const i of [''].concat(range(1, 10))) {
         const privateKeyPath = `${sslPath}/${folderHost}/privkey${i}.pem`;
         const certificatePath = `${sslPath}/${folderHost}/cert${i}.pem`;
@@ -51,7 +51,7 @@ const buildSSL = async (host) => {
           fs.writeFileSync(`./engine-private/ssl/${host}/_ca_bundle.crt`, ca, 'utf8');
           fs.writeFileSync(`./engine-private/ssl/${host}/_ca_full_bundle.crt`, caFull, 'utf8');
 
-          // fs.removeSync(`${sslPath}/${folderHost}`);
+          fs.removeSync(`${sslPath}/${folderHost}`);
           return true;
         }
       }

package/src/client/ssr/offline/default.index.js

@@ -1,31 +0,0 @@
-import { htmls, loggerFactory } from '../common/SsrCore.js';
-import { Alert } from '../common/Alert.js';
-import { Translate } from '../common/Translate.js';
-import { Worker } from '../common/Worker.js';
-/*imports*/
-
-const logger = loggerFactory({ url: '/offline.js' });
-
-window.onload = () =>
-  Worker.instance({
-    render: async () => {
-      window.ononline = async () => {
-        location.href = '/';
-      };
-      window.onoffline = async () => {
-        htmls(`.page-render`, html`${await Alert.noInternet({ Translate })}`);
-      };
-      try {
-        if (navigator.onLine) {
-          const maintenance = await fetch(location.origin + '/favicon.ico');
-          if (maintenance.status !== 200) {
-            htmls(`.page-render`, html`${await Alert.maintenance({ Translate })}`);
-          } else window.ononline();
-        }
-        throw new Error(`no internet connection`);
-      } catch (error) {
-        logger.error(error);
-        window.onoffline();
-      }
-    },
-  });

package/src/cron.js

@@ -1,30 +0,0 @@
-'use strict';
-
-// https://nodejs.org/api
-// https://expressjs.com/en/4x/api.html
-
-import dotenv from 'dotenv';
-import { loggerFactory } from './server/logger.js';
-import { Dns } from './server/dns.js';
-import { ProcessController } from './server/process.js';
-import { Config } from './server/conf.js';
-import { BackUpManagement } from './server/backup.js';
-import { CronManagement } from './server/cron.js';
-
-dotenv.config();
-
-await Config.build();
-
-const logger = loggerFactory(import.meta);
-
-await logger.setUpInfo();
-
-// every minutes
-CronManagement.add('ip', '* * * * *', await Dns.InitIpDaemon());
-
-// every day at 1 am
-CronManagement.add('backup', '0 1 * * *', await BackUpManagement.Init());
-
-await CronManagement.init();
-
-ProcessController.init(logger);

package/src/server/cron.js

@@ -1,35 +0,0 @@
-import cron from 'node-cron';
-import { loggerFactory } from './logger.js';
-
-const logger = loggerFactory(import.meta);
-
-const CronManagement = {
-  data: {},
-  init: function () {
-    // verify tokens
-    // https://github.com/settings/tokens
-    for (const cronKey of Object.keys(this.data)) {
-      if (this.data[cronKey].valid) {
-        this.data[cronKey].task.start();
-        logger.info(`Cron task "${this.data[cronKey].name}" started`);
-      } else {
-        logger.error(
-          `Invalid cron expression "${this.data[cronKey].expression}" for task "${this.data[cronKey].name}"`,
-        );
-      }
-    }
-  },
-  add: function (name = 'task', expression = '* * * * *', callback = async () => null) {
-    const args = { name, expression, valid: cron.validate(expression) };
-    this.data[name] = {
-      ...args,
-      task: cron.schedule(expression, callback, {
-        scheduled: false,
-        timezone: process.env.TIME_ZONE || 'America/New_York',
-        name,
-      }),
-    };
-  },
-};
-
-export { CronManagement };