underpost 3.1.3 → 3.2.2

package/src/cli/kubectl.js

@@ -0,0 +1,211 @@
+/**
+ * Kubectl module providing low-level Kubernetes resource management primitives.
+ * Centralises pod querying, file transfer, and in-container execution operations
+ * that were previously scattered across db, deploy, and cluster modules.
+ * @module src/cli/kubectl.js
+ * @namespace UnderpostKubectl
+ */
+
+import { loggerFactory } from '../server/logger.js';
+import { shellExec } from '../server/process.js';
+import Underpost from '../index.js';
+
+const logger = loggerFactory(import.meta);
+
+/**
+ * Redacts credentials from shell command strings before logging.
+ * Masks passwords in `-p<password>`, `--password=<password>`, and `-P <password>` patterns.
+ * @param {string} cmd - The raw command string.
+ * @returns {string} The command with credentials replaced by `***`.
+ * @memberof UnderpostKubectl
+ */
+const sanitizeCommand = (cmd) => {
+  if (typeof cmd !== 'string') return cmd;
+  return cmd
+    .replace(/-p['"]?[^\s'"]+/g, '-p***')
+    .replace(/--password=['"]?[^\s'"]+/g, '--password=***')
+    .replace(/-P\s+['"]?[^\s'"]+/g, '-P ***');
+};
+
+/**
+ * @class UnderpostKubectl
+ * @description Kubernetes cluster resource management primitives.
+ * Provides a unified interface for kubectl operations: resource listing, in-pod
+ * command execution, file transfer, and pod discovery/filtering.
+ * All methods are stateless and safe to call from any other CLI module.
+ * @memberof UnderpostKubectl
+ */
+class UnderpostKubectl {
+  static API = {
+    /**
+     * Lists Kubernetes resources matching `deployId`, parsed into plain objects.
+     * Equivalent to `kubectl get <kindType> -o wide`, filtered by name substring.
+     * @param {string} deployId - Substring to match against resource names. Empty string returns all.
+     * @param {string} [kindType='pods'] - Resource kind: pods, deployments, svc, nodes, …
+     * @param {string} [namespace=''] - Namespace to query; empty string → --all-namespaces.
+     * @returns {Array<object>} Parsed rows keyed by column header (NAME, STATUS, NODE, …).
+     * @memberof UnderpostKubectl
+     */
+    get(deployId, kindType = 'pods', namespace = '') {
+      const raw = shellExec(
+        `sudo kubectl get ${kindType}${namespace ? ` -n ${namespace}` : ` --all-namespaces`} -o wide`,
+        { stdout: true, disableLog: true, silent: true },
+      );
+
+      const heads = raw
+        .split(`\n`)[0]
+        .split(' ')
+        .filter((_r) => _r.trim());
+
+      const pods = raw
+        .split(`\n`)
+        .filter((r) => (deployId ? r.match(deployId) : r.trim() && !r.match('NAME')))
+        .map((r) => r.split(' ').filter((_r) => _r.trim()));
+
+      const result = [];
+      for (const row of pods) {
+        const pod = {};
+        let index = -1;
+        for (const head of heads) {
+          index++;
+          pod[head] = row[index];
+        }
+        result.push(pod);
+      }
+      return result;
+    },
+
+    /**
+     * Executes a kubectl command with credential-safe logging and error propagation.
+     * @param {string} command - Full kubectl command string.
+     * @param {object} [options={}] - Execution options.
+     * @param {string} [options.context=''] - Human-readable label for log messages.
+     * @returns {string} stdout output from the command.
+     * @throws {Error} Re-throws any execution error after logging.
+     * @memberof UnderpostKubectl
+     */
+    run(command, options = {}) {
+      const { context = '' } = options;
+      try {
+        logger.info(`Executing kubectl command`, { command: sanitizeCommand(command), context });
+        return shellExec(command, { stdout: true, disableLog: true });
+      } catch (error) {
+        logger.error(`kubectl command failed`, { command: sanitizeCommand(command), error: error.message, context });
+        throw error;
+      }
+    },
+
+    /**
+     * Runs a shell command inside a pod container via `kubectl exec`.
+     * @param {object} params
+     * @param {string} params.podName - Target pod name.
+     * @param {string} params.namespace - Pod namespace.
+     * @param {string} params.command - Shell command to run inside the container.
+     * @returns {string} stdout output from the in-pod command.
+     * @throws {Error} Re-throws any execution error after logging.
+     * @memberof UnderpostKubectl
+     */
+    exec({ podName, namespace, command }) {
+      try {
+        const kubectlCmd = `sudo kubectl exec -n ${namespace} -i ${podName} -- sh -c "${command}"`;
+        return Underpost.kubectl.run(kubectlCmd, { context: `exec in pod ${podName}` });
+      } catch (error) {
+        logger.error('Failed to execute command in pod', {
+          podName,
+          command: sanitizeCommand(command),
+          error: error.message,
+        });
+        throw error;
+      }
+    },
+
+    /**
+     * Copies a local file into a pod via `kubectl cp`.
+     * @param {object} params
+     * @param {string} params.sourcePath - Local source path.
+     * @param {string} params.podName - Target pod name.
+     * @param {string} params.namespace - Pod namespace.
+     * @param {string} params.destPath - Destination path inside the container.
+     * @returns {boolean} `true` on success, `false` on error.
+     * @memberof UnderpostKubectl
+     */
+    cpTo({ sourcePath, podName, namespace, destPath }) {
+      try {
+        const command = `sudo kubectl cp ${sourcePath} ${namespace}/${podName}:${destPath}`;
+        Underpost.kubectl.run(command, { context: `copy to pod ${podName}` });
+        return true;
+      } catch (error) {
+        logger.error('Failed to copy file to pod', { sourcePath, podName, destPath, error: error.message });
+        return false;
+      }
+    },
+
+    /**
+     * Copies a file from a pod to the local filesystem via `kubectl cp`.
+     * @param {object} params
+     * @param {string} params.podName - Source pod name.
+     * @param {string} params.namespace - Pod namespace.
+     * @param {string} params.sourcePath - Source path inside the container.
+     * @param {string} params.destPath - Local destination path.
+     * @returns {boolean} `true` on success, `false` on error.
+     * @memberof UnderpostKubectl
+     */
+    cpFrom({ podName, namespace, sourcePath, destPath }) {
+      try {
+        const command = `sudo kubectl cp ${namespace}/${podName}:${sourcePath} ${destPath}`;
+        Underpost.kubectl.run(command, { context: `copy from pod ${podName}` });
+        return true;
+      } catch (error) {
+        logger.error('Failed to copy file from pod', { podName, sourcePath, destPath, error: error.message });
+        return false;
+      }
+    },
+
+    /**
+     * Checks whether a file exists inside a pod container.
+     * @param {object} params
+     * @param {string} params.podName - Pod name.
+     * @param {string} params.path - Absolute path inside the container to test.
+     * @returns {boolean} `true` if the file exists.
+     * @memberof UnderpostKubectl
+     */
+    existsFile({ podName, path }) {
+      const result = shellExec(`kubectl exec ${podName} -- test -f ${path} && echo "true" || echo "false"`, {
+        stdout: true,
+        disableLog: true,
+        silent: true,
+      }).trim();
+      return result === 'true';
+    },
+
+    /**
+     * Returns a filtered list of pods from the cluster.
+     * Supports wildcard glob patterns on pod names and optional deployId substring filtering.
+     * @param {object} [criteria={}] - Filter criteria.
+     * @param {string} [criteria.deployId] - Substring to match against pod names (forwards to `get`).
+     * @param {string} [criteria.podNames] - Comma-separated glob patterns (supports `*`).
+     * @param {string} [criteria.namespace='default'] - Kubernetes namespace to query.
+     * @returns {Array<object>} Filtered pod rows from `get`.
+     * @memberof UnderpostKubectl
+     */
+    getFilteredPods(criteria = {}) {
+      const { podNames, namespace = 'default', deployId } = criteria;
+      try {
+        let pods = Underpost.kubectl.get(deployId || '', 'pods', namespace);
+        if (podNames) {
+          const patterns = podNames.split(',').map((p) => p.trim());
+          pods = pods.filter((pod) =>
+            patterns.some((pattern) => new RegExp('^' + pattern.replace(/\*/g, '.*') + '$').test(pod.NAME)),
+          );
+        }
+        logger.info(`Found ${pods.length} pod(s) matching criteria`, { criteria, podNames: pods.map((p) => p.NAME) });
+        return pods;
+      } catch (error) {
+        logger.error('Error filtering pods', { error: error.message, criteria });
+        return [];
+      }
+    },
+  };
+}
+
+export default UnderpostKubectl;

package/src/cli/release.js

@@ -0,0 +1,284 @@
+/**
+ * Release orchestrator module for managing version builds and deployments of the Underpost CLI.
+ *
+ * Provides automated workflows for building new versions (bumping version numbers across
+ * all package files, manifests, and configurations) and deploying releases (committing,
+ * pushing, and syncing secrets to remote repositories).
+ *
+ * @module src/cli/release.js
+ * @namespace UnderpostRelease
+ */
+
+import fs from 'fs-extra';
+import dotenv from 'dotenv';
+import { pbcopy, shellCd, shellExec } from '../server/process.js';
+import { loggerFactory } from '../server/logger.js';
+import { timer } from '../client/components/core/CommonJs.js';
+import Underpost from '../index.js';
+
+const logger = loggerFactory(import.meta);
+
+/**
+ * Kills any Node.js dev-server or nodemon processes that may hold file locks
+ * (e.g. overwriting package.json). Skips VSCode internals and the current process.
+ */
+function killDevServers() {
+  // shellExec(
+  //   `kill -9 $(pgrep -f 'nodemon|node.*src/server|node.*dev' | grep -v '^${process.pid}$') 2>/dev/null || true`,
+  // );
+  shellExec(`node bin run kill 4001`);
+  shellExec(`node bin run kill 4002`);
+  shellExec(`node bin run kill 4003`);
+  shellExec(`node bin run kill 3000`);
+}
+
+/**
+ * @class UnderpostRelease
+ * @description Orchestrates version builds and release deployments for the Underpost CLI.
+ * This class provides static methods to automate the full release lifecycle:
+ * building a new version (testing, bumping versions, rebuilding manifests)
+ * and deploying a release (syncing secrets, committing, and pushing to remotes).
+ * @memberof UnderpostRelease
+ */
+class UnderpostRelease {
+  static API = {
+    /**
+     * Builds a new version of the Underpost engine.
+     *
+     * Performs the full version build pipeline:
+     * 1. Loads production environment and pulls latest code.
+     * 2. Kills running dev servers on ports 4001-4003.
+     * 3. Builds and tests the pwa-microservices-template.
+     * 4. Bumps version in package.json, package-lock.json, and all conf package files.
+     * 5. Updates deployment YAML manifests and Docker image CI workflow with new version.
+     * 6. Updates src/index.js version string.
+     * 7. Rebuilds CLI docs, dependencies, client builds, deploy manifests, and default confs.
+     * 8. Syncs cron setup-start scripts and builds changelog.
+     *
+     * @method build
+     * @param {string} [newVersion] - The new version string to set. Defaults to current version if not provided.
+     * @param {object} [options] - Commander options object (unused, reserved for future flags).
+     * @memberof UnderpostRelease
+     */
+    async build(newVersion, options) {
+      dotenv.config({ path: `./engine-private/conf/dd-cron/.env.production`, override: true });
+      shellCd(`/home/dd/engine`);
+      killDevServers();
+      Underpost.repo.clean({ paths: ['/home/dd/engine', '/home/dd/engine/engine-private '] });
+      shellExec(`node bin pull . ${process.env.GITHUB_USERNAME}/engine`);
+      shellExec(`npm run update:template`);
+      shellExec(`cd ../pwa-microservices-template && npm install && npm run build`);
+      console.log(fs.existsSync(`../pwa-microservices-template/engine-private/conf/dd-default`));
+      shellExec(`cd ../pwa-microservices-template && ENABLE_FILE_LOGS=true timeout 5s npm run dev`, {
+        async: true,
+      });
+      await timer(5500);
+      const templateRunnerResult = fs.readFileSync(`../pwa-microservices-template/logs/start.js/all.log`, 'utf8');
+      logger.info('Test template runner result');
+      console.log(templateRunnerResult);
+      if (!templateRunnerResult || templateRunnerResult.toLowerCase().match('error')) {
+        logger.error('Test template runner result failed');
+        return;
+      }
+      killDevServers();
+      shellCd(`/home/dd/engine`);
+      Underpost.repo.clean({ paths: ['/home/dd/engine', '/home/dd/engine/engine-private '] });
+      const originPackageJson = JSON.parse(fs.readFileSync(`package.json`, 'utf8'));
+      if (!newVersion) newVersion = originPackageJson.version;
+      const { version } = originPackageJson;
+      originPackageJson.version = newVersion;
+      fs.writeFileSync(`package.json`, JSON.stringify(originPackageJson, null, 4), 'utf8');
+
+      const originPackageLockJson = JSON.parse(fs.readFileSync(`package-lock.json`, 'utf8'));
+      originPackageLockJson.version = newVersion;
+      originPackageLockJson.packages[''].version = newVersion;
+      fs.writeFileSync(`package-lock.json`, JSON.stringify(originPackageLockJson, null, 4), 'utf8');
+
+      if (fs.existsSync(`./engine-private/conf`)) {
+        const files = await fs.readdir(`./engine-private/conf`, { recursive: true });
+        for (const relativePath of files) {
+          const filePah = `./engine-private/conf/${relativePath.replaceAll(`\\`, '/')}`;
+          if (filePah.split('/').pop() === 'package.json') {
+            const originPackage = JSON.parse(fs.readFileSync(filePah, 'utf8'));
+            originPackage.version = newVersion;
+            fs.writeFileSync(filePah, JSON.stringify(originPackage, null, 4), 'utf8');
+          }
+          if (filePah.split('/').pop() === 'deployment.yaml') {
+            fs.writeFileSync(
+              filePah,
+              fs
+                .readFileSync(filePah, 'utf8')
+                .replaceAll(`v${version}`, `v${newVersion}`)
+                .replaceAll(`engine.version: ${version}`, `engine.version: ${newVersion}`),
+              'utf8',
+            );
+          }
+        }
+      }
+
+      fs.writeFileSync(
+        `./manifests/deployment/dd-default-development/deployment.yaml`,
+        fs
+          .readFileSync(`./manifests/deployment/dd-default-development/deployment.yaml`, 'utf8')
+          .replaceAll(`underpost:v${version}`, `underpost:v${newVersion}`),
+        'utf8',
+      );
+
+      if (fs.existsSync(`./.github/workflows/docker-image.ci.yml`))
+        fs.writeFileSync(
+          `./.github/workflows/docker-image.ci.yml`,
+          fs
+            .readFileSync(`./.github/workflows/docker-image.ci.yml`, 'utf8')
+            .replaceAll(`underpost-engine:v${version}`, `underpost-engine:v${newVersion}`),
+          'utf8',
+        );
+
+      fs.writeFileSync(
+        `./src/index.js`,
+        fs.readFileSync(`./src/index.js`, 'utf8').replaceAll(`${version}`, `${newVersion}`),
+        'utf8',
+      );
+      shellExec(`node bin/deploy cli-docs ${version} ${newVersion}`);
+      shellExec(`node bin/deploy update-dependencies`);
+      shellExec(`node bin/build dd`);
+      shellExec(`node bin deploy --build-manifest --sync --info-router --replicas 1 dd production`);
+      shellExec(`node bin deploy --build-manifest --sync --info-router --replicas 1 dd development`);
+      shellExec(`node bin/deploy build-default-confs`);
+      shellExec(`sudo rm -rf ./engine-private/conf/dd-default`);
+      shellExec(`node bin new --deploy-id dd-default`);
+      console.log(fs.existsSync(`./engine-private/conf/dd-default`));
+      shellExec(`sudo rm -rf ./engine-private/conf/dd-default`);
+      shellExec(`node bin cron --dev --setup-start`);
+      shellExec(`node bin cmt --changelog-build`);
+    },
+
+    /**
+     * Runs the local equivalent of an engine-*.ci.yml GitHub Actions workflow.
+     *
+     * Mirrors the CI pipeline locally:
+     * 1. Loads production environment (for GITHUB_TOKEN / GITHUB_USERNAME).
+     * 2. Clones pwa-microservices-template and engine-{suffix} (bare) into the parent dir (/home/dd).
+     * 3. Builds dd-{suffix} development from the engine directory.
+     * 4. Replaces .git in pwa-microservices-template with the bare-cloned git, then commits and pushes
+     *    to the underpostnet/engine-{suffix} remote repository.
+     *
+     * @method ci
+     * @param {string} deployId - The deploy-id suffix (e.g., "cyberia", "core", "lampp", "test").
+     *   Accepts "cyberia", "dd-cyberia", or "engine-cyberia" — the prefix is stripped automatically.
+     * @param {string} [message] - Optional commit message. Defaults to the last commit message of pwa-microservices-template.
+     * @param {object} [options] - Commander options object (unused, reserved for future flags).
+     * @memberof UnderpostRelease
+     */
+    async ci(deployId, message, options) {
+      dotenv.config({ path: `./engine-private/conf/dd-cron/.env.production`, override: true });
+      const suffix = deployId.replace(/^(dd-|engine-)/, '');
+      const repoName = `engine-${suffix}`;
+      const buildTarget = `dd-${suffix}`;
+      const githubOrg = process.env.GITHUB_USERNAME || 'underpostnet';
+      shellCd('/home/dd');
+      shellExec(`sudo rm -rf /home/dd/pwa-microservices-template`);
+      shellExec(`node engine/bin clone ${githubOrg}/pwa-microservices-template`);
+      // Use the message passed from the caller (engine repo changelog);
+      // fall back to the engine repo's last commit if not provided.
+      let commitMsg = message;
+      if (!commitMsg) {
+        shellCd('/home/dd/engine');
+        const rawMsg = shellExec(`node bin cmt --changelog 1 --changelog-no-hash`, {
+          stdout: true,
+          silent: true,
+        }).trim();
+        commitMsg = Underpost.repo.sanitizeChangelogMessage(rawMsg);
+        shellCd('/home/dd');
+      }
+      commitMsg = (commitMsg || '').trim() || `Update ${repoName} repository`;
+      logger.info(`CI push commit message: ${commitMsg}`);
+      shellExec(`node engine/bin clone --bare ${githubOrg}/${repoName}`);
+      shellCd('/home/dd/engine');
+      shellExec(`node bin/build ${buildTarget}`);
+      shellCd('/home/dd/pwa-microservices-template');
+      shellExec(`rm -rf ./.git`);
+      shellExec(`mv ../${repoName}.git ./.git`);
+      shellExec(`git config --local core.bare false`);
+      shellExec(`git reset`);
+      Underpost.repo.initLocalRepo({ path: '/home/dd/pwa-microservices-template' });
+      return {
+        triggerCmd: `cd /home/dd/pwa-microservices-template && git add . && git commit -m "${commitMsg}" && node ../engine/bin push . ${githubOrg}/${repoName}`,
+      };
+    },
+
+    /**
+     * Runs the pwa-microservices-template update and push flow locally.
+     *
+     * Always removes and re-clones pwa-microservices-template, then:
+     * 1. Runs update:template (node bin/file update-template) to sync engine sources.
+     * 2. Installs dependencies and builds the template.
+     * 3. Commits and pushes to the pwa-microservices-template remote repository.
+     *
+     * @method pwa
+     * @param {string} [message] - Optional commit message. Defaults to last commit message of pwa-microservices-template.
+     * @param {object} [options] - Commander options object (unused, reserved for future flags).
+     * @memberof UnderpostRelease
+     */
+    async pwa(message, options) {
+      dotenv.config({ path: `./engine-private/conf/dd-cron/.env.production`, override: true });
+      const githubOrg = process.env.GITHUB_USERNAME || 'underpostnet';
+      // Use the message passed from the caller (engine repo changelog);
+      // fall back to the engine repo's last commit if not provided.
+      let commitMsg = message;
+      if (!commitMsg) {
+        shellCd('/home/dd/engine');
+        const rawMsg = shellExec(`node bin cmt --changelog 1 --changelog-no-hash`, {
+          stdout: true,
+          silent: true,
+        }).trim();
+        commitMsg = Underpost.repo.sanitizeChangelogMessage(rawMsg);
+      }
+      commitMsg = (commitMsg || '').trim() || `Update pwa-microservices-template repository`;
+      shellCd('/home/dd');
+      shellExec(`sudo rm -rf /home/dd/pwa-microservices-template`);
+      shellExec(`node engine/bin clone ${githubOrg}/pwa-microservices-template`);
+      shellCd('/home/dd/engine');
+      shellExec(`npm run update:template`);
+      shellExec(`cd ../pwa-microservices-template && npm install && npm run build`);
+      shellCd('/home/dd/pwa-microservices-template');
+      shellExec(`git add .`);
+      // shellExec(`git commit -m "${commitMsg}"`);
+      return {
+        triggerCmd: `node bin push . ${githubOrg}/engine && cd /home/dd/pwa-microservices-template && git commit -m "${commitMsg}" && node ../engine/bin push . ${githubOrg}/pwa-microservices-template`,
+      };
+    },
+
+    /**
+     * Deploys a new version release to remote repositories.
+     *
+     * Performs the release deployment pipeline:
+     * 1. Loads production environment from dd-cron.
+     * 2. Syncs Underpost secrets from the production env file.
+     * 3. Builds the dd configuration.
+     * 4. Stages all changes in both engine and engine-private repositories.
+     * 5. Commits with a release message including the version tag.
+     * 6. Pushes both repositories to their respective GitHub remotes.
+     *
+     * @method deploy
+     * @param {string} [version] - The version string for the release commit message (e.g., "3.1.4").
+     * @param {object} [options] - Commander options object (unused, reserved for future flags).
+     * @memberof UnderpostRelease
+     */
+    async deploy(version, options) {
+      dotenv.config({ path: `./engine-private/conf/dd-cron/.env.production`, override: true });
+      killDevServers();
+      shellExec(
+        `node bin secret underpost --create-from-file /home/dd/engine/engine-private/conf/dd-cron/.env.production`,
+      );
+      shellExec(`node bin/build dd conf`);
+      shellExec(`git add . && cd ./engine-private && git add .`);
+      shellExec(`node bin cmt . ci package-pwa-microservices-template 'New release v:${version}'`);
+      shellExec(`node bin cmt ./engine-private ci package-pwa-microservices-template`);
+      shellExec(`node bin push . ${process.env.GITHUB_USERNAME}/engine`);
+      shellExec(`cd ./engine-private && node ../bin push . ${process.env.GITHUB_USERNAME}/engine-private`);
+    },
+  };
+}
+
+export { UnderpostRelease };
+export default UnderpostRelease;