underpost 2.8.878 → 2.8.882

package/src/server/object-layer.js

@@ -0,0 +1,196 @@
+import dotenv from 'dotenv';
+
+import fs from 'fs-extra';
+import { PNG } from 'pngjs';
+import sharp from 'sharp';
+import Jimp from 'jimp';
+
+import { range } from '../client/components/core/CommonJs.js';
+import { random } from '../client/components/core/CommonJs.js';
+
+dotenv.config({ path: `./engine-private/conf/dd-cyberia/.env.production`, override: true });
+
+const pngDirectoryIteratorByObjectLayerType = async (
+  objectLayerType = 'skin',
+  callback = ({ path, objectLayerType, objectLayerId, direction, frame }) => {},
+) => {
+  for (const objectLayerId of await fs.readdir(`./src/client/public/cyberia/assets/${objectLayerType}`)) {
+    for (const direction of await fs.readdir(
+      `./src/client/public/cyberia/assets/${objectLayerType}/${objectLayerId}`,
+    )) {
+      const dirFolder = `./src/client/public/cyberia/assets/${objectLayerType}/${objectLayerId}/${direction}`;
+      if (!fs.statSync(dirFolder).isDirectory()) continue;
+      for (const frame of await fs.readdir(dirFolder)) {
+        const imageFilePath = `./src/client/public/cyberia/assets/${objectLayerType}/${objectLayerId}/${direction}/${frame}`;
+        await callback({ path: imageFilePath, objectLayerType, objectLayerId, direction, frame });
+      }
+    }
+  }
+};
+
+const readPngAsync = (filePath) => {
+  return new Promise((resolve, reject) => {
+    fs.createReadStream(filePath)
+      .pipe(new PNG())
+      .on('parsed', function () {
+        resolve({
+          width: this.width,
+          height: this.height,
+          data: Buffer.from(this.data),
+        });
+      })
+      .on('error', (err) => {
+        reject(err);
+      });
+  });
+};
+
+const frameFactory = async (path, colors = []) => {
+  const frame = [];
+  try {
+    let image;
+
+    if (path.endsWith('.gif')) {
+      image = await Jimp.read(path);
+      // remove gif file
+      fs.removeSync(path);
+      // save image replacing gif for png
+      const pngPath = path.replace('.gif', '.png');
+      await image.writeAsync(pngPath);
+    } else {
+      const png = await readPngAsync(path);
+      image = new Jimp(png.width, png.height);
+      image.bitmap = png;
+    }
+
+    const mazeFactor = parseInt(image.bitmap.height / 24);
+    let _y = -1;
+    for (const y of range(0, image.bitmap.height - 1)) {
+      if (y % mazeFactor === 0) {
+        _y++;
+        if (!frame[_y]) frame[_y] = [];
+      }
+      let _x = -1;
+      for (const x of range(0, image.bitmap.width - 1)) {
+        const rgba = Object.values(Jimp.intToRGBA(image.getPixelColor(x, y)));
+        if (y % mazeFactor === 0 && x % mazeFactor === 0) {
+          _x++;
+          const indexColor = colors.findIndex(
+            (c) => c[0] === rgba[0] && c[1] === rgba[1] && c[2] === rgba[2] && c[3] === rgba[3],
+          );
+          if (indexColor === -1) {
+            colors.push(rgba);
+            frame[_y][_x] = colors.length - 1;
+          } else {
+            frame[_y][_x] = indexColor;
+          }
+        }
+      }
+    }
+  } catch (error) {
+    logger.error(`Failed to process image ${path}:`, error);
+  }
+  return { frame, colors };
+};
+
+const getKeyFramesDirectionsFromNumberFolderDirection = (direction) => {
+  let objectLayerFrameDirections = [];
+
+  switch (direction) {
+    case '08':
+      objectLayerFrameDirections = ['down_idle', 'none_idle', 'default_idle'];
+      break;
+    case '18':
+      objectLayerFrameDirections = ['down_walking'];
+      break;
+    case '02':
+      objectLayerFrameDirections = ['up_idle'];
+      break;
+    case '12':
+      objectLayerFrameDirections = ['up_walking'];
+      break;
+    case '04':
+      objectLayerFrameDirections = ['left_idle', 'up_left_idle', 'down_left_idle'];
+      break;
+    case '14':
+      objectLayerFrameDirections = ['left_walking', 'up_left_walking', 'down_left_walking'];
+      break;
+    case '06':
+      objectLayerFrameDirections = ['right_idle', 'up_right_idle', 'down_right_idle'];
+      break;
+    case '16':
+      objectLayerFrameDirections = ['right_walking', 'up_right_walking', 'down_right_walking'];
+      break;
+  }
+
+  return objectLayerFrameDirections;
+};
+
+const buildImgFromTile = async (
+  options = {
+    tile: { map_color: null, frame_matrix: null },
+    imagePath: '',
+    cellPixelDim: 20,
+    opacityFilter: (x, y, color) => 255,
+  },
+) => {
+  const { tile, imagePath, cellPixelDim, opacityFilter } = options;
+  const mainMatrix = tile.frame_matrix;
+  const sharpOptions = {
+    create: {
+      width: cellPixelDim * mainMatrix[0].length,
+      height: cellPixelDim * mainMatrix.length,
+      channels: 4,
+      background: { r: 0, g: 0, b: 0, alpha: 0 }, // transparent background
+    },
+  };
+
+  let image = await sharp(sharpOptions).png().toBuffer();
+  fs.writeFileSync(imagePath, image);
+  image = await Jimp.read(imagePath);
+
+  for (let y = 0; y < mainMatrix.length; y++) {
+    for (let x = 0; x < mainMatrix[y].length; x++) {
+      const colorIndex = mainMatrix[y][x];
+      if (colorIndex === null || colorIndex === undefined) continue;
+
+      const color = tile.map_color[colorIndex];
+      if (!color) continue;
+
+      const rgbaColor = color.length === 4 ? color : [...color, 255]; // Ensure alpha channel
+
+      for (let dy = 0; dy < cellPixelDim; dy++) {
+        for (let dx = 0; dx < cellPixelDim; dx++) {
+          const pixelX = x * cellPixelDim + dx;
+          const pixelY = y * cellPixelDim + dy;
+          image.setPixelColor(Jimp.rgbaToInt(...rgbaColor), pixelX, pixelY);
+        }
+      }
+    }
+  }
+
+  await image.writeAsync(imagePath);
+};
+
+const generateRandomStats = () => {
+  return {
+    effect: random(0, 10),
+    resistance: random(0, 10),
+    agility: random(0, 10),
+    range: random(0, 10),
+    intelligence: random(0, 10),
+    utility: random(0, 10),
+  };
+};
+
+const zIndexPriority = { floor: 0, skin: 1, weapon: 2, skill: 3, coin: 4 };
+
+export {
+  pngDirectoryIteratorByObjectLayerType,
+  readPngAsync,
+  frameFactory,
+  getKeyFramesDirectionsFromNumberFolderDirection,
+  buildImgFromTile,
+  generateRandomStats,
+  zIndexPriority,
+};

