cyberia 3.0.3 → 3.2.5

package/src/cli/deploy.js

@@ -11,6 +11,7 @@ import {
   Config,
   deployRangePortFactory,
   getDataDeploy,
+  loadConfServerJson,
   loadReplicas,
   pathPortAssignmentFactory,
 } from '../server/conf.js';
@@ -131,22 +132,16 @@ class UnderpostDeploy {
         cmd = [
           `npm install -g npm@11.2.0`,
           `npm install -g underpost`,
-          `underpost secret underpost --create-from-file /etc/config/.env.${env}`,
-          `underpost start --build --run --underpost-quickly-install ${deployId} ${env}`,
+          `underpost secret underpost --create-from-env`,
+          `underpost start --build --run ${deployId} ${env}`,
         ];
       const packageJson = JSON.parse(fs.readFileSync('./package.json', 'utf8'));
-      if (!volumes)
-        volumes = [
-          {
-            volumeMountPath: '/etc/config',
-            volumeName: 'config-volume',
-            configMap: 'underpost-config',
-          },
-        ];
+      if (!volumes) volumes = [];
       const confVolume = fs.existsSync(`./engine-private/conf/${deployId}/conf.volume.json`)
         ? JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.volume.json`, 'utf8'))
         : [];
       volumes = volumes.concat(confVolume);
+      const containerImage = image ? image : `localhost/rockylinux9-underpost:v${packageJson.version}`;
       return `apiVersion: apps/v1
 kind: Deployment
 metadata:
@@ -154,6 +149,7 @@ metadata:
   namespace: ${namespace ? namespace : 'default'}
   labels:
     app: ${deployId}-${env}-${suffix}
+    deploy-id: ${deployId}-${env}
 spec:
   replicas: ${replicas}
   selector:
@@ -163,10 +159,14 @@ spec:
     metadata:
       labels:
         app: ${deployId}-${env}-${suffix}
+        deploy-id: ${deployId}-${env}
     spec:
       containers:
         - name: ${deployId}-${env}-${suffix}
-          image: ${image ? image : `localhost/rockylinux9-underpost:v${packageJson.version}`}
+          image: ${containerImage}
+          envFrom:
+            - secretRef:
+                name: underpost-config
 ${
   resources
     ? `          resources:
@@ -182,13 +182,17 @@ ${
             - /bin/sh
             - -c
             - >
-              ${cmd.join(` && `)}
+              ${cmd.join(' &&\n              ')}
 
-${Underpost.deploy
-  .volumeFactory(volumes.map((v) => ((v.version = `${deployId}-${env}-${suffix}`), v)))
-  .render.split(`\n`)
-  .map((l) => '    ' + l)
-  .join(`\n`)}
+${
+  volumes.length > 0
+    ? Underpost.deploy
+        .volumeFactory(volumes.map((v) => ((v.version = `${deployId}-${env}-${suffix}`), v)))
+        .render.split(`\n`)
+        .map((l) => '    ' + l)
+        .join(`\n`)
+    : ''
+}
 ---
 apiVersion: v1
 kind: Service
@@ -230,7 +234,7 @@ spec:
         if (!deployId) continue;
         const confServer = loadReplicas(
           deployId,
-          JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8')),
+          loadConfServerJson(`./engine-private/conf/${deployId}/conf.server.json`),
         );
         const router = await Underpost.deploy.routerFactory(deployId, env);
         const pathPortAssignmentData = await pathPortAssignmentFactory(deployId, router, confServer);
@@ -259,6 +263,35 @@ ${Underpost.deploy
         }
         fs.writeFileSync(`./engine-private/conf/${deployId}/build/${env}/deployment.yaml`, deploymentYamlParts, 'utf8');
 
+        Underpost.deploy.buildGrpcServiceManifest({
+          deployId,
+          env,
+          confServer,
+          namespace: options.namespace,
+          traffic: options.traffic && typeof options.traffic === 'string' ? options.traffic.split(',') : ['blue'],
+        });
+
+        const confVolume = fs.existsSync(`./engine-private/conf/${deployId}/conf.volume.json`)
+          ? JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.volume.json`, 'utf8'))
+          : [];
+        if (confVolume.length > 0) {
+          let volumeYaml = '';
+          for (const deploymentVersion of deploymentVersions) {
+            for (const volume of confVolume) {
+              if (!volume.claimName) continue;
+              const pvcId = `${volume.claimName}-${deployId}-${env}-${deploymentVersion}`;
+              const pvId = pvcId.replace(/^pvc-/, 'pv-');
+              const hostPath = `/home/dd/engine/volume/${pvId}`;
+              volumeYaml += `---\n${Underpost.deploy.persistentVolumeFactory({
+                pvcId,
+                namespace: options.namespace,
+                hostPath,
+              })}\n`;
+            }
+          }
+          fs.writeFileSync(`./engine-private/conf/${deployId}/build/${env}/pv-pvc.yaml`, volumeYaml, 'utf8');
+        }
+
         let proxyYaml = '';
         let secretYaml = '';
         const customServices = fs.existsSync(`./engine-private/conf/${deployId}/conf.services.json`)
