cyberia 2.8.885

package/src/server/process.js

@@ -0,0 +1,171 @@
+/**
+ * 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 { loggerFactory } from './logger.js';
+import clipboard from 'clipboardy';
+import UnderpostRootEnv from '../cli/env.js';
+
+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',
+    'SIGTERM',
+    'SIGINT',
+    'SIGBREAK',
+    'SIGWINCH',
+    // 'SIGKILL',
+    // 'SIGSTOP',
+    'SIGBUS',
+    'SIGFPE',
+    '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) => {
+        this.logger.info(`process on ${sig}`, args);
+        switch (sig) {
+          case 'SIGINT':
+            return process.exit();
+
+          default:
+            break;
+        }
+      }),
+    );
+  },
+
+  /**
+   * 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) => {
+      this.logger.info(`process on exit`, args);
+    });
+    this.onSigListen();
+    UnderpostRootEnv.API.delete('await-deploy');
+  },
+};
+
+/**
+ * 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());
+}
+
+export { ProcessController, getRootDirectory, shellExec, shellCd, pbcopy, openTerminal, getTerminalPid, daemonProcess };

package/src/server/proxy.js

@@ -0,0 +1,110 @@
+/**
+ * Manages the creation and configuration of the reverse proxy server,
+ * including handling HTTP/HTTPS listeners and routing based on host configuration.
+ * @module src/server/proxy.js
+ * @namespace ProxyService
+ */
+'use strict';
+
+import express from 'express';
+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 UnderpostStartUp from './start.js';
+
+dotenv.config();
+
+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
+ * @memberof ProxyService
+ */
+class Proxy {
+  /**
+   * Initializes and starts the reverse proxy server for all configured ports and hosts.
+   * @async
+   * @static
+   * @memberof ProxyService
+   * @returns {Promise<void>}
+   * @memberof ProxyService
+   */
+  static async buildProxy() {
+    // Start a default Express listener on process.env.PORT (potentially unused, but ensures Express is initialized)
+    express().listen(process.env.PORT);
+
+    const proxyRouter = buildProxyRouter();
+
+    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 middleware
+      app.use(loggerMiddleware(import.meta));
+
+      // Proxy middleware options
+      /** @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)
+        router: {},
+        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
+        },
+      };
+
+      options.router = buildPortProxyRouter(port, proxyRouter);
+
+      const filter = proxyPath; // Use '/' as the general filter
+      app.use(proxyPath, createProxyMiddleware(filter, options));
+
+      // Determine which server to start (HTTP or HTTPS) based on port and environment
+      switch (process.env.NODE_ENV) {
+        case 'production':
+          switch (port) {
+            case 443:
+              // For port 443 (HTTPS), create the SSL server
+              const { ServerSSL } = await TLS.createSslServer(app, hosts);
+              await UnderpostStartUp.API.listenPortController(ServerSSL, port, runningData);
+              break;
+
+            default:
+              // For other ports in production, use standard HTTP
+              await UnderpostStartUp.API.listenPortController(app, port, runningData);
+              break;
+          }
+          break;
+
+        default:
+          // In non-production, always use standard HTTP listener
+          await UnderpostStartUp.API.listenPortController(app, port, runningData);
+          break;
+      }
+      logger.info('Proxy running', { port, options });
+    }
+  }
+}
+
+/**
+ * Backward compatibility export
+ * @type {function(): Promise<void>}
+ * @memberof ProxyService
+ */
+const buildProxy = Proxy.buildProxy;
+
+export { Proxy, buildProxy };

package/src/server/runtime.js

@@ -0,0 +1,170 @@
+/**
+ * The main runtime orchestrator responsible for reading configuration,
+ * initializing services (Prometheus, Ports, DB, Mailer), and building the
+ * specific server runtime for each host/path (e.g., nodejs, lampp).
+ * @module src/server/runtime.js
+ * @namespace Runtime
+ */
+
+import fs from 'fs-extra';
+import dotenv from 'dotenv';
+import * as promClient from 'prom-client';
+
+import UnderpostStartUp from './start.js';
+import { loggerFactory } from './logger.js';
+import { newInstance } from '../client/components/core/CommonJs.js';
+import { Lampp } from '../runtime/lampp/Lampp.js';
+import { getInstanceContext } from './conf.js';
+
+import ExpressService from '../runtime/express/Express.js';
+
+dotenv.config();
+
+const logger = loggerFactory(import.meta);
+
+/**
+ * Reads server configurations, sets up Prometheus metrics, and iterates through
+ * all defined hosts and paths to build and start the corresponding runtime instances.
+ *
+ * @memberof Runtime
+ * @returns {Promise<void>}
+ * @function buildRuntime
+ */
+const buildRuntime = async () => {
+  const deployId = process.env.DEPLOY_ID;
+
+  // 1. Initialize Prometheus Metrics
+  const collectDefaultMetrics = promClient.collectDefaultMetrics;
+  collectDefaultMetrics();
+
+  const promCounterOption = {
+    name: `${deployId.replaceAll('-', '_')}_http_requests_total`,
+    help: 'Total number of HTTP requests',
+    labelNames: ['instance', 'method', 'status_code'],
+  };
+
+  const requestCounter = new promClient.Counter(promCounterOption);
+  const initPort = parseInt(process.env.PORT) + 1;
+  let currentPort = initPort;
+
+  // 2. Load Configuration
+  const confServer = JSON.parse(fs.readFileSync(`./conf/conf.server.json`, 'utf8'));
+  const confSSR = JSON.parse(fs.readFileSync(`./conf/conf.ssr.json`, 'utf8'));
+  const singleReplicaHosts = [];
+
+  // 3. Iterate through hosts and paths
+  for (const host of Object.keys(confServer)) {
+    if (singleReplicaHosts.length > 0)
+      currentPort += singleReplicaHosts.reduce((accumulator, currentValue) => accumulator + currentValue.replicas, 0);
+
+    const rootHostPath = `/public/${host}`;
+    for (const path of Object.keys(confServer[host])) {
+      confServer[host][path].port = newInstance(currentPort);
+      const {
+        runtime,
+        port,
+        client,
+        apis,
+        origins,
+        directory,
+        ws,
+        mailer,
+        db,
+        redirect,
+        peer,
+        singleReplica,
+        replicas,
+        valkey,
+        apiBaseHost,
+        useLocalSsl,
+      } = confServer[host][path];
+
+      // Calculate context data
+      const { redirectTarget, singleReplicaHost } = await getInstanceContext({
+        redirect,
+        singleReplicaHosts,
+        singleReplica,
+        replicas,
+      });
+
+      if (singleReplicaHost) {
+        singleReplicaHosts.push({
+          host,
+          replicas: replicas.length,
+        });
+        continue;
+      }
+
+      const runningData = {
+        host,
+        path,
+        runtime,
+        client,
+        meta: import.meta,
+        apis,
+      };
+
+      switch (runtime) {
+        case 'nodejs':
+          logger.info('Build nodejs server runtime', `${host}${path}:${port}`);
+
+          const { portsUsed } = await ExpressService.createApp({
+            host,
+            path,
+            port,
+            client,
+            apis,
+            origins,
+            directory,
+            useLocalSsl,
+            ws,
+            mailer,
+            db,
+            redirect,
+            peer,
+            valkey,
+            apiBaseHost,
+            redirectTarget,
+            rootHostPath,
+            confSSR,
+            promRequestCounter: requestCounter,
+            promRegister: promClient.register,
+          });
+
+          // Increment currentPort by any additional ports used by the service (e.g., PeerServer port)
+          currentPort += portsUsed;
+          break;
+
+        case 'lampp':
+          {
+            const { disabled } = await Lampp.createApp({
+              port,
+              host,
+              path,
+              directory,
+              rootHostPath,
+              redirect,
+              redirectTarget,
+              resetRouter: currentPort === initPort,
+            });
+            if (disabled) continue;
+            await UnderpostStartUp.API.listenPortController(
+              UnderpostStartUp.API.listenServerFactory(),
+              port,
+              runningData,
+            );
+          }
+          break;
+        default:
+          break;
+      }
+      currentPort++;
+    }
+  }
+
+  if (Lampp.enabled() && Lampp.router) Lampp.initService();
+
+  UnderpostStartUp.API.logRuntimeRouter();
+};
+
+export { buildRuntime };

package/src/server/ssr.js

@@ -0,0 +1,127 @@
+/**
+ * Module for managing server side rendering
+ * @module src/server/ssr.js
+ * @namespace ServerSideRendering
+ */
+
+import fs from 'fs-extra';
+import dotenv from 'dotenv';
+import vm from 'node:vm';
+
+import Underpost from '../index.js';
+
+import { srcFormatted, JSONweb } from './client-formatted.js';
+import { loggerFactory } from './logger.js';
+import { getRootDirectory } from './process.js';
+
+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 ServerSideRendering
+ */
+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 ServerSideRendering
+ */
+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 ServerSideRendering
+ */
+const ssrMiddlewareFactory = async ({ app, directory, rootHostPath, path }) => {
+  const Render = await ssrFactory();
+  const ssrPath = path === '/' ? path : `${path}/`;
+
+  // Build default html src for 404 and 500
+
+  const defaultHtmlSrc404 = Render({
+    title: '404 Not Found',
+    ssrPath,
+    ssrHeadComponents: '',
+    ssrBodyComponents: (await ssrFactory(`./src/client/ssr/body/404.js`))(),
+    renderPayload: {
+      apiBasePath: process.env.BASE_API,
+      version: Underpost.version,
+    },
+    renderApi: {
+      JSONweb,
+    },
+  });
+  const path404 = `${directory ? directory : `${getRootDirectory()}${rootHostPath}`}/404/index.html`;
+  const page404 = fs.existsSync(path404) ? `${path === '/' ? '' : path}/404` : undefined;
+
+  const defaultHtmlSrc500 = Render({
+    title: '500 Server Error',
+    ssrPath,
+    ssrHeadComponents: '',
+    ssrBodyComponents: (await ssrFactory(`./src/client/ssr/body/500.js`))(),
+    renderPayload: {
+      apiBasePath: process.env.BASE_API,
+      version: Underpost.version,
+    },
+    renderApi: {
+      JSONweb,
+    },
+  });
+  const path500 = `${directory ? directory : `${getRootDirectory()}${rootHostPath}`}/500/index.html`;
+  const page500 = fs.existsSync(path500) ? `${path === '/' ? '' : path}/500` : undefined;
+
+  return {
+    error500: function (err, req, res, next) {
+      logger.error(err, err.stack);
+      if (page500) return res.status(500).redirect(page500);
+      else {
+        res.set('Content-Type', 'text/html');
+        return res.status(500).send(sanitizeHtml(res, req, defaultHtmlSrc500));
+      }
+    },
+    error400: function (req, res, next) {
+      // if /<path>/home redirect to /<path>
+      const homeRedirectPath = `${path === '/' ? '' : path}/home`;
+      if (req.url.startsWith(homeRedirectPath)) {
+        const redirectUrl = req.url.replace('/home', '');
+        return res.redirect(redirectUrl.startsWith('/') ? redirectUrl : `/${redirectUrl}`);
+      }
+
+      if (page404) return res.status(404).redirect(page404);
+      else {
+        res.set('Content-Type', 'text/html');
+        return res.status(404).send(sanitizeHtml(res, req, defaultHtmlSrc404));
+      }
+    },
+  };
+};
+
+export { ssrMiddlewareFactory, ssrFactory, sanitizeHtml };