@abtnode/core 1.6.17 → 1.6.21

package/lib/event.js

@@ -132,7 +132,7 @@ module.exports = ({
     onEvent(name, blocklet);
   };
 
-  const handleCLIEvent = (eventName) => {
+  const handleServerEvent = (eventName) => {
     const [, status] = eventName.split('.');
     onEvent(eventName, {
       title: `Blocklet Server ${status}`,
@@ -209,7 +209,8 @@ module.exports = ({
 
   events.handleBlockletAdd = handleBlockletAdd;
   events.handleBlockletRemove = handleBlockletRemove;
-  events.handleCLIEvent = handleCLIEvent;
+  events.handleServerEvent = handleServerEvent;
+  events.onEvent = onEvent;
 
   return events;
 };

package/lib/index.js

@@ -147,7 +147,7 @@ function ABTNode(options) {
     getCertificates,
     getSitesFromSnapshot,
     getRoutingCrons,
-    ensureDashboardCertificate,
+    ensureWildcardCerts,
   } = getRouterHelpers({ dataDirs, routingSnapshot, routerManager, blockletManager, certManager });
 
   const teamManager = new TeamManager({ nodeDid: options.nodeDid, dataDirs, states });
@@ -208,7 +208,6 @@ function ABTNode(options) {
     upgradeBlocklet: blockletManager.upgrade.bind(blockletManager),
     configBlocklet: blockletManager.config.bind(blockletManager),
     devBlocklet: blockletManager.dev.bind(blockletManager),
-    getBlockletStatus: blockletManager.getStatus.bind(blockletManager),
     checkChildBlockletsForUpdates: blockletManager.checkChildrenForUpdates.bind(blockletManager),
     updateChildBlocklets: blockletManager.updateChildren.bind(blockletManager),
     getLatestBlockletVersion: blockletManager.getLatestBlockletVersion.bind(blockletManager),
@@ -319,7 +318,7 @@ function ABTNode(options) {
     takeRoutingSnapshot,
     getSitesFromSnapshot,
     ensureDashboardRouting,
-    ensureDashboardCertificate,
+    ensureWildcardCerts,
 
     addDomainAlias: routerManager.addDomainAlias.bind(routerManager),
     deleteDomainAlias: routerManager.deleteDomainAlias.bind(routerManager),

package/lib/migrations/1.6.21-rename-ip-echo-domain.js

@@ -0,0 +1,27 @@
+const yaml = require('js-yaml');
+const fs = require('fs');
+const set = require('lodash/set');
+const omit = require('lodash/omit');
+const { DEFAULT_WILDCARD_CERT_HOST, DEFAULT_DID_DOMAIN, DEFAULT_DID_REGISTRY } = require('@abtnode/constant');
+
+module.exports = async ({ states, printInfo, configFile }) => {
+  printInfo('Try to rename dashboardDomain to ipWildcardDomain in db...');
+
+  let info = await states.node.read();
+  set(info, 'routing.ipWildcardDomain', info.routing.dashboardDomain);
+  set(info, 'routing.wildcardCertHost', DEFAULT_WILDCARD_CERT_HOST);
+  set(info, 'didDomain', DEFAULT_DID_DOMAIN);
+  set(info, 'didRegistry', DEFAULT_DID_REGISTRY);
+  info = omit(info, 'routing.dashboardDomain');
+
+  await states.node.updateNodeInfo(info);
+
+  let rawConfig = yaml.safeLoad(fs.readFileSync(configFile).toString());
+  set(rawConfig, 'node.routing.ipWildcardDomain', info.routing.ipWildcardDomain);
+  set(rawConfig, 'node.routing.wildcardCertHost', DEFAULT_WILDCARD_CERT_HOST);
+  set(rawConfig, 'node.didDomain', DEFAULT_DID_DOMAIN);
+  set(rawConfig, 'node.didRegistry', DEFAULT_DID_REGISTRY);
+  rawConfig = omit(rawConfig, 'node.routing.dashboardDomain');
+  fs.writeFileSync(configFile, yaml.dump(rawConfig));
+  printInfo(`> Persist new config to file: ${configFile}`);
+};

package/lib/router/helper.js

@@ -419,6 +419,13 @@ const decompressCertificates = async (source, dest) => {
   return dest;
 };
 
+const joinCertDownUrl = (baseUrl, name) => joinUrl(baseUrl, '/certs', name);
+
+const getIpEchoCertDownloadUrl = (baseUrl) => joinCertDownUrl(baseUrl, 'ip-abtnet-io.tar.gz');
+const getDidDomainCertDownloadUrl = (baseUrl) => joinCertDownUrl(baseUrl, 'did-abtnet-io.tar.gz');
+const getDownloadCertBaseUrl = (info) =>
+  process.env.ABT_NODE_WILDCARD_CERT_HOST || get(info, 'routing.wildcardCertHost', '');
+
 module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerManager, blockletManager, certManager }) {
   const nodeState = states.node;
   const blockletState = states.blocklet;
@@ -428,46 +435,13 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
   // site level duplication detection
   const hasRuleByPrefix = (site, value) => site.rules.find((x) => x.isProtected && get(x, 'from.pathPrefix') === value);
 
-  const updateDashboardCertificate = async ({ checkExpire = true }) => {
-    const info = await nodeState.read();
-    const provider = getProviderFromNodeInfo(info);
-    if (provider === ROUTER_PROVIDER_NONE) {
-      return;
-    }
-
-    const https = get(info, 'routing.https', true);
-    const dashboardDomain = get(info, 'routing.dashboardDomain', '');
-    const certDownloadAddress =
-      process.env.ABT_NODE_DASHBOARD_CERT_DOWN_URL || get(info, 'routing.dashboardCertDownloadAddress', '');
-    if (!https || !dashboardDomain || !certDownloadAddress) {
-      return;
-    }
-
-    if (checkExpire) {
-      try {
-        const cert = await routerManager.findCertificateByDomain(dashboardDomain);
-        if (!cert) {
-          return;
-        }
-
-        const now = Date.now();
-        const certInfo = getHttpsCertInfo(cert.certificate);
-        if (certInfo.validTo - now >= CERTIFICATE_EXPIRES_OFFSET) {
-          logger.info('skip dashboard certificate update before not expired');
-          return;
-        }
-      } catch (err) {
-        logger.error('failed to check dashboard certificate expiration', { error: err });
-        return;
-      }
-    }
-
+  const downloadCert = async ({ domain, url }) => {
     const destFolder = getTmpDirectory(path.join(`certificate-${Date.now()}`));
     try {
       const filename = path.join(destFolder, 'certificate.tar.gz');
       fs.ensureDirSync(destFolder);
 
-      await downloadFile(certDownloadAddress, filename);
+      await downloadFile(url, filename);
       await decompressCertificates(filename, destFolder);
 
       const certificateFilePath = path.join(destFolder, 'cert.pem');
@@ -485,7 +459,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
       const privateKey = fs.readFileSync(privateKeyFilePath).toString();
 
       await certManager.upsertByDomain({
-        domain: dashboardDomain,
+        domain,
         privateKey,
         certificate,
         isProtected: true,
@@ -499,23 +473,68 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     }
   };
 
-  const ensureDashboardCertificate = async () => {
+  const updateCert = async (domain, url) => {
+    try {
+      const cert = await routerManager.findCertificateByDomain(domain);
+      if (!cert) {
+        return;
+      }
+
+      const now = Date.now();
+      const certInfo = getHttpsCertInfo(cert.certificate);
+      if (certInfo.validTo - now >= CERTIFICATE_EXPIRES_OFFSET) {
+        logger.info('skip dashboard certificate update before not expired', { domain, url });
+        return;
+      }
+
+      await downloadCert({
+        domain,
+        url,
+      });
+    } catch (err) {
+      logger.error('failed to check dashboard certificate expiration', { error: err, domain, url });
+    }
+  };
+
+  const updateDashboardCertificates = async () => {
     const info = await nodeState.read();
-    const downloadUrl = get(info, 'routing.dashboardCertDownloadAddress', '');
-    const dashboardDomain = get(info, 'routing.dashboardDomain', '');
-    if (!dashboardDomain || !downloadUrl) {
-      throw new Error('dashboardCertDownloadAddress and dashboardDomain are not found in the routing configs');
+    const provider = getProviderFromNodeInfo(info);
+    if (provider === ROUTER_PROVIDER_NONE) {
+      return;
     }
 
-    const cert = await certManager.getByDomain(dashboardDomain);
-    if (cert) {
-      return { status: 'existed' };
+    const https = get(info, 'routing.https', true);
+    const ipWildcardDomain = get(info, 'routing.ipWildcardDomain', '');
+    const didDomain = info.didDomain;
+    const certDownloadAddress = getDownloadCertBaseUrl(info);
+    if (!https || !certDownloadAddress) {
+      return;
     }
 
-    logger.debug('downloading dashboard ip-domain certificate', { url: downloadUrl, dashboardDomain });
-    await updateDashboardCertificate({ checkExpire: false });
-    logger.debug('downloaded dashboard ip-domain certificate', { url: downloadUrl, dashboardDomain });
-    return { status: 'downloaded' };
+    await updateCert(ipWildcardDomain, getIpEchoCertDownloadUrl(certDownloadAddress));
+    await updateCert(`*.${didDomain}`, getDidDomainCertDownloadUrl(certDownloadAddress));
+  };
+
+  const ensureWildcardCerts = async () => {
+    const info = await nodeState.read();
+    const didDomain = info.didDomain;
+    const ipWildcardDomain = get(info, 'routing.ipWildcardDomain', '');
+
+    const ensureDomainCert = async (domain, url) => {
+      const cert = await certManager.getByDomain(domain);
+      if (!cert) {
+        await downloadCert({
+          domain,
+          url,
+        });
+      }
+    };
+
+    const certBaseUrl = getDownloadCertBaseUrl(info);
+    await Promise.all([
+      ensureDomainCert(ipWildcardDomain, getIpEchoCertDownloadUrl(certBaseUrl)),
+      ensureDomainCert(`*.${didDomain}`, getDidDomainCertDownloadUrl(certBaseUrl)),
+    ]);
   };
 
   const upsertSiteRule = async ({ site, rule }, context) => {
@@ -658,9 +677,11 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
         return domainAlias === item;
       });
 
-    const dashboardDomain = get(info, 'routing.dashboardDomain', '');
+    const ipWildcardDomain = get(info, 'routing.ipWildcardDomain', '');
     const didDomain = `${info.did.toLowerCase()}.${info.didDomain}`;
-    const dashboardAliasDomains = [dashboardDomain, didDomain]
+    let dashboardAliasDomains = [ipWildcardDomain, didDomain];
+
+    dashboardAliasDomains = dashboardAliasDomains
       .filter((item) => item && !isExistsInAlias(item))
       .map((item) => ({ value: item, isProtected: true }));
 
@@ -746,18 +767,18 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
 
     const existSite = await states.site.findOne({ domain: domainGroup });
     if (!existSite) {
-      const ipEchoDnsDomain = getIpDnsDomainForBlocklet(blocklet, webInterface, nodeInfo.did);
-      const appIdEnv = blocklet.environments.find((e) => e.key === 'BLOCKLET_APP_ID');
-      const domainAliases = [{ value: ipEchoDnsDomain, isProtected: true }];
+      const domainAliases = [];
 
       const didDomain = getDidDomainForBlocklet({
-        appId: appIdEnv.value,
+        name: blocklet.meta.name,
+        daemonDid: nodeInfo.did,
         didDomain: nodeInfo.didDomain,
       });
 
-      if (blocklet.mode !== 'development') {
-        domainAliases.push({ value: didDomain, isProtected: true });
-      }
+      const ipEchoDnsDomain = getIpDnsDomainForBlocklet(blocklet, webInterface, nodeInfo.did);
+
+      // let didDomain in front of ipEchoDnsDomain
+      domainAliases.push({ value: didDomain, isProtected: true }, { value: ipEchoDnsDomain, isProtected: true });
 
       await routerManager.addRoutingSite(
         {
@@ -1386,7 +1407,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
     getSitesFromSnapshot,
     getCertificates,
     checkDomain,
-    ensureDashboardCertificate,
+    ensureWildcardCerts,
     addWellknownSite,
     upsertSiteRule,
 
@@ -1394,7 +1415,7 @@ module.exports = function getRouterHelpers({ dataDirs, routingSnapshot, routerMa
       {
         name: 'update-dashboard-certificate',
         time: '0 1 */6 * * *', // refetch on 0:00, 6:00, etc.
-        fn: () => updateDashboardCertificate({ checkExpire: true }),
+        fn: () => updateDashboardCertificates(),
         options: { runOnInit: true },
       },
       {

package/lib/router/index.js

@@ -60,12 +60,12 @@ const getRoutingTable = ({ sites, nodeInfo }) => {
   let routingTable = Router.formatSites(sites);
   routingTable = expandSites(routingTable);
 
-  // put dashboardDomain to last, to let blockletDomain match first
+  // put ipWildcardDomain to last, to let blockletDomain match first
   // e.g.
-  //  dashboardDomain: 192-168-3-2.ip.abtnet.io
+  //  ipWildcardDomain: 192-168-3-2.ip.abtnet.io
   //  blockletDomain: static-demo-xxx-192-168-3-2.ip.abtnet.io
-  const dashboardDomain = get(nodeInfo, 'routing.dashboardDomain', '');
-  const index = routingTable.findIndex((x) => x.domain === dashboardDomain);
+  const ipWildcardDomain = get(nodeInfo, 'routing.ipWildcardDomain', '');
+  const index = routingTable.findIndex((x) => x.domain === ipWildcardDomain);
   if (index > -1) {
     routingTable.push(...routingTable.splice(index, 1));
   }
@@ -219,11 +219,11 @@ Router.formatSites = (sites = []) => {
 
 Router.flattenSitesToRules = (sites = [], info = {}) => {
   const result = [];
-  const dashboardDomain = get(info, 'routing.dashboardDomain', DEFAULT_DASHBOARD_DOMAIN);
+  const ipWildcardDomain = get(info, 'routing.ipWildcardDomain', DEFAULT_DASHBOARD_DOMAIN);
   sites.forEach((site) => {
     const aliases = (site.domainAliases || [])
       .map((x) => (typeof x === 'string' ? x : x.value))
-      .filter((x) => x !== dashboardDomain)
+      .filter((x) => x !== ipWildcardDomain)
       .filter(Boolean);
 
     if (Array.isArray(site.rules) && site.rules.length > 0) {

package/lib/router/manager.js

@@ -221,10 +221,10 @@ class RouterManager extends EventEmitter {
       }
     }
 
-    const updateResult = await states.site.update(
-      { _id: id },
-      { $push: { domainAliases: { value: domainAlias, isProtected: false } } }
-    );
+    // let custom domain in front of protected domain
+    const domainAliases = [{ value: domainAlias, isProtected: false }, ...dbSite.domainAliases];
+
+    const updateResult = await states.site.update({ _id: id }, { $set: { domainAliases } });
     logger.debug('add domain alias update result', { id, updateResult, domainAlias });
 
     const newSite = await states.site.findOne({ _id: id });

package/lib/states/blocklet.js

@@ -20,7 +20,7 @@ const {
 const logger = require('@abtnode/logger')('state-blocklet');
 
 const BaseState = require('./base');
-const { forEachBlocklet } = require('../util/blocklet');
+const { forEachBlocklet, checkDuplicateComponents } = require('../util/blocklet');
 const { validateBlockletMeta } = require('../util');
 
 const lock = new Lock('blocklet-port-assign-lock');
@@ -80,7 +80,11 @@ class BlockletState extends BaseState {
 
   getBlocklet(did) {
     return new Promise((resolve, reject) => {
-      this.db.findOne({ 'meta.did': did }, (err, doc) => {
+      if (!did) {
+        resolve(null);
+      }
+
+      this.db.findOne({ $or: [{ 'meta.did': did }, { appDid: did }] }, (err, doc) => {
         if (err) {
           return reject(err);
         }
@@ -160,6 +164,7 @@ class BlockletState extends BaseState {
             // add to db
             this.db.insert(
               {
+                appDid: null, // will updated later when updating blocklet environments
                 mode,
                 meta: omit(sanitized, ['htmlAst']),
                 status,
@@ -391,13 +396,20 @@ class BlockletState extends BaseState {
     return result;
   }
 
-  async setBlockletStatus(did, status) {
+  /**
+   * @param {String} did blocklet did
+   * @param {BlockletStatus} status blocklet status
+   *
+   * children status only different with parent before blocklet installation
+   * @param {Array<{did}>} children
+   */
+  async setBlockletStatus(did, status, { children } = {}) {
     if (typeof status === 'undefined') {
       throw new Error('Unsupported blocklet status');
     }
 
     const doc = await this.getBlocklet(did);
-    if (doc.status === status) {
+    if (doc.status === status && !children) {
       return formatBlocklet(doc, 'onRead', this.options.dek);
     }
 
@@ -412,6 +424,28 @@ class BlockletState extends BaseState {
       updates.stoppedAt = new Date();
     }
 
+    // update children status
+    updates.children = doc.children.map((child) => {
+      if (children === 'all') {
+        child.status = status;
+        return child;
+      }
+
+      if (!children) {
+        if (![BlockletStatus.waiting, BlockletStatus.upgrading, BlockletStatus.installing].includes(status)) {
+          child.status = status;
+        }
+
+        return child;
+      }
+
+      const inputChild = children.find((x) => x.did === child.meta.did);
+      if (inputChild) {
+        child.status = status;
+      }
+      return child;
+    });
+
     await this.update(doc._id, { $set: updates });
     return formatBlocklet({ ...doc, ...updates }, 'onRead', this.options.dek);
   }
@@ -463,6 +497,48 @@ class BlockletState extends BaseState {
 
     return children;
   }
+
+  async addChildren(did, children) {
+    const parent = await this.getBlocklet(did);
+    if (!parent) {
+      throw new Error('Blocklet does not exist');
+    }
+
+    const oldChildren = parent.children || [];
+
+    const newChildren = [...oldChildren];
+    for (const child of children) {
+      const { meta, mountPoint, sourceUrl = '', source = '', deployedFrom = '' } = child;
+
+      if (!mountPoint) {
+        throw new Error(`mountPoint is required when adding component ${meta.title || meta.name}`);
+      }
+
+      if (meta.did === parent.meta.did) {
+        throw new Error('Cannot add self as a component');
+      }
+
+      checkDuplicateComponents([child], newChildren);
+
+      newChildren.push({
+        mountPoint,
+        meta,
+        sourceUrl,
+        source,
+        deployedFrom,
+        dynamic: true,
+        status: BlockletStatus.added,
+      });
+    }
+
+    // use upgradeBlocklet to assign ports to children and write new data to db
+    return this.upgradeBlocklet({
+      meta: parent.meta,
+      source: parent.source,
+      deployedFrom: parent.deployedFrom,
+      children: newChildren,
+    });
+  }
 }
 
 BlockletState.BlockletStatus = BlockletStatus;

package/lib/states/node.js

@@ -92,7 +92,7 @@ class NodeState extends BaseState {
           mode,
           runtimeConfig,
           ownerNft,
-          launcherInfo,
+          launcher,
           didRegistry,
           didDomain,
           enablePassportIssuance = true,
@@ -128,7 +128,7 @@ class NodeState extends BaseState {
                 runtimeConfig,
                 ownerNft,
                 diskAlertThreshold: DISK_ALERT_THRESHOLD_PERCENT,
-                launcherInfo: launcherInfo || undefined,
+                launcher: launcher || undefined,
                 didRegistry,
                 didDomain,
                 enablePassportIssuance,
@@ -162,7 +162,8 @@ class NodeState extends BaseState {
   // FIXME: 这个接口比较危险，可能会修改一些本不应该修改的字段，后续需要考虑改进
   async updateNodeInfo(entity = {}) {
     const record = await this.read();
-    const updateResult = await this.update(record._id, { $set: omit(entity, ['ownerNft']) });
+
+    const updateResult = await this.update(record._id, { $set: omit(entity, ['ownerNft', 'sk']) });
     this.emit('node.updated', updateResult, record);
     return updateResult;
   }

package/lib/util/blocklet.js

@@ -42,7 +42,7 @@ const validateBlockletEntry = require('@blocklet/meta/lib/entry');
 const getBlockletEngine = require('@blocklet/meta/lib/engine');
 const getBlockletInfo = require('@blocklet/meta/lib/info');
 const { validateMeta, fixAndValidateService } = require('@blocklet/meta/lib/validate');
-const { forEachBlocklet } = require('@blocklet/meta/lib/util');
+const { forEachBlocklet, isFreeBlocklet } = require('@blocklet/meta/lib/util');
 
 const { validate: validateEngine, get: getEngine } = require('../blocklet/manager/engine');
 
@@ -252,7 +252,7 @@ const getRootSystemEnvironments = (blocklet, nodeInfo) => {
   const appDescription = description || result.description;
 
   // FIXME: we should use https here when possible, eg, when did-gateway is available
-  const appUrl = `http://${getDidDomainForBlocklet({ appId, didDomain: nodeInfo.didDomain })}`;
+  const appUrl = `http://${getDidDomainForBlocklet({ name, daemonDid: nodeInfo.did, didDomain: nodeInfo.didDomain })}`;
 
   return {
     BLOCKLET_DID: did,
@@ -951,7 +951,7 @@ const getRuntimeInfo = async (appId) => {
 
 /**
  * merge services
- * from meta.children[].mountPoints[].services
+ * from meta.children[].mountPoints[].services, meta.children[].services
  * to childrenMeta[].interfaces[].services
  *
  * @param {array<child>|object{children:array}} source e.g. [<config>] or { children: [<config>] }
@@ -993,6 +993,23 @@ const mergeMeta = (source, childrenMeta = []) => {
         childInterface.services = services;
       }
     });
+
+    if (config.services) {
+      const childInterface = findWebInterface(childMeta);
+      if (childInterface) {
+        // merge
+        const services = childInterface.services || [];
+        config.services.forEach((x) => {
+          const index = services.findIndex((y) => y.name === x.name);
+          if (index >= 0) {
+            services.splice(index, 1, x);
+          } else {
+            services.push(x);
+          }
+        });
+        childInterface.services = services;
+      }
+    }
   });
 };
 
@@ -1101,6 +1118,34 @@ const getDiffFiles = async (inputFiles, sourceDir) => {
 
 const getBundleDir = (installDir, bundle) => path.join(installDir, bundle.name, bundle.version);
 
+const needBlockletDownload = (blocklet, oldBlocklet) => {
+  if ([BlockletSource.upload, BlockletSource.local, BlockletSource.custom].includes(blocklet.source)) {
+    return false;
+  }
+
+  if (!get(oldBlocklet, 'meta.dist.integrity')) {
+    return true;
+  }
+
+  if (get(oldBlocklet, 'meta.dist.integrity') === get(blocklet, 'meta.dist.integrity')) {
+    return false;
+  }
+
+  return true;
+};
+
+const verifyPurchase = (meta, opts = {}) => {
+  if (opts.blockletPurchaseVerified) {
+    return true;
+  }
+
+  if (isFreeBlocklet(meta)) {
+    return true;
+  }
+
+  throw new Error('Can not install a non-free blocklet directly');
+};
+
 module.exports = {
   forEachBlocklet,
   getBlockletMetaFromUrl,
@@ -1135,4 +1180,6 @@ module.exports = {
   checkDuplicateComponents,
   getDiffFiles,
   getBundleDir,
+  needBlockletDownload,
+  verifyPurchase,
 };

package/lib/util/get-domain-for-blocklet.js

@@ -16,8 +16,8 @@ const getIpDnsDomainForBlocklet = (blocklet, blockletInterface) => {
   }${iName}-${SLOT_FOR_IP_DNS_SITE}.${DEFAULT_IP_DNS_DOMAIN_SUFFIX}`;
 };
 
-const getDidDomainForBlocklet = ({ appId, didDomain }) => {
-  return `${appId.toLowerCase()}.${didDomain}`;
+const getDidDomainForBlocklet = ({ name, daemonDid, didDomain }) => {
+  return `${formatName(name)}-${daemonDid.toLowerCase()}.${didDomain}`;
 };
 
 module.exports = { getIpDnsDomainForBlocklet, getDidDomainForBlocklet };

package/lib/util/index.js

@@ -373,7 +373,7 @@ const getBaseUrls = async (node, ips) => {
   if (info.routing.provider !== ROUTER_PROVIDER_NONE && info.routing.snapshotHash && info.routing.adminPath) {
     const sites = await node.getSitesFromSnapshot();
 
-    const { dashboardDomain } = info.routing;
+    const { ipWildcardDomain } = info.routing;
     const adminPath = normalizePathPrefix(info.routing.adminPath);
     const tmpHttpPort = getPort(httpPort, DEFAULT_HTTP_PORT);
 
@@ -383,12 +383,12 @@ const getBaseUrls = async (node, ips) => {
       };
     });
 
-    if (dashboardDomain) {
-      const site = sites.find((c) => (c.domainAliases || []).find((item) => item.value === dashboardDomain));
+    if (ipWildcardDomain) {
+      const site = sites.find((c) => (c.domainAliases || []).find((item) => item.value === ipWildcardDomain));
       if (site) {
-        const httpInfo = await getHttpInfo(dashboardDomain);
+        const httpInfo = await getHttpInfo(ipWildcardDomain);
         const httpsUrls = availableIps.map((ip) => ({
-          url: `${httpInfo.protocol}://${transformIPToDomain(ip)}.${dashboardDomain.substring(2)}${
+          url: `${httpInfo.protocol}://${transformIPToDomain(ip)}.${ipWildcardDomain.substring(2)}${
             httpInfo.port
           }${adminPath}`,
         }));

package/lib/util/upgrade.js

@@ -27,9 +27,6 @@ const waitUpdaterRpc = async (message) =>
 const checkNewVersion = async (params, context) => {
   try {
     const info = await states.node.read();
-    if (!info.autoUpgrade) {
-      return '';
-    }
 
     if (!process.env.ABT_NODE_PACKAGE_NAME) {
       logger.error('ABT_NODE_PACKAGE_NAME name was not found in environment');
@@ -176,7 +173,14 @@ const getCron = () => ({
   name: 'check-update',
   time: '0 0 8 * * *', // check every day
   // time: '0 */5 * * * *', // check every 5 minutes
-  fn: checkNewVersion,
+  fn: async () => {
+    const info = await states.node.read();
+    if (!info.autoUpgrade) {
+      return;
+    }
+
+    checkNewVersion();
+  },
   options: { runOnInit: false },
 });