underpost 2.8.46 → 2.8.48

package/Dockerfile

@@ -4,7 +4,7 @@ FROM debian:${BASE_DEBIAN}
 
 ENV DEBIAN_FRONTEND=noninteractive
 
-WORKDIR /code
+WORKDIR /home/dd
 
 # Set root password to root, format is 'user:password'.
 RUN echo 'root:root' | chpasswd
@@ -39,10 +39,10 @@ RUN npm --version
 
 RUN npm install -g underpost
 
-VOLUME [ "/code/app/logs" ]
+VOLUME [ "/home/dd/engine/logs" ]
 
 EXPOSE 22
 
 EXPOSE 4000-4004
 
-CMD [ "underpost", "new", "app" ]
+CMD [ "underpost", "new", "service" ]

package/bin/build.js

@@ -3,7 +3,7 @@ import { loggerFactory } from '../src/server/logger.js';
 import { shellExec } from '../src/server/process.js';
 import dotenv from 'dotenv';
 import { getCapVariableName } from '../src/client/components/core/CommonJs.js';
-import { buildProxyRouter, buildPortProxyRouter, Config, getPathsSSR, buildKindPorts } from '../src/server/conf.js';
+import { getPathsSSR } from '../src/server/conf.js';
 
 const baseConfPath = './engine-private/conf/dd-cron/.env.production';
 if (fs.existsSync(baseConfPath)) dotenv.config({ path: baseConfPath, override: true });
@@ -20,21 +20,13 @@ const logger = loggerFactory(import.meta);
 const confName = process.argv[2];
 const basePath = '../pwa-microservices-template';
 const repoName = `engine-${confName.split('dd-')[1]}`;
-const privateRepoName = `${repoName}-private`;
-const privateRepoNameBackUp = `${repoName}-cron-backups`;
-const gitPrivateUrl = `https://${process.env.GITHUB_TOKEN}@github.com/underpostnet/${privateRepoName}.git`;
-const gitPrivateBackUpUrl = `https://${process.env.GITHUB_TOKEN}@github.com/underpostnet/${privateRepoNameBackUp}.git`;
 
 logger.info('', {
   confName,
   repoName,
-  privateRepoName,
-  privateRepoNameBackUp,
   basePath,
 });
 
