@underpostnet/underpost 2.8.4 → 2.8.5

package/src/server/backup.js

@@ -1,120 +1,76 @@
 import fs from 'fs-extra';
 import { loggerFactory } from './logger.js';
-import { shellCd, shellExec } from './process.js';
-import { getCronBackUpFolder, getDataDeploy } from './conf.js';
+import { shellExec } from './process.js';
+import { getCronBackUpFolder } from './conf.js';
 import dotenv from 'dotenv';
 
 dotenv.config();
 
 const logger = loggerFactory(import.meta);
 
-const BackUpManagement = {
-  repoUrl: `https://${process.env.GITHUB_TOKEN}@github.com/${process.env.GITHUB_USERNAME}/${process.env.GITHUB_BACKUP_REPO}.git`,
-  Init: async function ({ deployId }) {
-    const Callback = async function () {
-      const privateCronConfPath = `./engine-private/conf/${deployId}/conf.cron.json`;
+class BackUp {
+  static callback = async function (deployList, options = { disableKindCluster: false }) {
+    if ((!deployList || deployList === 'dd') && fs.existsSync(`./engine-private/deploy/dd.router`))
+      deployList = fs.readFileSync(`./engine-private/deploy/dd.router`, 'utf8');
 
-      const confCronPath = fs.existsSync(privateCronConfPath) ? privateCronConfPath : './conf/conf.cron.json';
+    logger.info('init backups callback', deployList);
+    await logger.setUpInfo();
+    const currentDate = new Date().getTime();
+    const maxBackupRetention = 5;
 
-      const { backups } = JSON.parse(fs.readFileSync(confCronPath, 'utf8'));
+    if (!fs.existsSync('./engine-private/cron-backups'))
+      fs.mkdirSync('./engine-private/cron-backups', { recursive: true });
 
-      if (!backups) return;
+    for (const _deployId of deployList.split(',')) {
+      const deployId = _deployId.trim();
+      if (!deployId) continue;
 
-      logger.info('init backups callback');
-      await logger.setUpInfo();
-
-      const currentDate = new Date().getTime();
-
-      if (!fs.existsSync('./engine-private/cron-backups'))
-        fs.mkdirSync('./engine-private/cron-backups', { recursive: true });
-
-      for (const deployGroupData of backups) {
-        const { deployGroupId } = deployGroupData;
-        const dataDeploy = getDataDeploy({ deployGroupId });
-
-        for (const deployObj of dataDeploy) {
-          const { deployId, replicaHost } = deployObj;
-
-          if (replicaHost) continue;
-
-          const confServer = JSON.parse(
-            fs.existsSync(`./engine-private/replica/${deployId}/conf.server.json`)
-              ? fs.readFileSync(`./engine-private/replica/${deployId}/conf.server.json`, 'utf8')
-              : fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'),
-          );
-
-          for (const host of Object.keys(confServer))
-            for (const path of Object.keys(confServer[host])) {
-              // retention policy
-              let { db, backupFrequency, maxBackupRetention, singleReplica, wp, git, directory } =
-                confServer[host][path];
-
-              if (!db || singleReplica) continue;
-
-              if (!backupFrequency) backupFrequency = 'daily';
-              if (!maxBackupRetention) maxBackupRetention = 5;
-
-              const backUpPath = `${process.cwd()}/engine-private/cron-backups/${getCronBackUpFolder(host, path)}`;
-              if (!fs.existsSync(backUpPath)) fs.mkdirSync(`${backUpPath}`, { recursive: true });
-              // .isDirectory()
-              const files = await fs.readdir(backUpPath, { withFileTypes: true });
-
-              const currentBackupsDirs = files
-                .map((fileObj) => parseInt(fileObj.name))
-                .sort((a, b) => a - b)
-                .reverse();
+      if (options.disableKindCluster !== true) {
+        shellExec(`underpost db --export ${deployId}`);
+        continue;
+      }
 
-              switch (backupFrequency) {
-                case 'daily':
+      const confServer = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'));
 
-                default:
-                  // if (currentBackupsDirs[0] && currentDate - currentBackupsDirs[0] < 1000 * 60 * 60 * 24) continue;
-                  break;
-              }
+      for (const host of Object.keys(confServer))
+        for (const path of Object.keys(confServer[host])) {
+          // retention policy
+          const { db } = confServer[host][path];
+          if (!db) continue;
+          logger.info('Init backup', { host, path, db });
 
-              for (const retentionPath of currentBackupsDirs.filter((t, i) => i >= maxBackupRetention - 1)) {
-                const removePathRetention = `${backUpPath}/${retentionPath}`;
-                logger.info('Remove backup folder', removePathRetention);
-                fs.removeSync(removePathRetention);
-              }
+          const backUpPath = `${process.cwd()}/engine-private/cron-backups/${getCronBackUpFolder(host, path)}`;
+          if (!fs.existsSync(backUpPath)) fs.mkdirSync(`${backUpPath}`, { recursive: true });
+          // .isDirectory()
+          const files = await fs.readdir(backUpPath, { withFileTypes: true });
 
-              fs.mkdirSync(`${backUpPath}/${currentDate}`, { recursive: true });
+          const currentBackupsDirs = files
+            .map((fileObj) => parseInt(fileObj.name))
+            .sort((a, b) => a - b)
+            .reverse();
 
-              shellExec(`node bin/db ${host}${path} export ${deployId} ${backUpPath}/${currentDate}`);
+          for (const retentionPath of currentBackupsDirs.filter((t, i) => i >= maxBackupRetention - 1)) {
+            const removePathRetention = `${backUpPath}/${retentionPath}`;
+            logger.info('Remove backup folder', removePathRetention);
+            fs.removeSync(removePathRetention);
+          }
 
-              if (wp) {
-                const repoUrl = `https://${process.env.GITHUB_TOKEN}@github.com/${process.env.GITHUB_USERNAME}/${git
-                  .split('/')
-                  .pop()}.git`;
+          fs.mkdirSync(`${backUpPath}/${currentDate}`, { recursive: true });
 
-                shellExec(
-                  `cd ${directory}` +
-                    ` && git pull ${repoUrl}` +
-                    ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
-                    ` && git push ${repoUrl}`,
-                  {
-                    disableLog: true,
-                  },
-                );
-              }
-            }
+          shellExec(`node bin/db ${host}${path} export ${deployId} ${backUpPath}/${currentDate}`);
         }
-      }
       shellExec(
         `cd ./engine-private/cron-backups` +
-          ` && git pull ${BackUpManagement.repoUrl}` +
-          ` && git add . && git commit -m "backup ${new Date().toLocaleDateString()}"` +
-          ` && git push ${BackUpManagement.repoUrl}`,
+          ` && underpost pull . underpostnet/cron-backups` +
+          ` && git add .` +
+          ` && underpost cmt . backup cron-job '${new Date().toLocaleDateString()}'` +
+          ` && underpost push . underpostnet/cron-backups`,
         {
           disableLog: true,
         },
       );
-    };
-    await Callback();
-    BackUpManagement.Callback = Callback;
-    return Callback;
-  },
-  Callback: async function (params) {},
-};
+    }
+  };
+}
 
-export { BackUpManagement };
+export default BackUp;

package/src/server/client-build.js

@@ -191,8 +191,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
 
       if (redirect || disabledRebuild) continue;
 
-      if (fullBuildEnabled) {
-        //  !(confServer[host]['/'] && confServer[host]['/'].liteBuild)
+      if (fullBuildEnabled)
         await fullBuild({
           path,
           logger,
@@ -205,14 +204,6 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [] }
           iconsBuild,
           metadata,
         });
-        if (apis && false)
-          for (const apiBuildScript of apis) {
-            const scriptPath = `src/api/${apiBuildScript}/${apiBuildScript}.build.js`;
-            if (fs.existsSync(`./${scriptPath}`)) {
-              shellExec(`node ${scriptPath}`);
-            }
-          }
-      }
 
       if (components)
         for (const module of Object.keys(components)) {

package/src/server/client-formatted.js

@@ -1,6 +1,7 @@
 'use strict';
 
 import fs from 'fs-extra';
+import vm from 'node:vm';
 
 const srcFormatted = (src) =>
   src
@@ -48,9 +49,10 @@ const viewFormatted = (src, dists, proxyPath, baseHost = '') => {
 };
 
 const ssrFactory = async (componentPath = `./src/client/ssr/Render.js`) => {
-  let SrrComponent = () => {};
-  eval(await srcFormatted(fs.readFileSync(componentPath, 'utf8')));
-  return SrrComponent;
+  const context = { SrrComponent: () => {}, npm_package_version: process.env.npm_package_version };
+  vm.createContext(context);
+  vm.runInContext(await srcFormatted(fs.readFileSync(componentPath, 'utf8')), context);
+  return context.SrrComponent;
 };
 
 export { srcFormatted, JSONweb, componentFormatted, viewFormatted, ssrFactory };

package/src/server/conf.js

@@ -13,8 +13,8 @@ import cliProgress from 'cli-progress';
 import cliSpinners from 'cli-spinners';
 import logUpdate from 'log-update';
 import colors from 'colors';
-import { actionInitLog, loggerFactory } from './logger.js';
-import { pbcopy, shellExec } from './process.js';
+import { loggerFactory } from './logger.js';
+import { shellExec } from './process.js';
 import { DefaultConf } from '../../conf.js';
 import read from 'read';
 import splitFile from 'split-file';
@@ -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,15 @@ const Config = {
   },
 };
 
