@abtnode/core 1.17.5-beta-20251209-090953-3a59e7ac → 1.17.5-beta-20251211-104355-426d7eb6

package/lib/blocklet/manager/disk.js

@@ -905,6 +905,44 @@ class DiskBlockletManager extends BaseBlockletManager {
       this.emit(BlockletEvents.statusChange, doc1);
       const startedBlockletDids = [];
       const errorBlockletDids = [];
+      const parentBlockletId = blocklet.id;
+
+      // Helper function to update child status immediately and emit events
+      const updateChildStatusImmediately = async (componentDid, status) => {
+        if (!states.blockletChild || !parentBlockletId) {
+          return;
+        }
+
+        try {
+          await states.blockletChild.updateChildStatus(parentBlockletId, componentDid, status, false, {
+            operator,
+          });
+
+          // Get updated blocklet to emit events
+          const updatedBlocklet = await this.getBlocklet(did);
+          const componentsInfo = getComponentsInternalInfo(updatedBlocklet);
+
+          this.emit(BlockletInternalEvents.componentUpdated, {
+            appDid: blocklet.appDid,
+            components: componentsInfo.filter((c) => c.did === componentDid),
+          });
+
+          if (status === BlockletStatus.running) {
+            this.emit(BlockletInternalEvents.componentStarted, {
+              appDid: blocklet.appDid,
+              components: [{ did: componentDid }],
+            });
+          }
+
+          this.emit(BlockletEvents.statusChange, updatedBlocklet);
+        } catch (err) {
+          logger.error('Failed to update child status immediately', {
+            componentDid,
+            status,
+            error: err.message,
+          });
+        }
+      };
 
       const notStartedComponentDids = await this.startRequiredComponents({
         componentDids,
@@ -915,11 +953,13 @@ class DiskBlockletManager extends BaseBlockletManager {
         e2eMode,
         context,
         atomic,
-        onStarted: (subDid) => {
+        onStarted: async (subDid) => {
           startedBlockletDids.push({ did: subDid });
+          await updateChildStatusImmediately(subDid, BlockletStatus.running);
         },
-        onError: (subDid, error) => {
+        onError: async (subDid, error) => {
           errorBlockletDids.push({ did: subDid, error });
+          await updateChildStatusImmediately(subDid, BlockletStatus.error);
         },
       });
 
@@ -933,11 +973,13 @@ class DiskBlockletManager extends BaseBlockletManager {
               e2eMode,
               componentDids: [componentDid],
               operator,
-              onStarted: (subDid) => {
+              onStarted: async (subDid) => {
                 startedBlockletDids.push({ did: subDid });
+                await updateChildStatusImmediately(subDid, BlockletStatus.running);
               },
-              onError: (subDid, error) => {
+              onError: async (subDid, error) => {
                 errorBlockletDids.push({ did: subDid, error });
+                await updateChildStatusImmediately(subDid, BlockletStatus.error);
               },
             },
             context
@@ -950,15 +992,12 @@ class DiskBlockletManager extends BaseBlockletManager {
       let errorDescription = '';
       let resultBlocklet = nextBlocklet;
 
+      // Status updates are now done immediately in callbacks, so we only need to handle final events and cleanup
       if (startedBlockletDids.length) {
-        await states.blocklet.setBlockletStatus(did, BlockletStatus.running, {
-          componentDids: startedBlockletDids.map((x) => x.did),
-          operator,
-        });
-
         const finalBlocklet = await this.getBlocklet(did);
         resultBlocklet = finalBlocklet;
 
+        // Sync app config after all components started
         await this.configSynchronizer.throttledSyncAppConfig(finalBlocklet, { wait: 200 });
         const componentsInfo = getComponentsInternalInfo(finalBlocklet);
         this.emit(BlockletInternalEvents.componentUpdated, {
@@ -1009,10 +1048,7 @@ class DiskBlockletManager extends BaseBlockletManager {
           componentDids: errorBlockletDids.map((x) => x.did),
           shouldUpdateBlockletStatus: false,
         });
-        await states.blocklet.setBlockletStatus(did, BlockletStatus.error, {
-          componentDids: errorBlockletDids.map((x) => x.did),
-          operator,
-        });
+
         const finalBlocklet = await this.getBlocklet(did);
         resultBlocklet = finalBlocklet;
         this.emit(BlockletEvents.startFailed, {

package/lib/blocklet/manager/helper/blue-green-start-blocklet.js

@@ -173,6 +173,97 @@ const blueGreenStartBlocklet = async (
 
   const startedBlockletDids = [];
   const errorBlockletDids = [];
+  const appId = blocklet1.id;
+
+  const notificationChange = async () => {
+    // Get latest children from blocklet_children table instead of reloading entire blocklet
+    const latestChildren = await states.blocklet.loadChildren(appId);
+
+    // Merge latest children into blocklet1 for event emission
+    const finalBlocklet = {
+      ...blocklet1,
+      children: latestChildren,
+    };
+
+    await manager.configSynchronizer.throttledSyncAppConfig(finalBlocklet);
+    const componentsInfo = getComponentsInternalInfo(finalBlocklet);
+    manager.emit(BlockletInternalEvents.componentUpdated, {
+      appDid: blocklet1.appDid,
+      components: componentsInfo,
+    });
+
+    manager.emit(BlockletInternalEvents.componentStarted, {
+      appDid: blocklet1.appDid,
+      components: startedBlockletDids.map((x) => ({ did: x.did })),
+    });
+
+    // Emit statusChange event so UI can see the status change
+    manager.emit(BlockletEvents.statusChange, finalBlocklet);
+
+    manager.emit(BlockletEvents.started, { ...finalBlocklet, componentDids: startedBlockletDids.map((x) => x.did) });
+  };
+
+  // Helper function to update child status immediately and emit events
+  const updateChildStatusImmediately = async (componentDid, status, isGreen = false) => {
+    if (!states.blockletChild || !appId) {
+      return;
+    }
+
+    try {
+      const updates = {
+        operator,
+        inProgressStart: Date.now(),
+      };
+
+      if (status === BlockletStatus.running) {
+        updates.startedAt = new Date();
+        updates.stoppedAt = null;
+      } else if (status === BlockletStatus.error || status === BlockletStatus.stopped) {
+        updates.stoppedAt = new Date();
+      }
+
+      await states.blockletChild.updateChildStatus(appId, componentDid, status, isGreen, updates);
+
+      if (status === BlockletStatus.running) {
+        await states.blockletChild.updateChildStatus(appId, componentDid, BlockletStatus.stopped, !isGreen, updates);
+      }
+
+      // Get latest children from blocklet_children table and emit events immediately
+      const latestChildren = await states.blocklet.loadChildren(appId);
+      const updatedBlocklet = {
+        ...blocklet1,
+        children: latestChildren,
+      };
+      const componentsInfo = getComponentsInternalInfo(updatedBlocklet);
+
+      manager.emit(BlockletInternalEvents.componentUpdated, {
+        appDid: blocklet1.appDid,
+        components: componentsInfo.filter((c) => c.did === componentDid),
+      });
+
+      if (status === BlockletStatus.running) {
+        manager.emit(BlockletInternalEvents.componentStarted, {
+          appDid: blocklet1.appDid,
+          components: [{ did: componentDid }],
+        });
+      }
+
+      manager.emit(BlockletEvents.statusChange, updatedBlocklet);
+
+      // Emit statusChange event immediately so UI can see each component's status change
+      manager.emit(BlockletEvents.started, {
+        ...updatedBlocklet,
+        componentDids: startedBlockletDids.map((x) => x.did),
+      });
+    } catch (err) {
+      logger.error('Failed to update child status immediately', {
+        componentDid,
+        status,
+        isGreen,
+        error: err.message,
+      });
+    }
+  };
 
   for (const item of blueGreenComponentIds) {
     if (!item.componentDids.length) {
@@ -274,6 +365,11 @@ const blueGreenStartBlocklet = async (
           // 收集成功的组件（排除已经在 errorBlockletDids 中的组件）
           startedBlockletDids.push({ did: subDid, isGreen: item.changeToGreen });
 
+          // Update status immediately
+          await updateChildStatusImmediately(subDid, BlockletStatus.running, item.changeToGreen);
+
+          await manager.deleteProcess({ did, componentDids: [subDid], isGreen: !item.changeToGreen });
+
           logger.info('Green environment started successfully', {
             did,
             componentDids: [subDid],
@@ -285,6 +381,9 @@ const blueGreenStartBlocklet = async (
           // 收集失败的组件
           errorBlockletDids.push({ did: subDid, error, isGreen: item.changeToGreen });
 
+          // Update status immediately
+          await updateChildStatusImmediately(subDid, BlockletStatus.error, item.changeToGreen);
+
           try {
             await manager.deleteProcess({ did, componentDids: [subDid], isGreen: item.changeToGreen });
           } catch (cleanupError) {
@@ -326,37 +425,6 @@ const blueGreenStartBlocklet = async (
       });
     }
 
-    const greenBlockletDids = errorBlockletDids.filter((x) => x.isGreen).map((x) => x.did);
-    const blueBlockletDids = errorBlockletDids.filter((x) => !x.isGreen).map((x) => x.did);
-
-    if (greenBlockletDids.length) {
-      await manager.deleteProcess({
-        did,
-        componentDids: greenBlockletDids,
-        shouldUpdateBlockletStatus: false,
-        isGreen: true,
-      });
-      await states.blocklet.setBlockletStatus(did, BlockletStatus.error, {
-        componentDids: greenBlockletDids,
-        operator,
-        isGreen: true,
-      });
-    }
-
-    if (blueBlockletDids.length) {
-      await manager.deleteProcess({
-        did,
-        componentDids: blueBlockletDids,
-        shouldUpdateBlockletStatus: false,
-        isGreen: false,
-      });
-      await states.blocklet.setBlockletStatus(did, BlockletStatus.error, {
-        componentDids: blueBlockletDids,
-        operator,
-        isGreen: false,
-      });
-    }
-
     const finalBlocklet = await manager.getBlocklet(did);
     manager.emit(BlockletEvents.startFailed, {
       ...finalBlocklet,
@@ -368,45 +436,7 @@ const blueGreenStartBlocklet = async (
 
   // 处理成功启动的组件
   if (startedBlockletDids.length) {
-    const startedGreenBlockletDids = startedBlockletDids.filter((x) => x.isGreen).map((x) => x.did);
-    const startedBlueBlockletDids = startedBlockletDids.filter((x) => !x.isGreen).map((x) => x.did);
-
-    if (startedGreenBlockletDids.length) {
-      await states.blocklet.setBlockletStatus(did, BlockletStatus.running, {
-        componentDids: startedGreenBlockletDids,
-        operator,
-        isGreen: true,
-      });
-      await manager.deleteProcess({ did, componentDids: startedGreenBlockletDids, isGreen: false });
-    }
-
-    if (startedBlueBlockletDids.length) {
-      await states.blocklet.setBlockletStatus(did, BlockletStatus.running, {
-        componentDids: startedBlueBlockletDids,
-        operator,
-        isGreen: false,
-      });
-      await manager.deleteProcess({ did, componentDids: startedBlueBlockletDids, isGreen: true });
-    }
-
-    const finalBlocklet = await manager.getBlocklet(did);
-
-    await manager.configSynchronizer.throttledSyncAppConfig(finalBlocklet);
-    const componentsInfo = getComponentsInternalInfo(finalBlocklet);
-    manager.emit(BlockletInternalEvents.componentUpdated, {
-      appDid: blocklet1.appDid,
-      components: componentsInfo,
-    });
-    manager.emit(BlockletInternalEvents.componentStarted, {
-      appDid: blocklet1.appDid,
-      components: startedBlockletDids.map((x) => ({ did: x.did })),
-    });
-
-    manager.emit(BlockletEvents.statusChange, finalBlocklet);
-    manager.emit(BlockletEvents.started, {
-      ...finalBlocklet,
-      componentDids: startedBlockletDids.map((x) => x.did),
-    });
+    await notificationChange();
   }
 
   // 根据情况更新 route table， 会判断只有包含多 interfaces 的 DID 才会更新 route table

package/lib/migrations/index.js

@@ -169,11 +169,11 @@ const runSchemaMigrations = async ({
 
   // migrate server schema
   dbPaths.server = getDbFilePath(path.join(dataDir, 'core/server.db'));
-  await doSchemaMigration(dbPaths.server, 'server');
+  await doSchemaMigration(dbPaths.server, 'server', true);
   printSuccess(`Server schema successfully migrated: ${dbPaths.server}`);
   // migrate service schema
   dbPaths.service = getDbFilePath(path.join(dataDir, 'services/service.db'));
-  await doSchemaMigration(dbPaths.service, 'service');
+  await doSchemaMigration(dbPaths.service, 'service', true);
   printSuccess(`Service schema successfully migrated: ${dbPaths.service}`);
 
   // migrate blocklet schema
@@ -183,7 +183,7 @@ const runSchemaMigrations = async ({
     if (env) {
       const filePath = getDbFilePath(path.join(env.value, 'blocklet.db'));
       dbPaths.blocklets.push(filePath);
-      await doSchemaMigration(filePath, 'blocklet');
+      await doSchemaMigration(filePath, 'blocklet', true);
       printSuccess(`Blocklet schema successfully migrated: ${blocklet.appPid}: ${filePath}`);
     } else {
       printInfo(`Skip migrate schema for blocklet: ${blocklet.appPid}`);
@@ -193,7 +193,7 @@ const runSchemaMigrations = async ({
   // migrate certificate manager schema
   for (let i = 0; i < MODULES.length; i++) {
     const filePath = getDbFilePath(path.join(dataDir, `modules/${MODULES[i]}/module.db`));
-    await doSchemaMigration(filePath, MODULES[i]);
+    await doSchemaMigration(filePath, MODULES[i], true);
     dbPaths.certificateManagers.push(filePath);
     printSuccess(`${MODULES[i]} schema successfully migrated: ${filePath}`);
   }

package/lib/monitor/blocklet-runtime-monitor.js

@@ -230,16 +230,14 @@ class BlockletRuntimeMonitor extends EventEmitter {
 
     insertThrottleMap.set(blockletDid, now);
 
-    return this.states.runtimeInsight.insert({ did: blockletDid, ...value }).catch((err) => {
+    return this.states.runtimeInsight.insert({ did: blockletDid, ...value }).catch((error) => {
+      const err = typeof error === 'string' ? error : error.message;
       if (err.includes('duplicate key value violates unique constraint ')) {
         console.error('RuntimeInsight insert error duplicate key value violates unique constraint');
         return;
       }
       if (err.name === 'SequelizeValidationError') {
-        console.error(
-          'RuntimeInsight validation error',
-          err.errors.map((e) => e.message)
-        );
+        console.error('RuntimeInsight validation error:', err);
       } else {
         console.error('RuntimeInsight insert error', err);
       }

package/lib/states/blocklet-child.js

@@ -0,0 +1,119 @@
+/* eslint-disable no-underscore-dangle */
+const { BlockletStatus } = require('@blocklet/constant');
+const BaseState = require('./base');
+
+/**
+ * @extends BaseState<import('@abtnode/models').BlockletChildState>
+ */
+class BlockletChildState extends BaseState {
+  constructor(model, config = {}) {
+    super(model, config);
+  }
+
+  /**
+   * Get children by parent blocklet ID
+   * @param {string} parentBlockletId - The parent blocklet ID
+   * @returns {Promise<Array>} - Array of children
+   */
+  async getChildrenByParentId(parentBlockletId) {
+    if (!parentBlockletId) {
+      return [];
+    }
+    const children = await this.find({ parentBlockletId }, {}, { createdAt: 1 });
+    return children || [];
+  }
+
+  /**
+   * Delete children by parent blocklet ID
+   * @param {string} parentBlockletId - The parent blocklet ID
+   * @returns {Promise<number>} - Number of deleted children
+   */
+  deleteByParentId(parentBlockletId) {
+    if (!parentBlockletId) {
+      return 0;
+    }
+    return this.remove({ parentBlockletId });
+  }
+
+  /**
+   * Update child status by parent blocklet ID and child DID
+   * @param {string} parentBlockletId - The parent blocklet ID
+   * @param {string} childDid - The child DID
+   * @param {number} status - The status to set
+   * @param {Object} additionalFields - Additional fields to update
+   * @param {boolean} isGreen - Whether the child is green
+   * @returns {Promise<Object>} - Updated child
+   */
+  async updateChildStatus(parentBlockletId, childDid, status, isGreen = false, additionalFields = {}) {
+    if (!parentBlockletId) {
+      return null;
+    }
+    const children = await this.getChildrenByParentId(parentBlockletId);
+    const child = children.find((c) => c.childDid === childDid);
+
+    if (!child) {
+      return null;
+    }
+
+    const updates = {
+      ...additionalFields,
+    };
+    if (isGreen) {
+      updates.greenStatus = status;
+    } else {
+      updates.status = status;
+    }
+
+    if (status === BlockletStatus.running) {
+      updates.startedAt = new Date();
+      updates.stoppedAt = null;
+    } else if (status === BlockletStatus.stopped) {
+      updates.startedAt = null;
+      updates.stoppedAt = new Date();
+    }
+
+    const [, [updated]] = await this.update({ id: child.id }, { $set: updates });
+    return updated;
+  }
+
+  /**
+   * Batch update children status
+   * @param {string} parentBlockletId - The parent blocklet ID
+   * @param {Array<string>} childDids - Array of child DIDs to update
+   * @param {number} status - The status to set
+   * @param {Object} additionalFields - Additional fields to update
+   * @returns {Promise<Array>} - Updated children
+   */
+  async batchUpdateChildrenStatus(parentBlockletId, childDids, status, additionalFields = {}) {
+    if (!parentBlockletId) {
+      return [];
+    }
+    const children = await this.getChildrenByParentId(parentBlockletId);
+    const updates = [];
+
+    for (const child of children) {
+      if (childDids.includes(child.childDid)) {
+        const childUpdates = {
+          status,
+          ...additionalFields,
+        };
+
+        if (status === BlockletStatus.running) {
+          childUpdates.startedAt = new Date();
+          childUpdates.stoppedAt = null;
+        } else if (status === BlockletStatus.stopped) {
+          childUpdates.startedAt = null;
+          childUpdates.stoppedAt = new Date();
+        }
+
+        // eslint-disable-next-line no-await-in-loop
+        await this.update({ id: child.id }, { $set: childUpdates });
+        updates.push({ ...child, ...childUpdates });
+      }
+    }
+
+    return updates;
+  }
+}
+
+module.exports = BlockletChildState;

package/lib/states/blocklet.js

@@ -145,6 +145,8 @@ const getExternalPortsFromMeta = (meta) =>
 const formatBlocklet = (blocklet, phase, dek) => {
   if (phase === 'onRead') {
     blocklet.status = getBlockletStatus(blocklet);
+    // Ensure children exists before forEachBlockletSync accesses it
+    blocklet.children = blocklet.children || [];
   }
 
   forEachBlockletSync(blocklet, (b) => {
@@ -253,6 +255,200 @@ class BlockletState extends BaseState {
     // @didMap: { [did: string]: metaDid: string }
     this.didMap = new Map();
     this.statusLocks = new Map();
+
+    // BlockletChildState instance passed from outside
+    this.BlockletChildState = config.BlockletChildState || null;
+  }
+
+  /**
+   * Load children for a blocklet
+   * @param {string} blockletId - The blocklet ID
+   * @returns {Promise<Array>} - Array of children
+   */
+  async loadChildren(blockletId) {
+    if (!this.BlockletChildState || !blockletId) {
+      return [];
+    }
+
+    const children = await this.BlockletChildState.getChildrenByParentId(blockletId);
+    // Ensure children is always an array
+    if (!Array.isArray(children)) {
+      return [];
+    }
+
+    return children.map((child) => {
+      // Ensure meta is an object and has required fields
+      const meta = child.meta || {};
+      if (!meta.did) {
+        logger.warn('loadChildren: child missing meta.did', { childId: child.id, parentBlockletId: blockletId });
+      }
+      if (!meta.name && !meta.bundleName) {
+        logger.warn('loadChildren: child missing meta.name and meta.bundleName', {
+          childId: child.id,
+          childDid: meta.did,
+          parentBlockletId: blockletId,
+        });
+      }
+
+      const childObj = {
+        id: child.id,
+        mountPoint: child.mountPoint,
+        meta,
+        bundleSource: child.bundleSource || {},
+        source: child.source || 0,
+        deployedFrom: child.deployedFrom || '',
+        mode: child.mode || 'production',
+        status: child.status || 0,
+        ports: child.ports || {},
+        children: child.children || [],
+        migratedFrom: child.migratedFrom || [],
+        installedAt: child.installedAt,
+        startedAt: child.startedAt,
+        stoppedAt: child.stoppedAt,
+        pausedAt: child.pausedAt,
+        operator: child.operator,
+        inProgressStart: child.inProgressStart,
+        greenStatus: child.greenStatus,
+        greenPorts: child.greenPorts,
+      };
+
+      // Recursively load children for this child
+      if (child.children && child.children.length > 0) {
+        // Note: children array now contains IDs, need to load them
+        // This will be handled by forEachComponentV2 or similar methods
+      }
+
+      return childObj;
+    });
+  }
+
+  /**
+   * Save children to BlockletChild table
+   * @param {string} blockletId - The parent blocklet ID
+   * @param {string} blockletDid - The parent blocklet DID
+   * @param {Array} children - Array of children to save
+   */
+  async saveChildren(blockletId, blockletDid, children) {
+    if (!this.BlockletChildState) {
+      logger.warn('BlockletChildState is not initialized, cannot save children');
+      return;
+    }
+
+    if (!blockletId || !blockletDid) {
+      logger.warn('saveChildren called with invalid blockletId or blockletDid', { blockletId, blockletDid });
+      return;
+    }
+
+    if (!children || children.length === 0) {
+      // If no children provided, delete all existing children
+      await this.BlockletChildState.deleteByParentId(blockletId);
+      return;
+    }
+
+    // Get existing children
+    const existingChildren = await this.BlockletChildState.getChildrenByParentId(blockletId);
+    const existingChildrenMap = new Map();
+    existingChildren.forEach((child) => {
+      existingChildrenMap.set(child.childDid, child);
+    });
+
+    // Track which children should be kept
+    const childrenToKeep = new Set();
+
+    // Process each child: update if exists, insert if new
+    for (const child of children) {
+      const childDid = child.meta?.did;
+      if (!childDid) {
+        logger.warn('saveChildren: child missing meta.did, skipping', {
+          blockletId,
+          blockletDid,
+          child: child.meta?.name || 'unknown',
+        });
+        continue;
+      }
+
+      childrenToKeep.add(childDid);
+
+      const existingChild = existingChildrenMap.get(childDid);
+      const updates = {};
+
+      // Only update fields that have changed or are necessary
+      // Fields that should be updated: meta, bundleSource, source, deployedFrom, mode, ports, children, migratedFrom
+      // Fields that should be preserved if not provided: status, installedAt, startedAt, stoppedAt, pausedAt, operator, inProgressStart, greenStatus, greenPorts
+
+      // Always update these fields
+      if (child.mountPoint !== undefined) updates.mountPoint = child.mountPoint;
+      if (child.meta !== undefined) updates.meta = child.meta;
+      if (child.bundleSource !== undefined) updates.bundleSource = child.bundleSource;
+      if (child.source !== undefined) updates.source = child.source;
+      if (child.deployedFrom !== undefined) updates.deployedFrom = child.deployedFrom;
+      if (child.mode !== undefined) updates.mode = child.mode;
+      if (child.ports !== undefined) updates.ports = child.ports;
+      if (child.children !== undefined) updates.children = child.children || [];
+      if (child.migratedFrom !== undefined) updates.migratedFrom = child.migratedFrom;
+
+      // Only update status-related fields if explicitly provided
+      if (child.status !== undefined) updates.status = child.status;
+      if (child.installedAt !== undefined) updates.installedAt = child.installedAt;
+      if (child.startedAt !== undefined) updates.startedAt = child.startedAt;
+      if (child.stoppedAt !== undefined) updates.stoppedAt = child.stoppedAt;
+      if (child.pausedAt !== undefined) updates.pausedAt = child.pausedAt;
+      if (child.operator !== undefined) updates.operator = child.operator;
+      if (child.inProgressStart !== undefined) updates.inProgressStart = child.inProgressStart;
+      if (child.greenStatus !== undefined) updates.greenStatus = child.greenStatus;
+      if (child.greenPorts !== undefined) updates.greenPorts = child.greenPorts;
+
+      try {
+        if (existingChild) {
+          // Update existing child only if there are changes
+          if (Object.keys(updates).length > 0) {
+            await this.BlockletChildState.update({ id: existingChild.id }, { $set: updates });
+          }
+        } else {
+          // Insert new child
+          await this.BlockletChildState.insert({
+            parentBlockletId: blockletId,
+            parentBlockletDid: blockletDid,
+            childDid,
+            mountPoint: child.mountPoint,
+            meta: child.meta,
+            bundleSource: child.bundleSource,
+            source: child.source || 0,
+            deployedFrom: child.deployedFrom || '',
+            mode: child.mode || 'production',
+            status: child.status || 0,
+            ports: child.ports || {},
+            children: child.children || [],
+            migratedFrom: child.migratedFrom || [],
+            installedAt: child.installedAt,
+            startedAt: child.startedAt,
+            stoppedAt: child.stoppedAt,
+            pausedAt: child.pausedAt,
+            operator: child.operator,
+            inProgressStart: child.inProgressStart,
+            greenStatus: child.greenStatus,
+            greenPorts: child.greenPorts,
+          });
+        }
+      } catch (error) {
+        logger.error('saveChildren: failed to save child', {
+          blockletId,
+          blockletDid,
+          childDid,
+          isUpdate: !!existingChild,
+          error: error.message,
+        });
+        throw error;
+      }
+    }
+
+    // Delete children that are no longer in the list
+    const childrenToDelete = existingChildren.filter((child) => !childrenToKeep.has(child.childDid));
+    if (childrenToDelete.length > 0) {
+      for (const childToDelete of childrenToDelete) {
+        await this.BlockletChildState.remove({ id: childToDelete.id });
+      }
+    }
   }
 
   /**
@@ -268,7 +464,15 @@ class BlockletState extends BaseState {
     }
 
     const doc = await this.findOne({ $or: getConditions(did) });
-    return doc ? formatBlocklet(doc, 'onRead', decryptSk ? this.config.dek : null) : null;
+    if (!doc) {
+      return null;
+    }
+
+    // Load children from BlockletChild table
+    const children = await this.loadChildren(doc.id);
+    doc.children = children;
+
+    return formatBlocklet(doc, 'onRead', decryptSk ? this.config.dek : null);
   }
 
   async getBlockletMetaDid(did) {
@@ -304,7 +508,16 @@ class BlockletState extends BaseState {
 
   async getBlocklets(query = {}, projection = {}, sort = { createdAt: -1 }) {
     const docs = await this.find(query, projection, sort);
-    return docs.filter(Boolean).map((doc) => formatBlocklet(doc, 'onRead', this.config.dek));
+    const result = [];
+
+    for (const doc of docs.filter(Boolean)) {
+      // Load children for each blocklet
+      const children = await this.loadChildren(doc.id);
+      doc.children = children;
+      result.push(formatBlocklet(doc, 'onRead', this.config.dek));
+    }
+
+    return result;
   }
 
   async deleteBlocklet(did) {
@@ -313,6 +526,11 @@ class BlockletState extends BaseState {
       throw new CustomError(404, `Try to remove non-existing blocklet ${did}`);
     }
 
+    // Delete children from BlockletChild table
+    if (this.BlockletChildState) {
+      await this.BlockletChildState.deleteByParentId(doc.id);
+    }
+
     await this.remove({ id: doc.id });
 
     this.didMap.delete(doc.meta?.did);
@@ -376,7 +594,6 @@ class BlockletState extends BaseState {
         deployedFrom,
         ports,
         environments: [],
-        children,
         migratedFrom,
         externalSk,
         externalSkSource,
@@ -384,6 +601,10 @@ class BlockletState extends BaseState {
       });
 
       doc = await this.findOne({ id: doc.id });
+      doc.children = children;
+
+      // Save children to BlockletChild table
+      await this.saveChildren(doc.id, doc.meta.did, children);
 
       this.emit('add', doc);
 
@@ -403,6 +624,15 @@ class BlockletState extends BaseState {
     const formatted = formatBlocklet(omit(cloneDeep(updates), ['vaults']), 'onUpdate', this.config.dek);
     const [, [updated]] = await this.update({ id: doc.id }, { $set: formatted });
 
+    // If children are being updated, set them on the updated object before calculating status
+    // This ensures getBlockletStatus can correctly calculate status based on children
+    if (updates.children !== undefined) {
+      updated.children = updates.children;
+      if (this.BlockletChildState) {
+        await this.saveChildren(updated.id, updated.meta.did, updates.children);
+      }
+    }
+
     updated.status = getBlockletStatus(updated);
 
     return updated;
@@ -475,10 +705,13 @@ class BlockletState extends BaseState {
         meta: omit(sanitized, ['htmlAst']),
         source,
         deployedFrom,
-        children,
         ports,
       });
 
+      // Save children to BlockletChild table
+      await this.saveChildren(newDoc.id, newDoc.meta.did, children);
+      newDoc.children = children;
+
       this.emit('upgrade', newDoc);
       return newDoc;
     } finally {
@@ -630,9 +863,10 @@ class BlockletState extends BaseState {
     });
 
     if (actuallyRefreshedDids.length > 0) {
-      await this.updateBlocklet(did, {
-        children: blocklet.children,
-      });
+      await this.updateBlocklet(did, {});
+
+      // Save updated children to BlockletChild table
+      await this.saveChildren(blocklet.id, blocklet.meta.did, blocklet.children);
     }
 
     return {
@@ -643,7 +877,7 @@ class BlockletState extends BaseState {
   }
 
   async getServices() {
-    const blocklets = await this.getBlocklets({}, { meta: 1, children: 1, ports: 1 });
+    const blocklets = await this.getBlocklets({}, { meta: 1, ports: 1 });
     const services = [];
 
     blocklets.forEach((blocklet) => {
@@ -681,7 +915,7 @@ class BlockletState extends BaseState {
    * @return {Object} { <did> : { interfaceName } }
    */
   async groupAllInterfaces() {
-    const blocklets = await this.getBlocklets({}, { meta: 1, children: 1 });
+    const blocklets = await this.getBlocklets({}, { meta: 1 });
     const result = {};
     const fillResult = (component, { id }) => {
       const { interfaces } = component.meta;
@@ -701,6 +935,22 @@ class BlockletState extends BaseState {
     return result;
   }
 
+  /**
+   * Reset the blocklet state by clearing all blocklets and their children
+   * This overrides BaseState.reset() to handle foreign key constraints
+   */
+  async reset() {
+    // First, delete all children to avoid foreign key constraint errors
+    if (this.BlockletChildState) {
+      const allBlocklets = await this.getBlocklets({}, { id: 1 });
+      for (const blocklet of allBlocklets) {
+        await this.BlockletChildState.deleteByParentId(blocklet.id);
+      }
+    }
+    // Then call parent reset to clear the blocklets table
+    return super.reset();
+  }
+
   /**
    * @param {Did} did blocklet did
    * @param {BlockletStatus} status blocklet status
@@ -764,14 +1014,17 @@ class BlockletState extends BaseState {
 
       const shouldSetStatus = status === BlockletStatus.downloading || status === BlockletStatus.waiting;
       const updateData = {
-        children: doc.children,
         operator,
       };
       if (shouldSetStatus) {
         updateData.status = status;
       }
 
+      updateData.children = doc.children;
+
       const res = await this.updateBlocklet(did, updateData);
+
+      res.children = doc.children;
       return res;
     } finally {
       await lock.releaseLock(lockName);
@@ -902,7 +1155,7 @@ class BlockletState extends BaseState {
   }
 
   async _getOccupiedPorts() {
-    const blocklets = await this.getBlocklets({}, { port: 1, ports: 1, meta: 1, children: 1 });
+    const blocklets = await this.getBlocklets({}, { port: 1, ports: 1, meta: 1 });
 
     const occupiedExternalPorts = new Map();
     const occupiedInternalPorts = new Map();

package/lib/states/index.js

@@ -4,6 +4,7 @@ const logger = require('@abtnode/logger')('@abtnode/core:states');
 
 const NodeState = require('./node');
 const BlockletState = require('./blocklet');
+const BlockletChildState = require('./blocklet-child');
 const NotificationState = require('./notification');
 const SiteState = require('./site');
 const AccessKeyState = require('./access-key');
@@ -33,7 +34,8 @@ const init = (dataDirs, config = {}) => {
   const notificationState = new NotificationState(models.Notification, config, models);
 
   const nodeState = new NodeState(models.Server, config, dataDirs, notificationState);
-  const blockletState = new BlockletState(models.Blocklet, config);
+  const blockletChildState = new BlockletChildState(models.BlockletChild, config);
+  const blockletState = new BlockletState(models.Blocklet, { ...config, BlockletChildState: blockletChildState });
   const siteState = new SiteState(models.Site, config);
   const accessKeyState = new AccessKeyState(models.AccessKey, config);
   const webhookState = new WebhookState(models.WebHook, config);
@@ -52,6 +54,7 @@ const init = (dataDirs, config = {}) => {
   return {
     node: nodeState,
     blocklet: blockletState,
+    blockletChild: blockletChildState,
     notification: notificationState,
     site: siteState,
     accessKey: accessKeyState,

package/lib/util/blocklet.js

@@ -416,36 +416,6 @@ const getBlockletConfigObj = (blocklet, { excludeSecure } = {}) => {
 
   return obj;
 };
-/**
- * set 'configs', configObj', 'environmentObj' to blocklet TODO
- * @param {*} blocklet
- * @param {*} configs
- */
-const fillBlockletConfigs = (blocklet, configs) => {
-  blocklet.configs = configs || [];
-  blocklet.configObj = getBlockletConfigObj(blocklet);
-  blocklet.environments = blocklet.environments || [];
-  blocklet.environmentObj = blocklet.environments.reduce((acc, x) => {
-    acc[x.key] = templateReplace(x.value, blocklet);
-    return acc;
-  }, {});
-};
-
-const ensureBlockletExpanded = async (_meta, appDir) => {
-  const bundlePath = path.join(appDir, BLOCKLET_BUNDLE_FILE);
-  if (fs.existsSync(bundlePath)) {
-    try {
-      const nodeModulesPath = path.join(appDir, 'node_modules');
-      if (fs.existsSync(nodeModulesPath)) {
-        fs.removeSync(nodeModulesPath);
-      }
-      await expandBundle(bundlePath, appDir);
-      fs.removeSync(bundlePath);
-    } catch (err) {
-      throw new Error(`Failed to expand blocklet bundle: ${err.message}`);
-    }
-  }
-};
 
 const getAppSystemEnvironments = (blocklet, nodeInfo, dataDirs) => {
   const { did, name, title, description } = blocklet.meta;
@@ -562,6 +532,81 @@ const getComponentSystemEnvironments = (blocklet) => {
   };
 };
 
+/**
+ * set 'configs', configObj', 'environmentObj' to blocklet TODO
+ * @param {*} blocklet
+ * @param {*} configs
+ * @param {*} options - Optional: { rootBlocklet, nodeInfo, dataDirs }
+ */
+const fillBlockletConfigs = (blocklet, configs, options = {}) => {
+  blocklet.configs = configs || [];
+  blocklet.configObj = getBlockletConfigObj(blocklet);
+  blocklet.environments = blocklet.environments || [];
+  blocklet.environmentObj = blocklet.environments.reduce((acc, x) => {
+    acc[x.key] = templateReplace(x.value, blocklet);
+    return acc;
+  }, {});
+
+  // After migration: ensure all component system environments are set from blocklet.env if available
+  // This ensures children loaded from blocklet_children table have all required env vars in environmentObj
+  if (blocklet.env) {
+    try {
+      const componentSystemEnvs = getComponentSystemEnvironments(blocklet);
+      // Only set env vars that are not already set
+      Object.entries(componentSystemEnvs).forEach(([key, value]) => {
+        if (value !== undefined && value !== null && !blocklet.environmentObj[key]) {
+          blocklet.environmentObj[key] = value;
+        }
+      });
+    } catch (error) {
+      // If getting component system environments fails, log warning but continue
+      logger.warn('fillBlockletConfigs: failed to get component system environments', {
+        blockletDid: blocklet.meta?.did,
+        error: error.message,
+      });
+    }
+  }
+
+  // For children: also set app-level environment variables from root blocklet
+  // This ensures children have app-level env vars like BLOCKLET_APP_ID
+  const { rootBlocklet, nodeInfo, dataDirs } = options;
+  if (rootBlocklet && nodeInfo && dataDirs && blocklet !== rootBlocklet) {
+    try {
+      const appSystemEnvs = getAppSystemEnvironments(rootBlocklet, nodeInfo, dataDirs);
+      const appOverwrittenEnvs = getAppOverwrittenEnvironments(rootBlocklet, nodeInfo);
+      // Only set env vars that are not already set
+      Object.entries({ ...appSystemEnvs, ...appOverwrittenEnvs }).forEach(([key, value]) => {
+        if (value !== undefined && value !== null && !blocklet.environmentObj[key]) {
+          blocklet.environmentObj[key] = value;
+        }
+      });
+    } catch (error) {
+      // If getting app system environments fails, log warning but continue
+      logger.warn('fillBlockletConfigs: failed to get app system environments', {
+        blockletDid: blocklet.meta?.did,
+        rootDid: rootBlocklet.meta?.did,
+        error: error.message,
+      });
+    }
+  }
+};
+
+const ensureBlockletExpanded = async (_meta, appDir) => {
+  const bundlePath = path.join(appDir, BLOCKLET_BUNDLE_FILE);
+  if (fs.existsSync(bundlePath)) {
+    try {
+      const nodeModulesPath = path.join(appDir, 'node_modules');
+      if (fs.existsSync(nodeModulesPath)) {
+        fs.removeSync(nodeModulesPath);
+      }
+      await expandBundle(bundlePath, appDir);
+      fs.removeSync(bundlePath);
+    } catch (err) {
+      throw new Error(`Failed to expand blocklet bundle: ${err.message}`);
+    }
+  }
+};
+
 const getRuntimeEnvironments = (blocklet, nodeEnvironments, ancestors, isGreen = false) => {
   const root = (ancestors || [])[0] || blocklet;
 
@@ -1970,21 +2015,44 @@ const _getBlocklet = async ({
 
   await forEachBlocklet(blocklet, async (component, { id, level, ancestors }) => {
     // component env
-    component.env = {
-      id,
-      name: getComponentName(component, ancestors),
-      processId: getComponentProcessId(component, ancestors),
-      ...getComponentDirs(component, {
-        dataDirs,
-        ensure: ensureIntegrity,
-        ancestors,
-        e2eMode: level === 0 ? e2eMode : false,
-      }),
-    };
+    try {
+      // Validate component has required meta fields for getComponentDirs
+      if (!component.meta) {
+        throw new Error(`Component missing meta field: ${component.meta?.did || id}`);
+      }
+      if (!component.meta.name && !component.meta.bundleName) {
+        throw new Error(
+          `Component missing meta.name and meta.bundleName: ${component.meta.did || id}. ` +
+            'This may indicate a migration issue with blocklet_children table.'
+        );
+      }
+
+      component.env = {
+        id,
+        name: getComponentName(component, ancestors),
+        processId: getComponentProcessId(component, ancestors),
+        ...getComponentDirs(component, {
+          dataDirs,
+          ensure: ensureIntegrity,
+          ancestors,
+          e2eMode: level === 0 ? e2eMode : false,
+        }),
+      };
+    } catch (error) {
+      logger.error('Failed to set component env in _getBlocklet', {
+        componentDid: component.meta?.did,
+        componentName: component.meta?.name,
+        componentBundleName: component.meta?.bundleName,
+        error: error.message,
+        stack: error.stack,
+      });
+      throw error;
+    }
 
     // component config
     const configs = await states.blockletExtras.getConfigs([...ancestors.map((x) => x.meta.did), component.meta.did]);
-    fillBlockletConfigs(component, configs);
+    const rootBlocklet = ancestors.length > 0 ? ancestors[0] : blocklet;
+    fillBlockletConfigs(component, configs, { rootBlocklet, nodeInfo, dataDirs });
   });
 
   if (getOptionalComponents) {

package/lib/util/migration-sqlite-to-postgres.js

@@ -94,6 +94,14 @@ async function migrateAllTablesNoModels(dbPath) {
       .filter(([, def]) => def.type && ['JSON', 'JSONB'].includes(def.type.toUpperCase()))
       .map(([col, def]) => ({ name: col, type: def.type.toUpperCase() }));
 
+    // find DATE/TIMESTAMP columns (need to validate and fix invalid dates)
+    const dateCols = Object.entries(pgSchema)
+      .filter(([, def]) => {
+        const type = def.type?.toUpperCase() || '';
+        return type.includes('DATE') || type.includes('TIMESTAMP') || type === 'DATE' || type.startsWith('TIMESTAMP');
+      })
+      .map(([col]) => col);
+
     // find auto-increment columns (nextval default)
     const autoIncCols = Object.entries(pgSchema)
       .filter(([, def]) => typeof def.defaultValue === 'string' && def.defaultValue.startsWith('nextval('))
@@ -159,12 +167,37 @@ async function migrateAllTablesNoModels(dbPath) {
       console.log(`   Migrating rows ${offset + 1}-${offset + rows.length}`);
 
       for (const row of rows) {
-        // 如果有 createdAt 或 updatedAt 列, 并且值是不合法的 Date, 就改成当前时间
-        if (row.createdAt && Number.isNaN(new Date(row.createdAt).getTime())) {
-          row.createdAt = new Date();
-        }
-        if (row.updatedAt && Number.isNaN(new Date(row.updatedAt).getTime())) {
-          row.updatedAt = new Date();
+        // Fix invalid date values for all DATE/TIMESTAMP columns
+        for (const dateCol of dateCols) {
+          if (row[dateCol] != null) {
+            const dateVal = row[dateCol];
+            // Check if it's an invalid date (NaN, "Invalid date" string, or invalid Date object)
+            let isValid = false;
+            if (dateVal instanceof Date) {
+              isValid = !Number.isNaN(dateVal.getTime());
+            } else if (typeof dateVal === 'string') {
+              // Check for "Invalid date" string or empty string
+              if (dateVal === 'Invalid date' || dateVal === '' || dateVal === 'null') {
+                isValid = false;
+              } else {
+                const parsed = new Date(dateVal);
+                isValid = !Number.isNaN(parsed.getTime());
+              }
+            } else if (typeof dateVal === 'number') {
+              // Check if it's a valid timestamp
+              const parsed = new Date(dateVal);
+              isValid = !Number.isNaN(parsed.getTime());
+            } else {
+              // null or undefined are valid (will be handled by allowNull)
+              isValid = true;
+            }
+
+            if (!isValid) {
+              console.warn(`   ⚠️ ${tableName}: Invalid date in column "${dateCol}", fixing to current time`);
+              console.log(`      Old value: ${dateVal} (type: ${typeof dateVal})`);
+              row[dateCol] = new Date();
+            }
+          }
         }
 
         // 修复不合格的旧数据
@@ -266,6 +299,46 @@ async function migrateAllTablesNoModels(dbPath) {
             console.error(`   ❌ ${tableName}: string too long for VARCHAR columns:`, badCols);
             continue;
           }
+          // Handle invalid timestamp/date errors - should have been fixed above, but log if still occurs
+          const timestampErr = err.message.match(/invalid input syntax for type timestamp/i);
+          if (timestampErr) {
+            console.error(`   ❌ ${tableName}: Invalid timestamp error (should have been fixed):`, err.message);
+            console.log('      Row data:', JSON.stringify(row, null, 2));
+            // Try to fix and retry once
+            let fixed = false;
+            for (const dateCol of dateCols) {
+              if (row[dateCol] != null) {
+                const dateVal = row[dateCol];
+                if (
+                  dateVal === 'Invalid date' ||
+                  dateVal === '' ||
+                  (typeof dateVal === 'string' && dateVal.toLowerCase() === 'null')
+                ) {
+                  row[dateCol] = new Date();
+                  fixed = true;
+                } else {
+                  const parsed = new Date(dateVal);
+                  if (Number.isNaN(parsed.getTime())) {
+                    row[dateCol] = new Date();
+                    fixed = true;
+                  }
+                }
+              }
+            }
+            if (fixed) {
+              console.log('   🔧 Fixed invalid dates, retrying insert...');
+              const retryBindVals = insertCols.map((c) => row[c]);
+              try {
+                await pgDb.query(upsertSQL, { bind: retryBindVals });
+                continue;
+              } catch (retryErr) {
+                console.error('   ❌ Retry failed:', retryErr.message);
+              }
+            }
+            // If still failing, skip this row
+            console.warn('   ⚠️ Skipping row due to timestamp error');
+            continue;
+          }
           console.error(`   ❌ Upsert failed for ${tableName} : ${err.message}, SQL:${upsertSQL} value: ${bindVals}`);
           if (ignoreErrorTableNames.has(tableName)) {
             console.log(`   ❌ Ignore error for ${tableName}`);

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.17.5-beta-20251209-090953-3a59e7ac",
+  "version": "1.17.5-beta-20251211-104355-426d7eb6",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -17,21 +17,21 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "Apache-2.0",
   "dependencies": {
-    "@abtnode/analytics": "1.17.5-beta-20251209-090953-3a59e7ac",
-    "@abtnode/auth": "1.17.5-beta-20251209-090953-3a59e7ac",
-    "@abtnode/certificate-manager": "1.17.5-beta-20251209-090953-3a59e7ac",
-    "@abtnode/constant": "1.17.5-beta-20251209-090953-3a59e7ac",
-    "@abtnode/cron": "1.17.5-beta-20251209-090953-3a59e7ac",
-    "@abtnode/db-cache": "1.17.5-beta-20251209-090953-3a59e7ac",
-    "@abtnode/docker-utils": "1.17.5-beta-20251209-090953-3a59e7ac",
-    "@abtnode/logger": "1.17.5-beta-20251209-090953-3a59e7ac",
-    "@abtnode/models": "1.17.5-beta-20251209-090953-3a59e7ac",
-    "@abtnode/queue": "1.17.5-beta-20251209-090953-3a59e7ac",
-    "@abtnode/rbac": "1.17.5-beta-20251209-090953-3a59e7ac",
-    "@abtnode/router-provider": "1.17.5-beta-20251209-090953-3a59e7ac",
-    "@abtnode/static-server": "1.17.5-beta-20251209-090953-3a59e7ac",
-    "@abtnode/timemachine": "1.17.5-beta-20251209-090953-3a59e7ac",
-    "@abtnode/util": "1.17.5-beta-20251209-090953-3a59e7ac",
+    "@abtnode/analytics": "1.17.5-beta-20251211-104355-426d7eb6",
+    "@abtnode/auth": "1.17.5-beta-20251211-104355-426d7eb6",
+    "@abtnode/certificate-manager": "1.17.5-beta-20251211-104355-426d7eb6",
+    "@abtnode/constant": "1.17.5-beta-20251211-104355-426d7eb6",
+    "@abtnode/cron": "1.17.5-beta-20251211-104355-426d7eb6",
+    "@abtnode/db-cache": "1.17.5-beta-20251211-104355-426d7eb6",
+    "@abtnode/docker-utils": "1.17.5-beta-20251211-104355-426d7eb6",
+    "@abtnode/logger": "1.17.5-beta-20251211-104355-426d7eb6",
+    "@abtnode/models": "1.17.5-beta-20251211-104355-426d7eb6",
+    "@abtnode/queue": "1.17.5-beta-20251211-104355-426d7eb6",
+    "@abtnode/rbac": "1.17.5-beta-20251211-104355-426d7eb6",
+    "@abtnode/router-provider": "1.17.5-beta-20251211-104355-426d7eb6",
+    "@abtnode/static-server": "1.17.5-beta-20251211-104355-426d7eb6",
+    "@abtnode/timemachine": "1.17.5-beta-20251211-104355-426d7eb6",
+    "@abtnode/util": "1.17.5-beta-20251211-104355-426d7eb6",
     "@aigne/aigne-hub": "^0.10.10",
     "@arcblock/did": "^1.27.12",
     "@arcblock/did-connect-js": "^1.27.12",
@@ -43,15 +43,15 @@
     "@arcblock/pm2-events": "^0.0.5",
     "@arcblock/validator": "^1.27.12",
     "@arcblock/vc": "^1.27.12",
-    "@blocklet/constant": "1.17.5-beta-20251209-090953-3a59e7ac",
+    "@blocklet/constant": "1.17.5-beta-20251211-104355-426d7eb6",
     "@blocklet/did-space-js": "^1.2.6",
-    "@blocklet/env": "1.17.5-beta-20251209-090953-3a59e7ac",
+    "@blocklet/env": "1.17.5-beta-20251211-104355-426d7eb6",
     "@blocklet/error": "^0.3.3",
-    "@blocklet/meta": "1.17.5-beta-20251209-090953-3a59e7ac",
-    "@blocklet/resolver": "1.17.5-beta-20251209-090953-3a59e7ac",
-    "@blocklet/sdk": "1.17.5-beta-20251209-090953-3a59e7ac",
-    "@blocklet/server-js": "1.17.5-beta-20251209-090953-3a59e7ac",
-    "@blocklet/store": "1.17.5-beta-20251209-090953-3a59e7ac",
+    "@blocklet/meta": "1.17.5-beta-20251211-104355-426d7eb6",
+    "@blocklet/resolver": "1.17.5-beta-20251211-104355-426d7eb6",
+    "@blocklet/sdk": "1.17.5-beta-20251211-104355-426d7eb6",
+    "@blocklet/server-js": "1.17.5-beta-20251211-104355-426d7eb6",
+    "@blocklet/store": "1.17.5-beta-20251211-104355-426d7eb6",
     "@blocklet/theme": "^3.2.11",
     "@fidm/x509": "^1.2.1",
     "@ocap/mcrypto": "^1.27.12",
@@ -116,5 +116,5 @@
     "express": "^4.18.2",
     "unzipper": "^0.10.11"
   },
-  "gitHead": "514964082a28e8c6658d9a62cf283811dd6a8baf"
+  "gitHead": "9ea2a8077a8edbf5021281e823719758eb9fe02c"
 }