@abtnode/core 1.16.14-beta-a898bfcb → 1.16.14-beta-d802cd3c

package/lib/util/launcher.js

@@ -2,8 +2,13 @@ const path = require('path');
 const fs = require('fs-extra');
 const joinUrl = require('url-join');
 const pick = require('lodash/pick');
-const joinURL = require('url-join');
-const { parseUserAvatar, extractUserAvatar, getAvatarFile, getAvatarByUrl } = require('@abtnode/util/lib/user');
+const {
+  getUserAvatarUrl,
+  extractUserAvatar,
+  getAvatarFile,
+  getAvatarByUrl,
+  getAppAvatarUrl,
+} = require('@abtnode/util/lib/user');
 const { Hasher } = require('@ocap/mcrypto');
 const { getDisplayName } = require('@blocklet/meta/lib/util');
 const getBlockletInfo = require('@blocklet/meta/lib/info');
@@ -99,7 +104,7 @@ const setupAppOwner = async (node, sessionId) => {
       throw new Error(`Owner user not found from launcher: ${launcherUrl}`);
     }
     appOwnerProfile = pick(user, ['fullName', 'email', 'avatar']);
-    const avatarBase64 = await getAvatarByUrl(joinURL(launcherUrl, user.avatar));
+    const avatarBase64 = await getAvatarByUrl(joinUrl(launcherUrl, user.avatar));
     appOwnerProfile.avatar = await extractUserAvatar(avatarBase64, { dataDir });
     logger.info('Create owner from launcher for blocklet', { appDid, ownerDid, ownerPk, sessionId, appOwnerProfile });
   } else {
@@ -115,7 +120,7 @@ const setupAppOwner = async (node, sessionId) => {
       fs.mkdirpSync(path.dirname(destFile));
       fs.copyFileSync(srcFile, destFile);
     } else {
-      appOwnerProfile.avatar = extractUserAvatar(user.avatar, { dataDir });
+      appOwnerProfile.avatar = await extractUserAvatar(user.avatar, { dataDir });
     }
     logger.info('Create owner from session for blocklet', { appDid, ownerDid, ownerPk, sessionId, appOwnerProfile });
   }
