underpost 2.8.82 → 2.8.85

package/src/cli/index.js

@@ -4,9 +4,9 @@ import Underpost from '../index.js';
 import { getNpmRootPath, getUnderpostRootPath, loadConf } from '../server/conf.js';
 import fs from 'fs-extra';
 import { commitData } from '../client/components/core/CommonJs.js';
-import { shellExec } from '../server/process.js';
 import UnderpostLxd from './lxd.js';
 import UnderpostBaremetal from './baremetal.js';
+import UnderpostRun from './run.js';
 
 // Load environment variables from .env file
 const underpostRootPath = getUnderpostRootPath();
@@ -112,6 +112,7 @@ program
   .option('--mariadb', 'Initializes the cluster with a MariaDB statefulset.')
   .option('--mysql', 'Initializes the cluster with a MySQL statefulset.')
   .option('--mongodb', 'Initializes the cluster with a MongoDB statefulset.')
+  .option('--mongo-db-host <host>', 'Set custom mongo db host')
   .option('--postgresql', 'Initializes the cluster with a PostgreSQL statefulset.')
   .option('--mongodb4', 'Initializes the cluster with a MongoDB 4.4 service.')
   .option('--valkey', 'Initializes the cluster with a Valkey service.')
@@ -128,6 +129,7 @@ program
   .option('--info-capacity-pod', 'Displays the current machine capacity information per pod.')
   .option('--pull-image', 'Sets an optional associated image to pull during initialization.')
   .option('--init-host', 'Installs necessary Kubernetes node CLI tools (e.g., kind, kubeadm, docker, podman, helm).')
+  .option('--uninstall-host', 'Uninstalls all host components installed by init-host.')
   .option('--config', 'Sets the base Kubernetes node configuration.')
   .option('--worker', 'Sets the context for a worker node.')
   .option('--chown', 'Sets the appropriate ownership for Kubernetes kubeconfig files.')
@@ -314,6 +316,31 @@ program
   .description('Manages health server monitoring for specified deployments.')
   .action(Underpost.monitor.callback);
 
+// 'ssh' command: SSH management
+program
+  .command('ssh')
+  .option('--generate', 'Generates new ssh credential and stores it in current private keys file storage.')
+  .description('Import and start ssh server and client based on current default deployment ID.')
+  .action(Underpost.ssh.callback);
+
+// 'run' command: Run a script
+program
+  .command('run')
+  .argument('<runner-id>', `The runner ID to run. Options: ${Object.keys(UnderpostRun.RUNNERS).join(', ')}.`)
+  .argument('[path]', 'The absolute or relative directory path where the script is located.')
+  .option('--command <command-array>', 'Array of commands to run.')
+  .option('--args <args-array>', 'Array of arguments to pass to the command.')
+  .option('--dev', 'Sets the development context environment for the script.')
+  .option('--pod-name <pod-name>', 'Optional: Specifies the pod name for test execution.')
+  .option('--volume-host-path <volume-host-path>', 'Optional: Specifies the volume host path for test execution.')
+  .option('--volume-mount-path <volume-mount-path>', 'Optional: Specifies the volume mount path for test execution.')
+  .option('--volume-type <volume-type>', 'Optional: Specifies the volume type for test execution.')
+  .option('--image-name <image-name>', 'Optional: Specifies the image name for test execution.')
+  .option('--container-name <container-name>', 'Optional: Specifies the container name for test execution.')
+  .option('--namespace <namespace>', 'Optional: Specifies the namespace for test execution.')
+  .description('Runs a script from the specified path.')
+  .action(UnderpostRun.API.callback);
+
 // 'lxd' command: LXD management
 program
   .command('lxd')

package/src/cli/monitor.js

@@ -173,19 +173,15 @@ class UnderpostMonitor {
                     monitorTrafficName = undefined;
                     monitorPodName = undefined;
                   }
