@abtnode/core 1.16.22 → 1.16.23-beta-f85576a6

package/lib/blocklet/manager/config-synchronizer.js

@@ -3,13 +3,20 @@ const throttle = require('lodash/throttle');
 const fs = require('fs-extra');
 const logger = require('@abtnode/logger')('@abtnode/core:config-synchronizer');
 const { encrypt } = require('@blocklet/sdk/lib/security');
-const { APP_CONFIG_FILE_PATH, APP_CONFIG_DIR, COMPONENT_ENV_FILE_NAME } = require('@blocklet/constant');
+const {
+  APP_CONFIG_FILE_PATH,
+  APP_CONFIG_DIR,
+  COMPONENT_ENV_FILE_NAME,
+  APP_CONFIG_PUBLIC_DIR,
+} = require('@blocklet/constant');
 
 const { findComponentByIdV2, getSharedConfigObj, getBlockletAppIdList } = require('@blocklet/meta/lib/util');
 const { getBlockletLanguages, getBlockletPreferences } = require('@blocklet/env/lib/util');
 const { getComponentsInternalInfo } = require('@blocklet/meta/lib/blocklet');
 const { getComponentApiKey } = require('@abtnode/util/lib/blocklet');
 
+const { getBlockletConfigObj } = require('../../util/blocklet');
+
 const getValueFromEnvironments = (environments, key) => {
   const env = (environments || []).find((x) => x.key === key);
   return env ? env.value : undefined;
@@ -63,6 +70,9 @@ class ConfigSynchronizer {
     try {
       const app = await this.manager.getBlocklet(rootDid);
       const component = findComponentByIdV2(app, did);
+
+      const hasResources = !!component.meta.resource?.bundles?.length;
+
       const env = {
         ...component.configObj,
         ...getSharedConfigObj(app, component),
@@ -76,12 +86,21 @@ class ConfigSynchronizer {
 
       const dataDir = getValueFromEnvironments(app.environments, 'BLOCKLET_DATA_DIR');
 
-      const envString = JSON.stringify(env);
-
       await fs.outputFile(
         path.join(dataDir, APP_CONFIG_DIR, component.meta.did, COMPONENT_ENV_FILE_NAME),
-        encrypt(envString, componentApiKey, component.meta.did)
+        encrypt(JSON.stringify(env), componentApiKey, component.meta.did)
       );
+
+      if (hasResources) {
+        const publicEnv = {
+          ...getBlockletConfigObj(component, { excludeSecure: true }),
+          ...getSharedConfigObj(app, component),
+        };
+        await fs.outputFile(
+          path.join(dataDir, APP_CONFIG_PUBLIC_DIR, component.meta.did, COMPONENT_ENV_FILE_NAME),
+          JSON.stringify(publicEnv)
+        );
+      }
     } catch (error) {
       logger.error('sync component config failed', { error });
     }

package/lib/blocklet/project/create-pack-release.js

@@ -0,0 +1,262 @@
+/**
+ * WARNING this feature is not ready for production
+ */
+
+const path = require('path');
+const fs = require('fs-extra');
+const createArchive = require('archiver');
+const { slugify } = require('transliteration');
+const { BLOCKLET_META_FILE, PROJECT } = require('@blocklet/constant');
+const { update: updateMetaFile } = require('@blocklet/meta/lib/file');
+const { createRelease: createBlockletRelease } = require('@abtnode/util/lib/create-blocklet-release');
+const urlPathFriendly = require('@blocklet/meta/lib/url-path-friendly').default;
+
+const logger = require('@abtnode/logger')('create-resource-blocklet-pack');
+
+const { createReleaseSchema } = require('../../validators/project');
+
+const { getLogoFile, exportBlockletResources, getResourceList, checkResourceExists } = require('./util');
+
+const createRandomStr = () => Math.random().toString(36).substring(2, 8);
+
+const createPackRelease = async ({
+  did,
+  projectId,
+  releaseId,
+  blockletTitle,
+  blockletDescription,
+  blockletVersion,
+  blockletIntroduction,
+  blockletLogo,
+  blockletScreenshots,
+  note,
+  manager,
+  status,
+}) => {
+  if (!projectId) {
+    throw new Error('projectId is required');
+  }
+  if (!PROJECT.RELEASE_STATUS[status]) {
+    throw new Error(`status is invalid: ${status}`);
+  }
+
+  const params = {
+    blockletVersion,
+    blockletTitle,
+    blockletDescription,
+    blockletLogo,
+    blockletIntroduction,
+    blockletScreenshots,
+    note,
+  };
+
+  const releaseSchema = createReleaseSchema(status);
+  await releaseSchema.validateAsync(params);
+
+  const blocklet = await manager.getBlocklet(did);
+  const { projectState, releaseState } = await manager._getProjectState(did);
+
+  const project0 = await projectState.findOne({ id: projectId });
+  if (!project0) {
+    throw new Error('project not found');
+  }
+
+  if (project0.type !== PROJECT.TYPES.pack) {
+    throw new Error('project type is not pack');
+  }
+
+  const action = releaseId ? 'update' : 'create';
+
+  if (action === 'update') {
+    const release = await releaseState.findOne({ projectId, id: releaseId });
+    if (!release) {
+      throw new Error('release not found');
+    }
+    if (release.status !== 'draft') {
+      throw new Error('Can not update a published release');
+    }
+  }
+
+  const existVersion = await releaseState.findOne({ projectId, blockletVersion });
+  if (existVersion && (action === 'create' || existVersion.id !== releaseId)) {
+    throw new Error(`blockletVersion ${blockletVersion} already exists`);
+  }
+
+  const { blockletDid } = project0;
+
+  params.blockletDid = blockletDid;
+
+  const projectDir = path.join(blocklet.env.dataDir, PROJECT.DIR, `${projectId}`);
+
+  // test
+  // const components = blocklet.children.map((x) => ({
+  //   did: x.meta.did,
+  //   configs: x.configs.filter((y) => !y.secure),
+  // }));
+  // console.log(components.map((x) => x.configs));
+  // throw new Error('test');
+
+  if (status !== PROJECT.RELEASE_STATUS.draft) {
+    await checkResourceExists(projectDir, action, releaseId);
+  }
+
+  const release = await releaseState.upsertRelease({
+    ...params,
+    projectId,
+    releaseId,
+    status,
+  });
+  const project = await projectState.updateProject(projectId, params);
+
+  const _releaseId = release.id;
+
+  const tmpDir = path.join(manager.dataDirs.tmp, PROJECT.DIR, `${blockletDid}-${createRandomStr()}`);
+  const releaseDir = path.join(projectDir, PROJECT.RELEASE_DIR, `${_releaseId}`);
+  const resourceDir = path.join(releaseDir, PROJECT.RESOURCE_DIR);
+  const tmpResourceDir = path.join(projectDir, PROJECT.RESOURCE_DIR);
+
+  await fs.ensureDir(releaseDir);
+
+  // move tmp resource to release
+  if (action === 'create') {
+    await fs.ensureDir(tmpResourceDir);
+    await fs.remove(releaseDir);
+    await fs.ensureDir(releaseDir);
+    await fs.move(tmpResourceDir, resourceDir);
+    await fs.ensureDir(tmpResourceDir);
+  }
+
+  if (status === PROJECT.RELEASE_STATUS.draft) {
+    return release;
+  }
+
+  // create a release
+  if (fs.existsSync(tmpDir)) {
+    await fs.remove(tmpDir);
+  }
+
+  const tmpExportDir = path.join(tmpDir, 'export');
+  const tmpBundleDir = path.join(tmpExportDir, 'bundle');
+  const tmpReleaseDir = path.join(tmpExportDir, 'release');
+
+  const moniker = (urlPathFriendly(slugify(release.blockletTitle)) || 'blocklet').toLowerCase();
+  const releaseFileName = `${moniker}-${release.blockletVersion}.zip`;
+  const releaseFile = path.join(releaseDir, releaseFileName);
+  if (fs.existsSync(releaseFile)) {
+    logger.error('release file already exists, remove it', releaseFile);
+    await fs.remove(releaseFile);
+  }
+
+  try {
+    await fs.ensureDir(tmpBundleDir);
+
+    // create logo
+    const { logoFile, logoFileName } = getLogoFile(blocklet, project);
+    await fs.copy(logoFile, path.join(tmpBundleDir, logoFileName));
+
+    // create screenshots
+    const screenshotsDistDir = path.join(tmpBundleDir, 'screenshots');
+    await fs.ensureDir(screenshotsDistDir);
+    if (project.blockletScreenshots?.length) {
+      await Promise.all(
+        project.blockletScreenshots.map(async (screenshot) => {
+          const screenshotFile = path.join(projectDir, PROJECT.ASSET_DIR, screenshot);
+          await fs.copy(screenshotFile, path.join(screenshotsDistDir, screenshot));
+        })
+      );
+    }
+
+    // create readme
+    if (blockletIntroduction) {
+      await fs.outputFile(path.join(tmpBundleDir, 'README.md'), blockletIntroduction);
+    }
+
+    // changelog
+    const changelogDistFile = path.join(tmpBundleDir, 'CHANGELOG.md');
+    const releases = await releaseState.getReleases({ projectId, status: PROJECT.RELEASE_STATUS.published });
+    const changelog = releases.map((_release) => {
+      const { blockletVersion: version, note: content } = _release;
+      return `## ${version}\n\n${content}`;
+    });
+    await fs.outputFile(changelogDistFile, changelog.join('\n\n'));
+
+    // create resource
+    await exportBlockletResources({
+      app: blocklet,
+      projectId,
+      releaseId: _releaseId,
+      exportDir: tmpBundleDir,
+      blockletDid,
+      isPack: true,
+    });
+    const resourceList = await getResourceList(tmpBundleDir, { isPublic: false });
+
+    const components = blocklet.children
+      .filter((x) => x.bundleSource?.url || x.bundleSource?.store)
+      .map((x) => ({
+        name: x.meta.name,
+        mountPoint: x.mountPoint,
+        source: x.bundleSource,
+      }));
+
+    // create blocklet.yml
+    const meta = {
+      did: blockletDid,
+      name: blockletDid,
+      title: blockletTitle,
+      description: blockletDescription,
+      version: blockletVersion,
+      group: 'pack',
+      logo: logoFileName,
+      resource: {
+        bundles: resourceList.length ? resourceList : undefined,
+      },
+      components,
+      files: project.blockletScreenshots?.length ? ['screenshots'] : [],
+      screenshots: project.blockletScreenshots || [],
+    };
+    await updateMetaFile(path.join(tmpBundleDir, BLOCKLET_META_FILE), meta);
+
+    // create release
+    await createBlockletRelease(tmpExportDir, { printError: logger.error, printInfo: logger.info });
+
+    // archive
+    const archive = createArchive('zip', { zlib: { level: 9 } });
+    const writeStream = fs.createWriteStream(releaseFile);
+
+    await new Promise((resolve, reject) => {
+      archive
+        .directory(tmpReleaseDir, false)
+        .on('error', (err) => reject(err))
+        .pipe(writeStream);
+
+      writeStream.on('close', () => resolve(releaseFile));
+      archive.finalize();
+    });
+
+    const res2 = await releaseState.upsertRelease({
+      projectId,
+      releaseId: _releaseId,
+      files: [releaseFileName],
+    });
+
+    await fs.remove(tmpDir);
+
+    logger.info('create release success', res2);
+
+    return res2;
+  } catch (error) {
+    await fs.remove(tmpDir);
+    await fs.remove(releaseFile);
+    if (action === 'create') {
+      await fs.remove(releaseDir);
+      await releaseState.remove({ projectId, id: _releaseId });
+    } else {
+      await releaseState.update({ id: _releaseId }, { $set: { status: PROJECT.RELEASE_STATUS.draft } });
+    }
+    logger.error(`export ${project.type} error`, error);
+    throw error;
+  }
+};
+
+module.exports = createPackRelease;

package/lib/blocklet/project/index.js

@@ -2,19 +2,20 @@ const path = require('path');
 const fs = require('fs-extra');
 const createArchive = require('archiver');
 const { slugify } = require('transliteration');
-const { isValid: isValidDid } = require('@arcblock/did');
-const { BLOCKLET_META_FILE, PROJECT, BLOCKLET_RESOURCE_DIR } = require('@blocklet/constant');
+const { BLOCKLET_META_FILE, PROJECT } = require('@blocklet/constant');
 const { update: updateMetaFile } = require('@blocklet/meta/lib/file');
 const { createRelease: createBlockletRelease } = require('@abtnode/util/lib/create-blocklet-release');
 const { titleSchema } = require('@blocklet/meta/lib/schema');
 const { validateNewDid } = require('@blocklet/meta/lib/name');
 const urlPathFriendly = require('@blocklet/meta/lib/url-path-friendly').default;
-const fg = require('fast-glob');
 
 const logger = require('@abtnode/logger')('create-resource-blocklet');
 
 const { createReleaseSchema } = require('../../validators/project');
 
+const { getLogoFile, exportBlockletResources, getResourceList, checkResourceExists } = require('./util');
+const createPackRelease = require('./create-pack-release');
+
 const createRandomStr = () => Math.random().toString(36).substring(2, 8);
 
 const COMPONENT_CONFIG_MAP_DIR = '.component_config';
@@ -103,46 +104,6 @@ const deleteRelease = async ({ did, projectId, releaseId, manager }) => {
   await fs.remove(releaseDir);
 };
 
-const checkResourceExists = async (projectDir, action, releaseId) => {
-  const releaseDir =
-    action === 'create'
-      ? path.join(projectDir, PROJECT.RESOURCE_DIR)
-      : path.join(projectDir, PROJECT.RELEASE_DIR, `${releaseId}`, PROJECT.RESOURCE_DIR);
-
-  const configDir = path.join(releaseDir, COMPONENT_CONFIG_MAP_DIR);
-  const errMsg = 'resource should not be empty';
-  if (!fs.existsSync(configDir)) {
-    throw new Error(errMsg);
-  }
-
-  const files = await fs.readdir(configDir);
-  if (!files.length) {
-    throw new Error(errMsg);
-  }
-};
-
-const getResourceList = async (resourceDir) => {
-  const list = await fg(['*/*'], { cwd: resourceDir, onlyDirectories: true });
-
-  return list
-    .filter((x) => x !== COMPONENT_CONFIG_MAP_DIR)
-    .map((x) => {
-      const [did, type] = x.split('/');
-      if (!type) {
-        throw new Error(`invalid resource: ${x}. type is required`);
-      }
-      if (!isValidDid(did)) {
-        throw new Error(`invalid resource: ${x}. did is invalid`);
-      }
-
-      return {
-        did,
-        type,
-        public: true,
-      };
-    });
-};
-
 const createRelease = async ({
   did,
   projectId,
@@ -185,6 +146,23 @@ const createRelease = async ({
     throw new Error('project not found');
   }
 
+  if (project0.type === PROJECT.TYPES.pack) {
+    return createPackRelease({
+      did,
+      projectId,
+      releaseId,
+      blockletTitle,
+      blockletDescription,
+      blockletVersion,
+      blockletIntroduction,
+      blockletLogo,
+      blockletScreenshots,
+      note,
+      manager,
+      status,
+    });
+  }
+
   const action = releaseId ? 'update' : 'create';
 
   if (action === 'update') {
@@ -263,11 +241,7 @@ const createRelease = async ({
     await fs.ensureDir(tmpBundleDir);
 
     // create logo
-    const logoFile = project.blockletLogo
-      ? path.join(projectDir, PROJECT.ASSET_DIR, project.blockletLogo)
-      : path.join(__dirname, 'logo.png');
-    const logoExt = path.extname(logoFile);
-    const logoFileName = `logo${logoExt}`;
+    const { logoFile, logoFileName } = getLogoFile(blocklet, project);
     await fs.copy(logoFile, path.join(tmpBundleDir, logoFileName));
 
     // create screenshots
@@ -297,10 +271,13 @@ const createRelease = async ({
     await fs.outputFile(changelogDistFile, changelog.join('\n\n'));
 
     // create resource
-    await fs.ensureDir(resourceDir);
-    const tmpBundleResourceDir = path.join(tmpBundleDir, BLOCKLET_RESOURCE_DIR);
-    await fs.copy(resourceDir, tmpBundleResourceDir);
-    await fs.remove(path.join(tmpBundleResourceDir, COMPONENT_CONFIG_MAP_DIR));
+    await exportBlockletResources({
+      app: blocklet,
+      projectId,
+      releaseId: _releaseId,
+      exportDir: tmpBundleDir,
+      blockletDid,
+    });
 
     // create blocklet.yml
     const resourceList = await getResourceList(resourceDir);

package/lib/blocklet/project/util.js

@@ -0,0 +1,128 @@
+const path = require('path');
+const fs = require('fs-extra');
+const fg = require('fast-glob');
+const { isValid: isValidDid } = require('@arcblock/did');
+const { PROJECT, BLOCKLET_RESOURCE_DIR } = require('@blocklet/constant');
+
+const COMPONENT_CONFIG_MAP_DIR = '.component_config';
+
+/**
+ * @param {import('@abtnode/client').BlockletState} blocklet
+ * @param {{
+ *  id: string;
+ *  blockletLogo?: string;
+ * }} project
+ */
+const getLogoFile = (blocklet, project) => {
+  const { id } = project;
+  const projectDir = path.join(blocklet.env.dataDir, PROJECT.DIR, id);
+
+  const logoFile = project.blockletLogo
+    ? path.join(projectDir, PROJECT.ASSET_DIR, project.blockletLogo)
+    : path.join(__dirname, 'logo.png');
+  const logoExt = path.extname(logoFile);
+  const logoFileName = `logo${logoExt}`;
+  return { logoFile, logoFileName };
+};
+
+const exportBlockletResources = async ({ app, projectId, releaseId, exportDir, blockletDid, isPack }) => {
+  // create resource
+  const projectDir = path.join(app.env.dataDir, PROJECT.DIR, `${projectId}`);
+  const releaseDir = path.join(projectDir, PROJECT.RELEASE_DIR, `${releaseId}`);
+  const sourceDir = path.join(releaseDir, PROJECT.RESOURCE_DIR);
+
+  const resourceDir = path.join(exportDir, BLOCKLET_RESOURCE_DIR);
+  await fs.ensureDir(resourceDir);
+  await fs.copy(sourceDir, resourceDir);
+  await fs.remove(path.join(resourceDir, COMPONENT_CONFIG_MAP_DIR));
+
+  if (isPack) {
+    // create pack resource
+    const packResourceDir = path.join(resourceDir, blockletDid, 'config');
+    await fs.ensureDir(packResourceDir);
+    const site = {
+      rules: (app.site?.rules || [])
+        .filter((x) => !x.isProtected)
+        .map((rule) => ({
+          from: rule.from,
+          to: rule.to,
+        }))
+        .filter(Boolean),
+    };
+    const navigations = app.settings.navigations || [];
+    const componentsConfigs = app.children.map((x) => ({
+      did: x.meta.did,
+      configs: x.configs.filter((y) => !y.secure),
+    }));
+    await fs.outputJSON(path.join(packResourceDir, 'config.json'), {
+      site,
+      navigations,
+      components: componentsConfigs,
+    });
+  }
+};
+
+async function checkIfDirectory(file) {
+  try {
+    const stats = await fs.promises.stat(file);
+    return stats.isDirectory();
+  } catch {
+    // maybe file not exists
+    return false;
+  }
+}
+
+const getResourceList = async (resourceDir, { isPublic = true } = {}) => {
+  const hasResourceDir = await checkIfDirectory(path.join(resourceDir, BLOCKLET_RESOURCE_DIR));
+  const dir = hasResourceDir ? path.join(resourceDir, BLOCKLET_RESOURCE_DIR) : resourceDir;
+
+  const list = await fg(['*/*'], { cwd: dir, onlyDirectories: true });
+
+  return list
+    .filter((x) => x !== COMPONENT_CONFIG_MAP_DIR)
+    .map((x) => {
+      const [did, type] = x.split('/');
+      if (!type) {
+        throw new Error(`invalid resource: ${x}. type is required`);
+      }
+      if (!isValidDid(did)) {
+        throw new Error(`invalid resource: ${x}. did is invalid`);
+      }
+
+      const res = {
+        did,
+        type,
+      };
+
+      if (isPublic) {
+        res.public = true;
+      }
+
+      return res;
+    });
+};
+
+const checkResourceExists = async (projectDir, action, releaseId) => {
+  const releaseDir =
+    action === 'create'
+      ? path.join(projectDir, PROJECT.RESOURCE_DIR)
+      : path.join(projectDir, PROJECT.RELEASE_DIR, `${releaseId}`, PROJECT.RESOURCE_DIR);
+
+  const configDir = path.join(releaseDir, COMPONENT_CONFIG_MAP_DIR);
+  const errMsg = 'resource should not be empty';
+  if (!fs.existsSync(configDir)) {
+    throw new Error(errMsg);
+  }
+
+  const files = await fs.readdir(configDir);
+  if (!files.length) {
+    throw new Error(errMsg);
+  }
+};
+
+module.exports = {
+  getLogoFile,
+  exportBlockletResources,
+  getResourceList,
+  checkResourceExists,
+};

package/lib/util/blocklet.js

@@ -231,6 +231,22 @@ const getComponentStartEngine = (component, { e2eMode = false } = {}) => {
   return { cwd, script, args, environmentObj, interpreter, interpreterArgs };
 };
 
+const getBlockletConfigObj = (blocklet, { excludeSecure } = {}) => {
+  const obj = (blocklet?.configs || [])
+    .filter((x) => {
+      if (excludeSecure) {
+        return !x.secure;
+      }
+      return true;
+    })
+    .reduce((acc, x) => {
+      acc[x.key] = templateReplace(x.value, blocklet);
+      return acc;
+    }, {});
+
+  return obj;
+};
+
 /**
  * set 'configs', configObj', 'environmentObj' to blocklet TODO
  * @param {*} blocklet
@@ -238,10 +254,7 @@ const getComponentStartEngine = (component, { e2eMode = false } = {}) => {
  */
 const fillBlockletConfigs = (blocklet, configs) => {
   blocklet.configs = configs || [];
-  blocklet.configObj = blocklet.configs.reduce((acc, x) => {
-    acc[x.key] = templateReplace(x.value, blocklet);
-    return acc;
-  }, {});
+  blocklet.configObj = getBlockletConfigObj(blocklet);
   blocklet.environments = blocklet.environments || [];
   blocklet.environmentObj = blocklet.environments.reduce((acc, x) => {
     acc[x.key] = templateReplace(x.value, blocklet);
@@ -2028,4 +2041,5 @@ module.exports = {
   removeAppConfigsFromComponent,
   getConfigsFromInput,
   getPackConfig,
+  getBlockletConfigObj,
 };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.16.22",
+  "version": "1.16.23-beta-f85576a6",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -19,19 +19,19 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "Apache-2.0",
   "dependencies": {
-    "@abtnode/analytics": "1.16.22",
-    "@abtnode/auth": "1.16.22",
-    "@abtnode/certificate-manager": "1.16.22",
-    "@abtnode/constant": "1.16.22",
-    "@abtnode/cron": "1.16.22",
-    "@abtnode/logger": "1.16.22",
-    "@abtnode/models": "1.16.22",
-    "@abtnode/queue": "1.16.22",
-    "@abtnode/rbac": "1.16.22",
-    "@abtnode/router-provider": "1.16.22",
-    "@abtnode/static-server": "1.16.22",
-    "@abtnode/timemachine": "1.16.22",
-    "@abtnode/util": "1.16.22",
+    "@abtnode/analytics": "1.16.23-beta-f85576a6",
+    "@abtnode/auth": "1.16.23-beta-f85576a6",
+    "@abtnode/certificate-manager": "1.16.23-beta-f85576a6",
+    "@abtnode/constant": "1.16.23-beta-f85576a6",
+    "@abtnode/cron": "1.16.23-beta-f85576a6",
+    "@abtnode/logger": "1.16.23-beta-f85576a6",
+    "@abtnode/models": "1.16.23-beta-f85576a6",
+    "@abtnode/queue": "1.16.23-beta-f85576a6",
+    "@abtnode/rbac": "1.16.23-beta-f85576a6",
+    "@abtnode/router-provider": "1.16.23-beta-f85576a6",
+    "@abtnode/static-server": "1.16.23-beta-f85576a6",
+    "@abtnode/timemachine": "1.16.23-beta-f85576a6",
+    "@abtnode/util": "1.16.23-beta-f85576a6",
     "@arcblock/did": "1.18.108",
     "@arcblock/did-auth": "1.18.108",
     "@arcblock/did-ext": "^1.18.108",
@@ -42,11 +42,11 @@
     "@arcblock/pm2-events": "^0.0.5",
     "@arcblock/validator": "^1.18.108",
     "@arcblock/vc": "1.18.108",
-    "@blocklet/constant": "1.16.22",
-    "@blocklet/env": "1.16.22",
-    "@blocklet/meta": "1.16.22",
-    "@blocklet/resolver": "1.16.22",
-    "@blocklet/sdk": "1.16.22",
+    "@blocklet/constant": "1.16.23-beta-f85576a6",
+    "@blocklet/env": "1.16.23-beta-f85576a6",
+    "@blocklet/meta": "1.16.23-beta-f85576a6",
+    "@blocklet/resolver": "1.16.23-beta-f85576a6",
+    "@blocklet/sdk": "1.16.23-beta-f85576a6",
     "@did-space/client": "^0.3.50",
     "@fidm/x509": "^1.2.1",
     "@ocap/mcrypto": "1.18.108",
@@ -102,5 +102,5 @@
     "jest": "^27.5.1",
     "unzipper": "^0.10.11"
   },
-  "gitHead": "eba523c2d8f62f2a1c742b23e3280774bf9bc4cf"
+  "gitHead": "bac83a74944b4cef3ccb386277023caf0e1d5cd4"
 }