underpost 2.8.84 → 2.8.86

package/src/cli/deploy.js

@@ -242,12 +242,10 @@ spec:
         cert: false,
         versions: '',
         traffic: '',
-        dashboardUpdate: false,
         replicas: '',
         restoreHosts: false,
         disableUpdateDeployment: false,
         infoTraffic: false,
-        rebuildClientsBundle: false,
       },
     ) {
       if (options.infoUtil === true)
@@ -311,22 +309,21 @@ Password: <Your Key>
             deployId,
             env,
             traffic: UnderpostDeploy.API.getCurrentTraffic(deployId),
+            router: await UnderpostDeploy.API.routerFactory(deployId, env),
+            pods: await UnderpostDeploy.API.get(deployId),
           });
         }
         return;
       }
-      if (options.rebuildClientsBundle === true) await UnderpostDeploy.API.rebuildClientsBundle(deployList);
       if (!(options.versions && typeof options.versions === 'string')) options.versions = 'blue,green';
       if (!options.replicas) options.replicas = 1;
       if (options.sync) UnderpostDeploy.API.sync(deployList, options);
       if (options.buildManifest === true) await UnderpostDeploy.API.buildManifest(deployList, env, options);
-      if (options.infoRouter === true) logger.info('router', await UnderpostDeploy.API.routerFactory(deployList, env));
-      if (options.dashboardUpdate === true) await UnderpostDeploy.API.updateDashboardData(deployList, env, options);
-      if (options.infoRouter === true) return;
-      shellExec(`kubectl delete configmap underpost-config`);
-      shellExec(
-        `kubectl create configmap underpost-config --from-file=/home/dd/engine/engine-private/conf/dd-cron/.env.${env}`,
-      );
+      if (options.infoRouter === true) {
+        logger.info('router', await UnderpostDeploy.API.routerFactory(deployList, env));
+        return;
+      }
+      UnderpostDeploy.API.configMap(env);
       let renderHosts = '';
       let concatHots = '';
       const etcHost = (
@@ -435,23 +432,6 @@ Password: <Your Key>
 
       return result;
     },
-    rebuildClientsBundle(deployList) {
-      for (const _deployId of deployList.split(',')) {
-        const deployId = _deployId.trim();
-        const repoName = `engine-${deployId.split('-')[1]}`;
-
-        shellExec(`underpost script set ${deployId}-client-build '
-cd /home/dd/engine &&
-git checkout . &&
-underpost pull . underpostnet/${repoName} &&
-underpost pull ./engine-private underpostnet/${repoName}-private &&
-underpost env ${deployId} production &&
-node bin/deploy build-full-client ${deployId}
-'`);
-
-        shellExec(`node bin script run ${deployId}-client-build --itc --pod-name ${deployId}`);
-      }
-    },
     resourcesFactory() {
       return {
         requests: {
@@ -465,60 +445,6 @@ node bin/deploy build-full-client ${deployId}
         totalPods: UnderpostRootEnv.API.get('total-pods'),
       };
     },
-    async updateDashboardData(deployList, env, options) {
-      try {
-        const deployId = process.env.DEFAULT_DEPLOY_ID;
-        const host = process.env.DEFAULT_DEPLOY_HOST;
-        const path = process.env.DEFAULT_DEPLOY_PATH;
-        const { db } = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'))[host][
-          path
-        ];
-
-        await DataBaseProvider.load({ apis: ['instance'], host, path, db });
-
-        /** @type {import('../api/instance/instance.model.js').InstanceModel} */
-        const Instance = DataBaseProvider.instance[`${host}${path}`].mongoose.models.Instance;
-
-        await Instance.deleteMany();
-
-        for (const _deployId of deployList.split(',')) {
-          const deployId = _deployId.trim();
-          if (!deployId) continue;
-          const confServer = loadReplicas(
-            JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8')),
-            'proxy',
-          );
-          const router = await UnderpostDeploy.API.routerFactory(deployId, env);
-          const pathPortAssignmentData = pathPortAssignmentFactory(router, confServer);
-
-          for (const host of Object.keys(confServer)) {
-            for (const { path, port } of pathPortAssignmentData[host]) {
-              if (!confServer[host][path]) continue;
-
-              const { client, runtime, apis } = confServer[host][path];
-
-              const body = {
-                deployId,
-                host,
-                path,
-                port,
-                client,
-                runtime,
-                apis,
-              };
-
-              logger.info('save', body);
-
-              await new Instance(body).save();
-            }
-          }
-        }
-
-        await DataBaseProvider.instance[`${host}${path}`].mongoose.close();
-      } catch (error) {
-        logger.error(error, error.stack);
-      }
-    },
     existsContainerFile({ podName, path }) {
       return JSON.parse(
         shellExec(`kubectl exec ${podName} -- test -f ${path} && echo "true" || echo "false"`, {
@@ -528,6 +454,39 @@ node bin/deploy build-full-client ${deployId}
         }).trim(),
       );
     },
