underpost 2.85.0 → 2.85.7

package/src/cli/repository.js

@@ -111,8 +111,10 @@ class UnderpostRepository {
     ) {
       if (!repoPath) repoPath = '.';
       if (options.msg) {
-        let key = Object.keys(commitData).find((k) => k && options.msg.toLocaleLowerCase().match(k));
-        if (!key) key == 'chore';
+        options.msg = options.msg.replaceAll('"', '').replaceAll(`'`, '').replaceAll('`', '');
+        let key = Object.keys(commitData).find((k) => k && options.msg.toLocaleLowerCase().slice(0, 16).match(k));
+        if (!key) key = Object.keys(commitData).find((k) => k && options.msg.toLocaleLowerCase().match(k));
+        if (!key || key === undefined) key = 'chore';
         shellExec(
           `underpost cmt ${repoPath} ${key} ${options.deployId ? options.deployId : `''`} '${options.msg.replaceAll(`${key}(${key}`, '')}'`,
         );
@@ -211,60 +213,50 @@ class UnderpostRepository {
     },
 
     /**
-     * Creates a new Underpost project, service, or configuration.
-     * @param {string} repositoryName - The name of the new project or service, or a deployId.
-     * @param {object} [options={ dev: false, deployId: false, cluster: false, subConf: '' }] - Creation options.
-     * @param {boolean} [options.dev=false] - If true, sets up a development project.
-     * @param {boolean} [options.deployId=false] - If true, creates deploy ID configuration files.
-     * @param {boolean} [options.cluster=false] - If true, creates cluster configuration files.
-     * @param {string} [options.subConf=''] - If provided, creates a sub-configuration for a deployId.
-     * @returns {Promise<void>} A promise that resolves when the operation is complete.
+     * Initializes a new Underpost repository, optionally setting up a deploy ID or sub-configuration.
+     * @param {string} [projectName=''] - The name of the project to create.
+     * @param {object} [options={ deployId: '', subConf: '', cluster: false, dev: false }] - Initialization options.
+     * @param {string} [options.deployId=''] - The deployment ID to set up.
+     * @param {string} [options.subConf=''] - The sub-configuration to create.
+     * @param {boolean} [options.cluster=false] - If true, sets up a clustered configuration.
+     * @param {boolean} [options.dev=false] - If true, uses development settings.
+     * @returns {Promise<boolean>} A promise that resolves when the initialization is complete.
      * @memberof UnderpostRepository
      */
-    new(repositoryName, options = { dev: false, deployId: false, cluster: false, subConf: '' }) {
+    new(projectName, options = { deployId: '', subConf: '', cluster: false, dev: false }) {
       return new Promise(async (resolve, reject) => {
         try {
           await logger.setUpInfo();
           actionInitLog();
-          if (options.subConf && typeof options.subConf === 'string') {
-            const deployId = repositoryName;
-            logger.info('Creating sub conf', {
-              deployId,
-              subConf: options.subConf,
-            });
-            fs.copySync(
-              `./engine-private/conf/${deployId}/conf.server.json`,
-              `./engine-private/conf/${deployId}/conf.server.dev.${options.subConf}.json`,
-            );
-            return resolve();
+          if (options.deployId) {
+            Config.deployIdFactory(options.deployId, options);
+            return resolve(true);
           }
-          if (repositoryName === 'service')
-            return resolve(
-              await UnderpostStartUp.API.listenPortController(UnderpostStartUp.API.listenServerFactory(), ':'),
-            );
-          if (options.deployId === true) return Config.deployIdFactory(repositoryName, options);
-          const npmRoot = getNpmRootPath();
-          const underpostRoot = options?.dev === true ? '.' : `${npmRoot}/underpost`;
-          const destFolder = `./${repositoryName}`;
-          logger.info('Note: This process may take several minutes to complete');
-          logger.info('build app', { destFolder });
-          if (fs.existsSync(destFolder)) fs.removeSync(destFolder);
-          fs.mkdirSync(destFolder, { recursive: true });
-          if (!options.dev) {
-            fs.copySync(underpostRoot, destFolder);
-            fs.writeFileSync(
-              `${destFolder}/.gitignore`,
-              fs.readFileSync(`${underpostRoot}/.dockerignore`, 'utf8'),
-              'utf8',
-            );
-            shellExec(`cd ${destFolder} && git init && git add . && git commit -m "Base template implementation"`);
+          if (projectName) {
+            const npmRoot = getNpmRootPath();
+            const underpostRoot = options?.dev === true ? '.' : `${npmRoot}/underpost`;
+            const destFolder = `./${projectName}`;
+            logger.info('Note: This process may take several minutes to complete');
+            logger.info('build app', { destFolder });
+            if (fs.existsSync(destFolder)) fs.removeSync(destFolder);
+            fs.mkdirSync(destFolder, { recursive: true });
+            if (!options.dev) {
+              fs.copySync(underpostRoot, destFolder);
+              fs.writeFileSync(
+                `${destFolder}/.gitignore`,
+                fs.readFileSync(`${underpostRoot}/.dockerignore`, 'utf8'),
+                'utf8',
+              );
+              shellExec(`cd ${destFolder} && git init && git add . && git commit -m "Base template implementation"`);
+            }
+            shellExec(`cd ${destFolder} && npm run build`);
+            shellExec(`cd ${destFolder} && npm run dev`);
           }
-          shellExec(`cd ${destFolder} && npm run build`);
-          shellExec(`cd ${destFolder} && npm run dev`);
-          return resolve();
+          return resolve(true);
         } catch (error) {
+          console.log(error);
           logger.error(error, error.stack);
-          return reject(error.message);
+          return reject(false);
         }
       });
     },

package/src/cli/run.js

@@ -5,7 +5,14 @@
  */
 
 import { daemonProcess, getTerminalPid, openTerminal, pbcopy, shellCd, shellExec } from '../server/process.js';
-import { getNpmRootPath, getUnderpostRootPath, isDeployRunnerContext } from '../server/conf.js';
+import {
+  awaitDeployMonitor,
+  Config,
+  getNpmRootPath,
+  getUnderpostRootPath,
+  isDeployRunnerContext,
+  writeEnv,
+} from '../server/conf.js';
 import { actionInitLog, loggerFactory } from '../server/logger.js';
 import UnderpostTest from './test.js';
 import fs from 'fs-extra';
@@ -15,6 +22,7 @@ import UnderpostRootEnv from './env.js';
 import UnderpostRepository from './repository.js';
 import os from 'os';
 import Underpost from '../index.js';
+import dotenv from 'dotenv';
 
 const logger = loggerFactory(import.meta);
 
@@ -44,6 +52,12 @@ class UnderpostRun {
    * @property {boolean} k3s - Whether to run in k3s mode.
    * @property {boolean} kubeadm - Whether to run in kubeadm mode.
    * @property {boolean} force - Whether to force the operation.
+   * @property {boolean} reset - Whether to reset the operation.
+   * @property {boolean} tls - Whether to use TLS.
+   * @property {string} tty - The TTY option for the container.
+   * @property {string} stdin - The stdin option for the container.
+   * @property {string} restartPolicy - The restart policy for the container.
+   * @property {boolean} terminal - Whether to open a terminal.
    * @memberof UnderpostRun
    */
   static DEFAULT_OPTION = {
@@ -59,6 +73,13 @@ class UnderpostRun {
     k3s: false,
     kubeadm: false,
     force: false,
+    reset: false,
+    tls: false,
+    tty: '',
+    stdin: '',
+    restartPolicy: '',
+    terminal: false,
+    devProxyPortOffset: 0,
   };
   /**
    * @static
@@ -106,13 +127,21 @@ class UnderpostRun {
     },
     /**
      * @method kill
-     * @description Kills the process running on the specified port by finding its PID using `lsof -t -i:${path}`.
+     * @description Kills processes listening on the specified port(s). If the `path` contains a `+`, it treats it as a range of ports to kill.
      * @param {string} path - The input value, identifier, or path for the operation (used as the port number).
      * @param {Object} options - The default underpost runner options for customizing workflow
      * @memberof UnderpostRun
      */
-    kill: (path, options = UnderpostRun.DEFAULT_OPTION) => {
-      shellExec(`sudo kill -9 $(lsof -t -i:${path})`);
+    kill: (path = '', options = UnderpostRun.DEFAULT_OPTION) => {
+      for (const _path of path.split(',')) {
+        if (_path.split('+')[1]) {
+          let [port, sumPortOffSet] = _path.split('+');
+          port = parseInt(port);
+          sumPortOffSet = parseInt(sumPortOffSet);
+          for (const sumPort of range(0, sumPortOffSet))
+            shellExec(`sudo kill -9 $(lsof -t -i:${parseInt(port) + parseInt(sumPort)})`);
+        } else shellExec(`sudo kill -9 $(lsof -t -i:${_path})`);
+      }
     },
     /**
      * @method secret
@@ -274,7 +303,7 @@ class UnderpostRun {
      * @param {Object} options - The default underpost runner options for customizing workflow
      * @memberof UnderpostRun
      */
-    'template-deploy': (path, options = UnderpostRun.DEFAULT_OPTION) => {
+    'template-deploy': (path = '', options = UnderpostRun.DEFAULT_OPTION) => {
       const baseCommand = options.dev ? 'node bin' : 'underpost';
       shellExec(`${baseCommand} run clean`);
       shellExec(
@@ -314,16 +343,25 @@ class UnderpostRun {
     },
     /**
      * @method pull
-     * @description Cleans the core repository and pulls the latest content for `engine` and `engine-private` repositories from the remote.
+     * @description Clones or pulls updates for the `engine` and `engine-private` repositories into `/home/dd/engine` and `/home/dd/engine/engine-private`.
      * @param {string} path - The input value, identifier, or path for the operation.
      * @param {Object} options - The default underpost runner options for customizing workflow
      * @memberof UnderpostRun
      */
     pull: (path, options = UnderpostRun.DEFAULT_OPTION) => {
-      shellCd(`/home/dd/engine`);
-      shellExec(`node bin/deploy clean-core-repo`);
-      shellExec(`underpost pull . ${process.env.GITHUB_USERNAME}/engine`);
-      shellExec(`underpost pull ./engine-private ${process.env.GITHUB_USERNAME}/engine-private`);
+      if (!fs.existsSync(`/home/dd`) || !fs.existsSync(`/home/dd/engine`)) {
+        fs.mkdirSync(`/home/dd`, { recursive: true });
+        shellExec(`cd /home/dd && underpost clone ${process.env.GITHUB_USERNAME}/engine`);
+      } else {
+        shellExec(`underpost run clean`);
+        shellExec(`cd /home/dd/engine && underpost pull . ${process.env.GITHUB_USERNAME}/engine`);
+      }
+      if (!fs.existsSync(`/home/dd/engine/engine-private`))
+        shellExec(`cd /home/dd/engine && underpost clone ${process.env.GITHUB_USERNAME}/engine-private`);
+      else
+        shellExec(
+          `cd /home/dd/engine/engine-private && underpost pull . ${process.env.GITHUB_USERNAME}/engine-private`,
+        );
     },
     /**
      * @method release-deploy
@@ -412,7 +450,7 @@ class UnderpostRun {
 
       shellExec(
         `${baseCommand} deploy --kubeadm --build-manifest --sync --info-router --replicas ${
-          replicas ?? 1
+          replicas ? replicas : 1
         } --node ${node}${image ? ` --image ${image}` : ''}${versions ? ` --versions ${versions}` : ''} dd ${env}`,
       );
 
@@ -433,6 +471,16 @@ class UnderpostRun {
     'ls-deployments': async (path, options = UnderpostRun.DEFAULT_OPTION) => {
       console.table(await UnderpostDeploy.API.get(path, 'deployments'));
     },
+    /**
+     * @method ls-images
+     * @description Retrieves and logs a table of currently loaded Docker images in the 'kind-worker' node using `UnderpostDeploy.API.getCurrentLoadedImages`.
+     * @param {string} path - The input value, identifier, or path for the operation.
+     * @param {Object} options - The default underpost runner options for customizing workflow
+     * @memberof UnderpostRun
+     */
+    'ls-images': async (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      console.table(UnderpostDeploy.API.getCurrentLoadedImages('kind-worker', false));
+    },
 
     /**
      * @method host-update
@@ -447,6 +495,43 @@ class UnderpostRun {
       shellExec(`${options.underpostRoot}/scripts/rocky-setup.sh --yes${options.dev ? ' --install-dev' : ``}`);
     },
 
+    /**
+     * @method dev-container
+     * @description Runs a development container pod named `underpost-dev-container` with specified volume mounts and opens a terminal to follow its logs.
+     * @param {string} path - The input value, identifier, or path for the operation (used as an optional command to run inside the container).
+     * @param {Object} options - The default underpost runner options for customizing workflow
+     * @memberof UnderpostRun
+     */
+    'dev-container': async (path = '', options = UnderpostRun.DEFAULT_OPTION) => {
+      options.dev = true;
+      const baseCommand = options.dev ? 'node bin' : 'underpost';
+      const baseClusterCommand = options.dev ? ' --dev' : '';
+      const currentImage = UnderpostDeploy.API.getCurrentLoadedImages('kind-worker', false).find((o) =>
+        o.IMAGE.match('underpost'),
+      );
+      const podName = `underpost-dev-container`;
+      if (!UnderpostDeploy.API.existsContainerFile({ podName: 'kind-worker', path: '/home/dd/engine' })) {
+        shellExec(`docker exec -i kind-worker bash -c "mkdir -p /home/dd"`);
+        shellExec(`docker cp /home/dd/engine kind-worker:/home/dd/engine`);
+        shellExec(`docker exec -i kind-worker bash -c "chown -R 1000:1000 /home/dd || true; chmod -R 755 /home/dd"`);
+      }
+      if (!currentImage) shellExec(`${baseCommand} dockerfile-pull-base-images${baseClusterCommand} --kind-load`);
+      // shellExec(`kubectl delete pod ${podName} --ignore-not-found`);
+      await UnderpostRun.RUNNERS['deploy-job']('', {
+        dev: true,
+        podName,
+        imageName: currentImage ? currentImage.image : `localhost/rockylinux9-underpost:${Underpost.version}`,
+        volumeHostPath: '/home/dd',
+        volumeMountPath: '/home/dd',
+        on: {
+          init: async () => {
+            // openTerminal(`kubectl logs -f ${podName}`);
+          },
+        },
+        args: [daemonProcess(path ? path : `cd /home/dd/engine && npm run test`)],
+      });
+    },
+
     /**
      * @method monitor
      * @description Monitors a specific pod (identified by `path`) for the existence of a file (`/await`), and performs conditional actions (like file copying and opening Firefox) when the file is removed.
@@ -564,10 +649,16 @@ class UnderpostRun {
      * @memberof UnderpostRun
      */
     'git-conf': (path = '', options = UnderpostRun.DEFAULT_OPTION) => {
-      const defaultUsername = UnderpostRootEnv.API.get('GITHUB_USERNAME', '', { disableLog: true });
-      const defaultEmail = UnderpostRootEnv.API.get('GITHUB_EMAIL', '', { disableLog: true });
-      const [username, email] = path && path.split(',').length > 0 ? path.split(',') : [defaultUsername, defaultEmail];
-
+      const defaultUsername = UnderpostRootEnv.API.get('GITHUB_USERNAME');
+      const defaultEmail = UnderpostRootEnv.API.get('GITHUB_EMAIL');
+      const validPath = path && path.split(',').length;
+      const [username, email] = validPath ? path.split(',') : [defaultUsername, defaultEmail];
+      if (validPath) {
+        UnderpostRootEnv.API.set('GITHUB_USERNAME', username);
+        UnderpostRootEnv.API.set('GITHUB_EMAIL', email);
+        UnderpostRootEnv.API.get('GITHUB_USERNAME');
+        UnderpostRootEnv.API.get('GITHUB_EMAIL');
+      }
       shellExec(
         `git config --global credential.helper "" && ` +
           `git config credential.helper "" && ` +
@@ -706,6 +797,120 @@ class UnderpostRun {
       UnderpostDeploy.API.switchTraffic(deployId, env, targetTraffic);
     },
 
+    /**
+     * @method dev
+     * @description Starts development servers for client, API, and proxy based on provided parameters (deployId, host, path, clientHostPort).
+     * @param {string} path - The input value, identifier, or path for the operation (formatted as `deployId,subConf,host,path,clientHostPort`).
+     * @param {Object} options - The default underpost runner options for customizing workflow
+     * @memberof UnderpostRun
+     */
+    dev: async (path = '', options = UnderpostRun.DEFAULT_OPTION) => {
+      let [deployId, subConf, host, _path, clientHostPort] = path.split(',');
+      if (!deployId) deployId = 'dd-default';
+      if (!host) host = 'default.net';
+      if (!_path) _path = '/';
+      if (!clientHostPort) clientHostPort = 'localhost:4004';
+      if (!subConf) subConf = 'local';
+      if (options.reset && fs.existsSync(`./engine-private/conf/${deployId}`))
+        fs.removeSync(`./engine-private/conf/${deployId}`);
+      if (!fs.existsSync(`./engine-private/conf/${deployId}`)) Config.deployIdFactory(deployId, { subConf });
+      if (options.devProxyPortOffset) {
+        const envPath = `./engine-private/conf/${deployId}/.env.development`;
+        const envObj = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
+        envObj.DEV_PROXY_PORT_OFFSET = options.devProxyPortOffset;
+        writeEnv(envPath, envObj);
+      }
+      shellExec(`node bin run dev-cluster expose`);
+      {
+        const cmd = `npm run dev-api ${deployId} ${subConf} ${host} ${_path} ${clientHostPort}${options.tls ? ' tls' : ''}`;
+        options.terminal ? openTerminal(cmd) : shellExec(cmd, { async: true });
+      }
+      await awaitDeployMonitor(true);
+      {
+        const cmd = `npm run dev-client ${deployId} ${subConf} ${host} ${_path} proxy${options.tls ? ' tls' : ''}`;
+        options.terminal
+          ? openTerminal(cmd)
+          : shellExec(cmd, {
+              async: true,
+            });
+      }
+      await awaitDeployMonitor(true);
+      shellExec(`npm run dev-proxy ${deployId} ${subConf} ${host} ${_path}${options.tls ? ' tls' : ''}`);
+    },
+
+    /**
+     * @method service
+     * @description Deploys and exposes specific services (like `mongo-express-service`) on the cluster, updating deployment configurations and monitoring status.
+     * @param {string} path - The input value, identifier, or path for the operation (formatted as `deployId,serviceId,host,path,replicas,image,node`).
+     * @param {Object} options - The default underpost runner options for customizing workflow
+     * @memberof UnderpostRun
+     */
+    service: async (path = '', options = UnderpostRun.DEFAULT_OPTION) => {
+      const env = options.dev ? 'development' : 'production';
+      const baseCommand = options.dev ? 'node bin' : 'underpost';
+      // const baseClusterCommand = options.dev ? ' --dev' : '';
+      shellCd(`/home/dd/engine`);
+      let [deployId, serviceId, host, _path, replicas, image, node] = path.split(',');
+      const services = fs.existsSync(`./engine-private/deploy/${deployId}/conf.services.json`)
+        ? JSON.parse(fs.readFileSync(`./engine-private/deploy/${deployId}/conf.services.json`, 'utf8'))
+        : [];
+      switch (serviceId) {
+        case 'mongo-express-service': {
+          let serviceData = services.findIndex((s) => s.serviceId === serviceId);
+          const payload = {
+            serviceId,
+            path: _path,
+            port: 8081,
+            host,
+          };
+          if (serviceData == -1) {
+            services.push(payload);
+          } else {
+            services[serviceData] = payload;
+          }
+          fs.writeFileSync(
+            `./engine-private/conf/${deployId}/conf.services.json`,
+            JSON.stringify(services, null, 4),
+            'utf8',
+          );
+          shellExec(`kubectl delete svc mongo-express-service --ignore-not-found`);
+          shellExec(`kubectl delete deployment mongo-express --ignore-not-found`);
+          shellExec(`kubectl apply -f manifests/deployment/mongo-express/deployment.yaml`);
+
+          const success = await UnderpostTest.API.statusMonitor('mongo-express');
+
+          if (success) {
+            const versions = UnderpostDeploy.API.getCurrentTraffic(deployId) || 'blue';
+            if (!node) node = os.hostname();
+            shellExec(
+              `${baseCommand} deploy --kubeadm --build-manifest --sync --info-router --replicas ${
+                replicas ? replicas : 1
+              } --node ${node}${image ? ` --image ${image}` : ''}${versions ? ` --versions ${versions}` : ''} dd ${env}`,
+            );
+            shellExec(
+              `${baseCommand} deploy --kubeadm --disable-update-deployment ${deployId} ${env} --versions ${versions}`,
+            );
+          } else logger.error('Mongo Express deployment failed');
+          break;
+        }
+      }
+    },
+
+    /**
+     * @method release-cmt
+     * @description Commits and pushes a new release for the `engine` repository with a message indicating the new version.
+     * @param {string} path - The input value, identifier, or path for the operation.
+     * @param {Object} options - The default underpost runner options for customizing workflow
+     * @memberof UnderpostRun
+     */
+    'release-cmt': async (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      shellExec(`underpost run pull`);
+      shellExec(`underpost run secret`);
+      shellCd(`/home/dd/engine`);
+      shellExec(`underpost cmt --empty . ci engine ' New engine release $(underpost --version)'`);
+      shellExec(`underpost push . ${process.env.GITHUB_USERNAME}/engine`);
+    },
+
     /**
      * @method sync-replica
      * @description Syncs a replica for the dd.router
@@ -794,6 +999,9 @@ class UnderpostRun {
       const volumeMountPath = options.volumeMountPath || path;
       const volumeHostPath = options.volumeHostPath || path;
       const enableVolumeMount = volumeHostPath && volumeMountPath;
+      const tty = options.tty ? 'true' : 'false';
+      const stdin = options.stdin ? 'true' : 'false';
+      const restartPolicy = options.restartPolicy || 'Never';
 
       if (options.volumeType === 'dev') options.volumeType = 'FileOrCreate';
       const volumeType =
@@ -807,15 +1015,17 @@ kind: Pod
 metadata:
   name: ${podName}
   namespace: ${namespace}
+  labels:
+    app: ${podName}
 spec:
-  restartPolicy: Never
+  restartPolicy: ${restartPolicy}
 ${runtimeClassName ? `  runtimeClassName: ${runtimeClassName}` : ''}
   containers:
     - name: ${containerName}
       image: ${imageName}
       imagePullPolicy: IfNotPresent
-      tty: true
-      stdin: true
+      tty: ${tty}
+      stdin: ${stdin}
       command: ${JSON.stringify(options.command ? options.command : ['/bin/bash', '-c'])}
 ${
   args.length > 0
@@ -851,7 +1061,7 @@ ${
     : ''
 }
 EOF`;
-      shellExec(`kubectl delete pod ${podName}`);
+      shellExec(`kubectl delete pod ${podName} --ignore-not-found`);
       console.log(cmd);
       shellExec(cmd, { disableLog: true });
       const successInstance = await UnderpostTest.API.statusMonitor(podName);

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

@@ -101,6 +101,7 @@ const cap = (str) =>
 
 const capFirst = (str) => str.charAt(0).toUpperCase() + str.slice(1);
 
+// Other option: Array.from(new Set(arr))
 const uniqueArray = (arr) => arr.filter((item, pos) => arr.indexOf(item) == pos);
 
 const orderArrayFromAttrInt = (arr, attr, type) =>

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

@@ -35,8 +35,12 @@ const SocketIo = {
       // forceNew: true,
       // reconnectionAttempts: 'Infinity',
       // timeout: 10000,
-      // withCredentials: true,
       // autoConnect: 5000,
+      // Custom auth socket io credentials:
+      withCredentials: true,
+      extraHeaders: {
+        //   "my-custom-header": "abcd"
+      },
       transports: ['websocket', 'polling', 'flashsocket'],
     };
     // logger.error(`connect options:`, JSON.stringify(connectOptions, null, 4));