cyberia 3.0.2 → 3.1.3

package/src/cli/run.js

@@ -4,13 +4,14 @@
  * @namespace UnderpostRun
  */
 
-import { daemonProcess, getTerminalPid, openTerminal, shellCd, shellExec } from '../server/process.js';
+import { daemonProcess, getTerminalPid, shellCd, shellExec } from '../server/process.js';
 import {
   awaitDeployMonitor,
   buildKindPorts,
   Config,
   getNpmRootPath,
   isDeployRunnerContext,
+  loadConfServerJson,
   writeEnv,
 } from '../server/conf.js';
 import { actionInitLog, loggerFactory } from '../server/logger.js';
@@ -32,7 +33,6 @@ const logger = loggerFactory(import.meta);
  * @property {string} podName - The name of the pod to run.
  * @property {string} nodeName - The name of the node to run.
  * @property {number} port - Custom port to use.
- * @property {boolean} etcHosts - Whether to modify /etc/hosts.
  * @property {string} volumeHostPath - The host path for the volume.
  * @property {string} volumeMountPath - The mount path for the volume.
  * @property {string} imageName - The name of the image to run.
@@ -56,7 +56,6 @@ const logger = loggerFactory(import.meta);
  * @property {string} apiVersion - The API version for the container.
  * @property {string} claimName - The claim name for the volume.
  * @property {string} kindType - The kind of resource to create.
- * @property {boolean} terminal - Whether to open a terminal.
  * @property {number} devProxyPortOffset - The port offset for the development proxy.
  * @property {boolean} hostNetwork - Whether to use host networking.
  * @property {string} requestsMemory - The memory request for the container.
@@ -85,9 +84,13 @@ const logger = loggerFactory(import.meta);
  * @property {string} monitorStatusKindType - The monitor status kind type option.
  * @property {string} monitorStatusDeltaMs - The monitor status delta in milliseconds.
  * @property {string} monitorStatusMaxAttempts - The maximum number of attempts for monitor status.
+ * @property {boolean} logs - Whether to enable logs.
  * @property {boolean} dryRun - Whether to perform a dry run.
  * @property {boolean} createJobNow - Whether to create the job immediately.
