cyberia 2.89.2 → 2.89.45

package/src/cli/deploy.js

@@ -129,15 +129,28 @@ class UnderpostDeploy {
      * @param {object} resources - Resource configuration for the deployment.
      * @param {number} replicas - Number of replicas for the deployment.
      * @param {string} image - Docker image for the deployment.
+     * @param {string} namespace - Kubernetes namespace for the deployment.
      * @returns {string} - YAML deployment configuration for the specified deployment.
      * @memberof UnderpostDeploy
      */
-    deploymentYamlPartsFactory({ deployId, env, suffix, resources, replicas, image }) {
+    deploymentYamlPartsFactory({ deployId, env, suffix, resources, replicas, image, namespace }) {
       const packageJson = JSON.parse(fs.readFileSync('./package.json', 'utf8'));
+      let volumes = [
+        {
+          volumeMountPath: '/etc/config',
+          volumeName: 'config-volume',
+          configMap: 'underpost-config',
+        },
+      ];
+      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);
       return `apiVersion: apps/v1
 kind: Deployment
 metadata:
   name: ${deployId}-${env}-${suffix}
+  namespace: ${namespace ? namespace : 'default'}
   labels:
     app: ${deployId}-${env}-${suffix}
 spec:
@@ -168,18 +181,16 @@ spec:
               npm install -g underpost &&
               underpost secret underpost --create-from-file /etc/config/.env.${env} &&
               underpost start --build --run ${deployId} ${env}
-          volumeMounts:
-            - name: config-volume
-              mountPath: /etc/config
-      volumes:
-        - name: config-volume
-          configMap:
-            name: underpost-config
+${UnderpostDeploy.API.volumeFactory(volumes.map((v) => ((v.version = `${deployId}-${env}-${suffix}`), v)))
+  .render.split(`\n`)
+  .map((l) => '    ' + l)
+  .join(`\n`)}
 ---
 apiVersion: v1
 kind: Service
 metadata:
   name: ${deployId}-${env}-${suffix}-service
+  namespace: ${namespace}
 spec:
   selector:
     app: ${deployId}-${env}-${suffix}
@@ -193,6 +204,7 @@ spec:
      * @param {object} options - Options for the manifest build process.
      * @param {string} options.replicas - Number of replicas for each deployment.
      * @param {string} options.image - Docker image for the deployment.
+     * @param {string} options.namespace - Kubernetes namespace for the deployment.
      * @returns {Promise<void>} - Promise that resolves when the manifest is built.
      * @memberof UnderpostDeploy
      */
@@ -200,6 +212,7 @@ spec:
       const resources = UnderpostDeploy.API.resourcesFactory();
       const replicas = options.replicas;
       const image = options.image;
+      if (!options.namespace) options.namespace = 'default';
 
       for (const _deployId of deployList.split(',')) {
         const deployId = _deployId.trim();
@@ -227,6 +240,7 @@ ${UnderpostDeploy.API.deploymentYamlPartsFactory({
   resources,
   replicas,
   image,
+  namespace: options.namespace,
 }).replace('{{ports}}', buildKindPorts(fromPort, toPort))}
 `;
         }
@@ -249,6 +263,7 @@ apiVersion: projectcontour.io/v1
 kind: HTTPProxy
 metadata:
   name: ${host}
+  namespace: ${options.namespace}
 spec:
   virtualhost:
     fqdn: ${host}${
@@ -308,16 +323,18 @@ spec:
     /**
      * Builds a Certificate resource for a host using cert-manager.
      * @param {string} host - Hostname for which the certificate is being built.
+     * @param {string} namespace - Kubernetes namespace for the certificate.
      * @returns {string} - Certificate resource YAML for the specified host.
      * @memberof UnderpostDeploy
      */
-    buildCertManagerCertificate({ host }) {
+    buildCertManagerCertificate({ host, namespace }) {
       return `
 ---
 apiVersion: cert-manager.io/v1
 kind: Certificate
 metadata:
   name: ${host}
+  namespace: ${namespace}
 spec:
   commonName: ${host}
   dnsNames:
@@ -364,9 +381,11 @@ spec:
      * @param {boolean} options.disableUpdateDeployment - Whether to disable deployment updates.
      * @param {boolean} options.disableUpdateProxy - Whether to disable proxy updates.
      * @param {boolean} options.disableDeploymentProxy - Whether to disable deployment proxy.
+     * @param {boolean} options.disableUpdateVolume - Whether to disable volume updates.
      * @param {boolean} options.status - Whether to display deployment status.
      * @param {boolean} options.etcHosts - Whether to display the /etc/hosts file.
      * @param {boolean} options.disableUpdateUnderpostConfig - Whether to disable Underpost config updates.
+     * @param {string} [options.namespace] - Kubernetes namespace for the deployment.
      * @returns {Promise<void>} - Promise that resolves when the deployment process is complete.
      * @memberof UnderpostDeploy
      */
@@ -391,67 +410,18 @@ spec:
         disableUpdateDeployment: false,
         disableUpdateProxy: false,
         disableDeploymentProxy: false,
+        disableUpdateVolume: false,
         status: false,
         etcHosts: false,
         disableUpdateUnderpostConfig: false,
+        namespace: '',
       },
     ) {
-      if (options.infoUtil === true)
-        return logger.info(`
-kubectl rollout restart deployment/deployment-name
-kubectl rollout undo deployment/deployment-name
-kubectl scale statefulsets <stateful-set-name> --replicas=<new-replicas>
-kubectl get pods -w
-kubectl patch statefulset valkey-service --type='json' -p='[{"op": "replace", "path": "/spec/template/spec/containers/0/image", "value":"valkey/valkey:latest"}]'
-kubectl patch statefulset valkey-service -p '{"spec":{"template":{"spec":{"containers":[{"name":"valkey-service","imagePullPolicy":"Never"}]}}}}'
-kubectl logs -f <pod-name>
-kubectl describe pod <pod-name>
-kubectl exec -it <pod-name> -- bash
-kubectl exec -it <pod-name> -- sh
-docker exec -it kind-control-plane bash
-curl -4 -v google.com
-kubectl taint nodes <node-name> node-role.kubernetes.io/control-plane:NoSchedule-
-kubectl run test-pod --image=busybox:latest --restart=Never -- /bin/sh -c "while true; do sleep 30; done;"
-kubectl run test-pod --image=alpine/curl:latest --restart=Never -- sh -c "sleep infinity"
-kubectl get ippools -o yaml
-kubectl get node <node-name> -o jsonpath='{.spec.podCIDR}'
-kubectl patch ippool default-ipv4-ippool --type='json' -p='[{"op": "replace", "path": "/spec/cidr", "value": "10.244.0.0/16"}]'
-kubectl patch ippool default-ipv4-ippool --type='json' -p='[{"op": "replace", "path": "/spec/cidr", "value": "192.168.0.0/24"}]'
-sudo podman run --rm localhost/<image-name>:<image-version> <command>
-kubectl get configmap kubelet-config -n kube-system -o yaml > kubelet-config.yaml
-kubectl -n kube-system rollout restart daemonset kube-proxy
-kubectl get EndpointSlice -o wide --all-namespaces -w
-kubectl apply -k manifests/deployment/adminer/.
-kubectl wait --for=condition=Ready pod/busybox1
-kubectl wait --for=jsonpath='{.status.phase}'=Running pod/busybox1
-kubectl wait --for='jsonpath={.status.conditions[?(@.type=="Ready")].status}=True' pod/busybox1
-kubectl wait --for=delete pod/busybox1 --timeout=60s
-
-kubectl run --rm -it test-dns --image=busybox:latest --restart=Never -- /bin/sh -c "
-  nslookup kubernetes.default.svc.cluster.local;
-  nslookup mongodb-service.default.svc.cluster.local;
-  nslookup valkey-service.default.svc.cluster.local;
-  nc -vz mongodb-service 27017;
-  nc -vz valkey-service 6379;
-  echo exit code: \\\$?
-"
-
-kubectl apply -f - <<EOF
-apiVersion: apps/v1
-kind: StatefulSet
-metadata:
-  name: ...
-EOF
-
-https://org.ngc.nvidia.com/setup/api-keys
-docker login nvcr.io
-Username: $oauthtoken
-Password: <Your Key>
-`);
+      const namespace = options.namespace ? options.namespace : 'default';
       if (!deployList && options.certHosts) {
         for (const host of options.certHosts.split(',')) {
-          shellExec(`sudo kubectl apply -f - <<EOF
-${UnderpostDeploy.API.buildCertManagerCertificate({ host })}
+          shellExec(`sudo kubectl apply -f - -n ${namespace} <<EOF
+${UnderpostDeploy.API.buildCertManagerCertificate({ host, namespace })}
 EOF`);
         }
         return;
@@ -513,19 +483,44 @@ EOF`);
           continue;
         }
 
+        const confServer = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'));
+        const confVolume = fs.existsSync(`./engine-private/conf/${deployId}/conf.volume.json`)
+          ? JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.volume.json`, 'utf8'))
+          : [];
+
         if (!options.disableUpdateDeployment)
           for (const version of options.versions.split(',')) {
-            shellExec(`sudo kubectl delete svc ${deployId}-${env}-${version}-service`);
-            shellExec(`sudo kubectl delete deployment ${deployId}-${env}-${version}`);
+            shellExec(
+              `sudo kubectl delete svc ${deployId}-${env}-${version}-service -n ${namespace} --ignore-not-found`,
+            );
+            shellExec(
+              `sudo kubectl delete deployment ${deployId}-${env}-${version} -n ${namespace} --ignore-not-found`,
+            );
+            if (!options.disableUpdateVolume) {
+              for (const volume of confVolume) {
+                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 (!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`);
+                shellExec(`kubectl apply -f - -n ${namespace} <<EOF
+${UnderpostDeploy.API.persistentVolumeFactory({
+  hostPath: rootVolumeHostPath,
+  pvcId,
+})}
+EOF
+`);
+              }
+            }
           }
 
-        const confServer = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'));
-
         for (const host of Object.keys(confServer)) {
           if (!options.disableUpdateProxy) {
-            shellExec(`sudo kubectl delete HTTPProxy ${host}`);
+            shellExec(`sudo kubectl delete HTTPProxy ${host} -n ${namespace} --ignore-not-found`);
             if (UnderpostDeploy.API.isValidTLSContext({ host, env, options }))
-              shellExec(`sudo kubectl delete Certificate ${host}`);
+              shellExec(`sudo kubectl delete Certificate ${host} -n ${namespace} --ignore-not-found`);
           }
           if (!options.remove) etcHosts.push(host);
         }
@@ -536,11 +531,13 @@ EOF`);
             : `manifests/deployment/${deployId}-${env}`;
 
         if (!options.remove) {
-          if (!options.disableUpdateDeployment) shellExec(`sudo kubectl apply -f ./${manifestsPath}/deployment.yaml`);
-          if (!options.disableUpdateProxy) shellExec(`sudo kubectl apply -f ./${manifestsPath}/proxy.yaml`);
+          if (!options.disableUpdateDeployment)
+            shellExec(`sudo kubectl apply -f ./${manifestsPath}/deployment.yaml -n ${namespace}`);
+          if (!options.disableUpdateProxy)
+            shellExec(`sudo kubectl apply -f ./${manifestsPath}/proxy.yaml -n ${namespace}`);
 
           if (UnderpostDeploy.API.isValidTLSContext({ host: Object.keys(confServer)[0], env, options }))
-            shellExec(`sudo kubectl apply -f ./${manifestsPath}/secret.yaml`);
+            shellExec(`sudo kubectl apply -f ./${manifestsPath}/secret.yaml -n ${namespace}`);
         }
       }
       if (options.etcHosts === true) {
@@ -557,15 +554,19 @@ EOF`);
      * 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') {
-      const raw = shellExec(`sudo kubectl get ${kindType} --all-namespaces -o wide`, {
-        stdout: true,
-        disableLog: true,
-        silent: true,
-      });
+    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]
@@ -679,12 +680,13 @@ 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.
      * @memberof UnderpostDeploy
      */
-    configMap(env) {
-      shellExec(`kubectl delete configmap underpost-config`);
+    configMap(env, namespace = 'default') {
+      shellExec(`kubectl delete configmap 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}`,
+        `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}`,
       );
     },
     /**
@@ -693,15 +695,93 @@ EOF`);
      * @param {string} env - Environment for which the traffic is being switched.
      * @param {string} targetTraffic - Target traffic status for the deployment.
      * @param {number} replicas - Number of replicas for the deployment.
+     * @param {string} [namespace='default'] - Kubernetes namespace for the deployment.
      * @memberof UnderpostDeploy
      */
-    switchTraffic(deployId, env, targetTraffic, replicas = 1) {
+    switchTraffic(deployId, env, targetTraffic, replicas = 1, namespace = 'default') {
       UnderpostRootEnv.API.set(`${deployId}-${env}-traffic`, targetTraffic);
       shellExec(
-        `node bin deploy --info-router --build-manifest --traffic ${targetTraffic} --replicas ${replicas} ${deployId} ${env}`,
+        `node bin deploy --info-router --build-manifest --traffic ${targetTraffic} --replicas ${replicas} --namespace ${namespace} ${deployId} ${env}`,
       );
-      shellExec(`sudo kubectl apply -f ./engine-private/conf/${deployId}/build/${env}/proxy.yaml`);
+      shellExec(`sudo kubectl apply -f ./engine-private/conf/${deployId}/build/${env}/proxy.yaml -n ${namespace}`);
     },
+
+    /**
+     * Creates volume mounts and volumes for a deployment.
+     * @param {Array<volume>} volumes - List of volume configurations.
+     * @param {string} volume.volumeName - Name of the volume.
+     * @param {string} volume.volumeMountPath - Mount path of the volume in the container.
+     * @param {string} volume.volumeHostPath - Host path of the volume.
+     * @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).
+     * @returns {object} - Object containing the rendered volume mounts and volumes.
+     * @memberof UnderpostDeploy
+     */
+    volumeFactory(
+      volumes = [
+        {
+          volumeName: 'volume-name',
+          volumeMountPath: '/path/in/container',
+          volumeHostPath: '/path/on/host',
+          volumeType: 'Directory',
+          claimName: null,
+          configMap: null,
+          version: null,
+        },
+      ],
+    ) {
+      let _volumeMounts = `
+      volumeMounts:`;
+      let _volumes = `
+  volumes:`;
+      volumes.map((volumeData) => {
+        let { volumeName, volumeMountPath, volumeHostPath, volumeType, claimName, configMap, version } = volumeData;
+        if (version) {
+          volumeName = `${volumeName}-${version}`;
+          claimName = claimName ? `${claimName}-${version}` : null;
+        }
+        _volumeMounts += `
+        - name: ${volumeName}
+          mountPath: ${volumeMountPath}
+`;
+
+        _volumes += `
+    - name: ${volumeName}
+ ${
+   configMap
+     ? `     configMap:
+        name: ${configMap}`
+     : claimName
+       ? `     persistentVolumeClaim:
+        claimName: ${claimName}`
+       : `     hostPath:
+        path: ${volumeHostPath}
+        type: ${volumeType}
+`
+ }
+
+  `;
+      });
+      return { render: _volumeMounts + _volumes };
+    },
+
+    /**
+     * Creates a persistent volume and persistent volume claim for a deployment.
+     * @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.
+     * @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);
+    },
+
     /**
      * Creates a hosts file for a deployment.
      * @param {Array<string>} hosts - List of hosts to be added to the hosts file.
@@ -791,7 +871,7 @@ ${renderHosts}`,
     getCurrentLoadedImages(node = 'kind-worker', specContainers = false) {
       if (specContainers) {
         const raw = shellExec(
-          `kubectl get pods --all-namespaces -o=jsonpath='{range .items[*]}{"\\n"}{.metadata.name}{":\\t"}{range .spec.containers[*]}{.image}{", "}{end}{end}'`,
+          `kubectl get pods --all-namespaces -o=jsonpath='{range .items[*]}{"\\n"}{.metadata.namespace}{"/"}{.metadata.name}{":\\t"}{range .spec.containers[*]}{.image}{", "}{end}{end}'`,
           {
             stdout: true,
             silent: true,

package/src/cli/index.js

@@ -7,6 +7,8 @@ import { commitData } from '../client/components/core/CommonJs.js';
 import UnderpostLxd from './lxd.js';
 import UnderpostBaremetal from './baremetal.js';
 import UnderpostRun from './run.js';
+import Dns from '../server/dns.js';
+import { pbcopy } from '../server/process.js';
 
 // Load environment variables from .env file
 const underpostRootPath = getUnderpostRootPath();
@@ -78,6 +80,8 @@ program
   .option('--msg <msg>', 'Sets a custom commit message.')
   .option('--deploy-id <deploy-id>', 'Sets the deployment configuration ID for the commit context.')
   .option('--cached', 'Commit staged changes only or context.')
+  .option('--hashes <hashes>', 'Comma-separated list of specific file hashes of commits.')
+  .option('--extension <extension>', 'specific file extensions of commits.')
   .description('Manages commits to a GitHub repository, supporting various commit types and options.')
   .action(Underpost.repo.commit);
 
@@ -127,6 +131,16 @@ program
   .description('Displays the root path of the npm installation.')
   .action(() => console.log(getNpmRootPath()));
 
+program
+  .command('ip')
+  .option('--copy', 'Copies the IP addresses to the clipboard.')
+  .description('Displays the current public machine IP addresses.')
+  .action(async (options) => {
+    const ip = await Dns.getPublicIp();
+    if (options.copy) return pbcopy(ip);
+    return console.log(ip);
+  });
+
 // 'cluster' command: Manage Kubernetes clusters
 program
   .command('cluster')
@@ -142,10 +156,20 @@ program
   .option('--contour', 'Initializes the cluster with Project Contour base HTTPProxy and Envoy.')
   .option('--cert-manager', "Initializes the cluster with a Let's Encrypt production ClusterIssuer.")
   .option('--dedicated-gpu', 'Initializes the cluster with dedicated GPU base resources and environment settings.')
-  .option('--info', 'Retrieves information about all deployed Kubernetes objects.')
   .option('--full', 'Initializes the cluster with all available statefulsets and services.')
-  .option('--ns-use <ns-name>', 'Switches the current Kubernetes context to the specified namespace.')
+  .option(
+    '--ns-use <ns-name>',
+    "Switches the current Kubernetes context to the specified namespace (creates if it doesn't exist).",
+  )
   .option('--kubeadm', 'Initializes the cluster using kubeadm for control plane management.')
+  .option(
+    '--pod-network-cidr <cidr>',
+    'Sets custom pod network CIDR for kubeadm cluster initialization (defaults to "192.168.0.0/16").',
+  )
+  .option(
+    '--control-plane-endpoint <endpoint>',
+    'Sets custom control plane endpoint for kubeadm cluster initialization (defaults to "localhost:6443").',
+  )
   .option('--grafana', 'Initializes the cluster with a Grafana deployment.')
   .option(
     '--prom [hosts]',
@@ -163,6 +187,8 @@ program
   .option('--chown', 'Sets the appropriate ownership for Kubernetes kubeconfig files.')
   .option('--k3s', 'Initializes the cluster using K3s (Lightweight Kubernetes).')
   .option('--hosts <hosts>', 'A comma-separated list of cluster hostnames or IP addresses.')
+  .option('--remove-volume-host-paths', 'Removes specified volume host paths after execution.')
+  .option('--namespace <namespace>', 'Kubernetes namespace for cluster operations (defaults to "default").')
   .action(Underpost.cluster.init)
   .description('Manages Kubernetes clusters, defaulting to Kind cluster initialization.');
 
@@ -178,7 +204,6 @@ program
   .option('--sync', 'Synchronizes deployment environment variables, ports, and replica counts.')
   .option('--info-router', 'Displays the current router structure and configuration.')
   .option('--expose', 'Exposes services matching the provided deployment ID list.')
-  .option('--info-util', 'Displays useful `kubectl` utility management commands.')
   .option('--cert', 'Resets TLS/SSL certificate secrets for deployments.')
   .option('--cert-hosts <hosts>', 'Resets TLS/SSL certificate secrets for specified hosts.')
   .option('--node <node>', 'Sets optional node for deployment operations.')
@@ -193,6 +218,7 @@ program
   .option('--disable-update-deployment', 'Disables updates to deployments.')
   .option('--disable-update-proxy', 'Disables updates to proxies.')
   .option('--disable-deployment-proxy', 'Disables proxies of deployments.')
+  .option('--disable-update-volume', 'Disables updates to volume mounts during deployment.')
   .option(
     '--status',
     'Retrieves current network traffic data from resource deployments and the host machine network configuration.',
@@ -201,6 +227,7 @@ program
   .option('--etc-hosts', 'Enables the etc-hosts context for deployment operations.')
   .option('--restore-hosts', 'Restores default `/etc/hosts` entries.')
   .option('--disable-update-underpost-config', 'Disables updates to Underpost configuration during deployment.')
+  .option('--namespace <namespace>', 'Kubernetes namespace for deployment operations (defaults to "default").')
   .description('Manages application deployments, defaulting to deploying development pods.')
   .action(Underpost.deploy.callback);
 
@@ -392,6 +419,18 @@ program
   .option('--image-name <image-name>', 'Optional: Specifies the image name for test execution.')
   .option('--container-name <container-name>', 'Optional: Specifies the container name for test execution.')
   .option('--namespace <namespace>', 'Optional: Specifies the namespace for test execution.')
+  .option('--tty', 'Enables TTY for the container in deploy-job.')
+  .option('--stdin', 'Keeps STDIN open for the container in deploy-job.')
+  .option('--restart-policy <policy>', 'Sets the restart policy for the job in deploy-job.')
+  .option('--runtime-class-name <name>', 'Sets the runtime class name for the job in deploy-job.')
+  .option('--image-pull-policy <policy>', 'Sets the image pull policy for the job in deploy-job.')
+  .option('--api-version <version>', 'Sets the API version for the job manifest in deploy-job.')
+  .option(
+    '--labels <labels>',
+    'Optional: Specifies a comma-separated list of key-value pairs for labels (e.g., "app=my-app,env=prod").',
+  )
+  .option('--claim-name <name>', 'Optional: Specifies the claim name for volume mounting in deploy-job.')
+  .option('--kind <kind-type>', 'Specifies the kind of Kubernetes resource (e.g., Job, Deployment) for deploy-job.')
   .option('--kubeadm', 'Flag to indicate Kubeadm cluster type context')
   .option('--k3s', 'Flag to indicate K3s cluster type context')
   .option('--force', 'Forces operation, overriding any warnings or conflicts.')
@@ -399,7 +438,9 @@ program
   .option('--reset', 'Resets the runner state before execution.')
   .option('--terminal', 'Enables terminal mode for interactive script execution.')
   .option('--dev-proxy-port-offset <port-offset>', 'Sets a custom port offset for development proxy.')
+  .option('--host-network', 'Enables host network mode for the runner execution.')
   .option('--conf-server-path <conf-server-path>', 'Sets a custom configuration server path.')
+  .option('--underpost-root <underpost-root>', 'Sets a custom Underpost root path.')
   .description('Runs a script from the specified path.')
   .action(UnderpostRun.API.callback);
 

package/src/cli/monitor.js

@@ -39,6 +39,7 @@ class UnderpostMonitor {
      * @param {string} [options.type=''] - Type of deployment (e.g., 'blue-green', 'remote').
      * @param {string} [options.replicas=''] - Number of replicas for the deployment.
      * @param {boolean} [options.sync=false] - Synchronize traffic switching with the deployment.
+     * @param {string} [options.namespace=''] - Kubernetes namespace for the deployment.
      * @param {object} [commanderOptions] - Options passed from the command line interface.
      * @param {object} [auxRouter] - Optional router configuration for the deployment.
      * @memberof UnderpostMonitor
@@ -46,10 +47,11 @@ class UnderpostMonitor {
     async callback(
       deployId,
       env = 'development',
-      options = { now: false, single: false, msInterval: '', type: '', replicas: '', sync: false },
+      options = { now: false, single: false, msInterval: '', type: '', replicas: '', sync: false, namespace: '' },
       commanderOptions,
       auxRouter,
     ) {
+      if (!options.namespace) options.namespace = 'default';
       if (deployId === 'dd' && fs.existsSync(`./engine-private/deploy/dd.router`)) {
         for (const _deployId of fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8').split(','))
           UnderpostMonitor.API.callback(
@@ -95,12 +97,13 @@ class UnderpostMonitor {
         if (traffic === 'blue') traffic = 'green';
         else traffic = 'blue';
         UnderpostRootEnv.API.set(`${deployId}-${env}-traffic`, traffic);
+        const namespace = options.namespace || 'default';
         shellExec(
           `node bin deploy --info-router --build-manifest --traffic ${traffic} --replicas ${
             options.replicas ? options.replicas : 1
-          } ${deployId} ${env}`,
+          } --namespace ${namespace} ${deployId} ${env}`,
         );
-        shellExec(`sudo kubectl apply -f ./engine-private/conf/${deployId}/build/${env}/proxy.yaml`);
+        shellExec(`sudo kubectl apply -f ./engine-private/conf/${deployId}/build/${env}/proxy.yaml -n ${namespace}`);
       };
 
       const monitor = async (reject) => {
@@ -152,12 +155,15 @@ class UnderpostMonitor {
                           fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'),
                         );
 
-                        UnderpostDeploy.API.configMap(env);
+                        const namespace = options.namespace || 'default';
+                        UnderpostDeploy.API.configMap(env, namespace);
 
                         for (const host of Object.keys(confServer)) {
-                          shellExec(`sudo kubectl delete HTTPProxy ${host}`);
+                          shellExec(`sudo kubectl delete HTTPProxy ${host} -n ${namespace} --ignore-not-found`);
                         }
-                        shellExec(`sudo kubectl rollout restart deployment/${deployId}-${env}-${traffic}`);
+                        shellExec(
+                          `sudo kubectl rollout restart deployment/${deployId}-${env}-${traffic} -n ${namespace}`,
+                        );
 
                         switchTraffic();
                       }

package/src/cli/repository.js

@@ -89,6 +89,8 @@ class UnderpostRepository {
      * @param {boolean} [options.lastMsg=0] - If greater than 0, copies or show the last last single n commit message to clipboard.
      * @param {string} [options.msg=''] - If provided, outputs this message instead of committing.
      * @param {string} [options.deployId=''] - An optional deploy ID to include in the commit message.
+     * @param {string} [options.hashes=''] - If provided with diff option, shows the diff between two hashes.
+     * @param {string} [options.extension=''] - If provided with diff option, filters the diff by this file extension.
      * @memberof UnderpostRepository
      */
     commit(
@@ -107,9 +109,19 @@ class UnderpostRepository {
         log: 0,
         msg: '',
         deployId: '',
+        hashes: '',
+        extension: '',
       },
     ) {
       if (!repoPath) repoPath = '.';
+      if (options.diff && options.hashes) {
+        const hashes = options.hashes.split(',');
+        const cmd = `git --no-pager diff ${hashes[0]} ${hashes[1] ? hashes[1] : 'HEAD'}${options.extension ? ` -- '*.${options.extension}'` : ''}`;
+        if (options.copy) {
+          pbcopy(cmd);
+        } else console.log(cmd);
+        return;
+      }
       if (options.msg) {
         options.msg = options.msg.replaceAll('"', '').replaceAll(`'`, '').replaceAll('`', '');
         let key = Object.keys(commitData).find((k) => k && options.msg.toLocaleLowerCase().slice(0, 16).match(k));
@@ -167,7 +179,7 @@ class UnderpostRepository {
         return;
       }
       if (options.info) return logger.info('', commitData);
-      const _message = `${commitType}${subModule ? `(${subModule})` : ''}${process.argv.includes('!') ? '!' : ''}: ${
+      const _message = `${commitType}${subModule ? `(${subModule})` : ''}: ${
         commitData[commitType].emoji
       } ${message ? message : commitData[commitType].description}`;
       if (options.copy) return pbcopy(_message);