@abtnode/core 1.17.3-beta-20251123-232619-53258789 → 1.17.3-beta-20251126-121502-d0926972

package/lib/cert.js

@@ -118,7 +118,16 @@ class Cert extends EventEmitter {
   }
 
   update(data) {
-    return this.manager.update(data.id, { name: data.name, public: data.public });
+    if (data.certificate && data.privateKey) {
+      Cert.fixCertificate(data);
+    }
+
+    return this.manager.update(data.id, {
+      name: data.name,
+      public: data.public,
+      certificate: data.certificate,
+      privateKey: data.privateKey,
+    });
   }
 
   async remove({ id }) {

package/lib/states/blocklet.js

@@ -25,7 +25,7 @@ const {
   BLOCKLET_DEFAULT_PORT_NAME,
   BlockletGroup,
 } = require('@blocklet/constant');
-const { refreshPorts } = require('@abtnode/util/lib/port');
+const { isPortTaken } = require('@abtnode/util/lib/port');
 const { verifyVault } = require('@blocklet/meta/lib/security');
 const { APP_STRUCT_VERSION } = require('@abtnode/constant');
 
@@ -42,6 +42,97 @@ const lock = new DBCache(() => ({
   ...getAbtNodeRedisAndSQLiteUrl(),
 }));
 
+// Lock for port assignment to prevent race conditions in multi-process environment
+const portAssignLock = new DBCache(() => ({
+  prefix: 'blocklet-port-assign-lock',
+  ttl: 1000 * 30, // 30 seconds timeout
+  ...getAbtNodeRedisAndSQLiteUrl(),
+}));
+
+/**
+ * 统一的端口分配方法
+ * 无论是首次分配还是刷新端口，都使用这个方法
+ * @param {Object} options
+ * @param {Array<string>} options.wantedPorts - 需要分配的端口名称列表
+ * @param {Object} options.blackListPorts - 黑名单端口（已占用的端口）
+ * @param {Array<number>} options.portRange - 端口范围，默认 [10000, 31000]
+ * @param {number} options.defaultPort - 回退时的起始端口
+ * @returns {Promise<Object>} 分配的端口对象 { portName: portNumber }
+ */
+async function assignPortsWithLock({
+  wantedPorts,
+  blackListPorts = [],
+  portRange = [10000, 31000],
+  defaultPort = 5555,
+}) {
+  const lockName = 'blocklet-port-assign';
+
+  // ⚠️ 关键修复：使用 DBCache 锁确保端口分配的原子性
+  // 在多进程环境下，防止多个进程同时分配端口导致冲突
+  await portAssignLock.acquire(lockName);
+
+  try {
+    const assignedPorts = {};
+    const usedPorts = [...blackListPorts];
+
+    for (let i = 0; i < wantedPorts.length; i++) {
+      const wantedPort = wantedPorts[i];
+
+      let found = false;
+      let assignedPort = null;
+      let attempts = 0;
+      const maxAttempts = 100;
+
+      while (!found && attempts < maxAttempts) {
+        // 在 [10000, 31000] 范围内随机选择端口
+        const randomPort = Math.floor(Math.random() * (portRange[1] - portRange[0])) + portRange[0];
+
+        if (!usedPorts.includes(randomPort)) {
+          // eslint-disable-next-line no-await-in-loop
+          const isTaken = await isPortTaken(randomPort);
+          if (!isTaken) {
+            assignedPort = randomPort;
+            usedPorts.push(assignedPort);
+            found = true;
+          }
+        }
+        attempts++;
+      }
+
+      // 如果随机方式失败，回退到累加方式
+      if (!found) {
+        logger.warn('Random port assignment failed, falling back to sequential assignment', {
+          wantedPort,
+          attempts,
+        });
+        let port = defaultPort + 1;
+        // eslint-disable-next-line no-await-in-loop
+        let fallbackPort = await detectPort(Number(port));
+        while (usedPorts.includes(fallbackPort)) {
+          port = fallbackPort + 1;
+          while (usedPorts.includes(port)) {
+            port++;
+          }
+          // eslint-disable-next-line no-await-in-loop
+          fallbackPort = await detectPort(Number(port));
+        }
+        assignedPort = fallbackPort;
+        usedPorts.push(assignedPort);
+      }
+
+      // set wantedPort to assignedPort
+      assignedPorts[wantedPort] = assignedPort;
+    }
+
+    return assignedPorts;
+  } catch (err) {
+    logger.error('Failed to assign ports with lock', { error: err });
+    throw err;
+  } finally {
+    await portAssignLock.releaseLock(lockName);
+  }
+}
+
 const isHex = (str) => /^0x[0-9a-f]+$/i.test(str);
 const getMaxPort = (ports = {}) => Math.max(...Object.values(ports).map(Number));
 
@@ -436,31 +527,29 @@ class BlockletState extends BaseState {
         wantedPorts.push(BLOCKLET_DEFAULT_PORT_NAME);
       }
 
-      const assignedPorts = Object.assign({}, alreadyAssigned);
-      let port = Math.max(Number(this.defaultPort), defaultPort) + 1;
-
-      for (let i = 0; i < wantedPorts.length; i++) {
-        const wantedPort = wantedPorts[i];
-
-        if (typeof alreadyAssigned[wantedPort] === 'undefined') {
-          // find assignedPort not exist in occupiedInternalPorts
-          let assignedPort = await detectPort(Number(port));
-          while (occupiedInternalPorts.has(assignedPort)) {
-            port = assignedPort + 1;
-            while (occupiedInternalPorts.has(port)) {
-              port++;
-            }
-            assignedPort = await detectPort(Number(port));
-          }
-
-          // set wantedPort to assignedPort
-          assignedPorts[wantedPort] = assignedPort;
+      // 过滤出需要分配的端口（排除已分配的）
+      const portsToAssign = wantedPorts.filter((port) => typeof alreadyAssigned[port] === 'undefined');
 
-          port = assignedPort + 1;
-        }
+      if (portsToAssign.length === 0) {
+        return alreadyAssigned;
       }
 
-      return assignedPorts;
+      const blackListPorts = [
+        ...Array.from(occupiedExternalPorts.keys()),
+        ...Array.from(occupiedInternalPorts.keys()),
+        ...Object.values(alreadyAssigned),
+      ];
+
+      // 使用统一的端口分配方法（包含锁机制）
+      const newPorts = await assignPortsWithLock({
+        wantedPorts: portsToAssign,
+        blackListPorts,
+        portRange: [10000, 31000],
+        defaultPort: Math.max(Number(this.defaultPort), defaultPort),
+      });
+
+      // 合并已分配的端口和新分配的端口
+      return Object.assign({}, alreadyAssigned, newPorts);
     } catch (err) {
       logger.error('Failed to assign port to blocklet', { error: err });
       throw err;
@@ -469,6 +558,7 @@ class BlockletState extends BaseState {
 
   /**
    * refresh ports for blocklet if occupied during starting workflow
+   * @returns {Promise<{refreshed: boolean, componentDids: string[], isInitialAssignment?: boolean}>} 返回是否真正刷新了端口，isInitialAssignment 表示是否是首次分配（非冲突刷新）
    */
   async refreshBlockletPorts(did, componentDids = [], isGreen = false) {
     const blocklet = await this.getBlocklet(did);
@@ -477,22 +567,79 @@ class BlockletState extends BaseState {
     }
 
     const { occupiedExternalPorts, occupiedInternalPorts } = await this._getOccupiedPorts();
+    const blackListPorts = [...Array.from(occupiedExternalPorts.keys()), ...Array.from(occupiedInternalPorts.keys())];
+
+    const actuallyRefreshedDids = [];
+    let hasInitialAssignment = false; // 标记是否有首次分配（非冲突刷新）
 
     await forEachComponentV2(blocklet, async (component) => {
       if (!shouldSkipComponent(component.meta.did, componentDids)) {
         let oldPorts = component[isGreen ? 'greenPorts' : 'ports'];
-        if (!oldPorts || Object.keys(oldPorts).length === 0) {
+        const hasOldPorts = oldPorts && Object.keys(oldPorts).length > 0;
+
+        // 如果是 green 环境且 greenPorts 为空，需要分配新端口（基于 ports 的端口名）
+        // 这是首次分配，不是冲突刷新
+        if (isGreen && !hasOldPorts) {
+          // 从 ports 获取端口名，分配新的 green 端口
+          const basePorts = component.ports || {};
+          if (Object.keys(basePorts).length > 0) {
+            const wantedPorts = Object.keys(basePorts);
+            const newPorts = await assignPortsWithLock({
+              wantedPorts,
+              blackListPorts: [...blackListPorts, ...Object.values(basePorts)],
+              portRange: [10000, 31000],
+              defaultPort: this.defaultPort,
+            });
+
+            component.greenPorts = newPorts;
+            actuallyRefreshedDids.push(component.meta.did);
+            hasInitialAssignment = true; // 标记为首次分配
+          }
+          return;
+        }
+
+        // 如果 oldPorts 为空，回退到 ports
+        if (!hasOldPorts) {
           oldPorts = component.ports;
         }
-        component[isGreen ? 'greenPorts' : 'ports'] = await refreshPorts(oldPorts, {
-          blackList: [...occupiedExternalPorts.keys(), ...occupiedInternalPorts.keys()],
-        });
+
+        // 检查旧端口是否真的被占用
+        let needReassign = false;
+        for (const port of Object.values(oldPorts)) {
+          const isTaken = await isPortTaken(port);
+          if (isTaken) {
+            needReassign = true;
+            break;
+          }
+        }
+
+        // 只有旧端口被占用时才分配新端口
+        if (needReassign) {
+          const wantedPorts = Object.keys(oldPorts);
+          const newPorts = await assignPortsWithLock({
+            wantedPorts,
+            blackListPorts: [...blackListPorts, ...Object.values(oldPorts)],
+            portRange: [10000, 31000],
+            defaultPort: this.defaultPort,
+          });
+
+          component[isGreen ? 'greenPorts' : 'ports'] = newPorts;
+          actuallyRefreshedDids.push(component.meta.did);
+        }
       }
     });
 
-    return this.updateBlocklet(did, {
-      children: blocklet.children,
-    });
+    if (actuallyRefreshedDids.length > 0) {
+      await this.updateBlocklet(did, {
+        children: blocklet.children,
+      });
+    }
+
+    return {
+      refreshed: actuallyRefreshedDids.length > 0,
+      componentDids: actuallyRefreshedDids,
+      isInitialAssignment: hasInitialAssignment, // 返回是否是首次分配
+    };
   }
 
   async getServices() {

package/lib/util/blocklet.js

@@ -136,6 +136,92 @@ const parseDockerName = require('./docker/parse-docker-name');
 const { createDockerNetwork } = require('./docker/docker-network');
 const { ensureBun } = require('./ensure-bun');
 
+/**
+ * Get actual listening port from Docker container or process
+ * @param {string} processId - PM2 process ID
+ * @param {object} blocklet - Blocklet object with meta and env
+ * @returns {Promise<number|null>} Actual port number or null if not found
+ */
+const getActualListeningPort = async (processId, blocklet) => {
+  try {
+    // eslint-disable-next-line no-use-before-define
+    const info = await getProcessInfo(processId, { timeout: 3_000 });
+    const dockerName = info.pm2_env?.env?.dockerName;
+
+    if (dockerName) {
+      // For Docker containers, get actual port from docker inspect
+      try {
+        // Get port mapping from docker inspect
+        const inspectCmd = `docker inspect --format='{{range $p, $conf := .NetworkSettings.Ports}}{{$p}} {{end}}' ${dockerName}`;
+        const portMappings = await promiseSpawn(inspectCmd, { mute: true });
+
+        if (portMappings) {
+          const ports = portMappings.trim().split(/\s+/).filter(Boolean);
+          for (const portMapping of ports) {
+            const port = parseInt(portMapping.split('/')[0], 10);
+            if (port && !Number.isNaN(port)) {
+              try {
+                const portCmd = `docker port ${dockerName} ${portMapping}`;
+                const hostPortOutput = await promiseSpawn(portCmd, { mute: true });
+                const match = hostPortOutput.match(/:(\d+)$/);
+                if (match) {
+                  const actualPort = parseInt(match[1], 10);
+                  if (actualPort && !Number.isNaN(actualPort)) {
+                    logger.info('Got actual Docker port from container', {
+                      processId,
+                      dockerName,
+                      containerPort: port,
+                      hostPort: actualPort,
+                    });
+                    return actualPort;
+                  }
+                }
+              } catch (err) {
+                logger.debug('Failed to get port from docker port command', { error: err.message });
+              }
+            }
+          }
+        }
+
+        // Fallback: try to get from NetworkSettings.Ports directly
+        const inspectPortsCmd = `docker inspect --format='{{json .NetworkSettings.Ports}}' ${dockerName}`;
+        const portsJson = await promiseSpawn(inspectPortsCmd, { mute: true });
+        if (portsJson) {
+          const ports = JSON.parse(portsJson);
+          // Find the primary port (usually BLOCKLET_PORT)
+          const webInterface = (blocklet?.meta?.interfaces || []).find(
+            (x) => x.type === BLOCKLET_INTERFACE_TYPE_WEB || x.type === BLOCKLET_INTERFACE_TYPE_DOCKER
+          );
+          const expectedContainerPort = webInterface?.containerPort || webInterface?.port;
+
+          if (expectedContainerPort) {
+            const portKey = `${expectedContainerPort}/tcp`;
+            if (ports[portKey] && ports[portKey][0]) {
+              const hostPort = parseInt(ports[portKey][0].HostPort, 10);
+              if (hostPort && !Number.isNaN(hostPort)) {
+                logger.info('Got actual Docker port from NetworkSettings', {
+                  processId,
+                  dockerName,
+                  containerPort: expectedContainerPort,
+                  hostPort,
+                });
+                return hostPort;
+              }
+            }
+          }
+        }
+      } catch (error) {
+        logger.debug('Failed to get Docker port mapping', { error: error.message, processId, dockerName });
+      }
+    }
+
+    return null;
+  } catch (error) {
+    logger.debug('Failed to get actual listening port', { error: error.message, processId });
+    return null;
+  }
+};
+
 /**
  * get blocklet engine info, default is node
  * @param {object} meta blocklet meta
@@ -149,6 +235,13 @@ const startLock = new DBCache(() => ({
   ttl: 1000 * 60 * 3,
 }));
 
+// Lock for port assignment to prevent race conditions in multi-process environment
+const portAssignLock = new DBCache(() => ({
+  ...getAbtNodeRedisAndSQLiteUrl(),
+  prefix: 'blocklet-port-assign-lock',
+  ttl: 1000 * 30, // 30 seconds timeout
+}));
+
 const blockletCache = new DBCache(() => ({
   prefix: 'blocklet-state',
   ttl: BLOCKLET_CACHE_TTL,
@@ -1122,18 +1215,46 @@ const _checkProcessHealthy = async (
       throw new Error('process not start within 10s');
     }
 
+    // ⚠️ 关键修复：优先从进程实际监听的端口获取
+    // 对于 Docker 容器，从 Docker 端口映射获取实际端口
+    // 这样可以避免端口刷新后，健康检查使用错误的端口
+    const actualPort = await getActualListeningPort(processId, blocklet);
+
+    // 端口优先级：实际端口 > pm2 环境变量端口 > 数据库中的端口
     const port =
+      actualPort ||
       envPort ||
       findInterfacePortByName({ meta, ports: isGreen ? greenPorts : ports }, (webInterface || dockerInterface).name);
+
     if (logToTerminal) {
       // eslint-disable-next-line no-console
-      console.log(
-        `Checking endpoint healthy for ${meta.title}, port: ${port}, minConsecutiveTime: ${
+      logger.info(
+        // eslint-disable-next-line no-nested-ternary
+        `Checking endpoint healthy for ${meta.title}, port: ${port}${actualPort ? ' (actual)' : envPort ? ' (from pm2 env)' : ' (from db)'}, minConsecutiveTime: ${
           minConsecutiveTime / 1000
         }s, timeout: ${timeout / 1000}s`
       );
     }
 
+    if (
+      actualPort &&
+      actualPort !== envPort &&
+      actualPort !==
+        (isGreen
+          ? greenPorts?.[webInterface?.port || dockerInterface?.port]
+          : ports?.[webInterface?.port || dockerInterface?.port])
+    ) {
+      logger.info('Port mismatch detected, using actual port for health check', {
+        processId,
+        appDid,
+        actualPort,
+        envPort,
+        dbPort: isGreen
+          ? greenPorts?.[webInterface?.port || dockerInterface?.port]
+          : ports?.[webInterface?.port || dockerInterface?.port],
+      });
+    }
+
     try {
       await ensureEndpointHealthy({
         port,
@@ -2440,50 +2561,89 @@ const ensurePortsShape = (_states, portsA, portsB) => {
 
 const ensureAppPortsNotOccupied = async ({ blocklet, componentDids: inputDids, states, manager, isGreen = false }) => {
   const { did } = blocklet.meta;
-  const occupiedDids = new Set();
+  const lockName = `port-check-${did}`;
 
-  await forEachComponentV2(blocklet, async (b) => {
-    try {
-      if (shouldSkipComponent(b.meta.did, inputDids)) return;
+  // ⚠️ 关键修复：使用 DBCache 锁确保端口分配的原子性
+  // 在多进程环境下，防止多个进程同时检查同一个端口
+  await portAssignLock.acquire(lockName);
 
-      if (!b.greenPorts) {
-        occupiedDids.add(b.meta.did);
-        b.greenPorts = {};
-      }
-      const { ports = {}, greenPorts } = b;
-      ensurePortsShape(states, ports, greenPorts);
+  try {
+    const occupiedDids = new Set();
+
+    await forEachComponentV2(blocklet, async (b) => {
+      try {
+        if (shouldSkipComponent(b.meta.did, inputDids)) return;
+
+        if (!b.greenPorts) {
+          occupiedDids.add(b.meta.did);
+          b.greenPorts = {};
+        }
+        const { ports = {}, greenPorts } = b;
+        ensurePortsShape(states, ports, greenPorts);
+
+        const targetPorts = isGreen ? greenPorts : ports;
 
-      const targetPorts = isGreen ? greenPorts : ports;
+        let currentOccupied = false;
+        for (const port of Object.values(targetPorts)) {
+          currentOccupied = await isPortTaken(port);
+          if (currentOccupied) {
+            break;
+          }
+        }
 
-      let currentOccupied = false;
-      for (const port of Object.values(targetPorts)) {
-        currentOccupied = await isPortTaken(port);
         if (currentOccupied) {
-          break;
+          occupiedDids.add(b.meta.did);
         }
+      } catch (error) {
+        logger.error('Failed to check ports occupied', { error, blockletDid: b.meta.did, isGreen });
       }
+    });
 
-      if (currentOccupied) {
-        occupiedDids.add(b.meta.did);
+    if (occupiedDids.size === 0) {
+      logger.info('No occupied ports detected, no refresh needed', { did, isGreen });
+      return blocklet;
+    }
+
+    const componentDids = Array.from(occupiedDids);
+    const {
+      refreshed,
+      componentDids: actuallyRefreshedDids,
+      isInitialAssignment,
+    } = await states.blocklet.refreshBlockletPorts(did, componentDids, isGreen);
+
+    // 只有真正刷新了端口才打印日志和更新环境
+    if (refreshed && actuallyRefreshedDids.length > 0) {
+      // 区分首次分配和冲突刷新，使用不同的日志信息
+      if (isInitialAssignment) {
+        logger.info('Assigned green ports for blue-green deployment', {
+          did,
+          componentDids: actuallyRefreshedDids,
+          isGreen,
+        });
+      } else {
+        logger.info('Refreshed component ports due to conflict', {
+          did,
+          componentDids: actuallyRefreshedDids,
+          isGreen,
+        });
       }
-    } catch (error) {
-      logger.error('Failed to check ports occupied', { error, blockletDid: b.meta.did, isGreen });
-    }
-  });
 
-  if (occupiedDids.size === 0) {
-    logger.info('No occupied ports detected, no refresh needed');
-    return blocklet;
-  }
+      await manager._updateBlockletEnvironment(did);
+      const newBlocklet = await manager.ensureBlocklet(did);
 
-  const componentDids = Array.from(occupiedDids);
-  await states.blocklet.refreshBlockletPorts(did, componentDids, isGreen);
-  logger.info('Refreshed component ports due to conflict', { did, componentDids });
+      return newBlocklet;
+    }
 
-  await manager._updateBlockletEnvironment(did);
-  const newBlocklet = await manager.ensureBlocklet(did);
+    logger.info('Ports were detected as occupied but not actually occupied during refresh, no refresh needed', {
+      did,
+      componentDids,
+      isGreen,
+    });
 
-  return newBlocklet;
+    return blocklet;
+  } finally {
+    await portAssignLock.releaseLock(lockName);
+  }
 };
 
 const getComponentNamesWithVersion = (app = {}, componentDids = []) => {

package/lib/util/docker/ensure-docker-postgres.js

@@ -62,6 +62,7 @@ async function _ensureDockerPostgres(dataDir, name = 'abtnode-postgres', port =
   }
 
   const postgresVersion = process.env.ABT_NODE_POSTGRES_VERSION || '17.5';
+  const postgresMaxConnections = process.env.ABT_NODE_POSTGRES_MAX_CONNECTIONS || '500';
 
   const runCmd = [
     'docker run -d',
@@ -74,7 +75,7 @@ async function _ensureDockerPostgres(dataDir, name = 'abtnode-postgres', port =
     '-e POSTGRES_USER=postgres',
     '-e POSTGRES_DB=postgres',
     `postgres:${postgresVersion}`,
-    '-c max_connections=200',
+    `-c max_connections=${postgresMaxConnections}`,
   ].join(' ');
 
   const url = `postgresql://postgres:postgres@localhost:${port}/postgres`;

package/lib/util/install-external-dependencies.js

@@ -33,7 +33,7 @@ async function installExternalDependencies({ appDir, forceInstall = false, nodeI
   }
 
   if (!(await isSameOs(appDir, isUseDocker))) {
-    fs.removeSync(path.join(appDir, 'node_modules'));
+    fs.removeSync(path.join(appDir, 'node_modules'), { recursive: true });
   }
 
   const isNeedInstall = forceInstall || externals.some((dependency) => !isDependencyInstalled(appDir, dependency));

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.17.3-beta-20251123-232619-53258789",
+  "version": "1.17.3-beta-20251126-121502-d0926972",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -17,46 +17,46 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "Apache-2.0",
   "dependencies": {
-    "@abtnode/analytics": "1.17.3-beta-20251123-232619-53258789",
-    "@abtnode/auth": "1.17.3-beta-20251123-232619-53258789",
-    "@abtnode/certificate-manager": "1.17.3-beta-20251123-232619-53258789",
-    "@abtnode/constant": "1.17.3-beta-20251123-232619-53258789",
-    "@abtnode/cron": "1.17.3-beta-20251123-232619-53258789",
-    "@abtnode/db-cache": "1.17.3-beta-20251123-232619-53258789",
-    "@abtnode/docker-utils": "1.17.3-beta-20251123-232619-53258789",
-    "@abtnode/logger": "1.17.3-beta-20251123-232619-53258789",
-    "@abtnode/models": "1.17.3-beta-20251123-232619-53258789",
-    "@abtnode/queue": "1.17.3-beta-20251123-232619-53258789",
-    "@abtnode/rbac": "1.17.3-beta-20251123-232619-53258789",
-    "@abtnode/router-provider": "1.17.3-beta-20251123-232619-53258789",
-    "@abtnode/static-server": "1.17.3-beta-20251123-232619-53258789",
-    "@abtnode/timemachine": "1.17.3-beta-20251123-232619-53258789",
-    "@abtnode/util": "1.17.3-beta-20251123-232619-53258789",
-    "@aigne/aigne-hub": "^0.10.9",
-    "@arcblock/did": "^1.27.7",
-    "@arcblock/did-connect-js": "^1.27.7",
-    "@arcblock/did-ext": "^1.27.7",
+    "@abtnode/analytics": "1.17.3-beta-20251126-121502-d0926972",
+    "@abtnode/auth": "1.17.3-beta-20251126-121502-d0926972",
+    "@abtnode/certificate-manager": "1.17.3-beta-20251126-121502-d0926972",
+    "@abtnode/constant": "1.17.3-beta-20251126-121502-d0926972",
+    "@abtnode/cron": "1.17.3-beta-20251126-121502-d0926972",
+    "@abtnode/db-cache": "1.17.3-beta-20251126-121502-d0926972",
+    "@abtnode/docker-utils": "1.17.3-beta-20251126-121502-d0926972",
+    "@abtnode/logger": "1.17.3-beta-20251126-121502-d0926972",
+    "@abtnode/models": "1.17.3-beta-20251126-121502-d0926972",
+    "@abtnode/queue": "1.17.3-beta-20251126-121502-d0926972",
+    "@abtnode/rbac": "1.17.3-beta-20251126-121502-d0926972",
+    "@abtnode/router-provider": "1.17.3-beta-20251126-121502-d0926972",
+    "@abtnode/static-server": "1.17.3-beta-20251126-121502-d0926972",
+    "@abtnode/timemachine": "1.17.3-beta-20251126-121502-d0926972",
+    "@abtnode/util": "1.17.3-beta-20251126-121502-d0926972",
+    "@aigne/aigne-hub": "^0.10.10",
+    "@arcblock/did": "^1.27.12",
+    "@arcblock/did-connect-js": "^1.27.12",
+    "@arcblock/did-ext": "^1.27.12",
     "@arcblock/did-motif": "^1.1.14",
-    "@arcblock/did-util": "^1.27.7",
-    "@arcblock/event-hub": "^1.27.7",
-    "@arcblock/jwt": "^1.27.7",
+    "@arcblock/did-util": "^1.27.12",
+    "@arcblock/event-hub": "^1.27.12",
+    "@arcblock/jwt": "^1.27.12",
     "@arcblock/pm2-events": "^0.0.5",
-    "@arcblock/validator": "^1.27.7",
-    "@arcblock/vc": "^1.27.7",
-    "@blocklet/constant": "1.17.3-beta-20251123-232619-53258789",
-    "@blocklet/did-space-js": "^1.2.4",
-    "@blocklet/env": "1.17.3-beta-20251123-232619-53258789",
+    "@arcblock/validator": "^1.27.12",
+    "@arcblock/vc": "^1.27.12",
+    "@blocklet/constant": "1.17.3-beta-20251126-121502-d0926972",
+    "@blocklet/did-space-js": "^1.2.6",
+    "@blocklet/env": "1.17.3-beta-20251126-121502-d0926972",
     "@blocklet/error": "^0.3.3",
-    "@blocklet/meta": "1.17.3-beta-20251123-232619-53258789",
-    "@blocklet/resolver": "1.17.3-beta-20251123-232619-53258789",
-    "@blocklet/sdk": "1.17.3-beta-20251123-232619-53258789",
-    "@blocklet/server-js": "1.17.3-beta-20251123-232619-53258789",
-    "@blocklet/store": "1.17.3-beta-20251123-232619-53258789",
-    "@blocklet/theme": "^3.2.6",
+    "@blocklet/meta": "1.17.3-beta-20251126-121502-d0926972",
+    "@blocklet/resolver": "1.17.3-beta-20251126-121502-d0926972",
+    "@blocklet/sdk": "1.17.3-beta-20251126-121502-d0926972",
+    "@blocklet/server-js": "1.17.3-beta-20251126-121502-d0926972",
+    "@blocklet/store": "1.17.3-beta-20251126-121502-d0926972",
+    "@blocklet/theme": "^3.2.10",
     "@fidm/x509": "^1.2.1",
-    "@ocap/mcrypto": "^1.27.7",
-    "@ocap/util": "^1.27.7",
-    "@ocap/wallet": "^1.27.7",
+    "@ocap/mcrypto": "^1.27.12",
+    "@ocap/util": "^1.27.12",
+    "@ocap/wallet": "^1.27.12",
     "@slack/webhook": "^7.0.6",
     "archiver": "^7.0.1",
     "axios": "^1.7.9",
@@ -116,5 +116,5 @@
     "express": "^4.18.2",
     "unzipper": "^0.10.11"
   },
-  "gitHead": "d37497a49c982e82ba60249ed06c1b73f340b893"
+  "gitHead": "7039cacaad2a14a9573371e24e57cbbd6b6525c8"
 }