- * @property {boolean} logs - Whether to enable logs.
+ * @property {number} fromNCommit - Number of commits back to use for message propagation (default: 1, last commit only).
+ * @property {string|Array<{ip: string, hostnames: string[]}>} hostAliases - Adds entries to the Pod /etc/hosts via Kubernetes hostAliases.
+ *   As a string (CLI): semicolon-separated entries of "ip=hostname1,hostname2" (e.g., "127.0.0.1=foo.local,bar.local;10.1.2.3=foo.remote").
+ *   As an array (programmatic): objects with `ip` and `hostnames` fields (e.g., [{ ip: "127.0.0.1", hostnames: ["foo.local"] }]).
  * @memberof UnderpostRun
  */
 const DEFAULT_OPTION = {
@@ -118,7 +121,6 @@ const DEFAULT_OPTION = {
   apiVersion: '',
   claimName: '',
   kindType: '',
-  terminal: false,
   devProxyPortOffset: 0,
   hostNetwork: false,
   requestsMemory: '',
@@ -150,6 +152,8 @@ const DEFAULT_OPTION = {
   logs: false,
   dryRun: false,
   createJobNow: false,
+  fromNCommit: 0,
+  hostAliases: '',
 };
 
 /**
@@ -192,7 +196,7 @@ class UnderpostRun {
       }
 
       {
-        // Detect MongoDB primary pod using centralized method
+        // Detect MongoDB primary pod using method
         let primaryMongoHost = 'mongodb-0.mongodb-service';
         try {
           const primaryPodName = Underpost.db.getMongoPrimaryPodName({
@@ -352,58 +356,87 @@ class UnderpostRun {
     },
     /**
      * @method template-deploy
-     * @description Cleans up, pushes `engine-private` and `engine` repositories with a commit tag `ci package-pwa-microservices-template`.
-     * @param {string} path - The input value, identifier, or path for the operation.
+     * @description Pushes `engine-private`, dispatches CI workflow to build `pwa-microservices-template`,
+     * and optionally triggers engine-<conf-id> CI with sync/init which in turn dispatches the CD workflow
+     * after the build chain completes (template → ghpkg → engine-<conf-id> → CD).
+     * @param {string} path - The deployment path identifier (e.g., 'sync-engine-core', 'init-engine-core', or empty for build-only).
      * @param {Object} options - The default underpost runner options for customizing workflow
      * @memberof UnderpostRun
      */
     'template-deploy': (path = '', options = DEFAULT_OPTION) => {
       const baseCommand = options.dev ? 'node bin' : 'underpost';
-      const message = shellExec(`node bin cmt --changelog --changelog-no-hash`, { silent: true, stdout: true }).trim();
-      shellExec(`${baseCommand} run clean`);
+      shellExec(`npm run security:secrets`);
+      const reportPath = './gitleaks-report.json';
+      if (fs.existsSync(reportPath) && JSON.parse(fs.readFileSync(reportPath, 'utf8')).length > 0) {
+        logger.error('Secrets detected in gitleaks-report.json, aborting template-deploy');
+        return;
+      }
+      shellExec(`${baseCommand} run pull`);
+
+      // Capture last N commit messages for propagation (default: last 1 commit)
+      const fromN = options.fromNCommit && parseInt(options.fromNCommit) > 0 ? parseInt(options.fromNCommit) : 1;
+      const message = shellExec(`node bin cmt --changelog ${fromN} --changelog-no-hash`, {
+        silent: true,
+        stdout: true,
+      }).trim();
+
       shellExec(
         `${baseCommand} push ./engine-private ${options.force ? '-f ' : ''}${
           process.env.GITHUB_USERNAME
         }/engine-private`,
       );
       shellCd('/home/dd/engine');
+
+      const sanitizedMessage = Underpost.repo.sanitizeChangelogMessage(message);
+
+      // Push engine repo so workflow YAML changes reach GitHub
       shellExec(`git reset`);
-      function replaceNthNewline(str, n, replacement = ' ') {
-        let count = 0;
-        return str.replace(/\r\n?|\n/g, (match) => {
-          count++;
-          return count === n ? replacement : match;
-        });
-      }
-      shellExec(
-        `${baseCommand} cmt . --empty ci package-pwa-microservices-template${
-          path.startsWith('sync') ? `-${path}` : ''
-        }${
-          message
-            ? ` "${replaceNthNewline(
-                message.replaceAll('"', '').replaceAll('`', '').replaceAll('#', '').replaceAll('- ', ''),
-                2,
-              )}"`
-            : ''
-        }`,
-      );
       shellExec(`${baseCommand} push . ${options.force ? '-f ' : ''}${process.env.GITHUB_USERNAME}/engine`);
+
+      // Determine deploy conf and type from path (sync-engine-core, init-engine-core, etc.)
+      let deployConfId = '';
+      let deployType = '';
+      if (path.startsWith('sync-')) {
+        deployConfId = path.replace(/^sync-/, '');
+        deployType = 'sync-and-deploy';
+      } else if (path.startsWith('init-')) {
+        deployConfId = path.replace(/^init-/, '');
+        deployType = 'init';
+      }
+
+      // Dispatch npmpkg CI workflow — this builds pwa-microservices-template first.
+      // If deployConfId is set, npmpkg.ci.yml will dispatch the engine-<conf-id> CI
+      // with sync=true after template build completes. The engine CI then dispatches
+      // the CD workflow after the engine repo build finishes — ensuring correct sequence:
+      // npmpkg.ci → engine-<id>.ci → engine-<id>.cd
+      const repo = `${process.env.GITHUB_USERNAME}/engine`;
+      const inputs = {};
+      if (sanitizedMessage) inputs.message = sanitizedMessage;
+      if (deployConfId) inputs.deploy_conf_id = deployConfId;
+      if (deployType) inputs.deploy_type = deployType;
+
+      Underpost.repo.dispatchWorkflow({
+        repo,
+        workflowFile: 'npmpkg.ci.yml',
+        ref: 'master',
+        inputs,
+      });
     },
 
     /**
      * @method template-deploy-image
-     * @description Commits and pushes a Docker image deployment for the `engine` repository.
+     * @description Dispatches the Docker image CI workflow for the `engine` repository.
      * @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
      */
     'template-deploy-image': (path, options = DEFAULT_OPTION) => {
-      // const baseCommand = options.dev ? 'node bin' : 'underpost';
-      shellExec(
-        `cd /home/dd/engine && git reset && underpost cmt . --empty ci docker-image 'underpost-engine:${
-          Underpost.version
-        }' && underpost push . ${options.force ? '-f ' : ''}${process.env.GITHUB_USERNAME}/engine`,
-      );
+      Underpost.repo.dispatchWorkflow({
+        repo: `${process.env.GITHUB_USERNAME}/engine`,
+        workflowFile: 'docker-image.ci.yml',
+        ref: 'master',
+        inputs: {},
+      });
     },
     /**
      * @method clean
@@ -464,18 +497,30 @@ class UnderpostRun {
     },
     /**
      * @method ssh-deploy
-     * @description Performs a Git reset, commits with a message `cd ssh-${path}`, and pushes the `engine` repository, likely triggering an SSH-based CD pipeline.
-     * @param {string} path - The input value, identifier, or path for the operation (used as the deployment identifier for the commit message).
+     * @description Dispatches the corresponding CD workflow for SSH-based deployment, replacing empty commits with workflow_dispatch.
+     * @param {string} path - The deployment identifier (e.g., 'engine-core', 'sync-engine-core', 'init-engine-core').
      * @param {Object} options - The default underpost runner options for customizing workflow
      * @memberof UnderpostRun
      */
     'ssh-deploy': (path, options = DEFAULT_OPTION) => {
       actionInitLog();
-      const baseCommand = options.dev ? 'node bin' : 'underpost';
-      shellCd('/home/dd/engine');
-      shellExec(`git reset`);
-      shellExec(`${baseCommand} cmt . --empty cd ssh-${path}`);
-      shellExec(`${baseCommand} push . ${options.force ? '-f ' : ''}${process.env.GITHUB_USERNAME}/engine`);
+
+      let job = 'deploy';
+      let confId = path;
+      if (path.startsWith('sync-')) {
+        job = 'sync-and-deploy';
+        confId = path.replace(/^sync-/, '');
+      } else if (path.startsWith('init-')) {
+        job = 'init';
+        confId = path.replace(/^init-/, '');
+      }
+
+      Underpost.repo.dispatchWorkflow({
+        repo: `${process.env.GITHUB_USERNAME}/engine`,
+        workflowFile: `${confId}.cd.yml`,
+        ref: 'master',
+        inputs: { job },
+      });
     },
     /**
      * @method ide
@@ -485,15 +530,25 @@ class UnderpostRun {
      * @param {Object} options - The default underpost runner options for customizing workflow
      * @memberof UnderpostRun
      */