@@ -125,6 +130,7 @@ const setupAppOwner = async (node, sessionId) => {
   const vc = createPassportVC({
     issuerName: getDisplayName(blocklet),
     issuerWallet: wallet,
+    issuerAvatarUrl: getAppAvatarUrl(appUrl),
     ownerDid,
     passport: await createPassport({
       name: role,
@@ -138,7 +144,7 @@ const setupAppOwner = async (node, sessionId) => {
       userDid: ownerDid,
       teamDid: appDid,
     }),
-    ownerProfile: { ...appOwnerProfile, avatar: await parseUserAvatar(user.avatar, { dataDir: serverDataDir }) },
+    ownerProfile: { ...appOwnerProfile, avatar: getUserAvatarUrl(appUrl, appOwnerProfile.avatar) },
     preferredColor: 'default',
     expirationDate: undefined,
   });

package/lib/util/log.js

@@ -0,0 +1,403 @@
+/* eslint-disable no-underscore-dangle */
+const path = require('path');
+const createArchive = require('archiver');
+const fs = require('fs-extra');
+const glob = require('fast-glob');
+const isEqual = require('lodash/isEqual');
+const { Tail } = require('tail');
+const readLastLines = require('read-last-lines');
+const { BLOCKLET_MODES } = require('@blocklet/constant');
+const { findComponentByIdV2 } = require('@blocklet/meta/lib/util');
+const dayjs = require('@abtnode/util/lib/dayjs');
+const logger = require('@abtnode/logger')(require('../../package.json').name);
+
+class StreamLog {
+  constructor() {
+    this._files = null; // Object { <level>: <filePath> }
+    this._tails = null; // Object { <level>: <Tail> }
+  }
+
+  /**
+   * @param {Object} files Object { <level>: <filePath> }
+   * @return {Boolean} if files change
+   */
+  setFiles(files) {
+    if (!isEqual(this._files, files)) {
+      this.clearTails();
+      this._files = files;
+      return true;
+    }
+    return false;
+  }
+
+  getRecent(lineNum, callback) {
+    if (!this._files) {
+      callback(new Error('files is empty'));
+    }
+    Object.entries(this._files).forEach(([level, file]) => {
+      if (!file || !fs.existsSync(file)) {
+        return;
+      }
+      readLastLines
+        .read(file, lineNum || 0)
+        .then((data) => {
+          callback(null, level, data);
+        })
+        .catch((error) => {
+          callback(error, level);
+        });
+    });
+  }
+
+  ensureTails() {
+    if (this._tails) {
+      return this._tails;
+    }
+    if (!this._files) {
+      return {};
+    }
+    try {
+      this._tails = {};
+      Object.entries(this._files).forEach(([level, file]) => {
+        if (!file || !fs.existsSync(file)) {
+          return;
+        }
+
+        // 测试发现 Windows 下 fs.watch 没有效果，但是 fs.watch 的性能更好，所以只在 windows 下使用 fs.watchFile
+        this._tails[level] = new Tail(file, {
+          useWatchFile: process.platform === 'win32',
+          fsWatchOptions: { interval: 1500 },
+        });
+      });
+      return this._tails;
+    } catch (error) {
+      this._tails = null;
+      throw error;
+    }
+  }
+
+  clearTails() {
+    if (this._tails) {
+      Object.values(this._tails).forEach((tail) => {
+        tail.unwatch();
+      });
+      this._tails = null;
+    }
+  }
+}
+
+const createFile = (files) => {
+  Object.values(files).forEach((file) => {
+    if (!fs.existsSync(file)) {
+      try {
+        const dir = path.dirname(file);
+        fs.mkdirSync(dir, { recursive: true });
+      } catch (err) {
+        // Do nothing
+      }
+      fs.writeFileSync(file, '', 'utf8');
+    }
+  });
+};
+
+const getLogFiles = async ({ name, node }) => {
+  const dt = new Date();
+  const { yyyy, mm, dd } = {
+    yyyy: dt.getFullYear(),
+    mm: `${dt.getMonth() + 1}`.padStart(2, 0),
+    dd: `${dt.getDate()}`.padStart(2, 0),
+  };
+  const date = `${yyyy}-${mm}-${dd}`;
+
+  if (name === 'abtnode') {
+    const logDir = path.join(node.dataDirs.logs, '_abtnode');
+
+    const info = path.join(logDir, `daemon-${date}.log`);
+    const error = path.join(logDir, `daemon-error-${date}.log`);
+    const access = path.join(logDir, 'access.log');
+    const stdout = path.join(logDir, 'daemon.stdout.log');
+    const stderr = path.join(logDir, 'daemon.stderr.log');
+
+    createFile({
+      info,
+      error,
+      access,
+      stdout,
+      stderr,
+    });
+
+    return {
+      info,
+      error,
+      access,
+      stdout,
+      stderr,
+    };
+  }
+
+  if (name === 'blocklet-services') {
+    const logDir = path.join(node.dataDirs.logs, '_abtnode');
+    const info = path.join(logDir, 'service.log');
+    const error = path.join(logDir, 'service.error.log');
+    createFile({ info, error });
+    return { info, error };
+  }
+
+  if (name.indexOf('blocklet-') === 0) {
+    const did = name.substring('blocklet-'.length);
+    const [appId, componentId] = did.split('/');
+    const blocklet = await node.getBlocklet({ did: appId, useCache: true });
+    let { name: blockletName } = blocklet.meta;
+
+    if (componentId) {
+      const component = findComponentByIdV2(blocklet, componentId);
+      if (component) {
+        blockletName = path.join(blockletName, component.meta.name);
+      }
+    }
+
+    const dir = path.join(node.dataDirs.logs, blockletName);
+    const info = path.join(dir, `info-${date}.log`);
+    const error = path.join(dir, `info-error-${date}.log`);
+    const access = path.join(dir, 'access.log');
+    const stdout = path.join(dir, 'output.log');
+    const stderr = path.join(dir, 'error.log');
+
+    createFile({
+      info,
+      error,
+      access,
+      stdout,
+      stderr,
+    });
+
+    return {
+      info,
+      error,
+      access,
+      stdout,
+      stderr,
+      recent: blocklet.mode === BLOCKLET_MODES.DEVELOPMENT ? 0 : 100,
+    };
+  }
+
+  if (name.startsWith('service-gateway-')) {
+    const providerName = name.substring('service-gateway-'.length);
+    const provider = node.getRouterProvider(providerName);
+    if (!provider) {
+      logger.error('router engine is empty', { name, providerName });
+      return {};
+    }
+
+    return provider.getLogFilesForToday();
+  }
+
+  return {};
+};
+
+const getDownloadLogFilesFromServer = async ({ dates, nodeInfo, node } = {}) => {
+  const logDir = path.join(node.dataDirs.logs, '_abtnode');
+
+  const pm2Log = path.join(logDir, 'pm2.log');
+  const pm2LogSrc = path.join(process.env.PM2_HOME, 'pm2.log');
+  if (fs.existsSync(pm2LogSrc)) {
+    await fs.copy(pm2LogSrc, pm2Log);
+  }
+
+  const provider = node.getRouterProvider(nodeInfo.routing.provider);
+  if (!provider) {
+    logger.error('router engine is empty');
+  }
+
+  const list = [];
+
+  dates.forEach((d) => {
+    // log file created by @abtnode/log
+    // log file created by abt-node-log-rotate
+    list.push(path.join(logDir, `*-${d}*`));
+
+    // log file create by router
+    const routerLogDir = provider.getLogDir();
+    if (routerLogDir) {
+      list.push(path.join(routerLogDir, `*-${d}*`));
+    }
+  });
+
+  // abt-node-daemon console & gateway
+  list.push(path.join(logDir, 'daemon.stdout.log*'));
+  list.push(path.join(logDir, 'daemon.stderr.log*'));
+  list.push(path.join(logDir, 'access.log*'));
+
+  // abt-node-service console & gateway
+  list.push(path.join(logDir, 'service.output.log*'));
+  list.push(path.join(logDir, 'service.error.log*'));
+  list.push(path.join(logDir, 'service.log*'));
+
+  // abt-node-db-hub console & backup
+  list.push(path.join(logDir, 'db.output.log*'));
+  list.push(path.join(logDir, 'db.error.log*'));
+
+  // abt-node-event-hub console
+  list.push(path.join(logDir, 'event.output.log*'));
+  list.push(path.join(logDir, 'event.error.log*'));
+
+  // abt-node-log-rotate console
+  list.push(path.join(logDir, 'pm2-logrotate.stdout.log*'));
+  list.push(path.join(logDir, 'pm2-logrotate.stderr.log*'));
+
+  // abt-node-updater console
+  list.push(path.join(logDir, 'updater.error.log*'));
+  list.push(path.join(logDir, 'updater.output.log*'));
+
+  // fallback log
+  list.push(path.join(logDir, 'stderr.log*'));
+  list.push(path.join(logDir, 'stdout.log*'));
+
+  // router
+  list.push(...Object.values(provider.getLogFilesForToday() || {}));
+
+  // pm2 log
+  list.push(pm2Log);
+
+  return glob(list);
+};
+
+const getDownloadLogFilesFromBlocklet = ({ dates, blocklet } = {}) => {
+  const appLogDir = path.join(blocklet.env.logsDir);
+  const componentLogDirs = blocklet.children.map((c) => path.join(c.env.logsDir));
+
+  const list = [];
+
+  [appLogDir, ...componentLogDirs].forEach((logDir) => {
+    dates.forEach((d) => {
+      // log file created by @abtnode/log
+      // log file created by abt-node-log-rotate
+      list.push(path.join(logDir, `*-${d}*`));
+    });
+
+    list.push(path.join(logDir, 'output.log*'));
+    list.push(path.join(logDir, 'error.log*'));
+    list.push(path.join(logDir, 'access.log*'));
+  });
+
+  return glob(list);
+};
+
+const getDownloadLogFiles = async ({ did, node, days = 1, now } = {}) => {
+  const dates = [dayjs(now).format('YYYY-MM-DD')];
+
+  for (let i = 1; i <= days; i++) {
+    dates.unshift(dayjs(now).subtract(i, 'day').format('YYYY-MM-DD'));
+  }
+
+  const nodeInfo = await node.getNodeInfo({ useCache: true });
+
+  if (nodeInfo.did === did) {
+    return getDownloadLogFilesFromServer({ dates, node, nodeInfo });
+  }
+
+  const blocklet = await node.getBlocklet({ did });
+  if (!blocklet) {
+    throw new Error('blocklet not found');
+  }
+
+  return getDownloadLogFilesFromBlocklet({ dates, blocklet });
+};
+
+const createStreamLogManager = ({ onLog, onGetLogFiles }) => {
+  const store = {}; // Object<name: streamLog>
+
+  const ensure = (name) => {
+    if (!store[name]) {
+      store[name] = new StreamLog();
+    }
+    return store[name];
+  };
+
+  const destroy = (name) => {
+    logger.info('log stream: destroy', { name });
+    if (!store[name]) {
+      return;
+    }
+    const log = store[name];
+    try {
+      log.clearTails();
+      delete store[name];
+    } catch (error) {
+      logger.error('log stream: remove ref error ', error);
+      delete store[name];
+    }
+  };
+
+  const add = async (name, topic, firstLogCb) => {
+    logger.info('log stream: add', { name });
+    const log = ensure(name);
+    try {
+      // update files
+      // push recent 100 log
+      const { recent = 100, ...logFiles } = await onGetLogFiles(name);
+      const changed = await log.setFiles(logFiles);
+      logger.info('log stream: added', { name, logFiles });
+      log.getRecent(recent, (error, level, data) => {
+        if (error) {
+          logger.error('log stream error ', error);
+        }
+        if (firstLogCb) {
+          firstLogCb(level, data, logFiles);
+        }
+      });
+      // stream
+      if (changed) {
+        const tails = log.ensureTails();
+        Object.entries(tails).forEach(([level, tail]) => {
+          tail.on('line', (data) => {
+            onLog({ topic, level, logFiles, data });
+          });
+          tail.on('error', (error) => {
+            logger.error('log tail error ', { error });
+            destroy(name);
+          });
+        });
+      }
+    } catch (error) {
+      logger.error('log stream error ', error);
+    }
+  };
+
+  return {
+    add,
+    destroy,
+  };
+};
+
+const createDownloadLogStream = async ({ node, did, days, now }) => {
+  const files = await getDownloadLogFiles({ node, did, days, now });
+
+  if (!files.length) {
+    throw new Error('Log file does not found');
+  }
+
+  const cwd = path.dirname(node.dataDirs.logs);
+
+  const archive = createArchive('zip', { zlib: { level: 9 } });
+  files.forEach((x) => {
+    archive.file(x, {
+      name: x.replace(`${cwd}/logs`, '/logs').replace(`${cwd}`, '/logs').replace('/_abtnode', '/blocklet-server'),
+    });
+  });
+
+  archive.rawPipe = archive.pipe.bind(archive);
+  archive.pipe = (s) => {
+    archive.rawPipe(s);
+    archive.finalize();
+  };
+
+  return archive;
+};
+
+module.exports = {
+  createStreamLogManager,
+  getLogFiles,
+  getDownloadLogFiles,
+  createDownloadLogStream,
+};

package/lib/util/store.js

@@ -1,4 +1,4 @@
-const joinURL = require('url-join');
+const joinUrl = require('url-join');
 const pick = require('lodash/pick');
 const isBase64 = require('is-base64');
 
@@ -47,7 +47,7 @@ const fixAndVerifyMetaFromStore = (meta) => {
 };
 
 const validateStoreUrl = async (registry) => {
-  const url = joinURL(registry, BLOCKLET_STORE_API_PREFIX, `/blocklets.json?__t__=${Date.now()}`);
+  const url = joinUrl(registry, BLOCKLET_STORE_API_PREFIX, `/blocklets.json?__t__=${Date.now()}`);
   try {
     const res = await request.get(url);
     if (Array.isArray(res.data)) {
@@ -64,7 +64,7 @@ const validateStoreUrl = async (registry) => {
 
 const getStoreMeta = async (registry) => {
   try {
-    const url = joinURL(registry, BLOCKLET_STORE_META_PATH, `?__t__=${Date.now()}`);
+    const url = joinUrl(registry, BLOCKLET_STORE_META_PATH, `?__t__=${Date.now()}`);
     const { data } = await request.get(url);
 
     if (!data) {
@@ -86,7 +86,7 @@ const getStoreMeta = async (registry) => {
       } else if (isBase64(logoUrl, { allowMime: true })) {
         result.logoUrl = logoUrl;
       } else {
-        result.logoUrl = joinURL(registry, logoUrl);
+        result.logoUrl = joinUrl(registry, logoUrl);
       }
     }
 
@@ -141,14 +141,14 @@ const resolveTarballURL = ({ did, tarball = '', storeUrl = '' }) => {
     return '';
   }
 
-  return joinURL(storeUrl, 'api', 'blocklets', did, tarball);
+  return joinUrl(storeUrl, 'api', 'blocklets', did, tarball);
 };
 
 const getBlockletMetaUrl = ({ did, storeUrl }) =>
-  joinURL(storeUrl, BLOCKLET_STORE_API_PREFIX, `/blocklets/${did}/blocklet.json`);
+  joinUrl(storeUrl, BLOCKLET_STORE_API_PREFIX, `/blocklets/${did}/blocklet.json`);
 
 const getBlockletMeta = async ({ did, storeUrl }) => {
-  const url = joinURL(storeUrl, BLOCKLET_STORE_API_PREFIX, `/blocklets/${did}/blocklet.json?__t__=${Date.now()}`);
+  const url = joinUrl(storeUrl, BLOCKLET_STORE_API_PREFIX, `/blocklets/${did}/blocklet.json?__t__=${Date.now()}`);
 
   const { data } = await request.get(url);
   try {

package/lib/webhook/index.js

@@ -10,10 +10,18 @@ const IP = require('../util/ip');
 const states = require('../states');
 const { getBaseUrls } = require('../util');
 
-const getSlackUrlInfo = async (actionPath = '/notifications', urls) => {
+const getSlackUrlInfo = async ({ blockletUrl, path: actionPath = '/notifications', serverUrls: urls }) => {
   const info = [];
 
-  if (actionPath && actionPath.startsWith('/blocklet/')) {
+  if (blockletUrl) {
+    info.push({
+      type: 'section',
+      text: {
+        type: 'mrkdwn',
+        text: 'Use the following links to visit your Blocklet dashboard:',
+      },
+    });
+  } else if (actionPath && actionPath.startsWith('/blocklet/')) {
     info.push({
       type: 'section',
       text: {
@@ -31,15 +39,18 @@ const getSlackUrlInfo = async (actionPath = '/notifications', urls) => {
     });
   }
 
-  const priorities = await evaluateURLs(
-    urls.map((item) => item.url),
-    { checkAccessible: checkURLAccessible }
-  );
-  const priorityUrl = priorities[0].url;
-
-  const { protocol } = new URL(priorityUrl);
-  const normalized = `${priorityUrl}${actionPath}`.replace(`${protocol}//`, '').replace(/\/+/g, '/');
-  const url = `${protocol}//${normalized}`;
+  let url = blockletUrl;
+  if (!url) {
+    const priorities = await evaluateURLs(
+      urls.map((item) => item.url),
+      { checkAccessible: checkURLAccessible }
+    );
+    const priorityUrl = priorities[0].url;
+
+    const { protocol } = new URL(priorityUrl);
+    const normalized = `${priorityUrl}${actionPath}`.replace(`${protocol}//`, '').replace(/\/+/g, '/');
+    url = `${protocol}//${normalized}`;
+  }
 
   info.push({
     type: 'actions',
@@ -89,7 +100,7 @@ module.exports = ({ events, dataDirs, instance }) => {
           const options = { ...message, nodeInfo, node: instance };
           if (item.type === 'slack') {
             // eslint-disable-next-line
-            options.urlInfo = await getSlackUrlInfo(message.action, baseUrls);
+            options.urlInfo = await getSlackUrlInfo({ blockletUrl: message.blockletUrl, path: message.action, serverUrls: baseUrls });
           }
           try {
             // eslint-disable-next-line
@@ -118,8 +129,8 @@ module.exports = ({ events, dataDirs, instance }) => {
   });
 
   events.on(EVENTS.NOTIFICATION_CREATE, (data) => {
-    const { title, description, severity, action, entityType } = data;
-    queue.push({ title, description, status: severity, action, entityType });
+    const { title, description, severity, action, entityType, blockletUrl } = data;
+    queue.push({ title, description, status: severity, action, entityType, blockletUrl });
   });
 
   events.on(EVENTS.NODE_STARTED, async (message) => {

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.16.14-beta-a898bfcb",
+  "version": "1.16.14-beta-d802cd3c",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,38 +19,38 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "Apache-2.0",
   "dependencies": {
-    "@abtnode/analytics": "1.16.14-beta-a898bfcb",
-    "@abtnode/auth": "1.16.14-beta-a898bfcb",
-    "@abtnode/certificate-manager": "1.16.14-beta-a898bfcb",
-    "@abtnode/constant": "1.16.14-beta-a898bfcb",
-    "@abtnode/cron": "1.16.14-beta-a898bfcb",
-    "@abtnode/logger": "1.16.14-beta-a898bfcb",
-    "@abtnode/models": "1.16.14-beta-a898bfcb",
-    "@abtnode/queue": "1.16.14-beta-a898bfcb",
-    "@abtnode/rbac": "1.16.14-beta-a898bfcb",
-    "@abtnode/router-provider": "1.16.14-beta-a898bfcb",
-    "@abtnode/static-server": "1.16.14-beta-a898bfcb",
-    "@abtnode/timemachine": "1.16.14-beta-a898bfcb",
-    "@abtnode/util": "1.16.14-beta-a898bfcb",
-    "@arcblock/did": "1.18.84",
-    "@arcblock/did-auth": "1.18.84",
-    "@arcblock/did-ext": "^1.18.84",
-    "@arcblock/did-motif": "^1.1.12",
-    "@arcblock/did-util": "1.18.84",
-    "@arcblock/event-hub": "1.18.84",
-    "@arcblock/jwt": "^1.18.84",
+    "@abtnode/analytics": "1.16.14-beta-d802cd3c",
+    "@abtnode/auth": "1.16.14-beta-d802cd3c",
+    "@abtnode/certificate-manager": "1.16.14-beta-d802cd3c",
+    "@abtnode/constant": "1.16.14-beta-d802cd3c",
+    "@abtnode/cron": "1.16.14-beta-d802cd3c",
+    "@abtnode/logger": "1.16.14-beta-d802cd3c",
+    "@abtnode/models": "1.16.14-beta-d802cd3c",
+    "@abtnode/queue": "1.16.14-beta-d802cd3c",
+    "@abtnode/rbac": "1.16.14-beta-d802cd3c",
+    "@abtnode/router-provider": "1.16.14-beta-d802cd3c",
+    "@abtnode/static-server": "1.16.14-beta-d802cd3c",
+    "@abtnode/timemachine": "1.16.14-beta-d802cd3c",
+    "@abtnode/util": "1.16.14-beta-d802cd3c",
+    "@arcblock/did": "1.18.87",
+    "@arcblock/did-auth": "1.18.87",
+    "@arcblock/did-ext": "^1.18.87",
+    "@arcblock/did-motif": "^1.1.13",
+    "@arcblock/did-util": "1.18.87",
+    "@arcblock/event-hub": "1.18.87",
+    "@arcblock/jwt": "^1.18.87",
     "@arcblock/pm2-events": "^0.0.5",
-    "@arcblock/validator": "^1.18.84",
-    "@arcblock/vc": "1.18.84",
-    "@blocklet/constant": "1.16.14-beta-a898bfcb",
-    "@blocklet/meta": "1.16.14-beta-a898bfcb",
-    "@blocklet/resolver": "1.16.14-beta-a898bfcb",
-    "@blocklet/sdk": "1.16.14-beta-a898bfcb",
+    "@arcblock/validator": "^1.18.87",
+    "@arcblock/vc": "1.18.87",
+    "@blocklet/constant": "1.16.14-beta-d802cd3c",
+    "@blocklet/meta": "1.16.14-beta-d802cd3c",
+    "@blocklet/resolver": "1.16.14-beta-d802cd3c",
+    "@blocklet/sdk": "1.16.14-beta-d802cd3c",
     "@did-space/client": "^0.2.129",
     "@fidm/x509": "^1.2.1",
-    "@ocap/mcrypto": "1.18.84",
-    "@ocap/util": "1.18.84",
-    "@ocap/wallet": "1.18.84",
+    "@ocap/mcrypto": "1.18.87",
+    "@ocap/util": "1.18.87",
+    "@ocap/wallet": "1.18.87",
     "@slack/webhook": "^5.0.4",
     "archiver": "^5.3.1",
     "axios": "^0.27.2",
@@ -76,6 +76,7 @@
     "node-stream-zip": "^1.15.0",
     "p-limit": "^3.1.0",
     "p-retry": "4.6.1",
+    "read-last-lines": "^1.8.0",
     "semver": "^7.3.8",
     "sequelize": "^6.31.0",
     "shelljs": "^0.8.5",
@@ -83,6 +84,7 @@
     "stream-throttle": "^0.1.3",
     "stream-to-promise": "^3.0.0",
     "systeminformation": "^5.17.12",
+    "tail": "^2.2.4",
     "tar": "^6.1.11",
     "transliteration": "^2.3.5",
     "ua-parser-js": "^1.0.2",
@@ -94,7 +96,8 @@
     "compression": "^1.7.4",
     "expand-tilde": "^2.0.2",
     "express": "^4.18.2",
-    "jest": "^27.5.1"
+    "jest": "^27.5.1",
+    "unzipper": "^0.10.11"
   },
-  "gitHead": "1e6f2ec5199ca28e106a6b02114f2a3f355b3ceb"
+  "gitHead": "f8e2dcefd8d6876e5dedee833ac976b4a0496b20"
 }