@abtnode/core 1.17.7-beta-20251229-223813-e1e6c5e3 → 1.17.7-beta-20251230-120126-2836fe04

package/lib/blocklet/manager/disk.js

@@ -980,6 +980,9 @@ class DiskBlockletManager extends BaseBlockletManager {
 
       await pAll(tasks, { concurrency: 6 });
 
+      // Sync parent blocklet uptime status once after all components are processed
+      await states.blocklet.syncUptimeStatus(parentBlockletId);
+
       const nextBlocklet = await this.ensureBlocklet(did, { e2eMode });
       let errorDescription = '';
       let resultBlocklet = nextBlocklet;
@@ -1271,6 +1274,9 @@ class DiskBlockletManager extends BaseBlockletManager {
       for (const subDid of entryComponentIds) {
         onError?.(subDid, err);
       }
+      if (throwOnError) {
+        throw err;
+      }
     }
   }
 
@@ -2474,6 +2480,30 @@ class DiskBlockletManager extends BaseBlockletManager {
     });
     this.configSynchronizer.throttledSyncAppConfig(blocklet.meta.did);
 
+    // Restart blocklet if it's running to pick up the new mount point
+    // Only restart the component that was modified (did)
+    if (!isRootComponent && did) {
+      const updatedBlocklet = await this.getBlocklet(rootDid);
+      const updatedComponent = updatedBlocklet.children.find((x) => x.meta.did === did);
+
+      if (
+        updatedComponent &&
+        (updatedComponent.status === BlockletStatus.running || updatedComponent.greenStatus === BlockletStatus.running)
+      ) {
+        try {
+          await this.restart({ did: rootDid, componentDids: [did], operator: context?.user?.did }, context);
+          logger.info('restarted blocklet after mount point update', { rootDid, componentDid: did });
+        } catch (error) {
+          logger.error('failed to restart blocklet after mount point update', {
+            rootDid,
+            componentDid: did,
+            error,
+          });
+          // Don't throw error - mount point update succeeded, restart failure is logged but doesn't block the operation
+        }
+      }
+    }
+
     return this.getBlocklet(rootDid);
   }
 