-                  const cmd = `underpost config get container-status`;
                   const checkDeploymentReadyStatus = () => {
-                    const pods = UnderpostDeploy.API.get(`${deployId}-${env}-${traffic}`);
-                    if (pods && pods[0]) {
-                      const { NAME } = pods[0];
-                      if (
-                        shellExec(`sudo kubectl exec -i ${NAME} -- sh -c "${cmd}"`, { stdout: true }).match(
-                          `${deployId}-${env}-running-deployment`,
-                        )
-                      ) {
-                        monitorPodName = NAME;
-                        monitorTrafficName = `${traffic}`;
-                      }
+                    const { ready, notReadyPods, readyPods } = UnderpostDeploy.API.checkDeploymentReadyStatus(
+                      deployId,
+                      env,
+                      traffic,
+                    );
+                    if (ready) {
+                      monitorPodName = readyPods[0].NAME;
+                      monitorTrafficName = `${traffic}`;
                     }
                   };
                   if (!monitorPodName) {

package/src/cli/repository.js

@@ -60,7 +60,7 @@ class UnderpostRepository {
     },
 
     push(repoPath = './', gitUri = 'underpostnet/pwa-microservices-template', options = { f: false, g8: false }) {
-      const gExtension = options.g8 === true ? '.g8' : '.git';
+      const gExtension = options.g8 === true || options.G8 === true ? '.g8' : '.git';
       shellExec(
         `cd ${repoPath} && git push https://${process.env.GITHUB_TOKEN}@github.com/${gitUri}${gExtension}${
           options?.f === true ? ' --force' : ''
@@ -71,9 +71,12 @@ class UnderpostRepository {
       );
       logger.info(
         'commit url',
-        `http://github.com/${gitUri}/commit/${shellExec(`cd ${repoPath} && git rev-parse --verify HEAD`, {
-          stdout: true,
-        }).trim()}`,
+        `http://github.com/${gitUri}${gExtension === '.g8' ? '.g8' : ''}/commit/${shellExec(
+          `cd ${repoPath} && git rev-parse --verify HEAD`,
+          {
+            stdout: true,
+          },
+        ).trim()}`,
       );
     },
 

package/src/cli/run.js

@@ -0,0 +1,367 @@
+import { daemonProcess, getTerminalPid, openTerminal, pbcopy, shellCd, shellExec } from '../server/process.js';
+import read from 'read';
+import { getNpmRootPath } from '../server/conf.js';
+import { loggerFactory } from '../server/logger.js';
+import UnderpostTest from './test.js';
+import fs from 'fs-extra';
+import { range, setPad, timer } from '../client/components/core/CommonJs.js';
+import UnderpostDeploy from './deploy.js';
+import UnderpostRootEnv from './env.js';
+
+const logger = loggerFactory(import.meta);
+
+class UnderpostRun {
+  static DEFAULT_OPTION = {
+    dev: false,
+    podName: '',
+    volumeHostPath: '',
+    volumeMountPath: '',
+    imageName: '',
+    containerName: '',
+    namespace: '',
+  };
+  static RUNNERS = {
+    'spark-template': (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      const dir = '/home/dd/spark-template';
+      shellExec(`sudo rm -rf ${dir}`);
+      shellCd('/home/dd');
+
+      // pbcopy(`cd /home/dd && sbt new underpostnet/spark-template.g8`);
+      // await read({ prompt: 'Command copy to clipboard, press enter to continue.\n' });
+      shellExec(`cd /home/dd && sbt new underpostnet/spark-template.g8 '--name=spark-template'`);
+
+      shellCd(dir);
+
+      shellExec(`git init && git add . && git commit -m "Base implementation"`);
+      shellExec(`chmod +x ./replace_params.sh`);
+      shellExec(`chmod +x ./build.sh`);
+
+      shellExec(`./replace_params.sh`);
+      shellExec(`./build.sh`);
+
+      shellCd('/home/dd/engine');
+    },
+    rmi: (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      shellExec(`podman rmi $(podman images -qa) --force`);
+    },
+    kill: (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      shellExec(`sudo kill -9 $(lsof -t -i:${path})`);
+    },
+    secret: (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      shellExec(
+        `underpost secret underpost --create-from-file ${
+          path ? path : `/home/dd/engine/engine-private/conf/dd-cron/.env.production`
+        }`,
+      );
+    },
+    'gpu-env': (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      shellExec(
+        `node bin cluster --dev --reset && node bin cluster --dev --dedicated-gpu --kubeadm && kubectl get pods --all-namespaces -o wide -w`,
+      );
+    },
+    'tf-gpu-test': (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      const { underpostRoot } = options;
+      shellExec(`kubectl delete configmap tf-gpu-test-script`);
+      shellExec(`kubectl delete pod tf-gpu-test-pod`);
+      shellExec(`kubectl apply -f ${underpostRoot}/manifests/deployment/tensorflow/tf-gpu-test.yaml`);
+    },
+    'dev-cluster': (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      const baseCommand = options.dev ? 'node bin' : 'underpost';
+      shellExec(`${baseCommand} cluster${options.dev ? ' --dev' : ''} --reset`);
+      shellExec(`${baseCommand} cluster${options.dev ? ' --dev' : ''}`);
+      shellExec(
+        `${baseCommand} cluster${options.dev ? ' --dev' : ''} --mongodb --mongo-db-host ${'127.0.0.1'} --pull-image`,
+      );
+      shellExec(`${baseCommand} cluster${options.dev ? ' --dev' : ''} --valkey --pull-image`);
+      shellExec(`${baseCommand} deploy --expose mongo`, { async: true });
+      shellExec(`${baseCommand} deploy --expose valkey`, { async: true });
+    },
+    'cyberia-ide': (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      const baseCommand = options.dev ? 'node bin' : 'underpost';
+      shellExec(`${baseCommand} run ide /home/dd/cyberia-server`);
+      shellExec(`${baseCommand} run ide /home/dd/cyberia-client`);
+    },
+    'engine-ide': (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      const baseCommand = options.dev ? 'node bin' : 'underpost';
+      shellExec(`${baseCommand} run ide /home/dd/engine`);
+      shellExec(`${baseCommand} run ide /home/dd/engine/engine-private`);
+    },
+    'template-deploy': (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      const baseCommand = options.dev || true ? 'node bin' : 'underpost';
+      shellCd('/home/dd/engine');
+      shellExec(`git reset`);
+      shellExec(`${baseCommand} cmt . --empty ci package-pwa-microservices-template`);
+      shellExec(`${baseCommand} push . underpostnet/engine`);
+    },
+    'ssh-deploy': (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      const baseCommand = options.dev || true ? 'node bin' : 'underpost';
+      shellCd('/home/dd/engine');
+      shellExec(`git reset`);
+      shellExec(`${baseCommand} cmt . --empty cd ssh-${path}`);
+      shellExec(`${baseCommand} push . underpostnet/engine`);
+    },
+    ide: (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      const { underpostRoot } = options;
+      shellExec(`node ${underpostRoot}/bin/vs ${path}`);
+    },
+    monitor: (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      const pid = getTerminalPid();
+      logger.info('monitor pid', pid);
+      const checkPath = '/await';
+      const _monitor = async () => {
+        const result = UnderpostDeploy.API.existsContainerFile({ podName: path, path: checkPath });
+        logger.info('monitor', result);
+        if (result === true) {
+          switch (path) {
+            case 'tf-vae-test':
+              {
+                const nameSpace = 'default';
+                const podName = path;
+                const basePath = '/home/dd';
+                const scriptPath = '/site/en/tutorials/generative/cvae.py';
+                // shellExec(
+                //   `sudo kubectl cp ${nameSpace}/${podName}:${basePath}/docs${scriptPath} ${basePath}/lab/src/${scriptPath
+                //     .split('/')
+                //     .pop()}`,
+                // );
+                // const file = fs.readFileSync(`${basePath}/lab/src/${scriptPath.split('/').pop()}`, 'utf8');
+                //                 fs.writeFileSync(
+                //                   `${basePath}/lab/src/${scriptPath.split('/').pop()}`,
+                //                   file.replace(
+                //                     `import time`,
+                //                     `import time
+                // print('=== SCRIPT UPDATE TEST ===')`,
+                //                   ),
+                //                   'utf8',
+                //                 );
+                shellExec(
+                  `sudo kubectl cp ${basePath}/lab/src/${scriptPath
+                    .split('/')
+                    .pop()} ${nameSpace}/${podName}:${basePath}/docs${scriptPath}`,
+                );
+                // shellExec(`sudo kubectl exec -i ${podName} -- sh -c "ipython ${basePath}/docs${scriptPath}"`);
+                shellExec(`sudo kubectl exec -i ${podName} -- sh -c "rm -rf ${checkPath}"`);
+
+                {
+                  const checkPath = `/latent_space_plot.png`;
+                  const outsPaths = [];
+                  logger.info('monitor', checkPath);
+                  while (!UnderpostDeploy.API.existsContainerFile({ podName, path: `/home/dd/docs${checkPath}` }))
+                    await timer(1000);
+
+                  {
+                    const toPath = `${basePath}/lab${checkPath}`;
+                    outsPaths.push(toPath);
+                    shellExec(`sudo kubectl cp ${nameSpace}/${podName}:${basePath}/docs${checkPath} ${toPath}`);
+                  }
+
+                  for (let i of range(1, 10)) {
+                    i = `/image_at_epoch_${setPad(i, '0', 4)}.png`;
+                    const toPath = `${basePath}/lab/${i}`;
+                    outsPaths.push(toPath);
+                    shellExec(`sudo kubectl cp ${nameSpace}/${podName}:${basePath}/docs${i} ${toPath}`);
+                  }
+                  openTerminal(`firefox ${outsPaths.join(' ')}`, { single: true });
+                }
+                shellExec(`sudo kill -9 ${pid}`);
+              }
+              break;
+
+            default:
+              break;
+          }
+          return;
+        }
+        await timer(1000);
+        _monitor();
+      };
+      _monitor();
+    },
+    'db-client': async (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      const { underpostRoot } = options;
+      shellExec(`kubectl apply -k ${underpostRoot}/manifests/deployment/adminer/.`);
+    },
+    cluster: async (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      const deployList = fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8').split(',');
+      const env = 'production';
+      shellCd(`/home/dd/engine`);
+      shellExec(`underpost cluster --reset`);
+      await timer(5000);
+      shellExec(`underpost cluster --kubeadm`);
+      await timer(5000);
+      shellExec(`underpost dockerfile-pull-base-images --path /home/dd/engine/src/runtime/lampp --kubeadm-load`);
+      await timer(5000);
+      shellExec(`underpost cluster --kubeadm --pull-image --mongodb`);
+      await timer(5000);
+      shellExec(`underpost cluster --kubeadm --pull-image --mariadb`);
+      await timer(5000);
+      for (const deployId of deployList) {
+        shellExec(`underpost db ${deployId} --import --git`);
+      }
+      await timer(5000);
+      shellExec(`underpost cluster --kubeadm --pull-image --valkey`);
+      await timer(5000);
+      shellExec(`underpost cluster --kubeadm --contour`);
+      await timer(5000);
+      shellExec(`underpost cluster --kubeadm --cert-manager`);
+      for (const deployId of deployList) {
+        shellExec(`underpost deploy ${deployId} ${env} --kubeadm --cert`);
+      }
+    },
+    deploy: async (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      const deployId = path;
+      const currentTraffic = UnderpostDeploy.API.getCurrentTraffic(deployId);
+      const targetTraffic = currentTraffic === 'blue' ? 'green' : 'blue';
+      const env = 'production';
+      const ignorePods = UnderpostDeploy.API.get(`${deployId}-${env}-${targetTraffic}`).map((p) => p.NAME);
+      shellExec(`sudo kubectl rollout restart deployment/${deployId}-${env}-${targetTraffic}`);
+
+      let secondsElapsed = 0;
+      logger.info('Deployment init', { deployId, env, targetTraffic });
+
+      while (!UnderpostDeploy.API.checkDeploymentReadyStatus(deployId, env, targetTraffic, ignorePods).ready) {
+        await timer(1000);
+        secondsElapsed++;
+        logger.info(`Deployment in progress, seconds elapsed: ${secondsElapsed}`);
+      }
+
+      logger.info(`Deployment ready, seconds elapsed: ${secondsElapsed}`);
+
+      UnderpostRootEnv.API.set(`${deployId}-${env}-traffic`, targetTraffic);
+
+      shellExec(
+        `node bin deploy --info-router --build-manifest --traffic ${targetTraffic} --replicas ${
+          options.replicas ? options.replicas : 1
+        } ${deployId} ${env}`,
+      );
+      shellExec(`sudo kubectl apply -f ./engine-private/conf/${deployId}/build/${env}/proxy.yaml`);
+      shellExec(`sudo kubectl rollout restart deployment/${deployId}-${env}-${currentTraffic}`);
+    },
+    'tf-vae-test': async (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      const { underpostRoot } = options;
+      const podName = 'tf-vae-test';
+      await UnderpostRun.RUNNERS['deploy-job']('', {
+        podName,
+        // volumeMountPath: '/custom_images',
+        // volumeHostPath: '/home/dd/engine/src/client/public/cyberia/assets/skin',
+        on: {
+          init: async () => {
+            openTerminal(`node bin run --dev monitor ${podName}`);
+          },
+        },
+        args: [
+          `pip install --upgrade \
+               nbconvert \
+               tensorflow-probability==0.23.0 \
+               imageio \
+               git+https://github.com/tensorflow/docs \
+               matplotlib \
+               "numpy<1.25,>=1.21"`,
+          'mkdir -p /home/dd',
+          'cd /home/dd',
+          'git clone https://github.com/tensorflow/docs.git',
+          'cd docs',
+          'jupyter nbconvert --to python site/en/tutorials/generative/cvae.ipynb',
+          `echo '' > /await`,
+          `echo '=== WAITING SCRIPT LAUNCH ==='`,
+          `while [ -f /await ]; do sleep 1; done`,
+          `echo '=== FINISHED ==='`,
+          daemonProcess(`ipython site/en/tutorials/generative/cvae.py`),
+        ],
+      });
+    },
+    'deploy-job': async (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      const podName = options.podName || 'deploy-job';
+      const volumeName = `${podName}-volume`;
+      const args = (options.args ? options.args : path ? [`python ${path}`] : []).filter((c) => c.trim());
+      const imageName = options.imageName || 'nvcr.io/nvidia/tensorflow:24.04-tf2-py3';
+      const containerName = options.containerName || `${podName}-container`;
+      const gpuEnable = imageName.match('nvidia');
+      const runtimeClassName = gpuEnable ? 'nvidia' : '';
+      const namespace = options.namespace || 'default';
+      const volumeMountPath = options.volumeMountPath || path;
+      const volumeHostPath = options.volumeHostPath || path;
+      const enableVolumeMount = volumeHostPath && volumeMountPath;
+
+      if (options.volumeType === 'dev') options.volumeType = 'FileOrCreate';
+      const volumeType =
+        options.volumeType || (enableVolumeMount && fs.statSync(volumeHostPath).isDirectory()) ? 'Directory' : 'File';
+
+      const envs = UnderpostRootEnv.API.list();
+
+      const cmd = `kubectl apply -f - <<EOF
+apiVersion: v1
+kind: Pod
+metadata:
+  name: ${podName}
+  namespace: ${namespace}
+spec:
+  restartPolicy: Never
+${runtimeClassName ? `  runtimeClassName: ${runtimeClassName}` : ''}
+  containers:
+    - name: ${containerName}
+      image: ${imageName}
+      imagePullPolicy: IfNotPresent
+      tty: true
+      stdin: true
+      command: ${JSON.stringify(options.command ? options.command : ['/bin/bash', '-c'])}
+${
+  args.length > 0
+    ? `      args:
+        - |
+${args.map((arg) => `          ${arg}`).join('\n')}`
+    : ''
+}
+${`${
+  gpuEnable
+    ? `      resources:
+        limits:
+          nvidia.com/gpu: '1'
+`
+    : ''
+}      env:
+${Object.keys(envs)
+  .map((key) => ({ key, value: typeof envs[key] === 'number' ? envs[key] : `"${envs[key]}"` }))
+  .concat(gpuEnable ? [{ key: 'NVIDIA_VISIBLE_DEVICES', value: 'all' }] : [])
+  .map((env) => `        - name: ${env.key}\n          value: ${env.value}`)
+  .join('\n')}`}
+${
+  enableVolumeMount
+    ? `
+      volumeMounts:
+        - name: ${volumeName}
+          mountPath: ${volumeMountPath}
+  volumes:
+    - name: ${volumeName}
+      hostPath:
+        path: ${volumeHostPath}
+        type: ${volumeType}`
+    : ''
+}
+EOF`;
+      shellExec(`kubectl delete pod ${podName}`);
+      console.log(cmd);
+      shellExec(cmd, { disableLog: true });
+      const successInstance = await UnderpostTest.API.statusMonitor(podName);
+      if (successInstance) {
+        options.on?.init ? await options.on.init() : null;
+        shellExec(`kubectl logs -f ${podName}`);
+      }
+    },
+  };
+  static API = {
+    async callback(runner, path, options = UnderpostRun.DEFAULT_OPTION) {
+      const npmRoot = getNpmRootPath();
+      const underpostRoot = options?.dev === true ? '.' : `${npmRoot}/underpost`;
+      if (options.command) options.command = options.command.split(',');
+      if (options.args) options.args = options.args.split(',');
+      options.underpostRoot = underpostRoot;
+      options.npmRoot = npmRoot;
+      logger.info('callback', { path, options });
+      const result = await UnderpostRun.RUNNERS[runner](path, options);
+      return result;
+    },
+  };
+}
+
+export default UnderpostRun;

