underpost 2.8.31 → 2.8.42

package/src/runtime/lampp/Lampp.js

@@ -1,5 +1,4 @@
 import fs from 'fs-extra';
-import { network } from '../../server/network.js';
 import { shellCd, shellExec } from '../../server/process.js';
 import { timer } from '../../client/components/core/CommonJs.js';
 import { loggerFactory } from '../../server/logger.js';
@@ -39,20 +38,9 @@ const Lampp = {
       );
 
     shellExec(cmd);
-    await network.port.portClean(3306);
-    for (const port of this.ports) await network.port.portClean(port);
     cmd = `sudo /opt/lampp/lampp start`;
     if (this.router) fs.writeFileSync(`./tmp/lampp-router.conf`, this.router, 'utf-8');
-    shellExec(cmd, { async: true });
-    if (options && options.daemon) this.daemon();
-  },
-  daemon: async function () {
-    await timer(1000 * 60 * 2); // 2 minutes
-    for (const port of this.ports) {
-      const [portStatus] = await network.port.status([port]);
-      if (!portStatus.open) return await this.initService();
-    }
-    this.daemon();
+    shellExec(cmd);
   },
   enabled: () => fs.existsSync(`/opt/lampp/apache2/conf/httpd.conf`),
   appendRouter: function (render) {

package/src/runtime/xampp/Xampp.js

@@ -1,7 +1,5 @@
 import fs from 'fs-extra';
-import { network } from '../../server/network.js';
 import { shellExec } from '../../server/process.js';
-import { timer } from '../../client/components/core/CommonJs.js';
 
 const Xampp = {
   ports: [],
@@ -16,20 +14,9 @@ const Xampp = {
     fs.writeFileSync(`C:/xampp/apache/conf/extra/httpd-ssl.conf`, this.router || '', 'utf8');
     cmd = `C:/xampp/xampp_stop.exe`;
     shellExec(cmd);
-    await network.port.portClean(3306);
-    for (const port of this.ports) await network.port.portClean(port);
     cmd = `C:/xampp/xampp_start.exe`;
     if (this.router) fs.writeFileSync(`./tmp/xampp-router.conf`, this.router, 'utf-8');
     shellExec(cmd);
-    if (options && options.daemon) this.daemon();
-  },
-  daemon: async function () {
-    await timer(1000 * 60 * 2); // 2 minutes
-    for (const port of this.ports) {
-      const [portStatus] = await network.port.status([port]);
-      if (!portStatus.open) return await this.initService();
-    }
-    this.daemon();
   },
   enabled: () => fs.existsSync(`C:/xampp/apache/conf/httpd.conf`),
   appendRouter: function (render) {

package/src/server/auth.js

@@ -9,7 +9,7 @@ import jwt from 'jsonwebtoken';
 import { loggerFactory } from './logger.js';
 import crypto from 'crypto';
 import { userRoleEnum } from '../api/user/user.model.js';
-import { validatePassword } from '../client/components/core/CommonJs.js';
+import { commonAdminGuard, commonModeratorGuard, validatePassword } from '../client/components/core/CommonJs.js';
 
 dotenv.config();
 
@@ -162,7 +162,7 @@ const authMiddleware = (req, res, next) => {
  */
 const adminGuard = (req, res, next) => {
   try {
-    if (!(userRoleEnum.indexOf(req.auth.user.role) === userRoleEnum.indexOf('admin')))
+    if (!commonAdminGuard(req.auth.user.role))
       return res.status(403).json({ status: 'error', message: 'Insufficient permission' });
     return next();
   } catch (error) {
@@ -194,7 +194,7 @@ const adminGuard = (req, res, next) => {
  */
 const moderatorGuard = (req, res, next) => {
   try {
-    if (!(userRoleEnum.indexOf(req.auth.user.role) <= userRoleEnum.indexOf('moderator')))
+    if (!commonModeratorGuard(req.auth.user.role))
       return res.status(403).json({ status: 'error', message: 'Insufficient permission' });
     return next();
   } catch (error) {

package/src/server/client-build.js

@@ -50,10 +50,10 @@ const fullBuild = async ({
   buildAcmeChallengePath(acmeChallengeFullPath);
 
   if (publicClientId && publicClientId.startsWith('html-website-templates')) {
-    if (!fs.existsSync(`/dd/html-website-templates/`))
-      shellExec(`cd /dd && git clone https://github.com/designmodo/html-website-templates.git`);
+    if (!fs.existsSync(`/home/dd/html-website-templates/`))
+      shellExec(`cd /home/dd && git clone https://github.com/designmodo/html-website-templates.git`);
     if (!fs.existsSync(`${rootClientPath}/index.php`)) {
-      fs.copySync(`/dd/html-website-templates/${publicClientId.split('-publicClientId-')[1]}`, rootClientPath);
+      fs.copySync(`/home/dd/html-website-templates/${publicClientId.split('-publicClientId-')[1]}`, rootClientPath);
       shellExec(`cd ${rootClientPath} && git init && git add . && git commit -m "Base template implementation"`);
       // git remote add origin git@github.com:<username>/<repo>.git
       fs.writeFileSync(`${rootClientPath}/.git/.htaccess`, `Deny from all`, 'utf8');
@@ -545,17 +545,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
         let siteMapSrc = await new Promise((resolve) =>
           streamToPromise(Readable.from(siteMapLinks).pipe(siteMapStream)).then((data) => resolve(data.toString())),
         );
-        switch (publicClientId) {
-          case 'underpost':
-            siteMapSrc = siteMapSrc.replaceAll(
-              `</urlset>`,
-              `${fs.readFileSync(`./src/client/public/underpost/sitemap-template.txt`, 'utf8')} </urlset>`,
-            );
-            break;
 
-          default:
-            break;
-        }
         // Return a promise that resolves with your XML string
         fs.writeFileSync(`${rootClientPath}/sitemap.xml`, siteMapSrc, 'utf8');
         if (xslUrl)

package/src/server/conf.js

@@ -1,13 +1,20 @@
 import fs from 'fs-extra';
 import dotenv from 'dotenv';
-import { capFirst, getCapVariableName, newInstance, range, timer } from '../client/components/core/CommonJs.js';
+import {
+  capFirst,
+  getCapVariableName,
+  newInstance,
+  orderArrayFromAttrInt,
+  range,
+  timer,
+} from '../client/components/core/CommonJs.js';
 import * as dir from 'path';
 import cliProgress from 'cli-progress';
 import cliSpinners from 'cli-spinners';
 import logUpdate from 'log-update';
 import colors from 'colors';
-import { loggerFactory } from './logger.js';
-import { shellExec } from './process.js';
+import { actionInitLog, loggerFactory } from './logger.js';
+import { pbcopy, shellExec } from './process.js';
 import { DefaultConf } from '../../conf.js';
 import read from 'read';
 import splitFile from 'split-file';
@@ -17,13 +24,14 @@ import { ssrFactory } from './client-formatted.js';
 
 // axios.defaults.baseURL = BASE_URL;
 
-const httpsAgent = new https.Agent({
-  rejectUnauthorized: false,
-});
+// const httpsAgent = new https.Agent({
+//   rejectUnauthorized: false,
+// });
 
-axios.defaults.httpsAgent = httpsAgent;
+// axios.defaults.httpsAgent = httpsAgent;
 
 colors.enable();
+
 dotenv.config();
 
 const logger = loggerFactory(import.meta);
@@ -84,7 +92,7 @@ const Config = {
   },
 };
 
-const loadConf = (deployId) => {
+const loadConf = (deployId, envInput) => {
   const folder = fs.existsSync(`./engine-private/replica/${deployId}`)
     ? `./engine-private/replica/${deployId}`
     : `./engine-private/conf/${deployId}`;
@@ -110,9 +118,10 @@ const loadConf = (deployId) => {
   fs.writeFileSync(`./.env.production`, fs.readFileSync(`${folder}/.env.production`, 'utf8'), 'utf8');
   fs.writeFileSync(`./.env.development`, fs.readFileSync(`${folder}/.env.development`, 'utf8'), 'utf8');
   fs.writeFileSync(`./.env.test`, fs.readFileSync(`${folder}/.env.test`, 'utf8'), 'utf8');
-  if (process.env.NODE_ENV) {
-    fs.writeFileSync(`./.env`, fs.readFileSync(`${folder}/.env.${process.env.NODE_ENV}`, 'utf8'), 'utf8');
-    const env = dotenv.parse(fs.readFileSync(`${folder}/.env.${process.env.NODE_ENV}`, 'utf8'));
+  const NODE_ENV = envInput || process.env.NODE_ENV;
+  if (NODE_ENV) {
+    fs.writeFileSync(`./.env`, fs.readFileSync(`${folder}/.env.${NODE_ENV}`, 'utf8'), 'utf8');
+    const env = dotenv.parse(fs.readFileSync(`${folder}/.env.${NODE_ENV}`, 'utf8'));
     process.env = {
       ...process.env,
       ...env,
@@ -479,6 +488,44 @@ const buildProxyRouter = () => {
   return proxyRouter;
 };
 
+const buildKindPorts = (from, to) =>
+  range(parseInt(from), parseInt(to))
+    .map(
+      (port) => `    - name: 'tcp-${port}'
+      protocol: TCP
+      port: ${port}
+      targetPort: ${port}
+    - name: 'udp-${port}'
+      protocol: UDP
+      port: ${port}
+      targetPort: ${port}
+`,
+    )
+    .join('\n');
+
+const buildPortProxyRouter = (port, proxyRouter) => {
+  const hosts = proxyRouter[port];
+  const router = {};
+  // build router
+  Object.keys(hosts).map((hostKey) => {
+    let { host, path, target, proxy, peer } = hosts[hostKey];
+    if (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;
+  }); // order router
+
+  if (Object.keys(router).length === 0) return router;
+
+  for (const absoluteHostKey of orderArrayFromAttrInt(Object.keys(router), 'length'))
+    router[absoluteHostKey] = router[absoluteHostKey];
+  return router;
+};
+
 const cliBar = async (time = 5000) => {
   // create new progress bar
   const b = new cliProgress.SingleBar({
@@ -587,6 +634,7 @@ const validateTemplatePath = (absolutePath = '') => {
   if (absolutePath.match('src/api') && !confServer.apis.find((p) => absolutePath.match(`src/api/${p}/`))) {
     return false;
   }
+  if (absolutePath.match('conf.dd-') && absolutePath.match('.js')) return false;
   if (
     absolutePath.match('src/client/services/') &&
     !clients.find((p) => absolutePath.match(`src/client/services/${p}/`))
@@ -790,13 +838,10 @@ const restoreMacroDb = async (deployGroupId = '', deployId = null) => {
   }
 };
 
-const mergeBackUp = async (baseBackJsonPath, outputFilePath) => {
-  const names = JSON.parse(fs.readFileSync(baseBackJsonPath, 'utf8')).map((p) =>
-    p.replaceAll(`\\`, '/').replaceAll('C:/', '/').replaceAll('c:/', '/'),
-  );
+const mergeFile = async (parts = [], outputFilePath) => {
   await new Promise((resolve) => {
     splitFile
-      .mergeFiles(names, outputFilePath)
+      .mergeFiles(parts, outputFilePath)
       .then(() => {
         resolve();
       })
@@ -848,11 +893,13 @@ const getRestoreCronCmd = async (options = { host: '', path: '', conf: {}, deplo
       {
         if (process.argv.includes('cron')) {
           cmd = `mysql -u ${user} -p${password} ${name} < ${baseBackUpPath}/${currentBackupTimestamp}/${name}.sql`;
-          if (fs.existsSync(`${baseBackUpPath}/${currentBackupTimestamp}/${name}-parths.json`))
-            await mergeBackUp(
-              `${baseBackUpPath}/${currentBackupTimestamp}/${name}-parths.json`,
-              `${baseBackUpPath}/${currentBackupTimestamp}/${name}.sql`,
-            );
+          if (fs.existsSync(`${baseBackUpPath}/${currentBackupTimestamp}/${name}-parths.json`)) {
+            const names = JSON.parse(
+              fs.readFileSync(`${baseBackUpPath}/${currentBackupTimestamp}/${name}-parths.json`, 'utf8'),
+            ).map((p) => p.replaceAll(`\\`, '/').replaceAll('C:/', '/').replaceAll('c:/', '/'));
+
+            await mergeFile(names, `${baseBackUpPath}/${currentBackupTimestamp}/${name}.sql`);
+          }
         } else {
           cmd = `mysql -u ${user} -p${password} ${name} < ${
             backupPath ? backupPath : `./engine-private/sql-backups/${name}.sql`
@@ -863,15 +910,23 @@ const getRestoreCronCmd = async (options = { host: '', path: '', conf: {}, deplo
                 backupPath ? backupPath.split('/').slice(0, -1).join('/') : `./engine-private/sql-backups`
               }/${name}-parths.json`,
             )
-          )
-            await mergeBackUp(
-              `${
-                backupPath ? backupPath.split('/').slice(0, -1).join('/') : `./engine-private/sql-backups`
-              }/${name}-parths.json`,
+          ) {
+            const names = JSON.parse(
+              fs.readFileSync(
+                `${
+                  backupPath ? backupPath.split('/').slice(0, -1).join('/') : `./engine-private/sql-backups`
+                }/${name}-parths.json`,
+                'utf8',
+              ),
+            ).map((p) => p.replaceAll(`\\`, '/').replaceAll('C:/', '/').replaceAll('c:/', '/'));
+
+            await mergeFile(
+              names,
               `${
                 backupPath ? backupPath.split('/').slice(0, -1).join('/') : `./engine-private/sql-backups`
               }/${name}.sql`,
             );
+          }
         }
       }
       break;
@@ -890,6 +945,16 @@ const getRestoreCronCmd = async (options = { host: '', path: '', conf: {}, deplo
   return cmd;
 };
 
+const getPathsSSR = (conf) => {
+  const paths = ['src/client/ssr/Render.js'];
+  for (const o of conf.head) paths.push(`src/client/ssr/head/${o}.js`);
+  for (const o of conf.body) paths.push(`src/client/ssr/body/${o}.js`);
+  for (const o of Object.keys(conf.mailer)) paths.push(`src/client/ssr/mailer/${conf.mailer[o]}.js`);
+  for (const o of conf.offline) paths.push(`src/client/ssr/mailer/${o.client}.js`);
+  for (const o of conf.pages) paths.push(`src/client/ssr/pages/${o.client}.js`);
+  return paths;
+};
+
 const Cmd = {
   delete: (deployId) => `pm2 delete ${deployId}`,
   run: (deployId) => `node bin/deploy run ${deployId}`,
@@ -904,6 +969,7 @@ const Cmd = {
 };
 
 const fixDependencies = async () => {
+  return;
   // sed -i "$line_number s,.*,$new_text," "$file"
   // sed -i "$line_number c \\$new_text" "$file"
   const dep = fs.readFileSync(`./node_modules/peer/dist/module.mjs`, 'utf8');
@@ -933,6 +999,34 @@ const maintenanceMiddleware = (req, res, port, proxyRouter) => {
   }
 };
 
+const splitFileFactory = async (name, _path) => {
+  const stats = fs.statSync(_path);
+  const maxSizeInBytes = 1024 * 1024 * 50; // 50 mb
+  const fileSizeInBytes = stats.size;
+  if (fileSizeInBytes > maxSizeInBytes) {
+    logger.info('splitFileFactory input', { name, from: _path });
+    return await new Promise((resolve) => {
+      splitFile
+        .splitFileBySize(_path, maxSizeInBytes) // 50 mb
+        .then((names) => {
+          logger.info('splitFileFactory output', { parts: names });
+          fs.writeFileSync(
+            `${_path.split('/').slice(0, -1).join('/')}/${name}-parths.json`,
+            JSON.stringify(names, null, 4),
+            'utf8',
+          );
+          fs.removeSync(_path);
+          return resolve(true);
+        })
+        .catch((err) => {
+          console.log('Error: ', err);
+          return resolve(false);
+        });
+    });
+  }
+  return false;
+};
+
 const setUpProxyMaintenanceServer = ({ deployGroupId }) => {
   shellExec(`pm2 kill`);
   shellExec(`node bin/deploy valkey-service`);
@@ -941,6 +1035,168 @@ const setUpProxyMaintenanceServer = ({ deployGroupId }) => {
   shellExec(`node bin/deploy run ${proxyDeployId} maintenance`);
 };
 
+const repoClone = (gitUri = 'underpostnet/pwa-microservices-template') => {
+  const repoName = gitUri.split('/').pop();
+  if (fs.existsSync(`./${repoName}`)) fs.removeSync(`./${repoName}`);
+  shellExec(
+    `git clone https://${process.env.GITHUB_TOKEN ? `${process.env.GITHUB_TOKEN}@` : ''}github.com/${gitUri}.git`,
+  );
+  if (process.env.GITHUB_TOKEN) {
+    shellExec(
+      `git clone https://${
+        process.env.GITHUB_TOKEN ? `${process.env.GITHUB_TOKEN}@` : ''
+      }github.com/${gitUri}-private.git`,
+    );
+    fs.moveSync(`./${repoName}-private`, `./${repoName}/engine-private`, {
+      overwrite: true,
+    });
+  }
+};
+
+const repoPull = (repoPath = './', gitUri = 'underpostnet/pwa-microservices-template') => {
+  shellExec(`cd ${repoPath} && git pull https://${process.env.GITHUB_TOKEN}@github.com/${gitUri}.git`, {
+    disableLog: true,
+  });
+};
+
+const commitData = {
+  feat: {
+    description: 'A new feature',
+    title: 'Features',
+    emoji: '✨',
+  },
+  fix: {
+    description: 'A bug fix',
+    title: 'Bug Fixes',
+    emoji: '🐛',
+  },
+  docs: {
+    description: 'Documentation only changes',
+    title: 'Documentation',
+    emoji: '📚',
+  },
+  style: {
+    description:
+      'Changes that do not affect the meaning of the code (white-space, formatting, missing semi-colons, etc)',
+    title: 'Styles',
+    emoji: '💎',
+  },
+  refactor: {
+    description: 'A code change that neither fixes a bug nor adds a feature',
+    title: 'Code Refactoring',
+    emoji: '📦',
+  },
+  perf: {
+    description: 'A code change that improves performance',
+    title: 'Performance Improvements',
+    emoji: '⚡️',
+  },
+  cd: {
+    description:
+      'Changes to our Continuous Delivery configuration files and scripts (example scopes: Jenkins, Spinnaker, ArgoCD)',
+    title: 'Continuous Delivery',
+    emoji: '🚀',
+  },
+  test: {
+    description: 'Adding missing tests or correcting existing tests',
+    title: 'Tests',
+    emoji: '🚨',
+  },
+  build: {
+    description: 'Changes that affect the build system or external dependencies (example scopes: gulp, broccoli, npm)',
+    title: 'Builds',
+    emoji: '🛠',
+  },
+  ci: {
+    description:
+      'Changes to our CI configuration files and scripts (example scopes: Travis, Circle, BrowserStack, SauceLabs)',
+    title: 'Continuous Integrations',
+    emoji: '⚙️',
+  },
+  chore: {
+    description: "Other changes that don't modify src or test files",
+    title: 'Chores',
+    emoji: '♻️',
+  },
+  revert: {
+    description: 'Reverts a previous commit',
+    title: 'Reverts',
+    emoji: '🗑',
+  },
+  backup: {
+    description: 'Changes related to backups, including creation, restoration, and maintenance.',
+    title: 'Backups',
+    emoji: '💾',
+  },
+};
+
+const repoCommit = (
+  repoPath = './',
+  commitType = 'feat',
+  subModule = '',
+  message = '',
+  options = {
+    copy: false,
+    info: false,
+    empty: false,
+  },
+) => {
+  if (options.info) return logger.info('', commitData);
+  const _message = `${commitType}${subModule ? `(${subModule})` : ''}${process.argv.includes('!') ? '!' : ''}: ${
+    commitData[commitType].emoji
+  } ${message ? message : commitData[commitType].description}`;
+  if (options.copy) return pbcopy(_message);
+  shellExec(`cd ${repoPath} && git commit ${options?.empty ? `--allow-empty ` : ''}-m "${_message}"`);
+};
+
+const repoPush = (repoPath = './', gitUri = 'underpostnet/pwa-microservices-template') => {
+  shellExec(`cd ${repoPath} && git push https://${process.env.GITHUB_TOKEN}@github.com/${gitUri}.git`, {
+    disableLog: true,
+  });
+  logger.info(
+    'commit url',
+    `http://github.com/${gitUri}/commit/${shellExec(`cd ${repoPath} && git rev-parse --verify HEAD`, {
+      stdout: true,
+    }).trim()}`,
+  );
+};
+
+const getNpmRootPath = () =>
+  shellExec(`npm root -g`, {
+    stdout: true,
+  }).trim();
+
+const newProject = (repositoryName, version) => {
+  return new Promise(async (resolve, reject) => {
+    try {
+      const exeRootPath = `${getNpmRootPath()}/underpost`;
+      // const exeRootPath = '/home/dd/pwa-microservices-template';
+      actionInitLog(version);
+      await logger.setUpInfo();
+      const destFolder = `${process.cwd()}/${repositoryName}`;
+      logger.info('Note: This process may take several minutes to complete');
+      logger.info('build app', { destFolder });
+      fs.mkdirSync(destFolder, { recursive: true });
+      fs.copySync(exeRootPath, destFolder);
+      if (fs.existsSync(`${destFolder}/node_modules`)) fs.removeSync(`${destFolder}/node_modules`);
+      fs.writeFileSync(`${destFolder}/.gitignore`, fs.readFileSync(`${exeRootPath}/.dockerignore`, 'utf8'), 'utf8');
+      shellExec(`cd ${destFolder} && git init && git add . && git commit -m "Base template implementation"`);
+      shellExec(`cd ${destFolder} && npm install`);
+      shellExec(`cd ${destFolder} && npm run build`);
+      shellExec(`cd ${destFolder} && npm run dev`);
+      return resolve();
+    } catch (error) {
+      logger.error(error, error.stack);
+      return reject(error.message);
+    }
+  });
+};
+
+const runTest = (version) => {
+  actionInitLog(version);
+  shellExec(`cd ${getNpmRootPath()}/underpost && npm run test`);
+};
+
 export {
   Cmd,
   Config,
@@ -967,9 +1223,20 @@ export {
   deployRun,
   getCronBackUpFolder,
   getRestoreCronCmd,
-  mergeBackUp,
+  mergeFile,
   fixDependencies,
   getDeployId,
   maintenanceMiddleware,
   setUpProxyMaintenanceServer,
+  getPathsSSR,
+  buildKindPorts,
+  buildPortProxyRouter,
+  splitFileFactory,
+  repoClone,
+  repoPull,
+  repoCommit,
+  repoPush,
+  newProject,
+  runTest,
+  getNpmRootPath,
 };

package/src/server/dns.js

@@ -2,10 +2,9 @@ import axios from 'axios';
 import dotenv from 'dotenv';
 import fs from 'fs';
 import https from 'https';
-
+import validator from 'validator';
 import { ip } from './network.js';
 import { loggerFactory } from './logger.js';
-import { isIPv4 } from 'is-ip';
 import { shellExec } from './process.js';
 
 const httpsAgent = new https.Agent({
@@ -48,7 +47,7 @@ const Dns = {
       } catch (error) {
         logger.error(error, { testIp, stack: error.stack });
       }
-      if (testIp && typeof testIp === 'string' && isIPv4(testIp) && Dns.ip !== testIp) {
+      if (testIp && typeof testIp === 'string' && validator.isIP(testIp) && Dns.ip !== testIp) {
         logger.info(`New ip`, testIp);
         for (const recordType of Object.keys(confCronData.records)) {
           switch (recordType) {

package/src/server/logger.js

@@ -12,7 +12,6 @@ import morgan from 'morgan';
 import colorize from 'json-colorizer';
 import colors from 'colors';
 import v8 from 'v8';
-import isAdmin from 'is-admin';
 import { clearTerminalStringColor, formatBytes } from '../client/components/core/CommonJs.js';
 
 colors.enable();
@@ -79,8 +78,7 @@ const format = (meta) =>
  *
  * This function is used to log details about
  * the execution context, such as command-line arguments,
- * environment variables, the process's administrative privileges,
- * and the maximum available heap space size.
+ * environment variables, and the maximum available heap space size.
  *
  * @param {winston.Logger} logger - A pre-configured Winston logger object.
  * @memberof Logger
@@ -90,7 +88,6 @@ const setUpInfo = async (logger = new winston.Logger()) => {
   logger.info('argv', process.argv);
   logger.info('platform', process.platform);
   logger.info('env', process.env.NODE_ENV);
-  logger.info('admin', await isAdmin());
   logger.info('--max-old-space-size', {
     total_available_size: formatBytes(v8.getHeapStatistics().total_available_size),
   });
@@ -189,4 +186,12 @@ const underpostASCI = () => `
 ░╚═════╝░╚═╝░░╚══╝╚═════╝░╚══════╝╚═╝░░╚═╝╚═╝░░░░░░╚════╝░╚═════╝░░░░╚═╝░░░
                                                 `;
 
-export { loggerFactory, loggerMiddleware, setUpInfo, underpostASCI };
+const actionInitLog = (version = '0.0.0') =>
+  console.log(
+    underpostASCI() +
+      `
+    ${version} https://www.nexodev.org/docs
+`,
+  );
+
+export { loggerFactory, loggerMiddleware, setUpInfo, underpostASCI, actionInitLog };

package/src/server/network.js

@@ -1,10 +1,7 @@
-import detect from 'detect-port';
 import fs from 'fs-extra';
 
 import { publicIp, publicIpv4, publicIpv6 } from 'public-ip';
-import { killPortProcess } from 'kill-port-process';
 import { loggerFactory } from './logger.js';
-import { orderArrayFromAttrInt } from '../client/components/core/CommonJs.js';
 import { DataBaseProvider } from '../db/DataBaseProvider.js';
 import { getDeployId } from './conf.js';
 
@@ -15,38 +12,6 @@ import { getDeployId } from './conf.js';
 
 const logger = loggerFactory(import.meta);
 
-const network = {
-  port: {
-    status: async (ports) => {
-      const status = [];
-      for (const port of ports) {
-        status.push({
-          port,
-          open: await new Promise((resolve) =>
-            detect(port)
-              .then((_port) => {
-                if (port == _port)
-                  // `port: ${port} was not occupied`
-                  return resolve(false);
-
-                // `port: ${port} was occupied, try port: ${_port}`
-                return resolve(true);
-              })
-              .catch((error) => resolve(`${error.message}`)),
-          ),
-        });
-      }
-      return status;
-    },
-    kill: async (ports) => await killPortProcess(ports),
-    portClean: async function (port) {
-      const [portStatus] = await this.status([port]);
-      // logger.info('port status', portStatus);
-      if (portStatus.open) await this.kill([port]);
-    },
-  },
-};
-
 const ip = {
   public: {
     get: async () => await publicIp(), // => 'fe80::200:f8ff:fe21:67cf'
@@ -202,7 +167,6 @@ const listenPortController = async (server, port, metadata) =>
 
 export {
   ip,
-  network,
   listenPortController,
   networkRouter,
   netWorkCron,

package/src/server/process.js

@@ -83,7 +83,7 @@ function pbcopy(data) {
 
   clipboard.writeSync(data || '🦄');
 
-  logger.info(`copied to clipboard:`, clipboard.readSync());
+  logger.info(`copied to clipboard`, clipboard.readSync());
 }
 
 export { ProcessController, getRootDirectory, shellExec, shellCd, pbcopy };