@@ -335,7 +368,7 @@ ${Underpost.deploy
           const yamlPath = `./engine-private/conf/${deployId}/build/${env}/secret.yaml`;
           fs.writeFileSync(yamlPath, secretYaml, 'utf8');
         } else {
-          const deploymentsFiles = ['Dockerfile', 'proxy.yaml', 'deployment.yaml'];
+          const deploymentsFiles = ['Dockerfile', 'proxy.yaml', 'deployment.yaml', 'pv-pvc.yaml'];
           for (const file of deploymentsFiles) {
             if (fs.existsSync(`./engine-private/conf/${deployId}/build/${env}/${file}`)) {
               fs.copyFileSync(
@@ -347,6 +380,67 @@ ${Underpost.deploy
         }
       }
     },
+    /**
+     * Builds and writes a gRPC ClusterIP service YAML for a deployment.
+     * Scans conf.server.json for gRPC ports and emits grpc-service.yaml under
+     * `engine-private/conf/<deployId>/build/<env>/`. The selector always uses the
+     * explicit `app: <deployId>-<env>-<traffic>` label to target only the active
+     * colour (blue or green).
+     * @param {string} deployId - Deployment ID.
+     * @param {string} env - Environment ('development' or 'production').
+     * @param {object} confServer - Parsed conf.server.json content.
+     * @param {string} [namespace='default'] - Kubernetes namespace.
+     * @param {string[]} [traffic=['blue']] - Active traffic colour(s) ('blue', 'green', or both).
+     * @param {string|null} [host=null] - Specific host to scan for gRPC ports. If null, all hosts are scanned.
+     * @returns {string|null} - Path to the written YAML file, or null if no gRPC ports found.
+     * @memberof UnderpostDeploy
+     */
+    buildGrpcServiceManifest({ deployId, env, confServer, namespace = 'default', traffic = ['blue'], host = null }) {
+      const grpcPorts = new Set();
+      const hostsToScan = host ? [host] : Object.keys(confServer);
+      for (const h of hostsToScan) {
+        if (!confServer[h]) continue;
+        for (const path of Object.keys(confServer[h])) {
+          const grpc = confServer[h][path].grpc;
+          if (grpc && grpc.port) grpcPorts.add(parseInt(grpc.port));
+        }
+      }
+      if (grpcPorts.size === 0) return null;
+      const grpcPortsList = [...grpcPorts]
+        .map(
+          (port) => `    - name: grpc-${port}
+      protocol: TCP
+      port: ${port}
+      targetPort: ${port}`,
+        )
+        .join('\n');
+      let grpcServiceYaml = '';
+      for (const color of traffic) {
+        const grpcServiceName = `${deployId}-grpc-service-${env}-${color}`;
+        const selectorYaml = `app: ${deployId}-${env}-${color}`;
+        grpcServiceYaml += `---
+apiVersion: v1
+kind: Service
+metadata:
+  name: ${grpcServiceName}
+  namespace: ${namespace}
+  labels:
+    app: ${grpcServiceName}
+spec:
+  type: ClusterIP
+  selector:
+    ${selectorYaml}
+  ports:
+${grpcPortsList}
+`;
+        logger.info(
+          `gRPC ClusterIP service YAML written: ${grpcServiceName} (selector: ${selectorYaml}, ports: ${[...grpcPorts].join(', ')})`,
+        );
+      }
+      const yamlPath = `./engine-private/conf/${deployId}/build/${env}/grpc-service.yaml`;
+      fs.writeFileSync(yamlPath, grpcServiceYaml, 'utf8');
+      return yamlPath;
+    },
     /**
      * Builds a Certificate resource for a host using cert-manager.
      * @param {string} host - Hostname for which the certificate is being built.
@@ -385,7 +479,7 @@ spec:
       // kubectl get deploy,sts,svc,configmap,secret -n default -o yaml --export > default.yaml
       const hostTest = options?.hostTest
         ? options.hostTest
-        : Object.keys(JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8')))[0];
+        : Object.keys(loadConfServerJson(`./engine-private/conf/${deployId}/conf.server.json`))[0];
       const info = shellExec(`sudo kubectl get HTTPProxy/${hostTest} -n ${options.namespace} -o yaml`, {
         silent: true,
         stdout: true,
@@ -456,6 +550,10 @@ spec:
      * @param {string} [options.kindType] - Type of Kubernetes resource to retrieve information for.
      * @param {number} [options.port] - Port number for exposing the deployment.
      * @param {string} [options.cmd] - Custom initialization command for deploymentYamlPartsFactory (comma-separated commands).
+     * @param {boolean} [options.k3s] - Whether to use k3s cluster context.
+     * @param {boolean} [options.kubeadm] - Whether to use kubeadm cluster context.
+     * @param {boolean} [options.kind] - Whether to use kind cluster context.
+     * @param {boolean} [options.gitClean] - Whether to run git clean on volume mount paths before copying.
      * @returns {Promise<void>} - Promise that resolves when the deployment process is complete.
      * @memberof UnderpostDeploy
      */
@@ -493,6 +591,10 @@ spec:
         port: 0,
         exposePort: 0,
         cmd: '',
+        k3s: false,
+        kubeadm: false,
+        kind: false,
+        gitClean: false,
       },
     ) {
       const namespace = options.namespace ? options.namespace : 'default';
@@ -531,7 +633,7 @@ EOF`);
             env,
             traffic: Underpost.deploy.getCurrentTraffic(deployId, { namespace }),
             router: await Underpost.deploy.routerFactory(deployId, env),
-            pods: await Underpost.deploy.get(deployId),
+            pods: await Underpost.kubectl.get(deployId),
             instances,
           });
         }
@@ -550,7 +652,7 @@ EOF`);
       if (!(options.versions && typeof options.versions === 'string')) options.versions = 'blue,green';
       if (!options.replicas) options.replicas = 1;
       if (options.sync)
