@underpostnet/underpost 3.0.3 → 3.1.0

package/src/server/client-build-docs.js

@@ -59,6 +59,10 @@ const buildApiDocs = async ({
         name: 'user',
         description: 'User API operations',
       },
+      {
+        name: 'object-layer',
+        description: 'Object Layer API operations',
+      },
     ],
     components: {
       schemas: {
@@ -150,6 +154,70 @@ const buildApiDocs = async ({
           },
         },
       },
+      objectLayerResponse: {
+        type: 'object',
+        properties: {
+          status: { type: 'string', example: 'success' },
+          data: {
+            type: 'object',
+            properties: {
+              _id: { type: 'string', example: '66c377f57f99e5969b81de89' },
+              data: {
+                type: 'object',
+                properties: {
+                  stats: {
+                    type: 'object',
+                    properties: {
+                      effect: { type: 'number', example: 0 },
+                      resistance: { type: 'number', example: 0 },
+                      agility: { type: 'number', example: 0 },
+                      range: { type: 'number', example: 0 },
+                      intelligence: { type: 'number', example: 0 },
+                      utility: { type: 'number', example: 0 },
+                    },
+                  },
+                  item: {
+                    type: 'object',
+                    properties: {
+                      id: { type: 'string', example: 'skin-default' },
+                      type: { type: 'string', example: 'skin' },
+                      description: { type: 'string', example: 'Default skin layer' },
+                      activable: { type: 'boolean', example: false },
+                    },
+                  },
+                  ledger: {
+                    type: 'object',
+                    properties: {
+                      type: { type: 'string', example: 'semi-fungible' },
+                      address: { type: 'string', example: '0x0000000000000000000000000000000000000000' },
+                      tokenId: { type: 'string', example: '' },
+                    },
+                  },
+                  render: {
+                    type: 'object',
+                    properties: {
+                      cid: { type: 'string', example: '' },
+                      metadataCid: { type: 'string', example: '' },
+                    },
+                  },
+                },
+              },
+              cid: { type: 'string', example: '' },
+              sha256: { type: 'string', example: 'abc123def456...' },
+            },
+          },
+        },
+      },
+      objectLayerBadRequestResponse: {
+        type: 'object',
+        properties: {
+          status: { type: 'string', example: 'error' },
+          message: {
+            type: 'string',
+            example: 'Bad request. Please check your inputs, and try again',
+          },
+        },
+      },
       securitySchemes: {
         bearerAuth: {
           type: 'http',
@@ -221,7 +289,7 @@ const buildApiDocs = async ({
     const outputFile = `./public/${host}${path === '/' ? path : `${path}/`}swagger-output.json`;
     const routes = [];
     for (const api of apis) {
-      if (['user'].includes(api)) routes.push(`./src/api/${api}/${api}.router.js`);
+      if (['user', 'object-layer'].includes(api)) routes.push(`./src/api/${api}/${api}.router.js`);
     }
 
     await swaggerAutoGen({ openapi: '3.0.0' })(outputFile, routes, doc);
@@ -267,14 +335,82 @@ const buildApiDocs = async ({
  */
 const buildJsDocs = async ({ host, path, metadata = {}, publicClientId }) => {
   const logger = loggerFactory(import.meta);
-  const jsDocsConfig = JSON.parse(fs.readFileSync(`./jsdoc.json`, 'utf8'));
+
+  // Detect custom jsdoc.<deployId>.json by matching host against deploy server configs
+  let customJsDocPath = '';
+  const privateConfBase = `./engine-private/conf`;
+  if (fs.existsSync(privateConfBase)) {
+    for (const deployId of fs.readdirSync(privateConfBase)) {
+      const candidatePath = `./jsdoc.${deployId}.json`;
+      if (!fs.existsSync(candidatePath)) continue;
+
+      // Check if this deployId's server config contains the current host
+      const serverConfPath = `${privateConfBase}/${deployId}/conf.server.json`;
+      if (fs.existsSync(serverConfPath)) {
+        try {
+          const serverConf = JSON.parse(fs.readFileSync(serverConfPath, 'utf8'));
+          if (serverConf[host]) {
+            customJsDocPath = candidatePath;
+            logger.info('detected custom jsdoc config', { deployId, host, path: candidatePath });
+            break;
+          }
+        } catch (e) {
+          // skip invalid JSON
+        }
+      }
+
+      // Fallback: also check dev server configs
+      if (!customJsDocPath) {
+        const devConfFiles = fs
+          .readdirSync(`${privateConfBase}/${deployId}`)
+          .filter((f) => f.match(/^conf\.server\.dev\..*\.json$/));
+        for (const devFile of devConfFiles) {
+          try {
+            const devConf = JSON.parse(fs.readFileSync(`${privateConfBase}/${deployId}/${devFile}`, 'utf8'));
+            if (devConf[host]) {
+              customJsDocPath = candidatePath;
+              logger.info('detected custom jsdoc config (dev)', { deployId, host, path: candidatePath });
+              break;
+            }
+          } catch (e) {
+            // skip invalid JSON
+          }
+        }
+      }
+      if (customJsDocPath) break;
+    }
+  }
+
+  const jsDocSourcePath = customJsDocPath || `./jsdoc.json`;
+  const jsDocsConfig = JSON.parse(fs.readFileSync(jsDocSourcePath, 'utf8'));
+  logger.info('using jsdoc config', jsDocSourcePath);
 
   jsDocsConfig.opts.destination = `./public/${host}${path === '/' ? path : `${path}/`}docs/`;
   jsDocsConfig.opts.theme_opts.title = metadata?.title ? metadata.title : undefined;
   jsDocsConfig.opts.theme_opts.favicon = `./public/${host}${path === '/' ? '/' : `${path}/`}favicon.ico`;
 
   const tutorialsPath = `./src/client/public/${publicClientId}/docs/references`;
-  if (fs.existsSync(tutorialsPath)) {
+
+  // Auto-prepare hardhat references when jsdoc config includes hardhat source files
+  const includesHardhat =
+    jsDocsConfig.source &&
+    Array.isArray(jsDocsConfig.source.include) &&
+    jsDocsConfig.source.include.some((p) => p.includes('hardhat/'));
+  if (includesHardhat && fs.existsSync(`./hardhat`)) {
+    fs.mkdirSync(tutorialsPath, { recursive: true });
+    const hardhatReadmePath = `./hardhat/README.md`;
+    const hardhatWhitePaperPath = `./hardhat/WHITE-PAPER.md`;
+    if (fs.existsSync(hardhatReadmePath)) {
+      fs.copySync(hardhatReadmePath, `${tutorialsPath}/Hardhat Module.md`);
+      logger.info('copied hardhat README.md to tutorials references');
+    }
+    if (fs.existsSync(hardhatWhitePaperPath)) {
+      fs.copySync(hardhatWhitePaperPath, `${tutorialsPath}/White Paper.md`);
+      logger.info('copied hardhat WHITE-PAPER.md to tutorials references');
+    }
+  }
+
+  if (fs.existsSync(tutorialsPath) && fs.readdirSync(tutorialsPath).length > 0) {
     jsDocsConfig.opts.tutorials = tutorialsPath;
     if (jsDocsConfig.opts.theme_opts.sections && !jsDocsConfig.opts.theme_opts.sections.includes('Tutorials')) {
       jsDocsConfig.opts.theme_opts.sections.push('Tutorials');
@@ -311,6 +447,45 @@ const buildCoverage = async ({ host, path }) => {
   fs.copySync(`./coverage`, coverageBuildPath);
 
   logger.warn('build coverage', coverageBuildPath);
+
+  // Include hardhat coverage for cyberia-related builds
+  const hardhatCoveragePath = `./hardhat/coverage`;
+  if (fs.existsSync(hardhatCoveragePath) && fs.readdirSync(hardhatCoveragePath).length > 0) {
+    const hardhatCoverageBuildPath = `${jsDocsConfig.opts.destination}hardhat-coverage`;
+    fs.mkdirSync(hardhatCoverageBuildPath, { recursive: true });
+    fs.copySync(hardhatCoveragePath, hardhatCoverageBuildPath);
+    logger.warn('build hardhat coverage', hardhatCoverageBuildPath);
+  } else if (fs.existsSync(`./hardhat/package.json`)) {
+    // Attempt to generate hardhat coverage if the hardhat project exists
+    try {
+      const hardhatPkg = JSON.parse(fs.readFileSync(`./hardhat/package.json`, 'utf8'));
+      if (hardhatPkg.scripts && hardhatPkg.scripts.coverage) {
+        logger.info('generating hardhat coverage report');
+        shellExec(`cd ./hardhat && npx hardhat coverage`, { silent: true });
+        if (fs.existsSync(hardhatCoveragePath) && fs.readdirSync(hardhatCoveragePath).length > 0) {
+          const hardhatCoverageBuildPath = `${jsDocsConfig.opts.destination}hardhat-coverage`;
+          fs.mkdirSync(hardhatCoverageBuildPath, { recursive: true });
+          fs.copySync(hardhatCoveragePath, hardhatCoverageBuildPath);
+          logger.warn('build hardhat coverage (generated)', hardhatCoverageBuildPath);
+        }
+      }
+    } catch (e) {
+      logger.warn('hardhat coverage generation skipped', e.message);
+    }
+  }
+
+  // Copy hardhat README and WHITE-PAPER as markdown docs
+  const docsDestBase = jsDocsConfig.opts.destination;
+  const hardhatReadmePath = `./hardhat/README.md`;
+  const hardhatWhitePaperPath = `./hardhat/WHITE-PAPER.md`;
+  if (fs.existsSync(hardhatReadmePath)) {
+    fs.copySync(hardhatReadmePath, `${docsDestBase}hardhat-README.md`);
+    logger.info('copied hardhat README.md to docs');
+  }
+  if (fs.existsSync(hardhatWhitePaperPath)) {
+    fs.copySync(hardhatWhitePaperPath, `${docsDestBase}hardhat-WHITE-PAPER.md`);
+    logger.info('copied hardhat WHITE-PAPER.md to docs');
+  }
 };
 
 /**

package/src/server/client-build-live.js

@@ -5,7 +5,7 @@
  */
 
 import fs from 'fs-extra';
-import { Config, loadConf } from './conf.js';
+import { Config, loadConf, readConfJson } from './conf.js';
 import { loggerFactory } from './logger.js';
 import { buildClient } from './client-build.js';
 
@@ -17,14 +17,14 @@ const logger = loggerFactory(import.meta);
  * @memberof clientLiveBuild
  */
 const clientLiveBuild = async () => {
-  if (fs.existsSync(`./tmp/client.build.json`)) {
+  if (fs.existsSync(`/tmp/client.build.json`)) {
     const deployId = process.argv[2];
     const subConf = process.argv[3];
     let clientId = 'default';
     let host = 'default.net';
     let path = '/';
     let baseHost = `${host}${path === '/' ? '' : path}`;
-    let views = Config.default.client[clientId].views;
+    let views;
     let apiBaseHost;
     let apiBaseProxyPath;
 
@@ -33,19 +33,8 @@ const clientLiveBuild = async () => {
       (fs.existsSync(`./engine-private/conf/${deployId}`) || fs.existsSync(`./engine-private/replica/${deployId}`))
     ) {
       loadConf(deployId, subConf);
-      const confClient = JSON.parse(
-        fs.readFileSync(
-          fs.existsSync(`./engine-private/replica/${deployId}`)
-            ? `./engine-private/replica/${deployId}/conf.client.json`
-            : fs.existsSync(`./engine-private/conf/${deployId}/conf.client.json`)
-            ? `./engine-private/conf/${deployId}/conf.client.json`
-            : `./conf/conf.client.json`,
-          'utf8',
-        ),
-      );
-      const confServer = JSON.parse(
-        fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.dev.${subConf}.json`, 'utf8'),
-      );
+      const confClient = readConfJson(deployId, 'client');
+      const confServer = readConfJson(deployId, 'server');
       host = process.argv[4];
       path = process.argv[5];
       clientId = confServer[host][path].client;
@@ -53,6 +42,8 @@ const clientLiveBuild = async () => {
       baseHost = `${host}${path === '/' ? '' : path}`;
       apiBaseHost = confServer[host][path].apiBaseHost;
       apiBaseProxyPath = confServer[host][path].apiBaseProxyPath;
+    } else {
+      views = Config.default.client[clientId].views;
     }
 
     logger.info('Live build config', {
@@ -67,7 +58,7 @@ const clientLiveBuild = async () => {
       apiBaseProxyPath,
     });
 
-    const updates = JSON.parse(fs.readFileSync(`./tmp/client.build.json`, 'utf8'));
+    const updates = JSON.parse(fs.readFileSync(`/tmp/client.build.json`, 'utf8'));
     const liveClientBuildPaths = [];
     for (let srcPath of updates) {
       srcPath = srcPath.replaceAll('/', `\\`);
@@ -102,7 +93,7 @@ const clientLiveBuild = async () => {
     }
     logger.info('liveClientBuildPaths', liveClientBuildPaths);
     await buildClient({ liveClientBuildPaths, instances: [{ host, path }] });
-    fs.removeSync(`./tmp/client.build.json`);
+    fs.removeSync(`/tmp/client.build.json`);
   }
 };
 

package/src/server/client-build.js

@@ -15,9 +15,9 @@ import {
   orderArrayFromAttrInt,
   uniqueArray,
 } from '../client/components/core/CommonJs.js';
+import { readConfJson } from './conf.js';
 import UglifyJS from 'uglify-js';
 import { minify } from 'html-minifier-terser';
-import dotenv from 'dotenv';
 import AdmZip from 'adm-zip';
 import * as dir from 'path';
 import { shellExec } from './process.js';
@@ -28,8 +28,6 @@ import Underpost from '../index.js';
 import { buildDocs } from './client-build-docs.js';
 import { ssrFactory } from './ssr.js';
 
-dotenv.config();
-
 // Static Site Generation (SSG)
 
 /**
@@ -77,6 +75,156 @@ const copyNonExistingFiles = (src, dest) => {
   }
 };
 
+/** @type {string} Default XSL sitemap template used when no `sitemap` source file exists in the public directory. */
+const defaultSitemapXsl = `<?xml version="1.0" encoding="UTF-8"?>
+<xsl:stylesheet version="1.0"
+    xmlns:html="http://www.w3.org/TR/REC-html40"
+    xmlns:image="http://www.google.com/schemas/sitemap-image/1.1"
+    xmlns:sitemap="http://www.sitemaps.org/schemas/sitemap/0.9"
+    xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+    <xsl:output method="html" version="1.0" encoding="UTF-8" indent="yes" />
+    <xsl:template match="/">
+        <html xmlns="http://www.w3.org/1999/xhtml">
+            <head>
+                <title>XML Sitemap</title>
+                <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+                <style type="text/css">
+                    body {
+                    font-family: sans-serif;
+                    font-size: 16px;
+                    color: #242628;
+                    }
+                    a {
+                    color: #000;
+                    text-decoration: none;
+                    }
+                    a:hover {
+                    text-decoration: underline;
+                    }
+                    table {
+                    border: none;
+                    border-collapse: collapse;
+                    width: 100%
+                    }
+                    th {
+                    text-align: left;
+                    padding-right: 30px;
+                    font-size: 11px;
+                    }
+                    thead th {
+                    border-bottom: 1px solid #7d878a;
+                    cursor: pointer;
+                    }
+                    td {
+                    font-size:11px;
+                    padding: 5px;
+                    }
+                    tr:nth-child(odd) td {
+                    background-color: rgba(0,0,0,0.04);
+                    }
+                    tr:hover td {
+                    background-color: #e2edf2;
+                    }
+
+                    #content {
+                    margin: 0 auto;
+                    padding: 2% 5%;
+                    max-width: 800px;
+                    }
+
+                    .desc {
+                    margin: 18px 3px;
+                    line-height: 1.2em;
+                    }
+                    .desc a {
+                    color: #5ba4e5;
+                    }
+                </style>
+            </head>
+            <body>
+                <div id="content">
+                    <h1>XML Sitemap</h1>
+                    <p class="desc"> This is a sitemap generated by <a
+                            href="{{web-url}}">{{web-url}}</a>
+                    </p>
+                    <xsl:if test="count(sitemap:sitemapindex/sitemap:sitemap) &gt; 0">
+                        <table id="sitemap" cellpadding="3">
+                            <thead>
+                                <tr>
+                                    <th width="75%">Sitemap</th>
+                                    <th width="25%">Last Modified</th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                <xsl:for-each select="sitemap:sitemapindex/sitemap:sitemap">
+                                    <xsl:variable name="sitemapURL">
+                                        <xsl:value-of select="sitemap:loc" />
+                                    </xsl:variable>
+                                <tr>
+                                        <td>
+                                            <a href="{$sitemapURL}">
+                                                <xsl:value-of select="sitemap:loc" />
+                                            </a>
+                                        </td>
+                                        <td>
+                                            <xsl:value-of
+                                                select="concat(substring(sitemap:lastmod,0,11),concat(' ', substring(sitemap:lastmod,12,5)))" />
+                                        </td>
+                                    </tr>
+                                </xsl:for-each>
+                            </tbody>
+                        </table>
+                    </xsl:if>
+                    <xsl:if test="count(sitemap:sitemapindex/sitemap:sitemap) &lt; 1">
+                        <p class="desc">
+                            <a href="{{web-url}}sitemap.xml" class="back-link">&#8592; Back to index</a>
+                        </p>
+                        <table
+                            id="sitemap" cellpadding="3">
+                            <thead>
+                                <tr>
+                                    <th width="70%">URL (<xsl:value-of
+                                            select="count(sitemap:urlset/sitemap:url)" /> total)</th>
+                                    <th width="15%">Images</th>
+                                    <th title="Last Modification Time" width="15%">Last Modified</th>
+                                </tr>
+                            </thead>
+                            <tbody>
+                                <xsl:variable name="lower" select="'abcdefghijklmnopqrstuvwxyz'" />
+                                <xsl:variable name="upper" select="'ABCDEFGHIJKLMNOPQRSTUVWXYZ'" />
+                                <xsl:for-each select="sitemap:urlset/sitemap:url">
+                                    <tr>
+                                        <td>
+                                            <xsl:variable name="itemURL">
+                                                <xsl:value-of select="sitemap:loc" />
+                                            </xsl:variable>
+                                            <a href="{$itemURL}">
+                                                <xsl:value-of select="sitemap:loc" />
+                                            </a>
+                                        </td>
+                                        <td>
+                                            <xsl:value-of select="count(image:image)" />
+                                        </td>
+                                        <td>
+                                            <xsl:value-of
+                                                select="concat(substring(sitemap:lastmod,0,11),concat(' ', substring(sitemap:lastmod,12,5)))" />
+                                        </td>
+                                    </tr>
+                                </xsl:for-each>
+                            </tbody>
+                        </table>
+                        <p
+                            class="desc">
+                            <a href="{{web-url}}sitemap.xml" class="back-link">&#8592; Back to index</a>
+                        </p>
+                    </xsl:if>
+                </div>
+            </body>
+        </html>
+
+    </xsl:template>
+</xsl:stylesheet>`;
+
 /**
  * @async
  * @function buildClient
@@ -91,9 +239,10 @@ const copyNonExistingFiles = (src, dest) => {
  */
 const buildClient = async (options = { liveClientBuildPaths: [], instances: [], buildZip: false }) => {
   const logger = loggerFactory(import.meta);
-  const confClient = JSON.parse(fs.readFileSync(`./conf/conf.client.json`, 'utf8'));
-  const confServer = JSON.parse(fs.readFileSync(`./conf/conf.server.json`, 'utf8'));
-  const confSSR = JSON.parse(fs.readFileSync(`./conf/conf.ssr.json`, 'utf8'));
+  const deployId = process.env.DEPLOY_ID;
+  const confClient = readConfJson(deployId, 'client');
+  const confServer = readConfJson(deployId, 'server', { loadReplicas: true });
+  const confSSR = readConfJson(deployId, 'ssr');
   const packageData = JSON.parse(fs.readFileSync(`./package.json`, 'utf8'));
   const acmeChallengePath = `/.well-known/acme-challenge`;
   const publicPath = `./public`;
@@ -178,26 +327,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [],
           } */,
       );
     } else if (fs.existsSync(`./engine-private/src/client/public/${publicClientId}`)) {
-      switch (publicClientId) {
-        case 'mysql_test':
-          if (db) {
-            fs.copySync(`./engine-private/src/client/public/${publicClientId}`, rootClientPath);
-            fs.writeFileSync(
-              `${rootClientPath}/index.php`,
-              fs
-                .readFileSync(`${rootClientPath}/index.php`, 'utf8')
-                .replace('test_servername', 'localhost')
-                .replace('test_username', db.user)
-                .replace('test_password', db.password)
-                .replace('test_dbname', db.name),
-              'utf8',
-            );
-          } else logger.error('not provided db config');
-          break;
-
-        default:
-          break;
-      }
+      fs.copySync(`./engine-private/src/client/public/${publicClientId}`, rootClientPath);
     }
     if (dists)
       for (const dist of dists) {
@@ -573,31 +703,38 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [],
           }
       }
       if (!enableLiveRebuild && siteMapLinks.length > 0) {
-        const xslUrl = fs.existsSync(`${rootClientPath}/sitemap`)
-          ? `${path === '/' ? '' : path}/sitemap.xsl`
-          : undefined;
-        // Create a stream to write to
+        const hasSitemapTemplate = fs.existsSync(`${rootClientPath}/sitemap`);
+        const sitemapBaseUrl = `https://${host}${path === '/' ? '' : path}`;
+        // Create a stream to write to — omit xslUrl so we can inject a relative href below
         /** @type {import('sitemap').SitemapStreamOptions} */
-        const sitemapOptions = { hostname: `https://${host}`, xslUrl };
+        const sitemapOptions = { hostname: `https://${host}` };
 
         const siteMapStream = new SitemapStream(sitemapOptions);
         let siteMapSrc = await new Promise((resolve) =>
           streamToPromise(Readable.from(siteMapLinks).pipe(siteMapStream)).then((data) => resolve(data.toString())),
         );
 
+        // Inject a relative xml-stylesheet PI so the XSL loads from the same origin
+        // (works on both http://localhost:<port> and https://production-host)
+        siteMapSrc = siteMapSrc.replace(
+          '<?xml version="1.0" encoding="UTF-8"?>',
+          '<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet type="text/xsl" href="sitemap.xsl"?>',
+        );
+
         // Return a promise that resolves with your XML string
         fs.writeFileSync(`${rootClientPath}/sitemap.xml`, siteMapSrc, 'utf8');
-        if (xslUrl)
-          fs.writeFileSync(
-            `${rootClientPath}/sitemap.xsl`,
-            fs.readFileSync(`${rootClientPath}/sitemap`, 'utf8').replaceAll('{{web-url}}', `https://${host}${path}`),
-            'utf8',
-          );
+
+        // Generate XSL stylesheet from source template or default fallback
+        const xslTemplate = hasSitemapTemplate
+          ? fs.readFileSync(`${rootClientPath}/sitemap`, 'utf8')
+          : defaultSitemapXsl;
+        const webUrl = `https://${host}${path === '/' ? '/' : `${path}/`}`;
+        fs.writeFileSync(`${rootClientPath}/sitemap.xsl`, xslTemplate.replaceAll('{{web-url}}', webUrl), 'utf8');
 
         fs.writeFileSync(
           `${rootClientPath}/robots.txt`,
           `User-agent: *
-Sitemap: https://${host}${path === '/' ? '' : path}/sitemap.xml`,
+Sitemap: ${sitemapBaseUrl}/sitemap.xml`,
           'utf8',
         );
       }

package/src/server/client-dev-server.js

@@ -5,8 +5,10 @@
  */
 import fs from 'fs-extra';
 import nodemon from 'nodemon';
+import dotenv from 'dotenv';
 import { shellExec } from './process.js';
 import { loggerFactory } from './logger.js';
+import Underpost from '../index.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -21,22 +23,20 @@ const logger = loggerFactory(import.meta);
  * @returns {void}
  * @memberof clientDevServer
  */
-const createClientDevServer = (
+const createClientDevServer = async (
   deployId = process.argv[2] || 'dd-default',
   subConf = process.argv[3] || '',
   host = process.argv[4] || 'default.net',
   path = process.argv[5] || '/',
 ) => {
-  shellExec(
-    `env-cmd -f ./engine-private/conf/${deployId}/.env.${process.env.NODE_ENV}.${subConf}-dev-client node bin/deploy build-full-client ${deployId} ${subConf}-dev-client ${host} ${path}`.trim(),
-  );
+  const devClientEnvPath = `./engine-private/conf/${deployId}/.env.${process.env.NODE_ENV}.${subConf}-dev-client`;
+  if (fs.existsSync(devClientEnvPath)) dotenv.config({ path: devClientEnvPath, override: true });
 
-  shellExec(
-    `env-cmd -f ./engine-private/conf/${deployId}/.env.${process.env.NODE_ENV}.${subConf}-dev-client node src/server ${deployId} ${subConf}-dev-client`.trim(),
-    {
-      async: true,
-    },
-  );
+  await Underpost.repo.client(deployId, `${subConf}-dev-client`.trim(), host, path);
+
+  shellExec(`node src/server ${deployId} ${subConf}-dev-client`.trim(), {
+    async: true,
+  });
 
   // https://github.com/remy/nodemon/blob/main/doc/events.md
 
@@ -47,7 +47,7 @@ const createClientDevServer = (
   // restart([ array of files triggering the restart ]) - child process has restarted
   // config:update - nodemon's config has changed
 
-  if (fs.existsSync(`./tmp/client.build.json`)) fs.removeSync(`./tmp/client.build.json`);
+  if (fs.existsSync(`/tmp/client.build.json`)) fs.removeSync(`/tmp/client.build.json`);
 
   let buildPathScope = [];
 
@@ -77,10 +77,11 @@ const createClientDevServer = (
       }, 2500);
       const buildPathScopeBuild = buildPathScope.map((o) => o.path);
       logger.info('buildPathScopeBuild', buildPathScopeBuild);
-      fs.writeFileSync(`./tmp/client.build.json`, JSON.stringify(buildPathScopeBuild, null, 4));
+      fs.writeFileSync(`/tmp/client.build.json`, JSON.stringify(buildPathScopeBuild, null, 4));
     })
     .on('crash', function (error) {
-      logger.error(error, error.message);
+      if (error) logger.error(error, error.message || 'nodemon crash');
+      else logger.error('nodemon process crashed');
     });
 };