underpost 3.1.2 → 3.1.3

package/src/index.js

@@ -42,7 +42,7 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v3.1.2';
+  static version = 'v3.1.3';
 
   /**
    * Required Node.js major version

package/src/runtime/express/Express.js

@@ -165,14 +165,7 @@ class ExpressService {
         });
       }
 
-      // Swagger UI setup
-      if (fs.existsSync(swaggerJsonPath)) {
-        const swaggerDoc = JSON.parse(fs.readFileSync(swaggerJsonPath, 'utf8'));
-        const swaggerUiOptions = await buildSwaggerUiOptions();
-        app.use(swaggerPath, swaggerUi.serve, swaggerUi.setup(swaggerDoc, swaggerUiOptions));
-      }
-
-      // Security and CORS
+      // Security and CORS — must run before swagger-ui so CSP headers are included in swagger responses
       if (process.env.NODE_ENV === 'development' && useLocalSsl)
         origins = origins.map((origin) => origin.replace('http', 'https'));
 
@@ -180,6 +173,13 @@ class ExpressService {
         origin: origins,
       });
 
+      // Swagger UI setup (after security middleware so responses carry correct CSP headers)
+      if (fs.existsSync(swaggerJsonPath)) {
+        const swaggerDoc = JSON.parse(fs.readFileSync(swaggerJsonPath, 'utf8'));
+        const swaggerUiOptions = await buildSwaggerUiOptions();
+        app.use(swaggerPath, swaggerUi.serve, swaggerUi.setup(swaggerDoc, swaggerUiOptions));
+      }
+
       // Database and Valkey connections
       if (db && apis) await DataBaseProvider.load({ apis, host, path, db });
 

package/src/server/auth.js

@@ -613,13 +613,13 @@ function applySecurity(app, opts = {}) {
         frameAncestors: frameAncestors,
         imgSrc: ["'self'", 'data:', httpDirective, 'https:', 'blob:'],
         objectSrc: ["'none'"],
-        // script-src and script-src-elem include dynamic nonce
-        scriptSrc: [
+        // script-src and script-src-elem: use 'unsafe-inline' for swagger (no nonce, otherwise
+        // the nonce causes 'unsafe-inline' to be ignored per CSP3 spec), nonce for everything else.
+        scriptSrc: ["'self'", (req, res) => (res.locals.isSwagger ? "'unsafe-inline'" : `'nonce-${res.locals.nonce}'`)],
+        scriptSrcElem: [
           "'self'",
-          (req, res) => `'nonce-${res.locals.nonce}'`,
-          (req, res) => (res.locals.isSwagger ? "'unsafe-inline'" : ''),
+          (req, res) => (res.locals.isSwagger ? "'unsafe-inline'" : `'nonce-${res.locals.nonce}'`),
         ],
-        scriptSrcElem: ["'self'", (req, res) => `'nonce-${res.locals.nonce}'`],
         // style-src: avoid 'unsafe-inline' when possible; if you must inline styles,
         // use a nonce for them too (or hash).
         styleSrc: [
@@ -627,6 +627,7 @@ function applySecurity(app, opts = {}) {
           httpDirective,
           (req, res) => (res.locals.isSwagger ? "'unsafe-inline'" : `'nonce-${res.locals.nonce}'`),
         ],
+        styleSrcAttr: [(req, res) => (res.locals.isSwagger ? "'unsafe-inline'" : "'none'")],
         // deny plugins
         objectSrc: ["'none'"],
       },

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

@@ -332,56 +332,17 @@ const buildApiDocs = async ({
  * @param {string} options.path - The base path for the documentation
  * @param {Object} options.metadata - Metadata for the documentation
  * @param {string} options.publicClientId - Client ID used to resolve the tutorials/references directory
+ * @param {Object} options.docs - Documentation config from server conf
+ * @param {string} options.docs.jsJsonPath - Path to the JSDoc JSON config file
  */
