underpost 2.7.1 → 2.7.3

package/src/server/ssl.js

@@ -1,107 +1,120 @@
-import fs from 'fs-extra';
-import dotenv from 'dotenv';
-import https from 'https';
-import { loggerFactory } from './logger.js';
-import { range } from '../client/components/core/CommonJs.js';
-
-dotenv.config();
-
-const logger = loggerFactory(import.meta);
-
-const buildSSL = async (host) => {
-  const sslPath = process.env.CERTBOT_LIVE_PATH;
-
-  const files = await fs.readdir(sslPath);
-
-  for (const folderHost of files)
-    if (folderHost.match(host.split('/')[0])) {
-      for (const i of [''].concat(range(1, 10))) {
-        const privateKeyPath = `${sslPath}/${folderHost}/privkey${i}.pem`;
-        const certificatePath = `${sslPath}/${folderHost}/cert${i}.pem`;
-        const caPath = `${sslPath}/${folderHost}/chain${i}.pem`;
-        const caFullPath = `${sslPath}/${folderHost}/fullchain${i}.pem`;
-
-        if (
-          fs.existsSync(privateKeyPath) &&
-          fs.existsSync(certificatePath) &&
-          fs.existsSync(caPath) &&
-          fs.existsSync(caFullPath)
-        ) {
-          const privateKey = fs.readFileSync(privateKeyPath, 'utf8');
-          const certificate = fs.readFileSync(certificatePath, 'utf8');
-          const ca = fs.readFileSync(caPath, 'utf8');
-          const caFull = fs.readFileSync(caFullPath, 'utf8');
-
-          logger.info(`SSL files update`, {
-            privateKey,
-            certificate,
-            ca,
-            caFull,
-          });
-
-          if (!fs.existsSync(`./engine-private/ssl/${host}`))
-            fs.mkdirSync(`./engine-private/ssl/${host}`, { recursive: true });
-
-          fs.writeFileSync(`./engine-private/ssl/${host}/key.key`, privateKey, 'utf8');
-          fs.writeFileSync(`./engine-private/ssl/${host}/crt.crt`, certificate, 'utf8');
-          fs.writeFileSync(`./engine-private/ssl/${host}/ca_bundle.crt`, caFull, 'utf8');
-
-          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}`);
-          return true;
-        }
-      }
-    }
-  return false;
-};
-
-const validateSecureContext = (host) => {
-  return (
-    fs.existsSync(`./engine-private/ssl/${host}/key.key`) &&
-    fs.existsSync(`./engine-private/ssl/${host}/crt.crt`) &&
-    fs.existsSync(`./engine-private/ssl/${host}/ca_bundle.crt`)
-  );
-};
-
-const buildSecureContext = (host) => {
-  return {
-    key: fs.readFileSync(`./engine-private/ssl/${host}/key.key`, 'utf8'),
-    cert: fs.readFileSync(`./engine-private/ssl/${host}/crt.crt`, 'utf8'),
-    ca: fs.readFileSync(`./engine-private/ssl/${host}/ca_bundle.crt`, 'utf8'),
-  };
-};
-
-const createSslServer = async (app, hosts) => {
-  let ServerSSL;
-  for (const host of Object.keys(hosts)) {
-    // const { redirect } = hosts[host];
-    const [hostSSL, path = ''] = host.split('/');
-    await buildSSL(host);
-    const validSSL = validateSecureContext(hostSSL);
-    if (validSSL) {
-      if (!ServerSSL) ServerSSL = https.createServer(buildSecureContext(hostSSL), app);
-      else ServerSSL.addContext(hostSSL, buildSecureContext(hostSSL));
-    } else logger.error('Invalid SSL context', { host, ...hosts[host] });
-  }
-  return { ServerSSL };
-};
-
-const sslRedirectMiddleware = (req, res, port, proxyRouter) => {
-  const sslRedirectUrl = `https://${req.headers.host}${req.url}`;
-  if (
-    process.env.NODE_ENV === 'production' &&
-    port !== 443 &&
-    !req.secure &&
-    !req.url.startsWith(`/.well-known/acme-challenge`) &&
-    proxyRouter[443] &&
-    Object.keys(proxyRouter[443]).find((host) => {
-      const [hostSSL, path = ''] = host.split('/');
-      return sslRedirectUrl.match(hostSSL) && validateSecureContext(hostSSL);
-    })
-  )
-    return res.status(302).redirect(sslRedirectUrl);
-};
-
-export { buildSSL, buildSecureContext, validateSecureContext, createSslServer, sslRedirectMiddleware };
+import fs from 'fs-extra';
+import dotenv from 'dotenv';
+import https from 'https';
+import { loggerFactory } from './logger.js';
+import { range } from '../client/components/core/CommonJs.js';
+
+dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+const buildSSL = async (host) => {
+  const sslPath = process.env.CERTBOT_LIVE_PATH;
+  host = host.replaceAll(`\\`, '/');
+  const [hostSSL, path] = host.split('/');
+  if (path || !fs.existsSync(sslPath)) return;
+  const files = await fs.readdir(sslPath);
+
+  for (const folderHost of files)
+    if (folderHost.match(host.split('/')[0])) {
+      for (const i of [''].concat(range(1, 10))) {
+        const privateKeyPath = `${sslPath}/${folderHost}/privkey${i}.pem`;
+        const certificatePath = `${sslPath}/${folderHost}/cert${i}.pem`;
+        const caPath = `${sslPath}/${folderHost}/chain${i}.pem`;
+        const caFullPath = `${sslPath}/${folderHost}/fullchain${i}.pem`;
+
+        if (
+          fs.existsSync(privateKeyPath) &&
+          fs.existsSync(certificatePath) &&
+          fs.existsSync(caPath) &&
+          fs.existsSync(caFullPath)
+        ) {
+          const privateKey = fs.readFileSync(privateKeyPath, 'utf8');
+          const certificate = fs.readFileSync(certificatePath, 'utf8');
+          const ca = fs.readFileSync(caPath, 'utf8');
+          const caFull = fs.readFileSync(caFullPath, 'utf8');
+
+          logger.info(`SSL files update`, {
+            privateKey,
+            certificate,
+            ca,
+            caFull,
+          });
+
+          if (!fs.existsSync(`./engine-private/ssl/${host}`))
+            fs.mkdirSync(`./engine-private/ssl/${host}`, { recursive: true });
+
+          fs.writeFileSync(`./engine-private/ssl/${host}/key.key`, privateKey, 'utf8');
+          fs.writeFileSync(`./engine-private/ssl/${host}/crt.crt`, certificate, 'utf8');
+          fs.writeFileSync(`./engine-private/ssl/${host}/ca_bundle.crt`, caFull, 'utf8');
+
+          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}`);
+          return true;
+        }
+      }
+    }
+  return false;
+};
+
+const validateSecureContext = (host) => {
+  return (
+    fs.existsSync(`./engine-private/ssl/${host}/key.key`) &&
+    fs.existsSync(`./engine-private/ssl/${host}/crt.crt`) &&
+    fs.existsSync(`./engine-private/ssl/${host}/ca_bundle.crt`)
+  );
+};
+
+const buildSecureContext = (host) => {
+  return {
+    key: fs.readFileSync(`./engine-private/ssl/${host}/key.key`, 'utf8'),
+    cert: fs.readFileSync(`./engine-private/ssl/${host}/crt.crt`, 'utf8'),
+    ca: fs.readFileSync(`./engine-private/ssl/${host}/ca_bundle.crt`, 'utf8'),
+  };
+};
+
+const createSslServer = async (app, hosts) => {
+  let ServerSSL;
+  for (const host of Object.keys(hosts)) {
+    // const { redirect } = hosts[host];
+    const [hostSSL, path = ''] = host.split('/');
+    await buildSSL(host);
+    const validSSL = validateSecureContext(hostSSL);
+    if (validSSL) {
+      if (!ServerSSL) ServerSSL = https.createServer(buildSecureContext(hostSSL), app);
+      else ServerSSL.addContext(hostSSL, buildSecureContext(hostSSL));
+    } else logger.error('Invalid SSL context', { host, ...hosts[host] });
+  }
+  return { ServerSSL };
+};
+
+const sslRedirectMiddleware = (req, res, port, proxyRouter) => {
+  const sslRedirectUrl = `https://${req.headers.host}${req.url}`;
+  if (
+    process.env.NODE_ENV === 'production' &&
+    port !== 443 &&
+    !req.secure &&
+    !req.url.startsWith(`/.well-known/acme-challenge`) &&
+    proxyRouter[443] &&
+    Object.keys(proxyRouter[443]).find((host) => {
+      const [hostSSL, path = ''] = host.split('/');
+      return sslRedirectUrl.match(hostSSL) && validateSecureContext(hostSSL);
+    })
+  )
+    return res.status(302).redirect(sslRedirectUrl);
+};
+
+const installCertbot = () => {
+  switch (process.platform) {
+    case 'win32':
+      break;
+    case 'linux':
+      break;
+    default:
+      break;
+  }
+};
+
+export { buildSSL, buildSecureContext, validateSecureContext, createSslServer, sslRedirectMiddleware, installCertbot };

package/src/server.js

@@ -1,25 +1,25 @@
-'use strict';
-
-// https://nodejs.org/api
-// https://expressjs.com/en/4x/api.html
-
-import dotenv from 'dotenv';
-import { loggerFactory } from './server/logger.js';
-import { buildClient } from './server/client-build.js';
-import { buildRuntime } from './server/runtime.js';
-import { ProcessController } from './server/process.js';
-import { Config } from './server/conf.js';
-
-dotenv.config();
-
-await Config.build();
-
-const logger = loggerFactory(import.meta);
-
-await logger.setUpInfo();
-
-await buildClient();
-
-await buildRuntime();
-
-ProcessController.init(logger);
+'use strict';
+
+// https://nodejs.org/api
+// https://expressjs.com/en/4x/api.html
+
+import dotenv from 'dotenv';
+import { loggerFactory } from './server/logger.js';
+import { buildClient } from './server/client-build.js';
+import { buildRuntime } from './server/runtime.js';
+import { ProcessController } from './server/process.js';
+import { Config } from './server/conf.js';
+
+dotenv.config();
+
+await Config.build();
+
+const logger = loggerFactory(import.meta);
+
+await logger.setUpInfo();
+
+await buildClient();
+
+await buildRuntime();
+
+ProcessController.init(logger);

package/src/ws/IoInterface.js

@@ -1,45 +1,45 @@
-import { loggerFactory } from '../server/logger.js';
-
-const logger = loggerFactory(import.meta);
-
-const IoCreateChannel = (
-  IoInterface = {
-    channel: '',
-    connection: (socket = {}, client = {}, wsManagementId = '') => {},
-    controller: (socket = {}, client = {}, args = '', wsManagementId = '') => {},
-    disconnect: (socket = {}, client = {}, reason = '', wsManagementId = '') => {},
-    stream: false,
-  },
-) => {
-  return {
-    channel: IoInterface.channel,
-    client: {},
-    connection: async function (socket, wsManagementId) {
-      try {
-        this.client[socket.id] = socket;
-        socket.on(IoInterface.channel, (...args) => this.controller(socket, args, wsManagementId));
-        await IoInterface.connection(socket, this.client, wsManagementId);
-      } catch (error) {
-        logger.error(error, { channel: IoInterface.channel, wsManagementId, stack: error.stack });
-      }
-    },
-    controller: async function (socket, args, wsManagementId) {
-      try {
-        const payload = IoInterface.stream ? args[0] : JSON.parse(args[0]);
-        await IoInterface.controller(socket, this.client, payload, wsManagementId, args);
-      } catch (error) {
-        logger.error(error, { channel: IoInterface.channel, wsManagementId, args, stack: error.stack });
-      }
-    },
-    disconnect: async function (socket, reason, wsManagementId) {
-      try {
-        await IoInterface.disconnect(socket, this.client, reason, wsManagementId);
-        delete this.client[socket.id];
-      } catch (error) {
-        logger.error(error, { channel: IoInterface.channel, wsManagementId, reason, stack: error.stack });
-      }
-    },
-  };
-};
-
-export { IoCreateChannel };
+import { loggerFactory } from '../server/logger.js';
+
+const logger = loggerFactory(import.meta);
+
+const IoCreateChannel = (
+  IoInterface = {
+    channel: '',
+    connection: (socket = {}, client = {}, wsManagementId = '') => {},
+    controller: (socket = {}, client = {}, args = '', wsManagementId = '') => {},
+    disconnect: (socket = {}, client = {}, reason = '', wsManagementId = '') => {},
+    stream: false,
+  },
+) => {
+  return {
+    channel: IoInterface.channel,
+    client: {},
+    connection: async function (socket, wsManagementId) {
+      try {
+        this.client[socket.id] = socket;
+        socket.on(IoInterface.channel, (...args) => this.controller(socket, args, wsManagementId));
+        await IoInterface.connection(socket, this.client, wsManagementId);
+      } catch (error) {
+        logger.error(error, { channel: IoInterface.channel, wsManagementId, stack: error.stack });
+      }
+    },
+    controller: async function (socket, args, wsManagementId) {
+      try {
+        const payload = IoInterface.stream ? args[0] : JSON.parse(args[0]);
+        await IoInterface.controller(socket, this.client, payload, wsManagementId, args);
+      } catch (error) {
+        logger.error(error, { channel: IoInterface.channel, wsManagementId, args, stack: error.stack });
+      }
+    },
+    disconnect: async function (socket, reason, wsManagementId) {
+      try {
+        await IoInterface.disconnect(socket, this.client, reason, wsManagementId);
+        delete this.client[socket.id];
+      } catch (error) {
+        logger.error(error, { channel: IoInterface.channel, wsManagementId, reason, stack: error.stack });
+      }
+    },
+  };
+};
+
+export { IoCreateChannel };

package/src/ws/IoServer.js

@@ -1,39 +1,39 @@
-'use strict';
-
-import { Server } from 'socket.io';
-import { loggerFactory } from '../server/logger.js';
-
-// https://socket.io/docs/v3/
-
-const logger = loggerFactory(import.meta);
-
-const IoServer = (httpServer, options = {}, Connection = () => {}) => {
-  const wsOptions = {
-    cors: {
-      // origin: `http://localhost:${options.port}`,
-      origins: options.origins,
-      methods: ['GET', 'POST', 'DELETE', 'PUT'],
-      allowedHeaders: [
-        'Access-Control-Allow-Headers',
-        'Access-Control-Allow-Origin',
-        'X-Requested-With',
-        'X-Access-Token',
-        'Content-Type',
-        'Host',
-        'Accept',
-        'Connection',
-        'Cache-Control',
-        'Authorization',
-      ],
-      credentials: true,
-    },
-    path: options.path !== '/' ? `${options.path}/socket.io/` : '/socket.io',
-  };
-  return {
-    options: wsOptions,
-    meta: import.meta,
-    ioServer: new Server(httpServer, wsOptions).on('connection', Connection),
-  };
-};
-
-export { IoServer };
+'use strict';
+
+import { Server } from 'socket.io';
+import { loggerFactory } from '../server/logger.js';
+
+// https://socket.io/docs/v3/
+
+const logger = loggerFactory(import.meta);
+
+const IoServer = (httpServer, options = {}, Connection = () => {}) => {
+  const wsOptions = {
+    cors: {
+      // origin: `http://localhost:${options.port}`,
+      origins: options.origins,
+      methods: ['GET', 'POST', 'DELETE', 'PUT'],
+      allowedHeaders: [
+        'Access-Control-Allow-Headers',
+        'Access-Control-Allow-Origin',
+        'X-Requested-With',
+        'X-Access-Token',
+        'Content-Type',
+        'Host',
+        'Accept',
+        'Connection',
+        'Cache-Control',
+        'Authorization',
+      ],
+      credentials: true,
+    },
+    path: options.path !== '/' ? `${options.path}/socket.io/` : '/socket.io',
+  };
+  return {
+    options: wsOptions,
+    meta: import.meta,
+    ioServer: new Server(httpServer, wsOptions).on('connection', Connection),
+  };
+};
+
+export { IoServer };

package/src/ws/core/channels/core.ws.chat.js

@@ -1,23 +1,23 @@
-import { loggerFactory } from '../../../server/logger.js';
-import { IoCreateChannel } from '../../IoInterface.js';
-import { CoreWsEmit } from '../core.ws.emit.js';
-
-const channel = 'chat';
-const logger = loggerFactory(import.meta);
-
-const CoreWsChatController = {
-  channel,
-  controller: function (socket, client, payload, wsManagementId) {
-    for (const socketId of Object.keys(client)) {
-      if (socketId !== socket.id) {
-        CoreWsEmit(channel, client[socketId], { id: socket.id, ...payload });
-      }
-    }
-  },
-  connection: function (socket, client, wsManagementId) {},
-  disconnect: function (socket, client, reason, wsManagementId) {},
-};
-
-const CoreWsChatChannel = IoCreateChannel(CoreWsChatController);
-
-export { CoreWsChatChannel, CoreWsChatController };
+import { loggerFactory } from '../../../server/logger.js';
+import { IoCreateChannel } from '../../IoInterface.js';
+import { CoreWsEmit } from '../core.ws.emit.js';
+
+const channel = 'chat';
+const logger = loggerFactory(import.meta);
+
+const CoreWsChatController = {
+  channel,
+  controller: function (socket, client, payload, wsManagementId) {
+    for (const socketId of Object.keys(client)) {
+      if (socketId !== socket.id) {
+        CoreWsEmit(channel, client[socketId], { id: socket.id, ...payload });
+      }
+    }
+  },
+  connection: function (socket, client, wsManagementId) {},
+  disconnect: function (socket, client, reason, wsManagementId) {},
+};
+
+const CoreWsChatChannel = IoCreateChannel(CoreWsChatController);
+
+export { CoreWsChatChannel, CoreWsChatController };

package/src/ws/core/channels/core.ws.mailer.js

@@ -1,35 +1,35 @@
-import { loggerFactory } from '../../../server/logger.js';
-import { IoCreateChannel } from '../../IoInterface.js';
-import { CoreWsMailerManagement } from '../management/core.ws.mailer.js';
-
-const channel = 'mailer';
-const logger = loggerFactory(import.meta);
-
-const CoreWsMailerController = {
-  channel,
-  controller: function (socket, client, payload, wsManagementId) {
-    switch (payload.status) {
-      case 'register-user':
-        CoreWsMailerManagement.element[wsManagementId][socket.id] = {
-          model: {
-            user: payload.user,
-          },
-        };
-        break;
-      case 'unregister-user':
-        delete CoreWsMailerManagement.element[wsManagementId][socket.id];
-        break;
-
-      default:
-        break;
-    }
-  },
-  connection: function (socket, client, wsManagementId) {},
-  disconnect: function (socket, client, reason, wsManagementId) {
-    delete CoreWsMailerManagement.element[wsManagementId][socket.id];
-  },
-};
-
-const CoreWsMailerChannel = IoCreateChannel(CoreWsMailerController);
-
-export { CoreWsMailerChannel, CoreWsMailerController };
+import { loggerFactory } from '../../../server/logger.js';
+import { IoCreateChannel } from '../../IoInterface.js';
+import { CoreWsMailerManagement } from '../management/core.ws.mailer.js';
+
+const channel = 'mailer';
+const logger = loggerFactory(import.meta);
+
+const CoreWsMailerController = {
+  channel,
+  controller: function (socket, client, payload, wsManagementId) {
+    switch (payload.status) {
+      case 'register-user':
+        CoreWsMailerManagement.element[wsManagementId][socket.id] = {
+          model: {
+            user: payload.user,
+          },
+        };
+        break;
+      case 'unregister-user':
+        delete CoreWsMailerManagement.element[wsManagementId][socket.id];
+        break;
+
+      default:
+        break;
+    }
+  },
+  connection: function (socket, client, wsManagementId) {},
+  disconnect: function (socket, client, reason, wsManagementId) {
+    delete CoreWsMailerManagement.element[wsManagementId][socket.id];
+  },
+};
+
+const CoreWsMailerChannel = IoCreateChannel(CoreWsMailerController);
+
+export { CoreWsMailerChannel, CoreWsMailerController };

package/src/ws/core/channels/core.ws.stream.js

@@ -1,31 +1,31 @@
-import { loggerFactory } from '../../../server/logger.js';
-import { IoCreateChannel } from '../../IoInterface.js';
-import { CoreWsStreamManagement } from '../management/core.ws.stream.js';
-
-const channel = 'stream';
-const logger = loggerFactory(import.meta);
-
-const CoreWsStreamController = {
-  channel,
-  stream: true,
-  controller: function (socket, client, payload, wsManagementId, args) {
-    const [roomId, userId] = args;
-    CoreWsStreamManagement.element[wsManagementId][socket.id] = args;
-
-    socket.join(roomId); // Join the room
-    socket.broadcast.emit(`${channel}-user-connected`, userId); // Tell everyone else in the room that we joined
-  },
-  connection: function (socket, client, wsManagementId) {
-    CoreWsStreamManagement.element[wsManagementId][socket.id] = [];
-  },
-  disconnect: function (socket, client, reason, wsManagementId) {
-    // Communicate the disconnection
-    const [roomId, userId] = CoreWsStreamManagement.element[wsManagementId][socket.id];
-    socket.broadcast.emit(`${channel}-user-disconnected`, userId);
-    delete CoreWsStreamManagement.element[wsManagementId][socket.id];
-  },
-};
-
-const CoreWsStreamChannel = IoCreateChannel(CoreWsStreamController);
-
-export { CoreWsStreamChannel, CoreWsStreamController };
+import { loggerFactory } from '../../../server/logger.js';
+import { IoCreateChannel } from '../../IoInterface.js';
+import { CoreWsStreamManagement } from '../management/core.ws.stream.js';
+
+const channel = 'stream';
+const logger = loggerFactory(import.meta);
+
+const CoreWsStreamController = {
+  channel,
+  stream: true,
+  controller: function (socket, client, payload, wsManagementId, args) {
+    const [roomId, userId] = args;
+    CoreWsStreamManagement.element[wsManagementId][socket.id] = args;
+
+    socket.join(roomId); // Join the room
+    socket.broadcast.emit(`${channel}-user-connected`, userId); // Tell everyone else in the room that we joined
+  },
+  connection: function (socket, client, wsManagementId) {
+    CoreWsStreamManagement.element[wsManagementId][socket.id] = [];
+  },
+  disconnect: function (socket, client, reason, wsManagementId) {
+    // Communicate the disconnection
+    const [roomId, userId] = CoreWsStreamManagement.element[wsManagementId][socket.id];
+    socket.broadcast.emit(`${channel}-user-disconnected`, userId);
+    delete CoreWsStreamManagement.element[wsManagementId][socket.id];
+  },
+};
+
+const CoreWsStreamChannel = IoCreateChannel(CoreWsStreamController);
+
+export { CoreWsStreamChannel, CoreWsStreamController };