@abtnode/core 1.15.17 → 1.16.0-beta-8ee536d7

package/lib/blocklet/storage/utils/hash.js

@@ -0,0 +1,51 @@
+const { removeSync, existsSync, move, createReadStream } = require('fs-extra');
+const hasha = require('hasha');
+
+/**
+ *
+ *
+ * @param {NodeJS.ReadableStream} stream1
+ * @param {NodeJS.ReadableStream} stream2
+ * @return {Promise<boolean>}
+ */
+async function compareHash(stream1, stream2) {
+  const hash1 = await hasha.fromStream(stream1, {
+    algorithm: 'md5',
+  });
+  const hash2 = await hasha.fromStream(stream2, {
+    algorithm: 'md5',
+  });
+
+  return hash1 === hash2;
+}
+
+/**
+ *
+ * @description 比对新文件和旧文件的hash，旧文件不存在或者hash不同时，使用新文件替换，hash相同，删除新文件
+ * @param {string} oldFilePath
+ * @param {string} newFilePath
+ * @returns {Promise<boolean>}
+ */
+async function compareAndMove(oldFilePath, newFilePath) {
+  if (!existsSync(oldFilePath)) {
+    await move(newFilePath, oldFilePath, { overwrite: true });
+    return;
+  }
+
+  if (!existsSync(newFilePath)) {
+    throw new Error(`newFilePath(${newFilePath}) not found`);
+  }
+
+  const isSame = await compareHash(createReadStream(oldFilePath), createReadStream(newFilePath));
+  if (isSame) {
+    removeSync(newFilePath);
+    return;
+  }
+
+  await move(newFilePath, oldFilePath, { overwrite: true });
+}
+
+module.exports = {
+  compareHash,
+  compareAndMove,
+};

package/lib/blocklet/storage/utils/zip.js

@@ -0,0 +1,43 @@
+const archiver = require('archiver');
+const { ensureDirSync, existsSync, removeSync, createWriteStream } = require('fs-extra');
+const { dirname } = require('path');
+const StreamZip = require('node-stream-zip');
+
+/**
+ *
+ *
+ * @param {string} source ~/abc/ 通常是一个文件夹
+ * @param {string} target abc.zip 压缩包的名称
+ * @return {*}
+ */
+function dirToZip(source, target) {
+  return new Promise((resolve, reject) => {
+    ensureDirSync(dirname(target));
+
+    if (existsSync(target)) {
+      removeSync(target);
+    }
+
+    const output = createWriteStream(target);
+    const archive = archiver('zip', { level: 9 });
+    archive.on('error', (err) => reject(err));
+    output.on('close', () => resolve());
+
+    archive.directory(source, false);
+
+    archive.pipe(output);
+    archive.finalize();
+  });
+}
+
+async function zipToDir(source, target) {
+  // eslint-disable-next-line new-cap
+  const zip = new StreamZip.async({ file: source });
+  await zip.extract(null, target);
+  await zip.close();
+}
+
+module.exports = {
+  dirToZip,
+  zipToDir,
+};

package/lib/cert.js