-    ide: (path, options = DEFAULT_OPTION) => {
-      const { underpostRoot } = options;
-      if (path === 'install') {
-        shellExec(`sudo curl -f https://zed.dev/install.sh | sh`);
-        shellExec(
-          `sudo dnf config-manager --add-repo https://download.sublimetext.com/rpm/stable/x86_64/sublime-text.repo`,
-        );
-        shellExec(`sudo dnf install -y sublime-text`);
-      } else shellExec(`node ${underpostRoot}/bin/zed ${path}`);
+    ide: (path = '', options = DEFAULT_OPTION) => {
+      const underpostRoot = options.dev ? '.' : options.underpostRoot;
+      const [projectPath, customIde] = path.split(',');
+      if (projectPath === 'install') {
+        if (customIde === 'zed') shellExec(`sudo curl -f https://zed.dev/install.sh | sh`);
+        else if (customIde === 'subl') {
+          shellExec(
+            `sudo dnf config-manager --add-repo https://download.sublimetext.com/rpm/stable/x86_64/sublime-text.repo`,
+          );
+          shellExec(`sudo dnf install -y sublime-text`);
+        } else {
+          shellExec(`sudo rpm --import https://packages.microsoft.com/keys/microsoft.asc &&
+echo -e "[code]\nname=Visual Studio Code\nbaseurl=https://packages.microsoft.com/yumrepos/vscode\nenabled=1\nautorefresh=1\ntype=rpm-md\ngpgcheck=1\ngpgkey=https://packages.microsoft.com/keys/microsoft.asc" | sudo tee /etc/yum.repos.d/vscode.repo > /dev/null`);
+          shellExec(`sudo dnf install -y code`);
+        }
+        return;
+      }
+      if (customIde === 'zed') shellExec(`node ${underpostRoot}/bin/zed ${projectPath}`);
+      else shellExec(`node ${underpostRoot}/bin/vs ${projectPath}`);
     },
     /**
      * @method crypto-policy
@@ -522,7 +577,7 @@ class UnderpostRun {
         options.replicas,
         ``,
         ``,
-        options.dev || !isDeployRunnerContext(path, options) ? 'kind-control-plane' : os.hostname(),
+        !options.kubeadm && !options.k3s ? 'kind-control-plane' : os.hostname(),
       ];
       let [deployId, replicas, versions, image, node] = path ? path.split(',') : defaultPath;
       deployId = deployId ? deployId : defaultPath[0];
@@ -556,7 +611,7 @@ class UnderpostRun {
           image ? ` --image ${image}` : ''
         }${versions ? ` --versions ${versions}` : ''}${
           options.namespace ? ` --namespace ${options.namespace}` : ''
-        }${timeoutFlags}${cmdString} dd ${env}`,
+        }${timeoutFlags}${cmdString} ${deployId} ${env}`,
       );
 
       if (isDeployRunnerContext(path, options)) {
@@ -1005,9 +1060,7 @@ EOF
         volumeMountPath: volumeHostPath,
         ...(options.dev ? { volumeHostPath } : { claimName }),
         on: {
-          init: async () => {
-            // openTerminal(`kubectl logs -f ${podName}`);
-          },
+          init: async () => {},
         },
         args: [daemonProcess(path ? path : `cd /home/dd/engine && npm install && npm run test`)],
       };
@@ -1142,7 +1195,7 @@ EOF
       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'));
+        const confServer = loadConfServerJson(`./engine-private/conf/${deployId}/conf.server.json`);
         hosts = hosts.concat(Object.keys(confServer));
       }
       shellExec(`node bin cluster --prom ${hosts.join(',')}`);
@@ -1315,34 +1368,31 @@ EOF
       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);
       }
+      dotenv.config({ path: `./engine-private/conf/${deployId}/.env.development`, override: true });
       shellExec(`node bin run dev-cluster --expose --namespace ${options.namespace}`, { async: true });
       {
-        const cmd = `npm run dev-api ${deployId} ${subConf} ${host} ${_path} ${clientHostPort}${
+        const cmd = `npm run dev:api ${deployId} ${subConf} ${host} ${_path} ${clientHostPort} proxy${
           options.tls ? ' tls' : ''
         }`;
-        options.terminal ? openTerminal(cmd) : shellExec(cmd, { async: true });
+        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,
-            });
+        const cmd = `npm run dev:client ${deployId} ${subConf} ${host} ${_path} proxy${options.tls ? ' tls' : ''}`;
+
+        shellExec(cmd, {
+          async: true,
+        });
       }
       await awaitDeployMonitor(true);
       shellExec(
-        `./node_modules/.bin/env-cmd -f .env.development node src/proxy proxy ${deployId} ${subConf} ${host} ${_path}${
-          options.tls ? ' tls' : ''
-        }`,
+        `NODE_ENV=development node src/proxy proxy ${deployId} ${subConf} ${host} ${_path}${options.tls ? ' tls' : ''}`,
       );
     },
 
@@ -1361,7 +1411,7 @@ EOF
       let [deployId, serviceId, host, _path, replicas, image, node] = path.split(',');
       if (!replicas) replicas = options.replicas;
       // const confClient = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.client.json`, 'utf8'));
-      const confServer = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'));
+      const confServer = loadConfServerJson(`./engine-private/conf/${deployId}/conf.server.json`);
       // const confSSR = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.ssr.json`, 'utf8'));
       // const packageData = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/package.json`, 'utf8'));
       const services = fs.existsSync(`./engine-private/deploy/${deployId}/conf.services.json`)
@@ -1452,9 +1502,7 @@ EOF
     'etc-hosts': async (path = '', options = DEFAULT_OPTION) => {
       const hosts = path ? path.split(',') : [];
       if (options.deployId) {
-        const confServer = JSON.parse(
-          fs.readFileSync(`./engine-private/conf/${options.deployId}/conf.server.json`, 'utf8'),
-        );
+        const confServer = loadConfServerJson(`./engine-private/conf/${options.deployId}/conf.server.json`);
         hosts.push(...Object.keys(confServer));
       }
       const hostListenResult = Underpost.deploy.etcHostFactory(hosts);
@@ -1524,29 +1572,75 @@ EOF
     },
 
     /**
-     * @method ptls
-     * @description Set on ~/.bashrc alias: ports <port> Command to list listening ports that match the given keyword.
-     * @param {string} path - The input value, identifier, or path for the operation (used as a keyword to filter listening ports).
+     * @method pid-info
+     * @description Displays detailed information about a process by PID, including service details, command line, executable path, working directory, environment variables, and parent process tree.
+     * @param {string} path - The PID of the process to inspect.
      * @param {Object} options - The default underpost runner options for customizing workflow
      * @memberof UnderpostRun
      */
-    ptls: async (path = '', options = DEFAULT_OPTION) => {
-      shellExec(`chmod +x ${options.underpostRoot}/scripts/ports-ls.sh`);
-      shellExec(`${options.underpostRoot}/scripts/ports-ls.sh`);
+    'pid-info': (path, options = DEFAULT_OPTION) => {
+      const pid = path;
+      if (!pid) {
+        logger.error('PID is required. Usage: underpost run pid-info <pid>');
+        return;
+      }
+
+      // Services
+      logger.info('Process info');
+      shellExec(`sudo ps -p ${pid} -o pid,ppid,user,stime,etime,cmd`);
+      logger.info('Command line');
+      shellExec(`sudo cat /proc/${pid}/cmdline | tr '\\0' ' ' ; echo`);
+      logger.info('Executable path');
+      shellExec(`sudo readlink -f /proc/${pid}/exe`);
+      logger.info('Working directory');
+      shellExec(`sudo readlink -f /proc/${pid}/cwd`);
+      logger.info('Environment variables (first 200)');
+      shellExec(`sudo tr '\\0' '\\n' </proc/${pid}/environ | head -200`);
+
+      // Parent
+      logger.info('Parent process');
+      const parentInfo = shellExec(`sudo ps -o pid,ppid,user,cmd -p ${pid}`, { stdout: true, silent: true });
+      console.log(parentInfo);
+      const ppidMatch = parentInfo.split('\n').find((l) => l.trim().startsWith(pid));
+      if (ppidMatch) {
+        const ppid = ppidMatch.trim().split(/\s+/)[1];
+        logger.info(`Parent PID: ${ppid}`);
+        shellExec(`ps -fp ${ppid}`);
+      }
+      logger.info('Process tree');
+      shellExec(`pstree -s ${pid}`);
     },
+
     /**
-     * @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.
+     * @method background
+     * @description Runs a custom command in the background using nohup, logging output to `/var/log/<id>.log` and saving the PID to `/var/run/<id>.pid`.
+     * @param {string} path - The command to run in the background (e.g. 'npm run prod:container dd-cyberia-r3').
      * @param {Object} options - The default underpost runner options for customizing workflow
      * @memberof UnderpostRun
      */
-    'release-cmt': async (path, options = 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`, { silent: true });
+    background: (path, options = DEFAULT_OPTION) => {
+      if (!path) {
+        logger.error('Command is required. Usage: underpost run background <command>');
+        return;
+      }
+      const id = path.split(/\s+/).pop();
+      const logFile = `/var/log/${id}.log`;
+      const pidFile = `/var/run/${id}.pid`;
+      logger.info(`Starting background process`, { id, logFile, pidFile });
+      shellExec(`nohup ${path} > ${logFile} 2>&1 & pid=$!; echo $pid > ${pidFile}; disown`);
+      logger.info(`Background process started for '${id}'`);
+    },
+
+    /**
+     * @method ports
+     * @description Set on ~/.bashrc alias: ports <port> Command to list listening ports that match the given keyword.
+     * @param {string} path - The input value, identifier, or path for the operation (used as a keyword to filter listening ports).
+     * @param {Object} options - The default underpost runner options for customizing workflow
+     * @memberof UnderpostRun
+     */
+    ports: async (path = '', options = DEFAULT_OPTION) => {
+      shellExec(`chmod +x ${options.underpostRoot}/scripts/ports-ls.sh`);
+      shellExec(`${options.underpostRoot}/scripts/ports-ls.sh`);
     },
 
     /**
@@ -1569,42 +1663,11 @@ EOF
             `npm install -g npm@11.2.0`,
             `npm install -g underpost`,
             `${baseCommand} secret underpost --create-from-file /etc/config/.env.${env}`,
-            `${baseCommand} start --build --run ${deployId} ${env} --underpost-quickly-install`,
+            `${baseCommand} start --build --run ${deployId} ${env}`,
           ];
       shellExec(`node bin run sync${baseClusterCommand} --deploy-id-cron-jobs none dd-test --cmd "${cmd}"`);
     },
 
-    /**
-     * @method sync-replica
-     * @description Syncs a replica for the dd.router
-     * @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
-     */
-    'sync-replica': async (path, options = DEFAULT_OPTION) => {
-      const env = options.dev ? 'development' : 'production';
-      const baseCommand = options.dev ? 'node bin' : 'underpost';
-
-      for (let deployId of fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8').split(',')) {
-        deployId = deployId.trim();
-        const _path = '/single-replica';
-        const confServer = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'));
-        shellExec(`${baseCommand} env ${deployId} ${env}`);
-        for (const host of Object.keys(confServer))
-          if (_path in confServer[host]) shellExec(`node bin/deploy build-single-replica ${deployId} ${host} ${_path}`);
-        const node = options.nodeName
-          ? options.nodeName
-          : options.dev || !isDeployRunnerContext(path, options)
-            ? 'kind-control-plane'
-            : os.hostname();
-        // deployId, replicas, versions, image, node
-        let defaultPath = [deployId, 1, ``, ``, node];
-        shellExec(`${baseCommand} run${options.dev === true ? ' --dev' : ''} --build sync ${defaultPath}`);
-        shellExec(`node bin/deploy build-full-client ${deployId}`);
-      }
-      if (isDeployRunnerContext(path, options)) shellExec(`${baseCommand} run promote ${path} production`);
-    },
-
     /**
      * @method tf-vae-test
      * @description Creates and runs a job pod (`tf-vae-test`) that installs TensorFlow dependencies, clones the TensorFlow docs, and runs the CVAE tutorial script, with a terminal monitor attached.
@@ -1677,7 +1740,7 @@ EOF
                   shellExec(`sudo kubectl cp ${nameSpace}/${podName}:${basePath}/docs${fromPath} ${toPath}`);
                 }
 
-                openTerminal(`firefox ${outsPaths.join(' ')}`, { single: true });
+                shellExec(`firefox ${outsPaths.join(' ')}`);
                 process.exit(0);
               }
             })();
@@ -1840,6 +1903,30 @@ EOF
       const imagePullPolicy = options.imagePullPolicy || 'IfNotPresent';
       const hostNetwork = options.hostNetwork ? options.hostNetwork : '';
       const apiVersion = options.apiVersion || 'v1';
+      // Parse hostAliases option:
+      //   - string from CLI: "ip1=host1,host2;ip2=host3,host4"
+      //   - array from programmatic callers: [{ ip: "127.0.0.1", hostnames: ["foo.local"] }]
+      const hostAliases = options.hostAliases
+        ? Array.isArray(options.hostAliases)
+          ? options.hostAliases
+          : options.hostAliases
+              .split(';')
+              .filter((entry) => entry.trim())
+              .map((entry) => {
+                const [ip, hostnamesStr] = entry.split('=');
+                const hostnames = hostnamesStr ? hostnamesStr.split(',').map((h) => h.trim()) : [];
+                return { ip: ip.trim(), hostnames };
+              })
+        : [];
+      const hostAliasesYaml =
+        hostAliases.length > 0
+          ? `  hostAliases:\n${hostAliases
+              .map(
+                (alias) =>
+                  `  - ip: "${alias.ip}"\n    hostnames:\n${alias.hostnames.map((h) => `    - "${h}"`).join('\n')}`,
+              )
+              .join('\n')}`
+          : '';
       const labels = options.labels
         ? options.labels
             .split(',')
@@ -1870,6 +1957,7 @@ spec:
   restartPolicy: ${restartPolicy}
 ${runtimeClassName ? `  runtimeClassName: ${runtimeClassName}` : ''}
 ${hostNetwork ? `  hostNetwork: ${hostNetwork}` : ''}
+${hostAliasesYaml}
   containers:
     - name: ${containerName}
       image: ${imageName}

package/src/cli/secrets.js

@@ -4,13 +4,11 @@
  * @namespace UnderpostSecret
  */
 
-import dotenv from 'dotenv';
 import { shellExec } from '../server/process.js';
 import fs from 'fs-extra';
+import dotenv from 'dotenv';
 import Underpost from '../index.js';
 
-dotenv.config();
-
 /**
  * @class UnderpostSecret
  * @description Manages the secrets of the application.

package/src/cli/ssh.js

@@ -497,7 +497,7 @@ EOF`);
     },
 
     /**
-     * Generic SSH remote command runner that centralizes SSH execution logic.
+     * Generic SSH remote command runner that SSH execution logic.
      * Executes arbitrary shell commands on a remote server via SSH with proper credential handling.
      * @async
      * @function sshRemoteRunner