+    checkDeploymentReadyStatus(deployId, env, traffic, ignoresNames = []) {
+      const cmd = `underpost config get container-status`;
+      const pods = UnderpostDeploy.API.get(`${deployId}-${env}-${traffic}`);
+      const readyPods = [];
+      const notReadyPods = [];
+      for (const pod of pods) {
+        const { NAME } = pod;
+        if (ignoresNames && ignoresNames.find((t) => NAME.trim().toLowerCase().match(t.trim().toLowerCase()))) continue;
+        if (
+          shellExec(`sudo kubectl exec -i ${NAME} -- sh -c "${cmd}"`, { stdout: true }).match(
+            `${deployId}-${env}-running-deployment`,
+          )
+        ) {
+          readyPods.push(pod);
+        } else {
+          notReadyPods.push(pod);
+        }
+      }
+      return { ready: notReadyPods.length === 0, notReadyPods, readyPods };
+    },
+    configMap(env) {
+      shellExec(`kubectl delete configmap underpost-config`);
+      shellExec(
+        `kubectl create configmap underpost-config --from-file=/home/dd/engine/engine-private/conf/dd-cron/.env.${env}`,
+      );
+    },
+    switchTraffic(deployId, env, targetTraffic, replicas = 1) {
+      UnderpostRootEnv.API.set(`${deployId}-${env}-traffic`, targetTraffic);
+      shellExec(
+        `node bin deploy --info-router --build-manifest --traffic ${targetTraffic} --replicas ${replicas} ${deployId} ${env}`,
+      );
+      shellExec(`sudo kubectl apply -f ./engine-private/conf/${deployId}/build/${env}/proxy.yaml`);
+    },
   };
 }
 

package/src/cli/index.js

@@ -23,6 +23,7 @@ program.name('underpost').description(`underpost ci/cd cli ${Underpost.version}`
 program
   .command('new')
   .argument('<app-name>', 'The name of the application to create.')
+  .option('--dev', 'Sets the development cli context')
   .description('Initializes a new Underpost project with a predefined structure.')
   .action(Underpost.repo.new);
 
@@ -112,6 +113,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.')
@@ -122,6 +124,11 @@ program
   .option('--full', 'Initializes the cluster with all available statefulsets and services.')
   .option('--ns-use <ns-name>', 'Switches the current Kubernetes context to the specified namespace.')
   .option('--kubeadm', 'Initializes the cluster using kubeadm for control plane management.')
+  .option('--grafana', 'Initializes the cluster with a Grafana deployment.')
+  .option(
+    '--prom [hosts]',
+    'Initializes the cluster with a Prometheus Operator deployment and monitor scrap for specified hosts.',
+  )
   .option('--dev', 'Initializes a development-specific cluster configuration.')
   .option('--list-pods', 'Displays detailed information about all pods.')
   .option('--info-capacity', 'Displays the current total machine capacity information.')
@@ -154,7 +161,6 @@ program
     '--build-manifest',
     'Builds Kubernetes YAML manifests, including deployments, services, proxies, and secrets.',
   )
-  .option('--dashboard-update', 'Updates dashboard instance data with the current router configuration.')
   .option('--replicas <replicas>', 'Sets a custom number of replicas for deployments.')
   .option('--versions <deployment-versions>', 'A comma-separated list of custom deployment versions.')
   .option('--traffic <traffic-versions>', 'A comma-separated list of custom deployment traffic weights.')
@@ -162,10 +168,6 @@ program
   .option('--info-traffic', 'Retrieves traffic configuration from current resource deployments.')
   .option('--kubeadm', 'Enables the kubeadm context for deployment operations.')
   .option('--restore-hosts', 'Restores default `/etc/hosts` entries.')
-  .option(
-    '--rebuild-clients-bundle',
-    'Inside the container, rebuilds client bundles (only static public or storage client files).',
-  )
   .description('Manages application deployments, defaulting to deploying development pods.')
   .action(Underpost.deploy.callback);
 