package/src/server/peer.js

@@ -1,30 +1,72 @@
+/**
+ * Module for peerjs server management.
+ * Initializes and configures the PeerJS server instance, typically running
+ * alongside a main Node.js application.
+ *
+ * @module src/server/peer.js
+ * @namespace Peer
+ */
+
 import { PeerServer } from 'peer';
 import dotenv from 'dotenv';
 import { loggerFactory } from './logger.js';
-import fs from 'fs-extra';
 import UnderpostStartUp from './start.js';
 
 dotenv.config();
 
+/**
+ * Logger instance for this module, utilizing the framework's factory.
+ * @type {function(*): void}
+ * @memberof Peer
+ * @private
+ */
 const logger = loggerFactory(import.meta);
 
+// Documentation references:
 // https://github.com/peers/peerjs
 // https://github.com/peers/peerjs-server
 
+/**
+ * Creates and starts a configured PeerJS server instance.
+ *
+ * This function handles port configuration, CORS origins, and paths, then uses
+ * a listener factory to start the server.
+ *
+ * @async
+ * @function createPeerServer
+ * @memberof Peer
+ * @param {object} config - Configuration object for the PeerJS server setup.
+ * @param {number} config.port - The primary port on which the PeerJS server will listen.
+ * @param {number} [config.devPort] - Optional development port. If provided and in 'development' NODE_ENV, 'http://localhost:${devPort}' is added to allowed origins.
+ * @param {string[]} config.origins - An array of allowed domain origins for Cross-Origin Resource Sharing (CORS).
+ * @param {string} config.host - The host address the server is bound to (used internally for configuration).
+ * @param {string} config.path - The base path for the API. The PeerJS path ('/peer') will be appended to this.
+ * @returns {Promise<object>} A promise that resolves to an object containing the final configuration and the server instance.
+ * @returns {import('peer').IConfig} return.options - The final options object used to create the PeerServer.
+ * @returns {import('peer').Server} return.peerServer - The created and listening PeerServer instance (wrapped by the listening server factory).
+ * @returns {object} return.meta - The module's import meta object (`import.meta`).
+ */
 const createPeerServer = async ({ port, devPort, origins, host, path }) => {
-  if (process.env.NODE_ENV === 'development' && devPort) origins.push(`http://localhost:${devPort}`);
+  if (process.env.NODE_ENV === 'development' && devPort) {
+    logger.warn(`Adding development origin: http://localhost:${devPort}`);
+    origins.push(`http://localhost:${devPort}`);
+  }
+
   /** @type {import('peer').IConfig} */
   const options = {
     port,
+    // Ensure the path is correctly formatted, handling the root path case
     path: `${path === '/' ? '' : path}/peer`,
     corsOptions: {
       origin: origins,
     },
     proxied: true,
-    // key: fs.readFileSync(''),
-    // cert: fs.readFileSync(''),
-    // ca: fs.readFileSync(''),
+    // key: fs.readFileSync(''), // Example for HTTPS/SSL
+    // cert: fs.readFileSync(''), // Example for HTTPS/SSL
+    // ca: fs.readFileSync(''),   // Example for HTTPS/SSL
   };
+
+  // Use the framework's factory to listen on the server, ensuring graceful startup/shutdown
   const peerServer = UnderpostStartUp.API.listenServerFactory(() => PeerServer(options));
 
   return { options, peerServer, meta: import.meta };

package/src/server/process.js

@@ -1,8 +1,14 @@
+/**
+ * Module for process and shell command management.
+ * Provides utilities for executing shell commands, managing signals, and handling environment details.
+ * @module src/server/process.js
+ * @namespace Process
+ */
+
 // https://nodejs.org/api/process
 
 import shell from 'shelljs';
 import dotenv from 'dotenv';
-import fs from 'fs-extra';
 import { loggerFactory } from './logger.js';
 import clipboard from 'clipboardy';
 import UnderpostRootEnv from '../cli/env.js';
@@ -11,9 +17,23 @@ dotenv.config();
 
 const logger = loggerFactory(import.meta);
 
+/**
+ * Gets the current working directory, replacing backslashes with forward slashes for consistency.
+ * @memberof Process
+ * @returns {string} The root directory path.
+ */
 const getRootDirectory = () => process.cwd().replace(/\\/g, '/');
 
+/**
+ * Controls and manages process-level events and signals.
+ * @namespace ProcessController
+ */
 const ProcessController = {
+  /**
+   * List of signals to listen for for graceful shutdown/handling.
+   * @memberof ProcessController
+   * @type {string[]}
+   */
   SIG: [
     'SIGPIPE',
     'SIGHUP',
@@ -28,6 +48,13 @@ const ProcessController = {
     'SIGSEGV',
     'SIGILL',
   ],
+
+  /**
+   * Sets up listeners for various process signals defined in {@link ProcessController.SIG}.
+   * Handles graceful exit on 'SIGINT' (Ctrl+C).
+   * @memberof ProcessController
+   * @returns {Array<process.Process>} An array of process listener handles.
+   */
   onSigListen: function () {
     return this.SIG.map((sig) =>
       process.on(sig, (...args) => {
@@ -42,6 +69,14 @@ const ProcessController = {
       }),
     );
   },
+
+  /**
+   * Initializes the ProcessController.
+   * Sets up signal listeners, registers a listener for the 'exit' event, and cleans up temporary deployment environment variables.
+   * @memberof ProcessController
+   * @param {Object} logger - The logger instance to use for internal logging.
+   * @returns {void}
+   */
   init: function (logger) {
     this.logger = logger;
     process.on('exit', (...args) => {
@@ -52,33 +87,82 @@ const ProcessController = {
   },
 };
 
+/**
+ * Executes a shell command using shelljs.
+ * @memberof Process
+ * @param {string} cmd - The command string to execute.
+ * @param {Object} [options] - Options for execution.
+ * @param {boolean} [options.silent=false] - Suppress output from shell commands.
+ * @param {boolean} [options.async=false] - Run command asynchronously.
+ * @param {boolean} [options.stdout=false] - Return stdout content (string) instead of shelljs result object.
+ * @param {boolean} [options.disableLog=false] - Prevent logging of the command.
+ * @returns {string|shelljs.ShellString} The result of the shell command (string if `stdout: true`, otherwise a ShellString object).
+ */
 const shellExec = (cmd, options = { silent: false, async: false, stdout: false, disableLog: false }) => {
   if (!options.disableLog) logger.info(`cmd`, cmd);
   return options.stdout ? shell.exec(cmd, options).stdout : shell.exec(cmd, options);
 };
 
+/**
+ * Changes the current working directory using shelljs.
+ * @memberof Process
+ * @param {string} cd - The path to change the directory to.
+ * @param {Object} [options] - Options for the CD operation.
+ * @param {boolean} [options.disableLog=false] - Prevent logging of the CD command.
+ * @returns {shelljs.ShellString} The result of the shelljs cd command.
+ */
 const shellCd = (cd, options = { disableLog: false }) => {
   if (!options.disableLog) logger.info(`cd`, cd);
   return shell.cd(cd);
 };
 
+/**
+ * Opens a new GNOME terminal and executes a command.
+ * Note: This function is environment-specific (GNOME/Linux).
+ * @memberof Process
+ * @param {string} cmd - The command to execute in the new terminal.
+ * @param {Object} [options] - Options for the terminal opening.
+ * @param {boolean} [options.single=false] - If true, execute as a single session process using `setsid`.
+ * @returns {void}
+ */
 const openTerminal = (cmd, options = { single: false }) => {
   if (options.single === true) {
+    // Run as a single session process
     shellExec(`setsid gnome-terminal -- bash -ic "${cmd}; exec bash" >/dev/null 2>&1 &`);
     return;
   }
+  // Run asynchronously and disown
   shellExec(`gnome-terminal -- bash -c "${cmd}; exec bash" & disown`, {
     async: true,
     stdout: true,
   });
 };
 
+/**
+ * Wraps a command to run it as a daemon process in a shell (keeping the process alive/terminal open).
+ * @memberof Process
+ * @param {string} cmd - The command to daemonize.
+ * @returns {string} The shell command string for the daemon process.
+ */
 const daemonProcess = (cmd) => `exec bash -c '${cmd}; exec tail -f /dev/null'`;
 
+/**
+ * Retrieves the process ID (PID) of the most recently created gnome-terminal instance.
+ * Note: This function is environment-specific (GNOME/Linux) and uses `pgrep -n`.
+ * @memberof Process
+ * @returns {number} The PID of the last gnome-terminal process.
+ */
 // list all terminals: pgrep gnome-terminal
 // list last terminal: pgrep -n gnome-terminal
 const getTerminalPid = () => JSON.parse(shellExec(`pgrep -n gnome-terminal`, { stdout: true, silent: true }));
 
+/**
+ * Copies text content to the system clipboard using clipboardy.
+ * Logs the copied content for confirmation.
+ * @memberof Process
+ * @param {string} [data='🦄'] - The data to copy. Defaults to '🦄'.
+ * @returns {void}
+ */
 function pbcopy(data) {
   clipboard.writeSync(data || '🦄');
   logger.info(`copied to clipboard`, clipboard.readSync());

package/src/server/runtime.js

@@ -99,6 +99,8 @@ const buildRuntime = async () => {
             return next();
           });
 
+          if (process.env.NODE_ENV === 'production') app.set('trust proxy', true);
+
           app.use((req, res, next) => {
             requestCounter.inc({
               instance: `${host}:${port}${path}`,
@@ -129,17 +131,6 @@ const buildRuntime = async () => {
             return compression.filter(req, res);
           }
 
-          if (process.argv.includes('static')) {
-            logger.info('Build static server runtime', `${host}${path}`);
-            currentPort += 2;
-            const staticPort = newInstance(currentPort);
-
-            await UnderpostStartUp.API.listenPortController(app, staticPort, runningData);
-            currentPort++;
-            continue;
-          }
-          logger.info('Build api server runtime', `${host}${path}`);
-
           // parse requests of content-type - application/json
           app.use(express.json({ limit: '100MB' }));
 
@@ -163,6 +154,23 @@ const buildRuntime = async () => {
 
           // instance public static
           app.use('/', express.static(directory ? directory : `.${rootHostPath}`));
+          if (process.argv.includes('static')) {
+            logger.info('Build static server runtime', `${host}${path}`);
+            currentPort += 2;
+            const staticPort = newInstance(currentPort);
+            await UnderpostStartUp.API.listenPortController(app, staticPort, runningData);
+            currentPort++;
+            continue;
+          }
+
+          // Flag swagger requests before security middleware is applied
+          const swaggerJsonPath = `./public/${host}${path === '/' ? path : `${path}/`}swagger-output.json`;
+          const swaggerPath = `${path === '/' ? `/api-docs` : `${path}/api-docs`}`;
+          if (fs.existsSync(swaggerJsonPath))
+            app.use(swaggerPath, (req, res, next) => {
+              res.locals.isSwagger = true;
+              next();
+            });
 
           // security
           applySecurity(app, {
@@ -194,22 +202,14 @@ const buildRuntime = async () => {
           if (peer) currentPort++;
 
           if (!apiBaseHost) {
-            const swaggerJsonPath = `./public/${host}${path === '/' ? path : `${path}/`}swagger-output.json`;
             if (fs.existsSync(swaggerJsonPath)) {
-              // logger.info('Build swagger serve', swaggerJsonPath);
-
               const swaggerInstance =
                 (swaggerDoc) =>
                 (...args) =>
                   swaggerUi.setup(swaggerDoc)(...args);
-
               const swaggerDoc = JSON.parse(fs.readFileSync(swaggerJsonPath, 'utf8'));
-
-              app.use(
-                `${path === '/' ? `/api-docs` : `${path}/api-docs`}`,
-                swaggerUi.serve,
-                swaggerInstance(swaggerDoc),
-              );
+              const swaggerPath = `${path === '/' ? `/api-docs` : `${path}/api-docs`}`;
+              app.use(swaggerPath, swaggerUi.serve, swaggerInstance(swaggerDoc));
             }
 
             if (db && apis) await DataBaseProvider.load({ apis, host, path, db });
@@ -228,12 +228,12 @@ const buildRuntime = async () => {
                 templates: mailerSsrConf ? mailerSsrConf.mailer : {},
               });
             }
-            if (apis) {
+            if (apis && apis.length > 0) {
               const authMiddleware = authMiddlewareFactory({ host, path });
-
               const apiPath = `${path === '/' ? '' : path}/${process.env.BASE_API}`;
               for (const api of apis)
                 await (async () => {
+                  logger.info(`Build api server`, `${host}${apiPath}/${api}`);
                   const { ApiRouter } = await import(`../api/${api}/${api}.router.js`);
                   const router = ApiRouter({ host, path, apiPath, mailer, db, authMiddleware, origins });
                   // router.use(cors({ origin: origins }));

package/src/server/ssr.js

@@ -1,8 +1,16 @@
+/**
+ * Module for managing server side rendering
+ * @module src/server/ssr.js
+ * @namespace SSR
+ */
+
 import fs from 'fs-extra';
 import dotenv from 'dotenv';
+import vm from 'node:vm';
+
 import Underpost from '../index.js';
 
-import { ssrFactory, JSONweb } from './client-formatted.js';
+import { srcFormatted, JSONweb } from './client-formatted.js';
 import { loggerFactory } from './logger.js';
 import { getRootDirectory } from './process.js';
 
@@ -10,6 +18,48 @@ dotenv.config();
 
 const logger = loggerFactory(import.meta);
 
+/**
+ * Creates a server-side rendering component function from a given file path.
+ * It reads the component file, formats it, and executes it in a sandboxed Node.js VM context to extract the component.
+ * @param {string} [componentPath='./src/client/ssr/Render.js'] - The path to the SSR component file.
+ * @returns {Promise<Function>} A promise that resolves to the SSR component function.
+ * @memberof SSR
+ */
+const ssrFactory = async (componentPath = `./src/client/ssr/Render.js`) => {
+  const context = { SrrComponent: () => {}, npm_package_version: Underpost.version };
+  vm.createContext(context);
+  vm.runInContext(await srcFormatted(fs.readFileSync(componentPath, 'utf8')), context);
+  return context.SrrComponent;
+};
+
+/**
+ * Sanitizes an HTML string by adding a nonce to all script and style tags for Content Security Policy (CSP).
+ * The nonce is retrieved from `res.locals.nonce`.
+ * @param {object} res - The Express response object.
+ * @param {object} req - The Express request object.
+ * @param {string} html - The HTML string to sanitize.
+ * @returns {string} The sanitized HTML string with nonces.
+ * @memberof SSR
+ */
+const sanitizeHtml = (res, req, html) => {
+  const nonce = res.locals.nonce;
+
+  return html
+    .replace(/<script(?=\s|>)/gi, `<script nonce="${nonce}"`)
+    .replace(/<style(?=\s|>)/gi, `<style nonce="${nonce}"`);
+};
+
+/**
+ * Factory function to create Express middleware for handling 404 and 500 errors.
+ * It generates server-side rendered HTML for these error pages. If static error pages exist, it redirects to them.
+ * @param {object} options - The options for creating the middleware.
+ * @param {object} options.app - The Express app instance.
+ * @param {string} options.directory - The directory for the instance's static files.
+ * @param {string} options.rootHostPath - The root path for the host's public files.
+ * @param {string} options.path - The base path for the instance.
+ * @returns {Promise<{error500: Function, error400: Function}>} A promise that resolves to an object containing the 500 and 404 error handling middleware.
+ * @memberof SSR
+ */
 const ssrMiddlewareFactory = async ({ app, directory, rootHostPath, path }) => {
   const Render = await ssrFactory();
   const ssrPath = path === '/' ? path : `${path}/`;
@@ -48,14 +98,6 @@ const ssrMiddlewareFactory = async ({ app, directory, rootHostPath, path }) => {
   const path500 = `${directory ? directory : `${getRootDirectory()}${rootHostPath}`}/500/index.html`;
   const page500 = fs.existsSync(path500) ? `${path === '/' ? '' : path}/500` : undefined;
 
-  const sanitizeHtml = (res, req, html) => {
-    const nonce = res.locals.nonce;
-
-    return html
-      .replace(/<script(?=\s|>)/gi, `<script nonce="${nonce}"`)
-      .replace(/<style(?=\s|>)/gi, `<style nonce="${nonce}"`);
-  };
-
   return {
     error500: function (err, req, res, next) {
       logger.error(err, err.stack);
@@ -82,4 +124,4 @@ const ssrMiddlewareFactory = async ({ app, directory, rootHostPath, path }) => {
   };
 };
 
-export { ssrMiddlewareFactory };
+export { ssrMiddlewareFactory, ssrFactory, sanitizeHtml };