@underpostnet/underpost 2.99.1 → 2.99.5

package/src/client/components/core/Translate.js

@@ -687,6 +687,10 @@ const TranslateCore = {
       en: 'Markdown source copied to clipboard',
       es: 'Fuente de Markdown copiada al portapapeles',
     };
+    Translate.Data['success-clear-filter'] = {
+      en: 'Filter cleared successfully',
+      es: 'Filtro limpiado con éxito',
+    };
   },
 };
 

package/src/client/services/default/default.management.js

@@ -39,9 +39,19 @@ const DefaultOptions = {
 const columnDefFormatter = (obj, columnDefs, customFormat) => {
   for (const colDef of columnDefs)
     switch (colDef.cellDataType) {
-      case 'date':
-        obj[colDef.field] = obj[colDef.field] ? new Date(obj[colDef.field]) : new Date();
+      case 'date': {
+        const value = obj[colDef.field];
+
+        // Do NOT default missing/blank dates to "now" — render as empty instead.
+        if (value === null || value === undefined || value === '') {
+          obj[colDef.field] = null;
+          break;
+        }
+
+        const date = new Date(value);
+        obj[colDef.field] = isNaN(date.getTime()) ? null : date;
         break;
+      }
       case 'boolean':
         if (obj[colDef.field] !== true && obj[colDef.field] !== false) obj[colDef.field] = false;
       default:

package/src/index.js

@@ -25,6 +25,7 @@ import UnderpostDns from './server/dns.js';
 import UnderpostBackup from './server/backup.js';
 import UnderpostCron from './server/cron.js';
 import UnderpostStartUp from './server/start.js';
+import UnderpostTLS from './server/tls.js';
 
 /**
  * Underpost main module methods
@@ -38,7 +39,16 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v2.99.1';
+  static version = 'v2.99.5';
+
+  /**
+   * Required Node.js major version
+   * @static
+   * @type {String}
+   * @memberof Underpost
+   */
+  static majorNodejsVersion = 'v24';
+
   /**
    * Repository cli API
    * @static
@@ -228,8 +238,23 @@ class Underpost {
   static get start() {
     return UnderpostStartUp.API;
   }
+
+  /**
+   * TLS/SSL server utilities API
+   * @static
+   * @type {UnderpostTLS.API}
+   * @memberof Underpost
+   */
+  static get tls() {
+    return UnderpostTLS.API;
+  }
 }
 
+if (!process.version || !process.version.startsWith(`${Underpost.majorNodejsVersion}.`))
+  console.warn(
+    `${`Underpost Warning: Required Node.js version is `.red}${`${Underpost.majorNodejsVersion}.x`.bgBlue.bold.white}${`, you are using `.red}${process.version.bgRed.bold.white}`,
+  );
+
 const up = Underpost;
 
 const underpost = Underpost;
@@ -258,6 +283,7 @@ export {
   UnderpostBackup,
   UnderpostCron,
   UnderpostStartUp,
+  UnderpostTLS,
 };
 
 export default Underpost;

package/src/runtime/express/Express.js

@@ -20,7 +20,7 @@ import { createPeerServer } from '../../server/peer.js';
 import { createValkeyConnection } from '../../server/valkey.js';
 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';
 
@@ -249,8 +249,8 @@ class ExpressService {
 
     // Start listening on the main port
     if (useLocalSsl && process.env.NODE_ENV === 'development') {
-      if (!TLS.validateSecureContext()) shellExec(`node bin/deploy tls`);
-      const { ServerSSL } = await TLS.createSslServer(app);
+      if (!Underpost.tls.validateSecureContext()) shellExec(`node bin/deploy tls`);
+      const { ServerSSL } = await Underpost.tls.createSslServer(app);
       await Underpost.start.listenPortController(ServerSSL, port, runningData);
     } else await Underpost.start.listenPortController(server, port, runningData);
 

package/src/server/conf.js

@@ -66,7 +66,7 @@ const Config = {
   /**
    * @method deployIdFactory
    * @description Creates a new deploy ID.
-   * @param {string} [deployId='dd-default
+   * @param {string} [deployId='dd-default']
    * @param {object} [options={ subConf: '', cluster: false }] - The options.
    * @memberof ServerConfBuilder
    */
@@ -842,8 +842,10 @@ const buildPortProxyRouter = (
 
   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',
+      fs.readFileSync(
+        `./engine-private/conf/${process.argv[3]}/conf.server.dev.${process.argv[4]}-dev-api.json`,
+        'utf8',
+      ),
     );
     let devApiHosts = [];
     let origins = [];
@@ -899,7 +901,7 @@ const buildReplicaId = ({ deployId, replica }) => `${deployId}-${replica.slice(1
  * @description Gets the data deploy.
  * @param {object} options - The options.
  * @param {boolean} [options.buildSingleReplica=false] - The build single replica.
- * @param {string} options.deployId - The deploy ID.
+ * @param {string} [options.deployId] - The deploy ID.
  * @param {boolean} [options.disableSyncEnvPort=false] - The disable sync env port.
  * @returns {object} - The data deploy.
  * @memberof ServerConfBuilder

package/src/server/logger.js

@@ -28,11 +28,13 @@ const levels = {
   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');
+/**
+ * The `level` function determines the logging level based on the provided `logLevel` parameter or defaults to 'info'.
+ * @param {string} logLevel - The logging level to be used. If not provided, it defaults to 'info'.
+ * @returns {string} The logging level to be used for the logger.
+ * @memberof Logger
+ */
+const level = (logLevel = '') => logLevel || 'info';
 
 // Define different colors for each level.
 // Colors make the log message more visible,
@@ -98,13 +100,14 @@ const setUpInfo = async (logger = new winston.Logger()) => {
  * messages.
  * @param meta - The `meta` parameter in the `loggerFactory` function is used to extract the last part
  * of a URL and use it to create log files in a specific directory.
- * @returns {winston.Logger} The `loggerFactory` function returns a logger instance created using Winston logger
+ * @param logLevel - Specify the logging level for the logger instance. e.g., 'error', 'warn', 'info', 'debug'.
+ * @returns {underpostLogger} The `loggerFactory` function returns a logger instance created using Winston logger
  * library. The logger instance is configured with various transports for printing out messages to
  * different destinations such as the terminal, error.log file, and all.log file. The logger instance
  * also has a method `setUpInfo` attached to it for setting up additional information.
  * @memberof Logger
  */
-const loggerFactory = (meta = { url: '' }) => {
+const loggerFactory = (meta = { url: '' }, logLevel = '') => {
   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
@@ -125,7 +128,7 @@ const loggerFactory = (meta = { url: '' }) => {
   // and used to log messages.
   const logger = winston.createLogger({
     defaultMeta: meta,
-    level: level(),
+    level: level(logLevel),
     levels,
     format: format(meta),
     transports,
@@ -133,45 +136,44 @@ const loggerFactory = (meta = { url: '' }) => {
     // rejectionHandlers: [new winston.transports.File({ filename: 'rejections.log' })],
     // exitOnError: false,
   });
-  logger.setUpInfo = async () => {
-    await setUpInfo(logger);
-  };
+  /**
+   * The returned logger is a real Winston logger instance with an extra `setUpInfo` method.
+   *
+   * @memberof Logger
+   * @typedef {winston.Logger & {
+   *  setUpInfo: (logger?: winston.Logger) => Promise<void>
+   * }} underpostLogger
+   */
+  logger.setUpInfo = () => setUpInfo(logger);
+
   return logger;
 };
 
 /**
- * The `loggerMiddleware` function creates a middleware for logging HTTP requests using Morgan with
- * custom message format and options.
- * @param meta - The `meta` parameter in the `loggerMiddleware` function is an object that contains
- * information about the request URL. It has a default value of an empty object `{ url: '' }`. This
- * object is used to provide additional metadata for logging purposes.
- * @returns {Handler<any, any>} The `loggerMiddleware` function returns a middleware function that uses the Morgan library
- * to log HTTP request information. The middleware function formats the log message using predefined
- * tokens provided by Morgan and custom tokens like `:host` to include specific request details. The
- * log message format includes information such as remote address, HTTP method, host, URL, status code,
- * content length, and response time in milliseconds. The middleware
+ * The `loggerMiddleware` function is an Express middleware that uses the Morgan library to log HTTP requests.
+ * @param {Object} meta - An object containing metadata, such as the URL, to be used in the logger.
+ * @param {string} logLevel - The logging level to be used for the logger (e.g., 'error', 'warn', 'info', 'debug').
+ * @param {Function} skip - A function to determine whether to skip logging for a particular request.
+ * @returns {Function} A middleware function that can be used in an Express application to log HTTP requests.
  * @memberof Logger
  */
-const loggerMiddleware = (meta = { url: '' }) => {
+const loggerMiddleware = (
+  meta = { url: '' },
+  logLevel = 'info',
+  skip = (req, res) => process.env.NODE_ENV === 'production',
+) => {
   const stream = {
     // Use the http severity
-    write: (message) => loggerFactory(meta).http(message),
+    write: (message) => loggerFactory(meta, logLevel).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.
+    // Define message format string
     `: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 },
   );
 };

package/src/server/process.js

@@ -12,6 +12,7 @@ import dotenv from 'dotenv';
 import { loggerFactory } from './logger.js';
 import clipboard from 'clipboardy';
 import Underpost from '../index.js';
+import { getNpmRootPath } from './conf.js';
 
 dotenv.config();
 
@@ -128,16 +129,40 @@ const shellCd = (cd, options = { disableLog: false }) => {
  * @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`.
+ * @param {string} [options.chown] - Path to change ownership to the target user.
  * @returns {void}
  */
 const openTerminal = (cmd, options = { single: false }) => {
+  // Find the graphical user's UID from /run/user (prefer non-root UID, usually 1000)
+  const IDS = shellExec(`ls -1 /run/user`, { stdout: true, silent: true })
+    .split('\n')
+    .map((v) => v.trim())
+    .filter(Boolean);
+
+  const nonRootIds = IDS.filter((id) => id !== '0');
+  const ID = nonRootIds.length > 0 ? nonRootIds[0] : IDS[0];
+
+  if (!options.chown) options.chown = `/home/dd ${getNpmRootPath()}/underpost`;
+
+  shellExec(`chown -R ${ID}:${ID} ${options.chown}`);
+
+  // Run the terminal as the graphical user and use THAT user's runtime dir/bus.
+  const confCmd = `USER_GRAPHICAL=$(getent passwd "${ID}" | cut -d: -f1); \
+sudo -u "$USER_GRAPHICAL" env DISPLAY="$DISPLAY" \
+XDG_RUNTIME_DIR="/run/user/${ID}" \
+DBUS_SESSION_BUS_ADDRESS="unix:path=/run/user/${ID}/bus" \
+PATH="$PATH" \
+`;
+
   if (options.single === true) {
     // Run as a single session process
-    shellExec(`setsid gnome-terminal -- bash -ic "${cmd}; exec bash" >/dev/null 2>&1 &`);
+    shellExec(`${confCmd} setsid gnome-terminal -- bash -ic '${cmd}; exec bash' >/dev/null 2>&1 &`, {
+      async: true,
+    });
     return;
   }
   // Run asynchronously and disown
-  shellExec(`gnome-terminal -- bash -c "${cmd}; exec bash" & disown`, {
+  shellExec(`${confCmd} gnome-terminal -- bash -c '${cmd}; exec bash' >/dev/null 2>&1 & disown`, {
     async: true,
     stdout: true,
   });

package/src/server/proxy.js

@@ -13,10 +13,8 @@ import { createProxyMiddleware } from 'http-proxy-middleware';
 import { loggerFactory, loggerMiddleware } from './logger.js';
 import { buildPortProxyRouter, buildProxyRouter, getTlsHosts, isDevProxyContext, isTlsDevProxy } from './conf.js';
 
-import { SSL_BASE, TLS } from './tls.js';
 import { shellExec } from './process.js';
 import fs from 'fs-extra';
-
 import Underpost from '../index.js';
 
 dotenv.config();
@@ -85,7 +83,7 @@ class ProxyService {
           switch (port) {
             case 443:
               // For port 443 (HTTPS), create the SSL server
-              const { ServerSSL } = await TLS.createSslServer(app, hosts);
+              const { ServerSSL } = await Underpost.tls.createSslServer(app, hosts);
               await Underpost.start.listenPortController(ServerSSL, port, runningData);
               break;
 
@@ -103,12 +101,12 @@ class ProxyService {
               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}"`);
+                  if (fs.existsSync(Underpost.tls.SSL_BASE(tlsHost))) fs.removeSync(Underpost.tls.SSL_BASE(tlsHost));
+                  if (!Underpost.tls.validateSecureContext(tlsHost)) shellExec(`node bin/deploy tls "${tlsHost}"`);
                   tlsHosts[tlsHost] = {};
                 }
               }