@@ -239,6 +241,20 @@ program
   .description('Manages database operations, including import, export, and collection management.')
   .action(Underpost.db.callback);
 
+program
+  .command('metadata')
+  .argument('[deploy-id]', 'The deployment ID to manage metadata.')
+  .argument('[host]', 'The host to manage metadata.')
+  .argument('[path]', 'The path to manage metadata.')
+  .option('--import', 'Imports from local storage.')
+  .option('--export', 'Exports to local storage.')
+  .option('--crons', 'Apply to cron data collection')
+  .option('--instances', 'Apply to instance data collection')
+  .option('--generate', 'Generate cluster metadata')
+  .option('--itc', 'Apply under container execution context')
+  .description('Manages cluster metadata operations, including import and export.')
+  .action(Underpost.db.clusterMetadataBackupCallback);
+
 // 'script' command: Execute scripts
 program
   .command('script')
@@ -267,7 +283,6 @@ program
   .option('--itc', 'Executes cron jobs within the container execution context.')
   .option('--init', 'Initializes cron jobs for the default deployment ID.')
   .option('--git', 'Uploads cron job configurations to GitHub.')
-  .option('--dashboard-update', 'Updates dashboard cron data with the current job configurations.')
   .description('Manages cron jobs, including initialization, execution, and configuration updates.')
   .action(Underpost.cron.callback);
 
@@ -315,6 +330,13 @@ 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')
@@ -326,6 +348,7 @@ program
   .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.')

package/src/cli/monitor.js

@@ -120,10 +120,7 @@ class UnderpostMonitor {
                           fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'),
                         );
 
-                        shellExec(`kubectl delete configmap underpost-config`);
-                        shellExec(
-                          `kubectl create configmap underpost-config --from-file=/home/dd/engine/engine-private/conf/dd-cron/.env.${env}`,
-                        );
+                        UnderpostDeploy.API.configMap(env);
 
                         for (const host of Object.keys(confServer)) {
                           shellExec(`sudo kubectl delete HTTPProxy ${host}`);
@@ -173,19 +170,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

@@ -80,7 +80,7 @@ class UnderpostRepository {
       );
     },
 
-    new(repositoryName) {
+    new(repositoryName, options = { dev: false }) {
       return new Promise(async (resolve, reject) => {
         try {
           await logger.setUpInfo();
@@ -89,15 +89,22 @@ class UnderpostRepository {
               await UnderpostStartUp.API.listenPortController(UnderpostStartUp.API.listenServerFactory(), ':'),
             );
           else actionInitLog();
-          const exeRootPath = `${getNpmRootPath()}/underpost`;
+          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 });
-          fs.copySync(exeRootPath, destFolder);
-          fs.writeFileSync(`${destFolder}/.gitignore`, fs.readFileSync(`${exeRootPath}/.dockerignore`, 'utf8'), 'utf8');
-          shellExec(`cd ${destFolder} && git init && git add . && git commit -m "Base template implementation"`);
+          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`);
           return resolve();

package/src/cli/run.js

@@ -1,11 +1,12 @@
 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 { actionInitLog, 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);
 
@@ -53,6 +54,9 @@ class UnderpostRun {
         }`,
       );
     },
+    'underpost-config': (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      UnderpostDeploy.API.configMap(path ?? '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`,
@@ -64,10 +68,79 @@ class UnderpostRun {
       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 });
+    },
+    'ssh-cluster-info': (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      const { underpostRoot } = options;
+      shellExec(`chmod +x ${underpostRoot}/manifests/maas/ssh-cluster-info.sh`);
+      shellExec(`${underpostRoot}/manifests/maas/ssh-cluster-info.sh`);
+    },
+    '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`);
+    },
+    clean: (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      shellCd(path ?? `/home/dd/engine`);
+      shellExec(`node bin/deploy clean-core-repo`);
+    },
+    pull: (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      shellCd(`/home/dd/engine`);
+      shellExec(`node bin/deploy clean-core-repo`);
+      shellExec(`underpost pull . underpostnet/engine`);
+      shellExec(`underpost pull engine-private underpostnet/engine-private`, { silent: true });
+    },
+    'release-deploy': (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      actionInitLog();
+      shellExec(`underpost --version`);
+      shellCd(`/home/dd/engine`);
+      for (const _deployId of fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8').split(',')) {
+        const deployId = _deployId.trim();
+        shellExec(`underpost run deploy ${deployId}`, { async: true });
+      }
+    },
+    '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}`);
     },
