underpost 2.8.852 → 2.8.854

package/src/cli/db.js

@@ -3,6 +3,7 @@ import { loggerFactory } from '../server/logger.js';
 import { shellExec } from '../server/process.js';
 import fs from 'fs-extra';
 import UnderpostDeploy from './deploy.js';
+import UnderpostCron from './cron.js';
 
 const logger = loggerFactory(import.meta);
 
@@ -216,6 +217,129 @@ class UnderpostDB {
         }
       }
     },
+    async updateDashboardData(
+      deployId = process.env.DEFAULT_DEPLOY_ID,
+      host = process.env.DEFAULT_DEPLOY_HOST,
+      path = process.env.DEFAULT_DEPLOY_PATH,
+    ) {
+      try {
+        deployId = deployId ?? process.env.DEFAULT_DEPLOY_ID;
+        host = host ?? process.env.DEFAULT_DEPLOY_HOST;
+        path = path ?? process.env.DEFAULT_DEPLOY_PATH;
+
+        const { db } = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'))[host][
+          path
+        ];
+
+        await DataBaseProvider.load({ apis: ['instance'], host, path, db });
+
+        /** @type {import('../api/instance/instance.model.js').InstanceModel} */
+        const Instance = DataBaseProvider.instance[`${host}${path}`].mongoose.models.Instance;
+
+        await Instance.deleteMany();
+
+        for (const _deployId of deployList.split(',')) {
+          const deployId = _deployId.trim();
+          if (!deployId) continue;
+          const confServer = loadReplicas(
+            JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8')),
+            'proxy',
+          );
+          const router = await UnderpostDeploy.API.routerFactory(deployId, env);
+          const pathPortAssignmentData = pathPortAssignmentFactory(router, confServer);
+
+          for (const host of Object.keys(confServer)) {
+            for (const { path, port } of pathPortAssignmentData[host]) {
+              if (!confServer[host][path]) continue;
+
+              const { client, runtime, apis } = confServer[host][path];
+
+              const body = {
+                deployId,
+                host,
+                path,
+                port,
+                client,
+                runtime,
+                apis,
+              };
+
+              logger.info('save', body);
+
+              await new Instance(body).save();
+            }
+          }
+        }
+
+        await DataBaseProvider.instance[`${host}${path}`].mongoose.close();
+      } catch (error) {
+        logger.error(error, error.stack);
+      }
+
+      try {
+        const confServerPath = `./engine-private/conf/${deployId}/conf.server.json`;
+        const confServer = JSON.parse(fs.readFileSync(confServerPath, 'utf8'));
+        const { db } = confServer[host][path];
+
+        await DataBaseProvider.load({ apis: ['cron'], host, path, db });
+
+        /** @type {import('../api/cron/cron.model.js').CronModel} */
+        const Cron = DataBaseProvider.instance[`${host}${path}`].mongoose.models.Cron;
+
+        await Cron.deleteMany();
+
+        for (const cronInstance of UnderpostCron.NETWORK) {
+          logger.info('save', cronInstance);
+          await new Cron(cronInstance).save();
+        }
+
+        await DataBaseProvider.instance[`${host}${path}`].mongoose.close();
+      } catch (error) {
+        logger.error(error, error.stack);
+      }
+    },
+    clusterMetadataBackupCallback(
+      deployId = process.env.DEFAULT_DEPLOY_ID,
+      host = process.env.DEFAULT_DEPLOY_HOST,
+      path = process.env.DEFAULT_DEPLOY_PATH,
+      options = {
+        import: false,
+        export: false,
+        instances: false,
+        crons: false,
+      },
+    ) {
+      deployId = deployId ?? process.env.DEFAULT_DEPLOY_ID;
+      host = host ?? process.env.DEFAULT_DEPLOY_HOST;
+      path = path ?? process.env.DEFAULT_DEPLOY_PATH;
+
+      if (options.instances === true) {
+        const outputPath = './engine-private/instances';
+        if (fs.existsSync(outputPath)) fs.mkdirSync(outputPath, { recursive: true });
+        const collection = 'instances';
+        if (options.export === true)
+          shellExec(
+            `node bin db --export --collections ${collection} --out-path ${outputPath} --hosts ${host} --paths '${path}' ${deployId}`,
+          );
+        if (options.import === true)
+          shellExec(
+            `node bin db --import --drop --preserveUUID --out-path ${outputPath} --hosts ${host} --paths '${path}' ${deployId}`,
+          );
+      }
+      if (options.crons === true) {
+        const outputPath = './engine-private/crons';
+        if (fs.existsSync(outputPath)) fs.mkdirSync(outputPath, { recursive: true });
+        const collection = 'crons';
+        if (options.export === true)
+          shellExec(
+            `node bin db --export --collections ${collection} --out-path ${outputPath} --hosts ${host} --paths '${path}' ${deployId}`,
+          );
+        if (options.import === true)
+          shellExec(
+            `node bin db --import --drop --preserveUUID --out-path ${outputPath} --hosts ${host} --paths '${path}' ${deployId}`,
+          );
+      }
+    },
   };
 }
 

