@underpostnet/underpost 2.8.0 → 2.8.4

package/bin/build.js

@@ -0,0 +1,278 @@
+import fs from 'fs-extra';
+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';
+
+const baseConfPath = './engine-private/conf/dd-cron/.env.production';
+if (fs.existsSync(baseConfPath)) dotenv.config({ path: baseConfPath, override: true });
+
+const logger = loggerFactory(import.meta);
+
+// (async () => {
+//   return;
+//   const files = await fs.readdir(`./src`);
+//   for (const relativePath of files) {
+//   }
+// })();
+
+const confName = process.argv[2];
+const basePath = '../pwa-microservices-template';
+const repoName = `engine-${confName.split('dd-')[1]}-private`;
+const repoNameBackUp = `engine-${confName.split('dd-')[1]}-cron-backups`;
+const gitUrl = `https://${process.env.GITHUB_TOKEN}@github.com/underpostnet/${repoName}.git`;
+const gitBackUpUrl = `https://${process.env.GITHUB_TOKEN}@github.com/underpostnet/${repoNameBackUp}.git`;
+
+logger.info('', {
+  confName,
+  // gitUrl,
+  repoName,
+  repoNameBackUp,
+  basePath,
+});
+
+if (process.argv.includes('info')) 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(`../${repoName}`)) {
+    shellExec(`cd .. && git clone ${gitUrl}`, { silent: true });
+  } else {
+    shellExec(`cd ../${repoName} && git pull`);
+  }
+  const toPath = `../${repoName}/conf/${confName}`;
+  fs.removeSync(toPath);
+  fs.mkdirSync(toPath, { recursive: true });
+  fs.copySync(`./engine-private/conf/${confName}`, toPath);
+  shellExec(
+    `cd ../${repoName}` +
+      ` && 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(`../${repoNameBackUp}`)) {
+    shellExec(`cd .. && git clone ${gitBackUpUrl}`, { silent: true });
+  } else {
+    shellExec(`cd ../${repoNameBackUp} && 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 = `../${repoNameBackUp}/${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);
+      }
+    }
+  }
+  shellExec(
+    `cd ../${repoNameBackUp}` +
+      ` && 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`);
+
+{
+  for (const host of Object.keys(DefaultConf.server)) {
+    for (const path of Object.keys(DefaultConf.server[host])) {
+      const { apis, ws } = DefaultConf.server[host][path];
+      if (apis)
+        for (const api of apis) {
+          {
+            const originPath = `./src/api/${api}`;
+            logger.info(`Build`, originPath);
+            fs.copySync(originPath, `${basePath}/src/api/${api}`);
+          }
+          {
+            const originPath = `./src/client/services/${api}`;
+            logger.info(`Build`, originPath);
+            fs.copySync(originPath, `${basePath}/src/client/services/${api}`);
+          }
+        }
+
+      if (ws && ws !== 'core' && ws !== 'default') {
+        fs.copySync(`./src/ws/${ws}`, `${basePath}/src/ws/${ws}`);
+      }
+    }
+  }
+}
+
+{
+  for (const client of Object.keys(DefaultConf.client)) {
+    const capName = getCapVariableName(client);
+    for (const component of Object.keys(DefaultConf.client[client].components)) {
+      const originPath = `./src/client/components/${component}`;
+      if (fs.existsSync(originPath)) {
+        logger.info(`Build`, originPath);
+        fs.copySync(originPath, `${basePath}/src/client/components/${component}`);
+      }
+    }
+    {
+      const originPath = `./src/client/${capName}.index.js`;
+      if (fs.existsSync(originPath)) {
+        logger.info(`Build`, originPath);
+        fs.copyFileSync(originPath, `${basePath}/src/client/${capName}.index.js`);
+      }
+    }
+    {
+      const originPath = `./src/client/public/${client}`;
+      if (fs.existsSync(originPath)) {
+        logger.info(`Build`, originPath);
+        fs.copySync(originPath, `${basePath}/src/client/public/${client}`);
+      }
+    }
+  }
+}
+
+{
+  for (const client of Object.keys(DefaultConf.ssr)) {
+    const ssrPaths = getPathsSSR(DefaultConf.ssr[client]);
+    for (const originPath of ssrPaths) {
+      if (fs.existsSync(originPath)) {
+        logger.info(`Build`, originPath);
+        fs.copySync(originPath, `${basePath}/${originPath}`);
+      }
+    }
+  }
+
+  fs.copyFileSync(`./conf.${confName}.js`, `${basePath}/conf.js`);
+  fs.copyFileSync(
+    `./.github/workflows/engine.${confName.split('dd-')[1]}.ci.yml`,
+    `${basePath}/.github/workflows/engine.${confName.split('dd-')[1]}.ci.yml`,
+  );
+
+  const packageJson = JSON.parse(fs.readFileSync(`${basePath}/package.json`, 'utf8'));
+  packageJson.name = repoName;
+  fs.writeFileSync(`${basePath}/package.json`, JSON.stringify(packageJson, null, 4), 'utf8');
+}

package/bin/db.js

@@ -4,10 +4,9 @@ import { loggerFactory } from '../src/server/logger.js';
 import { MariaDB } from '../src/db/mariadb/MariaDB.js';
 import { Xampp } from '../src/runtime/xampp/Xampp.js';
 import { Lampp } from '../src/runtime/lampp/Lampp.js';
-import { getCapVariableName, getRestoreCronCmd, loadConf } from '../src/server/conf.js';
+import { getCapVariableName, getRestoreCronCmd, loadConf, splitFileFactory } from '../src/server/conf.js';
 import { DataBaseProvider } from '../src/db/DataBaseProvider.js';
 import { hashPassword } from '../src/server/auth.js';
-import splitFile from 'split-file';
 
 const logger = loggerFactory(import.meta);
 
@@ -101,28 +100,7 @@ try {
 
             cmd = `mysqldump -u ${user} -p${password} ${name} > ${cmdBackupPath}`;
             shellExec(cmd);
-            const stats = fs.statSync(cmdBackupPath);
-            const maxSizeInBytes = 1024 * 1024 * 50; // 50 mb
-            const fileSizeInBytes = stats.size;
-            if (fileSizeInBytes > maxSizeInBytes) {
-              await new Promise((resolve) => {
-                splitFile
-                  .splitFileBySize(cmdBackupPath, maxSizeInBytes) // 50 mb
-                  .then((names) => {
-                    fs.writeFileSync(
-                      `${cmdBackupPath.split('/').slice(0, -1).join('/')}/${name}-parths.json`,
-                      JSON.stringify(names, null, 4),
-                      'utf8',
-                    );
-                    resolve();
-                  })
-                  .catch((err) => {
-                    console.log('Error: ', err);
-                    resolve();
-                  });
-              });
-              fs.removeSync(cmdBackupPath);
-            }
+            await splitFileFactory(name, cmdBackupPath);
           }
           break;
         case 'import':

package/bin/deploy.js

@@ -4,7 +4,7 @@ import axios from 'axios';
 import dotenv from 'dotenv';
 import plantuml from 'plantuml';
 
-import { shellCd, shellExec } from '../src/server/process.js';
+import { pbcopy, shellCd, shellExec } from '../src/server/process.js';
 import { loggerFactory } from '../src/server/logger.js';
 import {
   Config,
@@ -29,7 +29,6 @@ import {
 } from '../src/server/conf.js';
 import { buildClient } from '../src/server/client-build.js';
 import { range, setPad, timer, uniqueArray } from '../src/client/components/core/CommonJs.js';
-import simpleGit from 'simple-git';
 import { MongooseDB } from '../src/db/mongo/MongooseDB.js';
 import { Lampp } from '../src/runtime/lampp/Lampp.js';
 import { DefaultConf } from '../conf.js';
@@ -139,8 +138,7 @@ try {
       }
       break;
     case 'conf': {
-      loadConf(process.argv[3]);
-      if (process.argv[4]) fs.writeFileSync(`.env`, fs.readFileSync(`.env.${process.argv[4]}`, 'utf8'), 'utf8');
+      loadConf(process.argv[3], process.argv[4]);
       break;
     }
     case 'run':
@@ -307,7 +305,7 @@ try {
     }
 
     case 'adminer': {
-      const directory = '/dd/engine/public/adminer';
+      const directory = '/home/dd/engine/public/adminer';
       // const host = '127.0.0.1';
       const host = 'localhost';
       const port = 80;
@@ -337,7 +335,7 @@ try {
 
     case 'pma':
       {
-        const directory = '/dd/engine/public/phpmyadmin';
+        const directory = '/home/dd/engine/public/phpmyadmin';
         // const host = '127.0.0.1';
         const host = 'localhost';
         const port = 80;
@@ -454,14 +452,16 @@ try {
       }
       break;
 
-    case 'update-package':
+    case 'update-dependencies':
       const files = await fs.readdir(`./engine-private/conf`, { recursive: true });
       const originPackage = JSON.parse(fs.readFileSync(`./package.json`, 'utf8'));
       for (const relativePath of files) {
         const filePah = `./engine-private/conf/${relativePath.replaceAll(`\\`, '/')}`;
         if (filePah.split('/').pop() === 'package.json') {
-          originPackage.scripts.start = JSON.parse(fs.readFileSync(filePah), 'utf8').scripts.start;
-          fs.writeFileSync(filePah, JSON.stringify(originPackage, null, 4), 'utf8');
+          const deployPackage = JSON.parse(fs.readFileSync(filePah), 'utf8');
+          deployPackage.dependencies = originPackage.dependencies;
+          deployPackage.devDependencies = originPackage.devDependencies;
+          fs.writeFileSync(filePah, JSON.stringify(deployPackage, null, 4), 'utf8');
         }
       }
       break;
@@ -731,6 +731,16 @@ try {
               originPackage.version = newVersion;
               fs.writeFileSync(filePah, JSON.stringify(originPackage, null, 4), 'utf8');
             }
+            if (filePah.split('/').pop() === 'deployment.yaml') {
+              fs.writeFileSync(
+                filePah,
+                fs
+                  .readFileSync(filePah, 'utf8')
+                  .replaceAll(`v${version}`, `v${newVersion}`)
+                  .replaceAll(`engine.version: ${version}`, `engine.version: ${newVersion}`),
+                'utf8',
+              );
+            }
           }
         }
 
@@ -752,60 +762,37 @@ try {
           );
 
         fs.writeFileSync(
-          `./src/client/components/core/Docs.js`,
-          fs
-            .readFileSync(`./src/client/components/core/Docs.js`, 'utf8')
-            .replaceAll(`/engine/${version}`, `/engine/${newVersion}`),
+          `./src/index.js`,
+          fs.readFileSync(`./src/index.js`, 'utf8').replaceAll(`${version}`, `${newVersion}`),
           'utf8',
         );
 
-        fs.writeFileSync(
-          `./src/client/ssr/body/CacheControl.js`,
-          fs.readFileSync(`./src/client/ssr/body/CacheControl.js`, 'utf8').replaceAll(`v${version}`, `v${newVersion}`),
-          'utf8',
-        );
-
-        fs.writeFileSync(
-          `./bin/index.js`,
-          fs.readFileSync(`./bin/index.js`, 'utf8').replaceAll(`${version}`, `${newVersion}`),
-          'utf8',
-        );
-
-        shellExec(`node bin/deploy update-package`);
+        shellExec(`node bin/deploy update-dependencies`);
         shellExec(`auto-changelog`);
       }
       break;
 
     case 'update-authors': {
-      // shellExec(`git log --reverse --format='%aN (<%aE>)' | sort -u`, { stdout: true });
-      const logs = await simpleGit().log();
-
+      // #### Ordered by first contribution.
       fs.writeFileSync(
         './AUTHORS.md',
         `# Authors
 
-#### Ordered by first contribution.
 
-${uniqueArray(logs.all.map((log) => `- ${log.author_name} ([${log.author_email}](mailto:${log.author_email}))`)).join(`
-`)}
+${shellExec(`git log | grep Author: | sort -u`, { stdout: true }).split(`\n`).join(`\n\n\n`)}
 
 #### Generated by [underpost.net](https://underpost.net)`,
         'utf8',
       );
 