-        getDataDeploy({
+        await getDataDeploy({
           buildSingleReplica: true,
         });
       if (options.buildManifest === true) await Underpost.deploy.buildManifest(deployList, env, options);
@@ -573,7 +675,7 @@ EOF`);
         if (!deployId) continue;
         if (options.expose === true) {
           const kindType = options.kindType ? options.kindType : 'svc';
-          const svc = Underpost.deploy.get(deployId, kindType)[0];
+          const svc = Underpost.kubectl.get(deployId, kindType)[0];
           const port = options.exposePort
             ? parseInt(options.exposePort)
             : options.port
@@ -591,7 +693,7 @@ EOF`);
           continue;
         }
 
-        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 confVolume = fs.existsSync(`./engine-private/conf/${deployId}/conf.volume.json`)
           ? JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.volume.json`, 'utf8'))
           : [];
@@ -612,6 +714,8 @@ EOF`);
                   version,
                   namespace,
                   nodeName: options.node ? options.node : env === 'development' ? 'kind-worker' : os.hostname(),
+                  clusterContext: options.k3s ? 'k3s' : options.kubeadm ? 'kubeadm' : 'kind',
+                  gitClean: options.gitClean || false,
                 });
           }
 
@@ -630,8 +734,11 @@ EOF`);
             : `manifests/deployment/${deployId}-${env}`;
 
         if (!options.remove) {
-          if (!options.disableUpdateDeployment)
+          if (!options.disableUpdateDeployment) {
             shellExec(`sudo kubectl apply -f ./${manifestsPath}/deployment.yaml -n ${namespace}`);
+            const grpcServicePath = `./${manifestsPath}/grpc-service.yaml`;
+            if (fs.existsSync(grpcServicePath)) shellExec(`sudo kubectl apply -f ${grpcServicePath} -n ${namespace}`);
+          }
           if (!options.disableUpdateProxy)
             shellExec(`sudo kubectl apply -f ./${manifestsPath}/proxy.yaml -n ${namespace}`);
 
@@ -649,65 +756,6 @@ EOF`);
 ` + renderHosts,
         );
     },
-    /**
-     * Retrieves information about a deployment.
-     * @param {string} deployId - Deployment ID for which information is being retrieved.
-     * @param {string} kindType - Type of Kubernetes resource to retrieve information for (e.g. 'pods').
-     * @param {string} namespace - Kubernetes namespace to retrieve information from.
-     * @returns {Array<object>} - Array of objects containing information about the deployment.
-     * @memberof UnderpostDeploy
-     */
-    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;
-    },
-
-    /**
-     * Checks if a container file exists in a pod.
-     * @param {object} options - Options for the check.
-     * @param {string} options.podName - Name of the pod to check.
-     * @param {string} options.path - Path to the container file to check.
-     * @returns {boolean} - True if the container file exists, false otherwise.
-     * @memberof UnderpostDeploy
-     */
-    existsContainerFile({ 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';
-    },
     /**
      * Checks the status of a deployment.
      * @param {string} deployId - Deployment ID for which the status is being checked.
@@ -720,7 +768,7 @@ EOF`);
      */
     async checkDeploymentReadyStatus(deployId, env, traffic, ignoresNames = [], namespace = 'default') {
       const cmd = `underpost config get container-status`;
-      const pods = Underpost.deploy.get(`${deployId}-${env}-${traffic}`, 'pods', namespace);
+      const pods = Underpost.kubectl.get(`${deployId}-${env}-${traffic}`, 'pods', namespace);
       const readyPods = [];
       const notReadyPods = [];
       for (const pod of pods) {
@@ -746,15 +794,16 @@ EOF`);
       };
     },
     /**
-     * Creates a configmap for a deployment.
-     * @param {string} env - Environment for which the configmap is being created.
-     * @param {string} [namespace='default'] - Kubernetes namespace for the configmap.
+     * Creates a Kubernetes Secret for a deployment (replaces configMap for secret data).
+     * Secrets are mounted as tmpfs (never written to node disk) and support RBAC restrictions.
+     * @param {string} env - Environment for which the secret is being created.
+     * @param {string} [namespace='default'] - Kubernetes namespace for the secret.
      * @memberof UnderpostDeploy
      */
     configMap(env, namespace = 'default') {
-      shellExec(`kubectl delete configmap underpost-config -n ${namespace} --ignore-not-found`);
+      shellExec(`kubectl delete secret underpost-config -n ${namespace} --ignore-not-found`);
       shellExec(
-        `kubectl create configmap underpost-config --from-file=/home/dd/engine/engine-private/conf/dd-cron/.env.${env} --dry-run=client -o yaml | kubectl apply -f - -n ${namespace}`,
+        `kubectl create secret generic underpost-config --from-env-file=/home/dd/engine/engine-private/conf/dd-cron/.env.${env} --dry-run=client -o yaml | kubectl apply -f - -n ${namespace}`,
       );
     },
     /**
@@ -792,6 +841,9 @@ EOF`);
 
       shellExec(`sudo kubectl apply -f ./engine-private/conf/${deployId}/build/${env}/proxy.yaml -n ${namespace}`);
 
+      const grpcServicePath = `./engine-private/conf/${deployId}/build/${env}/grpc-service.yaml`;
+      if (fs.existsSync(grpcServicePath)) shellExec(`kubectl apply -f ${grpcServicePath} -n ${namespace}`);
+
       Underpost.env.set(`${deployId}-${env}-traffic`, targetTraffic);
     },
 