package/src/cli/deploy.js

@@ -242,12 +242,10 @@ spec:
         cert: false,
         versions: '',
         traffic: '',
-        dashboardUpdate: false,
         replicas: '',
         restoreHosts: false,
         disableUpdateDeployment: false,
         infoTraffic: false,
-        rebuildClientsBundle: false,
       },
     ) {
       if (options.infoUtil === true)
@@ -311,18 +309,20 @@ Password: <Your Key>
             deployId,
             env,
             traffic: UnderpostDeploy.API.getCurrentTraffic(deployId),
+            router: await UnderpostDeploy.API.routerFactory(deployId, env),
+            pods: await UnderpostDeploy.API.get(deployId),
           });
         }
         return;
       }
-      if (options.rebuildClientsBundle === true) await UnderpostDeploy.API.rebuildClientsBundle(deployList);
       if (!(options.versions && typeof options.versions === 'string')) options.versions = 'blue,green';
       if (!options.replicas) options.replicas = 1;
       if (options.sync) UnderpostDeploy.API.sync(deployList, options);
       if (options.buildManifest === true) await UnderpostDeploy.API.buildManifest(deployList, env, options);
-      if (options.infoRouter === true) logger.info('router', await UnderpostDeploy.API.routerFactory(deployList, env));
-      if (options.dashboardUpdate === true) await UnderpostDeploy.API.updateDashboardData(deployList, env, options);
-      if (options.infoRouter === true) return;
+      if (options.infoRouter === true) {
+        logger.info('router', await UnderpostDeploy.API.routerFactory(deployList, env));
+        return;
+      }
       shellExec(`kubectl delete configmap underpost-config`);
       shellExec(
         `kubectl create configmap underpost-config --from-file=/home/dd/engine/engine-private/conf/dd-cron/.env.${env}`,
@@ -435,23 +435,6 @@ Password: <Your Key>
 
       return result;
     },