+    'dev-client': (_path, options = UnderpostRun.DEFAULT_OPTION) => {
+      let [deployId, hostpath, subConf, lite] = _path.split(',');
+      let [host, path] = hostpath.split('/');
+      if (!path) path = '/';
+      shellExec(`npm run dev-client ${deployId} ${host} ${path} ${subConf} static${lite === 'l' ? ' l' : ''}`);
+    },
+    'dev-api': (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      let [deployId, subConf] = path.split(',');
+      shellExec(`npm run dev-api ${deployId} ${subConf}`);
+    },
     monitor: (path, options = UnderpostRun.DEFAULT_OPTION) => {
       const pid = getTerminalPid();
       logger.info('monitor pid', pid);
@@ -141,6 +214,92 @@ class UnderpostRun {
       };
       _monitor();
     },
+    'db-client': async (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      const { underpostRoot } = options;
+      shellExec(`kubectl apply -k ${underpostRoot}/manifests/deployment/adminer/.`);
+    },
+    promote: async (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      let [inputDeployId, inputEnv, inputReplicas] = path.split(',');
+      if (!inputEnv) inputEnv = 'production';
+      if (!inputReplicas) inputReplicas = 1;
+      if (inputDeployId === 'dd') {
+        for (const deployId of fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8').split(',')) {
+          const currentTraffic = UnderpostDeploy.API.getCurrentTraffic(deployId);
+          const targetTraffic = currentTraffic === 'blue' ? 'green' : 'blue';
+          UnderpostDeploy.API.switchTraffic(deployId, inputEnv, targetTraffic, inputReplicas);
+        }
+      } else {
+        const currentTraffic = UnderpostDeploy.API.getCurrentTraffic(inputDeployId);
+        const targetTraffic = currentTraffic === 'blue' ? 'green' : 'blue';
+        UnderpostDeploy.API.switchTraffic(inputDeployId, inputEnv, targetTraffic, inputReplicas);
+      }
+    },
+
+    metrics: async (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      const deployList = fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8').split(',');
+      let hosts = [];
+      for (const deployId of deployList) {
+        const confServer = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'));
+        hosts = hosts.concat(Object.keys(confServer));
+      }
+      shellExec(`node bin cluster --prom ${hosts.join(',')}`);
+      shellExec(`node bin cluster --grafana`);
+    },
+
+    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 checkStatusIteration = 0;
+      const checkStatusIterationMsDelay = 1000;
+      const iteratorTag = `[${deployId}-${env}-${targetTraffic}]`;
+      logger.info('Deployment init', { deployId, env, targetTraffic, checkStatusIterationMsDelay });
+
+      while (!UnderpostDeploy.API.checkDeploymentReadyStatus(deployId, env, targetTraffic, ignorePods).ready) {
+        await timer(checkStatusIterationMsDelay);
+        checkStatusIteration++;
+        logger.info(
+          `${iteratorTag} | Deployment in progress... | Delay number check iterations: ${checkStatusIteration}`,
+        );
+      }
+
+      logger.info(`${iteratorTag} | Deployment ready. | Total delay number check iterations: ${checkStatusIteration}`);
+
+      UnderpostDeploy.API.switchTraffic(deployId, env, targetTraffic);
+
+      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';
@@ -187,6 +346,12 @@ class UnderpostRun {
       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
@@ -210,16 +375,19 @@ ${
 ${args.map((arg) => `          ${arg}`).join('\n')}`
     : ''
 }
-${
+${`${
   gpuEnable
     ? `      resources:
         limits:
           nvidia.com/gpu: '1'
-      env:
-        - name: NVIDIA_VISIBLE_DEVICES
-          value: all`
+`
     : ''
-}
+}      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
     ? `
@@ -230,7 +398,7 @@ ${
     - name: ${volumeName}
       hostPath:
         path: ${volumeHostPath}
-        type: ${fs.statSync(volumeHostPath).isDirectory() ? 'Directory' : 'File'}`
+        type: ${volumeType}`
     : ''
 }
 EOF`;

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/client/Default.index.js

@@ -15,27 +15,29 @@ import { DefaultParams } from './components/default/CommonDefault.js';
 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();
       await SignUpDefault();
-      await Scroll.pullTopRefresh();
       await Keyboard.Init({ callBackTime: DefaultParams.EVENT_CALLBACK_TIME });
     },
   });