@abtnode/core 1.16.6-beta-8be2fe37 → 1.16.6-beta-4ea1eb90

package/lib/blocklet/manager/disk.js

@@ -4,6 +4,7 @@ const fs = require('fs-extra');
 const path = require('path');
 const flat = require('flat');
 const get = require('lodash/get');
+const omit = require('lodash/omit');
 const uniq = require('lodash/uniq');
 const merge = require('lodash/merge');
 const pick = require('lodash/pick');
@@ -61,6 +62,7 @@ const {
   BLOCKLET_META_FILE,
   BLOCKLET_CONFIGURABLE_KEY,
   RESTORE_PROGRESS_STATUS,
+  CHAIN_PROP_MAP_REVERSE,
 } = require('@blocklet/constant');
 const util = require('../../util');
 const {
@@ -79,6 +81,7 @@ const {
   getBlockletStatusFromProcess,
   checkBlockletProcessHealthy,
   validateBlocklet,
+  validateBlockletChainInfo,
   statusMap,
   pruneBlockletBundle,
   getDiskInfo,
@@ -99,6 +102,7 @@ const {
   checkVersionCompatibility,
   getBlockletKnownAs,
   updateBlockletFallbackLogo,
+  ensureAppLogo,
 } = require('../../util/blocklet');
 const states = require('../../states');
 const BaseBlockletManager = require('./base');
@@ -433,6 +437,7 @@ class BlockletManager extends BaseBlockletManager {
 
       // validate requirement and engine
       await validateBlocklet(blocklet);
+      await validateBlockletChainInfo(blocklet);
 
       if (!hasRunnableComponent(blocklet)) {
         throw new Error('No runnable component found');
@@ -613,7 +618,7 @@ class BlockletManager extends BaseBlockletManager {
    * @memberof BlockletManager
    */
   // eslint-disable-next-line no-unused-vars
-  async restore(input, context) {
+  async restoreBlocklet(input, context) {
     const { from, ...param } = input;
     if (from === 'spaces') {
       return this._restoreFromSpaces(param, context);
@@ -999,7 +1004,6 @@ class BlockletManager extends BaseBlockletManager {
     return getBackupList(this.dataDirs.data);
   }
 
-  // CAUTION: this method currently only support config by blocklet.meta.did
   // eslint-disable-next-line no-unused-vars
   async config({ did, configs: newConfigs, skipHook, skipDidDocument }, context) {
     // todo: skipDidDocument will be deleted
@@ -1113,6 +1117,9 @@ class BlockletManager extends BaseBlockletManager {
       }
     }
 
+    // chain config
+    await this._ensureAppChainConfig(rootMetaDid, newConfigs);
+
     await this._updateBlockletEnvironment(rootDid);
 
     // response
@@ -1962,13 +1969,7 @@ class BlockletManager extends BaseBlockletManager {
       logger.info('blocklet installed', { source, did: meta.did });
 
       // logo
-      if (blocklet.source === BlockletSource.custom && blocklet.children[0]?.meta?.logo) {
-        const fileName = blocklet.children[0].meta.logo;
-        const src = path.join(getBundleDir(this.installDir, blocklet.children[0].meta), fileName);
-        const dist = path.join(getBundleDir(this.installDir, blocklet.meta), fileName);
-        await fs.copy(src, dist);
-      }
-
+      await ensureAppLogo(blocklet, this.installDir);
       await updateBlockletFallbackLogo(blocklet);
 
       // Init db
@@ -2346,6 +2347,9 @@ class BlockletManager extends BaseBlockletManager {
 
         // write configs to db
         await states.blockletExtras.setConfigs([...ancestors.map((x) => x.meta.did), b.meta.did], environments);
+
+        // chain config
+        await this._ensureAppChainConfig(blocklet.meta.did, environments, 'name');
       });
     } else {
       const child = blocklet.children.find((x) => x.meta.did === childDid);
@@ -2354,6 +2358,9 @@ class BlockletManager extends BaseBlockletManager {
           [blocklet.meta.did, ...ancestors.map((x) => x.meta.did), b.meta.did],
           [...get(b.meta, 'environments', []), ...getConfigFromPreferences(child)]
         );
+
+        // chain config
+        await this._ensureAppChainConfig(blocklet.meta.did, get(b.meta, 'environments', []), 'name');
       });
     }
   }
@@ -2603,12 +2610,21 @@ class BlockletManager extends BaseBlockletManager {
   async _backupToSpaces({ blocklet }, context) {
     const userDid = context.user.did;
     const { referrer } = context;
-    const { appDid } = blocklet;
+    const {
+      appDid,
+      meta: { did: appPid },
+    } = blocklet;
 
-    const spacesBackup = new SpacesBackup({ appDid, event: this, userDid, referrer });
-    this.emit(BlockletEvents.backupProgress, { appDid, message: 'Start backup...', progress: 10, completed: false });
+    const spacesBackup = new SpacesBackup({ appDid, appPid, event: this, userDid, referrer });
+    this.emit(BlockletEvents.backupProgress, {
+      appDid,
+      meta: { did: appPid },
+      message: 'Start backup...',
+      progress: 10,
+      completed: false,
+    });
     await spacesBackup.backup();
-    this.emit(BlockletEvents.backupProgress, { appDid, completed: true, progress: 100 });
+    this.emit(BlockletEvents.backupProgress, { appDid, meta: { did: appPid }, completed: true, progress: 100 });
   }
 
   /**
@@ -2634,11 +2650,17 @@ class BlockletManager extends BaseBlockletManager {
       await sleep(input.delay);
     }
 
-    this.emit(BlockletEvents.restoreProgress, { appDid: input.appDid, status: RESTORE_PROGRESS_STATUS.start });
+    const appPid = input.appDid;
+
+    this.emit(BlockletEvents.restoreProgress, {
+      appDid: input.appDid,
+      meta: { did: appPid },
+      status: RESTORE_PROGRESS_STATUS.start,
+    });
 
     const userDid = context.user.did;
 
-    const spacesRestore = new SpacesRestore({ ...input, event: this, userDid, referrer: context.referrer });
+    const spacesRestore = new SpacesRestore({ ...input, appPid, event: this, userDid, referrer: context.referrer });
     const params = await spacesRestore.restore();
 
     const removeRestoreDir = () => {
@@ -2702,6 +2724,21 @@ class BlockletManager extends BaseBlockletManager {
       throw error;
     }
   }
+
+  async _ensureAppChainConfig(metaDid, configs, key = 'key') {
+    const chainConfigs = configs.filter((x) => ['CHAIN_HOST', 'CHAIN_ID', 'CHAIN_TYPE'].includes(x[key]));
+    if (chainConfigs.length) {
+      const items = chainConfigs.map((x) => ({
+        ...omit(x, ['description', 'validation']),
+        [key]: CHAIN_PROP_MAP_REVERSE[x[key]],
+        shared: true,
+        secure: false,
+        required: false,
+        custom: false,
+      }));
+      await states.blockletExtras.setConfigs(metaDid, items);
+    }
+  }
 }
 
 module.exports = BlockletManager;

package/lib/blocklet/manager/helper/install-application-from-dev.js

@@ -1,7 +1,7 @@
 const { BlockletStatus, BLOCKLET_MODES, fromBlockletStatus, BlockletSource } = require('@blocklet/constant');
 
 const logger = require('@abtnode/logger')('@abtnode/core:install-app-dev');
-const { ensureMeta, updateBlockletFallbackLogo } = require('../../../util/blocklet');
+const { ensureMeta, updateBlockletFallbackLogo, ensureAppLogo } = require('../../../util/blocklet');
 
 /**
  *
@@ -79,10 +79,12 @@ const installApplicationFromDev = async ({ folder, meta, states, manager } = {})
 
   await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
 
-  blocklet = await manager.getBlocklet(did);
-
+  // logo
+  await ensureAppLogo(blocklet, manager.installDir);
   await updateBlockletFallbackLogo(blocklet);
 
+  blocklet = await manager.getBlocklet(did);
+
   return blocklet;
 };
 

package/lib/blocklet/manager/helper/install-component-from-url.js

@@ -117,6 +117,9 @@ const installComponentFromUrl = async ({
       }
 
       await states.blockletExtras.setConfigs([blocklet.meta.did, newChild.meta.did], configs);
+
+      // chain config
+      await manager._ensureAppChainConfig(blocklet.meta.did, configs);
     }
   } catch (err) {
     logger.error('Add component failed', err);

package/lib/blocklet/storage/backup/spaces.js

@@ -1,6 +1,7 @@
 /**
  * @typedef {{
  *  appDid: string
+ *  appPid: string,
  *  event: import('events').EventEmitter,
  *  userDid: string,
  *  referrer: string,
@@ -147,6 +148,7 @@ class SpacesBackup extends BaseBackup {
   async export() {
     this.input.event.emit(BlockletEvents.backupProgress, {
       appDid: this.input.appDid,
+      meta: { did: this.input.appPid },
       message: 'Preparing data for backup...',
       progress: 15,
       completed: false,
@@ -156,6 +158,7 @@ class SpacesBackup extends BaseBackup {
 
     this.input.event.emit(BlockletEvents.backupProgress, {
       appDid: this.input.appDid,
+      meta: { did: this.input.appPid },
       message: 'Data ready, start backup...',
       progress: 20,
       completed: false,
@@ -193,11 +196,12 @@ class SpacesBackup extends BaseBackup {
           // FIXME: @yejianchao 这里需要更完整的黑名单
           return object.name !== '.DS_Store';
         },
-        onProgress: (data) => {
+        onAfterUpload: (data) => {
           logger.info('backup progress', { appDid: this.input.appDid, data });
           const percent = (data.completed * 100) / data.total;
           this.input.event.emit(BlockletEvents.backupProgress, {
             appDid: this.input.appDid,
+            meta: { did: this.input.appDid },
             message: `Uploading file ${basename(data.key)} (${data.completed}/${data.total})`,
             // 0.8 是因为上传文件到 spaces 占进度的 80%，+ 20 是因为需要累加之前的进度
             progress: +Math.ceil(percent * 0.8).toFixed(2) + 20,

package/lib/blocklet/storage/restore/spaces.js

@@ -1,6 +1,7 @@
 /**
  * @typedef {{
  *  appDid: string; // --> appDid
+ *  appPid: string;
  *  endpoint: string;
  *  password: Buffer; // derived from (appSk, appDid)
  *  delegation: string; // from appDid --> serverDid for downloading
@@ -118,10 +119,11 @@ class SpacesRestore extends BaseRestore {
         debug: true,
         concurrency: 32,
         retryCount: 10,
-        onProgress: (data) => {
+        onAfterUpload: (data) => {
           logger.info('restore progress', { appDid: this.input.appDid, data });
           this.input.event.emit(BlockletEvents.restoreProgress, {
             appDid: this.input.appDid,
+            meta: { did: this.input.appPid },
             status: RESTORE_PROGRESS_STATUS.downloading,
             data,
           });
@@ -140,6 +142,7 @@ class SpacesRestore extends BaseRestore {
   async import(params) {
     this.input.event.emit(BlockletEvents.restoreProgress, {
       appDid: this.input.appDid,
+      meta: { did: this.input.appPid },
       status: RESTORE_PROGRESS_STATUS.importData,
     });
 
@@ -150,6 +153,7 @@ class SpacesRestore extends BaseRestore {
     );
     this.input.event.emit(BlockletEvents.restoreProgress, {
       appDid: this.input.appDid,
+      meta: { did: this.input.appPid },
       status: RESTORE_PROGRESS_STATUS.importDataSuccess,
     });
   }

package/lib/crons/check-new-version.js

@@ -0,0 +1,68 @@
+/* eslint-disable no-param-reassign */
+const semver = require('semver');
+const listNpmPackageVersion = require('@abtnode/util/lib/list-npm-package-version');
+const logger = require('@abtnode/logger')('@abtnode/core:maintain');
+
+const states = require('../states');
+
+// eslint-disable-next-line no-unused-vars
+const checkNewVersion = async (params, context) => {
+  try {
+    const info = await states.node.read();
+
+    if (!process.env.ABT_NODE_PACKAGE_NAME) {
+      logger.error('ABT_NODE_PACKAGE_NAME name was not found in environment');
+      return '';
+    }
+
+    const versions = await listNpmPackageVersion(process.env.ABT_NODE_PACKAGE_NAME, {
+      includePrereleases: !!info.enableBetaRelease,
+    });
+    if (Array.isArray(versions) && versions.length) {
+      const latestVersionStr = versions[0].version;
+      const latestVersion = semver.coerce(latestVersionStr);
+      const currentVersion = semver.coerce(info.version);
+      if (latestVersionStr !== info.version && semver.gte(latestVersion, currentVersion)) {
+        logger.info('New version found for Blocklet Server', {
+          latestVersion: latestVersionStr,
+          currentVersion: info.version,
+          nextVersion: info.nextVersion,
+        });
+        await states.node.updateNodeInfo({ nextVersion: latestVersionStr });
+        await states.notification.create({
+          title: 'Blocklet Server upgrade available',
+          description: 'A new and improved version of blocklet server is now available',
+          entityType: 'node',
+          severity: 'info',
+          sticky: true,
+          action: '/settings/about',
+        });
+
+        return latestVersionStr;
+      }
+    }
+
+    return '';
+  } catch (err) {
+    logger.error('Failed to check new version for Blocklet Server', { error: err });
+  }
+
+  return '';
+};
+
+const getCron = () => ({
+  name: 'check-new-version',
+  time: '0 0 8 * * *', // check every day
+  // time: '0 */5 * * * *', // check every 5 minutes
+  fn: async () => {
+    const info = await states.node.read();
+    if (!info.autoUpgrade) {
+      return;
+    }
+
+    checkNewVersion();
+  },
+  options: { runOnInit: false },
+});
+
+module.exports = { getCron, checkNewVersion };

package/lib/{util/disk-monitor.js → crons/monitor-disk-usage.js}

@@ -1,5 +1,5 @@
 const logger = require('@abtnode/logger')('@abtnode/disk-monitor');
-const info = require('./sysinfo');
+const info = require('../util/sysinfo');
 
 const states = require('../states');
 
@@ -29,7 +29,7 @@ const check = async (threshold) => {
 };
 
 const getCron = () => ({
-  name: 'disk-monitor',
+  name: 'monitor-disk-usage',
   time: '0 5 * * * *', // check every hour
   fn: async () => {
     const nodeInfo = await states.node.read();

package/lib/crons/rotate-pm2-logs/index.js

@@ -0,0 +1,41 @@
+/* eslint-disable no-console */
+const path = require('path');
+const spawn = require('cross-spawn');
+const { LOG_RETAIN_IN_DAYS } = require('@abtnode/constant');
+
+const getCron = () => ({
+  name: 'rotate-pm2-logs',
+  time: '0 0 * * *', // default : every day at midnight
+  options: { runOnInit: false },
+  fn: async () => {
+    console.info(`Log rotator started on ${new Date().toISOString()}`);
+    const child = spawn('node', [path.join(__dirname, './script.js')], {
+      detached: true,
+      windowsHide: true, // required for Windows
+      cwd: process.cwd(),
+      timeout: 30 * 60 * 1000, // 30 minutes
+      shell: process.env.SHELL || false,
+      stdio: ['ignore', process.stdout, process.stderr],
+      env: {
+        PATH: process.env.PATH,
+        PM2_HOME: process.env.PM2_HOME,
+        COMPRESS: true,
+        RETAIN: LOG_RETAIN_IN_DAYS,
+      },
+    });
+
+    child.on('error', (err) => {
+      console.error('Log rotator errored', err);
+    });
+
+    child.on('close', (code) => {
+      console.info(`Log rotator exited with code ${code} on ${new Date().toISOString()}`);
+    });
+
+    child.unref();
+  },
+});
+
+module.exports = {
+  getCron,
+};

package/lib/crons/rotate-pm2-logs/script.js

@@ -0,0 +1,56 @@
+/* eslint-disable no-console */
+const pm2 = require('@abtnode/util/lib/async-pm2');
+
+const LogRotator = require('../../util/rotator');
+
+const RETAIN = parseInt(process.env.RETAIN || '', 10);
+const COMPRESS = JSON.parse(process.env.COMPRESS || 'false');
+const DATE_FORMAT = process.env.DATE_FORMAT || 'YYYY-MM-DD';
+const { TZ } = process.env;
+
+const logRotate = new LogRotator({ compress: COMPRESS, dateFormat: DATE_FORMAT, tz: TZ, retain: RETAIN });
+
+// register the cron to force rotate file
+console.info('Start rotating pm2 logs...');
+
+// get list of process managed by pm2
+pm2.connect((err) => {
+  if (err) {
+    console.error('Can not connect to pm2 daemon', err);
+    process.exit(1);
+  }
+
+  // eslint-disable-next-line no-shadow
+  pm2.list(async (err, apps) => {
+    if (err) {
+      console.error('Can not list apps from pm2', err);
+      process.exit(1);
+    }
+
+    const appMap = {};
+
+    // force rotate for each app
+    await Promise.allSettled(
+      apps.map((app) => {
+        // if apps instances are multi and one of the instances has rotated, ignore
+        if (app.pm2_env.instances > 1 && appMap[app.name]) {
+          return Promise.resolve(true);
+        }
+
+        appMap[app.name] = app;
+
+        return logRotate
+          .proceedPm2App(app)
+          .then(() => {
+            console.info(`Rotate ${app.name} log files succeed`);
+          })
+          .catch((error) => {
+            console.error(`Rotate ${app.name} log files failed`, { error });
+          });
+      })
+    );
+
+    console.info('Done rotating pm2 logs...');
+    process.exit(0);
+  });
+});

package/lib/index.js

@@ -24,7 +24,9 @@ const IP = require('./util/ip');
 const DomainStatus = require('./util/domain-status');
 const Maintain = require('./util/maintain');
 const resetNode = require('./util/reset-node');
-const DiskMonitor = require('./util/disk-monitor');
+const DiskMonitor = require('./crons/monitor-disk-usage');
+const LogRotator = require('./crons/rotate-pm2-logs');
+const VersionChecker = require('./crons/check-new-version');
 const StoreUtil = require('./util/store');
 const createQueue = require('./util/queue');
 const createEvents = require('./event');
@@ -235,7 +237,7 @@ function ABTNode(options) {
     updateComponentTitle: blockletManager.updateComponentTitle.bind(blockletManager),
     updateComponentMountPoint: blockletManager.updateComponentMountPoint.bind(blockletManager),
     backupBlocklet: blockletManager.backup.bind(blockletManager),
-    restoreBlocklet: blockletManager.restore.bind(blockletManager),
+    restoreBlocklet: blockletManager.restoreBlocklet.bind(blockletManager),
     migrateApplicationToStructV2: blockletManager.migrateApplicationToStructV2.bind(blockletManager),
 
     // For diagnose purpose
@@ -402,8 +404,8 @@ function ABTNode(options) {
     markMigrationExecuted: states.migration.markExecuted.bind(states.migration),
 
     // Upgrading
+    checkNodeVersion: VersionChecker.checkNewVersion,
     upgradeNodeVersion: () => Maintain.triggerMaintain({ action: 'upgrade', next: Maintain.resumeMaintain }),
-    checkNodeVersion: Maintain.checkNewVersion,
     restartServer: () => Maintain.triggerMaintain({ action: 'restart', next: Maintain.resumeMaintain }),
     isBeingMaintained: Maintain.isBeingMaintained,
     resumeMaintain: Maintain.resumeMaintain,
@@ -452,10 +454,11 @@ function ABTNode(options) {
       context: { states, events, webhook },
       jobs: [
         IP.cron,
-        Maintain.getCron(),
+        VersionChecker.getCron(),
         ...getRoutingCrons(),
         ...blockletManager.getCrons(),
         DiskMonitor.getCron(),
+        LogRotator.getCron(),
         ...getStateCrons(states),
         ...nodeAPI.getCrons(),
       ],

package/lib/processes/updater.js

@@ -0,0 +1,160 @@
+/* eslint-disable no-console */
+const fs = require('fs-extra');
+const axon = require('axon');
+const path = require('path');
+const shell = require('shelljs');
+const semver = require('semver');
+
+const VERBOSE = '';
+// const VERBOSE = '--verbose';
+
+const BINARY_NAME = process.env.ABT_NODE_BINARY_NAME;
+const COMMAND_NAME = process.env.ABT_NODE_COMMAND_NAME;
+const PACKAGE_NAME = process.env.ABT_NODE_PACKAGE_NAME;
+const VALID_BINARY_NAMES = ['blocklet', 'abtnode'];
+
+console.info(`binary name: ${BINARY_NAME}`);
+console.info(`command name: ${COMMAND_NAME}`);
+console.info(`package name: ${PACKAGE_NAME}`);
+
+// async and promise style of shelljs.exec
+const runAsync = (command, options) =>
+  new Promise((resolve) => {
+    console.info(`Run command: ${command}`);
+    shell.exec(command, { async: true, ...options }, (code, stdout, stderr) => {
+      resolve({ code, stdout, stderr });
+    });
+  });
+
+const getInstaller = () => {
+  const { stdout: pnpmPath } = shell.which('pnpm') || {};
+  if (pnpmPath) {
+    const { stdout: expectedDir } = shell.exec('pnpm bin -g', { silent: true });
+    const { stdout: binPath } = shell.which(BINARY_NAME);
+    if (expectedDir && binPath && expectedDir.trim() === path.dirname(binPath)) {
+      return 'pnpm';
+    }
+  }
+
+  const { stdout: yarnPath } = shell.which('yarn') || {};
+  if (yarnPath) {
+    const { stdout: binaryDir } = shell.exec(`yarn global bin ${BINARY_NAME}`, { silent: true });
+    const binaryPath = path.join(binaryDir, BINARY_NAME);
+    if (fs.existsSync(binaryPath)) {
+      return 'yarn';
+    }
+  }
+
+  return 'npm';
+};
+
+const getBinaryDir = () => {
+  const installer = getInstaller();
+  if (installer === 'pnpm') {
+    const { stdout: binaryDir } = shell.exec('pnpm bin -g', { silent: true });
+    return binaryDir.trim();
+  }
+
+  if (installer === 'yarn') {
+    const { stdout: binaryDir } = shell.exec(`yarn global bin ${BINARY_NAME}`, { silent: true });
+    return binaryDir.trim();
+  }
+
+  const { stdout: binaryDir } = shell.exec(`npm bin -g ${BINARY_NAME}`, { silent: true });
+  return binaryDir.trim();
+};
+
+const installBlockletServer = async (version) => {
+  if (VALID_BINARY_NAMES.includes(BINARY_NAME) === false) {
+    return { code: 1, stderr: 'Abort because you are not using a standard @blocklet/cli setup' };
+  }
+
+  const installer = getInstaller();
+  const commands = {
+    pnpm: `pnpm add -g ${PACKAGE_NAME}@${version} ${VERBOSE}`,
+    npm: `npm install -g ${PACKAGE_NAME}@${version} ${VERBOSE}`,
+    yarn: `yarn global add ${PACKAGE_NAME}@${version} ${VERBOSE}`,
+  };
+  const command = commands[installer];
+  console.info('Installing blocklet server', { version, installer, command });
+  const result = await runAsync(command);
+  console.info('Installing blocklet server done', { version });
+  return result;
+};
+
+const verifyBlockletServer = async (version) => {
+  console.info('Verifying blocklet server', { version });
+  const result = await runAsync(`${BINARY_NAME} --version`);
+  console.info('Verifying blocklet server done', { version });
+
+  if (result.code === 0) {
+    const actual = semver.coerce(result.stdout);
+    if (actual && actual.version === version) {
+      return result;
+    }
+
+    return { code: 1, stderr: `Blocklet server version is not expected ${version}` };
+  }
+
+  return result;
+};
+
+// Restart Blocklet Server
+const restartBlockletServer = async (dataDir) => {
+  // We put this in the event loop because it will terminate the current node process
+  // But we need to wait for the session state to transition from restarting to cleanup
+  process.nextTick(async () => {
+    const binaryDir = getBinaryDir();
+    console.info('Restarting blocklet server', { dataDir, binaryDir });
+
+    if (!binaryDir) {
+      console.error('Can not restart blocklet server because no binaryDir found');
+      return;
+    }
+
+    // restart the server
+    if (VALID_BINARY_NAMES.includes(BINARY_NAME)) {
+      await runAsync(`${binaryDir}/${COMMAND_NAME} start`, { cwd: path.dirname(dataDir) });
+    } else {
+      await runAsync(`${COMMAND_NAME} start`, { cwd: path.dirname(dataDir) });
+    }
+    console.info('Restarting blocklet server done');
+  });
+
+  return dataDir;
+};
+
+// Start the server
+const sock = axon.socket('rep');
+const port = Number(process.env.ABT_NODE_UPDATER_PORT);
+sock.bind(port, '127.0.0.1');
+sock.on('message', async (raw, reply) => {
+  console.info('receive', { raw });
+
+  try {
+    const message = JSON.parse(raw);
+    if (message.command === 'install') {
+      const result = await installBlockletServer(message.version);
+      reply(result);
+    } else if (message.command === 'verify') {
+      const result = await verifyBlockletServer(message.version);
+      reply(result);
+    } else if (message.command === 'restart') {
+      const result = await restartBlockletServer(message.dataDir);
+      reply(result);
+    } else if (message.command === 'shutdown') {
+      reply('Terminate myself after this message');
+      setTimeout(() => {
+        process.exit(0);
+      }, 500);
+    } else if (message.command === 'ping') {
+      reply('pong');
+    } else {
+      reply({ error: 'Unknown command' });
+    }
+  } catch (err) {
+    console.error('failed to process command', { error: err });
+  }
+});
+
+console.info(`Blocklet Server Updater process is ready on port ${port}`);

package/lib/states/node.js

@@ -125,6 +125,7 @@ class NodeState extends BaseState {
                 docker,
                 mode,
                 enableWelcomePage: mode !== NODE_MODES.SERVERLESS,
+                enableBetaRelease: false,
                 runtimeConfig,
                 ownerNft,
                 diskAlertThreshold: DISK_ALERT_THRESHOLD_PERCENT,

package/lib/util/blocklet.js

@@ -18,6 +18,7 @@ const isUrl = require('is-url');
 const semver = require('semver');
 const axios = require('@abtnode/util/lib/axios');
 const { stableStringify } = require('@arcblock/vc');
+const { chainInfo: chainInfoSchema } = require('@arcblock/did-auth/lib/schema');
 
 const { fromSecretKey } = require('@ocap/wallet');
 const { toHex, toBase58, isHex, toDid } = require('@ocap/util');
@@ -78,6 +79,7 @@ const {
   isEnvShareable,
   getBlockletAppIdList,
   isBeforeInstalled,
+  getChainInfo,
 } = require('@blocklet/meta/lib/util');
 const toBlockletDid = require('@blocklet/meta/lib/did');
 const { titleSchema, descriptionSchema, logoSchema } = require('@blocklet/meta/lib/schema');
@@ -884,6 +886,21 @@ const validateBlocklet = (blocklet) =>
     validateEngine(getBlockletEngineNameByPlatform(b.meta));
   });
 
+const validateBlockletChainInfo = (blocklet) => {
+  const chainInfo = getChainInfo({
+    CHAIN_TYPE: blocklet.configObj[BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_CHAIN_TYPE],
+    CHAIN_ID: blocklet.configObj[BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_CHAIN_ID],
+    CHAIN_HOST: blocklet.configObj[BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_CHAIN_HOST],
+  });
+
+  const { error } = chainInfoSchema.validate(chainInfo);
+  if (error) {
+    throw error;
+  }
+
+  return chainInfo;
+};
+
 const checkBlockletProcessHealthy = async (blocklet, { minConsecutiveTime, timeout } = {}) => {
   await forEachBlocklet(
     blocklet,
@@ -1885,6 +1902,26 @@ const updateBlockletFallbackLogo = async (blocklet) => {
   }
 };
 
+const ensureAppLogo = async (blocklet, blockletsDir) => {
+  if (!blocklet) {
+    return;
+  }
+
+  if (
+    blocklet.source === BlockletSource.custom &&
+    (blocklet.children || [])[0]?.meta?.logo &&
+    blocklet.children[0].env.appDir
+  ) {
+    const fileName = blocklet.children[0].meta.logo;
+    const src = path.join(blocklet.children[0].env.appDir, fileName);
+    const dist = path.join(getBundleDir(blockletsDir, blocklet.meta), fileName);
+
+    if (fs.existsSync(src)) {
+      await fs.copy(src, dist);
+    }
+  }
+};
+
 module.exports = {
   updateBlockletFallbackLogo,
   consumeServerlessNFT,
@@ -1897,6 +1934,7 @@ module.exports = {
   getComponentSystemEnvironments,
   getRuntimeEnvironments,
   validateBlocklet,
+  validateBlockletChainInfo,
   fillBlockletConfigs,
   ensureBlockletExpanded,
   startBlockletProcess,
@@ -1941,4 +1979,5 @@ module.exports = {
   validateBlockletMeta,
   getBlockletKnownAs,
   getFixedBundleSource,
+  ensureAppLogo,
 };

package/lib/util/ip.js

@@ -1,9 +1,6 @@
 const getIp = require('@abtnode/util/lib/get-ip');
 const logger = require('@abtnode/logger')('@abtnode/core:ip');
 
-const doRpc = require('./rpc');
-const { memoizeAsync } = require('./index');
-
 let cache = null;
 const fetch = async () => {
   try {
@@ -25,9 +22,6 @@ const cron = {
   fn: fetch,
 };
 
-const lookup = memoizeAsync((ip) => doRpc({ command: 'lookup', ip }));
-
 module.exports.fetch = fetch;
 module.exports.get = get;
 module.exports.cron = cron;
-module.exports.lookup = lookup;

package/lib/util/maintain.js

@@ -1,59 +1,15 @@
 /* eslint-disable no-param-reassign */
-const semver = require('semver');
 const sleep = require('@abtnode/util/lib/sleep');
 const SysInfo = require('systeminformation');
 const { NODE_MODES, NODE_MAINTAIN_PROGRESS, EVENTS } = require('@abtnode/constant');
-const listNpmPackageVersion = require('@abtnode/util/lib/list-npm-package-version');
 const Lock = require('@abtnode/util/lib/lock');
 const logger = require('@abtnode/logger')('@abtnode/core:maintain');
 
 const states = require('../states');
-const doRpc = require('./rpc');
+const { doRpcCall, startRpcServer } = require('./rpc');
 
 const lock = new Lock('node-upgrade-lock');
 
-// eslint-disable-next-line no-unused-vars
-const checkNewVersion = async (params, context) => {
-  try {
-    const info = await states.node.read();
-
-    if (!process.env.ABT_NODE_PACKAGE_NAME) {
-      logger.error('ABT_NODE_PACKAGE_NAME name was not found in environment');
-      return '';
-    }
-
-    const versions = await listNpmPackageVersion(process.env.ABT_NODE_PACKAGE_NAME);
-    if (Array.isArray(versions) && versions.length) {
-      const latestVersion = versions[0].version;
-      if (semver.gt(latestVersion, info.version)) {
-        // if (semver.gte(latestVersion, info.version)) {
-        logger.info('New version found for Blocklet Server', {
-          latestVersion,
-          currentVersion: info.version,
-          nextVersion: info.nextVersion,
-        });
-        await states.node.updateNodeInfo({ nextVersion: latestVersion });
-        await states.notification.create({
-          title: 'Blocklet Server upgrade available',
-          description: 'A new and improved version of blocklet server is now available',
-          entityType: 'node',
-          severity: 'info',
-          sticky: true,
-          action: '/settings/about',
-        });
-
-        return latestVersion;
-      }
-    }
-
-    return '';
-  } catch (err) {
-    logger.error('Failed to check new version for Blocklet Server', { error: err });
-  }
-
-  return '';
-};
-
 const triggerMaintain = async ({ action, next }) => {
   if (['upgrade', 'restart'].includes(action) === false) {
     throw new Error(`Unrecognized server maintain action: ${action}`);
@@ -98,6 +54,8 @@ const triggerMaintain = async ({ action, next }) => {
     throw new Error(`${action} aborted due to invalid session: ${sessionId}`);
   }
 
+  await startRpcServer();
+
   process.nextTick(async () => {
     await next(session);
   });
@@ -134,7 +92,7 @@ const resumeMaintain = async (session) => {
 
   // 2. install new version
   if (session.stage === NODE_MAINTAIN_PROGRESS.INSTALLING) {
-    const result = await doRpc({ command: 'install', version: to });
+    const result = await doRpcCall({ command: 'install', version: to });
     logger.info('new version installed', { from, to, sessionId });
     if (result.code !== 0) {
       await sleep(3000);
@@ -144,7 +102,7 @@ const resumeMaintain = async (session) => {
 
   // 2. verify new version
   if (session.stage === NODE_MAINTAIN_PROGRESS.VERIFYING) {
-    const result = await doRpc({ command: 'verify', version: to });
+    const result = await doRpcCall({ command: 'verify', version: to });
     await sleep(3000);
     if (result.code === 0) {
       logger.info('new version verified', { from, to, sessionId });
@@ -164,6 +122,7 @@ const resumeMaintain = async (session) => {
     await states.node.updateNodeInfo({ nextVersion: '', version: from, upgradeSessionId: '' });
     try {
       await states.node.exitMode(NODE_MODES.MAINTENANCE);
+      await doRpcCall({ command: 'shutdown' });
     } catch (error) {
       logger.error('Failed to rollback', { error });
     }
@@ -177,7 +136,7 @@ const resumeMaintain = async (session) => {
     await sleep(3000);
     await goNextState(NODE_MAINTAIN_PROGRESS.CLEANUP, true);
     await sleep(3000);
-    await doRpc({ command: 'restart', dataDir: process.env.ABT_NODE_DATA_DIR });
+    await doRpcCall({ command: 'restart', dataDir: process.env.ABT_NODE_DATA_DIR });
     await lock.release();
     return; // we should abort here and resume after restart
   }
@@ -190,6 +149,7 @@ const resumeMaintain = async (session) => {
     await states.node.updateNodeInfo({ nextVersion: '', version: to, upgradeSessionId: '' });
     try {
       await states.node.exitMode(NODE_MODES.MAINTENANCE);
+      await doRpcCall({ command: 'shutdown' });
     } catch (error) {
       logger.error('Failed to exit maintenance mode', { error });
     }
@@ -215,19 +175,4 @@ const isBeingMaintained = async () => {
   return session;
 };
 
-const getCron = () => ({
-  name: 'check-update',
-  time: '0 0 8 * * *', // check every day
-  // time: '0 */5 * * * *', // check every 5 minutes
-  fn: async () => {
-    const info = await states.node.read();
-    if (!info.autoUpgrade) {
-      return;
-    }
-
-    checkNewVersion();
-  },
-  options: { runOnInit: false },
-});
-
-module.exports = { getCron, checkNewVersion, resumeMaintain, triggerMaintain, isBeingMaintained };
+module.exports = { resumeMaintain, triggerMaintain, isBeingMaintained };

package/lib/util/rotator.js

@@ -0,0 +1,194 @@
+/**
+ * Base on: https://github.com/keymetrics/pm2-logrotate
+ */
+const fs = require('fs-extra');
+const path = require('path');
+const moment = require('moment-timezone');
+const zlib = require('zlib');
+const log = require('@abtnode/logger');
+
+const buildLogger =
+  (func) =>
+  (...args) => {
+    if (typeof args[0] === 'string') {
+      func(`pm2.log.rotate.${args[0]}`, ...args.slice(1));
+      return;
+    }
+
+    func('pm2.log.rotate', ...args);
+  };
+
+// eslint-disable-next-line no-console
+const logInfo = buildLogger(console.info);
+const logError = buildLogger(console.error);
+
+module.exports = class LogRotate {
+  constructor({ compress, dateFormat, tz, retain } = {}) {
+    this.compress = compress;
+    this.dateFormat = dateFormat;
+    this.tz = tz;
+    this.retain = retain;
+    this.compressedFileFormat = '.gz';
+  }
+
+  getLimitSize(maxSize) {
+    if (!maxSize) {
+      return 1024 * 1024 * 10; // 10M
+    }
+
+    if (typeof maxSize === 'number') {
+      return maxSize;
+    }
+
+    if (typeof maxSize !== 'string') {
+      throw new Error('maxSize must be a string or number');
+    }
+
+    // eslint-disable-next-line no-param-reassign
+    maxSize = maxSize.trim();
+
+    const unit = maxSize[maxSize.length - 1].toUpperCase();
+    if (unit === 'G') {
+      return parseInt(maxSize, 10) * 1024 * 1024 * 1024;
+    }
+
+    if (unit === 'M') {
+      return parseInt(maxSize, 10) * 1024 * 1024;
+    }
+
+    if (unit === 'K') {
+      return parseInt(maxSize, 10) * 1024;
+    }
+
+    return parseInt(maxSize, 10);
+  }
+
+  /**
+   * Apply the rotation process of the log file.
+   *
+   * @param {string} file
+   */
+  proceed(file, callback = () => {}) {
+    // set default final time
+    let finalTime = moment().subtract(1, 'day').format(this.dateFormat);
+    // check for a timezone
+    if (this.tz) {
+      try {
+        finalTime = moment().tz(this.tz).subtract(1, 'day').format(this.dateFormat);
+      } catch (err) {
+        // use default
+      }
+    }
+
+    const filename = path.basename(file, path.extname(file));
+    const dirname = path.dirname(file);
+    const extName = this.compress ? `.log${this.compressedFileFormat}` : '.log';
+
+    let finalName = `${path.join(dirname, filename)}-${finalTime}${extName}`;
+
+    // 这种情况是为了兼容，之间的日志文件名中的日志大了一天，所以升级时旧数据可能存在重复
+    if (fs.existsSync(finalName)) {
+      finalName = `${path.join(dirname, filename)}-${finalTime}.1${extName}`;
+    }
+
+    // if compression is enabled, add gz extention and create a gzip instance
+    let GZIP;
+    if (this.compress) {
+      GZIP = zlib.createGzip({
+        level: zlib.constants.Z_BEST_COMPRESSION,
+        memLevel: zlib.constants.Z_BEST_COMPRESSION,
+      });
+    }
+
+    // create our read/write streams
+    const readStream = fs.createReadStream(file);
+    const writeStream = fs.createWriteStream(finalName, { flags: 'w+' });
+
+    // pipe all stream
+    if (this.compress) {
+      readStream.pipe(GZIP).pipe(writeStream);
+    } else {
+      readStream.pipe(writeStream);
+    }
+
+    const onError = (err) => {
+      logError(err);
+      callback(err);
+    };
+
+    // listen for error
+    readStream.on('error', onError);
+    writeStream.on('error', onError);
+    if (this.compression) {
+      GZIP.on('error', onError);
+    }
+
+    // when the read is done, empty the file and check for retain option
+    writeStream.on('finish', () => {
+      if (GZIP) {
+        GZIP.close();
+      }
+      readStream.close();
+      writeStream.close();
+
+      fs.truncateSync(file);
+      logInfo('rotated file:', finalName);
+
+      callback(null, finalName);
+    });
+  }
+
+  proceedSync(file) {
+    return new Promise((resolve, reject) => {
+      this.proceed(file, (err, res) => {
+        if (err) {
+          return reject(err);
+        }
+
+        return resolve(res);
+      });
+    });
+  }
+
+  /**
+   * Apply the rotation process if the `file` size exceeds the `SIZE_LIMIT`.
+   *
+   * @param {string} file
+   */
+  async proceedFile(file) {
+    if (!fs.existsSync(file)) {
+      return;
+    }
+
+    if (fs.statSync(file).size > 0) {
+      await this.proceedSync(file);
+    }
+
+    log.deleteOldLogfiles(file, this.retain);
+  }
+
+  /**
+   * Apply the rotation process of all log files of `app` where the file size exceeds the`SIZE_LIMIT`.
+   *
+   * @param {Object} app
+   */
+  async proceedPm2App(app) {
+    // Check all log path
+    // Note: If same file is defined for multiple purposes, it will be processed once only.
+    if (app.pm2_env.pm_out_log_path) {
+      await this.proceedFile(app.pm2_env.pm_out_log_path);
+    }
+
+    if (app.pm2_env.pm_err_log_path && app.pm2_env.pm_err_log_path !== app.pm2_env.pm_out_log_path) {
+      await this.proceedFile(app.pm2_env.pm_err_log_path);
+    }
+
+    if (
+      app.pm2_env.pm_log_path &&
+      app.pm2_env.pm_log_path !== app.pm2_env.pm_out_log_path &&
+      app.pm2_env.pm_log_path !== app.pm2_env.pm_err_log_path
+    ) {
+      await this.proceedFile(app.pm2_env.pm_log_path);
+    }
+  }
+};

package/lib/util/rpc.js

@@ -1,16 +1,77 @@
+/* eslint-disable no-console */
 const axon = require('axon');
+const kill = require('kill-port');
+const path = require('path');
+const spawn = require('cross-spawn');
+
 const logger = require('@abtnode/logger')('@abtnode/core:rpc');
 
-const sock = axon.socket('req');
-sock.connect(Number(process.env.ABT_NODE_UPDATER_PORT || 40405), '127.0.0.1');
+const host = '127.0.0.1';
+const port = Number(process.env.ABT_NODE_UPDATER_PORT || 40405);
 
-const doRpc = async (message) =>
+const doRpcCall = async (message) =>
   new Promise((resolve) => {
-    logger.info('send rpc request', message);
-    sock.send(JSON.stringify(message), (result) => {
-      logger.info('receive rpc response', result);
-      resolve(result);
+    logger.info('try send rpc request', message);
+    const sock = axon.socket('req');
+    sock.connect(port, host);
+    sock.on('connect', () => {
+      sock.send(JSON.stringify(message), (result) => {
+        logger.info('receive rpc response', result);
+        sock.close();
+        resolve(result);
+      });
     });
   });
 
-module.exports = doRpc;
+const startRpcServer = async () => {
+  try {
+    await kill(port, 'tcp');
+    console.info('Killed existing rpc server');
+  } catch (err) {
+    console.error('Failed to kill existing rpc server', err);
+  }
+
+  console.info(`Rpc Server started on ${new Date().toISOString()}`);
+  const child = spawn('node', [path.join(__dirname, '../processes/updater.js')], {
+    detached: true,
+    windowsHide: true, // required for Windows
+    cwd: process.cwd(),
+    timeout: 60 * 60 * 1000, // 60 minutes
+    shell: process.env.SHELL || false,
+    stdio: ['ignore', process.stdout, process.stderr],
+    env: {
+      PATH: process.env.PATH,
+      PM2_HOME: process.env.PM2_HOME,
+      ABT_NODE_UPDATER_PORT: process.env.ABT_NODE_UPDATER_PORT,
+      ABT_NODE_PACKAGE_NAME: process.env.ABT_NODE_PACKAGE_NAME,
+      ABT_NODE_BINARY_NAME: process.env.ABT_NODE_BINARY_NAME,
+      ABT_NODE_COMMAND_NAME: process.env.ABT_NODE_COMMAND_NAME,
+    },
+  });
+
+  child.on('error', (err) => {
+    console.error('Rpc Server errored', err);
+  });
+
+  child.on('close', (code) => {
+    console.info(`Rpc Server exited with code ${code} on ${new Date().toISOString()}`);
+  });
+
+  child.unref();
+};
+
+module.exports = { doRpcCall, startRpcServer };
+
+// Following script used to test the upgrade process
+// process.env.SHELL = '/opt/homebrew/bin/zsh';
+// process.env.PM2_HOME = '/Users/wangshijun/.arcblock/abtnode';
+// process.env.ABT_NODE_UPDATER_PORT = '40405';
+// process.env.ABT_NODE_PACKAGE_NAME = '@blocklet/cli';
+// process.env.ABT_NODE_BINARY_NAME = 'blocklet';
+// process.env.ABT_NODE_COMMAND_NAME = 'blocklet server';
+// startRpcServer().then(async () => {
+//   let result = await doRpcCall({ command: 'verify', version: '1.16.5' });
+//   console.log(result);
+//   result = await doRpcCall({ command: 'shutdown', version: '1.16.5' });
+//   console.log(result);
+// });

package/lib/util/sysinfo.js

@@ -31,13 +31,15 @@ const getSysInfo = async () => {
     },
     mem: info.mem,
     os: info.osInfo,
-    disks: drives.map((x) => ({
-      device: x.fs,
-      mountPoint: x.mount,
-      total: x.size,
-      used: x.used,
-      free: x.size - x.used,
-    })),
+    disks: drives
+      .map((x) => ({
+        device: x.fs,
+        mountPoint: x.mount,
+        total: x.size,
+        used: x.used,
+        free: x.size - x.used,
+      }))
+      .filter((x) => x.total > 0),
   };
 };
 

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.16.6-beta-8be2fe37",
+  "version": "1.16.6-beta-4ea1eb90",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,39 +19,41 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
   "dependencies": {
-    "@abtnode/auth": "1.16.6-beta-8be2fe37",
-    "@abtnode/certificate-manager": "1.16.6-beta-8be2fe37",
-    "@abtnode/constant": "1.16.6-beta-8be2fe37",
-    "@abtnode/cron": "1.16.6-beta-8be2fe37",
-    "@abtnode/db": "1.16.6-beta-8be2fe37",
-    "@abtnode/logger": "1.16.6-beta-8be2fe37",
-    "@abtnode/queue": "1.16.6-beta-8be2fe37",
-    "@abtnode/rbac": "1.16.6-beta-8be2fe37",
-    "@abtnode/router-provider": "1.16.6-beta-8be2fe37",
-    "@abtnode/static-server": "1.16.6-beta-8be2fe37",
-    "@abtnode/timemachine": "1.16.6-beta-8be2fe37",
-    "@abtnode/util": "1.16.6-beta-8be2fe37",
-    "@arcblock/did": "1.18.71",
+    "@abtnode/auth": "1.16.6-beta-4ea1eb90",
+    "@abtnode/certificate-manager": "1.16.6-beta-4ea1eb90",
+    "@abtnode/constant": "1.16.6-beta-4ea1eb90",
+    "@abtnode/cron": "1.16.6-beta-4ea1eb90",
+    "@abtnode/db": "1.16.6-beta-4ea1eb90",
+    "@abtnode/logger": "1.16.6-beta-4ea1eb90",
+    "@abtnode/queue": "1.16.6-beta-4ea1eb90",
+    "@abtnode/rbac": "1.16.6-beta-4ea1eb90",
+    "@abtnode/router-provider": "1.16.6-beta-4ea1eb90",
+    "@abtnode/static-server": "1.16.6-beta-4ea1eb90",
+    "@abtnode/timemachine": "1.16.6-beta-4ea1eb90",
+    "@abtnode/util": "1.16.6-beta-4ea1eb90",
+    "@arcblock/did": "1.18.72",
+    "@arcblock/did-auth": "1.18.72",
     "@arcblock/did-motif": "^1.1.10",
-    "@arcblock/did-util": "1.18.71",
-    "@arcblock/event-hub": "1.18.71",
-    "@arcblock/jwt": "^1.18.71",
+    "@arcblock/did-util": "1.18.72",
+    "@arcblock/event-hub": "1.18.72",
+    "@arcblock/jwt": "^1.18.72",
     "@arcblock/pm2-events": "^0.0.5",
-    "@arcblock/vc": "1.18.71",
-    "@blocklet/constant": "1.16.6-beta-8be2fe37",
-    "@blocklet/meta": "1.16.6-beta-8be2fe37",
-    "@blocklet/sdk": "1.16.6-beta-8be2fe37",
-    "@did-space/client": "^0.2.74",
+    "@arcblock/vc": "1.18.72",
+    "@blocklet/constant": "1.16.6-beta-4ea1eb90",
+    "@blocklet/meta": "1.16.6-beta-4ea1eb90",
+    "@blocklet/sdk": "1.16.6-beta-4ea1eb90",
+    "@did-space/client": "^0.2.80",
     "@fidm/x509": "^1.2.1",
-    "@ocap/client": "1.18.71",
-    "@ocap/mcrypto": "1.18.71",
-    "@ocap/util": "1.18.71",
-    "@ocap/wallet": "1.18.71",
+    "@ocap/client": "1.18.72",
+    "@ocap/mcrypto": "1.18.72",
+    "@ocap/util": "1.18.72",
+    "@ocap/wallet": "1.18.72",
     "@slack/webhook": "^5.0.4",
     "archiver": "^5.3.1",
     "axios": "^0.27.2",
     "axon": "^2.0.3",
     "chalk": "^4.1.2",
+    "cross-spawn": "^7.0.3",
     "dayjs": "^1.11.7",
     "deep-diff": "^1.0.2",
     "detect-port": "^1.5.1",
@@ -67,8 +69,10 @@
     "is-url": "^1.2.4",
     "joi": "17.7.0",
     "js-yaml": "^4.1.0",
+    "kill-port": "^2.0.1",
     "lodash": "^4.17.21",
     "lru-cache": "^6.0.0",
+    "moment-timezone": "^0.5.37",
     "node-stream-zip": "^1.15.0",
     "p-limit": "^3.1.0",
     "p-retry": "4.6.1",
@@ -78,7 +82,7 @@
     "ssri": "^8.0.1",
     "stream-throttle": "^0.1.3",
     "stream-to-promise": "^3.0.0",
-    "systeminformation": "^5.12.6",
+    "systeminformation": "^5.17.12",
     "tar": "^6.1.11",
     "transliteration": "^2.3.5",
     "ua-parser-js": "^1.0.2",
@@ -93,5 +97,5 @@
     "express": "^4.18.2",
     "jest": "^27.5.1"
   },
-  "gitHead": "27229a1a62850e95907b7a53e0259a809d99377b"
+  "gitHead": "0f0f63b552a88343a3f8e0d434b47c3bca6a75b9"
 }