@abtnode/core 1.6.17 → 1.6.21

package/lib/api/node.js

@@ -93,7 +93,7 @@ class NodeAPI {
   async updateNodeInfo(entity = {}, context) {
     await validateNodeInfo(entity, context);
 
-    if (entity.autoUpgrade) {
+    if (entity.autoUpgrade && process.env.NODE_ENV !== 'development') {
       try {
         canPackageReadWrite(process.env.ABT_NODE_BINARY_NAME, process.env.ABT_NODE_PACKAGE_NAME);
       } catch (err) {

package/lib/blocklet/hooks.js

@@ -1,68 +1,23 @@
-const childProcess = require('child_process');
 const get = require('lodash/get');
 const camelCase = require('lodash/camelCase');
+const runScript = require('@abtnode/util/lib/run-script');
 
 // eslint-disable-next-line global-require
 const logger = require('@abtnode/logger')(`${require('../../package.json').name}:blocklet:hooks`);
 
 const { getSafeEnv } = require('../util');
 
-const runAsync = ({ appDir, env, hook, progress = false }) => {
-  const safeEnv = getSafeEnv(env);
-  const child = childProcess.exec(hook, {
-    cwd: appDir,
-    env: safeEnv,
-    stdio: 'inherit',
-  });
-
-  if (progress) {
-    child.stdout.pipe(process.stdout);
-    child.stderr.pipe(process.stderr);
-  }
-
-  return new Promise((resolve, reject) => {
-    const errorMessages = [];
-    let hasUnhandledRejection = false;
-
-    child.stderr.on('data', (err) => {
-      // Check if has unhandledRejection in childProcess
-      // https://stackoverflow.com/questions/32784649/gracefully-handle-errors-in-child-processes-in-nodejs
-      if (err.includes('UnhandledPromiseRejectionWarning')) {
-        hasUnhandledRejection = true;
-      }
-      errorMessages.push(err);
-    });
-
-    child.on('exit', (code) => {
-      if (errorMessages.length > 0) {
-        if (code !== 0 || hasUnhandledRejection) {
-          return reject(new Error(errorMessages.join('\r\n')));
-        }
-
-        if (!progress) {
-          errorMessages.forEach((message) => process.stderr.write(message));
-        }
-      }
-
-      return resolve();
-    });
-  });
-};
-
-/**
- * @param {*} args.did root blocklet did
- */
-const runUserHook = async (name, args) => {
-  const { appDir, hooks, env, exitOnError = true, progress = false, notification, did } = args;
-  const hook = get(hooks, `[${name}]`) || get(hooks, `[${camelCase(name)}]`);
+const runUserHook = async (appId, hookName, args) => {
+  const { appDir, hooks, env, exitOnError = true, silent = false, notification, did } = args;
+  const hook = get(hooks, `[${hookName}]`) || get(hooks, `[${camelCase(hookName)}]`);
 
   try {
     if (!hook) {
       return;
     }
 
-    logger.info(`run hook:${name}:`, { hook });
-    await runAsync({ appDir, env, hook, progress });
+    logger.info(`run hook:${hookName}:`, { hook });
+    await runScript(hook, [appId, hookName].join(':'), { cwd: appDir, env: getSafeEnv(env), silent });
   } catch (error) {
     logger.error(`run ${hook} error:`, { error });
 
@@ -77,33 +32,31 @@ const runUserHook = async (name, args) => {
     }
 
     if (exitOnError) {
-      throw new Error(`Run [${name}] failed: ${error.message}`);
+      throw new Error(`Run [${hookName}] failed: ${error.message}`);
     }
   }
 };
 
-const preDeploy = (...args) => runUserHook('pre-deploy', ...args);
-const preInstall = (...args) => runUserHook('pre-install', ...args);
-const postInstall = (...args) => runUserHook('post-install', ...args);
-
-const preStart = async (blocklet, option) => {
+const preDeploy = (appId, ...args) => runUserHook(appId, 'pre-deploy', ...args);
+const preInstall = (appId, ...args) => runUserHook(appId, 'pre-install', ...args);
+const postInstall = (appId, ...args) => runUserHook(appId, 'post-install', ...args);
+const preConfig = (appId, ...args) => runUserHook(appId, 'pre-config', ...args);
+const preStart = async (blocklet, options) => {
   // check required environments
   let environments = get(blocklet, 'meta.environments', []);
   if (!Array.isArray(environments)) {
     environments = [environments];
   }
 
-  const tmp = environments.filter((e) => e.required && option.env[e.name] === undefined).map((e) => e.name);
+  const tmp = environments.filter((e) => e.required && options.env[e.name] === undefined).map((e) => e.name);
   if (tmp.length > 0) {
     throw new Error(`Required environments is not set: ${tmp.join(',')}`);
   }
 
-  return runUserHook('pre-start', option);
+  return runUserHook(blocklet.env.appId, 'pre-start', options);
 };
 
-const preUninstall = (...args) => runUserHook('pre-uninstall', ...args);
-const preStop = (...args) => runUserHook('pre-stop', ...args);
-
-const preConfig = (...args) => runUserHook('pre-config', ...args);
+const preUninstall = (appId, ...args) => runUserHook(appId, 'pre-uninstall', ...args);
+const preStop = (appId, ...args) => runUserHook(appId, 'pre-stop', ...args);
 
 module.exports = { preDeploy, preInstall, postInstall, preStart, preUninstall, preStop, preConfig };

package/lib/blocklet/manager/disk.js

@@ -20,18 +20,17 @@ const logger = require('@abtnode/logger')('@abtnode/core:blocklet:manager');
 const downloadFile = require('@abtnode/util/lib/download-file');
 const Lock = require('@abtnode/util/lib/lock');
 const { getVcFromPresentation } = require('@abtnode/util/lib/vc');
-const { updateBlocklet: updateDidDocument } = require('@abtnode/util/lib/did-document');
-const { BLOCKLET_PURCHASE_NFT_TYPE } = require('@abtnode/constant');
+const { VC_TYPE_BLOCKLET_PURCHASE } = require('@abtnode/constant');
 
 const getBlockletEngine = require('@blocklet/meta/lib/engine');
 const {
   isFreeBlocklet,
+  isComponentBlocklet,
   isDeletableBlocklet,
   getRequiredMissingConfigs,
   hasRunnableComponent,
 } = require('@blocklet/meta/lib/util');
 const validateBlockletEntry = require('@blocklet/meta/lib/entry');
-const { getBlockletInfo } = require('@blocklet/meta/lib');
 const toBlockletDid = require('@blocklet/meta/lib/did');
 const { validateMeta } = require('@blocklet/meta/lib/validate');
 const { update: updateMetaFile } = require('@blocklet/meta/lib/file');
@@ -90,6 +89,8 @@ const {
   checkDuplicateComponents,
   getDiffFiles,
   getBundleDir,
+  needBlockletDownload,
+  verifyPurchase,
 } = require('../../util/blocklet');
 const states = require('../../states');
 const BlockletRegistry = require('../registry');
@@ -197,6 +198,20 @@ class BlockletManager extends BaseBlockletManager {
     throw new Error('Unknown source');
   }
 
+  /**
+   * @param {String} rootDid
+   * @param {String} mountPoint
+   * @param {Boolean} context.blockletPurchaseVerified
+   *
+   * installFromUrl
+   * @param {String} url
+   *
+   * InstallFromUpload
+   * @param {Object} file
+   * @param {String} did for diff upload
+   * @param {String} diffVersion for diff upload
+   * @param {Array} deleteSet for diff upload
+   */
   async installComponent({ rootDid, mountPoint, url, file, did, diffVersion, deleteSet }, context = {}) {
     logger.debug('start install component', { rootDid, mountPoint, url });
 
@@ -244,8 +259,8 @@ class BlockletManager extends BaseBlockletManager {
     // FIXME: 这里的 trustedIssuers 相当于相信任何 VC，需要想更安全的方法
     verifyPresentation({ presentation: vcPresentation, trustedIssuers: [get(vc, 'issuer.id')], challenge });
 
-    if (!vc.type.includes(BLOCKLET_PURCHASE_NFT_TYPE)) {
-      throw new Error(`Expect ${BLOCKLET_PURCHASE_NFT_TYPE} VC type`);
+    if (!vc.type.includes(VC_TYPE_BLOCKLET_PURCHASE)) {
+      throw new Error(`Expect ${VC_TYPE_BLOCKLET_PURCHASE} VC type`);
     }
 
     const blockletUrl = get(vc, 'credentialSubject.purchased.blocklet.url');
@@ -293,7 +308,6 @@ class BlockletManager extends BaseBlockletManager {
             hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
             env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
             did, // root blocklet did,
-            progress: blocklet.mode === BLOCKLET_MODES.DEVELOPMENT,
           }),
         nodeEnvironments,
         nodeInfo: await states.node.read(),
@@ -344,7 +358,7 @@ class BlockletManager extends BaseBlockletManager {
     }
   }
 
-  async stop({ did, updateStatus = true }, context) {
+  async stop({ did, updateStatus = true, silent = false }, context) {
     logger.info('stop blocklet', { did });
 
     const blocklet = await this.ensureBlocklet(did);
@@ -360,7 +374,7 @@ class BlockletManager extends BaseBlockletManager {
 
     await stopBlockletProcess(blocklet, {
       preStop: (b) =>
-        hooks.preStop({
+        hooks.preStop(b.env.appId, {
           appDir: b.env.appDir,
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
           env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
@@ -368,7 +382,7 @@ class BlockletManager extends BaseBlockletManager {
           notification: states.notification,
           context,
           exitOnError: false,
-          progress: blocklet.mode === BLOCKLET_MODES.DEVELOPMENT,
+          silent,
         }),
     });
 
@@ -436,7 +450,7 @@ class BlockletManager extends BaseBlockletManager {
 
       await deleteBlockletProcess(blocklet, {
         preDelete: (b) =>
-          hooks.preUninstall({
+          hooks.preUninstall(b.env.appId, {
             appDir: b.env.appDir,
             hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
             env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
@@ -512,12 +526,14 @@ class BlockletManager extends BaseBlockletManager {
     return result;
   }
 
-  async detail({ did, attachRuntimeInfo = true }, context) {
+  async detail({ did, attachConfig = true, attachRuntimeInfo = true }, context) {
     if (!did) {
       throw new Error('did should not be empty');
     }
 
-    const nodeInfo = await states.node.read();
+    if (!attachConfig) {
+      return states.blocklet.getBlocklet(did);
+    }
 
     if (!attachRuntimeInfo) {
       try {
@@ -528,6 +544,8 @@ class BlockletManager extends BaseBlockletManager {
       }
     }
 
+    const nodeInfo = await states.node.read();
+
     return this.attachRuntimeInfo({ did, nodeInfo, diskInfo: true, context });
   }
 
@@ -624,14 +642,13 @@ class BlockletManager extends BaseBlockletManager {
     }
 
     // FIXME: we should also call preConfig for child blocklets
-    await hooks.preConfig({
+    await hooks.preConfig(blocklet.env.appId, {
       appDir: blocklet.env.appDir,
       hooks: Object.assign(blocklet.meta.hooks || {}, blocklet.meta.scripts || {}),
       exitOnError: true,
       env: { ...getRuntimeEnvironments(blocklet, nodeEnvironments), ...blocklet.configObj },
       did,
       context,
-      progress: blocklet.mode === BLOCKLET_MODES.DEVELOPMENT,
     });
 
     // update db
@@ -819,21 +836,23 @@ class BlockletManager extends BaseBlockletManager {
     };
   }
 
-  async updateChildren({ updateId, did: inputDid, children: inputChildren }, context) {
+  async updateChildren({ updateId, did: inputDid, children: inputChildren, oldBlocklet: inputOldBlocklet }, context) {
     let did;
     let children;
+    let oldBlocklet;
     if (!updateId && inputDid && inputChildren) {
       did = inputDid;
       children = inputChildren;
+      oldBlocklet = inputOldBlocklet;
     } else {
       const sessionData = await states.session.end(updateId);
       did = sessionData.did;
       const { staticChildren = [], dynamicChildren = [] } = sessionData;
       children = [...staticChildren, ...dynamicChildren.map((x) => ({ ...x, dynamic: true }))];
+      oldBlocklet = await states.blocklet.getBlocklet(did);
     }
 
     // get old blocklet
-    const oldBlocklet = await states.blocklet.getBlocklet(did);
     const { meta } = oldBlocklet;
     const { name, version } = meta;
 
@@ -887,6 +906,11 @@ class BlockletManager extends BaseBlockletManager {
   // ============================================================================================
   // Internal API that are used by public APIs and called from CLI
   // ============================================================================================
+
+  /**
+   * After the dev function finished, the caller should send a BlockletEvents.deployed event to the daemon
+   * @returns {Object} blocklet
+   */
   async dev(folder) {
     logger.info('dev blocklet', { folder });
 
@@ -919,11 +943,13 @@ class BlockletManager extends BaseBlockletManager {
       await this.deleteProcess({ did });
       logger.info('delete blocklet precess for dev', { did, version });
     } catch (err) {
-      logger.error('failed to delete blocklet process for dev', { error: err });
+      if (process.env.NODE_ENV !== 'development') {
+        logger.error('failed to delete blocklet process for dev', { error: err });
+      }
     }
 
     const children = await this._getChildren(meta);
-    const blocklet = await states.blocklet.addBlocklet({
+    const added = await states.blocklet.addBlocklet({
       did,
       meta,
       source: BlockletSource.local,
@@ -934,15 +960,16 @@ class BlockletManager extends BaseBlockletManager {
     logger.info('add blocklet for dev', { did, version, meta });
 
     const oldBlocklet = { children: children.filter((x) => x.dynamic) }; // let downloader skip re-downloading dynamic blocklet
-    await this._downloadBlocklet(blocklet, oldBlocklet);
+    await this._downloadBlocklet(added, oldBlocklet);
     await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
 
     // Add environments
     await this._setConfigs(did);
     await this.updateBlockletEnvironment(did);
 
-    this.emit(BlockletEvents.deployed, { blocklet, context: {} });
-    return this.ensureBlocklet(did);
+    const blocklet = await this.ensureBlocklet(did);
+
+    return blocklet;
   }
 
   async ensureBlocklet(did) {
@@ -1171,9 +1198,6 @@ class BlockletManager extends BaseBlockletManager {
         return;
       }
 
-      const blocklet1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.downloading);
-      this.emit(BlockletEvents.statusChange, blocklet1);
-
       preDownloadLock.release();
 
       const { isCancelled } = await this._downloadBlocklet(blocklet, oldBlocklet);
@@ -1319,14 +1343,15 @@ class BlockletManager extends BaseBlockletManager {
     const blocklet = await states.blocklet.getBlocklet(did);
     const nodeInfo = await states.node.read();
 
-    const rootSystemEnvironments = getRootSystemEnvironments(blockletWithEnv, nodeInfo);
-    const overwrittenEnvironments = getOverwrittenEnvironments(blockletWithEnv, nodeInfo);
+    const rootSystemEnvironments = {
+      ...getRootSystemEnvironments(blockletWithEnv, nodeInfo),
+      ...getOverwrittenEnvironments(blockletWithEnv, nodeInfo),
+    };
 
     // fill environments to blocklet and blocklet.children
     blocklet.environments = formatEnvironments({
       ...getSystemEnvironments(blockletWithEnv),
       ...rootSystemEnvironments,
-      ...overwrittenEnvironments,
     });
 
     for (const child of blocklet.children) {
@@ -1335,11 +1360,13 @@ class BlockletManager extends BaseBlockletManager {
         child.environments = formatEnvironments({
           ...getSystemEnvironments(childWithEnv), // system env of child blocklet
           ...rootSystemEnvironments, // system env of root blocklet
-          ...overwrittenEnvironments,
         });
       }
     }
 
+    // put BLOCKLET_APP_ID at root level for indexing
+    blocklet.appDid = rootSystemEnvironments.BLOCKLET_APP_ID;
+
     // update state to db
     return states.blocklet.updateBlocklet(did, blocklet);
   }
@@ -1360,23 +1387,21 @@ class BlockletManager extends BaseBlockletManager {
 
     const registryUrl = registry || (await states.node.getBlockletRegistry());
     const info = await BlockletRegistry.getRegistryMeta(registryUrl);
-    const blocklet = await this.registry.getBlocklet(did, registryUrl);
-    if (!blocklet) {
+    const meta = await this.registry.getBlocklet(did, registryUrl);
+    if (!meta) {
       throw new Error('Can not install blocklet that not found in registry');
     }
 
-    const state = await states.blocklet.getBlocklet(blocklet.did);
+    const state = await states.blocklet.getBlocklet(meta.did);
     if (state) {
       throw new Error('Can not install an already installed blocklet');
     }
 
-    if (isFreeBlocklet(blocklet) === false && !context.blockletPurchaseVerified) {
-      throw new Error('Can not install a non-free blocklet directly');
-    }
+    verifyPurchase(meta, context);
 
     // install
     return this._install({
-      meta: blocklet,
+      meta,
       source: BlockletSource.registry,
       deployedFrom: info.cdnUrl || registryUrl,
       context,
@@ -1426,6 +1451,12 @@ class BlockletManager extends BaseBlockletManager {
       throw new Error('Cannot add self as a component');
     }
 
+    if (!isComponentBlocklet(meta)) {
+      throw new Error('The blocklet cannot be a component');
+    }
+
+    verifyPurchase(meta, context);
+
     const newChildren = await parseChildren(blocklet.meta, {
       children: [
         {
@@ -1439,10 +1470,14 @@ class BlockletManager extends BaseBlockletManager {
 
     checkDuplicateComponents(blocklet.children, newChildren);
 
+    // add component to db
+    await states.blocklet.addChildren(rootDid, newChildren);
+
     return this.updateChildren(
       {
         did: rootDid,
         children: [...blocklet.children, ...newChildren],
+        oldBlocklet: blocklet,
       },
       context
     );
@@ -1705,19 +1740,6 @@ class BlockletManager extends BaseBlockletManager {
     );
   }
 
-  async getStatus(did) {
-    if (!did) {
-      throw new Error('did is required');
-    }
-
-    const blocklet = await states.blocklet.getBlocklet(did);
-    if (!blocklet) {
-      return null;
-    }
-
-    return { name: blocklet.meta.name, did: blocklet.meta.did, status: blocklet.status };
-  }
-
   async prune() {
     const blocklets = await states.blocklet.getBlocklets();
     const settings = await states.blockletExtras.listSettings();
@@ -2126,7 +2148,7 @@ class BlockletManager extends BaseBlockletManager {
       // pre install
       const nodeEnvironments = await states.node.getEnvironments();
       const preInstall = (b) =>
-        hooks.preInstall({
+        hooks.preInstall(b.env.appId, {
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
           env: { ...nodeEnvironments },
           appDir: b.env.appDir,
@@ -2142,7 +2164,7 @@ class BlockletManager extends BaseBlockletManager {
 
       // post install
       const postInstall = (b) =>
-        hooks.postInstall({
+        hooks.postInstall(b.env.appId, {
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
           env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
           appDir: b.env.appDir,
@@ -2155,17 +2177,6 @@ class BlockletManager extends BaseBlockletManager {
       await states.blocklet.setBlockletStatus(did, BlockletStatus.installed);
       blocklet = await this.ensureBlocklet(did);
       logger.info('blocklet installed', { source, did: meta.did });
-      if (process.env.NODE_ENV !== 'test') {
-        const nodeInfo = await states.node.read();
-        const blockletInfo = getBlockletInfo(blocklet, nodeInfo.sk);
-        const updateDidDnsResult = await updateDidDocument({
-          wallet: blockletInfo.wallet,
-          domain: nodeInfo.didDomain,
-          nodeDid: nodeInfo.did,
-          didRegistryUrl: nodeInfo.didRegistry,
-        });
-        logger.info('updated did document', { updateDidDnsResult, blockletId: blocklet.meta.did });
-      }
 
       this.emit(BlockletEvents.installed, { blocklet, context });
 
@@ -2226,7 +2237,7 @@ class BlockletManager extends BaseBlockletManager {
       // pre install
       const nodeEnvironments = await states.node.getEnvironments();
       const preInstall = (b) =>
-        hooks.preInstall({
+        hooks.preInstall(b.env.appId, {
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
           env: { ...nodeEnvironments },
           appDir: b.env.appDir,
@@ -2242,7 +2253,7 @@ class BlockletManager extends BaseBlockletManager {
 
       // post install
       const postInstall = (b) =>
-        hooks.postInstall({
+        hooks.postInstall(b.env.appId, {
           hooks: Object.assign(b.meta.hooks || {}, b.meta.scripts || {}),
           env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
           appDir: b.env.appDir,
@@ -2258,10 +2269,10 @@ class BlockletManager extends BaseBlockletManager {
         if (b.meta.did === did) {
           return runMigrationScripts({
             blocklet: b,
+            appDir: b.env.appDir,
+            env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
             oldVersion,
             newVersion: version,
-            env: getRuntimeEnvironments(b, nodeEnvironments, blocklet),
-            appDir: b.env.appDir,
             did: b.meta.did,
             notification: states.notification,
             context,
@@ -2288,7 +2299,7 @@ class BlockletManager extends BaseBlockletManager {
       } else {
         const status =
           oldBlocklet.status === BlockletStatus.installed ? BlockletStatus.installed : BlockletStatus.stopped;
-        await states.blocklet.setBlockletStatus(did, status);
+        await states.blocklet.setBlockletStatus(did, status, { children: 'all' });
       }
 
       blocklet = await this.ensureBlocklet(did, context);
@@ -2512,10 +2523,7 @@ class BlockletManager extends BaseBlockletManager {
     } = blocklet;
 
     const metas = [];
-    if (
-      ![BlockletSource.upload, BlockletSource.local].includes(blocklet.source) &&
-      get(oldBlocklet, 'meta.dist.integrity') !== get(blocklet, 'meta.dist.integrity')
-    ) {
+    if (needBlockletDownload(blocklet)) {
       metas.push(blocklet.meta);
     }
 
@@ -2526,16 +2534,17 @@ class BlockletManager extends BaseBlockletManager {
 
     for (const child of blocklet.children) {
       const oldChild = oldChildren[child.meta.did];
-      if (
-        !oldChild ||
-        (![BlockletSource.upload, BlockletSource.local].includes(child.source) &&
-          child.sourceUrl &&
-          get(oldChild, 'meta.dist.integrity') !== get(child, 'meta.dist.integrity'))
-      ) {
+      if (needBlockletDownload(child, oldChild)) {
         metas.push(child.meta);
       }
     }
 
+    // update children status
+    const blocklet1 = await states.blocklet.setBlockletStatus(did, BlockletStatus.downloading, {
+      children: metas.map((x) => ({ did: x.did })),
+    });
+    this.emit(BlockletEvents.statusChange, blocklet1);
+
     try {
       logger.info('Download Blocklet', { name, did, bundles: metas.map((x) => get(x, 'dist.tarball')) });
       const tasks = [];

package/lib/blocklet/migration.js

@@ -1,67 +1,25 @@
 /* eslint-disable no-await-in-loop */
-const childProcess = require('child_process');
 const fs = require('fs-extra');
 const path = require('path');
 const semver = require('semver');
+const runScript = require('@abtnode/util/lib/run-script');
 
 const { getMigrationScripts: getScripts } = require('../migrations');
 const { getSafeEnv } = require('../util');
 const { name } = require('../../package.json');
 const logger = require('@abtnode/logger')(`${name}:blocklet:migration`); // eslint-disable-line
 
-const _runScript = ({ appDir, env, migrationScript, progress = false }) => {
-  const safeEnv = getSafeEnv(env);
-
-  const child = childProcess.exec(`node ${migrationScript}`, {
-    cwd: appDir,
-    env: safeEnv,
-    stdio: 'inherit',
-  });
-  let hasUnhandledRejection = false;
-
-  if (progress) {
-    child.stdout.pipe(process.stdout);
-    child.stderr.pipe(process.stderr);
-  }
-
-  return new Promise((resolve, reject) => {
-    const errorMessages = [];
-
-    child.stderr.on('data', (err) => {
-      // Check if has unhandledRejection in childProcess
-      // https://stackoverflow.com/questions/32784649/gracefully-handle-errors-in-child-processes-in-nodejs
-      if (err.includes('UnhandledPromiseRejectionWarning')) {
-        hasUnhandledRejection = true;
-      }
-      errorMessages.push(err);
-    });
-
-    child.on('exit', (code) => {
-      if (errorMessages.length > 0) {
-        if (code !== 0 || hasUnhandledRejection) {
-          return reject(new Error(errorMessages.join('\r\n')));
-        }
-
-        if (!progress) {
-          errorMessages.forEach((message) => process.stderr.write(message));
-        }
-      }
-
-      return resolve();
-    });
-  });
-};
-
 async function runScripts({
+  blocklet,
+  appDir,
+  env,
+  oldVersion,
   dbDir,
   backupDir,
   scriptsDir,
   printInfo,
   printSuccess,
   printError,
-  appDir,
-  env,
-  oldVersion,
 }) {
   let scripts = [];
   try {
@@ -90,7 +48,11 @@ async function runScripts({
     const { script: scriptPath } = pendingScripts[i];
     try {
       printInfo(`Migration script started: ${scriptPath}`);
-      await _runScript({ appDir, env, migrationScript: path.join(scriptsDir, scriptPath) });
+      await runScript(`node ${path.join(scriptsDir, scriptPath)}`, [blocklet.env.appId, 'migration'].join(':'), {
+        cwd: appDir,
+        env: getSafeEnv(env),
+        silent: false,
+      });
       printInfo(`Migration script executed: ${scriptPath}`);
     } catch (migrationErr) {
       printError(`Failed to execute migration script: ${scriptPath}, error: ${migrationErr.message}`);
@@ -123,6 +85,7 @@ async function doRestore({ dbDir, backupDir, printInfo, printSuccess }) {
 }
 
 module.exports = async ({
+  blocklet,
   appDir,
   env,
   oldVersion,
@@ -142,15 +105,16 @@ module.exports = async ({
   fs.ensureDirSync(backupDir);
 
   await runScripts({
+    blocklet,
+    appDir,
+    env,
+    oldVersion,
+    newVersion,
     dbDir,
     backupDir,
     scriptsDir,
     printError,
     printInfo,
     printSuccess,
-    appDir,
-    env,
-    oldVersion,
-    newVersion,
   });
 };