package/src/cli/ssh.js

@@ -0,0 +1,32 @@
+import { getNpmRootPath } from '../server/conf.js';
+import { shellExec } from '../server/process.js';
+
+class UnderpostSSH {
+  static API = {
+    /**
+     * @method callback
+     * @param {object} options
+     * @param {boolean} options.generate - Generates new ssh credential and stores it in current private keys file storage.
+     * @description Import and start ssh server and client based on current default deployment ID.
+     */
+    callback: async (
+      options = {
+        generate: false,
+      },
+    ) => {
+      // only import + start
+      // node bin/deploy ssh root@<host> <password> import
+
+      // generate + import + start
+      // node bin/deploy ssh root@<host> <password>
+
+      shellExec(
+        `node bin/deploy ssh root@${process.env.DEFAULT_DEPLOY_HOST} ${process.env.DEFAULT_DEPLOY_PASSWORD ?? `''`}${
+          options.generate === true ? '' : ' import'
+        }`,
+      );
+    },
+  };
+}
+
+export default UnderpostSSH;

package/src/cli/test.js

@@ -94,7 +94,7 @@ class UnderpostTest {
         const _monitor = async () => {
           await timer(deltaMs);
           const pods = UnderpostDeploy.API.get(podName, kindType);
-          const result = pods.find((p) => p.STATUS === status);
+          let result = pods.find((p) => p.STATUS === status || (status === 'Running' && p.STATUS === 'Completed'));
           logger.info(
             `Testing pod ${podName}... ${result ? 1 : 0}/1 - elapsed time ${deltaMs * (index + 1)}s - attempt ${
               index + 1

package/src/client/Default.index.js

@@ -16,21 +16,25 @@ import { SocketIo } from './components/core/SocketIo.js';
 import { SocketIoDefault } from './components/default/SocketIoDefault.js';
 import { ElementsDefault } from './components/default/ElementsDefault.js';
 import { Scroll } from './components/core/Scroll.js';
+import { CssDefaultDark, CssDefaultLight } from './components/default/CssDefault.js';
 
 const htmlMainBody = async () => {
-  return html`<span style="color: black; padding: 5px">Hello World!!</span>`;
+  return html`<span>Hello World!!</span>`;
 };
 
 window.onload = () =>
   Worker.instance({
     router: RouterDefault,
     render: async () => {
-      await Css.loadThemes();
+      await Css.loadThemes([CssDefaultLight, CssDefaultDark]);
       await TranslateCore.Init();
       await TranslateDefault.Init();
       await Responsive.Init();
       await MenuDefault.Render({ htmlMainBody });
-      await SocketIo.Init({ channels: ElementsDefault.Data });
+      await SocketIo.Init({
+        channels: ElementsDefault.Data,
+        path: `/`,
+      });
       await SocketIoDefault.Init();
       await LogInDefault();
       await LogOutDefault();

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

@@ -44,7 +44,7 @@ const Account = {
         { model: 'email', id: `account-email`, rules: [{ type: 'isEmpty' }, { type: 'isEmail' }] },
         {
           model: 'password',
-          defaultValue: '*******',
+          defaultValue: '#Changethis123',
           id: `account-password`,
           rules: [{ type: 'isStrongPassword' }],
         },

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

@@ -53,7 +53,7 @@ const Chat = {
       html`
         <div class="in">
           <span class="chat-message-header">${getIsoDate(new Date())} | ${id}:</span><br />
-          ${message}
+          <span class="chat-message-body"> ${message}</span>
         </div>
       `,
     );

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

@@ -822,70 +822,72 @@ const generateRandomPasswordSelection = (length) => {
 
 const commitData = {
   feat: {
-    description: 'A new feature',
+    description: 'New feature or enhancement (frontend, backend, API, or UX)',
     title: 'Features',
     emoji: '✨',
   },
   fix: {
-    description: 'A bug fix',
+    description: 'Fix a bug',
     title: 'Bug Fixes',
     emoji: '🐛',
   },
   docs: {
-    description: 'Documentation only changes',
+    description: 'Documentation changes',
     title: 'Documentation',
     emoji: '📚',
   },
   style: {
-    description:
-      'Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)',
+    description: 'Formatting, whitespace, semicolons, code style',
     title: 'Styles',
     emoji: '💎',
   },
   refactor: {
-    description: 'A code change that neither fixes a bug nor adds a feature',
+    description: 'Code refactor.',
     title: 'Code Refactoring',
     emoji: '📦',
   },
   perf: {
-    description: 'A code change that improves performance',
+    description: 'Performance improvements across the stack.',
     title: 'Performance Improvements',
     emoji: '⚡️',
   },
+  ci: {
+    description: 'CI pipeline changes (GitHub Actions, runners, caching)',
+    title: 'Continuous Integration',
+    emoji: '⚙️',
+  },
   cd: {
-    description:
-      'Changes to our Continuous Delivery configuration files and scripts (example scopes: Jenkins, Spinnaker, ArgoCD)',
+    description: 'CD / deployment changes (Remote ssh deployment scripts)',
     title: 'Continuous Delivery',
     emoji: '🚀',
   },
-  test: {
-    description: 'Adding missing tests or correcting existing tests',
-    title: 'Tests',
-    emoji: '🚨',
+  infra: {
+    description: 'Infrastructure changes (MAAS, LXD, cloud infra, networking, provisioning).',
+    title: 'Infrastructure',
+    emoji: '🏗️',
   },
   build: {
-    description: 'Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)',
+    description: 'Build system or dependency changes (tooling, bundler, build scripts).',
     title: 'Builds',
     emoji: '🛠',
   },
-  ci: {
-    description:
-      'Changes to our CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs)',
-    title: 'Continuous Integrations',
-    emoji: '⚙️',
+  test: {
+    description: 'Unit or integration tests added/updated, test helpers, flake fixes.',
+    title: 'Tests',
+    emoji: '🚨',
   },
   chore: {
-    description: "Other changes that don't modify src or test files",
+    description: "Other changes that don't modify src or tests (automation, housekeeping).",
     title: 'Chores',
     emoji: '♻️',
   },
   revert: {
-    description: 'Reverts a previous commit',
+    description: 'Revert a previous commit or change.',
     title: 'Reverts',
     emoji: '🗑',
   },
   backup: {
-    description: 'Changes related to backups, including creation, restoration, and maintenance.',
+    description: 'Backups, snapshotting, restore scripts, or backup docs.',
     title: 'Backups',
     emoji: '💾',
   },