underpost 2.85.1 → 2.89.0

package/src/proxy.js

@@ -11,7 +11,7 @@ import { Config } from './server/conf.js';
 
 dotenv.config();
 
-await Config.build();
+await Config.build(process.argv[2], process.argv[3], process.argv[4]);
 
 const logger = loggerFactory(import.meta);
 

package/src/runtime/express/Express.js

@@ -23,6 +23,7 @@ import { applySecurity, authMiddlewareFactory } from '../../server/auth.js';
 import { ssrMiddlewareFactory } from '../../server/ssr.js';
 import { TLS } from '../../server/tls.js';
 import { shellExec } from '../../server/process.js';
+import { devProxyHostFactory, isDevProxyContext, isTlsDevProxy } from '../../server/conf.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -94,7 +95,9 @@ class ExpressService {
 
     const app = express();
 
-    if (process.env.NODE_ENV === 'production') app.set('trust proxy', true);
+    if (origins && isDevProxyContext())
+      origins.push(devProxyHostFactory({ host, includeHttp: true, tls: isTlsDevProxy() }));
+    app.set('trust proxy', true);
 
     app.use((req, res, next) => {
       res.on('finish', () => {

package/src/server/auth.js

@@ -17,6 +17,7 @@ import slowDown from 'express-slow-down';
 import cors from 'cors';
 import cookieParser from 'cookie-parser';
 import { DataBaseProvider } from '../db/DataBaseProvider.js';
+import { isDevProxyContext } from './conf.js';
 
 dotenv.config();
 const logger = loggerFactory(import.meta);
@@ -348,7 +349,7 @@ const cookieOptionsFactory = (req, host) => {
     secure,
     sameSite,
     path: '/',
-    domain: process.env.NODE_ENV === 'production' ? host : 'localhost',
+    domain: process.env.NODE_ENV === 'production' || isDevProxyContext() ? host : 'localhost',
     maxAge,
   };
 

package/src/server/client-build.js

@@ -32,6 +32,51 @@ dotenv.config();
 
 // Static Site Generation (SSG)
 
+/**
+ * Recursively copies files from source to destination, but only files that don't exist in destination.
+ * @function copyNonExistingFiles
+ * @param {string} src - Source directory path
+ * @param {string} dest - Destination directory path
+ * @returns {void}
+ * @memberof clientBuild
+ */
+const copyNonExistingFiles = (src, dest) => {
+  // Ensure source exists
+  if (!fs.existsSync(src)) {
+    throw new Error(`Source directory does not exist: ${src}`);
+  }
+
+  // Get stats for source
+  const srcStats = fs.statSync(src);
+
+  // If source is a file, copy only if it doesn't exist in destination
+  if (srcStats.isFile()) {
+    if (!fs.existsSync(dest)) {
+      const destDir = dir.dirname(dest);
+      fs.mkdirSync(destDir, { recursive: true });
+      fs.copyFileSync(src, dest);
+    }
+    return;
+  }
+
+  // If source is a directory, create destination if it doesn't exist
+  if (srcStats.isDirectory()) {
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+
+    // Read all items in source directory
+    const items = fs.readdirSync(src);
+
+    // Recursively process each item
+    for (const item of items) {
+      const srcPath = dir.join(src, item);
+      const destPath = dir.join(dest, item);
+      copyNonExistingFiles(srcPath, destPath);
+    }
+  }
+};
+
 /**
  * @async
  * @function buildClient
@@ -83,6 +128,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
    * @param {string} options.publicClientId - Public client ID.
    * @param {boolean} options.iconsBuild - Whether to build icons.
    * @param {Object} options.metadata - Metadata for the client.
+   * @param {boolean} options.publicCopyNonExistingFiles - Whether to copy non-existing files from public directory.
    * @returns {Promise<void>} - Promise that resolves when the full build is complete.
    * @throws {Error} - If the full build fails.
    * @memberof clientBuild
@@ -98,6 +144,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
     publicClientId,
     iconsBuild,
     metadata,
+    publicCopyNonExistingFiles,
   }) => {
     logger.warn('Full build', rootClientPath);
 
@@ -169,11 +216,15 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
           fs.copySync(dist.styles, `${rootClientPath}${dist.public_styles_folder}`);
         }
       }
+
+    if (publicCopyNonExistingFiles)
+      copyNonExistingFiles(`./src/client/public/${publicCopyNonExistingFiles}`, rootClientPath);
   };
 
   // { srcBuildPath, publicBuildPath }
   const enableLiveRebuild =
     options && options.liveClientBuildPaths && options.liveClientBuildPaths.length > 0 ? true : false;
+  const isDevelopment = process.env.NODE_ENV === 'development';
 
   let currentPort = parseInt(process.env.PORT) + 1;
   for (const host of Object.keys(confServer)) {
@@ -205,7 +256,8 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
       } = confServer[host][path];
       if (singleReplica) continue;
       if (!confClient[client]) confClient[client] = {};
-      const { components, dists, views, services, metadata, publicRef } = confClient[client];
+      const { components, dists, views, services, metadata, publicRef, publicCopyNonExistingFiles } =
+        confClient[client];
       let backgroundImage;
       if (metadata) {
         backgroundImage = metadata.backgroundImage;
@@ -240,6 +292,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
           publicClientId,
           iconsBuild,
           metadata,
+          publicCopyNonExistingFiles,
         });
 
       if (components)
@@ -520,6 +573,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
                 apiBaseHost,
                 apiBasePath: process.env.BASE_API,
                 version: Underpost.version,
+                dev: isDevelopment,
               },
               renderApi: {
                 JSONweb,
@@ -613,6 +667,7 @@ Sitemap: https://${host}${path === '/' ? '' : path}/sitemap.xml`,
                   apiBaseHost,
                   apiBasePath: process.env.BASE_API,
                   version: Underpost.version,
+                  dev: isDevelopment,
                 },
                 renderApi: {
                   JSONweb,
@@ -687,4 +742,4 @@ ${fs.readFileSync(`${rootClientPath}/sw.js`, 'utf8')}`,
   }
 };
 
-export { buildClient };
+export { buildClient, copyNonExistingFiles };

package/src/server/conf.js

@@ -66,11 +66,11 @@ const Config = {
   /**
    * @method deployIdFactory
    * @description Creates a new deploy ID.
-   * @param {string} [deployId='dd-default'] - The deploy ID.
-   * @param {object} [options={ cluster: false }] - The options.
+   * @param {string} [deployId='dd-default
+   * @param {object} [options={ subConf: '', cluster: false }] - The options.
    * @memberof ServerConfBuilder
    */
-  deployIdFactory: function (deployId = 'dd-default', options = { cluster: false }) {
+  deployIdFactory: function (deployId = 'dd-default', options = { subConf: '', cluster: false }) {
     if (!deployId.startsWith('dd-')) deployId = `dd-${deployId}`;
 
     logger.info('Build deployId', deployId);
@@ -102,6 +102,17 @@ const Config = {
 
     this.buildTmpConf(folder);
 
+    if (options.subConf) {
+      logger.info('Creating sub conf', {
+        deployId: deployId,
+        subConf: options.subConf,
+      });
+      fs.copySync(
+        `./engine-private/conf/${deployId}/conf.server.json`,
+        `./engine-private/conf/${deployId}/conf.server.dev.${options.subConf}.json`,
+      );
+    }
+
     if (options.cluster === true) {
       fs.writeFileSync(
         `./.github/workflows/${repoName}.cd.yml`,
@@ -640,6 +651,8 @@ const buildProxyRouter = () => {
     for (const path of Object.keys(confServer[host])) {
       if (confServer[host][path].singleReplica) continue;
 
+      if (isDevProxyContext()) confServer[host][path].proxy = [isTlsDevProxy() ? 443 : 80];
+
       confServer[host][path].port = newInstance(currentPort);
       for (const port of confServer[host][path].proxy) {
         if (!(port in proxyRouter)) proxyRouter[port] = {};
@@ -784,14 +797,21 @@ const buildKindPorts = (from, to) =>
 /**
  * @method buildPortProxyRouter
  * @description Builds the port proxy router.
- * @param {number} port - The port.
- * @param {object} proxyRouter - The proxy router.
- * @param {object} [options={ orderByPathLength: false }] - The options.
+ * @param {object} options - The options.
+ * @param {number} [options.port=4000] - The port.
+ * @param {object} options.proxyRouter - The proxy router.
+ * @param {object} [options.hosts] - The hosts.
+ * @param {boolean} [options.orderByPathLength=false] - Whether to order by path length.
+ * @param {boolean} [options.devProxyContext=false] - Whether to use dev proxy context.
  * @returns {object} - The port proxy router.
  * @memberof ServerConfBuilder
  */
-const buildPortProxyRouter = (port, proxyRouter, options = { orderByPathLength: false }) => {
-  const hosts = proxyRouter[port];
+const buildPortProxyRouter = (
+  options = { port: 4000, proxyRouter, hosts, orderByPathLength: false, devProxyContext: false },
+) => {
+  let { port, proxyRouter, hosts, orderByPathLength } = options;
+  hosts = hosts || proxyRouter[port] || {};
+
   const router = {};
   // build router
   Object.keys(hosts).map((hostKey) => {
@@ -804,7 +824,7 @@ const buildPortProxyRouter = (port, proxyRouter, options = { orderByPathLength:
         return;
       }
     }
-
+    // ${process.env.NODE_ENV === 'development' && !isDevProxyContext() ? `:${port}` : ''}
     const absoluteHost = [80, 443].includes(port)
       ? `${host}${path === '/' ? '' : path}`
       : `${host}:${port}${path === '/' ? '' : path}`;
@@ -812,12 +832,48 @@ const buildPortProxyRouter = (port, proxyRouter, options = { orderByPathLength:
     if (absoluteHost in router)
       logger.warn('Overwrite: Absolute host already exists on router', { absoluteHost, target });
 
-    router[absoluteHost] = target;
+    if (options.devProxyContext === true) {
+      const appDevPort = parseInt(target.split(':')[2]) - process.env.DEV_PROXY_PORT_OFFSET;
+      router[absoluteHost] = `http://localhost:${appDevPort}`;
+    } else router[absoluteHost] = target;
   }); // order router
 
   if (Object.keys(router).length === 0) return router;
 
-  if (options.orderByPathLength === true) {
+  if (options.devProxyContext === true && process.env.NODE_ENV === 'development') {
+    const confDevApiServer = JSON.parse(
+      fs.readFileSync(`./engine-private/conf/${process.argv[3]}/conf.server.dev.${process.argv[4]}-dev-api.json`),
+      'utf8',
+    );
+    let devApiHosts = [];
+    let origins = [];
+    for (const _host of Object.keys(confDevApiServer))
+      for (const _path of Object.keys(confDevApiServer[_host])) {
+        if (confDevApiServer[_host][_path].origins && confDevApiServer[_host][_path].origins.length) {
+          origins.push(...confDevApiServer[_host][_path].origins);
+          if (_path !== 'peer' && devApiHosts.length === 0)
+            devApiHosts.push(
+              `${_host}${[80, 443].includes(port) && isDevProxyContext() ? '' : `:${port}`}${_path == '/' ? '' : _path}`,
+            );
+        }
+      }
+    origins = Array.from(new Set(origins));
+    console.log({
+      origins,
+      devApiHosts,
+    });
+    for (const devApiHost of devApiHosts) {
+      if (devApiHost in router) {
+        const target = router[devApiHost];
+        delete router[devApiHost];
+        router[`${devApiHost}/${process.env.BASE_API}`] = target;
+        router[`${devApiHost}/socket.io`] = target;
+        for (const origin of origins) router[devApiHost] = origin;
+      }
+    }
+  }
+
+  if (orderByPathLength === true) {
     const reOrderRouter = {};
     for (const absoluteHostKey of orderArrayFromAttrInt(Object.keys(router), 'length'))
       reOrderRouter[absoluteHostKey] = router[absoluteHostKey];
@@ -1409,11 +1465,14 @@ const buildApiConf = async (options = { deployId: '', subConf: '', host: '', pat
  * @param {string} options.apiBaseHost - The API base host.
  * @param {string} options.host - The host.
  * @param {string} options.path - The path.
+ * @param {boolean} options.devProxy - The dev proxy flag.
  * @returns {void}
  * @memberof ServerConfBuilder
  */
-const buildClientStaticConf = async (options = { deployId: '', subConf: '', apiBaseHost: '', host: '', path: '' }) => {
-  let { deployId, subConf, host, path } = options;
+const buildClientStaticConf = async (
+  options = { deployId: '', subConf: '', apiBaseHost: '', host: '', path: '', devProxy: false },
+) => {
+  let { deployId, subConf, host, path, devProxy } = options;
   if (!deployId) deployId = process.argv[2].trim();
   if (!subConf) subConf = process.argv[3].trim();
   if (!host) host = process.argv[4].trim();
@@ -1425,10 +1484,14 @@ const buildClientStaticConf = async (options = { deployId: '', subConf: '', apiB
     fs.readFileSync(`./engine-private/conf/${deployId}/.env.${process.env.NODE_ENV}.${subConf}-dev-api`, 'utf8'),
   );
   envObj.PORT = parseInt(envObj.PORT);
-  const apiBaseHost = options?.apiBaseHost ? options.apiBaseHost : `localhost:${envObj.PORT + 1}`;
+  const apiBaseHost = devProxy
+    ? devProxyHostFactory({ host, tls: isTlsDevProxy() })
+    : options?.apiBaseHost
+      ? options.apiBaseHost
+      : `localhost:${envObj.PORT + 1}`;
   confServer[host][path].apiBaseHost = apiBaseHost;
   confServer[host][path].apiBaseProxyPath = path;
-  logger.info('Build client static conf', { host, path, apiBaseHost });
+  logger.warn('Build client static conf', { host, path, apiBaseHost });
   envObj.PORT = parseInt(confServer[host][path].origins[0].split(':')[2]) - 1;
   writeEnv(`./engine-private/conf/${deployId}/.env.${process.env.NODE_ENV}.${subConf}-dev-client`, envObj);
   fs.writeFileSync(
@@ -1448,6 +1511,56 @@ const buildClientStaticConf = async (options = { deployId: '', subConf: '', apiB
  */
 const isDeployRunnerContext = (path, options) => !options.build && path && path !== 'template-deploy';
 
+/**
+ * @method isDevProxyContext
+ * @description Checks if the dev proxy context is valid.
+ * @returns {boolean} - The dev proxy context.
+ * @memberof ServerConfBuilder
+ */
+const isDevProxyContext = () => {
+  try {
+    if (process.argv[2] === 'proxy') return true;
+    if (!process.argv[6].startsWith('localhost')) return false;
+    return new URL('http://' + process.argv[6]).hostname ? true : false;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * @method devProxyHostFactory
+ * @description Creates the dev proxy host.
+ * @param {object} options - The options.
+ * @param {string} [options.host='default.net'] - The host.
+ * @param {boolean} [options.includeHttp=false] - Whether to include HTTP.
+ * @param {number} [options.port=443] - The port.
+ * @param {boolean} [options.tls=false] - Whether to use TLS.
+ * @returns {string} - The dev proxy host.
+ * @memberof ServerConfBuilder
+ */
+const devProxyHostFactory = (options = { host: 'default.net', includeHttp: false, port: 80, tls: false }) =>
+  `${options.includeHttp ? (options.tls ? 'https://' : 'http://') : ''}${options.host ? options.host : 'localhost'}:${
+    (options.port ? options.port : options.tls ? 443 : 80) + parseInt(process.env.DEV_PROXY_PORT_OFFSET)
+  }`;
+
+/**
+ * @method isTlsDevProxy
+ * @description Checks if TLS is used in the dev proxy.
+ * @returns {boolean} - The TLS dev proxy status.
+ * @memberof ServerConfBuilder
+ */
+const isTlsDevProxy = () => process.env.NODE_ENV !== 'production' && process.argv[7] === 'tls';
+
+/**
+ * @method getTlsHosts
+ * @description Gets the TLS hosts.
+ * @param {object} confServer - The server configuration.
+ * @returns {Array} - The TLS hosts.
+ * @memberof ServerConfBuilder
+ */
+const getTlsHosts = (confServer) =>
+  Array.from(new Set(Object.keys(confServer).map((h) => new URL('https://' + h).hostname)));
+
 export {
   Cmd,
   Config,
@@ -1484,4 +1597,8 @@ export {
   buildApiConf,
   buildClientStaticConf,
   isDeployRunnerContext,
+  isDevProxyContext,
+  devProxyHostFactory,
+  isTlsDevProxy,
+  getTlsHosts,
 };

package/src/server/object-layer.js

@@ -192,6 +192,49 @@ export class ObjectLayerEngine {
     return objectLayerFrameDirections;
   }
 
+  /**
+   * @memberof CyberiaObjectLayer
+   * @static
+   * @description Processes an image file through frameFactory and adds the resulting frame to the render data structure.
+   * Updates the color palette and pushes the frame to all keyframe directions corresponding to the given direction code.
+   * Initializes colors array, frames object, and direction arrays if they don't exist.
+   * @param {Object} renderData - The render data object containing frames and colors.
+   * @param {string} imagePath - The path to the image file to process.
+   * @param {string} directionCode - The numerical direction code (e.g., '08', '14').
+   * @returns {Promise<Object>} - The updated render data object.
+   * @memberof CyberiaObjectLayer
+   */
+  static async processAndPushFrame(renderData, imagePath, directionCode) {
+    // Initialize colors array if it doesn't exist
+    if (!renderData.colors) {
+      renderData.colors = [];
+    }
+
+    // Initialize frames object if it doesn't exist
+    if (!renderData.frames) {
+      renderData.frames = {};
+    }
+
+    // Process the image and extract frame matrix and updated colors
+    const frameFactoryResult = await ObjectLayerEngine.frameFactory(imagePath, renderData.colors);
+
+    // Update the colors palette
+    renderData.colors = frameFactoryResult.colors;
+
+    // Get all keyframe directions for this direction code
+    const keyframeDirections = ObjectLayerEngine.getKeyFramesDirectionsFromNumberFolderDirection(directionCode);
+
+    // Push the frame to all corresponding directions
+    for (const keyframeDirection of keyframeDirections) {
+      if (!renderData.frames[keyframeDirection]) {
+        renderData.frames[keyframeDirection] = [];
+      }
+      renderData.frames[keyframeDirection].push(frameFactoryResult.frame);
+    }
+
+    return renderData;
+  }
+
   /**
    * @memberof CyberiaObjectLayer
    * @static
@@ -290,5 +333,6 @@ export const readPngAsync = ObjectLayerEngine.readPngAsync;
 export const frameFactory = ObjectLayerEngine.frameFactory;
 export const getKeyFramesDirectionsFromNumberFolderDirection =
   ObjectLayerEngine.getKeyFramesDirectionsFromNumberFolderDirection;
+export const processAndPushFrame = ObjectLayerEngine.processAndPushFrame;
 export const buildImgFromTile = ObjectLayerEngine.buildImgFromTile;
 export const generateRandomStats = ObjectLayerEngine.generateRandomStats;

package/src/server/proxy.js

@@ -11,9 +11,12 @@ import dotenv from 'dotenv';
 
 import { createProxyMiddleware } from 'http-proxy-middleware';
 import { loggerFactory, loggerMiddleware } from './logger.js';
-import { TLS } from './tls.js';
-import { buildPortProxyRouter, buildProxyRouter } from './conf.js';
+import { buildPortProxyRouter, buildProxyRouter, getTlsHosts, isDevProxyContext, isTlsDevProxy } from './conf.js';
 import UnderpostStartUp from './start.js';
+import UnderpostDeploy from '../cli/deploy.js';
+import { SSL_BASE, TLS } from './tls.js';
+import { shellExec } from './process.js';
+import fs from 'fs-extra';
 
 dotenv.config();
 
@@ -22,28 +25,27 @@ const logger = loggerFactory(import.meta);
 /**
  * Main class for building and running the proxy server.
  * All utility methods are implemented as static to serve as a namespace container.
- * @class Proxy
- * @augments Proxy
+ * @class ProxyService
  * @memberof ProxyService
  */
-class Proxy {
+class ProxyService {
   /**
-   * Initializes and starts the reverse proxy server for all configured ports and hosts.
-   * @async
+   * Builds and starts the proxy server with appropriate routing and SSL configuration.
    * @static
-   * @memberof ProxyService
-   * @returns {Promise<void>}
-   * @memberof ProxyService
+   * @returns {Promise<void>} Resolves when the server is successfully started.
    */
-  static async buildProxy() {
+  static async build() {
+    if (process.env.NODE_ENV === 'production') process.env.DEV_PROXY_PORT_OFFSET = 0;
+
     // Start a default Express listener on process.env.PORT (potentially unused, but ensures Express is initialized)
+    process.env.PORT = parseInt(process.env.PORT) + parseInt(process.env.DEV_PROXY_PORT_OFFSET);
     express().listen(process.env.PORT);
 
     const proxyRouter = buildProxyRouter();
 
     for (let port of Object.keys(proxyRouter)) {
-      port = parseInt(port);
       const hosts = proxyRouter[port];
+      port = parseInt(port) + parseInt(process.env.DEV_PROXY_PORT_OFFSET);
       const proxyPath = '/';
       const proxyHost = 'localhost';
       const runningData = { host: proxyHost, path: proxyPath, client: null, runtime: 'nodejs', meta: import.meta };
@@ -56,19 +58,22 @@ class Proxy {
       /** @type {import('http-proxy-middleware/dist/types').Options} */
       const options = {
         ws: true, // Enable websocket proxying
-        target: `http://localhost:${process.env.PORT}`, // Default target (should be overridden by router)
+        target: `http://localhost:${parseInt(process.env.PORT - 1)}`, // Default target (should be overridden by router)
         router: {},
+        // changeOrigin: true,
+        logLevel: 'debug',
         xfwd: true, // Adds x-forward headers (Host, Proto, etc.)
-        onProxyReq: (proxyReq, req, res, options) => {
-          // Use the static method from the TLS class for redirection logic
-          TLS.sslRedirectMiddleware(req, res, port, proxyRouter);
-        },
-        pathRewrite: {
-          // Add path rewrite rules here if necessary
-        },
+        onProxyReq: (proxyReq, req, res, options) => {},
+        pathRewrite: {},
       };
 
-      options.router = buildPortProxyRouter(port, proxyRouter, { orderByPathLength: true });
+      options.router = buildPortProxyRouter({
+        port,
+        proxyRouter,
+        hosts,
+        orderByPathLength: true,
+        devProxyContext: process.env.NODE_ENV !== 'production',
+      });
 
       const filter = proxyPath; // Use '/' as the general filter
       app.use(proxyPath, createProxyMiddleware(filter, options));
@@ -91,11 +96,33 @@ class Proxy {
           break;
 
         default:
-          // In non-production, always use standard HTTP listener
-          await UnderpostStartUp.API.listenPortController(app, port, runningData);
-          break;
+          switch (port) {
+            case 443: {
+              let tlsHosts = hosts;
+              if (isDevProxyContext() && isTlsDevProxy()) {
+                tlsHosts = {};
+                for (const tlsHost of getTlsHosts(hosts)) {
+                  if (fs.existsSync(SSL_BASE(tlsHost))) fs.removeSync(SSL_BASE(tlsHost));
+                  if (!TLS.validateSecureContext(tlsHost)) shellExec(`node bin/deploy tls "${tlsHost}"`);
+                  tlsHosts[tlsHost] = {};
+                }
+              }
+              const { ServerSSL } = await TLS.createSslServer(app, tlsHosts);
+              await UnderpostStartUp.API.listenPortController(ServerSSL, port, runningData);
+              break;
+            }
+            default: // In non-production, always use standard HTTP listener
+              await UnderpostStartUp.API.listenPortController(app, port, runningData);
+              break;
+          }
       }
       logger.info('Proxy running', { port, options });
+      if (process.env.NODE_ENV === 'development')
+        logger.info(
+          UnderpostDeploy.API.etcHostFactory(Object.keys(options.router), {
+            append: true,
+          }).renderHosts,
+        );
     }
   }
 }
@@ -105,6 +132,6 @@ class Proxy {
  * @type {function(): Promise<void>}
  * @memberof ProxyService
  */
-const buildProxy = Proxy.buildProxy;
+const buildProxy = ProxyService.build;
 
-export { Proxy, buildProxy };
+export { ProxyService, buildProxy };

package/src/server/start.js

@@ -53,7 +53,7 @@ class UnderpostStartUp {
               throw new Error(message);
             }
           }, msDelta);
-          return logic ? await logic(...args) : undefined, args[1]();
+          return (logic ? await logic(...args) : undefined, args[1]());
         },
       };
     },
@@ -95,8 +95,8 @@ class UnderpostStartUp {
                 port === 80
                   ? `http://${host}${path}`
                   : port === 443
-                  ? `https://${host}${path}`
-                  : `http://${host}:${port}${path}`,
+                    ? `https://${host}${path}`
+                    : `http://${host}:${port}${path}`,
               local: `http://localhost:${port}${path}`,
               apis: metadata.apis,
             };
@@ -122,6 +122,12 @@ class UnderpostStartUp {
       if (options.build === true) await UnderpostStartUp.API.build(deployId, env);
       if (options.run === true) await UnderpostStartUp.API.run(deployId, env);
     },
+    /**
+     * Run itc-scripts and builds client bundle.
+     * @param {string} deployId - The ID of the deployment.
+     * @param {string} env - The environment of the deployment.
+     * @memberof UnderpostStartUp
+     */
     async build(deployId = 'dd-default', env = 'development') {
       const buildBasePath = `/home/dd`;
       const repoName = `engine-${deployId.split('-')[1]}`;
@@ -139,6 +145,12 @@ class UnderpostStartUp {
       }
       shellExec(`node bin/deploy build-full-client ${deployId}`);
     },
+    /**
+     * Runs a deployment.
+     * @param {string} deployId - The ID of the deployment.
+     * @param {string} env - The environment of the deployment.
+     * @memberof UnderpostStartUp
+     */
     async run(deployId = 'dd-default', env = 'development') {
       const runCmd = env === 'production' ? 'run prod-img' : 'run dev-img';
       if (fs.existsSync(`./engine-private/replica`)) {
@@ -158,4 +170,14 @@ class UnderpostStartUp {
   };
 }
 
+/**
+ * Creates a keep-alive process to maintain server activity.
+ * @memberof UnderpostStartUp
+ * @returns
+ */
+const createKeepAliveProcess = async () =>
+  await UnderpostStartUp.API.listenPortController(UnderpostStartUp.API.listenServerFactory(), ':');
+
 export default UnderpostStartUp;
+
+export { createKeepAliveProcess, UnderpostStartUp };

package/src/server/tls.js

@@ -248,4 +248,4 @@ const validateSecureContext = TLS.validateSecureContext;
 const createSslServer = TLS.createSslServer;
 const sslRedirectMiddleware = TLS.sslRedirectMiddleware;
 
-export { TLS, buildSSL, buildSecureContext, validateSecureContext, createSslServer, sslRedirectMiddleware };
+export { TLS, SSL_BASE, buildSSL, buildSecureContext, validateSecureContext, createSslServer, sslRedirectMiddleware };

package/src/ws/IoInterface.js

@@ -21,11 +21,10 @@ const logger = loggerFactory(import.meta);
  */
 
 /**
+ * Manages the logic, client map, and event listeners for a specific WebSocket channel,
+ * ensuring robust message handling and lifecycle management.
  * @class IoChannel
- * @alias IoChannel
  * @memberof SocketIoInterface
- * @classdesc Manages the logic, client map, and event listeners for a specific WebSocket channel,
- * ensuring robust message handling and lifecycle management.
  */
 class IoChannel {
   /**