underpost 2.8.85 → 2.8.87

package/src/server/conf.js

@@ -9,17 +9,11 @@ import {
   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 { DefaultConf } from '../../conf.js';
-import read from 'read';
 import splitFile from 'split-file';
-import axios from 'axios';
-import { ssrFactory } from './client-formatted.js';
 
 colors.enable();
 
@@ -27,68 +21,84 @@ dotenv.config();
 
 const logger = loggerFactory(import.meta);
 
-// monitoring: https://app.pm2.io/
-
 const Config = {
   default: DefaultConf,
-  build: async function (options = { folder: '' }, deployContext, deployList, subConf) {
-    if (!deployContext) deployContext = process.argv[2];
+  build: async function (deployContext = 'dd-default', deployList, subConf) {
+    if (typeof process.argv[2] === 'string' && process.argv[2].startsWith('dd-')) 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/${deployContext}`))
-      return loadConf(deployContext, process.env.NODE_ENV, subConf);
     if (fs.existsSync(`./engine-private/replica/${deployContext}`))
       return loadConf(deployContext, process.env.NODE_ENV, subConf);
+    else if (deployContext.startsWith('dd-')) return loadConf(deployContext, process.env.NODE_ENV, subConf);
+    if (deployContext === 'proxy') Config.buildProxy(deployContext, deployList, subConf);
+  },
+  deployIdFactory: function (deployId = 'dd-default') {
+    if (!deployId.startsWith('dd-')) deployId = `dd-${deployId}`;
 
-    if (deployContext === 'deploy') return;
-
-    if (deployContext === 'proxy') {
-      if (!deployList) deployList = process.argv[3];
-      if (!subConf) subConf = process.argv[4];
-      this.default.server = {};
-      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.${subConf}.json`;
-        const confDevPath = fs.existsSync(privateConfDevPath)
-          ? privateConfDevPath
-          : `./engine-private/conf/${deployId}/conf.server.dev.json`;
-
-        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, deployContext, subConf))) {
-          if (serverConf[host]['/'])
-            this.default.server[host] = {
-              ...this.default.server[host],
-              ...serverConf[host],
-            };
-          else
-            this.default.server[host] = {
-              ...serverConf[host],
-              ...this.default.server[host],
-            };
-        }
+    logger.info('Build deployId', deployId);
+
+    const folder = `./engine-private/conf/${deployId}`;
+
+    if (!fs.existsSync(folder)) fs.mkdirSync(folder, { recursive: true });
+    fs.writeFileSync(
+      `${folder}/.env.production`,
+      fs.readFileSync('./.env.production', 'utf8').replaceAll('dd-default', deployId),
+      'utf8',
+    );
+    fs.writeFileSync(
+      `${folder}/.env.development`,
+      fs.readFileSync('./.env.development', 'utf8').replaceAll('dd-default', deployId),
+      'utf8',
+    );
+    fs.writeFileSync(
+      `${folder}/.env.test`,
+      fs.readFileSync('./.env.test', 'utf8').replaceAll('dd-default', deployId),
+      'utf8',
+    );
+    fs.writeFileSync(`${folder}/package.json`, fs.readFileSync('./package.json', 'utf8'), 'utf8');
+
+    this.buildTmpConf(folder);
+
+    return { deployIdFolder: folder, deployId };
+  },
+  buildTmpConf: function (folder = './conf') {
+    for (const confType of Object.keys(this.default))
+      fs.writeFileSync(`${folder}/conf.${confType}.json`, JSON.stringify(this.default[confType], null, 4), 'utf8');
+  },
+  buildProxy: function (deployContext = 'dd-default', deployList, subConf) {
+    if (!deployList) deployList = process.argv[3];
+    if (!subConf) subConf = process.argv[4];
+    this.default.server = {};
+    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.${subConf}.json`;
+      const confDevPath = fs.existsSync(privateConfDevPath)
+        ? privateConfDevPath
+        : `./engine-private/conf/${deployId}/conf.server.dev.json`;
+
+      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, deployContext, subConf))) {
+        if (serverConf[host]['/'])
+          this.default.server[host] = {
+            ...this.default.server[host],
+            ...serverConf[host],
+          };
+        else
+          this.default.server[host] = {
+            ...serverConf[host],
+            ...this.default.server[host],
+          };
       }
     }
-    if (!options || !options.folder)
-      options = {
-        ...options,
-        folder: `./conf`,
-      };
-    if (!fs.existsSync(options.folder)) fs.mkdirSync(options.folder, { recursive: true });
-    for (const confType of Object.keys(this.default)) {
-      fs.writeFileSync(
-        `${options.folder}/conf.${confType}.json`,
-        JSON.stringify(this.default[confType], null, 4),
-        'utf8',
-      );
-    }
+    this.buildTmpConf();
   },
 };
 
-const loadConf = (deployId, envInput, subConf) => {
+const loadConf = (deployId = 'dd-default', envInput, subConf) => {
   if (deployId === 'current') {
     console.log(process.env.DEPLOY_ID);
     return;
@@ -107,18 +117,12 @@ const loadConf = (deployId, envInput, subConf) => {
   const folder = fs.existsSync(`./engine-private/replica/${deployId}`)
     ? `./engine-private/replica/${deployId}`
     : `./engine-private/conf/${deployId}`;
+  if (!fs.existsSync(folder)) Config.deployIdFactory(deployId);
   if (!fs.existsSync(`./conf`)) fs.mkdirSync(`./conf`);
-  if (!fs.existsSync(`./tmp`)) fs.mkdirSync(`./tmp`, { recursive: true });
-  const isValidDeployId = fs.existsSync(`${folder}`);
-  if (!isValidDeployId) {
-    logger.info(`Save new deploy conf: '${deployId}'`);
-    shellExec(`node bin/deploy save ${deployId}`);
-    return loadConf(deployId);
-  }
+  if (!fs.existsSync(`./tmp`)) fs.mkdirSync(`./tmp`);
+
   for (const typeConf of Object.keys(Config.default)) {
-    let srcConf = isValidDeployId
-      ? fs.readFileSync(`${folder}/conf.${typeConf}.json`, 'utf8')
-      : JSON.stringify(Config.default[typeConf]);
+    let srcConf = fs.readFileSync(`${folder}/conf.${typeConf}.json`, 'utf8');
     if (process.env.NODE_ENV === 'development' && typeConf === 'server') {
       if (!subConf) subConf = process.argv[3];
       const devConfPath = `${folder}/conf.${typeConf}.dev${subConf ? `.${subConf}` : ''}.json`;
@@ -493,15 +497,6 @@ const buildProxyRouter = () => {
       }
     }
   }
-  if (process.argv.includes('maintenance'))
-    (async () => {
-      globalThis.defaultHtmlSrcMaintenance = (await ssrFactory())({
-        title: 'Site in maintenance',
-        ssrPath: '/',
-        ssrHeadComponents: '',
-        ssrBodyComponents: (await ssrFactory(`./src/client/ssr/offline/Maintenance.js`))(),
-      });
-    })();
 
   return proxyRouter;
 };
@@ -561,16 +556,24 @@ const buildPortProxyRouter = (port, proxyRouter) => {
   // build router
   Object.keys(hosts).map((hostKey) => {
     let { host, path, target, proxy, peer } = hosts[hostKey];
-    if (process.argv.includes('localhost') && process.env.NODE_ENV === 'development') host = `localhost`;
+    if (process.env.NODE_ENV === 'development') host = `localhost`;
+
+    if (!proxy.includes(port)) {
+      logger.warn('Proxy port not set on conf', { port, host, path, proxy, target });
+      if (process.env.NODE_ENV === 'production') {
+        logger.warn('Omitting host', { host, path, target });
+        return;
+      }
+    }
 
-    if (!proxy.includes(port)) return;
     const absoluteHost = [80, 443].includes(port)
       ? `${host}${path === '/' ? '' : path}`
       : `${host}:${port}${path === '/' ? '' : path}`;
 
-    if (process.argv.includes('localhost')) {
-      if (!(absoluteHost in router)) router[absoluteHost] = target;
-    } else router[absoluteHost] = target;
+    if (absoluteHost in router)
+      logger.warn('Overwrite: Absolute host already exists on router', { absoluteHost, target });
+
+    router[absoluteHost] = target;
   }); // order router
 
   if (Object.keys(router).length === 0) return router;
@@ -582,51 +585,6 @@ const buildPortProxyRouter = (port, proxyRouter) => {
   return reOrderRouter;
 };
 
-const cliBar = async (time = 5000) => {
-  // create new progress bar
-  const b = new cliProgress.SingleBar({
-    format: 'Delay | {bar} | {percentage}% || {value}/{total} Chunks || Speed: {speed}',
-    barCompleteChar: '\u2588',
-    barIncompleteChar: '\u2591',
-    hideCursor: true,
-  });
-
-  const maxValueDisplay = 200;
-  const minValueDisplay = 0;
-  const steps = 10;
-  const incrementValue = 200 / steps;
-  const delayTime = time / steps;
-  // initialize the bar - defining payload token "speed" with the default value "N/A"
-  b.start(maxValueDisplay, minValueDisplay, {
-    speed: 'N/A',
-  });
-
-  // update values
-  // b1.increment();
-  // b1.update(20);
-
-  for (const step of range(1, steps)) {
-    b.increment(incrementValue);
-    await timer(delayTime);
-  }
-
-  // stop the bar
-  b.stop();
-};
-
-const cliSpinner = async (time = 5000, message0, message1, color, type = 'dots') => {
-  const { frames, interval } = cliSpinners[type];
-  const steps = parseInt(time / interval);
-  let index = 0;
-  for (const step of range(1, steps)) {
-    const msg = `${message0 ? message0 : ''}${frames[index]}${message1 ? message1 : ''}`;
-    logUpdate(color ? msg[color] : msg);
-    await timer(interval);
-    index++;
-    if (index === frames.length) index = 0;
-  }
-};
-
 const buildReplicaId = ({ deployId, replica }) => `${deployId}-${replica.slice(1)}`;
 
 const getDataDeploy = (
@@ -635,7 +593,6 @@ const getDataDeploy = (
     deployGroupId: '',
     deployId: '',
     disableSyncEnvPort: false,
-    deployIdConcat: [],
   },
 ) => {
   let dataDeploy =
@@ -648,8 +605,6 @@ const getDataDeploy = (
     .map((deployId) => deployId.trim())
     .filter((deployId) => deployId);
 
-  if (options.deployIdConcat) dataDeploy = dataDeploy.concat(options.deployIdConcat);
-
   if (options.deployId) dataDeploy = dataDeploy.filter((d) => d === options.deployId);
 
   dataDeploy = dataDeploy.map((deployId) => {
@@ -770,152 +725,16 @@ const validateTemplatePath = (absolutePath = '') => {
   return true;
 };
 
-const deployTest = async (dataDeploy = [{ deployId: 'default' }]) => {
-  const failed = [];
-  for (const deploy of dataDeploy) {
-    const deployServerConfPath = fs.existsSync(`./engine-private/replica/${deploy.deployId}/conf.server.json`)
-      ? `./engine-private/replica/${deploy.deployId}/conf.server.json`
-      : `./engine-private/conf/${deploy.deployId}/conf.server.json`;
-    const serverConf = loadReplicas(JSON.parse(fs.readFileSync(deployServerConfPath, 'utf8')));
-    let fail = false;
-    for (const host of Object.keys(serverConf))
-      for (const path of Object.keys(serverConf[host])) {
-        const { singleReplica } = serverConf[host][path];
-        if (singleReplica) continue;
-        const urlTest = `https://${host}${path}`;
-        try {
-          const result = await axios.get(urlTest, { timeout: 10000 });
-          const test = result.data.split('<title>');
-          if (test[1])
-            logger.info('Success deploy', {
-              ...deploy,
-              result: test[1].split('</title>')[0],
-              urlTest,
-            });
-          else {
-            logger.error('Error deploy', {
-              ...deploy,
-              result: result.data,
-              urlTest,
-            });
-            fail = true;
-          }
-        } catch (error) {
-          logger.error('Error deploy', {
-            ...deploy,
-            message: error.message,
-            urlTest,
-          });
-          fail = true;
-        }
-      }
-    if (fail) failed.push(deploy);
-  }
-  return { failed };
-};
-
 const awaitDeployMonitor = async (init = false, deltaMs = 1000) => {
   if (init) fs.writeFileSync(`./tmp/await-deploy`, '', 'utf8');
   await timer(deltaMs);
   if (fs.existsSync(`./tmp/await-deploy`)) return await awaitDeployMonitor();
 };
 