-const buildJsDocs = async ({ host, path, metadata = {}, publicClientId }) => {
+const buildJsDocs = async ({ host, path, metadata = {}, publicClientId, docs }) => {
   const logger = loggerFactory(import.meta);
 
-  // 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 = docs.jsJsonPath;
+  if (!fs.existsSync(jsDocSourcePath)) {
+    logger.warn('jsdoc config not found, skipping', jsDocSourcePath);
+    return;
   }
-
-  const jsDocSourcePath = customJsDocPath || `./jsdoc.json`;
   const jsDocsConfig = JSON.parse(fs.readFileSync(jsDocSourcePath, 'utf8'));
   logger.info('using jsdoc config', jsDocSourcePath);
 
@@ -391,22 +352,14 @@ const buildJsDocs = async ({ host, path, metadata = {}, publicClientId }) => {
 
   const tutorialsPath = `./src/client/public/${publicClientId}/docs/references`;
 
-  // 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`)) {
+  if (Array.isArray(docs.references) && docs.references.length > 0) {
     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');
+    for (const refPath of docs.references) {
+      if (fs.existsSync(refPath)) {
+        const fileName = refPath.split('/').pop();
+        fs.copySync(refPath, `${tutorialsPath}/${fileName}`);
+        logger.info('copied reference to tutorials', refPath);
+      }
     }
   }
 
@@ -420,10 +373,10 @@ const buildJsDocs = async ({ host, path, metadata = {}, publicClientId }) => {
     delete jsDocsConfig.opts.tutorials;
   }
 
-  fs.writeFileSync(`./jsdoc.json`, JSON.stringify(jsDocsConfig, null, 4), 'utf8');
+  fs.writeFileSync(jsDocSourcePath, JSON.stringify(jsDocsConfig, null, 4), 'utf8');
   logger.warn('build jsdoc view', jsDocsConfig.opts.destination);
 
-  shellExec(`npm run docs`, { silent: true });
+  shellExec(`npx jsdoc -c ${jsDocSourcePath}`, { silent: true });
 };
 
 /**
@@ -433,58 +386,37 @@ const buildJsDocs = async ({ host, path, metadata = {}, publicClientId }) => {
  * @param {Object} options - Coverage build options
  * @param {string} options.host - The hostname for the coverage
  * @param {string} options.path - The base path for the coverage
+ * @param {Object} options.docs - Documentation config from server conf
+ * @param {string} options.docs.coveragePath - Directory where to run npm run coverage
  */
-const buildCoverage = async ({ host, path }) => {
+const buildCoverage = async ({ host, path, docs }) => {
   const logger = loggerFactory(import.meta);
-  const jsDocsConfig = JSON.parse(fs.readFileSync(`./jsdoc.json`, 'utf8'));
-
-  if (!fs.existsSync(`./coverage`)) {
-    shellExec(`npm test`);
-  }
-
-  const coverageBuildPath = `${jsDocsConfig.opts.destination}coverage`;
-  fs.mkdirSync(coverageBuildPath, { recursive: true });
-  fs.copySync(`./coverage`, coverageBuildPath);
-
-  logger.warn('build coverage', coverageBuildPath);
+  const jsDocSourcePath = docs.jsJsonPath;
+  const jsDocsConfig = JSON.parse(fs.readFileSync(jsDocSourcePath, 'utf8'));
+  const coveragePath = docs.coveragePath;
 
-  // 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);
-        }
+  const coverageOutputPath = `${coveragePath}/coverage`;
+  if (!fs.existsSync(coverageOutputPath)) {
+    const pkgPath = `${coveragePath}/package.json`;
+    if (fs.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+      if (pkg.scripts && pkg.scripts.coverage) {
+        logger.info('generating coverage report', coveragePath);
+        shellExec(`cd ${coveragePath} && npm run coverage`, { silent: true });
+      } else if (pkg.scripts && pkg.scripts.test) {
+        logger.info('generating coverage via test', coveragePath);
+        shellExec(`cd ${coveragePath} && npm test`, { silent: true });
       }
-    } 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');
+  if (fs.existsSync(coverageOutputPath) && fs.readdirSync(coverageOutputPath).length > 0) {
+    const coverageBuildPath = `${jsDocsConfig.opts.destination}coverage`;
+    fs.mkdirSync(coverageBuildPath, { recursive: true });
+    fs.copySync(coverageOutputPath, coverageBuildPath);
+    logger.warn('build coverage', coverageBuildPath);
+  } else {
+    logger.warn('no coverage output found, skipping', coverageOutputPath);
   }
 };
 
@@ -501,6 +433,7 @@ const buildCoverage = async ({ host, path }) => {
  * @param {string} options.publicClientId - Client ID for the public documentation
  * @param {string} options.rootClientPath - Root path for client files
  * @param {Object} options.packageData - Package.json data
+ * @param {Object} options.docs - Documentation config from server conf
  */
 const buildDocs = async ({
   host,
@@ -511,9 +444,10 @@ const buildDocs = async ({
   publicClientId,
   rootClientPath,
   packageData,
+  docs,
 }) => {
-  await buildJsDocs({ host, path, metadata, publicClientId });
-  await buildCoverage({ host, path });
+  await buildJsDocs({ host, path, metadata, publicClientId, docs });
+  await buildCoverage({ host, path, docs });
   await buildApiDocs({
     host,
     path,

package/src/server/client-build.js

@@ -230,16 +230,28 @@ const defaultSitemapXsl = `<?xml version="1.0" encoding="UTF-8"?>
  * @function buildClient
  * @memberof clientBuild
  * @param {Object} options - Options for the build process.
+ * @param {string} options.deployId - The deployment ID for which to build the client.
  * @param {Array} options.liveClientBuildPaths - List of paths to build incrementally.
  * @param {Array} options.instances - List of instances to build.
  * @param {boolean} options.buildZip - Whether to create zip files of the builds.
+ * @param {boolean} options.fullBuild - Whether to perform a full build.
+ * @param {boolean} options.iconsBuild - Whether to build icons.
  * @returns {Promise<void>} - Promise that resolves when the build is complete.
  * @throws {Error} - If the build fails.
  * @memberof clientBuild
  */
-const buildClient = async (options = { liveClientBuildPaths: [], instances: [], buildZip: false }) => {
+const buildClient = async (
+  options = {
+    deployId: '',
+    liveClientBuildPaths: [],
+    instances: [],
+    buildZip: false,
+    fullBuild: false,
+    iconsBuild: false,
+  },
+) => {
   const logger = loggerFactory(import.meta);
-  const deployId = process.env.DEPLOY_ID;
+  const deployId = options.deployId || process.env.DEPLOY_ID;
   const confClient = readConfJson(deployId, 'client');
   const confServer = readConfJson(deployId, 'server', { loadReplicas: true });
   const confSSR = readConfJson(deployId, 'ssr');
@@ -373,17 +385,14 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [],
         client,
         directory,
         disabledRebuild,
-        minifyBuild,
         db,
         redirect,
         apis,
-        iconsBuild,
-        docsBuild,
         apiBaseProxyPath,
         apiBaseHost,
         ttiLoadTimeLimit,
         singleReplica,
-        offlineBuild,
+        docs,
       } = confServer[host][path];
       if (singleReplica) continue;
       if (!confClient[client]) confClient[client] = {};
@@ -397,9 +406,10 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [],
       const rootClientPath = directory ? directory : `${publicPath}/${host}${path}`;
       const port = newInstance(currentPort);
       const publicClientId = publicRef ? publicRef : client;
-      const fullBuildEnabled = !confServer[host][path].liteBuild && !enableLiveRebuild;
+      const fullBuildEnabled = options.fullBuild && !enableLiveRebuild;
       // const baseHost = process.env.NODE_ENV === 'production' ? `https://${host}` : `http://localhost:${port}`;
       const baseHost = process.env.NODE_ENV === 'production' ? `https://${host}` : ``;
+      const minifyBuild = process.env.NODE_ENV === 'production';
       // ''; // process.env.NODE_ENV === 'production' ? `https://${host}` : ``;
       currentPort++;
 
@@ -421,7 +431,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [],
           rootClientPath,
           acmeChallengeFullPath,
           publicClientId,
-          iconsBuild,
+          iconsBuild: options.iconsBuild,
           metadata,
           publicCopyNonExistingFiles,
         });
@@ -445,11 +455,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [],
               'components',
               baseHost,
             );
-            fs.writeFileSync(
-              jsPublicPath,
-              minifyBuild || process.env.NODE_ENV === 'production' ? UglifyJS.minify(jsSrc).code : jsSrc,
-              'utf8',
-            );
+            fs.writeFileSync(jsPublicPath, minifyBuild ? UglifyJS.minify(jsSrc).code : jsSrc, 'utf8');
           }
         }
 
@@ -471,11 +477,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [],
               'services',
               baseHost,
             );
-            fs.writeFileSync(
-              jsPublicPath,
-              minifyBuild || process.env.NODE_ENV === 'production' ? UglifyJS.minify(jsSrc).code : jsSrc,
-              'utf8',
-            );
+            fs.writeFileSync(jsPublicPath, minifyBuild ? UglifyJS.minify(jsSrc).code : jsSrc, 'utf8');
           }
         }
 
@@ -493,11 +495,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [],
               'services',
               baseHost,
             );