-    rebuildClientsBundle(deployList) {
-      for (const _deployId of deployList.split(',')) {
-        const deployId = _deployId.trim();
-        const repoName = `engine-${deployId.split('-')[1]}`;
-
-        shellExec(`underpost script set ${deployId}-client-build '
-cd /home/dd/engine &&
-git checkout . &&
-underpost pull . underpostnet/${repoName} &&
-underpost pull ./engine-private underpostnet/${repoName}-private &&
-underpost env ${deployId} production &&
-node bin/deploy build-full-client ${deployId}
-'`);
-
-        shellExec(`node bin script run ${deployId}-client-build --itc --pod-name ${deployId}`);
-      }
-    },
     resourcesFactory() {
       return {
         requests: {
@@ -465,60 +448,6 @@ node bin/deploy build-full-client ${deployId}
         totalPods: UnderpostRootEnv.API.get('total-pods'),
       };
     },
-    async updateDashboardData(deployList, env, options) {
-      try {
-        const deployId = process.env.DEFAULT_DEPLOY_ID;
-        const host = process.env.DEFAULT_DEPLOY_HOST;
-        const path = process.env.DEFAULT_DEPLOY_PATH;
-        const { db } = JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8'))[host][
-          path
-        ];
-
-        await DataBaseProvider.load({ apis: ['instance'], host, path, db });
-
-        /** @type {import('../api/instance/instance.model.js').InstanceModel} */
-        const Instance = DataBaseProvider.instance[`${host}${path}`].mongoose.models.Instance;
-
-        await Instance.deleteMany();
-
-        for (const _deployId of deployList.split(',')) {
-          const deployId = _deployId.trim();
-          if (!deployId) continue;
-          const confServer = loadReplicas(
-            JSON.parse(fs.readFileSync(`./engine-private/conf/${deployId}/conf.server.json`, 'utf8')),
-            'proxy',
-          );
-          const router = await UnderpostDeploy.API.routerFactory(deployId, env);
-          const pathPortAssignmentData = pathPortAssignmentFactory(router, confServer);
-
-          for (const host of Object.keys(confServer)) {
-            for (const { path, port } of pathPortAssignmentData[host]) {
-              if (!confServer[host][path]) continue;
-
-              const { client, runtime, apis } = confServer[host][path];
-
-              const body = {
-                deployId,
-                host,
-                path,
-                port,
-                client,
-                runtime,
-                apis,
-              };
-
-              logger.info('save', body);
-
-              await new Instance(body).save();
-            }
-          }
-        }
-
-        await DataBaseProvider.instance[`${host}${path}`].mongoose.close();
-      } catch (error) {
-        logger.error(error, error.stack);
-      }
-    },
     existsContainerFile({ podName, path }) {
       return JSON.parse(
         shellExec(`kubectl exec ${podName} -- test -f ${path} && echo "true" || echo "false"`, {

package/src/cli/index.js

@@ -123,6 +123,11 @@ program
   .option('--full', 'Initializes the cluster with all available statefulsets and services.')
   .option('--ns-use <ns-name>', 'Switches the current Kubernetes context to the specified namespace.')
   .option('--kubeadm', 'Initializes the cluster using kubeadm for control plane management.')
+  .option('--grafana', 'Initializes the cluster with a Grafana deployment.')
+  .option(
+    '--prom [hosts]',
+    'Initializes the cluster with a Prometheus Operator deployment and monitor scrap for specified hosts.',
+  )
   .option('--dev', 'Initializes a development-specific cluster configuration.')
   .option('--list-pods', 'Displays detailed information about all pods.')
   .option('--info-capacity', 'Displays the current total machine capacity information.')
@@ -155,7 +160,6 @@ program
     '--build-manifest',
     'Builds Kubernetes YAML manifests, including deployments, services, proxies, and secrets.',
   )
-  .option('--dashboard-update', 'Updates dashboard instance data with the current router configuration.')
   .option('--replicas <replicas>', 'Sets a custom number of replicas for deployments.')
   .option('--versions <deployment-versions>', 'A comma-separated list of custom deployment versions.')
   .option('--traffic <traffic-versions>', 'A comma-separated list of custom deployment traffic weights.')
@@ -163,10 +167,6 @@ program
   .option('--info-traffic', 'Retrieves traffic configuration from current resource deployments.')
   .option('--kubeadm', 'Enables the kubeadm context for deployment operations.')
   .option('--restore-hosts', 'Restores default `/etc/hosts` entries.')
-  .option(
-    '--rebuild-clients-bundle',
-    'Inside the container, rebuilds client bundles (only static public or storage client files).',
-  )
   .description('Manages application deployments, defaulting to deploying development pods.')
   .action(Underpost.deploy.callback);
 
@@ -240,6 +240,18 @@ program
   .description('Manages database operations, including import, export, and collection management.')
   .action(Underpost.db.callback);
 
+program
+  .command('metadata')
+  .argument('[deploy-id]', 'The deployment ID to manage metadata.')
+  .argument('[host]', 'The host to manage metadata.')
+  .argument('[path]', 'The path to manage metadata.')
+  .option('--import', 'Imports from local storage.')
+  .option('--export', 'Exports to local storage.')
+  .option('--crons', 'Apply to cron data collection')
+  .option('--instances', 'Apply to instance data collection')
+  .description('Manages cluster metadata operations, including import and export.')
+  .action(Underpost.db.clusterMetadataBackupCallback);
+
 // 'script' command: Execute scripts
 program
   .command('script')
@@ -268,7 +280,6 @@ program
   .option('--itc', 'Executes cron jobs within the container execution context.')
   .option('--init', 'Initializes cron jobs for the default deployment ID.')
   .option('--git', 'Uploads cron job configurations to GitHub.')
-  .option('--dashboard-update', 'Updates dashboard cron data with the current job configurations.')
   .description('Manages cron jobs, including initialization, execution, and configuration updates.')
   .action(Underpost.cron.callback);
 

package/src/cli/run.js

@@ -76,6 +76,11 @@ class UnderpostRun {
       shellExec(`${baseCommand} deploy --expose mongo`, { async: true });
       shellExec(`${baseCommand} deploy --expose valkey`, { async: true });
     },
+    'ssh-cluster-info': (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      const { underpostRoot } = options;
+      shellExec(`chmod +x ${underpostRoot}/manifests/maas/ssh-cluster-info.sh`);
+      shellExec(`${underpostRoot}/manifests/maas/ssh-cluster-info.sh`);
+    },
     'cyberia-ide': (path, options = UnderpostRun.DEFAULT_OPTION) => {
       const baseCommand = options.dev ? 'node bin' : 'underpost';
       shellExec(`${baseCommand} run ide /home/dd/cyberia-server`);
@@ -93,6 +98,19 @@ class UnderpostRun {
       shellExec(`${baseCommand} cmt . --empty ci package-pwa-microservices-template`);
       shellExec(`${baseCommand} push . underpostnet/engine`);
     },
+    clean: (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      shellCd(path ?? `/home/dd/engine`);
+      shellExec(`node bin/deploy clean-core-repo`);
+    },
+    upgrade: (path, options = UnderpostRun.DEFAULT_OPTION) => {
+      const { underpostRoot } = options;
+      shellExec(`npm install -g underpost`);
+      shellExec(`underpost run secret`);
+      shellCd(`/home/dd/engine`);
+      shellExec(`node bin/deploy clean-core-repo`);
+      shellExec(`underpost pull . underpostnet/engine`);
+      shellExec(`underpost pull engine-private underpostnet/engine-private`, { silent: true });
+    },
     'ssh-deploy': (path, options = UnderpostRun.DEFAULT_OPTION) => {
       const baseCommand = options.dev || true ? 'node bin' : 'underpost';
       shellCd('/home/dd/engine');

package/src/client/Default.index.js

@@ -15,7 +15,6 @@ import { DefaultParams } from './components/default/CommonDefault.js';
 import { SocketIo } from './components/core/SocketIo.js';
 import { SocketIoDefault } from './components/default/SocketIoDefault.js';
 import { ElementsDefault } from './components/default/ElementsDefault.js';
-import { Scroll } from './components/core/Scroll.js';
 import { CssDefaultDark, CssDefaultLight } from './components/default/CssDefault.js';
 
 const htmlMainBody = async () => {
@@ -39,7 +38,6 @@ window.onload = () =>
       await LogInDefault();
       await LogOutDefault();
       await SignUpDefault();
-      await Scroll.pullTopRefresh();
       await Keyboard.Init({ callBackTime: DefaultParams.EVENT_CALLBACK_TIME });
     },
   });

package/src/client/components/core/Account.js

@@ -10,7 +10,7 @@ import { Modal } from './Modal.js';
 import { NotificationManager } from './NotificationManager.js';
 import { Translate } from './Translate.js';
 import { Validator } from './Validator.js';
-import { append, htmls, s } from './VanillaJs.js';
+import { append, getProxyPath, htmls, s } from './VanillaJs.js';
 
 const Account = {
   UpdateEvent: {},

package/src/client/components/core/Modal.js

@@ -502,7 +502,7 @@ const Modal = {
                       class="abs modal slide-menu-top-bar-fix"
                       style="height: ${options.heightTopBar}px; top: 0px"
                     >
-                      <a class="a-link-top-banner">
+                      <a class="a-link-top-banner fl">
                         <div class="inl">${await options.slideMenuTopBarBannerFix()}</div></a
                       >
                     </div>`
@@ -1160,7 +1160,7 @@ const Modal = {
                   if (s(`.slide-menu-top-bar-fix`)) {
                     htmls(
                       `.slide-menu-top-bar-fix`,
-                      html`<a class="a-link-top-banner">${await options.slideMenuTopBarBannerFix()}</a>`,
+                      html`<a class="a-link-top-banner fl">${await options.slideMenuTopBarBannerFix()}</a>`,
                     );
                     Modal.setTopBannerLink();
                   }

package/src/client/components/core/Recover.js

@@ -80,9 +80,10 @@ const Recover = {
         }
         switch (mode) {
           case 'recover-verify-email': {
-            body.proxyPath = getProxyPath();
-            body.hostname = `${location.hostname}`;
-            const result = await UserService.post({ id: 'recover-verify-email', body });
+            const result = await UserService.post({
+              id: 'recover-verify-email',
+              body: { ...body, proxyPath: getProxyPath(), hostname: `${location.hostname}` },
+            });
             NotificationManager.Push({
               html:
                 result.status === 'error' ? result.message : Translate.Render(`${result.status}-recover-verify-email`),

package/src/client/components/core/Scroll.js

@@ -1,131 +1,76 @@
-import { borderChar } from './Css.js';
-import { Modal } from './Modal.js';
-import { append, s } from './VanillaJs.js';
+import { s } from './VanillaJs.js';
 
-const Scroll = {
-  data: {},
-  init: function (selector) {
-    s(selector).addEventListener('scroll', Scroll.scrollHandler);
-    Scroll.data[selector] = {
-      element: s(selector),
+class Scroll {
+  /**
+   * Attach scroll listener to an element (resolved with s(selector)).
+   * @param {string} selector - selector passed to s(selector)
+   * @param {function} [callback] - callback function to be called on scroll
+   * @param {object} options
+   * @param {number} [options.threshold=1] - px margin to treat as bottom
+   * @param {number} [options.precision=3] - decimal places for percentages
+   */
+  static setEvent(selector, callback = async () => {}, options = { threshold: 1, precision: 3 }) {
+    const el = s(selector);
+    if (!el) return;
+
+    const threshold = options.threshold ?? 1; // px tolerance for bottom detection
+    const precision = options.precision ?? 3;
+    let ticking = false;
+
+    const round = (v) => {
+      const m = Math.pow(10, precision);
+      return Math.round(v * m) / m;
     };
-    return Scroll.data[selector];
-  },
-  getScrollPosition: function (selector) {
-    // Scroll.data[selector].element.clientHeight -
-    return Scroll.data[selector].element.scrollTop;
-  },
-  scrollHandler: async function () {
-    for (const selector in Scroll.data) await Scroll.data[selector].callback(Scroll.getScrollPosition(selector));
-  },
-  addEvent: function (selector = '', callback = (position = 0) => {}) {
-    Scroll.data[selector].callback = callback;
-  },
-  removeEvent: function (selector) {
-    delete Scroll.data[selector];
-  },
-  to: function (elector = '', options = { top: 100, left: 100, behavior: 'smooth' }) {
-    Scroll.data[selector].element.scrollTo({
-      top: options.top || Scroll.getScrollPosition(selector),
-      left: options.left || 0,
-      behavior: options.behavior || 'smooth',
-    });
-  },
-  topRefreshEvents: {},
-  addTopRefreshEvent: function (options = { id: '', callback: () => {}, condition: () => {} }) {
-    this.topRefreshEvents[options.id] = options;
-  },
-  removeTopRefreshEvent: function (id = '') {
-    delete this.topRefreshEvents[id];
-  },
-  pullTopRefresh: function () {
-    return;
-    append(
-      'body',
-      html` <style>
-          .pull-refresh-icon-container {
-            height: 60px;
-            width: 100%;
-            z-index: 10;
-            transition: 0.3s;
-            left: 0px;
-          }
-          .pull-refresh-icon {
-            width: 60px;
-            height: 60px;
-            margin: auto;
-            color: white;
-            font-size: 30px;
-          }
-        </style>
-        ${borderChar(2, 'black', [' .pull-refresh-icon-container'])}
-        <div style="top: -60px" class="abs pull-refresh-icon-container">
-          <div class="in pull-refresh-icon">
-            <div class="abs center"><i class="fa-solid fa-arrows-rotate"></i></div>
-          </div>
-        </div>`,
-    );
 
-    let touchstartY = 0;
-    let reload = false;
-    const minHeightDragReload = 3;
-    const maxHeightDragReload = 20;
+    const listener = (event) => {
+      if (ticking) return;
+      ticking = true;
+
+      requestAnimationFrame(() => {
+        const scrollHeight = el.scrollHeight;
+        const clientHeight = el.clientHeight;
+        const scrollTop = el.scrollTop;
+
+        // pixels left to scroll (clamped to >= 0)
+        const remaining = Math.max(0, scrollHeight - clientHeight - scrollTop);
 
-    document.addEventListener('touchstart', (e) => {
-      touchstartY = e.touches[0].clientY;
-      // console.warn('touchstart', touchstartY);
-    });
+        // maximum possible remaining (0 if content fits without scrolling)
+        const maxRemaining = Math.max(0, scrollHeight - clientHeight);
 
-    document.addEventListener('touchmove', (e) => {
-      if (
-        !Object.keys(Scroll.topRefreshEvents).find((event) => Scroll.topRefreshEvents[event].condition()) ||
-        (!s(`.btn-bar-center-icon-close`).classList.contains('hide') &&
-          !s(
-            `.btn-icon-menu-mode-${Modal.Data['modal-menu'].options.mode !== 'slide-menu-right' ? 'left' : 'right'}`,
-          ).classList.contains('hide'))
-      )
-        return;
+        // percentRemaining: 1 = top (all remaining), 0 = bottom (none remaining)
+        let percentRemaining = maxRemaining === 0 ? 0 : remaining / maxRemaining;
+        percentRemaining = Math.max(0, Math.min(1, percentRemaining));
 
-      const touchY = e.touches[0].clientY;
-      const touchDiff = touchY - touchstartY;
+        // percentScrolled: complementary value (0 = top, 1 = bottom)
+        let percentScrolled = 1 - percentRemaining;
+        percentScrolled = Math.max(0, Math.min(1, percentScrolled));
 
-      // console.warn('touchDiff', touchDiff, maxHeightDragReload);
+        const payload = {
+          scrollHeight,
+          clientHeight,
+          scrollTop,
+          remaining, // px left (>= 0)
+          scrollBottom: remaining <= threshold ? 0 : remaining,
+          atBottom: remaining <= threshold,
+          percentRemaining: round(percentRemaining), // 0..1
+          percentScrolled: round(percentScrolled), // 0..1
+        };
 
-      if (touchDiff > maxHeightDragReload)
-        s(`.pull-refresh-icon-container`).style.top = 60 + maxHeightDragReload + 'px';
-      else s(`.pull-refresh-icon-container`).style.top = 60 + touchDiff + 'px';
+        // replace this with an event dispatch or callback if you prefer
+        // console.warn('scroll', event, JSON.stringify(payload, null, 2));
+        callback(payload);
 
-      if (touchDiff > minHeightDragReload && window.scrollY === 0) {
-        reload = true;
-      } else {
-        reload = false;
-      }
-    });
-    document.addEventListener('touchend', (e) => {
-      // console.warn('touchend');
-      s(`.pull-refresh-icon-container`).style.top = '-60px';
-      if (reload) {
-        for (const event of Object.keys(Scroll.topRefreshEvents))
-          if (Scroll.topRefreshEvents[event].condition()) Scroll.topRefreshEvents[event].callback();
-      }
-      reload = false;
-    });
-    Scroll.addTopRefreshEvent({
-      id: 'main-body',
-      callback: () => {
-        location.reload();
-      },
-      condition: () => {
-        return (
-          s('.main-body') &&
-          s('.main-body').scrollTop === 0 &&
-          !Object.keys(Modal.Data).find(
-            (idModal) => !['modal-menu', 'main-body', 'bottom-bar', 'main-body-top'].includes(idModal),
-          )
-        );
-      },
-    });
-  },
-};
+        ticking = false;
+      });
+    };
+
+    el.addEventListener('scroll', listener, { passive: true });
+
+    return {
+      removeEvent: () => el.removeEventListener('scroll', listener),
+    };
+  }
+}
 
 export { Scroll };
+export default Scroll;

package/src/index.js

@@ -35,7 +35,7 @@ class Underpost {
    * @type {String}
    * @memberof Underpost
    */
-  static version = 'v2.8.852';
+  static version = 'v2.8.854';
   /**
    * Repository cli API
    * @static