underpost 2.6.2

package/src/server/downloader.js

@@ -0,0 +1,42 @@
+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' }) =>
+  new Promise((resolve, reject) =>
+    axios({
+      url,
+      ...options,
+    })
+      .then((response) => {
+        // Create a write stream to save the file to the specified path
+        const writer = fs.createWriteStream(fullPath);
+        response.data.pipe(writer);
+        writer.on('finish', () => {
+          logger.info('Download complete. File saved at', fullPath);
+          return resolve(fullPath);
+        });
+        writer.on('error', (error) => {
+          logger.error(error, 'Error downloading the file');
+          return reject(error);
+        });
+      })
+      .catch((error) => {
+        logger.error(error, 'Error in the request');
+        return reject(error);
+      }),
+  );
+
+export { Downloader };

package/src/server/logger.js

@@ -0,0 +1,135 @@
+'use strict';
+
+import dotenv from 'dotenv';
+import winston from 'winston';
+import morgan from 'morgan';
+import colorize from 'json-colorizer';
+import colors from 'colors';
+import v8 from 'v8';
+import isAdmin from 'is-admin';
+import { clearTerminalStringColor, formatBytes } from '../client/components/core/CommonJs.js';
+
+colors.enable();
+dotenv.config();
+
+// Define your severity levels.
+// With them, You can create log files,
+// see or hide levels based on the running ENV.
+const levels = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  http: 3,
+  debug: 4,
+};
+
+// This method set the current severity based on
+// the current NODE_ENV: show all the log levels
+// if the server was run in development mode; otherwise,
+// if it was run in production, show only warn and error messages.
+const level = () => 'info'; // (process.env.NODE_ENV || 'development' ? 'debug' : 'warn');
+
+// Define different colors for each level.
+// Colors make the log message more visible,
+// adding the ability to focus or ignore messages.
+
+// Tell winston that you want to link the colors
+// defined above to the severity levels.
+winston.addColors({
+  error: 'red',
+  warn: 'yellow',
+  info: 'green',
+  http: 'magenta',
+  debug: 'white',
+});
+
+// Chose the aspect of your log customizing the log format.
+const format = (meta) =>
+  winston.format.combine(
+    // winston.format.errors({ stack: true }),
+    // Add the message timestamp with the preferred format
+    winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss:ms' }),
+    // Tell Winston that the logs must be colored
+    winston.format.colorize({ all: true }),
+    // Define the format of the message showing the timestamp, the level and the message
+    winston.format.printf((info) => {
+      const symbols = Object.getOwnPropertySymbols(info);
+      return `${`[${meta}]`.green} ${info.timestamp} ${info.level} ${
+        symbols[1]
+          ? `${clearTerminalStringColor(info.message)}: ${colorize(JSON.stringify(info[symbols[1]][0], null, 4), {
+              colors: {
+                STRING_KEY: 'green',
+                STRING_LITERAL: 'magenta.bold',
+                NUMBER_LITERAL: '#FF0000',
+              },
+            })}`
+          : info.message
+      }`;
+    }),
+  );
+
+const loggerFactory = (meta) => {
+  meta = meta.url.split('/').pop();
+  // Define which transports the logger must use to print out messages.
+  // In this example, we are using three different transports
+  const transports = [
+    // Allow the use the terminal to print the messages
+    new winston.transports.Console(),
+    // Allow to print all the error level messages inside the error.log file
+    new winston.transports.File({
+      filename: `logs/${meta}/error.log`,
+      level: 'error',
+    }),
+    // Allow to print all the error message inside the all.log file
+    // (also the error log that are also printed inside the error.log(
+    new winston.transports.File({ filename: `logs/${meta}/all.log` }),
+  ];
+
+  // Create the logger instance that has to be exported
+  // and used to log messages.
+  const logger = winston.createLogger({
+    defaultMeta: meta,
+    level: level(),
+    levels,
+    format: format(meta),
+    transports,
+    // exceptionHandlers: [new winston.transports.File({ filename: 'exceptions.log' })],
+    // rejectionHandlers: [new winston.transports.File({ filename: 'rejections.log' })],
+    // exitOnError: false,
+  });
+  logger.setUpInfo = async () => {
+    logger.info('argv', process.argv);
+    logger.info('env', process.env.NODE_ENV);
+    logger.info('admin', await isAdmin());
+    logger.info('--max-old-space-size', {
+      total_available_size: formatBytes(v8.getHeapStatistics().total_available_size),
+    });
+  };
+  return logger;
+};
+
+const loggerMiddleware = (meta) => {
+  const stream = {
+    // Use the http severity
+    write: (message) => loggerFactory(meta).http(message),
+  };
+
+  const skip = (req, res) => process.env.NODE_ENV === 'production';
+
+  morgan.token('host', function (req, res) {
+    return req.headers['host'];
+  });
+
+  return morgan(
+    // Define message format string (this is the default one).
+    // The message format is made from tokens, and each token is
+    // defined inside the Morgan library.
+    // You can create your custom token to show what do you want from a request.
+    `:remote-addr :method :host:url :status :res[content-length] - :response-time ms`,
+    // Options: in this case, I overwrote the stream and the skip logic.
+    // See the methods above.
+    { stream, skip },
+  );
+};
+
+export { loggerFactory, loggerMiddleware };