-if (process.argv.includes('info')) process.exit(0);
-
 if (process.argv.includes('clean')) {
   if (fs.existsSync(`${basePath}/images`)) fs.copySync(`${basePath}/images`, `./images`);
   shellExec(`cd ${basePath} && git checkout .`);
@@ -42,173 +34,34 @@ if (process.argv.includes('clean')) {
   process.exit(0);
 }
 
-if (process.argv.includes('proxy')) {
-  const env = process.argv.includes('development') ? 'development' : 'production';
-  process.env.NODE_ENV = env;
-  process.env.PORT = process.env.NODE_ENV === 'development' ? 4000 : 3000;
-  process.argv[2] = 'proxy';
-  process.argv[3] = fs.readFileSync('./engine-private/deploy/dd-router', 'utf8').trim();
-
-  await Config.build();
-  process.env.NODE_ENV = 'production';
-  const router = buildPortProxyRouter(443, buildProxyRouter());
-  const confServer = JSON.parse(fs.readFileSync(`./engine-private/conf/${confName}/conf.server.json`, 'utf8'));
-  const confHosts = Object.keys(confServer);
-
-  for (const host of Object.keys(router)) {
-    if (!confHosts.find((_host) => host.match(_host))) {
-      delete router[host];
-    }
-  }
-
-  const ports = Object.values(router).map((p) => p.split(':')[2]);
-
-  const fromPort = ports[0];
-  const toPort = ports[ports.length - 1];
-
-  logger.info('port range', { fromPort, toPort, router });
-
-  const deploymentYamlFilePath = `./engine-private/conf/${confName}/build/${env}/deployment.yaml`;
-
-  const deploymentYamlParts = fs.readFileSync(deploymentYamlFilePath, 'utf8').split('ports:');
-  deploymentYamlParts[1] =
-    buildKindPorts(fromPort, toPort) +
-    `  type: LoadBalancer
-`;
-
-  fs.writeFileSync(
-    deploymentYamlFilePath,
-    deploymentYamlParts.join(`ports:
-`),
-  );
-
-  let proxyYaml = '';
-  let secretYaml = '';
-
-  for (const host of Object.keys(confServer)) {
-    if (env === 'production')
-      secretYaml += `
----
-apiVersion: cert-manager.io/v1
-kind: Certificate
-metadata:
-  name: ${host}
-spec:
-  commonName: ${host}
-  dnsNames:
-  - ${host}
-  issuerRef:
-    name: letsencrypt-prod
-    kind: ClusterIssuer
-  secretName: ${host}`;
-
-    const pathPortConditions = [];
-    for (const path of Object.keys(confServer[host])) {
-      const { peer } = confServer[host][path];
-      const port = parseInt(router[`${host}${path === '/' ? '' : path}`].split(':')[2]);
-      // logger.info('', { host, port, path });
-      pathPortConditions.push({
-        port,
-        path,
-      });
-
-      if (peer) {
-        //  logger.info('', { host, port: port + 1, path: '/peer' });
-        pathPortConditions.push({
-          port: port + 1,
-          path: '/peer',
-        });
-      }
-    }
-    // logger.info('', { host, pathPortConditions });
-    proxyYaml += `
----
-apiVersion: projectcontour.io/v1
-kind: HTTPProxy
-metadata:
-  name: ${host}
-spec:
-  virtualhost:
-    fqdn: ${host}${
-      env === 'development'
-        ? ''
-        : `
-    tls:
-      secretName: ${host}`
-    }
-  routes:`;
-    for (const conditionObj of pathPortConditions) {
-      const { path, port } = conditionObj;
-      proxyYaml += `
-    - conditions:
-        - prefix: ${path}
-      enableWebsockets: true
-      services:
-        - name: ${confName}-${env}-service
-          port: ${port}`;
-    }
-  }
-  const yamlPath = `./engine-private/conf/${confName}/build/${env}/proxy.yaml`;
-  fs.writeFileSync(yamlPath, proxyYaml, 'utf8');
-  if (env === 'production') {
-    const yamlPath = `./engine-private/conf/${confName}/build/${env}/secret.yaml`;
-    fs.writeFileSync(yamlPath, secretYaml, 'utf8');
-  }
-
-  process.exit(0);
-}
 if (process.argv.includes('conf')) {
-  if (!fs.existsSync(`../${privateRepoName}`)) {
-    shellExec(`cd .. && git clone ${gitPrivateUrl}`, { silent: true });
-  } else {
-    shellExec(`cd ../${privateRepoName} && git pull`);
-  }
-  const toPath = `../${privateRepoName}/conf/${confName}`;
-  fs.removeSync(toPath);
-  fs.mkdirSync(toPath, { recursive: true });
-  fs.copySync(`./engine-private/conf/${confName}`, toPath);
-  shellExec(
-    `cd ../${privateRepoName}` +
-      ` && git add .` +
-      ` && git commit -m "ci(engine-core-conf): ⚙️ Update ${confName} conf"` +
-      ` && git push`,
-  );
-  process.exit(0);
-}
-
-if (process.argv.includes('cron-backups')) {
-  if (!fs.existsSync(`../${privateRepoNameBackUp}`)) {
-    shellExec(`cd .. && git clone ${gitPrivateBackUpUrl}`, { silent: true });
-  } else {
-    shellExec(`cd ../${privateRepoNameBackUp} && git pull`);
-  }
-  const serverConf = JSON.parse(fs.readFileSync(`./engine-private/conf/${confName}/conf.server.json`, 'utf8'));
-  for (const host of Object.keys(serverConf)) {
-    for (let path of Object.keys(serverConf[host])) {
-      path = path.replaceAll('/', '-');
-      const toPath = `../${privateRepoNameBackUp}/${host}${path}`;
-      const fromPath = `./engine-private/cron-backups/${host}${path}`;
-      if (fs.existsSync(fromPath)) {
-        if (fs.existsSync(toPath)) fs.removeSync(toPath);
-        logger.info('Build', { fromPath, toPath });
-        fs.copySync(fromPath, toPath);
-      }
+  for (const _confName of (confName === 'dd'
+    ? fs.readFileSync(`./engine-private/deploy/dd-router`, 'utf8')
+    : confName
+  ).split(',')) {
+    const _repoName = `engine-${_confName.split('dd-')[1]}`;
+    const privateRepoName = `${_repoName}-private`;
+    const privateGitUri = `${process.env.GITHUB_USERNAME}/${privateRepoName}`;
+
+    if (!fs.existsSync(`../${privateRepoName}`)) {
+      shellExec(`cd .. && underpost clone ${privateGitUri}`, { silent: true });
+    } else {
+      shellExec(`cd ../${privateRepoName} && underpost pull . ${privateGitUri}`);
     }
+    const toPath = `../${privateRepoName}/conf/${_confName}`;
+    fs.removeSync(toPath);
+    fs.mkdirSync(toPath, { recursive: true });
+    fs.copySync(`./engine-private/conf/${_confName}`, toPath);
+    shellExec(
+      `cd ../${privateRepoName}` +
+        ` && git add .` +
+        ` && underpost cmt . ci engine-core-conf 'Update ${_confName} conf'` +
+        ` && underpost push . ${privateGitUri}`,
+    );
   }
-  shellExec(
-    `cd ../${privateRepoNameBackUp}` +
-      ` && git add .` +
-      ` && git commit -m "ci(engine-core-cron-backups): ⚙️ Update ${confName} cron backups"` +
-      ` && git push`,
-  );
   process.exit(0);
 }
 
-if (process.argv.includes('test')) {
-  fs.mkdirSync(`${basePath}/engine-private/conf`, { recursive: true });
-  fs.copySync(`./engine-private/conf/${confName}`, `${basePath}/engine-private/conf/${confName}`);
-}
-
 const { DefaultConf } = await import(`../conf.${confName}.js`);
 
 {
@@ -294,27 +147,9 @@ const { DefaultConf } = await import(`../conf.${confName}.js`);
   const env = process.argv.includes('development') ? 'development' : 'production';
   const deploymentsFiles = ['Dockerfile', 'proxy.yaml', 'deployment.yaml', 'secret.yaml'];
   // remove engine-private of .dockerignore for local testing
-
-  if (process.argv.includes('engine')) {
-    fs.removeSync(`${basePath}/manifests/deployment`);
-
-    if (!fs.existsSync(`./manifests/deployment/${confName}-${env}`))
-      fs.mkdirSync(`./manifests/deployment/${confName}-${env}`);
-
-    for (const file of deploymentsFiles) {
-      if (fs.existsSync(`./engine-private/conf/${confName}/build/${env}/${file}`)) {
-        fs.copyFileSync(`./engine-private/conf/${confName}/build/${env}/${file}`, `${basePath}/${file}`);
-        fs.copyFileSync(
-          `./engine-private/conf/${confName}/build/${env}/${file}`,
-          `./manifests/deployment/${confName}-${env}/${file}`,
-        );
-      }
-    }
-  } else {
-    for (const file of deploymentsFiles) {
-      if (fs.existsSync(`./manifests/deployment/${confName}-${env}/${file}`)) {
-        fs.copyFileSync(`./manifests/deployment/${confName}-${env}/${file}`, `${basePath}/${file}`);
-      }
+  for (const file of deploymentsFiles) {
+    if (fs.existsSync(`./manifests/deployment/${confName}-${env}/${file}`)) {
+      fs.copyFileSync(`./manifests/deployment/${confName}-${env}/${file}`, `${basePath}/${file}`);
     }
   }
 }

package/bin/file.js

@@ -1,7 +1,13 @@
 import fs from 'fs-extra';
 
 import { loggerFactory } from '../src/server/logger.js';
-import { cap, getCapVariableName, getDirname, newInstance } from '../src/client/components/core/CommonJs.js';
+import {
+  cap,
+  getCapVariableName,
+  getDirname,
+  newInstance,
+  uniqueArray,
+} from '../src/client/components/core/CommonJs.js';
 import { shellCd, shellExec } from '../src/server/process.js';
 import walk from 'ignore-walk';
 import { validateTemplatePath } from '../src/server/conf.js';
@@ -81,10 +87,12 @@ try {
           '.github/workflows/engine.core.ci.yml',
           '.github/workflows/engine.cyberia.ci.yml',
           './manifests/deployment/dd-lampp-development',
+          './manifests/deployment/dd-cyberia-development',
+          './manifests/deployment/dd-core-development',
           'bin/web3.js',
           'bin/cyberia.js',
         ]) {
-          fs.removeSync('../pwa-microservices-template/' + deletePath);
+          if (fs.existsSync(deletePath)) fs.removeSync('../pwa-microservices-template/' + deletePath);
         }
         const originPackageJson = JSON.parse(fs.readFileSync('./package.json', 'utf8'));
         const templatePackageJson = JSON.parse(fs.readFileSync('../pwa-microservices-template/package.json', 'utf8'));
@@ -102,8 +110,8 @@ try {
         templatePackageJson.description = description;
         templatePackageJson.scripts.dev = dev;
         templatePackageJson.scripts.build = build;
-        templatePackageJson.keywords = ['pwa', 'microservices', 'template', 'builder'].concat(
-          templatePackageJson.keywords,
+        templatePackageJson.keywords = uniqueArray(
+          ['pwa', 'microservices', 'template', 'builder'].concat(templatePackageJson.keywords),
         );
         delete templatePackageJson.scripts['update-template'];
         fs.writeFileSync(

package/bin/index.js

@@ -97,6 +97,17 @@ program
   })
   .description('Manage cluster, for default initialization base kind cluster');
 
+program
+  .command('deploy')
+  .argument('<deploy-list>', 'Deploy id list, e.g. default-a, default-b')
+  .argument('[env]', 'Optional environment, for default is development')
+  .option('--remove', 'Delete deployments and services')
+  .option('--sync', 'Sync deployments env, ports, and replicas')
+  .option('--info-router', 'Display router structure')
+  .option('--build-manifest', 'Build kind yaml manifests: deployments, services, proxy and secrets')
+  .description('Manage deployment, for default deploy development pods')
+  .action(Underpost.deploy.callback);
+
 program
   .command('secret')
   .argument('<platform>', `Options: ${Object.keys(Underpost.secret)}`)
@@ -142,11 +153,11 @@ program
 
 program
   .command('db')
-  .option('--import <deploy-id-list>', 'Import databases to containers from deploy id list, e.g. default-a, default-b')
+  .argument('<deploy-list>', 'Deploy id list, e.g. default-a, default-b')
+  .option('--import', 'Import container backups from repositories')
+  .option('--export', 'Export container backups to repositories')
   .description('Manage databases')
-  .action((...args) => {
-    if (args && args[0].import) return UnderpostDB.API.import(...args);
-  });
+  .action(UnderpostDB.API.callback);
 
 program
   .command('script')
@@ -158,6 +169,12 @@ program
   )
   .action((...args) => Underpost.script[args[0]](args[1], args[2]));
 
-program.command('test').description('Run tests').action(Underpost.test.run);
+program
+  .command('test')
+  .argument('[deploy-list]', 'Deploy id list, e.g. default-a, default-b')
+  .description('Manage Test, for default run current underpost default test')
+  .option('--inside-container', 'Inside container execution context')
+  .option('--sh', 'Copy to clipboard, container entrypoint shell command')
+  .action(Underpost.test.callback);
 
 program.parse();

package/docker-compose.yml

@@ -58,7 +58,7 @@ services:
           cpus: '0.25'
           memory: 20M
     labels: # labels in Compose file instead of Dockerfile
-      engine.version: '2.8.46'
+      engine.version: '2.8.48'
     networks:
       - load-balancer
 

package/package.json

@@ -2,7 +2,7 @@
     "type": "module",
     "main": "src/index.js",
     "name": "underpost",
-    "version": "2.8.46",
+    "version": "2.8.48",
     "description": "pwa api rest template",
     "scripts": {
         "start": "env-cmd -f .env.production node --max-old-space-size=8192 src/server",
@@ -32,10 +32,6 @@
         "url": "git+https://github.com/underpostnet/pwa-microservices-template.git"
     },
     "keywords": [
-        "pwa",
-        "microservices",
-        "template",
-        "builder",
         "pwa",
         "microservices",
         "template",

package/src/cli/cluster.js

@@ -43,7 +43,7 @@ class UnderpostCluster {
         return;
       }
       const testClusterInit = shellExec(`kubectl get pods --all-namespaces -o wide`, {
-        disableLogging: true,
+        disableLog: true,
         silent: true,
         stdout: true,
       });

package/src/cli/db.js

@@ -1,4 +1,4 @@
-import { mergeFile } from '../server/conf.js';
+import { mergeFile, splitFileFactory } from '../server/conf.js';
 import { loggerFactory } from '../server/logger.js';
 import { shellExec } from '../server/process.js';
 import fs from 'fs-extra';
@@ -7,8 +7,10 @@ const logger = loggerFactory(import.meta);
 
 class UnderpostDB {
   static API = {
-    async import(options = { import: 'default' }) {
-      for (const _deployId of options.import.split(',')) {
+    async callback(deployList = 'default', options = { import: false, export: false }) {
+      const newBackupTimestamp = new Date().getTime();
+      const nameSpace = 'default';
+      for (const _deployId of deployList.split(',')) {
         const deployId = _deployId.trim();
         if (!deployId) continue;
         const dbs = {};
@@ -38,18 +40,22 @@ class UnderpostDB {
           for (const dbName of Object.keys(dbs[provider])) {
             const { hostFolder, user, password } = dbs[provider][dbName];
             if (hostFolder) {
-              logger.info('import', { hostFolder, provider, dbName });
+              logger.info('', { hostFolder, provider, dbName });
 
               const backUpPath = `../${repoName}/${hostFolder}`;
               const times = await fs.readdir(backUpPath);
               const currentBackupTimestamp = Math.max(...times.map((t) => parseInt(t)));
               dbs[provider][dbName].currentBackupTimestamp = currentBackupTimestamp;
+              const removeBackupTimestamp = Math.min(...times.map((t) => parseInt(t)));
 
+              const sqlContainerPath = `/home/${dbName}.sql`;
               const _fromPartsParts = `../${repoName}/${hostFolder}/${currentBackupTimestamp}/${dbName}-parths.json`;
               const _toSqlPath = `../${repoName}/${hostFolder}/${currentBackupTimestamp}/${dbName}.sql`;
+              const _toNewSqlPath = `../${repoName}/${hostFolder}/${newBackupTimestamp}/${dbName}.sql`;
               const _toBsonPath = `../${repoName}/${hostFolder}/${currentBackupTimestamp}/${dbName}`;
+              const _toNewBsonPath = `../${repoName}/${hostFolder}/${newBackupTimestamp}/${dbName}`;
 
-              if (fs.existsSync(_fromPartsParts) && !fs.existsSync(_toSqlPath)) {
+              if (options.import === true && fs.existsSync(_fromPartsParts) && !fs.existsSync(_toSqlPath)) {
                 const names = JSON.parse(fs.readFileSync(_fromPartsParts, 'utf8')).map((_path) => {
                   return `../${repoName}/${hostFolder}/${currentBackupTimestamp}/${_path.split('/').pop()}`;
                 });
@@ -61,26 +67,59 @@ class UnderpostDB {
                 await mergeFile(names, _toSqlPath);
               }
 
+              if (options.export === true && times.length >= 5) {
+                fs.removeSync(`../${repoName}/${hostFolder}/${removeBackupTimestamp}`);
+                fs.mkdirSync(`../${repoName}/${hostFolder}/${newBackupTimestamp}`, { recursive: true });
+              }
+
               switch (provider) {
                 case 'mariadb': {
                   const podName = `mariadb-statefulset-0`;
-                  const nameSpace = 'default';
                   const serviceName = 'mariadb';
-                  shellExec(`sudo kubectl cp ${_toSqlPath} ${nameSpace}/${podName}:/${dbName}.sql`);
-                  const cmd = `mariadb -u ${user} -p${password} ${dbName} < /${dbName}.sql`;
-                  shellExec(
-                    `kubectl exec -i ${podName} -- ${serviceName} -p${password} -e 'CREATE DATABASE ${dbName};'`,
-                  );
-                  shellExec(`sudo kubectl exec -i ${podName} -- sh -c "${cmd}"`);
+                  if (options.import === true) {
+                    shellExec(`sudo kubectl cp ${_toSqlPath} ${nameSpace}/${podName}:/${dbName}.sql`);
+                    const cmd = `mariadb -u ${user} -p${password} ${dbName} < /${dbName}.sql`;
+                    shellExec(
+                      `kubectl exec -i ${podName} -- ${serviceName} -p${password} -e 'CREATE DATABASE ${dbName};'`,
+                    );
+                    shellExec(`sudo kubectl exec -i ${podName} -- sh -c "${cmd}"`);
+                  }
+                  if (options.export === true) {
+                    const cmd = `mariadb-dump --user=${user} --password=${password} --lock-tables ${dbName} > ${sqlContainerPath}`;
+                    shellExec(`sudo kubectl exec -i ${podName} -- sh -c "${cmd}"`);
+                    shellExec(`sudo kubectl cp ${nameSpace}/${podName}:${sqlContainerPath} ${_toNewSqlPath}`);
+                    await splitFileFactory(dbName, _toNewSqlPath);
+                  }
                   break;
                 }
 
                 case 'mongoose': {
-                  const podName = `mongodb-0`;
-                  const nameSpace = 'default';
-                  shellExec(`sudo kubectl cp ${_toBsonPath} ${nameSpace}/${podName}:/${dbName}`);
-                  const cmd = `mongorestore -d ${dbName} /${dbName}`;
-                  shellExec(`sudo kubectl exec -i ${podName} -- sh -c "${cmd}"`);
+                  if (options.import === true) {
+                    const podName = `mongodb-0`;
+                    shellExec(`sudo kubectl cp ${_toBsonPath} ${nameSpace}/${podName}:/${dbName}`);
+                    const cmd = `mongorestore -d ${dbName} /${dbName}`;
+                    shellExec(`sudo kubectl exec -i ${podName} -- sh -c "${cmd}"`);
+                  }
+                  if (options.export === true) {
+                    const podName = `backup-access`;
+                    const containerBaseBackupPath = '/backup';
+                    let timeFolder = shellExec(
+                      `sudo kubectl exec -i ${podName} -- sh -c "cd ${containerBaseBackupPath} && ls -a"`,
+                      {
+                        stdout: true,
+                        disableLog: false,
+                        silent: true,
+                      },
+                    ).split(`\n`);
+                    timeFolder = timeFolder[timeFolder.length - 2];
+                    if (timeFolder === '..') {
+                      logger.warn(`Cannot backup available`, { timeFolder });
+                    } else {
+                      shellExec(
+                        `sudo kubectl cp ${nameSpace}/${podName}:${containerBaseBackupPath}/${timeFolder}/${dbName} ${_toNewBsonPath}`,
+                      );
+                    }
+                  }
                   break;
                 }
 
@@ -90,6 +129,17 @@ class UnderpostDB {
             }
           }
         }
+        if (options.export === true) {
+          shellExec(`cd ../${repoName} && git add .`);
+          shellExec(
+            `underpost cmt ../${repoName} backup '' '${new Date(newBackupTimestamp).toLocaleDateString()} ${new Date(
+              newBackupTimestamp,
+            ).toLocaleTimeString()}'`,
+          );
+          shellExec(`cd ../${repoName} && underpost push . ${process.env.GITHUB_USERNAME}/${repoName}`, {
+            disableLog: true,
+          });
+        }
       }
     },
   };

package/src/cli/deploy.js

@@ -0,0 +1,277 @@
+import {
+  buildKindPorts,
+  buildPortProxyRouter,
+  buildProxyRouter,
+  Config,
+  getDataDeploy,
+  loadReplicas,
+} from '../server/conf.js';
+import { loggerFactory } from '../server/logger.js';
+import { shellExec } from '../server/process.js';
+import fs from 'fs-extra';
+import dotenv from 'dotenv';
+import Underpost from '../index.js';
+
+const logger = loggerFactory(import.meta);
+
+class UnderpostDeploy {
+  static API = {
+    sync(deployList) {
+      const deployGroupId = '_dd';
+      fs.writeFileSync(`./engine-private/deploy/${deployGroupId}.json`, JSON.stringify(deployList.split(',')), 'utf8');
+      return getDataDeploy({
+        buildSingleReplica: true,
+        deployGroupId,
+      });
+    },
+    async routerFactory(deployList, env) {
+      const initEnvPath = `./engine-private/conf/${deployList.split(',')[0]}/.env.${env}`;
+      const initEnvObj = dotenv.parse(fs.readFileSync(initEnvPath, 'utf8'));
+      process.env.PORT = initEnvObj.PORT;
+      process.env.NODE_ENV = env;
+      await Config.build(undefined, 'proxy', deployList);
+      return buildPortProxyRouter(env === 'development' ? 80 : 443, buildProxyRouter());
+    },
+    async buildManifest(deployList, env) {
+      for (const _deployId of deployList.split(',')) {
+        const deployId = _deployId.trim();
+        if (!deployId) continue;
+
+        const router = await UnderpostDeploy.API.routerFactory(deployId, env);
+        const ports = Object.values(router).map((p) => parseInt(p.split(':')[2]));
+        const fromPort = Math.min(...ports);
+        const toPort = Math.max(...ports);
+        const confServer = loadReplicas(
+          JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8')),
+          'proxy',
+        );
+
+        fs.mkdirSync(`./engine-private/conf/${deployId}/build/${env}`, { recursive: true });
+        if (env === 'development') fs.mkdirSync(`./manifests/deployment/${deployId}-${env}`, { recursive: true });
+
+        logger.info('port range', { deployId, fromPort, toPort });
+
+        const deploymentYamlParts = `apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: ${deployId}-${env}
+  labels:
+    app: ${deployId}-${env}
+spec:
+  replicas: 2
+  selector:
+    matchLabels:
+      app: ${deployId}-${env}
+  template:
+    metadata:
+      labels:
+        app: ${deployId}-${env}
+    spec:
+      containers:
+        - name: ${deployId}-${env}
+          image: localhost/${deployId}-${env}:${Underpost.version}
+---
+apiVersion: v1
+kind: Service
+metadata:
+  name: ${deployId}-${env}-service
+spec:
+  selector:
+    app: ${deployId}-${env}
+  ports:
+  type: LoadBalancer`.split('ports:');
+        deploymentYamlParts[1] =
+          buildKindPorts(fromPort, toPort) +
+          `  type: LoadBalancer
+`;
+
+        fs.writeFileSync(
+          `./engine-private/conf/${deployId}/build/${env}/deployment.yaml`,
+          deploymentYamlParts.join(`ports:
+`),
+        );
+
+        let proxyYaml = '';
+        let secretYaml = '';
+
+        for (const host of Object.keys(confServer)) {
+          if (env === 'production')
+            secretYaml += `
+---
+apiVersion: cert-manager.io/v1
+kind: Certificate
+metadata:
+  name: ${host}
+spec:
+  commonName: ${host}
+  dnsNames:
+    - ${host}
+  issuerRef:
+    name: letsencrypt-prod
+    kind: ClusterIssuer
+  secretName: ${host}`;
+
+          const pathPortConditions = [];
+          for (const path of Object.keys(confServer[host])) {
+            const { peer } = confServer[host][path];
+            if (!router[`${host}${path === '/' ? '' : path}`]) continue;
+            const port = parseInt(router[`${host}${path === '/' ? '' : path}`].split(':')[2]);
+            // logger.info('', { host, port, path });
+            pathPortConditions.push({
+              port,
+              path,
+            });
+
+            if (peer) {
+              //  logger.info('', { host, port: port + 1, path: '/peer' });
+              pathPortConditions.push({
+                port: port + 1,
+                path: '/peer',
+              });
+            }
+          }
+
+          // logger.info('', { host, pathPortConditions });
+          proxyYaml += `
+---
+apiVersion: projectcontour.io/v1
+kind: HTTPProxy
+metadata:
+  name: ${host}
+spec:
+  virtualhost:
+    fqdn: ${host}${
+            env === 'development'
+              ? ''
+              : `
+    tls:
+      secretName: ${host}`
+          }
+  routes:`;
+          for (const conditionObj of pathPortConditions) {
+            const { path, port } = conditionObj;
+            proxyYaml += `
+    - conditions:
+        - prefix: ${path}
+      enableWebsockets: true
+      services:
+        - name: ${deployId}-${env}-service
+          port: ${port}`;
+          }
+        }
+        const yamlPath = `./engine-private/conf/${deployId}/build/${env}/proxy.yaml`;
+        fs.writeFileSync(yamlPath, proxyYaml, 'utf8');
+        if (env === 'production') {
+          const yamlPath = `./engine-private/conf/${deployId}/build/${env}/secret.yaml`;
+          fs.writeFileSync(yamlPath, secretYaml, 'utf8');
+        } else {
+          const deploymentsFiles = ['Dockerfile', 'proxy.yaml', 'deployment.yaml'];
+          for (const file of deploymentsFiles) {
+            if (fs.existsSync(`./engine-private/conf/${deployId}/build/${env}/${file}`)) {
+              fs.copyFileSync(
+                `./engine-private/conf/${deployId}/build/${env}/${file}`,
+                `./manifests/deployment/${deployId}-${env}/${file}`,
+              );
+            }
+          }
+        }
+      }
+    },
+    async callback(
+      deployList = 'default',
+      env = 'development',
+      options = { remove: false, infoRouter: false, sync: false, buildManifest: false },
+    ) {
+      if (deployList === 'dd' && fs.existsSync(`./engine-private/deploy/dd-router`))
+        deployList = fs.readFileSync(`./engine-private/deploy/dd-router`, 'utf8');
+      if (options.sync) UnderpostDeploy.API.sync(deployList);
+      if (options.buildManifest === true) await UnderpostDeploy.API.buildManifest(deployList, env);
+      if (options.infoRouter === true)
+        return logger.info('router', await UnderpostDeploy.API.routerFactory(deployList, env));
+
+      for (const _deployId of deployList.split(',')) {
+        const deployId = _deployId.trim();
+        if (!deployId) continue;
+
+        shellExec(`sudo kubectl delete svc ${deployId}-${env}-service`);
+        shellExec(`sudo kubectl delete deployment ${deployId}-${env}`);
+
+        const etcHost = (
+          concat,
+        ) => `127.0.0.1  ${concat} localhost localhost.localdomain localhost4 localhost4.localdomain4
+::1         localhost localhost.localdomain localhost6 localhost6.localdomain6`;
+        let concatHots = '';
+
+        const confServer = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'));
+        for (const host of Object.keys(confServer)) {
+          shellExec(`sudo kubectl delete HTTPProxy ${host}`);
+          if (!options.remove === true && env === 'development') concatHots += ` ${host}`;
+        }
+
+        if (!options.remove === true) {
+          shellExec(`sudo kubectl apply -f ./manifests/deployment/${deployId}-${env}/deployment.yaml`);
+          shellExec(`sudo kubectl apply -f ./manifests/deployment/${deployId}-${env}/proxy.yaml`);
+        }
+
+        let renderHosts;
+
+        switch (process.platform) {
+          case 'linux':
+            {
+              switch (env) {
+                case 'development':
+                  renderHosts = etcHost(concatHots);
+                  fs.writeFileSync(`/etc/hosts`, renderHosts, 'utf8');
+
+                  break;
+
+                default:
+                  break;
+              }
+            }
+            break;
+
+          default:
+            break;
+        }
+        logger.info(
+          `
+` + renderHosts,
+        );
+      }
+    },
+    getPods(deployId) {
+      const raw = shellExec(`sudo kubectl get pods --all-namespaces -o wide`, {
+        stdout: true,
+        disableLog: false,
+        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;
+    },
+  };
+}
+
+export default UnderpostDeploy;

package/src/cli/image.js

@@ -1,7 +1,6 @@
 import fs from 'fs-extra';
 import Underpost from '../index.js';
 import { shellExec } from '../server/process.js';
-import { MariaDB } from '../db/mariadb/MariaDB.js';
 import dotenv from 'dotenv';
 import { getNpmRootPath } from '../server/conf.js';
 
@@ -45,17 +44,6 @@ class UnderpostImage {
           case 'dd-lampp':
             {
               const lamppPublicPath = '/xampp/htdocs/online';
-              if (process.argv.includes('test')) {
-                const { MARIADB_HOST, MARIADB_USER, MARIADB_PASSWORD, DD_LAMPP_TEST_DB_0 } = process.env;
-
-                await MariaDB.query({
-                  host: MARIADB_HOST,
-                  user: MARIADB_USER,
-                  password: MARIADB_PASSWORD,
-                  query: `SHOW TABLES FROM ${DD_LAMPP_TEST_DB_0}`,
-                });
-                process.exit(0);
-              }
               shellExec(`sudo mkdir -p ${lamppPublicPath}`);
 
               {

package/src/cli/repository.js

@@ -4,6 +4,7 @@ import { pbcopy, shellExec } from '../server/process.js';
 import { actionInitLog, loggerFactory } from '../server/logger.js';
 import fs from 'fs-extra';
 import { getNpmRootPath } from '../server/conf.js';
+import { listenPortController, listenServerFactory } from '../server/network.js';
 
 dotenv.config();
 
@@ -54,6 +55,10 @@ class UnderpostRepository {
         empty: false,
       },
     ) {
+      if (commitType === 'reset') {
+        shellExec(`cd ${repoPath} && git reset --soft HEAD~${isNaN(parseInt(subModule)) ? 1 : parseInt(subModule)}`);
+        return;
+      }
       if (options.info) return logger.info('', commitData);
       const _message = `${commitType}${subModule ? `(${subModule})` : ''}${process.argv.includes('!') ? '!' : ''}: ${
         commitData[commitType].emoji
@@ -82,9 +87,10 @@ class UnderpostRepository {
     new(repositoryName) {
       return new Promise(async (resolve, reject) => {
         try {
-          const exeRootPath = `${getNpmRootPath()}/underpost`;
-          actionInitLog();
           await logger.setUpInfo();
+          if (repositoryName === 'service') return resolve(await listenPortController(listenServerFactory(), ':'));
+          else actionInitLog();
+          const exeRootPath = `${getNpmRootPath()}/underpost`;
           const destFolder = `./${repositoryName}`;
           logger.info('Note: This process may take several minutes to complete');
           logger.info('build app', { destFolder });

package/src/cli/test.js

@@ -1,6 +1,8 @@
+import { MariaDB } from '../db/mariadb/MariaDB.js';
 import { getNpmRootPath } from '../server/conf.js';
 import { actionInitLog, loggerFactory } from '../server/logger.js';
-import { shellExec } from '../server/process.js';
+import { pbcopy, shellExec } from '../server/process.js';
+import UnderpostDeploy from './deploy.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -26,6 +28,52 @@ class UnderpostTest {
       actionInitLog();
       shellExec(`cd ${getNpmRootPath()}/underpost && npm run test`);
     },
+    async callback(deployList = '', options = { insideContainer: false, sh: false }) {
+      if (options.sh === true) {
+        const [pod] = UnderpostDeploy.API.getPods(deployList);
+        if (pod) return pbcopy(`sudo kubectl exec -it ${pod.NAME} -- sh`);
+        return logger.warn(`Couldn't find pods in deployment`, deployList);
+      }
+      if (deployList) {
+        for (const _deployId of deployList.split(',')) {
+          const deployId = _deployId.trim();
+          if (!deployId) continue;
+          if (options.insideContainer === true)
+            switch (deployId) {
+              case 'dd-lampp':
+                {
+                  const { MARIADB_HOST, MARIADB_USER, MARIADB_PASSWORD, DD_LAMPP_TEST_DB_0 } = process.env;
+
+                  await MariaDB.query({
+                    host: MARIADB_HOST,
+                    user: MARIADB_USER,
+                    password: MARIADB_PASSWORD,
+                    query: `SHOW TABLES FROM ${DD_LAMPP_TEST_DB_0}`,
+                  });
+                }
+                break;
+
+              default:
+                {
+                  shellExec('npm run test');
+                }
+
+                break;
+            }
+          else {
+            const pods = UnderpostDeploy.API.getPods(deployId);
+            if (pods.length > 0)
+              for (const deployData of pods) {
+                const { NAME } = deployData;
+                shellExec(
+                  `sudo kubectl exec -i ${NAME} -- sh -c "cd /home/dd/engine && underpost test ${deployId} --inside-container"`,
+                );
+              }
+            else logger.warn(`Couldn't find pods in deployment`, { deployId });
+          }
+        }
+      } else return UnderpostTest.API.run();
+    },
   };
 }
 

package/src/client/components/core/CommonJs.js

@@ -573,6 +573,14 @@ const isValidFormat = (value, format) => {
   }
 };
 
+const getCurrentTrace = () => {
+  try {
+    _stack;
+  } catch (error) {
+    return error.stack.split('is not defined')[1];
+  }
+};
+
 /**
  * Returns the time difference between UTC time and local time, in minutes.
  * @memberof CommonJS
@@ -943,6 +951,7 @@ export {
   commonAdminGuard,
   commonModeratorGuard,
   isChileanIdentityDocument,
+  getCurrentTrace,
   userRoleEnum,
   commitData,
 };

package/src/client/components/core/Modal.js

@@ -9,7 +9,6 @@ import {
   htmls,
   sa,
   getAllChildNodes,
-  getCurrentTrace,
   isActiveElement,
 } from './VanillaJs.js';
 import { BtnIcon } from './BtnIcon.js';

package/src/client/components/core/VanillaJs.js

@@ -419,14 +419,6 @@ const isActiveTab = () => document.hasFocus();
 const isActiveElement = (classSearch = '') =>
   document.activeElement?.classList?.value?.match(classSearch) ? true : false;
 
-const getCurrentTrace = () => {
-  try {
-    _stack;
-  } catch (error) {
-    return error.stack.split('is not defined')[1];
-  }
-};
-
 const isDevInstance = () => location.origin.match('localhost') && location.port;
 
 const getDataFromInputFile = async (file) => Array.from(new Uint8Array(await file.arrayBuffer()));
@@ -460,7 +452,6 @@ export {
   isNavigator,
   getTimeZone,
   getAllChildNodes,
-  getCurrentTrace,
   isActiveTab,
   isActiveElement,
   isDevInstance,

package/src/client/components/core/Worker.js

@@ -22,41 +22,44 @@ const Worker = {
     setTimeout(() => {
       if ('onLine' in navigator && navigator.onLine) window.ononline();
     });
-    navigator.serviceWorker.addEventListener('controllerchange', () => {
-      logger.info('The controller of current browsing context has changed.');
-    });
-    navigator.serviceWorker.ready.then((worker) => {
-      logger.info('Ready', worker);
-      // event message
-      navigator.serviceWorker.addEventListener('message', (event) => {
-        logger.info('Received event message', event.data);
-        const { status } = event.data;
+    if ('serviceWorker' in navigator) {
+      navigator.serviceWorker.addEventListener('controllerchange', () => {
+        logger.info('The controller of current browsing context has changed.');
+      });
+      navigator.serviceWorker.ready.then((worker) => {
+        logger.info('Ready', worker);
+        // event message
+        navigator.serviceWorker.addEventListener('message', (event) => {
+          logger.info('Received event message', event.data);
+          const { status } = event.data;
 
-        switch (status) {
-          case 'loader':
-            {
-              LoadingAnimation.RenderCurrentSrcLoad(event);
-            }
-            break;
+          switch (status) {
+            case 'loader':
+              {
+                LoadingAnimation.RenderCurrentSrcLoad(event);
+              }
+              break;
 
-          default:
-            break;
-        }
-      });
+            default:
+              break;
+          }
+        });
 
-      // if (navigator.serviceWorker.controller)
-      //   navigator.serviceWorker.controller.postMessage({
-      //     title: 'Hello from Client event message',
-      //   });
+        // if (navigator.serviceWorker.controller)
+        //   navigator.serviceWorker.controller.postMessage({
+        //     title: 'Hello from Client event message',
+        //   });
+
+        // broadcast message
+        // const channel = new BroadcastChannel('sw-messages');
+        // channel.addEventListener('message', (event) => {
+        //   logger.info('Received broadcast message', event.data);
+        // });
+        // channel.postMessage({ title: 'Hello from Client broadcast message' });
+        // channel.close();
+      });
+    }
 
-      // broadcast message
-      // const channel = new BroadcastChannel('sw-messages');
-      // channel.addEventListener('message', (event) => {
-      //   logger.info('Received broadcast message', event.data);
-      // });
-      // channel.postMessage({ title: 'Hello from Client broadcast message' });
-      // channel.close();
-    });
     this.RouterInstance = router();
     const isInstall = await this.status();
     if (!isInstall) await this.install();

package/src/index.js

@@ -6,6 +6,7 @@
 
 import UnderpostCluster from './cli/cluster.js';
 import UnderpostDB from './cli/db.js';
+import UnderpostDeploy from './cli/deploy.js';
 import UnderpostRootEnv from './cli/env.js';
 import UnderpostImage from './cli/image.js';
 import UnderpostRepository from './cli/repository.js';
@@ -25,7 +26,7 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v2.8.46';
+  static version = 'v2.8.48';
   /**
    * Repository cli API
    * @static
@@ -82,6 +83,13 @@ class Underpost {
    * @memberof Underpost
    */
   static db = UnderpostDB.API;
+  /**
+   * Deployment cli API
+   * @static
+   * @type {UnderpostDeploy.API}
+   * @memberof Underpost
+   */
+  static deploy = UnderpostDeploy.API;
 }
 
 const up = Underpost;

package/src/server/conf.js

@@ -40,21 +40,26 @@ const logger = loggerFactory(import.meta);
 
 const Config = {
   default: DefaultConf,
-  build: async function (options = { folder: '' }) {
+  build: async function (options = { folder: '' }, deployContext, deployList, subConf) {
+    if (!deployContext) deployContext = process.argv[2];
     if (!fs.existsSync(`./tmp`)) fs.mkdirSync(`./tmp`, { recursive: true });
     fs.writeFileSync(`./tmp/await-deploy`, '', 'utf8');
-    if (fs.existsSync(`./engine-private/conf/${process.argv[2]}`)) return loadConf(process.argv[2]);
-    if (fs.existsSync(`./engine-private/replica/${process.argv[2]}`)) return loadConf(process.argv[2]);
+    if (fs.existsSync(`./engine-private/conf/${deployContext}`))
+      return loadConf(deployContext, process.env.NODE_ENV, subConf);
+    if (fs.existsSync(`./engine-private/replica/${deployContext}`))
+      return loadConf(deployContext, process.env.NODE_ENV, subConf);
 
-    if (process.argv[2] === 'deploy') return;
+    if (deployContext === 'deploy') return;
 
-    if (process.argv[2] === 'proxy') {
+    if (deployContext === 'proxy') {
+      if (!deployList) deployList = process.argv[3];
+      if (!subConf) subConf = process.argv[4];
       this.default.server = {};
-      for (const deployId of process.argv[3].split(',')) {
+      for (const deployId of deployList.split(',')) {
         let confPath = `./engine-private/conf/${deployId}/conf.server.json`;
         const privateConfDevPath = fs.existsSync(`./engine-private/replica/${deployId}/conf.server.json`)
           ? `./engine-private/replica/${deployId}/conf.server.json`
-          : `./engine-private/conf/${deployId}/conf.server.dev.${process.argv[4]}.json`;
+          : `./engine-private/conf/${deployId}/conf.server.dev.${subConf}.json`;
         const confDevPath = fs.existsSync(privateConfDevPath)
           ? privateConfDevPath
           : `./engine-private/conf/${deployId}/conf.server.dev.json`;
@@ -62,7 +67,7 @@ const Config = {
         if (process.env.NODE_ENV === 'development' && fs.existsSync(confDevPath)) confPath = confDevPath;
         const serverConf = JSON.parse(fs.readFileSync(confPath, 'utf8'));
 
-        for (const host of Object.keys(loadReplicas(serverConf))) {
+        for (const host of Object.keys(loadReplicas(serverConf, deployContext, subConf))) {
           if (serverConf[host]['/'])
             this.default.server[host] = {
               ...this.default.server[host],
@@ -92,7 +97,7 @@ const Config = {
   },
 };
 
-const loadConf = (deployId, envInput) => {
+const loadConf = (deployId, envInput, subConf) => {
   const folder = fs.existsSync(`./engine-private/replica/${deployId}`)
     ? `./engine-private/replica/${deployId}`
     : `./engine-private/conf/${deployId}`;
@@ -109,7 +114,8 @@ const loadConf = (deployId, envInput) => {
       ? fs.readFileSync(`${folder}/conf.${typeConf}.json`, 'utf8')
       : JSON.stringify(Config.default[typeConf]);
     if (process.env.NODE_ENV === 'development' && typeConf === 'server') {
-      const devConfPath = `${folder}/conf.${typeConf}.dev${process.argv[3] ? `.${process.argv[3]}` : ''}.json`;
+      if (!subConf) subConf = process.argv[3];
+      const devConfPath = `${folder}/conf.${typeConf}.dev${subConf ? `.${subConf}` : ''}.json`;
       if (fs.existsSync(devConfPath)) srcConf = fs.readFileSync(devConfPath, 'utf8');
     }
     if (typeConf === 'server') srcConf = JSON.stringify(loadReplicas(JSON.parse(srcConf)), null, 4);
@@ -135,15 +141,17 @@ const loadConf = (deployId, envInput) => {
   return { folder, deployId };
 };
 
-const loadReplicas = (confServer) => {
+const loadReplicas = (confServer, deployContext, subConf) => {
+  if (!deployContext) deployContext = process.argv[2];
+  if (!subConf) subConf = process.argv[3];
   for (const host of Object.keys(confServer)) {
     for (const path of Object.keys(confServer[host])) {
       const { replicas, singleReplica } = confServer[host][path];
       if (
         replicas &&
-        (process.argv[2] === 'proxy' ||
+        (deployContext === 'proxy' ||
           !singleReplica ||
-          (singleReplica && process.env.NODE_ENV === 'development' && !process.argv[3]))
+          (singleReplica && process.env.NODE_ENV === 'development' && !subConf))
       )
         for (const replicaPath of replicas) {
           confServer[host][replicaPath] = newInstance(confServer[host][path]);
@@ -513,14 +521,16 @@ const buildPortProxyRouter = (port, proxyRouter) => {
   // build router
   Object.keys(hosts).map((hostKey) => {
     let { host, path, target, proxy, peer } = hosts[hostKey];
-    if (process.env.NODE_ENV === 'development') host = `localhost`;
+    if (process.argv.includes('localhost') && process.env.NODE_ENV === 'development') host = `localhost`;
 
     if (!proxy.includes(port)) return;
     const absoluteHost = [80, 443].includes(port)
       ? `${host}${path === '/' ? '' : path}`
       : `${host}:${port}${path === '/' ? '' : path}`;
 
-    if (!(absoluteHost in router)) router[absoluteHost] = target;
+    if (process.argv.includes('localhost')) {
+      if (!(absoluteHost in router)) router[absoluteHost] = target;
+    } else router[absoluteHost] = target;
   }); // order router
 
   if (Object.keys(router).length === 0) return router;

package/src/server/network.js

@@ -1,7 +1,7 @@
 import fs from 'fs-extra';
 
 import { publicIp, publicIpv4, publicIpv6 } from 'public-ip';
-import { loggerFactory } from './logger.js';
+import { actionInitLog, loggerFactory } from './logger.js';
 import { DataBaseProvider } from '../db/DataBaseProvider.js';
 import { getDeployId } from './conf.js';
 
@@ -77,7 +77,7 @@ const saveRuntimeRouter = async () => {
 
     if (closeConn) await DataBaseProvider.instance[`${host}${path}`].mongoose.close();
   } catch (error) {
-    logger.error(error);
+    logger.error(error, error.stack);
   }
 };
 
@@ -114,20 +114,30 @@ const saveRuntimeCron = async () => {
 
     if (closeConn) await DataBaseProvider.instance[`${host}${path}`].mongoose.close();
   } catch (error) {
-    logger.error(error);
+    logger.error(error, error.stack);
   }
 };
 
 const listenServerFactory = (logic = async () => {}) => {
   return {
-    listen: async (...args) => (logic ? await logic(...args) : undefined, args[1]()),
+    listen: async (...args) => (
+      setTimeout(() => {
+        const message = 'Listen server factory timeout';
+        logger.error(message);
+        throw new Error(message);
+      }, 80000000), // ~ 55 days
+      (logic ? await logic(...args) : undefined, args[1]())
+    ),
   };
 };
 
 const listenPortController = async (server, port, metadata) =>
   new Promise((resolve) => {
     try {
-      if (!server) server = listenServerFactory();
+      if (port === ':') {
+        server.listen(port, actionInitLog);
+        return resolve(true);
+      }
 
       const { host, path, client, runtime, meta } = metadata;
       const error = [];