-              const { ServerSSL } = await TLS.createSslServer(app, tlsHosts);
+              const { ServerSSL } = await Underpost.tls.createSslServer(app, tlsHosts);
               await Underpost.start.listenPortController(ServerSSL, port, runningData);
               break;
             }

package/src/server/tls.js

@@ -1,8 +1,7 @@
 /**
- * Provides utilities for managing, building, and serving SSL/TLS contexts,
- * primarily using Certbot files and creating HTTPS servers.
+ * Transport Layer Security (TLS) / SSL utilities and HTTPS server creation and management.
  * @module src/server/tls.js
- * @namespace TransportLayerSecurity
+ * @namespace UnderpostTLS
  */
 
 import fs from 'fs-extra';
@@ -43,7 +42,7 @@ class TLS {
    * It attempts to be permissive: accepts cert-only, cert+ca, or fullchain.
    * @param {string} host
    * @returns {{key?:string, cert?:string, fullchain?:string, ca?:string, dir:string}}
-   * @memberof TransportLayerSecurity
+   * @memberof UnderpostTLS
    */
   static locateSslFiles(host = DEFAULT_HOST) {
     const dir = SSL_BASE(host);
@@ -103,7 +102,7 @@ class TLS {
    * Validate that a secure context can be built for host (key + cert or fullchain present)
    * @param {string} host
    * @returns {boolean}
-   * @memberof TransportLayerSecurity
+   * @memberof UnderpostTLS
    */
   static validateSecureContext(host = DEFAULT_HOST) {
     const files = TLS.locateSslFiles(host);
@@ -116,7 +115,7 @@ class TLS {
    * If separate cert + ca are found, they will be used accordingly.
    * @param {string} host
    * @returns {{key:string, cert:string, ca?:string}} options
-   * @memberof TransportLayerSecurity
+   * @memberof UnderpostTLS
    */
   static buildSecureContext(host = DEFAULT_HOST) {
     const files = TLS.locateSslFiles(host);
@@ -142,7 +141,7 @@ class TLS {
    * The function will copy existing discovered files to: key.key, crt.crt, ca_bundle.crt when possible.
    * @param {string} host
    * @returns {boolean} true if at least key+cert exist after operation
-   * @memberof TransportLayerSecurity
+   * @memberof UnderpostTLS
    */
   static async buildLocalSSL(host = DEFAULT_HOST) {
     const dir = SSL_BASE(host);
@@ -177,19 +176,16 @@ class TLS {
    * @param {import('express').Application} app
    * @param {Object<string, any>} hosts
    * @returns {{ServerSSL?: https.Server}}
-   * @memberof TransportLayerSecurity
+   * @memberof UnderpostTLS
    */
   static async createSslServer(app, hosts = { [DEFAULT_HOST]: {} }) {
     let server;
     for (const host of Object.keys(hosts)) {
       // ensure canonical files exist (copies where possible)
       await TLS.buildLocalSSL(host);
-      if (!TLS.validate_secure_context_check(host)) {
-        // backward compatibility: some callers expect validateSecureContext
-        if (!TLS.validateSecureContext(host)) {
-          logger.error('Invalid SSL context, skipping host', { host });
-          continue;
-        }
+      if (!TLS.validateSecureContext(host)) {
+        logger.error('Invalid SSL context, skipping host', { host });
+        continue;
       }
 
       // build secure context options
@@ -218,7 +214,7 @@ class TLS {
    * @param {number} port
    * @param {Object<string, any>} proxyRouter
    * @returns {import('express').RequestHandler}
-   * @memberof TransportLayerSecurity
+   * @memberof UnderpostTLS
    */
   static sslRedirectMiddleware(req, res, port = 80, proxyRouter = {}) {
     const sslRedirectUrl = `https://${req.headers.host}${req.url}`;
@@ -238,14 +234,23 @@ class TLS {
   }
 }
 
-// small helper for internal backward compatibility check name typo in older code
-TLS.validate_secure_context_check = TLS.validateSecureContext;
-
-// Backward compatibility exports
-const buildSSL = TLS.buildLocalSSL;
-const buildSecureContext = TLS.buildSecureContext;
-const validateSecureContext = TLS.validateSecureContext;
-const createSslServer = TLS.createSslServer;
-const sslRedirectMiddleware = TLS.sslRedirectMiddleware;
+/**
+ * @class UnderpostTLS
+ * @description TLS/SSL utilities for Underpost.
+ * @memberof UnderpostTLS
+ */
+class UnderpostTLS {
+  static API = {
+    TLS,
+    SSL_BASE,
+    locateSslFiles: TLS.locateSslFiles,
+    validateSecureContext: TLS.validateSecureContext,
+    buildSecureContext: TLS.buildSecureContext,
+    buildLocalSSL: TLS.buildLocalSSL,
+    createSslServer: TLS.createSslServer,
+    sslRedirectMiddleware: TLS.sslRedirectMiddleware,
+  };
+}
 
-export { TLS, SSL_BASE, buildSSL, buildSecureContext, validateSecureContext, createSslServer, sslRedirectMiddleware };
+export { TLS, SSL_BASE, UnderpostTLS };
+export default UnderpostTLS;