package/src/server/network.js

@@ -0,0 +1,122 @@
+import detect from 'detect-port';
+import fs from 'fs-extra';
+
+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';
+
+// Network Address Translation Management
+
+// import dotenv from 'dotenv';
+// dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+const network = {
+  port: {
+    status: async (ports) => {
+      const status = [];
+      for (const port of ports) {
+        status.push({
+          port,
+          open: await new Promise((resolve) =>
+            detect(port)
+              .then((_port) => {
+                if (port == _port)
+                  // `port: ${port} was not occupied`
+                  return resolve(false);
+
+                // `port: ${port} was occupied, try port: ${_port}`
+                return resolve(true);
+              })
+              .catch((error) => resolve(`${error.message}`)),
+          ),
+        });
+      }
+      return status;
+    },
+    kill: async (ports) => await killPortProcess(ports),
+    portClean: async function (port) {
+      const [portStatus] = await this.status([port]);
+      // logger.info('port status', portStatus);
+      if (portStatus.open) await this.kill([port]);
+    },
+  },
+};
+
+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'
+  },
+};
+
+let ipInstance = '';
+const networkRouter = {};
+
+const logRuntimeRouter = () => {
+  const displayLog = {};
+
+  for (const host of Object.keys(networkRouter))
+    for (const path of Object.keys(networkRouter[host]))
+      displayLog[networkRouter[host][path].publicHost] = networkRouter[host][path].local;
+
+  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 listenServerFactory = (logic = async () => {}) => {
+  return {
+    listen: async (...args) => (logic ? await logic(...args) : undefined, args[1]()),
+  };
+};
+
+const listenPortController = async (server, port, metadata) =>
+  new Promise((resolve) => {
+    try {
+      if (!server) server = listenServerFactory();
+
+      const { host, path, client, runtime, meta } = metadata;
+      const error = [];
+      if (port === undefined) error.push(`port`);
+      if (host === undefined) error.push(`host`);
+      if (path === undefined) error.push(`path`);
+      if (client === undefined) error.push(`client`);
+      if (runtime === undefined) error.push(`runtime`);
+      if (meta === undefined) error.push(`meta`);
+      if (error.length > 0) throw new Error('Listen port controller requires values: ' + error.join(', '));
+
+      server.listen(port, () => {
+        if (!networkRouter[host]) networkRouter[host] = {};
+        networkRouter[host][path] = {
+          meta,
+          client,
+          runtime,
+          port,
+          public: `http://${ipInstance}:${port}${path}`,
+          publicHost:
+            port === 80
+              ? `http://${host}${path}`
+              : port === 443
+              ? `https://${host}${path}`
+              : `http://${host}:${port}${path}`,
+          local: `http://localhost:${port}${path}`,
+        };
+
+        return resolve(true);
+      });
+    } catch (error) {
+      logger.error(error, { metadata, port, stack: error.stack });
+      resolve(false);
+    }
+  });
+
+export { ip, network, listenPortController, networkRouter, saveRuntimeRouter, logRuntimeRouter, listenServerFactory };

package/src/server/peer.js

@@ -0,0 +1,33 @@
+import { PeerServer } from 'peer';
+import dotenv from 'dotenv';
+import { loggerFactory } from './logger.js';
+import fs from 'fs-extra';
+import { listenServerFactory } from './network.js';
+
+dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+// https://github.com/peers/peerjs
+// https://github.com/peers/peerjs-server
+
+const createPeerServer = async ({ port, devPort, origins, host, path }) => {
+  if (process.env.NODE_ENV === 'development' && devPort) origins.push(`http://localhost:${devPort}`);
+  /** @type {import('peer').IConfig} */
+  const options = {
+    port,
+    path: `${path === '/' ? '' : path}/peer`,
+    corsOptions: {
+      origin: origins,
+    },
+    proxied: true,
+    // key: fs.readFileSync(''),
+    // cert: fs.readFileSync(''),
+    // ca: fs.readFileSync(''),
+  };
+  const peerServer = listenServerFactory(() => PeerServer(options));
+
+  return { options, peerServer, meta: import.meta };
+};
+
+export { createPeerServer };

package/src/server/process.js

@@ -0,0 +1,66 @@
+// https://nodejs.org/api/process
+
+import shell from 'shelljs';
+import dotenv from 'dotenv';
+import fs from 'fs-extra';
+
+import { loggerFactory } from './logger.js';
+
+dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+// process.exit();
+
+const getRootDirectory = () => process.cwd().replace(/\\/g, '/');
+
+const ProcessController = {
+  SIG: [
+    'SIGPIPE',
+    'SIGHUP',
+    'SIGTERM',
+    'SIGINT',
+    'SIGBREAK',
+    'SIGWINCH',
+    // 'SIGKILL',
+    // 'SIGSTOP',
+    'SIGBUS',
+    'SIGFPE',
+    'SIGSEGV',
+    'SIGILL',
+  ],
+  onSigListen: function () {
+    return this.SIG.map((sig) =>
+      process.on(sig, (...args) => {
+        this.logger.info(`process on ${sig}`, args);
+        switch (sig) {
+          case 'SIGINT':
+            return process.exit();
+
+          default:
+            break;
+        }
+      }),
+    );
+  },
+  init: function (logger) {
+    this.logger = logger;
+    process.on('exit', (...args) => {
+      this.logger.info(`process on exit`, args);
+    });
+    this.onSigListen();
+    if (fs.existsSync(`./tmp/await-deploy`)) fs.remove(`./tmp/await-deploy`);
+  },
+};
+
+const shellExec = (cmd, options = { silent: false, async: false, stdout: false }) => {
+  logger.info(`cmd`, cmd);
+  return options.stdout ? shell.exec(cmd, options).stdout : shell.exec(cmd, options);
+};
+
+const shellCd = (cd) => {
+  logger.info(`cd`, cd);
+  return shell.cd(cd);
+};
+
+export { ProcessController, getRootDirectory, shellExec, shellCd };

package/src/server/proxy.js

@@ -0,0 +1,118 @@
+'use strict';
+
+import express from 'express';
+import fs from 'fs-extra';
+import dotenv from 'dotenv';
+
+import { createProxyMiddleware } from 'http-proxy-middleware';
+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';
+
+dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+const buildProxy = async () => {
+  // default target
+  await network.port.portClean(process.env.PORT);
+  express().listen(process.env.PORT);
+
+  const proxyRouter = buildProxyRouter();
+
+  for (let port of Object.keys(proxyRouter)) {
+    port = parseInt(port);
+    const hosts = proxyRouter[port];
+    const app = express();
+
+    // set logger
+    app.use(loggerMiddleware(import.meta));
+
+    // instance proxy options
+    // https://github.com/chimurai/http-proxy-middleware/tree/v2.0.4#readme
+
+    // proxy middleware options
+    /** @type {import('http-proxy-middleware/dist/types').Options} */
+    const options = {
+      ws: true,
+      // changeOrigin: true,
+      // autoRewrite: false,
+      target: `http://localhost:${process.env.PORT}`,
+      router: {},
+      xfwd: true, // adds x-forward headers
+      // preserveHeaderKeyCase: true,
+      // secure: true, warn validator
+      onProxyReq: (proxyReq, req, res, options) => {
+        sslRedirectMiddleware(req, res, port, proxyRouter);
+      },
+      pathRewrite: {
+        // only add path
+        // '^/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;
+    });
+
+    // order router
+    const router = {};
+    for (const absoluteHostKey of orderArrayFromAttrInt(Object.keys(options.router), 'length'))
+      router[absoluteHostKey] = options.router[absoluteHostKey];
+    options.router = router;
+
+    if (Object.keys(options.router).length === 0) continue;
+
+    // instance proxy server
+
+    const proxyPath = '/';
+    const proxyHost = 'localhost';
+
+    const filter = false
+      ? (pathname, req) => {
+          // return pathname.match('^/api') && req.method === 'GET';
+          return true;
+        }
+      : proxyPath;
+    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) {
+          case 443:
+            const { ServerSSL } = await createSslServer(app, hosts);
+            await listenPortController(ServerSSL, port, runningData);
+            break;
+
+          default:
+            await listenPortController(app, port, runningData);
+
+            break;
+        }
+
+        break;
+
+      default:
+        await listenPortController(app, port, runningData);
+
+        break;
+    }
+    logger.info('Proxy running', { port, options });
+  }
+};
+
+export { buildProxy };