-const loadConf = (deployId, envInput) => {
+const loadConf = (deployId, envInput, subConf) => {
+  if (deployId === 'clean') {
+    shellExec(`git checkout package.json`);
+    shellExec(`git checkout .env.production`);
+    shellExec(`git checkout .env.development`);
+    shellExec(`git checkout .env.test`);
+    shellExec(`git checkout jsdoc.json`);
+    return;
+  }
   const folder = fs.existsSync(`./engine-private/replica/${deployId}`)
     ? `./engine-private/replica/${deployId}`
     : `./engine-private/conf/${deployId}`;
@@ -109,7 +122,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);
@@ -127,19 +141,25 @@ const loadConf = (deployId, envInput) => {
       ...env,
     };
   }
-  fs.writeFileSync(`./package.json`, fs.readFileSync(`${folder}/package.json`, 'utf8'), 'utf8');
+  const originPackageJson = JSON.parse(fs.readFileSync(`./package.json`, 'utf8'));
+  const packageJson = JSON.parse(fs.readFileSync(`${folder}/package.json`, 'utf8'));
+  originPackageJson.scripts.start = packageJson.scripts.start;
+  packageJson.scripts = originPackageJson.scripts;
+  fs.writeFileSync(`./package.json`, JSON.stringify(packageJson, null, 4), 'utf8');
   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]);