@@ -0,0 +1,206 @@
+const { EventEmitter } = require('events');
+const CertificateManager = require('@abtnode/certificate-manager/sdk/manager');
+const logger = require('@abtnode/logger')('@abtnode/core:cert');
+const { EVENTS } = require('@abtnode/constant');
+const { BlockletEvents } = require('@blocklet/constant');
+
+const onCertExpired = async (cert, states) => {
+  logger.info('send certificate expire notification', { domain: cert.domain });
+  states.notification.create({
+    title: 'SSL Certificate Expired',
+    description: `Your SSL certificate for domain ${cert.domain} has expired, please update it in Blocklet Server`,
+    severity: 'error',
+    entityType: 'certificate',
+    entityId: cert.id,
+  });
+};
+
+const onCertAboutExpire = (cert, states) => {
+  logger.info('send certificate about-expire notification', { domain: cert.domain });
+  states.notification.create({
+    title: 'SSL Certificate Expire Warning',
+    description: `Your SSL certificate for domain ${cert.domain} will expire in ${
+      cert.expireInDays
+    } days (on ${new Date(cert.validTo).toLocaleString()}), please remember to update it in Blocklet Server`,
+    severity: 'warning',
+    entityType: 'certificate',
+    entityId: cert.id, // eslint-disable-line no-underscore-dangle
+  });
+};
+
+const onCertIssued = (cert, states) => {
+  states.notification.create({
+    title: 'Certificate Issued',
+    description: `The ${cert.domain} certificate is issued successfully`,
+    severity: 'success',
+    entityType: 'certificate',
+    entityId: cert.id,
+  });
+};
+
+const onCertIssueFailed = (cert, states) => {
+  states.notification.create({
+    title: 'Certificate Issue Failed',
+    description: `Failed to issue certificate for ${cert.domain}`,
+    severity: 'error',
+    entityType: 'certificate',
+    entityId: cert.id,
+  });
+};
+
+const getDomainFromInput = (input) => {
+  if (Object.prototype.toString.call(input) === '[object Object]') {
+    return input.domain;
+  }
+
+  return input;
+};
+
+class Cert extends EventEmitter {
+  constructor({ maintainerEmail, dataDir, states }) {
+    super();
+
+    this.manager = new CertificateManager({ maintainerEmail, dataDir });
+
+    this.manager.on('cert.issued', this._onCertIssued.bind(this));
+    this.manager.on('cert.expired', this._onCertExpired.bind(this));
+    this.manager.on('cert.about_to_expire', this._onCertAboutToExpire.bind(this));
+    this.manager.on('cert.error', this._onCertError.bind(this));
+
+    /**
+     * Array<{domain: string, did: string}>
+     */
+    this._blockletDomains = [];
+    this.states = states;
+  }
+
+  start() {
+    return this.manager.start();
+  }
+
+  static fixCertificate(entity) {
+    // Hack: this logic exists because gql does not allow line breaks in arg values
+    entity.privateKey = entity.privateKey.split('|').join('\n');
+    entity.certificate = entity.certificate.split('|').join('\n');
+  }
+
+  getAll() {
+    return this.manager.getAll();
+  }
+
+  getAllNormal() {
+    return this.manager.getAllNormal();
+  }
+
+  getNormalByDomain(domain) {
+    return this.manager.getNormalByDomain(domain);
+  }
+
+  getByDomain(inputDomain) {
+    const domain = getDomainFromInput(inputDomain);
+    return this.manager.getByDomain(domain);
+  }
+
+  async add(data) {
+    if (!data.certificate || !data.privateKey) {
+      throw new Error('certificate and privateKey are required');
+    }
+
+    Cert.fixCertificate(data);
+
+    const result = await this.manager.add(data);
+    logger.info('add certificate result', { name: result.name });
+    this.emit(EVENTS.CERT_ADDED, result);
+
+    return result;
+  }
+
+  /**
+   * @param {{
+   *   did?:string // blocklet.meta.did
+   * }}
+   */
+  async issue({ domain, did }) {
+    logger.info(`generate certificate for ${domain}`);
+
+    if (did) {
+      this._bindBlocklet({ domain, did });
+    }
+
+    return this.manager.issue(domain);
+  }
+
+  async upsertByDomain(data) {
+    const result = await this.manager.upsertByDomain(data);
+    this.emit(EVENTS.CERT_UPDATED, result);
+
+    return result;
+  }
+
+  async update(data) {
+    return this.manager.update(data.id, { name: data.name, public: data.public });
+  }
+
+  async remove({ id }) {
+    await this.manager.remove(id);
+    logger.info('delete certificate', { id });
+    this.emit(EVENTS.CERT_REMOVED);
+
+    return {};
+  }
+
+  async addWithoutValidations(data) {
+    return this.manager.addWithoutValidations(data);
+  }
+
+  async updateWithoutValidations(id, data) {
+    return this.manager.updateWithoutValidations(id, data);
+  }
+
+  _bindBlocklet({ domain, did }) {
+    // only save 100 domains in memory
+    const list = this._blockletDomains.slice(-100).filter((x) => x.domain !== domain);
+    list.push({ domain, did });
+    this._blockletDomains = list;
+  }
+
+  /**
+   * @param {{
+   *   blocklet: string;
+   *   server: string;
+   * }} event
+   * @param {{
+   *   domain: string
+   * }} cert
+   */
+  _emitEvent(event, cert) {
+    const blockletDomain = this._blockletDomains.find((x) => x.domain === cert.domain);
+    if (blockletDomain) {
+      this.emit(event.blocklet, { ...cert, meta: { did: blockletDomain.did } });
+    } else {
+      this.emit(event.server, cert);
+    }
+  }
+
+  _onCertIssued(cert) {
+    this._emitEvent({ blocklet: BlockletEvents.certIssued, server: EVENTS.CERT_ISSUED }, cert);
+
+    onCertIssued(cert, this.states);
+  }
+
+  _onCertError(cert) {
+    this._emitEvent({ blocklet: BlockletEvents.certError, server: EVENTS.CERT_ERROR }, cert);
+
+    onCertIssueFailed(cert, this.states);
+  }
+
+  _onCertExpired(cert) {
+    onCertExpired(cert, this.states);
+  }
+
+  _onCertAboutToExpire(cert) {
+    onCertAboutExpire(cert, this.states);
+  }
+}
+
+module.exports = Cert;