@@ -3756,6 +3786,13 @@ class DiskBlockletManager extends BaseBlockletManager {
   }
 
   async _onRestart({ did, componentDids, context, operator }) {
+    // 检查 blocklet 是否存在，如果不存在则跳过重启任务
+    // 这可以防止在 blocklet 被删除后，队列中待处理的重启任务执行时出错
+    if (!(await this.hasBlocklet({ did }))) {
+      logger.warn('skip restart job: blocklet not found', { did });
+      return;
+    }
+
     if (process.env.ABT_NODE_DISABLE_BLUE_GREEN) {
       await this.stop({ did, componentDids, context, operator });
       await this.start({ did, componentDids, checkHealthImmediately: true });

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

@@ -401,6 +401,9 @@ const blueGreenStartBlocklet = async (
 
   await pAll(tasks, { concurrency: 6 });
 
+  // Sync parent blocklet uptime status once after all components are processed
+  await states.blocklet.syncUptimeStatus(appId);
+
   const lastBlocklet = await manager.getBlocklet(did, { e2eMode });
   let errorDescription = '';
 

package/lib/migrations/1.17.6-beta-2025123004-blocklet-updated-at.js

@@ -0,0 +1,48 @@
+/* eslint-disable no-await-in-loop */
+
+/**
+ * Migration script to populate startedAt/stoppedAt for existing blocklets
+ *
+ * This migration:
+ * 1. Queries all blocklet IDs efficiently (only fetching `id` field)
+ * 2. For each blocklet, calls syncUptimeStatus to populate startedAt/stoppedAt
+ *    based on the running state of its children
+ *
+ * Uses silent: true internally to prevent updatedAt from being modified
+ */
+module.exports = async ({ states, printInfo }) => {
+  printInfo('Try to populate blocklet uptime (startedAt/stoppedAt)...');
+
+  // Query only the id field for efficiency
+  const blocklets = await states.blocklet.model.findAll({
+    attributes: ['id'],
+    raw: true,
+  });
+
+  if (!blocklets || blocklets.length === 0) {
+    printInfo('No blocklets found, skipping migration');
+    return;
+  }
+
+  printInfo(`Found ${blocklets.length} blocklets to process`);
+
+  let updatedCount = 0;
+  let skippedCount = 0;
+
+  for (const blocklet of blocklets) {
+    try {
+      // syncUptimeStatus handles all the logic:
+      // - Checks if any child is running
+      // - If running and no startedAt: sets startedAt from earliest child startedAt
+      // - If not running and has startedAt without stoppedAt: sets stoppedAt = now
+      // - Uses silent: true to prevent updatedAt modification
+      await states.blocklet.syncUptimeStatus(blocklet.id);
+      updatedCount++;
+    } catch (err) {
+      printInfo(`Skipped blocklet ${blocklet.id}: ${err.message}`);
+      skippedCount++;
+    }
+  }
+
+  printInfo(`Blocklet uptime migration completed: ${updatedCount} updated, ${skippedCount} skipped`);
+};

package/lib/router/helper.js

@@ -508,8 +508,7 @@ const expandComponentRules = (sites = [], blocklets) => {
       }
 
       const blocklet = blocklets.find((x) => x.meta.did === site.blockletDid);
-      const components = blocklet.children.filter((x) => x.mode === BLOCKLET_MODES.PRODUCTION);
-      const expandedRules = components
+      const expandedRules = blocklet.children
         .filter((x) => hasMountPoint(x.meta))
         .map((x) => ({
           id: UUID.v4(),

package/lib/states/blocklet-child.js

@@ -339,6 +339,57 @@ class BlockletChildState extends BaseState {
 
     return results.map((x) => x.toJSON());
   }
+
+  /**
+   * Check if any child of a parent blocklet is in running state
+   * Uses efficient COUNT query instead of loading all children
+   * Checks both status and greenStatus for blue-green deployment support
+   * @param {string} parentBlockletId - The parent blocklet ID
+   * @returns {Promise<boolean>} - True if any child is running
+   */
+  async hasAnyRunningChild(parentBlockletId) {
+    if (!parentBlockletId) {
+      return false;
+    }
+
+    const { Op } = Sequelize;
+    const count = await this.model.count({
+      where: {
+        parentBlockletId,
+        [Op.or]: [{ status: BlockletStatus.running }, { greenStatus: BlockletStatus.running }],
+      },
+    });
+
+    return count > 0;
+  }
+
+  /**
+   * Get the earliest startedAt timestamp from running children
+   * Used to determine when the app first started running
+   * @param {string} parentBlockletId - The parent blocklet ID
+   * @returns {Promise<Date|null>} - Earliest startedAt or null if no running children
+   */
+  async getEarliestRunningStartedAt(parentBlockletId) {
+    if (!parentBlockletId) {
+      return null;
+    }
+
+    const { Op } = Sequelize;
+    const result = await this.model.findOne({
+      attributes: [[Sequelize.fn('MIN', Sequelize.col('startedAt')), 'earliestStartedAt']],
+      where: {
+        parentBlockletId,
+        [Op.or]: [{ status: BlockletStatus.running }, { greenStatus: BlockletStatus.running }],
+        startedAt: { [Op.not]: null },
+      },
+      raw: true,
+    });
+
+    if (result && result.earliestStartedAt) {
+      return new Date(result.earliestStartedAt);
+    }
+    return null;
+  }
 }
 
 module.exports = BlockletChildState;

package/lib/states/blocklet.js

@@ -646,7 +646,7 @@ class BlockletState extends BaseState {
    */
   async findPaginated({ search, external, paging, sort } = {}) {
     // Allowed sort fields whitelist
-    const ALLOWED_SORT_FIELDS = ['installedAt', 'updatedAt', 'status'];
+    const ALLOWED_SORT_FIELDS = ['installedAt', 'updatedAt', 'status', 'startedAt'];
     const ALLOWED_SORT_DIRECTIONS = ['asc', 'desc'];
 
     const conditions = { where: {} };
@@ -658,11 +658,25 @@ class BlockletState extends BaseState {
       const escapedSearch = searchTerm.replace(/[%_]/g, '\\$&');
       const searchLike = `%${escapedSearch}%`;
 
+      const dialect = this.model.sequelize.getDialect();
+
+      // Build search condition for meta column
+      // PostgreSQL: meta is JSONB, need to cast to text before using lower()
+      // SQLite: meta is stored as text, can use lower() directly
+      let metaSearchCondition;
+      if (dialect === 'postgres') {
+        // Cast JSONB to text before applying lower() using PostgreSQL-specific syntax
+        metaSearchCondition = Sequelize.where(Sequelize.literal('lower("meta"::text)'), { [Op.like]: searchLike });
+      } else {
+        // SQLite: meta is already text
+        metaSearchCondition = Sequelize.where(Sequelize.fn('lower', Sequelize.col('meta')), {
+          [Op.like]: searchLike,
+        });
+      }
+
       conditions.where[Op.or] = [
         // Search in meta column (JSON stored as text) - search the whole JSON string
-        Sequelize.where(Sequelize.fn('lower', Sequelize.col('meta')), {
-          [Op.like]: searchLike,
-        }),
+        metaSearchCondition,
         // Search in appDid
         Sequelize.where(Sequelize.fn('lower', Sequelize.col('appDid')), {
           [Op.like]: searchLike,
@@ -1326,6 +1340,12 @@ class BlockletState extends BaseState {
         }
       }
 
+      // Sync parent uptime for stable states (running, stopped, error)
+      const stableStatuses = [BlockletStatus.running, BlockletStatus.stopped, BlockletStatus.error];
+      if (stableStatuses.includes(status)) {
+        await this.syncUptimeStatus(doc.id);
+      }
+
       const children = await this.loadChildren(doc.id);
 
       res.children = children;
@@ -1340,6 +1360,64 @@ class BlockletState extends BaseState {
     }
   }
 
+  /**
+   * Synchronize parent blocklet's startedAt/stoppedAt based on children's running state
+   *
+   * Rules:
+   * - If ANY child has status === RUNNING or greenStatus === RUNNING:
+   *   → App is running, startedAt = earliest child startedAt, stoppedAt = null
+   * - If NO child is running (all stopped/error):
+   *   → App is stopped, stoppedAt = now, startedAt = null
+   * - Only acts on stable states, ignores in-progress statuses
+   *
+   * @param {string} blockletId - The parent blocklet ID (not DID)
+   * @returns {Promise<void>}
+   */
+  async syncUptimeStatus(blockletId) {
+    if (!blockletId) {
+      return;
+    }
+
+    try {
+      const blocklet = await this.findOne({ id: blockletId });
+      if (!blocklet) {
+        return;
+      }
+
+      const hasRunning = await this.BlockletChildState.hasAnyRunningChild(blockletId);
+      if (hasRunning) {
+        // App is running - update startedAt if not already set
+        if (!blocklet.startedAt) {
+          const earliestStartedAt = await this.BlockletChildState.getEarliestRunningStartedAt(blockletId);
+          const newStartedAt = earliestStartedAt || new Date();
+          // Use silent: true to prevent updatedAt from being modified
+          await this.model.update(
+            { startedAt: newStartedAt, stoppedAt: null },
+            { where: { id: blockletId }, silent: true }
+          );
+          logger.info('syncUptimeStatus: app started', {
+            blockletId,
+            appDid: blocklet.appDid,
+            startedAt: newStartedAt,
+          });
+        }
+      } else if (blocklet.startedAt && !blocklet.stoppedAt) {
+        // App is not running - update stoppedAt if was previously running
+        const now = new Date();
+        // Use silent: true to prevent updatedAt from being modified
+        await this.model.update({ stoppedAt: now, startedAt: null }, { where: { id: blockletId }, silent: true });
+        logger.info('syncUptimeStatus: app stopped', {
+          blockletId,
+          appDid: blocklet.appDid,
+          stoppedAt: now,
+        });
+      }
+    } catch (error) {
+      logger.error('syncUptimeStatus failed', { blockletId, error: error.message });
+      // Don't throw - uptime sync failure shouldn't break status updates
+    }
+  }
+
   async setInstalledAt(did) {
     logger.info('setInstalledAt', { did });
     const blocklet = await this.getBlocklet(did);

package/lib/util/ready.js

@@ -1,37 +1,18 @@
 /* eslint-disable no-console */
 const logger = require('@abtnode/logger')('@abtnode/core:ready');
-const chalk = require('chalk');
 
 const createStateReadyHandler =
   () =>
-  ({ states, options }) => {
+  ({ states }) => {
     return states.node
       .read()
-      .then(async (state) => {
+      .then((state) => {
         // Set default sender/receiver for notification center
         states.notification.setDefaultSender(state.did);
         if (state.nodeOwner) {
           states.notification.setDefaultReceiver(state.nodeOwner.did);
         }
-
-        if (process.env.NODE_ENV === 'test' || process.env.CI || process.env.TRAVIS) {
-          // Do not validate data dir sharing in test env
-        } else {
-          const count = await states.node.count();
-          if (count > 1) {
-            // eslint-disable-next-line no-underscore-dangle
-            await states.node.remove({ did: state.did });
-            console.error('\n\x1b[31m======================================================');
-            console.error(`Data dir: ${options.dataDir} is used by another Blocklet Server instance, abort!`);
-            console.error('Sharing data dir between Blocklet Server instances may break things!');
-            console.error('======================================================\x1b[0m');
-            console.log('\nIf you intend to use this dir:');
-            console.log(`  1. Stop Blocklet Server by ${chalk.cyan('blocklet server stop --force')}`);
-            console.log(`  2. Clear data dir by ${chalk.cyan(`rm -r ${options.dataDir}`)}`);
-            console.log('  3. Reinitialize and start Blocklet Server');
-            process.exit(1);
-          }
-        }
+        // deleted states.node.count() check
       })
       .catch((err) => {
         console.error('Can not ready node state on Blocklet Server start:', err.message);

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.17.7-beta-20251229-223813-e1e6c5e3",
+  "version": "1.17.7-beta-20251230-120126-2836fe04",
   "description": "",
   "main": "lib/index.js",
   "files": [
@@ -17,19 +17,19 @@
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "Apache-2.0",
   "dependencies": {
-    "@abtnode/analytics": "1.17.7-beta-20251229-223813-e1e6c5e3",
-    "@abtnode/auth": "1.17.7-beta-20251229-223813-e1e6c5e3",
-    "@abtnode/certificate-manager": "1.17.7-beta-20251229-223813-e1e6c5e3",
-    "@abtnode/constant": "1.17.7-beta-20251229-223813-e1e6c5e3",
-    "@abtnode/cron": "1.17.7-beta-20251229-223813-e1e6c5e3",
-    "@abtnode/db-cache": "1.17.7-beta-20251229-223813-e1e6c5e3",
-    "@abtnode/docker-utils": "1.17.7-beta-20251229-223813-e1e6c5e3",
-    "@abtnode/logger": "1.17.7-beta-20251229-223813-e1e6c5e3",
-    "@abtnode/models": "1.17.7-beta-20251229-223813-e1e6c5e3",
-    "@abtnode/queue": "1.17.7-beta-20251229-223813-e1e6c5e3",
-    "@abtnode/rbac": "1.17.7-beta-20251229-223813-e1e6c5e3",
-    "@abtnode/router-provider": "1.17.7-beta-20251229-223813-e1e6c5e3",
-    "@abtnode/util": "1.17.7-beta-20251229-223813-e1e6c5e3",
+    "@abtnode/analytics": "1.17.7-beta-20251230-120126-2836fe04",
+    "@abtnode/auth": "1.17.7-beta-20251230-120126-2836fe04",
+    "@abtnode/certificate-manager": "1.17.7-beta-20251230-120126-2836fe04",
+    "@abtnode/constant": "1.17.7-beta-20251230-120126-2836fe04",
+    "@abtnode/cron": "1.17.7-beta-20251230-120126-2836fe04",
+    "@abtnode/db-cache": "1.17.7-beta-20251230-120126-2836fe04",
+    "@abtnode/docker-utils": "1.17.7-beta-20251230-120126-2836fe04",
+    "@abtnode/logger": "1.17.7-beta-20251230-120126-2836fe04",
+    "@abtnode/models": "1.17.7-beta-20251230-120126-2836fe04",
+    "@abtnode/queue": "1.17.7-beta-20251230-120126-2836fe04",
+    "@abtnode/rbac": "1.17.7-beta-20251230-120126-2836fe04",
+    "@abtnode/router-provider": "1.17.7-beta-20251230-120126-2836fe04",
+    "@abtnode/util": "1.17.7-beta-20251230-120126-2836fe04",
     "@aigne/aigne-hub": "^0.10.15",
     "@arcblock/did": "^1.27.16",
     "@arcblock/did-connect-js": "^1.27.16",
@@ -41,15 +41,15 @@
     "@arcblock/pm2-events": "^0.0.5",
     "@arcblock/validator": "^1.27.16",
     "@arcblock/vc": "^1.27.16",
-    "@blocklet/constant": "1.17.7-beta-20251229-223813-e1e6c5e3",
+    "@blocklet/constant": "1.17.7-beta-20251230-120126-2836fe04",
     "@blocklet/did-space-js": "^1.2.12",
-    "@blocklet/env": "1.17.7-beta-20251229-223813-e1e6c5e3",
+    "@blocklet/env": "1.17.7-beta-20251230-120126-2836fe04",
     "@blocklet/error": "^0.3.5",
-    "@blocklet/meta": "1.17.7-beta-20251229-223813-e1e6c5e3",
-    "@blocklet/resolver": "1.17.7-beta-20251229-223813-e1e6c5e3",
-    "@blocklet/sdk": "1.17.7-beta-20251229-223813-e1e6c5e3",
-    "@blocklet/server-js": "1.17.7-beta-20251229-223813-e1e6c5e3",
-    "@blocklet/store": "1.17.7-beta-20251229-223813-e1e6c5e3",
+    "@blocklet/meta": "1.17.7-beta-20251230-120126-2836fe04",
+    "@blocklet/resolver": "1.17.7-beta-20251230-120126-2836fe04",
+    "@blocklet/sdk": "1.17.7-beta-20251230-120126-2836fe04",
+    "@blocklet/server-js": "1.17.7-beta-20251230-120126-2836fe04",
+    "@blocklet/store": "1.17.7-beta-20251230-120126-2836fe04",
     "@blocklet/theme": "^3.3.3",
     "@fidm/x509": "^1.2.1",
     "@ocap/mcrypto": "^1.27.16",
@@ -114,5 +114,5 @@
     "express": "^4.18.2",
     "unzipper": "^0.10.11"
   },
-  "gitHead": "5cc55a399f97ddc0822c9896615375c1d3042a72"
+  "gitHead": "ee9edd47a6da9d6b47799357dca96814082f8065"
 }