-const getDeployGroupId = () => {
-  const deployGroupIndexArg = process.argv.findIndex((a) => a.match(`deploy-group:`));
-  if (deployGroupIndexArg > -1) return process.argv[deployGroupIndexArg].split(':')[1].trim();
-  return 'dd';
-};
-
-const getDeployId = () => {
-  const deployIndexArg = process.argv.findIndex((a) => a.match(`deploy-id:`));
-  if (deployIndexArg > -1) return process.argv[deployIndexArg].split(':')[1].trim();
-  for (const deployId of process.argv) {
-    if (fs.existsSync(`./engine-private/conf/${deployId}`)) return deployId;
-    else if (fs.existsSync(`./engine-private/replica/${deployId}`)) return deployId;
-  }
-  return 'default';
-};
-
 const getCronBackUpFolder = (host = '', path = '') => {
   return `${host}${path.replace(/\\/g, '/').replace(`/`, '-')}`;
 };
 
-const execDeploy = async (options = { deployId: 'default' }, currentAttempt = 1) => {
-  const { deployId } = options;
-  shellExec(Cmd.delete(deployId));
-  shellExec(Cmd.conf(deployId));
-  shellExec(Cmd.run(deployId));
-  const maxTime = 1000 * 60;
-  const minTime = 20 * 1000;
-  const intervalTime = 1000;
-  return await new Promise(async (resolve) => {
-    let currentTime = 0;
-    const attempt = () => {
-      if (currentTime >= minTime && !fs.existsSync(`./tmp/await-deploy`)) {
-        clearInterval(processMonitor);
-        return resolve(true);
-      }
-      cliSpinner(
-        intervalTime,
-        `[deploy.js] `,
-        ` Load instance | attempt:${currentAttempt} | elapsed time ${currentTime / 1000}s / ${maxTime / 1000}s`,
-        'yellow',
-        'material',
-      );
-      currentTime += intervalTime;
-      if (currentTime >= maxTime) {
-        clearInterval(processMonitor);
-        return resolve(false);
-      }
-    };
-    const processMonitor = setInterval(attempt, intervalTime);
-  });
-};
-
-const deployRun = async (dataDeploy, currentAttempt = 1) => {
-  if (!fs.existsSync(`./tmp`)) fs.mkdirSync(`./tmp`, { recursive: true });
-  await fixDependencies();
-  const maxAttempts = 3;
-  for (const deploy of dataDeploy) {
-    let currentAttempt = 1;
-    const attempt = async () => {
-      const success = await execDeploy(deploy, currentAttempt);
-      currentAttempt++;
-      if (!success && currentAttempt <= maxAttempts) await attempt();
-    };
-    await attempt();
-  }
-  const { failed } = await deployTest(dataDeploy);
-  if (failed.length > 0) {
-    for (const deploy of failed) logger.error(deploy.deployId, Cmd.run(deploy.deployId));
-    if (currentAttempt === maxAttempts) return logger.error(`max deploy attempts exceeded`);
-    await read({ prompt: 'Press enter to retry failed processes\n' });
-    currentAttempt++;
-    await deployRun(failed, currentAttempt);
-  } else logger.info(`Deploy process successfully`);
-};
-
-const restoreMacroDb = async (deployGroupId = '', deployId = null) => {
-  const dataDeploy = await getDataDeploy({ deployGroupId, buildSingleReplica: false });
-  for (const deployGroup of dataDeploy) {
-    if (deployId && deployGroup.deployId !== deployId) continue;
-    if (!deployGroup.replicaHost) {
-      const deployServerConfPath = `./engine-private/conf/${deployGroup.deployId}/conf.server.json`;
-      const serverConf = JSON.parse(fs.readFileSync(deployServerConfPath, 'utf8'));
-
-      for (const host of Object.keys(serverConf)) {
-        for (const path of Object.keys(serverConf[host])) {
-          const { db, singleReplica } = serverConf[host][path];
-          if (db && !singleReplica) {
-            const cmd = `node bin/db ${host}${path} import ${deployGroup.deployId} cron`;
-            shellExec(cmd);
-          }
-        }
-      }
-    }
-  }
-};
-
 const mergeFile = async (parts = [], outputFilePath) => {
   await new Promise((resolve) => {
     splitFile
@@ -977,99 +796,6 @@ const rebuildConfFactory = ({ deployId, valkey, mongo }) => {
   return { hosts };
 };
 
-const getRestoreCronCmd = async (options = { host: '', path: '', conf: {}, deployId: '' }) => {
-  const { host, path, conf, deployId } = options;
-  const { runtime, db, git, directory } = conf[host][path];
-  const { provider, name, user, password = '', backupPath = '' } = db;
-
-  if (['xampp', 'lampp'].includes(runtime)) {
-    logger.info('Create database', `node bin/db ${host}${path} create ${deployId}`);
-    shellExec(`node bin/db ${host}${path} create ${deployId}`);
-  }
-
-  if (git) {
-    if (directory && !fs.existsSync(directory)) fs.mkdirSync(directory, { recursive: true });
-
-    shellExec(`git clone ${git}`);
-
-    // fs.mkdirSync(`./public/${host}${path}`, { recursive: true });
-
-    if (fs.existsSync(`./${git.split('/').pop()}`))
-      fs.moveSync(`./${git.split('/').pop()}`, directory ? directory : `./public/${host}${path}`, {
-        overwrite: true,
-      });
-  }
-
-  let cmd, currentBackupTimestamp, baseBackUpPath;
-
-  if (process.argv.includes('cron')) {
-    baseBackUpPath = `${process.cwd()}/engine-private/cron-backups/${getCronBackUpFolder(host, path)}`;
-
-    const files = await fs.readdir(baseBackUpPath, { withFileTypes: true });
-
-    currentBackupTimestamp = files
-      .map((fileObj) => parseInt(fileObj.name))
-      .sort((a, b) => a - b)
-      .reverse()[0];
-  }
-
-  switch (provider) {
-    case 'mariadb':
-      {
-        if (process.argv.includes('cron')) {
-          cmd = `mysql -u ${user} -p${password} ${name} < ${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`
-          }`;
-          if (
-            fs.existsSync(
-              `${
-                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;
-
-    case 'mongoose':
-      {
-        if (process.argv.includes('cron')) {
-          cmd = `mongorestore -d ${name} ${baseBackUpPath}/${currentBackupTimestamp}/${name}`;
-        } else cmd = `mongorestore -d ${name} ${backupPath ? backupPath : `./engine-private/mongodb-backup/${name}`}`;
-      }
-      break;
-  }
-
-  // logger.info('Restore', cmd);
-
-  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`);
@@ -1093,37 +819,6 @@ const Cmd = {
     }${options?.git ? `--git ` : ''}${deployList} ${jobList}`,
 };
 
-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');
-  const errorLine = `import {WebSocketServer as $hSjDC$WebSocketServer} from "ws";`;
-
-  fs.writeFileSync(
-    `./node_modules/peer/dist/module.mjs`,
-    dep.replaceAll(
-      errorLine,
-      `import WebSocketServer from "ws";
-    let $hSjDC$WebSocketServer = WebSocketServer.Server;`,
-    ),
-    'utf8',
-  );
-};
-
-const maintenanceMiddleware = (req, res, port, proxyRouter) => {
-  if (process.argv.includes('maintenance') && globalThis.defaultHtmlSrcMaintenance) {
-    if (req.method.toUpperCase() === 'GET') {
-      res.set('Content-Type', 'text/html');
-      return res.status(503).send(globalThis.defaultHtmlSrcMaintenance);
-    }
-    return res.status(503).json({
-      status: 'error',
-      message: 'Server is under maintenance',
-    });
-  }
-};
-
 const splitFileFactory = async (name, _path) => {
   const stats = fs.statSync(_path);
   const maxSizeInBytes = 1024 * 1024 * 50; // 50 mb
@@ -1152,14 +847,6 @@ const splitFileFactory = async (name, _path) => {
   return false;
 };
 
-const setUpProxyMaintenanceServer = ({ deployGroupId }) => {
-  shellExec(`pm2 kill`);
-  shellExec(`node bin/deploy valkey-service`);
-  const proxyDeployId = fs.readFileSync(`./engine-private/deploy/${deployGroupId}.proxy`, 'utf8').trim();
-  shellExec(`node bin/deploy conf ${proxyDeployId} production`);
-  shellExec(`npm start ${proxyDeployId} maintenance`);
-};
-
 const getNpmRootPath = () =>
   shellExec(`npm root -g`, {
     stdout: true,
@@ -1253,22 +940,11 @@ export {
   buildWsSrc,
   cloneSrcComponents,
   buildProxyRouter,
-  cliBar,
-  cliSpinner,
   getDataDeploy,
   validateTemplatePath,
   buildReplicaId,
-  restoreMacroDb,
-  getDeployGroupId,
-  execDeploy,
-  deployRun,
   getCronBackUpFolder,
-  getRestoreCronCmd,
   mergeFile,
-  fixDependencies,
-  getDeployId,
-  maintenanceMiddleware,
-  setUpProxyMaintenanceServer,
   getPathsSSR,
   buildKindPorts,
   buildPortProxyRouter,
@@ -1276,7 +952,6 @@ export {
   getNpmRootPath,
   getUnderpostRootPath,
   writeEnv,
-  deployTest,
   pathPortAssignmentFactory,
   deployRangePortFactory,
   awaitDeployMonitor,

package/src/server/proxy.js

@@ -6,7 +6,7 @@ import dotenv from 'dotenv';
 import { createProxyMiddleware } from 'http-proxy-middleware';
 import { loggerFactory, loggerMiddleware } from './logger.js';
 import { createSslServer, sslRedirectMiddleware } from './ssl.js';
-import { buildPortProxyRouter, buildProxyRouter, maintenanceMiddleware } from './conf.js';
+import { buildPortProxyRouter, buildProxyRouter } from './conf.js';
 import UnderpostStartUp from './start.js';
 
 dotenv.config();
@@ -48,7 +48,6 @@ const buildProxy = async () => {
       onProxyReq: (proxyReq, req, res, options) => {
         // https://wtools.io/check-http-status-code
         // http://nexodev.org
-        maintenanceMiddleware(req, res, port, proxyRouter);
         sslRedirectMiddleware(req, res, port, proxyRouter);
       },
       pathRewrite: {
@@ -56,7 +55,7 @@ const buildProxy = async () => {
         // '^/target-path': '/',
       },
     };
-    if (!process.argv.includes('maintenance')) options.router = buildPortProxyRouter(port, proxyRouter);
+    options.router = buildPortProxyRouter(port, proxyRouter);
 
     const filter = false
       ? (pathname, req) => {

package/src/server/runtime.js

@@ -18,7 +18,6 @@ import { DataBaseProvider } from '../db/DataBaseProvider.js';
 // import { createProxyMiddleware } from 'http-proxy-middleware';
 import { createPeerServer } from './peer.js';
 import { Lampp } from '../runtime/lampp/Lampp.js';
-import { getDeployId } from './conf.js';
 import { JSONweb, ssrFactory } from './client-formatted.js';
 import Underpost from '../index.js';
 import { createValkeyConnection } from './valkey.js';
@@ -28,7 +27,7 @@ dotenv.config();
 const logger = loggerFactory(import.meta);
 
 const buildRuntime = async () => {
-  const deployId = getDeployId();
+  const deployId = process.env.DEPLOY_ID;
 
   const collectDefaultMetrics = promClient.collectDefaultMetrics;
   collectDefaultMetrics();