underpost 3.2.5 → 3.2.8

package/src/cli/run.js

@@ -93,7 +93,6 @@ const logger = loggerFactory(import.meta);
  * @property {boolean} kubeadm - Whether to run in kubeadm mode.
  * @property {boolean} kind - Whether to run in kind mode.
  * @property {boolean} k3s - Whether to run in k3s mode.
- * @property {string} logType - The type of log to generate.
  * @property {string} hosts - The hosts to use.
  * @property {string} deployId - The deployment ID.
  * @property {string} instanceId - The instance ID.
@@ -158,7 +157,6 @@ const DEFAULT_OPTION = {
   kubeadm: false,
   kind: false,
   k3s: false,
-  logType: '',
   hosts: '',
   deployId: '',
   instanceId: '',
@@ -490,21 +488,6 @@ class UnderpostRun {
         : await Underpost.release.pwa(sanitizedMessage, options);
       pbcopy(triggerCmd + ' && cd /home/dd/engine');
     },
-    /**
-     * @method template-deploy-image
-     * @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) => {
-      Underpost.repo.dispatchWorkflow({
-        repo: `${process.env.GITHUB_USERNAME}/engine`,
-        workflowFile: 'docker-image.ci.yml',
-        ref: 'master',
-        inputs: {},
-      });
-    },
     /**
      * @method docker-image
      * @description Dispatches the Docker image CI workflow (`docker-image.ci.yml`) for the `engine` repository via `workflow_dispatch`.
@@ -515,7 +498,7 @@ class UnderpostRun {
     'docker-image': (path, options = DEFAULT_OPTION) => {
       Underpost.repo.dispatchWorkflow({
         repo: `${process.env.GITHUB_USERNAME}/engine`,
-        workflowFile: 'docker-image.ci.yml',
+        workflowFile: `docker-image${path ? `.${path}` : ''}.ci.yml`,
         ref: 'master',
         inputs: {},
       });
@@ -652,7 +635,7 @@ echo -e "[code]\nname=Visual Studio Code\nbaseurl=https://packages.microsoft.com
     sync: async (path, options = DEFAULT_OPTION) => {
       // Dev usage: node bin run --dev --build sync dd-default
       const env = options.dev ? 'development' : 'production';
-      const baseCommand = options.dev ? 'node bin' : 'underpost';
+      const baseCommand = 'node bin'; // options.dev ? 'node bin' : 'underpost';
       const baseClusterCommand = options.dev ? ' --dev' : '';
       const clusterFlag = options.k3s ? ' --k3s' : options.kind ? ' --kind' : ' --kubeadm';
       const defaultPath = [
@@ -669,6 +652,15 @@ echo -e "[code]\nname=Visual Studio Code\nbaseurl=https://packages.microsoft.com
       image = image ? image : defaultPath[3];
       node = node ? node : defaultPath[4];
       shellExec(`${baseCommand} cluster --ns-use ${options.namespace}`);
+
+      if (image && !image.startsWith('localhost'))
+        Underpost.image.pullDockerHubImage({
+          dockerhubImage: image,
+          kind: options.kind || (!options.nodeName && !options.kubeadm && !options.k3s),
+          kubeadm: options.nodeName || options.kubeadm,
+          k3s: options.k3s,
+        });
+
       if (isDeployRunnerContext(path, options)) {
         if (!options.disablePrivateConfUpdate) {
           const { validVersion } = Underpost.repo.privateConfUpdate(deployId);
@@ -928,12 +920,17 @@ echo -e "[code]\nname=Visual Studio Code\nbaseurl=https://packages.microsoft.com
           image: _image,
           fromPort: _fromPort,
           toPort: _toPort,
+          fromDebugPort: _fromDebugPort,
+          toDebugPort: _toDebugPort,
           cmd: _cmd,
           volumes: _volumes,
           metadata: _metadata,
         } = instance;
         if (id !== _id) continue;
         const _deployId = `${deployId}-${_id}`;
+        // Use debug ports in development when defined, fall back to production ports.
+        if (env === 'development' && _fromDebugPort) _fromPort = _fromDebugPort;
+        if (env === 'development' && _toDebugPort) _toPort = _toDebugPort;
         const currentTraffic = Underpost.deploy.getCurrentTraffic(_deployId, {
           hostTest: _host,
           namespace: options.namespace,
@@ -1003,12 +1000,17 @@ EOF
           image: _image,
           fromPort: _fromPort,
           toPort: _toPort,
+          fromDebugPort: _fromDebugPort,
+          toDebugPort: _toDebugPort,
           cmd: _cmd,
           volumes: _volumes,
           metadata: _metadata,
         } = instance;
         if (id !== _id) continue;
         const _deployId = `${deployId}-${_id}`;
+        // Use debug ports in development when defined, fall back to production ports.
+        if (env === 'development' && _fromDebugPort) _fromPort = _fromDebugPort;
+        if (env === 'development' && _toDebugPort) _toPort = _toDebugPort;
         etcHosts.push(_host);
         if (options.expose) continue;
         // Examples images:
@@ -1016,12 +1018,13 @@ EOF
         // `localhost/rockylinux9-underpost:${Underpost.version}`
         if (!_image) _image = `underpost/underpost-engine:${Underpost.version}`;
 
-        Underpost.image.pullDockerHubImage({
-          dockerhubImage: _image,
-          kind: options.kind || (!options.nodeName && !options.kubeadm && !options.k3s),
-          kubeadm: options.nodeName || options.kubeadm,
-          k3s: options.k3s,
-        });
+        if (_image && !_image.startsWith('localhost'))
+          Underpost.image.pullDockerHubImage({
+            dockerhubImage: _image,
+            kind: options.kind || (!options.nodeName && !options.kubeadm && !options.k3s),
+            kubeadm: options.nodeName || options.kubeadm,
+            k3s: options.k3s,
+          });
 
         const currentTraffic = Underpost.deploy.getCurrentTraffic(_deployId, {
           hostTest: _host,
@@ -1095,7 +1098,6 @@ EOF
           targetTraffic,
           ignorePods,
           options.namespace,
-          options.logType,
         );
 
         if (!ready) {
@@ -1115,6 +1117,153 @@ EOF
       }
     },
 
+    /**
+     * @method instance-build-manifest
+     * @description Builds a Kubernetes Deployment + Service manifest for a specific instance entry
+     * from `conf.instances.json` and writes it to a file.
+     * Traffic colour is automatically chosen as the opposite of the current live colour (blue/green),
+     * defaulting to `blue` when no deployment is running yet.
+     *
+     * If `--build` is supplied the image is built from the project Dockerfile and loaded into the
+     * cluster before the manifest is written (kind by default; `--kubeadm` / `--k3s` override).
+     *
+     * @param {string} path - Comma-separated: `deployId,instanceId[,projectPath]`.
+     *   `projectPath` is the root directory that contains the `Dockerfile` (e.g. `./cyberia-client`).
+     *   Artifacts are written to `<projectPath>/manifests/<env>/Dockerfile` and
+     *   `<projectPath>/manifests/<env>/deployment.yaml`.
+     *   In production, files are also copied to `<projectPath>/Dockerfile` and
+     *   `<projectPath>/deployment.yaml`.
+     * @param {Object} options - The default underpost runner options for customizing workflow
+     * @memberof UnderpostRun
+     */
+    'instance-build-manifest': (path, options = DEFAULT_OPTION) => {
+      const env = options.dev ? 'development' : 'production';
+      let [deployId, id, projectPath] = path.split(',');
+      const rootPath = projectPath ? projectPath : '.';
+      const envManifestPath = `${rootPath}/manifests/deployments/${id}-${env}`;
+      const outputPath = `${envManifestPath}/deployment.yaml`;
+      const dockerfileManifestPath = `${envManifestPath}/Dockerfile`;
+
+      fs.mkdirpSync(envManifestPath);
+
+      const confInstances = JSON.parse(
+        fs.readFileSync(`./engine-private/conf/${deployId}/conf.instances.json`, 'utf8'),
+      );
+
+      const instance = confInstances.find((i) => i.id === id);
+      if (!instance) {
+        logger.error(`Instance with id '${id}' not found in conf.instances.json for deployId '${deployId}'`);
+        return;
+      }
+
+      let {
+        id: _id,
+        host: _host,
+        path: _path,
+        image: _image,
+        fromPort: _fromPort,
+        toPort: _toPort,
+        fromDebugPort: _fromDebugPort,
+        toDebugPort: _toDebugPort,
+        cmd: _cmd,
+        volumes: _volumes,
+        metadata: _metadata,
+        runtime: _runtime,
+      } = instance;
+
+      // Resolve Dockerfile source: use runtime-specific path when instance defines a runtime.
+      const dockerfileSourcePath = _runtime ? `src/runtime/${_runtime}/Dockerfile` : `${rootPath}/Dockerfile`;
+      if (fs.existsSync(dockerfileSourcePath)) {
+        fs.copyFileSync(dockerfileSourcePath, dockerfileManifestPath);
+      } else {
+        logger.warn(`[instance-build-manifest] Dockerfile not found at ${dockerfileSourcePath}`);
+      }
+
+      const _deployId = `${deployId}-${_id}`;
+      if (!_image) _image = `underpost/underpost-engine:${Underpost.version}`;
+      // Use debug ports in development when defined, fall back to production ports.
+      if (env === 'development' && _fromDebugPort) _fromPort = _fromDebugPort;
+      if (env === 'development' && _toDebugPort) _toPort = _toDebugPort;
+
+      // Build image from projectPath Dockerfile and load into cluster when --build is set.
+      if (options.build && projectPath) {
+        const isKind = !options.kubeadm && !options.k3s;
+        Underpost.image.build({
+          path: projectPath,
+          imageName: _image,
+          podmanSave: true,
+          imagePath: projectPath,
+          kind: isKind,
+          kubeadm: !!options.kubeadm,
+          k3s: !!options.k3s,
+          reset: !!options.reset,
+          dev: options.dev,
+        });
+        logger.info(`[instance-build-manifest] Image built and loaded`, {
+          image: _image,
+          cluster: isKind ? 'kind' : options.kubeadm ? 'kubeadm' : 'k3s',
+        });
+      }
+
+      // Determine target traffic: opposite of current, or 'blue' if nothing is running yet.
+      const currentTraffic = Underpost.deploy.getCurrentTraffic(_deployId, {
+        hostTest: _host,
+        namespace: options.namespace,
+      });
+      const targetTraffic = currentTraffic ? (currentTraffic === 'blue' ? 'green' : 'blue') : 'blue';
+
+      // Resolve {{grpc-service-dns}} using the parent deploy's current (or default) traffic.
+      const parentTraffic = Underpost.deploy.getCurrentTraffic(deployId, { namespace: options.namespace }) || 'blue';
+      const resolvedCmd = _cmd[env].map((c) =>
+        c.replaceAll(
+          '{{grpc-service-dns}}',
+          `${deployId}-grpc-service-${env}-${parentTraffic}.${options.namespace || 'default'}.svc.cluster.local:50051`,
+        ),
+      );
+
+      const deploymentYaml =
+        `---\n` +
+        Underpost.deploy
+          .deploymentYamlPartsFactory({
+            deployId: _deployId,
+            env,
+            suffix: targetTraffic,
+            resources: Underpost.deploy.resourcesFactory(options),
+            replicas: options.replicas,
+            image: _image,
+            namespace: options.namespace,
+            volumes: _volumes,
+            cmd: resolvedCmd,
+          })
+          .replace('{{ports}}', buildKindPorts(_fromPort, _toPort));
+
+      fs.writeFileSync(outputPath, deploymentYaml, 'utf8');
+      logger.info(`[instance-build-manifest] Manifest written to ${outputPath}`, {
+        deployId: _deployId,
+        env,
+        traffic: targetTraffic,
+        image: _image,
+      });
+
+      if (env === 'production') {
+        if (fs.existsSync(dockerfileManifestPath)) {
+          fs.copyFileSync(dockerfileManifestPath, `${rootPath}/Dockerfile`);
+        }
+        fs.copyFileSync(outputPath, `${rootPath}/deployment.yaml`);
+        logger.info('[instance-build-manifest] Production artifacts copied to project root', {
+          rootPath,
+          dockerfile: `${rootPath}/Dockerfile`,
+          deployment: `${rootPath}/deployment.yaml`,
+        });
+        const ciSrc = `./.github/workflows/docker-image.${_runtime}.ci.yml`;
+        if (fs.existsSync(ciSrc)) {
+          if (!fs.existsSync(`${rootPath}/.github/workflows`)) fs.mkdirpSync(`${rootPath}/.github/workflows`);
+          fs.copyFileSync(ciSrc, `${rootPath}/.github/workflows/docker-image.${_runtime}.ci.yml`);
+          logger.info(`[instance-build-manifest] CI workflow copied`, { src: ciSrc });
+        }
+      }
+    },
+
     /**
      * @method ls-deployments
      * @description Retrieves and logs a table of Kubernetes deployments using `Underpost.deploy.get`.
@@ -1920,6 +2069,16 @@ EOF
 
       shellCd('/home/dd/engine');
     },
+    /**
+     * @method pull-rocky-image
+     * @description Pulls the base `rockylinux:9` image from Docker Hub via Podman.
+     * @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-rocky-image': (path, options = DEFAULT_OPTION) => {
+      shellExec(`sudo podman pull docker.io/library/rockylinux:9`);
+    },
     /**
      * @method rmi
      * @description Forces the removal of all local Podman images (`podman rmi $(podman images -qa) --force`).
@@ -1949,13 +2108,6 @@ EOF
         } else shellExec(`sudo kill -9 $(lsof -t -i:${_path})`);
       }
     },
-    /**
-     * @method secret
-     * @description Creates an Underpost secret named 'underpost' from a file, defaulting to `/home/dd/engine/engine-private/conf/dd-cron/.env.production` if no path is provided.
-     * @param {string} path - The input value, identifier, or path for the operation (used as the optional path to the secret file).
-     * @param {Object} options - The default underpost runner options for customizing workflow
-     * @memberof UnderpostRun
-     */
     /**
      * @method generate-pass
      * @description Generates a cryptographically secure random password that satisfies all validatePassword
@@ -1992,10 +2144,16 @@ EOF
       if (options.copy) pbcopy(password);
       else console.log(password);
     },
-
+    /**
+     * @method secret
+     * @description Creates an Underpost secret named 'underpost' from a file, defaulting to `/home/dd/engine/engine-private/conf/dd-cron/.env.production` if no path is provided.
+     * @param {string} path - The input value, identifier, or path for the operation (used as the optional path to the secret file).
+     * @param {Object} options - The default underpost runner options for customizing workflow
+     * @memberof UnderpostRun
+     */
     secret: (path, options = DEFAULT_OPTION) => {
       const secretPath = path ? path : `/home/dd/engine/engine-private/conf/dd-cron/.env.production`;
-      const command = `node bin secret underpost --create-from-file ${secretPath}`;
+      const command = `${options.dev ? 'node bin' : 'underpost'} secret underpost --create-from-file ${secretPath}`;
       shellExec(command);
     },
     /**
@@ -2166,6 +2324,113 @@ EOF`;
         if (options.logs) shellExec(`kubectl logs -f ${podName} -n ${namespace}`, { async: true });
       }
     },
+
+    /**
+     * @method push-bundle
+     * @description Builds the client zip for the specified deployment, splits it into parts, and uploads to file storage.
+     *   Steps: set env, build+split zip, switch to cron env, upload parts to storage.
+     * @param {string} path - Optional `fsPath.splitOption` string.
+     *   Examples: `build` (default split 8), `build.16` (split 16 MB), `build.none-split` (no split flag).
+     * @param {Object} options - The default underpost runner options for customizing workflow.
+     * @param {string} [options.deployId] - Override deploy ID.
+     * @param {boolean} [options.dev] - Use development environment; defaults to production.
+     * @memberof UnderpostRun
+     */
+    'push-bundle': (path = '', options = DEFAULT_OPTION) => {
+      const baseCommand = options.dev ? 'node bin' : 'underpost';
+      const env = options.dev ? 'development' : 'production';
+      const deployId = options.deployId || 'dd-default';
+      const pathParts = (path || '').split('.');
+      const fsPath = (pathParts[0] || '').trim() || 'build';
+      const splitOption = (pathParts[1] || '').trim();
+
+      let splitFlag = '--split 8';
+      if (splitOption) {
+        if (splitOption === 'none-split') {
+          splitFlag = '';
+        } else {
+          const splitMb = Number(splitOption);
+          if (Number.isFinite(splitMb) && splitMb > 0) {
+            splitFlag = `--split ${splitMb}`;
+          } else {
+            logger.warn('push-bundle: invalid split option, using default split 8', {
+              path,
+              splitOption,
+            });
+          }
+        }
+      }
+
+      shellExec(`${baseCommand} env ${deployId} ${env}`);
+      shellExec(`${baseCommand} client ${deployId} --build-zip${splitFlag ? ` ${splitFlag}` : ''}`);
+      shellExec(
+        `${baseCommand} fs ${fsPath} --recursive --deploy-id ${deployId} --storage-file-path engine-private/conf/${deployId}/storage.bundle.json --force`,
+      );
+    },
+
+    /**
+     * @method pull-bundle
+     * @description Downloads split zip parts from file storage, merges and extracts them, and moves the result into the public directory.
+     *   Steps: set cron env, download parts (omit-unzip), merge zip, unzip, remove zip, move to public/<host>.
+     * @param {string} path - Optional host name(s) used to locate zip(s) and as public destination(s) (e.g. 'underpost.net' or 'a.com,b.com').
+     *   If omitted, hosts are loaded from `engine-private/conf/<deployId>/conf.server.json`.
+     * @param {Object} options - The default underpost runner options for customizing workflow.
+     * @param {string} [options.deployId] - Deploy ID for storage lookup (defaults to 'dd-default').
+     * @param {boolean} [options.dev] - Use development environment; defaults to production.
+     * @memberof UnderpostRun
+     */
+    'pull-bundle': (path = '', options = DEFAULT_OPTION) => {
+      const baseCommand = options.dev ? 'node bin' : 'underpost';
+      const env = options.dev ? 'development' : 'production';
+      const deployId = options.deployId || 'dd-default';
+      const confServerPath = `./engine-private/conf/${deployId}/conf.server.json`;
+      const hosts = path
+        ? path
+            .split(',')
+            .map((h) => h.trim())
+            .filter(Boolean)
+        : fs.existsSync(confServerPath)
+          ? Object.keys(loadConfServerJson(confServerPath))
+          : [];
+
+      if (hosts.length === 0) {
+        logger.error('pull-bundle: no hosts resolved', {
+          deployId,
+          path,
+          confServerPath,
+        });
+        return;
+      }
+
+      shellExec(`${baseCommand} env ${deployId} ${env}`);
+      if (!fs.existsSync('./build')) fs.mkdirSync('./build', { recursive: true });
+      shellExec(
+        `${baseCommand} fs build --recursive --deploy-id ${deployId} --storage-file-path engine-private/conf/${deployId}/storage.bundle.json --pull --omit-unzip`,
+      );
+      for (const host of hosts) {
+        const zipPath = `build/${host}-.zip`;
+        const hasZip = fs.existsSync(zipPath);
+        const hasParts =
+          fs.existsSync('./build') &&
+          fs
+            .readdirSync('./build')
+            .some((name) => name.startsWith(`${host}-.zip.part`) || name.startsWith(`${host}-.zip-part`));
+
+        if (!hasZip && !hasParts) {
+          logger.warn(`Bundle not found for host '${host}'. Skipping host.`, {
+            zipPath,
+            deployId,
+          });
+          continue;
+        }
+
+        if (hasParts) shellExec(`${baseCommand} client --merge-zip ${zipPath}`);
+        shellExec(`${baseCommand} client --unzip ${zipPath}`);
+        shellExec(`sudo rm -rf ${zipPath}`);
+        if (fs.existsSync(`public/${host}`)) shellExec(`sudo rm -rf public/${host}`);
+        shellExec(`sudo mv build/${host} public/${host}`);
+      }
+    },
   };
 
   static API = {

package/src/cli/ssh.js

@@ -315,7 +315,7 @@ EOF`);
         console.log(`group_name : password_x : GID(Internal Group ID) : user_list`.blue);
         console.log(filter ? groupsOut.replaceAll(filter, filter.red) : groupsOut);
         console.log('Users'.bold.blue);
-        console.log(`usuario : x : UID : GID : GECOS : home_dir : shell`.blue);
+        console.log(`user : x : UID : GID : GECOS : home_dir : shell`.blue);
         console.log(filter ? usersOut.replaceAll(filter, filter.red) : usersOut);
       }