-            fs.writeFileSync(
-              jsPublicPath,
-              minifyBuild || process.env.NODE_ENV === 'production' ? UglifyJS.minify(jsSrc).code : jsSrc,
-              'utf8',
-            );
+            fs.writeFileSync(jsPublicPath, minifyBuild ? UglifyJS.minify(jsSrc).code : jsSrc, 'utf8');
           }
         }
       }
@@ -517,11 +515,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [],
         if (!(enableLiveRebuild && !options.liveClientBuildPaths.find((p) => p.srcBuildPath === jsSrcPath))) {
           const jsSrc = viewFormatted(await srcFormatted(fs.readFileSync(jsSrcPath, 'utf8')), dists, path, baseHost);
 
-          fs.writeFileSync(
-            jsPublicPath,
-            minifyBuild || process.env.NODE_ENV === 'production' ? UglifyJS.minify(jsSrc).code : jsSrc,
-            'utf8',
-          );
+          fs.writeFileSync(jsPublicPath, minifyBuild ? UglifyJS.minify(jsSrc).code : jsSrc, 'utf8');
         }
 
         if (
@@ -548,11 +542,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [],
               baseHost,
             );
 
-            fs.writeFileSync(
-              `${buildPath}${buildId}.js`,
-              minifyBuild || process.env.NODE_ENV === 'production' ? UglifyJS.minify(jsSrc).code : jsSrc,
-              'utf8',
-            );
+            fs.writeFileSync(`${buildPath}${buildId}.js`, minifyBuild ? UglifyJS.minify(jsSrc).code : jsSrc, 'utf8');
             const title = metadata.title ? metadata.title : title;
 
             const canonicalURL = `https://${host}${path}${
@@ -689,7 +679,7 @@ const buildClient = async (options = { liveClientBuildPaths: [], instances: [],
 
             fs.writeFileSync(
               `${buildPath}index.html`,
-              minifyBuild || process.env.NODE_ENV === 'production'
+              minifyBuild
                 ? await minify(htmlSrc, {
                     minifyCSS: true,
                     minifyJS: true,
@@ -739,7 +729,7 @@ Sitemap: ${sitemapBaseUrl}/sitemap.xml`,
         );
       }
 