@@ -509,21 +529,25 @@ 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;
 
+  const reOrderRouter = {};
   for (const absoluteHostKey of orderArrayFromAttrInt(Object.keys(router), 'length'))
-    router[absoluteHostKey] = router[absoluteHostKey];
-  return router;
+    reOrderRouter[absoluteHostKey] = router[absoluteHostKey];
+
+  return reOrderRouter;
 };
 
 const cliBar = async (time = 5000) => {
@@ -576,7 +600,15 @@ const buildReplicaId = ({ deployId, replica }) => `${deployId}-${replica.slice(1
 const getDataDeploy = (
   options = { buildSingleReplica: false, deployGroupId: '', deployId: '', disableSyncEnvPort: false },
 ) => {
-  let dataDeploy = JSON.parse(fs.readFileSync(`./engine-private/deploy/${options.deployGroupId}.json`, 'utf8'));
+  let dataDeploy =
+    options.deployGroupId === 'dd'
+      ? fs.readFileSync(`./engine-private/deploy/${options.deployGroupId}.router`, 'utf8')
+      : fs.readFileSync(`./engine-private/deploy/${options.deployGroupId}`, 'utf8');
+
+  dataDeploy = dataDeploy
+    .split(',')
+    .map((deployId) => deployId.trim())
+    .filter((deployId) => deployId);
 
   if (options.deployId) dataDeploy = dataDeploy.filter((d) => d === options.deployId);
 
@@ -962,10 +994,10 @@ const Cmd = {
   conf: (deployId, env) => `node bin/deploy conf ${deployId} ${env ? env : 'production'}`,
   replica: (deployId, host, path) => `node bin/deploy build-single-replica ${deployId} ${host} ${path}`,
   syncPorts: (deployGroupId) => `node bin/deploy sync-env-port ${deployGroupId}`,
-  cron: (deployId, job, expression) => {
-    shellExec(Cmd.delete(`${deployId}-${job}`));
-    return `env-cmd -f .env.production pm2 start bin/cron.js --no-autorestart --instances 1 --cron "${expression}" --name ${deployId}-${job} -- ${job} ${deployId}`;
-  },
+  cron: (deployList, jobList, name, expression, options) =>
+    `pm2 start ./bin/index.js --no-autorestart --instances 1 --cron "${expression}" --name ${name} -- cron ${
+      options?.disableKindCluster ? `--disable-kind-cluster ` : ''
+    }${deployList} ${jobList}`,
 };
 
 const fixDependencies = async () => {
@@ -1035,167 +1067,21 @@ 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,
+    disableLog: true,
+    silent: 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`);
-};
+const writeEnv = (envPath, envObj) =>
+  fs.writeFileSync(
+    envPath,
+    Object.keys(envObj)
+      .map((key) => `${key}=${envObj[key]}`)
+      .join(`\n`),
+    'utf8',
+  );
 
 export {
   Cmd,
@@ -1232,11 +1118,6 @@ export {
   buildKindPorts,
   buildPortProxyRouter,
   splitFileFactory,
-  repoClone,
-  repoPull,
-  repoCommit,
-  repoPush,
-  newProject,
-  runTest,
   getNpmRootPath,
+  writeEnv,
 };