@@ -807,6 +859,8 @@ EOF`);
      * @param {string} options.version - Version of the deployment.
      * @param {string} options.namespace - Kubernetes namespace for the deployment.
      * @param {string} options.nodeName - Node name for the deployment.
+     * @param {string} [options.clusterContext='kind'] - Cluster context type ('kind', 'kubeadm', or 'k3s').
+     * @param {boolean} [options.gitClean=false] - Whether to run git clean on volumeMountPath before copying.
      * @memberof UnderpostDeploy
      */
     deployVolume(
@@ -817,6 +871,8 @@ EOF`);
         version: '',
         namespace: '',
         nodeName: '',
+        clusterContext: 'kind',
+        gitClean: false,
       },
     ) {
       if (!volume.claimName) {
@@ -824,19 +880,26 @@ EOF`);
         return;
       }
       const { deployId, env, version, namespace } = options;
+      const clusterContext = options.clusterContext || 'kind';
       const pvcId = `${volume.claimName}-${deployId}-${env}-${version}`;
       const pvId = `${volume.claimName.replace('pvc-', 'pv-')}-${deployId}-${env}-${version}`;
       const rootVolumeHostPath = `/home/dd/engine/volume/${pvId}`;
+      if (options.gitClean && volume.volumeMountPath) {
+        Underpost.repo.clean({ paths: [volume.volumeMountPath] });
+      }
       if (options.nodeName) {
         if (!fs.existsSync(rootVolumeHostPath)) fs.mkdirSync(rootVolumeHostPath, { recursive: true });
         fs.copySync(volume.volumeMountPath, rootVolumeHostPath);
-      } else {
+      } else if (clusterContext === 'kind') {
         shellExec(`docker exec -i kind-worker bash -c "mkdir -p ${rootVolumeHostPath}"`);
         // shellExec(`docker cp ${volume.volumeMountPath} kind-worker:${rootVolumeHostPath}`);
         shellExec(`tar -C ${volume.volumeMountPath} -c . | docker cp - kind-worker:${rootVolumeHostPath}`);
         shellExec(
           `docker exec -i kind-worker bash -c "chown -R 1000:1000 ${rootVolumeHostPath}; chmod -R 755 ${rootVolumeHostPath}"`,
         );
+      } else {
+        if (!fs.existsSync(rootVolumeHostPath)) fs.mkdirSync(rootVolumeHostPath, { recursive: true });
+        fs.copySync(volume.volumeMountPath, rootVolumeHostPath);
       }
       shellExec(`kubectl delete pvc ${pvcId} -n ${namespace} --ignore-not-found`);
       shellExec(`kubectl delete pv ${pvId} --ignore-not-found`);
@@ -844,6 +907,7 @@ EOF`);
 ${Underpost.deploy.persistentVolumeFactory({
   hostPath: rootVolumeHostPath,
   pvcId,
+  namespace,
 })}
 EOF
 `);
@@ -858,6 +922,8 @@ EOF
      * @param {string} volume.volumeType - Type of the volume (e.g. 'Directory').
      * @param {string|null} volume.claimName - Name of the persistent volume claim (if applicable).
      * @param {string|null} volume.configMap - Name of the config map (if applicable).
+     * @param {string|null} volume.secret - Name of the Kubernetes Secret (if applicable). Mounts as readOnly.
+     * @param {boolean} [volume.emptyDir=false] - If true, uses an emptyDir volume (writable tmpfs).
      * @returns {object} - Object containing the rendered volume mounts and volumes.
      * @memberof UnderpostDeploy
      */
@@ -879,7 +945,17 @@ EOF
       let _volumes = `
   volumes:`;
       volumes.map((volumeData) => {
-        let { volumeName, volumeMountPath, volumeHostPath, volumeType, claimName, configMap, version } = volumeData;
+        let {
+          volumeName,
+          volumeMountPath,
+          volumeHostPath,
+          volumeType,
+          claimName,
+          configMap,
+          secret,
+          emptyDir,
+          version,
+        } = volumeData;
         if (version) {
           volumeName = `${volumeName}-${version}`;
           claimName = claimName ? `${claimName}-${version}` : null;
@@ -887,18 +963,23 @@ EOF
         _volumeMounts += `
         - name: ${volumeName}
           mountPath: ${volumeMountPath}
-`;
+${secret ? `          readOnly: true\n` : ''}`;
 
         _volumes += `
     - name: ${volumeName}
  ${
-   configMap
-     ? `     configMap:
+   emptyDir
+     ? `     emptyDir: {}`
+     : secret
+       ? `     secret:
+        secretName: ${secret}`
+       : configMap
+         ? `     configMap:
         name: ${configMap}`
-     : claimName
-       ? `     persistentVolumeClaim:
+         : claimName
+           ? `     persistentVolumeClaim:
         claimName: ${claimName}`
-       : `     hostPath:
+           : `     hostPath:
         path: ${volumeHostPath}
         type: ${volumeType}
 `
@@ -914,15 +995,44 @@ EOF
      * @param {object} options - Options for the persistent volume and claim creation.
      * @param {string} options.hostPath - Host path for the persistent volume.
      * @param {string} options.pvcId - Persistent volume claim ID.
+     * @param {string} [options.namespace='default'] - Kubernetes namespace for the PVC claimRef.
      * @returns {string} - YAML configuration for the persistent volume and claim.
      * @memberof UnderpostDeploy
      */
-    persistentVolumeFactory({ hostPath, pvcId }) {
-      return fs
-        .readFileSync(`./manifests/pv-pvc-dd.yaml`, 'utf8')
-        .replace('/home/dd', hostPath)
-        .replace('pv-dd', pvcId.replace('pvc-', 'pv-'))
-        .replace('pvc-dd', pvcId);
+    persistentVolumeFactory({ hostPath, pvcId, namespace = 'default' }) {
+      const pvId = pvcId.replace(/^pvc-/, 'pv-');
+      return `apiVersion: v1
+kind: PersistentVolume
+metadata:
+  name: ${pvId}
+spec:
+  capacity:
+    storage: 5Gi
+  accessModes:
+    - ReadWriteOnce
+  persistentVolumeReclaimPolicy: Retain
+  storageClassName: manual
+  claimRef:
+    apiVersion: v1
+    kind: PersistentVolumeClaim
+    name: ${pvcId}
+    namespace: ${namespace}
+  hostPath:
+    path: ${hostPath}
+    type: DirectoryOrCreate
+---
+apiVersion: v1
+kind: PersistentVolumeClaim
+metadata:
+  name: ${pvcId}
+spec:
+  accessModes:
+    - ReadWriteOnce
+  storageClassName: manual
+  volumeName: ${pvId}
+  resources:
+    requests:
+      storage: 5Gi`;
     },
 
     /**
@@ -989,7 +1099,7 @@ ${renderHosts}`,
     async monitorReadyRunner(deployId, env, targetTraffic, ignorePods = [], namespace = 'default', outLogType = '') {
       let checkStatusIteration = 0;
       const checkStatusIterationMsDelay = 1000;
-      const maxIterations = 500;
+      const maxIterations = 3000;
       const deploymentId = `${deployId}-${env}-${targetTraffic}`;
       const iteratorTag = `[${deploymentId}]`;
       logger.info('Deployment init', { deployId, env, targetTraffic, checkStatusIterationMsDelay, namespace });

package/src/cli/env.js

@@ -10,12 +10,23 @@ import { loggerFactory } from '../server/logger.js';
 import dotenv from 'dotenv';
 import { pbcopy } from '../server/process.js';
 
-dotenv.config();
-
 const logger = loggerFactory(import.meta);
 
 /**
- * @class UnderpostEnv
+ * Guards an env file path against stale directory artifacts.
+ * Removes the path if it exists as a directory (e.g. `.env/` created by a previous EISDIR bug).
+ * @param {string} envPath - The path to the environment file.
+ * @memberof UnderpostEnv
+ */
+const guardEnvPath = (envPath) => {
+  if (fs.existsSync(envPath) && !fs.statSync(envPath).isFile()) {
+    logger.warn(`Removing stale directory at env path: ${envPath}`);
+    fs.removeSync(envPath);
+  }
+};
+
+/**
+ * @class UnderpostRootEnv
  * @description Manages the environment variables of the underpost root.
  * @memberof UnderpostEnv
  */
@@ -33,6 +44,7 @@ class UnderpostRootEnv {
      */
     set(key, value, options = { deployId: '', build: false }) {
       const _set = (envPath, key, value) => {
+        guardEnvPath(envPath);
         let env = {};
         if (fs.existsSync(envPath)) env = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
         env[key] = value;
@@ -41,13 +53,16 @@ class UnderpostRootEnv {
       if (options.build) {
         const deployIdList = options.deployId
           ? [options.deployId]
-          : fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8').split(',');
+          : fs.existsSync(`./engine-private/deploy/dd.router`)
+            ? fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8').split(',')
+            : [DEFAULT_DEPLOY_ID];
         for (const deployId of deployIdList)
           for (const envFile of ['test', 'development', 'production'])
             _set(`./engine-private/conf/${deployId}/.env.${envFile}`, key, value);
         return;
       }
       const exeRootPath = `${getNpmRootPath()}/underpost`;
+      fs.ensureDirSync(exeRootPath);
       const envPath = `${exeRootPath}/.env`;
       _set(envPath, key, value);
     },
@@ -60,6 +75,7 @@ class UnderpostRootEnv {
     delete(key) {
       const exeRootPath = `${getNpmRootPath()}/underpost`;
       const envPath = `${exeRootPath}/.env`;
+      guardEnvPath(envPath);
       let env = {};
       if (fs.existsSync(envPath)) env = dotenv.parse(fs.readFileSync(envPath, 'utf8'));
       delete env[key];
@@ -79,7 +95,7 @@ class UnderpostRootEnv {
     get(key, value, options = { plain: false, disableLog: false, copy: false }) {
       const exeRootPath = `${getNpmRootPath()}/underpost`;
       const envPath = `${exeRootPath}/.env`;
-      if (!fs.existsSync(envPath)) {
+      if (!fs.existsSync(envPath) || !fs.statSync(envPath).isFile()) {
         logger.warn(`Empty environment variables`);
         return undefined;
       }
@@ -101,6 +117,7 @@ class UnderpostRootEnv {
     list(key, value, options = {}) {
       const exeRootPath = `${getNpmRootPath()}/underpost`;
       const envPath = `${exeRootPath}/.env`;
+      guardEnvPath(envPath);
       if (!fs.existsSync(envPath)) {
         logger.warn(`Empty environment variables`);
         return {};
@@ -136,7 +153,19 @@ class UnderpostRootEnv {
       const envPath = `${exeRootPath}/.env`;
       fs.removeSync(envPath);
     },
+    /**
+     * @method isInsideContainer
+     * @description Detects whether the current process is running inside a container.
+     * Checks for Kubernetes service injection or Docker's .dockerenv marker.
+     * @returns {boolean} True if running inside a container.
+     * @memberof UnderpostEnv
+     */
+    isInsideContainer() {
+      return !!process.env.KUBERNETES_SERVICE_HOST || fs.existsSync('/.dockerenv');
+    },
   };
 }
 
 export default UnderpostRootEnv;
+
+export { guardEnvPath };