-      if (fullBuildEnabled && !enableLiveRebuild && docsBuild) {
+      if (fullBuildEnabled && docs) {
         await buildDocs({
           host,
           path,
@@ -749,13 +739,14 @@ Sitemap: ${sitemapBaseUrl}/sitemap.xml`,
           publicClientId,
           rootClientPath,
           packageData,
+          docs,
         });
       }
 
       if (client) {
         let PRE_CACHED_RESOURCES = [];
 
-        if (views && offlineBuild && fs.existsSync(`${rootClientPath}/sw.js`)) {
+        if (views && fs.existsSync(`${rootClientPath}/sw.js`)) {
           PRE_CACHED_RESOURCES = await fs.readdir(rootClientPath, { recursive: true });
           PRE_CACHED_RESOURCES = views
             .map((view) => `${path === '/' ? '' : path}${view.path}`)
@@ -774,7 +765,7 @@ Sitemap: ${sitemapBaseUrl}/sitemap.xml`,
               const htmlSrc = Render({
                 title: page.title,
                 ssrPath,
-                ssrHeadComponents: '',
+                ssrHeadComponents: '<base target="_top">',
                 ssrBodyComponents: SsrComponent(),
                 renderPayload: {
                   apiBaseProxyPath,
@@ -802,7 +793,7 @@ Sitemap: ${sitemapBaseUrl}/sitemap.xml`,
 
               fs.writeFileSync(
                 buildHtmlPath,
-                minifyBuild || process.env.NODE_ENV === 'production'
+                minifyBuild
                   ? await minify(htmlSrc, {
                       minifyCSS: true,
                       minifyJS: true,

package/src/server/conf.js

@@ -1275,18 +1275,6 @@ const awaitDeployMonitor = async (init = false, deltaMs = 1000) => {
   if (Underpost.env.get('await-deploy')) return await awaitDeployMonitor();
 };
 
-/**
- * @method getCronBackUpFolder
- * @description Gets the cron back up folder.
- * @param {string} host - The host.
- * @param {string} path - The path.
- * @returns {string} - The cron back up folder.
- * @memberof ServerConfBuilder
- */
-const getCronBackUpFolder = (host = '', path = '') => {
-  return `${host}${path.replace(/\\/g, '/').replace(`/`, '-')}`;
-};
-
 /**
  * @method mergeFile
  * @description Merges the file.
@@ -1499,8 +1487,25 @@ const buildCliDoc = (program, oldVersion, newVersion) => {
   md = md.replaceAll(oldVersion, newVersion);
   fs.writeFileSync(`./src/client/public/nexodev/docs/references/Command Line Interface.md`, md, 'utf8');
   fs.writeFileSync(`./CLI-HELP.md`, md, 'utf8');
-  const readme = fs.readFileSync(`./README.md`, 'utf8');
-  fs.writeFileSync('./README.md', readme.replaceAll(oldVersion, newVersion), 'utf8');
+
+  // Update README.md: replace version and CLI index section between comment tags
+  let readme = fs.readFileSync(`./README.md`, 'utf8');
+  readme = readme.replaceAll(oldVersion, newVersion);
+  const cliStartTag = '<!-- cli-index-start -->';
+  const cliEndTag = '<!-- cli-index-end -->';
+  const startIdx = readme.indexOf(cliStartTag);
+  const endIdx = readme.indexOf(cliEndTag);
+  if (startIdx !== -1 && endIdx !== -1) {
+    readme =
+      readme.substring(0, startIdx) +
+      cliStartTag +
+      '\n' +
+      baseOptions +
+      '\n' +
+      cliEndTag +
+      readme.substring(endIdx + cliEndTag.length);
+  }
+  fs.writeFileSync('./README.md', readme, 'utf8');
 };
 
 /**
@@ -1743,7 +1748,6 @@ export {
   getDataDeploy,
   validateTemplatePath,
   buildReplicaId,
-  getCronBackUpFolder,
   mergeFile,
   getPathsSSR,
   buildKindPorts,

package/src/server/start.js

@@ -147,18 +147,25 @@ class UnderpostStartUp {
      * @param {string} deployId - The ID of the deployment.
      * @param {string} env - The environment of the deployment.
      * @param {Object} options - Options for the build.
+     * @param {boolean} options.skipPullBase - Whether to skip pulling the base code and use the current workspace code directly.
      * @param {boolean} options.underpostQuicklyInstall - Whether to use underpost quickly install.
      * @memberof UnderpostStartUp
      */
-    async build(deployId = 'dd-default', env = 'development', options = { underpostQuicklyInstall: false }) {
+    async build(
+      deployId = 'dd-default',
+      env = 'development',
+      options = { underpostQuicklyInstall: false, skipPullBase: false },
+    ) {
       const buildBasePath = `/home/dd`;
       const repoName = `engine-${deployId.split('-')[1]}`;
-      shellExec(`cd ${buildBasePath} && underpost clone ${process.env.GITHUB_USERNAME}/${repoName}`);
-      shellExec(`mkdir -p ${buildBasePath}/engine`);
-      shellExec(`cd ${buildBasePath} && sudo cp -a ./${repoName}/. ./engine`);
-      shellExec(`cd ${buildBasePath} && sudo rm -rf ./${repoName}`);
-      shellExec(`cd ${buildBasePath}/engine && underpost clone ${process.env.GITHUB_USERNAME}/${repoName}-private`);
-      shellExec(`cd ${buildBasePath}/engine && sudo mv ./${repoName}-private ./engine-private`);
+      if (!options.skipPullBase) {
+        shellExec(`cd ${buildBasePath} && underpost clone ${process.env.GITHUB_USERNAME}/${repoName}`);
+        shellExec(`mkdir -p ${buildBasePath}/engine`);
+        shellExec(`cd ${buildBasePath} && sudo cp -a ./${repoName}/. ./engine`);
+        shellExec(`cd ${buildBasePath} && sudo rm -rf ./${repoName}`);
+        shellExec(`cd ${buildBasePath}/engine && underpost clone ${process.env.GITHUB_USERNAME}/${repoName}-private`);
+        shellExec(`cd ${buildBasePath}/engine && sudo mv ./${repoName}-private ./engine-private`);
+      }
       shellCd(`${buildBasePath}/engine`);
       shellExec(options?.underpostQuicklyInstall ? `underpost install` : `npm install`);
       shellExec(`node bin env ${deployId} ${env}`);
@@ -167,7 +174,7 @@ class UnderpostStartUp {
         for (const itcScript of itcScripts)
           if (itcScript.match(deployId)) shellExec(`node ./engine-private/itc-scripts/${itcScript}`);
       }
-      await Underpost.repo.client(deployId);
+      shellExec(`node bin client ${deployId}`);
     },
     /**
      * Runs a deployment.