-      // hash: '1c7418ad2f49c7798a6d28d370b34c69d31dce46',
-      // date: '2024-09-16T17:10:13-03:00',
-      // message: 'update',
-      // refs: '',
-      // body: '',
-      // author_name: 'fcoverdugo',
-      // author_email: 'fcoverdugoa@underpost.net'
+      break;
     }
 
     case 'restore-macro-db':
       {
         const deployGroupId = process.argv[3];
-        await restoreMacroDb(deployGroupId);
+        const deployId = process.argv[4];
+        await restoreMacroDb(deployGroupId, deployId);
       }
 
       break;
@@ -840,10 +827,10 @@ ${uniqueArray(logs.all.map((log) => `- ${log.author_name} ([${log.author_email}]
             shellExec(`bin/besu --help`);
 
             // Set env path
-            // export PATH=$PATH:/dd/besu-24.9.1/bin
+            // export PATH=$PATH:/home/dd/besu-24.9.1/bin
 
             // Open src
-            // shellExec(`sudo code /dd/besu-24.9.1 --user-data-dir="/root/.vscode-root" --no-sandbox`);
+            // shellExec(`sudo code /home/dd/besu-24.9.1 --user-data-dir="/root/.vscode-root" --no-sandbox`);
           }
 
           break;
@@ -861,23 +848,43 @@ ${uniqueArray(logs.all.map((log) => `- ${log.author_name} ([${log.author_email}]
     }
 
     case 'update-default-conf': {
-      const host = process.argv[3] ? process.argv[3] : 'underpostnet.github.io';
-      const path = process.argv[4] ? process.argv[4] : '/pwa-microservices-template-ghpkg';
-      DefaultConf.server = {
-        [host]: { [path]: DefaultConf.server['default.net']['/'] },
-      };
-      DefaultConf.server[host][path].apiBaseProxyPath = '/';
-      DefaultConf.server[host][path].apiBaseHost = 'www.nexodev.org';
-      fs.writeFileSync(
-        './conf.js',
-        `
-        const DefaultConf = ${JSONweb(DefaultConf)};
-        
-        export { DefaultConf }
-
-        `,
-        'utf8',
-      );
+      const defaultServer = DefaultConf.server['default.net']['/'];
+      let confName = process.argv[3];
+      if (confName === 'ghpkg') {
+        confName = undefined;
+        const host = 'underpostnet.github.io';
+        const path = '/pwa-microservices-template-ghpkg';
+        DefaultConf.server = {
+          [host]: { [path]: defaultServer },
+        };
+        DefaultConf.server[host][path].apiBaseProxyPath = '/';
+        DefaultConf.server[host][path].apiBaseHost = 'www.nexodev.org';
+      } else if (confName) {
+        DefaultConf.client = JSON.parse(fs.readFileSync(`./engine-private/conf/${confName}/conf.client.json`, 'utf8'));
+        DefaultConf.server = JSON.parse(fs.readFileSync(`./engine-private/conf/${confName}/conf.server.json`, 'utf8'));
+        DefaultConf.ssr = JSON.parse(fs.readFileSync(`./engine-private/conf/${confName}/conf.ssr.json`, 'utf8'));
+        DefaultConf.cron = JSON.parse(fs.readFileSync(`./engine-private/conf/${confName}/conf.cron.json`, 'utf8'));
+
+        for (const host of Object.keys(DefaultConf.server)) {
+          for (const path of Object.keys(DefaultConf.server[host])) {
+            DefaultConf.server[host][path].db = defaultServer.db;
+            DefaultConf.server[host][path].mailer = defaultServer.mailer;
+
+            delete DefaultConf.server[host][path]._wp_client;
+            delete DefaultConf.server[host][path]._wp_git;
+            delete DefaultConf.server[host][path]._wp_directory;
+            delete DefaultConf.server[host][path].wp;
+            delete DefaultConf.server[host][path].git;
+            delete DefaultConf.server[host][path].directory;
+          }
+        }
+      }
+      const sepRender = '/**/';
+      const confRawPaths = fs.readFileSync('./conf.js', 'utf8').split(sepRender);
+      confRawPaths[1] = `${JSON.stringify(DefaultConf)};`;
+      const targetConfPath = `./conf${confName ? `.${confName}` : ''}.js`;
+      fs.writeFileSync(targetConfPath, confRawPaths.join(sepRender), 'utf8');
+      shellExec(`prettier --write ${targetConfPath}`);
 
       break;
     }
@@ -893,7 +900,11 @@ ${uniqueArray(logs.all.map((log) => `- ${log.author_name} ([${log.author_email}]
     }
     case 'ssh-import-client-keys': {
       const host = process.argv[3];
-      shellExec(`node bin/deploy set-ssh-keys ./engine-private/deploy/ssh_host_rsa_key${host ? ` ${host}` : ``} clean`);
+      shellExec(
+        `node bin/deploy set-ssh-keys ./engine-private/deploy/ssh_host_rsa_key ${host ? ` ${host}` : ``} ${
+          process.argv.includes('clean') ? 'clean' : ''
+        }`,
+      );
       break;
     }
     case 'ssh-keys': {
@@ -958,14 +969,24 @@ ${uniqueArray(logs.all.map((log) => `- ${log.author_name} ([${log.author_email}]
     }
 
     case 'ssh': {
-      if (!process.argv.includes('server')) {
-        shellExec(`sudo apt update`);
-        shellExec(`sudo apt install openssh-server -y`);
-        shellExec(`sudo apt install ssh-askpass`);
+      if (process.argv.includes('rocky')) {
+        shellExec(`sudo systemctl enable sshd`);
+
+        shellExec(`sudo systemctl start sshd`);
+
+        shellExec(`sudo systemctl status sshd`);
+
+        shellExec(`sudo ss -lt`);
+      } else {
+        if (!process.argv.includes('server')) {
+          shellExec(`sudo apt update`);
+          shellExec(`sudo apt install openssh-server -y`);
+          shellExec(`sudo apt install ssh-askpass`);
+        }
+        shellExec(`sudo systemctl enable ssh`);
+        shellExec(`sudo systemctl restart ssh`);
+        shellExec(`sudo systemctl status ssh`);
       }
-      shellExec(`sudo systemctl enable ssh`);
-      shellExec(`sudo systemctl restart ssh`);
-      shellExec(`sudo systemctl status ssh`);
       // sudo service ssh restart
       shellExec(`ip a`);
 
@@ -1023,11 +1044,26 @@ ${uniqueArray(logs.all.map((log) => `- ${log.author_name} ([${log.author_email}]
 
     case 'valkey': {
       if (!process.argv.includes('server')) {
-        shellExec(`cd /dd && git clone https://github.com/valkey-io/valkey.git`);
-        shellExec(`cd /dd/valkey && make`);
-        shellExec(`apt install valkey-tools`); // valkey-cli
+        if (process.argv.includes('rocky')) {
+          // shellExec(`yum install -y https://repo.percona.com/yum/percona-release-latest.noarch.rpm`);
+          // shellExec(`sudo percona-release enable valkey experimental`);
+          shellExec(`sudo dnf install valkey`);
+          shellExec(`chown -R valkey:valkey /etc/valkey`);
+          shellExec(`chown -R valkey:valkey /var/lib/valkey`);
+          shellExec(`chown -R valkey:valkey /var/log/valkey`);
+          shellExec(`sudo systemctl enable valkey.service`);
+          shellExec(`sudo systemctl start valkey`);
+          shellExec(`valkey-cli ping`);
+        } else {
+          shellExec(`cd /home/dd && git clone https://github.com/valkey-io/valkey.git`);
+          shellExec(`cd /home/dd/valkey && make`);
+          shellExec(`apt install valkey-tools`); // valkey-cli
+        }
       }
-      shellExec(`cd /dd/valkey && ./src/valkey-server`);
+      if (process.argv.includes('rocky')) {
+        shellExec(`sudo systemctl stop valkey`);
+        shellExec(`sudo systemctl start valkey`);
+      } else shellExec(`cd /home/dd/valkey && ./src/valkey-server`);
 
       break;
     }

package/bin/file.js

@@ -1,7 +1,7 @@
 import fs from 'fs-extra';
 
 import { loggerFactory } from '../src/server/logger.js';
-import { cap, getCapVariableName, getDirname } from '../src/client/components/core/CommonJs.js';
+import { cap, getCapVariableName, getDirname, newInstance } 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';
@@ -78,7 +78,7 @@ try {
         fs.copySync(`./src/client/public/default`, `../pwa-microservices-template/src/client/public/default`);
 
         shellCd('../pwa-microservices-template');
-        for (const deletePath of ['CHANGELOG.md', 'README.md', 'package-lock.json', 'package.json']) {
+        for (const deletePath of ['README.md', 'package-lock.json', 'package.json']) {
           shellExec(`git checkout ${deletePath}`);
         }
         for (const deletePath of [
@@ -86,13 +86,42 @@ try {
           '.github/workflows/docker-image.yml',
           '.github/workflows/deploy.ssh.yml',
           '.github/workflows/deploy.api-rest.yml',
+          '.github/workflows/engine.lampp.ci.yml',
+          '.github/workflows/engine.core.ci.yml',
+          '.github/workflows/engine.cyberia.ci.yml',
           'bin/web3.js',
           'bin/cyberia.js',
-          'src/ipfs.js',
-          'src/k8s.js',
         ]) {
           fs.removeSync('../pwa-microservices-template/' + deletePath);
         }
+        shellCd('../engine');
+        const originPackageJson = JSON.parse(fs.readFileSync('./package.json', 'utf8'));
+        const templatePackageJson = JSON.parse(fs.readFileSync('../pwa-microservices-template/package.json', 'utf8'));
+        templatePackageJson.dependencies = originPackageJson.dependencies;
+        templatePackageJson.devDependencies = originPackageJson.devDependencies;
+        templatePackageJson.version = originPackageJson.version;
+        fs.writeFileSync(
+          '../pwa-microservices-template/package.json',
+          JSON.stringify(templatePackageJson, null, 4),
+          'utf8',
+        );
+
+        const originPackageLockJson = JSON.parse(fs.readFileSync('./package-lock.json', 'utf8'));
+        const templatePackageLockJson = JSON.parse(
+          fs.readFileSync('../pwa-microservices-template/package-lock.json', 'utf8'),
+        );
+        const originBasePackageLock = newInstance(templatePackageLockJson.packages['']);
+        templatePackageLockJson.version = originPackageLockJson.version;
+        templatePackageLockJson.packages = originPackageLockJson.packages;
+        templatePackageLockJson.packages[''].name = originBasePackageLock.name;
+        templatePackageLockJson.packages[''].version = originPackageLockJson.version;
+        templatePackageLockJson.packages[''].hasInstallScript = originBasePackageLock.hasInstallScript;
+        templatePackageLockJson.packages[''].license = originBasePackageLock.license;
+        fs.writeFileSync(
+          '../pwa-microservices-template/package-lock.json',
+          JSON.stringify(templatePackageLockJson, null, 4),
+          'utf8',
+        );
       }
 
       break;