package/lib/event.js

@@ -1,20 +1,23 @@
+const get = require('lodash/get');
+const cloneDeep = require('lodash/cloneDeep');
 const { EventEmitter } = require('events');
-const { BLOCKLET_MODES } = require('@blocklet/meta/lib/constants');
+const { wipeSensitiveData } = require('@blocklet/meta/lib/util');
 const logger = require('@abtnode/logger')('@abtnode/core:event');
-const { BlockletStatus, BlockletSource, BlockletEvents } = require('@blocklet/meta/lib/constants');
+const { BLOCKLET_MODES, BlockletStatus, BlockletSource, BlockletEvents } = require('@blocklet/constant');
+const { EVENTS } = require('@abtnode/constant');
+const handleInstanceInStore = require('./util/public-to-store');
 
 const eventHub =
   process.env.NODE_ENV === 'test' ? require('@arcblock/event-hub/single') : require('@arcblock/event-hub');
 
-const { isCLI } = require('./util');
 const states = require('./states');
+const { isBeforeInstalled } = require('./util');
 
 const routingSnapshotPrefix = (blocklet) => (blocklet.mode === BLOCKLET_MODES.DEVELOPMENT ? '[DEV] ' : '');
 
 // Initialize the event queue: this will make events across process
 module.exports = ({
   blockletManager,
-  blockletRegistry,
   ensureBlockletRouting,
   ensureBlockletRoutingForUpgrade,
   removeBlockletRouting,
@@ -22,34 +25,63 @@ module.exports = ({
   handleRouting,
   domainStatus,
   teamAPI,
+  teamManager,
+  certManager,
+  routerManager,
+  node,
+  nodeRuntimeMonitor,
 }) => {
   const notificationState = states.notification;
   const nodeState = states.node;
 
   const events = new EventEmitter();
-  // HACK: do not emit any events from CLI
-  if (isCLI() && process.env.NODE_ENV !== 'test') {
-    events.emit = (name) => logger.debug('stopped core state event in CLI', name);
-  }
-
-  // Push events to event hub for other process to consume
-  const originEmit = events.emit.bind(events);
-  events.emit = (name, ...args) => {
-    logger.debug('proxy event to event hub', { name });
-    eventHub.broadcast(name, ...args);
-    originEmit(name, ...args);
-  };
+  events.setMaxListeners(0);
 
   let eventHandler = null;
+  events.setEventHandler = (handler) => {
+    if (typeof handler === 'function') {
+      eventHandler = handler;
+    }
+  };
+
+  // Listen events from eventHub and call eventHandler
+  [...Object.values(BlockletEvents), ...Object.values(EVENTS)].forEach((name) => {
+    eventHub.on(name, (data) => {
+      if (name === BlockletEvents.removed) {
+        // Cleanup cache in teamManager for every node instance
+        teamManager.deleteTeam(data?.meta?.did, { closeDatabase: false });
+      }
 
+      if (typeof eventHandler === 'function') {
+        eventHandler({ name, data });
+      }
+    });
+  });
+
+  // Wipe sensitive data
+  // Emit events to event hub
+  // Emit events to node listener
   const onEvent = (name, data) => {
+    let safeData = data;
+    if (get(data, 'meta.did', '')) {
+      safeData = wipeSensitiveData(cloneDeep(data));
+    }
+
+    logger.debug('proxy event to event hub', { name });
+    eventHub.broadcast(name, safeData);
+    events.emit(name, safeData);
+  };
+
+  // Emit events to node listener
+  // Call eventHandler
+  const onInternalEvent = (name, data) => {
     events.emit(name, data);
     if (typeof eventHandler === 'function') {
       eventHandler({ name, data });
     }
   };
 
-  const handleBlockletAdd = async (name, { blocklet, context }) => {
+  const handleBlockletInstall = async (name, { blocklet, context }) => {
     try {
       const changed = await ensureBlockletRouting(blocklet, context);
       if (changed) {
@@ -72,11 +104,13 @@ module.exports = ({
         severity: 'error',
       });
     }
-
-    onEvent(name, blocklet);
   };
 
   const handleBlockletRemove = async (name, { blocklet, context }) => {
+    if (context?.skipAll) {
+      return;
+    }
+
     try {
       const changed = await removeBlockletRouting(blocklet, context);
 
@@ -96,8 +130,6 @@ module.exports = ({
     } catch (error) {
       logger.error('prune blocklet app folder error', { event: name, error });
     }
-
-    onEvent(name, blocklet);
   };
 
   const handleBlockletUpgrade = async (name, { blocklet, context }) => {
@@ -114,6 +146,14 @@ module.exports = ({
       await teamAPI.refreshBlockletInterfacePermissions(blocklet.meta);
     } catch (error) {
       logger.error('upgrade blocklet routing rules error', { event: name, error });
+      notificationState.create({
+        title: 'Blocklet URL Mapping Error',
+        // eslint-disable-next-line max-len
+        description: `Failed to upgrade URL mapping for blocklet ${blocklet.meta.name}@${blocklet.meta.version}, due to: ${error.message}`,
+        entityType: 'blocklet',
+        entityId: blocklet.meta.did,
+        severity: 'error',
+      });
     }
 
     try {
@@ -121,11 +161,9 @@ module.exports = ({
     } catch (error) {
       logger.error('prune blocklet app folder error', { event: name, error });
     }
-
-    onEvent(name, blocklet);
   };
 
-  const handleCLIEvent = (eventName) => {
+  const handleServerEvent = (eventName) => {
     const [, status] = eventName.split('.');
     onEvent(eventName, {
       title: `Blocklet Server ${status}`,
@@ -135,6 +173,108 @@ module.exports = ({
     });
   };
 
+  /**
+   *
+   * @description 事件必须注册在这里才能被发布出去
+   * @param {string} eventName
+   * @param {any} payload
+   */
+  const handleBlockletEvent = async (eventName, payload) => {
+    const blocklet = payload.blocklet || payload;
+
+    if ([BlockletEvents.installed].includes(eventName)) {
+      await handleBlockletInstall(eventName, payload);
+
+      try {
+        await node.createAuditLog({
+          action: 'installBlocklet',
+          args: {
+            did: blocklet.meta.did,
+          },
+          context: payload.context || {},
+          result: blocklet,
+        });
+      } catch (error) {
+        logger.error('Failed to createAuditLog for installBlocklet', { error });
+      }
+    } else if ([BlockletEvents.upgraded, BlockletEvents.downgraded].includes(eventName)) {
+      await handleBlockletUpgrade(eventName, payload);
+
+      if (payload?.context?.createAuditLog !== false) {
+        try {
+          await node.createAuditLog({
+            action: 'upgradeBlocklet',
+            args: {
+              did: blocklet.meta.did,
+            },
+            context: payload.context || {},
+            result: blocklet,
+          });
+        } catch (error) {
+          logger.error('Failed to createAuditLog for upgradeBlocklet', { error });
+        }
+      }
+    } else if ([BlockletEvents.removed, BlockletEvents.dataCleaned].includes(eventName)) {
+      await handleBlockletRemove(eventName, payload);
+    } else if ([BlockletEvents.started].includes(eventName)) {
+      const { publicToStore } = blocklet.settings || {};
+      if (publicToStore) {
+        handleInstanceInStore(blocklet, { publicToStore }).catch((error) => {
+          logger.error('handleInstanceInStore failed', { message: error.message });
+        });
+      }
+    } else if ([BlockletEvents.upgradeFailed, BlockletEvents.downgradeFailed].includes(eventName)) {
+      try {
+        await node.createAuditLog({
+          action: 'upgradeBlocklet',
+          args: {
+            did: blocklet.meta.did,
+          },
+          context: payload.context || {},
+          result: {
+            ...blocklet,
+            resultStatus: 'failed',
+          },
+        });
+      } catch (error) {
+        logger.error('Failed to createAuditLog for upgradeBlocklet failed', { error });
+      }
+    } else if (BlockletEvents.appDidChanged === eventName) {
+      const hash = await takeRoutingSnapshot(
+        { message: `${routingSnapshotPrefix(blocklet)}Update blocklet ${blocklet.meta.name} app did`, dryRun: false },
+        get(payload, 'context') || {}
+      );
+
+      logger.info('take snapshot after updated blocklet app', { event: eventName, did: blocklet.meta.did, hash });
+    } else if (BlockletEvents.spaceConnected === eventName) {
+      nodeState
+        .read()
+        .then((info) => handleRouting(info))
+        .catch((err) => {
+          logger.error('Reload gateway failed on blocklet.connectedSpace', { error: err });
+        });
+      logger.info('Reload gateway after blocklet connected to space', { event: eventName, did: blocklet.appDid });
+    }
+
+    if (
+      ![BlockletEvents.removed, BlockletEvents.dataCleaned].includes(eventName) &&
+      blocklet.status &&
+      !isBeforeInstalled(blocklet.status)
+    ) {
+      try {
+        await blockletManager.runtimeMonitor.monit(blocklet.meta.did);
+      } catch (error) {
+        logger.error('monit runtime info failed', { eventName, error });
+      }
+    }
+
+    if (payload.blocklet && !payload.meta) {
+      onEvent(eventName, payload.blocklet);
+    } else {
+      onEvent(eventName, payload);
+    }
+  };
+
   const downloadAddedBlocklet = async () => {
     try {
       const blocklets = await states.blocklet.find({
@@ -151,31 +291,50 @@ module.exports = ({
     }
   };
 
-  blockletManager.on(BlockletEvents.statusChange, (data) => onEvent(BlockletEvents.statusChange, data));
-  blockletManager.on(BlockletEvents.added, (data) => onEvent(BlockletEvents.added, data));
-  blockletManager.on(BlockletEvents.installed, (data) => handleBlockletAdd(BlockletEvents.installed, data));
-  blockletManager.on(BlockletEvents.installFailed, (data) => onEvent(BlockletEvents.installFailed, data));
-  blockletManager.on(BlockletEvents.deployed, (data) => handleBlockletAdd(BlockletEvents.deployed, data));
-  blockletManager.on(BlockletEvents.started, (data) => onEvent(BlockletEvents.started, data));
-  blockletManager.on(BlockletEvents.startFailed, (data) => onEvent(BlockletEvents.startFailed, data));
-  blockletManager.on(BlockletEvents.reloaded, (data) => onEvent(BlockletEvents.reloaded, data));
-  blockletManager.on(BlockletEvents.updated, (data) => onEvent(BlockletEvents.updated, data));
-  blockletManager.on(BlockletEvents.downloadFailed, (data) => onEvent(BlockletEvents.downloadFailed, data));
-  blockletManager.on(BlockletEvents.upgraded, (data) => handleBlockletUpgrade(BlockletEvents.upgraded, data));
-  blockletManager.on(BlockletEvents.downgraded, (data) => handleBlockletUpgrade(BlockletEvents.downgraded, data));
-  blockletManager.on(BlockletEvents.removed, (data) => handleBlockletRemove(BlockletEvents.removed, data));
-  notificationState.on('notification.create', (data) => onEvent('notification.create', data));
-  nodeState.on(BlockletEvents.purchaseChange, (data) => onEvent(BlockletEvents.purchaseChange, data));
-  nodeState.on('routing.updated', (nodeInfo) => onEvent('routing.updated', { routing: nodeInfo.routing }));
-  nodeState.once('node.addedOwner', () => downloadAddedBlocklet());
-  nodeState.on('node.updated', (nodeInfo, oldInfo) => {
-    onEvent('node.updated', { did: nodeInfo.did });
-    blockletRegistry
-      .refreshBlocklets()
-      .catch((error) => logger.error('refresh blocklets failed on initialize the registry', { error }));
+  /**
+   *
+   *
+   * @param {*} subject
+   * @param {string} event
+   * @param {(event: string, data: any) => Promise<void> | void} handler
+   */
+  const listen = (subject, event, handler) => subject.on(event, (data) => handler(event, data));
+
+  [
+    BlockletEvents.added,
+    BlockletEvents.downloadFailed,
+    BlockletEvents.installed,
+    BlockletEvents.installFailed,
+    BlockletEvents.upgraded,
+    BlockletEvents.upgradeFailed,
+    BlockletEvents.downgraded,
+    BlockletEvents.downgradeFailed,
+    BlockletEvents.updated,
+    BlockletEvents.statusChange,
+    BlockletEvents.removed,
+    BlockletEvents.started,
+    BlockletEvents.startFailed,
+    BlockletEvents.stopped,
+    BlockletEvents.appDidChanged,
+
+    BlockletEvents.backupProgress,
+    BlockletEvents.restoreProgress,
+
+    BlockletEvents.spaceConnected,
+  ].forEach((eventName) => {
+    listen(blockletManager, eventName, handleBlockletEvent);
+  });
+
+  listen(notificationState, EVENTS.NOTIFICATION_CREATE, onEvent);
+
+  listen(nodeState, BlockletEvents.purchaseChange, onEvent);
+  nodeState.on(EVENTS.ROUTING_UPDATED, (nodeInfo) => onEvent(EVENTS.ROUTING_UPDATED, { routing: nodeInfo.routing }));
+  nodeState.once(EVENTS.NODE_ADDED_OWNER, () => downloadAddedBlocklet());
+  nodeState.on(EVENTS.NODE_UPDATED, (nodeInfo, oldInfo) => {
+    onEvent(EVENTS.NODE_UPDATED, { did: nodeInfo.did });
 
     // We need update router on some fields change
-    const fields = ['enableWelcomePage', 'webWalletUrl'];
+    const fields = ['enableWelcomePage', 'webWalletUrl', 'registerUrl'];
     const shouldUpdateRouter = fields.some((x) => nodeInfo[x] !== oldInfo[x]);
     if (shouldUpdateRouter) {
       handleRouting(nodeInfo).catch((err) => {
@@ -183,26 +342,40 @@ module.exports = ({
       });
     }
   });
-  nodeState.on('node.upgrade.progress', (session) => onEvent('node.upgrade.progress', session));
-  domainStatus.on('domain.status', (data) => {
-    if (data) {
-      onEvent('domain.status', data);
-    }
+
+  listen(nodeState, EVENTS.NODE_MAINTAIN_PROGRESS, onEvent);
+  nodeState.on(EVENTS.RELOAD_GATEWAY, (nodeInfo) => {
+    handleRouting(nodeInfo).catch((err) => {
+      logger.error('Handle routing failed on node.updated', { error: err });
+    });
   });
-  teamAPI.on('user.added', (data) => onEvent('user.added', data));
-  teamAPI.on('user.removed', (data) => onEvent('user.removed', data));
-  teamAPI.on('user.updated', (data) => onEvent('user.updated', data));
-  teamAPI.on(BlockletEvents.updated, (data) => onEvent(BlockletEvents.updated, data));
 
-  events.setEventHandler = (handler) => {
-    if (typeof handler === 'function') {
-      eventHandler = handler;
-    }
-  };
+  [EVENTS.DOMAIN_STATUS, BlockletEvents.domainStatus].forEach((eventName) => {
+    domainStatus.on(eventName, (data) => {
+      if (data) {
+        onEvent(eventName, data);
+      }
+    });
+  });
+
+  listen(teamAPI, EVENTS.USER_ADDED, onEvent);
+  listen(teamAPI, EVENTS.USER_REMOVED, onEvent);
+  listen(teamAPI, EVENTS.USER_UPDATED, onEvent);
+  listen(teamAPI, BlockletEvents.updated, onEvent);
+  listen(teamManager, BlockletEvents.storeChange, onEvent);
+
+  listen(certManager, EVENTS.CERT_ISSUED, onEvent);
+  listen(certManager, EVENTS.CERT_ERROR, onEvent);
+  listen(certManager, BlockletEvents.certIssued, onEvent);
+  listen(certManager, BlockletEvents.certError, onEvent);
+
+  listen(routerManager, BlockletEvents.updated, onEvent);
+
+  listen(nodeRuntimeMonitor, EVENTS.NODE_RUNTIME_INFO, onInternalEvent);
+  listen(blockletManager.runtimeMonitor, EVENTS.BLOCKLETS_RUNTIME_INFO, onInternalEvent);
 
-  events.handleBlockletAdd = handleBlockletAdd;
-  events.handleBlockletRemove = handleBlockletRemove;
-  events.handleCLIEvent = handleCLIEvent;
+  events.handleServerEvent = handleServerEvent;
+  events.handleBlockletEvent = handleBlockletEvent;
 
   return events;
 };