cyberia 3.2.9 → 3.2.22

package/src/cli/repository.js

@@ -8,6 +8,7 @@ import dotenv from 'dotenv';
 import { commitData } from '../client/components/core/CommonJs.js';
 import { pbcopy, shellCd, shellExec } from '../server/process.js';
 import { actionInitLog, loggerFactory } from '../server/logger.js';
+import path from 'path';
 import fs from 'fs-extra';
 import {
   getNpmRootPath,
@@ -133,10 +134,21 @@ class UnderpostRepository {
         p: undefined,
         bc: '',
         isRemoteRepo: '',
+        hasChanges: false,
       },
     ) {
       if (!repoPath) repoPath = '.';
 
+      if (options.hasChanges) {
+        const status = shellExec(`cd ${repoPath} && git status --porcelain`, {
+          stdout: true,
+          silent: true,
+          disableLog: true,
+        }).trim();
+        process.stdout.write(status ? '1' : '');
+        return;
+      }
+
       if (options.isRemoteRepo) {
         const accessible = Underpost.repo.isRemoteRepo(options.isRemoteRepo);
         console.log(accessible);
@@ -556,7 +568,7 @@ class UnderpostRepository {
             // Handle sync-conf operation
             if (options.syncConf) {
               logger.info(`Syncing configuration for deploy ID: ${deployId}`);
-              shellExec(`node bin/build ${deployId} conf`);
+              shellExec(`node bin/build ${deployId} --conf`);
               logger.info('Configuration synced successfully');
               return resolve(true);
             }
@@ -608,7 +620,8 @@ class UnderpostRepository {
             const npmRoot = getNpmRootPath();
             const underpostRoot = options?.dev === true ? '.' : `${npmRoot}/underpost`;
             const destFolder = `./${projectName}`;
-            logger.info('build app', { destFolder });
+            const deployId = projectName.startsWith('dd-') ? projectName : `dd-${projectName}`;
+            logger.info('build app', { destFolder, deployId });
             if (fs.existsSync(destFolder)) fs.removeSync(destFolder);
             fs.mkdirSync(destFolder, { recursive: true });
             if (!options.dev) {
@@ -621,8 +634,9 @@ class UnderpostRepository {
               UnderpostRepository.API.initLocalRepo({ path: destFolder });
               shellExec(`cd ${destFolder} && git add . && git commit -m "Base template implementation"`);
             }
-            shellExec(`cd ${destFolder} && npm run build`);
-            shellExec(`cd ${destFolder} && npm run dev`);
+            shellExec(`cd ${destFolder} && node bin new --deploy-id ${deployId} --default-conf`);
+            shellExec(`cd ${destFolder} && node bin client ${deployId}`);
+            shellExec(`cd ${destFolder} && DEPLOY_ID=${deployId} npm run dev`);
           }
           return resolve(true);
         } catch (error) {
@@ -852,6 +866,7 @@ class UnderpostRepository {
               }
             }
             await buildClient({
+              deployId: resolvedDeployId,
               buildZip: options.buildZip || false,
               split: options.split || '',
               fullBuild: options.liteBuild ? false : true,
@@ -862,7 +877,12 @@ class UnderpostRepository {
                 logger.warn('Skip replica client build: replica folder not found', { replicaDeployId });
                 continue;
               }
-              await Underpost.repo.client(replicaDeployId);
+              await Underpost.repo.client(replicaDeployId, '', '', '', {
+                buildZip: options.buildZip || false,
+                split: options.split || '',
+                liteBuild: options.liteBuild || false,
+                iconsBuild: options.iconsBuild || false,
+              });
             }
 
             return resolve(true);
@@ -924,8 +944,6 @@ class UnderpostRepository {
       shellExec(`cd ${privateRepoPath} && underpost pull . ${process.env.GITHUB_USERNAME}/${privateRepoName}`, {
         silent: true,
       });
-      shellExec(`underpost run secret`);
-      shellExec(`underpost run underpost-config`);
       const packageJsonDeploy = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/package.json`, 'utf8'));
       const packageJsonEngine = JSON.parse(fs.readFileSync(`./package.json`, 'utf8'));
       if (packageJsonDeploy.version !== packageJsonEngine.version) {
@@ -939,7 +957,7 @@ Prevent build private config repo.`,
           deployVersion: packageJsonDeploy.version,
         };
       }
-      shellExec(`node bin/build ${deployId} conf`);
+      shellExec(`node bin/build ${deployId} --conf`);
       return {
         validVersion: true,
         engineVersion: packageJsonEngine.version,
@@ -1008,11 +1026,14 @@ Prevent build private config repo.`,
             const host = 'default.net';
             const path = '/';
             DefaultConf.server[host][path].valkey = {
-              port: 6379,
-              host: 'valkey-service.default.svc.cluster.local',
+              port: 'env:VALKEY_PORT:int:6379',
+              host: 'env:VALKEY_HOST:127.0.0.1',
             };
-            // mongodb-0.mongodb-service
-            DefaultConf.server[host][path].db.host = 'mongodb://mongodb-service:27017';
+            DefaultConf.server[host][path].db.host = 'env:DB_HOST:mongodb://127.0.0.1:27017';
+            DefaultConf.server[host][path].db.replicaSet = 'env:DB_REPLICA_SET:rs0';
+            DefaultConf.server[host][path].db.authSource = 'env:DB_AUTH_SOURCE:admin';
+            DefaultConf.server[host][path].db.user = 'env:DB_USER:';
+            DefaultConf.server[host][path].db.password = 'env:DB_PASSWORD:';
             defaultConf = true;
             break;
           }
@@ -1048,9 +1069,9 @@ Prevent build private config repo.`,
      */
     clean(options = { paths: [''] }) {
       for (const path of options.paths) {
-        shellExec(`cd ${path} && git reset`, { silent: true });
-        shellExec(`cd ${path} && git checkout .`, { silent: true });
-        shellExec(`cd ${path} && git clean -f -d`, { silent: true });
+        shellExec(`cd ${path} && git reset`, { silentOnError: true, silent: true, disableLog: true });
+        shellExec(`cd ${path} && git checkout .`, { silentOnError: true, silent: true, disableLog: true });
+        shellExec(`cd ${path} && git clean -f -d`, { silentOnError: true, silent: true, disableLog: true });
       }
     },
 
@@ -1104,7 +1125,7 @@ Prevent build private config repo.`,
 
       try {
         // Fetch directory contents recursively
-        const copiedFiles = await this._fetchAndCopyGitHubDirectory({
+        const copiedFiles = await this.fetchAndCopyGitHubDirectory({
           apiUrl,
           targetPath,
           basePath: directoryPath,
@@ -1140,7 +1161,7 @@ Prevent build private config repo.`,
      * @returns {Promise<array>} Array of copied file paths.
      * @memberof UnderpostRepository
      */
-    async _fetchAndCopyGitHubDirectory(options) {
+    async fetchAndCopyGitHubDirectory(options) {
       const { apiUrl, targetPath, basePath, branch } = options;
       const copiedFiles = [];
 
@@ -1175,14 +1196,12 @@ Prevent build private config repo.`,
 
       logger.info(`Found ${contents.length} items in directory: ${basePath}`);
 
-      // Process each item in the directory
       for (const item of contents) {
         const itemTargetPath = `${targetPath}/${item.name}`;
 
         if (item.type === 'file') {
           logger.info(`Downloading file: ${item.path}`);
 
-          // Download file content
           const fileResponse = await fetch(item.download_url);
           if (!fileResponse.ok) {
             logger.error(`Failed to download: ${item.download_url}`);
@@ -1192,16 +1211,14 @@ Prevent build private config repo.`,
           const fileContent = await fileResponse.text();
           fs.writeFileSync(itemTargetPath, fileContent);
 
-          logger.info(`✓ Saved: ${itemTargetPath}`);
+          logger.info(`Saved: ${itemTargetPath}`);
           copiedFiles.push(itemTargetPath);
         } else if (item.type === 'dir') {
-          logger.info(`📁 Processing directory: ${item.path}`);
+          logger.info(`Processing directory: ${item.path}`);
 
-          // Create subdirectory
           fs.mkdirSync(itemTargetPath, { recursive: true });
 
-          // Recursively process subdirectory
-          const subFiles = await this._fetchAndCopyGitHubDirectory({
+          const subFiles = await this.fetchAndCopyGitHubDirectory({
             apiUrl: item.url,
             targetPath: itemTargetPath,
             basePath: item.path,
@@ -1209,7 +1226,7 @@ Prevent build private config repo.`,
           });
 
           copiedFiles.push(...subFiles);
-          logger.info(`✓ Completed directory: ${item.path} (${subFiles.length} files)`);
+          logger.info(`Completed directory: ${item.path} (${subFiles.length} files)`);
         } else {
           logger.warn(`Skipping unknown item type '${item.type}': ${item.path}`);
         }
@@ -1295,7 +1312,7 @@ Prevent build private config repo.`,
     },
     /**
      * Checks whether a remote Git repository URL is reachable.
-     * Uses `git ls-remote` with `|| true` so the process always exits 0.
+     * Uses `silentOnError` so a non-reachable remote returns false instead of throwing.
      * Injects `GITHUB_TOKEN` into GitHub HTTPS URLs when available.
      * @param {string} url - Full HTTPS clone URL to test (e.g. "https://github.com/org/repo.git").
      * @returns {boolean} `true` when the remote responded with at least one ref hash.
@@ -1305,10 +1322,11 @@ Prevent build private config repo.`,
       if (!url) return false;
       const authUrl = Underpost.repo.resolveAuthUrl(url);
       // GIT_TERMINAL_PROMPT=0 prevents git from hanging on credential prompts inside containers.
-      const raw = shellExec(`GIT_TERMINAL_PROMPT=0 git ls-remote "${authUrl}" HEAD 2>&1 || true`, {
+      const raw = shellExec(`GIT_TERMINAL_PROMPT=0 git ls-remote "${authUrl}" HEAD 2>&1`, {
         stdout: true,
         silent: true,
         disableLog: true,
+        silentOnError: true,
       });
       logger.info('isRemoteRepo', { url, raw: (raw || '').slice(0, 120) });
       return typeof raw === 'string' && /^[0-9a-f]{40}\t/m.test(raw);
@@ -1376,15 +1394,17 @@ Prevent build private config repo.`,
       const gitEmail = process.env.GITHUB_EMAIL || `development@underpost.net`;
 
       if (!fs.existsSync(`${repoPath}/.git`)) {
-        shellExec(`cd "${repoPath}" && git init`);
+        shellExec(`mkdir -p "${repoPath}" && git init "${repoPath}"`);
       }
+
       shellExec(`cd "${repoPath}" && git config user.name '${gitUsername}'`);
       shellExec(`cd "${repoPath}" && git config user.email '${gitEmail}'`);
-
+      shellExec(`cd "${repoPath}" && git config core.filemode false`);
       if (origin) {
-        const currentRemote = shellExec(`cd "${repoPath}" && git remote get-url origin 2>/dev/null || true`, {
+        const currentRemote = shellExec(`cd "${repoPath}" && git remote get-url origin`, {
           stdout: true,
           silent: true,
+          silentOnError: true,
         }).trim();
         if (!currentRemote) {
           shellExec(`cd "${repoPath}" && git remote add origin "${origin}"`);
@@ -1608,6 +1628,125 @@ Prevent build private config repo.`,
         logger.info('engine-private in /home/dd removed');
       }
     },
+
+    /**
+     * Resolves the GitHub repository for a given instance runtime by scanning
+     * every `conf.instances.json` listed in `./engine-private/deploy/dd.router`.
+     *
+     * Resolution order:
+     *  1. If `runtime` is falsy, returns `${GITHUB_USERNAME}/engine`.
+     *  2. Iterates each deploy ID found in `dd.router` and looks for an instance
+     *     whose `runtime` field matches the supplied value.
+     *  3. When a match is found, returns `instance.metadata.repository`.
+     *  4. Falls back to `${GITHUB_USERNAME}/engine` when no match is found.
+     *
+     * @param {string} [runtime=''] - The runtime identifier to look up (e.g. `'cyberia-server'`, `'cyberia-client'`).
+     * @returns {string} The resolved `owner/repo` string.
+     * @memberof UnderpostRepository
+     */
+    resolveInstanceRepo(runtime = '') {
+      const fallback = `${process.env.GITHUB_USERNAME}/engine`;
+      if (!runtime) return fallback;
+      const ddRouter = './engine-private/deploy/dd.router';
+      const deployIds = fs.existsSync(ddRouter)
+        ? fs
+            .readFileSync(ddRouter, 'utf8')
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean)
+        : [];
+      for (const deployId of deployIds) {
+        const confPath = `./engine-private/conf/${deployId}/conf.instances.json`;
+        if (!fs.existsSync(confPath)) continue;
+        try {
+          const instances = JSON.parse(fs.readFileSync(confPath, 'utf8'));
+          const match = instances.find((i) => i && i.runtime === runtime);
+          if (match && match.metadata && match.metadata.repository) {
+            logger.info(`[resolveInstanceRepo] resolved from ${confPath}`, {
+              runtime,
+              repo: match.metadata.repository,
+            });
+            return match.metadata.repository;
+          }
+        } catch (err) {
+          logger.warn(`[resolveInstanceRepo] failed to parse ${confPath}: ${err.message}`);
+        }
+      }
+      return fallback;
+    },
+
+    /**
+     * Performs a shallow sparse Git checkout of a single subdirectory from any
+     * GitHub repository into a local target directory.
+     *
+     * Uses `--depth 1 --no-checkout` + `git sparse-checkout` so only the
+     * requested path is fetched — no full clone of the remote repo.
+     * Skips the clone entirely when `<targetDir>/<subPath>` already exists on
+     * disk (idempotent).
+     *
+     * Requires `GITHUB_TOKEN` to be set in the environment for authenticated
+     * access to private repositories.
+     *
+     * @param {string} subPath - The subdirectory path within the remote repo to
+     *   check out (e.g. `'conf/dd-prototype'`, `'src/api/payments'`).
+     * @param {object} [options]
+     * @param {string} [options.repoOwner='underpostnet'] - GitHub organisation or
+     *   user that owns the repository.
+     * @param {string} [options.repoName='engine-private'] - Name of the
+     *   repository on GitHub.
+     * @param {string} [options.targetDir='./engine-private'] - Local directory
+     *   where the repo will be cloned.
+     * @returns {boolean} `true` when the checkout was performed, `false` when it
+     *   was skipped because the target path already existed.
+     * @memberof UnderpostRepository
+     */
+    sparseCheckoutDirectory(
+      subPath,
+      options = { repoOwner: 'underpostnet', repoName: 'engine-private', targetDir: './engine-private' },
+    ) {
+      const { repoOwner = 'underpostnet', repoName = 'engine-private', targetDir = './engine-private' } = options;
+      const localPath = `${targetDir}/${subPath}`;
+      if (fs.existsSync(localPath)) {
+        logger.info('[sparseCheckoutDirectory] path already present, skipping', localPath);
+        return false;
+      }
+      const authUrl = `https://${process.env.GITHUB_TOKEN}@github.com/${repoOwner}/${repoName}.git`;
+      shellExec(`git clone --depth 1 --no-checkout ${authUrl} ${targetDir}`, { disableLog: true });
+      shellExec(`cd ${targetDir} && git sparse-checkout set ${subPath} && git checkout`, { disableLog: true });
+      logger.info('[sparseCheckoutDirectory] sparse checkout complete', localPath);
+      return true;
+    },
+
+    /**
+     * Ensures a deploy's public source repo (e.g. `engine-prototype`) is present
+     * next to the engine and reset to a pristine HEAD, so catalog `sourceMoves`
+     * can (re)pull custom sources even after a previous build moved them out of
+     * the source tree.
+     *
+     * Clones `../<repoName>` when missing; otherwise restores a clean checkout
+     * (`git checkout .` brings back any moved-out tracked files) and pulls latest.
+     * Mirrors the sibling-repo handling used by `syncPrivateConf`.
+     *
+     * @param {string} repoName - Public source repo name (e.g. `engine-prototype`).
+     * @returns {boolean} `true` when the repo is available on disk.
+     * @memberof UnderpostRepository
+     */
+    pullSourceRepo(repoName) {
+      const username = process.env.GITHUB_USERNAME;
+      if (!username || !repoName) return false;
+      const repoPath = `../${repoName}`;
+      const gitUri = `${username}/${repoName}`;
+      if (!fs.existsSync(repoPath)) {
+        shellExec(`cd .. && underpost clone ${gitUri}`, { silent: true });
+      } else {
+        const repoAbsPath = path.resolve(repoPath);
+        shellExec(`git config --global --add safe.directory '${repoAbsPath}'`);
+        shellExec(`cd ${repoPath} && git checkout . && git clean -f -d && underpost pull . ${gitUri}`, {
+          silent: true,
+        });
+      }
+      return fs.existsSync(repoPath);
+    },
   };
 }