@abtnode/core 1.17.7-beta-20251227-001958-ea2ba3f5 → 1.17.7-beta-20251229-223813-e1e6c5e3

package/lib/states/blocklet.js

@@ -2,21 +2,16 @@
 /* eslint-disable no-await-in-loop */
 /* eslint-disable function-paren-newline */
 /* eslint-disable no-underscore-dangle */
+const crypto = require('crypto');
 const omit = require('lodash/omit');
 const uniq = require('lodash/uniq');
+const { Op, Sequelize } = require('sequelize');
 const cloneDeep = require('@abtnode/util/lib/deep-clone');
 const detectPort = require('detect-port');
 const security = require('@abtnode/util/lib/security');
 const { CustomError } = require('@blocklet/error');
 const { fixPerson, fixInterfaces } = require('@blocklet/meta/lib/fix');
-const {
-  getDisplayName,
-  forEachBlocklet,
-  forEachBlockletSync,
-  forEachComponentV2,
-  getBlockletServices,
-  hasStartEngine,
-} = require('@blocklet/meta/lib/util');
+const { getDisplayName, forEachBlockletSync, forEachComponentV2, hasStartEngine } = require('@blocklet/meta/lib/util');
 
 const {
   BlockletStatus,
@@ -24,10 +19,12 @@ const {
   BLOCKLET_MODES,
   BLOCKLET_DEFAULT_PORT_NAME,
   BlockletGroup,
+  BLOCKLET_INTERFACE_TYPE_SERVICE,
 } = require('@blocklet/constant');
 const { isPortTaken } = require('@abtnode/util/lib/port');
 const { verifyVault } = require('@blocklet/meta/lib/security');
 const { APP_STRUCT_VERSION } = require('@abtnode/constant');
+const { isValid: isValidDid } = require('@arcblock/did');
 
 const logger = require('@abtnode/logger')('@abtnode/core:states:blocklet');
 
@@ -49,21 +46,26 @@ const portAssignLock = new DBCache(() => ({
   ...getAbtNodeRedisAndSQLiteUrl(),
 }));
 
+// Default port range: 10000-49151 (registered ports, avoiding ephemeral range 49152-65535)
+const DEFAULT_PORT_RANGE = [10000, 49151];
+
 /**
- * 统一的端口分配方法
- * 无论是首次分配还是刷新端口，都使用这个方法
+ * 统一的端口分配方法（优化版本）
+ * 使用 Set 进行 O(1) 端口查找，hash-based 确定性分配
  * @param {Object} options
  * @param {Array<string>} options.wantedPorts - 需要分配的端口名称列表
- * @param {Object} options.blackListPorts - 黑名单端口（已占用的端口）
- * @param {Array<number>} options.portRange - 端口范围，默认 [10000, 31000]
+ * @param {Array<number>} options.blackListPorts - 黑名单端口（已占用的端口）
+ * @param {Array<number>} options.portRange - 端口范围，默认 [10000, 49151]
  * @param {number} options.defaultPort - 回退时的起始端口
+ * @param {string} options.blockletDid - blocklet DID，用于确定性 hash 分配
  * @returns {Promise<Object>} 分配的端口对象 { portName: portNumber }
  */
 async function assignPortsWithLock({
   wantedPorts,
   blackListPorts = [],
-  portRange = [10000, 31000],
+  portRange = DEFAULT_PORT_RANGE,
   defaultPort = 5555,
+  blockletDid = '',
 }) {
   const lockName = 'blocklet-port-assign';
 
@@ -73,54 +75,63 @@ async function assignPortsWithLock({
 
   try {
     const assignedPorts = {};
-    const usedPorts = [...blackListPorts];
+    // OPTIMIZATION: Use Set for O(1) lookup instead of Array O(n)
+    const usedPortsSet = new Set(blackListPorts.map(Number));
+    const rangeSize = portRange[1] - portRange[0];
 
     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];
+      // OPTIMIZATION: Hash-based starting point for deterministic allocation
+      // This reduces collision probability and makes port assignment reproducible
+      let basePort = portRange[0];
+      if (blockletDid) {
+        const hash = crypto.createHash('md5').update(`${blockletDid}:${wantedPort}:${i}`).digest('hex');
+        basePort = portRange[0] + (parseInt(hash.slice(0, 8), 16) % rangeSize);
+      } else {
+        // Fallback to random if no DID provided
+        basePort = portRange[0] + Math.floor(Math.random() * rangeSize);
+      }
+
+      // OPTIMIZATION: Linear probe from hash position (more efficient than random retry)
+      // Maximum probes limited to range size to guarantee termination
+      const maxProbes = Math.min(rangeSize, 1000); // Cap at 1000 to avoid excessive probing
+      for (let offset = 0; offset < maxProbes; offset++) {
+        const candidatePort = portRange[0] + ((basePort - portRange[0] + offset) % rangeSize);
 
-        if (!usedPorts.includes(randomPort)) {
+        if (!usedPortsSet.has(candidatePort)) {
           // eslint-disable-next-line no-await-in-loop
-          const isTaken = await isPortTaken(randomPort);
+          const isTaken = await isPortTaken(candidatePort);
           if (!isTaken) {
-            assignedPort = randomPort;
-            usedPorts.push(assignedPort);
-            found = true;
+            assignedPort = candidatePort;
+            usedPortsSet.add(assignedPort);
+            break;
           }
+          // Mark as used even if taken by external process to avoid re-checking
+          usedPortsSet.add(candidatePort);
         }
-        attempts++;
       }
 
-      // 如果随机方式失败，回退到累加方式
-      if (!found) {
-        logger.warn('Random port assignment failed, falling back to sequential assignment', {
+      // Fallback to detectPort if linear probe fails
+      if (!assignedPort) {
+        logger.warn('Linear probe port assignment failed, falling back to detectPort', {
           wantedPort,
-          attempts,
+          blockletDid,
+          rangeSize,
         });
-        let port = defaultPort + 1;
+        let port = Math.max(defaultPort, portRange[0]) + 1;
         // eslint-disable-next-line no-await-in-loop
         let fallbackPort = await detectPort(Number(port));
-        while (usedPorts.includes(fallbackPort)) {
+        while (usedPortsSet.has(fallbackPort) && fallbackPort < portRange[1]) {
           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);
+        usedPortsSet.add(assignedPort);
       }
 
-      // set wantedPort to assignedPort
       assignedPorts[wantedPort] = assignedPort;
     }
 
@@ -136,8 +147,25 @@ async function assignPortsWithLock({
 const isHex = (str) => /^0x[0-9a-f]+$/i.test(str);
 const getMaxPort = (ports = {}) => Math.max(...Object.values(ports).map(Number));
 
-// structV1Did is just for migration purpose and should be removed in the future
-const getConditions = (did) => [{ 'meta.did': did }, { appDid: did }, { appPid: did }, { structV1Did: did }];
+/**
+ * Build SQL condition for searching a DID in migratedFrom array
+ * @param {string} did - The DID to search for (must be validated before calling)
+ * @param {string} dialect - Database dialect ('postgres' or 'sqlite')
+ * @returns {Object} Sequelize literal condition
+ */
+const getMigratedFromCondition = (did, dialect) => {
+  if (dialect === 'postgres') {
+    return Sequelize.literal(`EXISTS (
+      SELECT 1 FROM jsonb_array_elements("migratedFrom") AS m
+      WHERE m->>'appDid' = '${did}'
+    )`);
+  }
+  // SQLite
+  return Sequelize.literal(`EXISTS (
+    SELECT 1 FROM json_each("migratedFrom")
+    WHERE json_extract(value, '$.appDid') = '${did}'
+  )`);
+};
 
 const getExternalPortsFromMeta = (meta) =>
   (meta.interfaces || []).map((x) => x.port && x.port.external).filter(Boolean);
@@ -254,12 +282,10 @@ class BlockletState extends BaseState {
     this.defaultPort = config.blockletPort || 5555;
     // @didMap: { [did: string]: metaDid: string }
     this.didMap = new Map();
-    // @didToIdMap: { [did: string]: id: string } - 缓存 did 到 doc.id 的映射，避免重复 $or 查询
-    this.didToIdMap = new Map();
     this.statusLocks = new Map();
 
     // BlockletChildState instance passed from outside
-    this.BlockletChildState = config.BlockletChildState || null;
+    this.BlockletChildState = config.BlockletChildState;
   }
 
   /**
@@ -318,7 +344,7 @@ class BlockletState extends BaseState {
   }
 
   async loadChildren(blockletId) {
-    if (!this.BlockletChildState || !blockletId) {
+    if (!blockletId) {
       return [];
     }
 
@@ -333,11 +359,6 @@ class BlockletState extends BaseState {
    * @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;
@@ -479,25 +500,24 @@ class BlockletState extends BaseState {
    * @memberof BlockletState
    */
   async getBlocklet(did, { decryptSk = true } = {}) {
-    if (!did) {
+    if (!did || !isValidDid(did)) {
       return null;
     }
 
-    // 优先使用缓存的 id 直接查询，避免 $or 查询
-    const cachedId = process.env.NODE_ENV === 'test' ? null : this.didToIdMap.get(did);
-    const doc = await this.findOne(cachedId ? { id: cachedId } : { $or: getConditions(did) });
+    const conditions = [{ appDid: did }, { appPid: did }, { 'meta.did': did }, { structV1Did: did }];
+    let doc = await this.findOne({ $or: conditions });
+
+    // If not found and DID is valid, try searching in migratedFrom
     if (!doc) {
-      // 如果缓存的 id 查不到，可能是缓存失效，清除并重试
-      if (cachedId) {
-        this.didToIdMap.delete(did);
-        return this.getBlocklet(did, { decryptSk });
+      const condition = getMigratedFromCondition(did, this.model.sequelize.getDialect());
+      const result = await this.model.findOne({ where: condition });
+      if (result) {
+        doc = result.toJSON();
       }
-      return null;
     }
 
-    // 缓存 did -> id 映射
-    if (!cachedId && process.env.NODE_ENV !== 'test') {
-      this.didToIdMap.set(did, doc.id);
+    if (!doc) {
+      return null;
     }
 
     // Load children from BlockletChild table
@@ -534,7 +554,15 @@ class BlockletState extends BaseState {
       return false;
     }
 
-    const count = await this.count({ $or: getConditions(did) });
+    const conditions = [{ appDid: did }, { appPid: did }, { 'meta.did': did }, { structV1Did: did }];
+    let count = await this.count({ $or: conditions });
+
+    // If not found and DID is valid, try searching in migratedFrom
+    if (count === 0) {
+      const condition = getMigratedFromCondition(did, this.model.sequelize.getDialect());
+      count = await this.model.count({ where: condition });
+    }
+
     return count > 0;
   }
 
@@ -548,10 +576,8 @@ class BlockletState extends BaseState {
 
     // Batch load all children in a single query (instead of N+1 queries)
     let childrenMap = new Map();
-    if (this.BlockletChildState) {
-      const blockletIds = validDocs.map((doc) => doc.id);
-      childrenMap = await this.BlockletChildState.getChildrenByParentIds(blockletIds);
-    }
+    const blockletIds = validDocs.map((doc) => doc.id);
+    childrenMap = await this.BlockletChildState.getChildrenByParentIds(blockletIds);
 
     return validDocs.map((doc) => {
       doc.children = this._processLoadedChildren(childrenMap.get(doc.id) || [], doc.id);
@@ -559,25 +585,158 @@ class BlockletState extends BaseState {
     });
   }
 
+  /**
+   * Process all blocklets in paginated batches without loading children
+   * Optimized for bulk operations that only need specific fields (e.g., appPid)
+   * Memory-efficient: only loads one batch at a time instead of all 10K records
+   *
+   * @param {Object} options
+   * @param {Object} [options.query={}] - Query conditions
+   * @param {Object} [options.projection={}] - Fields to select (e.g., { appPid: 1 })
+   * @param {number} [options.batchSize=100] - Number of records per batch
+   * @param {Function} options.onBatch - Async callback for each batch: (batch) => Promise<void>
+   * @returns {Promise<void>}
+   *
+   * @example
+   * await blockletState.forEachBatch({
+   *   projection: { appPid: 1 },
+   *   batchSize: 100,
+   *   onBatch: async (blocklets) => {
+   *     await Promise.all(blocklets.map(b => processBlocklet(b.appPid)));
+   *   }
+   * });
+   */
+  async forEachBatch({ query = {}, projection = {}, batchSize = 100, onBatch } = {}) {
+    if (typeof onBatch !== 'function') {
+      throw new Error('onBatch callback is required');
+    }
+
+    let page = 1;
+    let hasMore = true;
+
+    while (hasMore) {
+      // Use paginate from BaseState - does NOT load children
+      const result = await this.paginate(query, { createdAt: 1 }, { page, pageSize: batchSize }, projection, {
+        noCount: page > 1, // Only count on first page for efficiency
+      });
+
+      if (result.list.length > 0) {
+        await onBatch(result.list);
+      }
+
+      // Check if there are more pages
+      if (page === 1) {
+        hasMore = page < result.paging.pageCount;
+      } else {
+        // After first page, check by list length
+        hasMore = result.list.length === batchSize;
+      }
+      page++;
+    }
+  }
+
+  /**
+   * Paginated blocklet query with server-side search
+   * @param {Object} params - Query parameters
+   * @param {string} [params.search] - Search text (matches name, title, appDid, appPid)
+   * @param {boolean} [params.external] - Filter by external blocklets (true/false/undefined for all)
+   * @param {Object} [params.paging] - Pagination parameters { page, pageSize }
+   * @param {Object} [params.sort] - Sort parameters { field, direction }
+   * @returns {Promise<{ list: BlockletState[], paging: Paging }>}
+   */
+  async findPaginated({ search, external, paging, sort } = {}) {
+    // Allowed sort fields whitelist
+    const ALLOWED_SORT_FIELDS = ['installedAt', 'updatedAt', 'status'];
+    const ALLOWED_SORT_DIRECTIONS = ['asc', 'desc'];
+
+    const conditions = { where: {} };
+
+    // Server-side search (case-insensitive)
+    if (search?.trim()) {
+      const searchTerm = search.trim().toLowerCase();
+      // Escape special characters for LIKE pattern
+      const escapedSearch = searchTerm.replace(/[%_]/g, '\\$&');
+      const searchLike = `%${escapedSearch}%`;
+
+      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,
+        }),
+        // Search in appDid
+        Sequelize.where(Sequelize.fn('lower', Sequelize.col('appDid')), {
+          [Op.like]: searchLike,
+        }),
+        // Search in appPid
+        Sequelize.where(Sequelize.fn('lower', Sequelize.col('appPid')), {
+          [Op.like]: searchLike,
+        }),
+      ];
+    }
+
+    // Filter by external/internal (based on controller field)
+    if (typeof external === 'boolean') {
+      // skip this for now
+      // conditions.where.controller = external ? { [Op.not]: null } : null;
+    }
+
+    // Validate and build sort order
+    let sortOrder = { updatedAt: -1 }; // default sort
+
+    if (sort?.field) {
+      // Validate sort field against whitelist, fallback to updatedAt if invalid
+      const isValidField = ALLOWED_SORT_FIELDS.includes(sort.field);
+      const sortField = isValidField ? sort.field : 'updatedAt';
+
+      if (!isValidField) {
+        logger.warn(
+          `Invalid sort field: ${sort.field}. Falling back to updatedAt. Allowed: ${ALLOWED_SORT_FIELDS.join(', ')}`
+        );
+      }
+
+      // Validate sort direction, fallback to desc if invalid
+      const direction = sort.direction?.toLowerCase();
+      const isValidDirection = direction && ALLOWED_SORT_DIRECTIONS.includes(direction);
+      const validDirection = isValidDirection ? direction : 'desc';
+
+      if (direction && !isValidDirection) {
+        logger.warn(
+          `Invalid sort direction: ${sort.direction}. Falling back to desc. Allowed: ${ALLOWED_SORT_DIRECTIONS.join(', ')}`
+        );
+      }
+
+      sortOrder = { [sortField]: validDirection === 'asc' ? 1 : -1 };
+    }
+
+    // Use inherited paginate method
+    const result = await this.paginate(conditions, sortOrder, { pageSize: 10, ...paging });
+
+    // Batch load children (existing pattern)
+    if (result.list.length > 0) {
+      const blockletIds = result.list.map((doc) => doc.id);
+      const childrenMap = await this.BlockletChildState.getChildrenByParentIds(blockletIds);
+      result.list = result.list.map((doc) => {
+        doc.children = this._processLoadedChildren(childrenMap.get(doc.id) || [], doc.id);
+        return formatBlocklet(doc, 'onRead', this.config.dek);
+      });
+    } else {
+      result.list = result.list.map((doc) => formatBlocklet(doc, 'onRead', this.config.dek));
+    }
+
+    return result;
+  }
+
   async deleteBlocklet(did) {
     const doc = await this.getBlocklet(did);
     if (!doc) {
       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.BlockletChildState.deleteByParentId(doc.id);
     await this.remove({ id: doc.id });
 
     this.didMap.delete(doc.meta?.did);
     this.didMap.delete(doc.appDid);
-    this.didToIdMap.delete(did);
-    this.didToIdMap.delete(doc.meta?.did);
-    this.didToIdMap.delete(doc.appDid);
-    this.didToIdMap.delete(doc.appPid);
     this.statusLocks.delete(doc.meta?.did);
     this.statusLocks.delete(doc.appDid);
 
@@ -618,9 +777,12 @@ class BlockletState extends BaseState {
       sanitized = ensureMeta(sanitized);
       sanitized = omit(sanitized, ['htmlAst']);
 
-      // get ports
-      const ports = await this.getBlockletPorts({ interfaces: sanitized.interfaces || [] });
-      const children = await this.fillChildrenPorts(rawChildren, { defaultPort: getMaxPort(ports) });
+      // DEPRECATED: App-level port allocation removed
+      // Only components (children) need ports as they are the ones that run processes
+      // App is just a container and doesn't bind to any ports
+      const children = await this.fillChildrenPorts(rawChildren, {
+        defaultPort: this.defaultPort,
+      });
       fixChildren(children);
       children.forEach((x) => {
         x.installedAt = new Date();
@@ -635,7 +797,7 @@ class BlockletState extends BaseState {
         status,
         source,
         deployedFrom,
-        ports,
+        ports: {}, // DEPRECATED: App-level ports no longer allocated
         environments: [],
         migratedFrom,
         externalSk,
@@ -671,9 +833,7 @@ class BlockletState extends BaseState {
     // 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);
-      }
+      await this.saveChildren(updated.id, updated.meta.did, updates.children);
     }
 
     updated.status = getBlockletStatus(updated);
@@ -709,22 +869,18 @@ class BlockletState extends BaseState {
 
       const sanitized = validateBlockletMeta(meta);
 
-      // get ports
+      // DEPRECATED: App-level port allocation removed
+      // Only components (children) need ports as they are the ones that run processes
 
-      const ports = await this.getBlockletPorts({
-        interfaces: sanitized.interfaces || [],
-        skipOccupiedCheckPorts: getExternalPortsFromMeta(doc.meta),
-      });
-      Object.keys(ports).forEach((p) => {
-        ports[p] = doc.ports[p] || ports[p];
+      // fill children ports
+      logger.info('Fill children ports when upgrading blocklet', { name: doc.meta.name, did: doc.meta.did });
+      await this.fillChildrenPorts(children, {
+        oldChildren: doc.children,
+        defaultPort: this.defaultPort,
       });
 
-      // fill
-      logger.info('Fill children ports when when upgrading blocklet', { name: doc.meta.name, did: doc.meta.did });
-      await this.fillChildrenPorts(children, { oldChildren: doc.children, defaultPort: getMaxPort(ports) });
-
       if (manualChildPorts?.length) {
-        logger.info('Fill manual child ports when when upgrading blocklet', {
+        logger.info('Fill manual child ports when upgrading blocklet', {
           did: doc.meta.did,
           manualChildPorts,
         });
@@ -743,12 +899,11 @@ class BlockletState extends BaseState {
 
       fixChildren(children);
 
-      // add to db
+      // add to db - no longer updating app-level ports
       const newDoc = await this.updateBlocklet(meta.did, {
         meta: omit(sanitized, ['htmlAst']),
         source,
         deployedFrom,
-        ports,
       });
 
       // Save children to BlockletChild table
@@ -771,6 +926,7 @@ class BlockletState extends BaseState {
     skipOccupiedCheck = false,
     skipOccupiedCheckPorts = [],
     defaultPort = 0,
+    blockletDid = '',
   } = {}) {
     try {
       const { occupiedExternalPorts, occupiedInternalPorts } = await this._getOccupiedPorts();
@@ -820,8 +976,9 @@ class BlockletState extends BaseState {
       const newPorts = await assignPortsWithLock({
         wantedPorts: portsToAssign,
         blackListPorts,
-        portRange: [10000, 31000],
+        portRange: DEFAULT_PORT_RANGE,
         defaultPort: Math.max(Number(this.defaultPort), defaultPort),
+        blockletDid,
       });
 
       // 合并已分配的端口和新分配的端口
@@ -834,6 +991,7 @@ class BlockletState extends BaseState {
 
   /**
    * refresh ports for blocklet if occupied during starting workflow
+   * OPTIMIZATION: Uses parallel port checks with concurrency limit for better performance at scale
    * @returns {Promise<{refreshed: boolean, componentDids: string[], isInitialAssignment?: boolean}>} 返回是否真正刷新了端口，isInitialAssignment 表示是否是首次分配（非冲突刷新）
    */
   async refreshBlockletPorts(did, componentDids = [], isGreen = false) {
@@ -845,78 +1003,122 @@ class BlockletState extends BaseState {
     const { occupiedExternalPorts, occupiedInternalPorts } = await this._getOccupiedPorts();
     const blackListPorts = [...Array.from(occupiedExternalPorts.keys()), ...Array.from(occupiedInternalPorts.keys())];
 
+    // OPTIMIZATION: Collect all components that need processing first
+    const componentsToProcess = [];
+    await forEachComponentV2(blocklet, (component) => {
+      if (!shouldSkipComponent(component.meta.did, componentDids)) {
+        componentsToProcess.push(component);
+      }
+    });
+
+    if (componentsToProcess.length === 0) {
+      return { refreshed: false, componentDids: [], isInitialAssignment: false };
+    }
+
     const actuallyRefreshedDids = [];
-    let hasInitialAssignment = false; // 标记是否有首次分配（非冲突刷新）
+    let hasInitialAssignment = false;
+
+    // OPTIMIZATION: Check port availability in parallel with concurrency limit
+    const PORT_CHECK_CONCURRENCY = 10;
+    const checkPortAvailability = async (ports) => {
+      const portValues = Object.values(ports);
+      if (portValues.length === 0) return false;
+
+      // Check ports in parallel batches
+      for (let i = 0; i < portValues.length; i += PORT_CHECK_CONCURRENCY) {
+        const batch = portValues.slice(i, i + PORT_CHECK_CONCURRENCY);
+        const results = await Promise.all(batch.map((port) => isPortTaken(port)));
+        if (results.some((taken) => taken)) {
+          return true; // At least one port is taken
+        }
+      }
+      return false;
+    };
 
-    await forEachComponentV2(blocklet, async (component) => {
-      if (!shouldSkipComponent(component.meta.did, componentDids)) {
+    // Process components: first pass - check which need reassignment (parallel)
+    const componentChecks = await Promise.all(
+      componentsToProcess.map(async (component) => {
         let oldPorts = component[isGreen ? 'greenPorts' : 'ports'];
         const hasOldPorts = oldPorts && Object.keys(oldPorts).length > 0;
 
-        // 如果是 green 环境且 greenPorts 为空，需要分配新端口（基于 ports 的端口名）
-        // 这是首次分配，不是冲突刷新
+        // Green environment initial assignment
         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 { component, action: 'initial_green', basePorts };
           }
-          return;
+          return { component, action: 'skip' };
         }
 
-        // 如果 oldPorts 为空，回退到 ports
+        // Fallback to ports if oldPorts is empty
         if (!hasOldPorts) {
           oldPorts = component.ports;
         }
 
-        // 检查旧端口是否真的被占用
-        let needReassign = false;
-        for (const port of Object.values(oldPorts)) {
-          const isTaken = await isPortTaken(port);
-          if (isTaken) {
-            needReassign = true;
-            break;
-          }
+        if (!oldPorts || Object.keys(oldPorts).length === 0) {
+          return { component, action: 'skip' };
         }
 
-        // 只有旧端口被占用时才分配新端口
+        // Check if any port is taken (parallel within component)
+        const needReassign = await checkPortAvailability(oldPorts);
         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 { component, action: 'reassign', oldPorts };
         }
+
+        return { component, action: 'skip' };
+      })
+    );
+
+    // Second pass - assign new ports for components that need it (sequential due to lock)
+    // Track ports assigned in this batch to prevent duplicate assignments
+    const assignedInThisBatch = [];
+
+    for (const { component, action, basePorts, oldPorts } of componentChecks) {
+      if (action === 'skip') continue;
+
+      // Use combined parent/component DID for deterministic per-component port assignment
+      const componentBlockletDid = [blocklet.meta.did, component.meta.did].join('/');
+
+      if (action === 'initial_green') {
+        const wantedPorts = Object.keys(basePorts);
+        const newPorts = await assignPortsWithLock({
+          wantedPorts,
+          blackListPorts: [...blackListPorts, ...Object.values(basePorts), ...assignedInThisBatch],
+          portRange: DEFAULT_PORT_RANGE,
+          defaultPort: this.defaultPort,
+          blockletDid: componentBlockletDid,
+        });
+
+        component.greenPorts = newPorts;
+        actuallyRefreshedDids.push(component.meta.did);
+        hasInitialAssignment = true;
+        assignedInThisBatch.push(...Object.values(newPorts));
+      } else if (action === 'reassign') {
+        const wantedPorts = Object.keys(oldPorts);
+        const newPorts = await assignPortsWithLock({
+          wantedPorts,
+          blackListPorts: [...blackListPorts, ...Object.values(oldPorts), ...assignedInThisBatch],
+          portRange: DEFAULT_PORT_RANGE,
+          defaultPort: this.defaultPort,
+          blockletDid: componentBlockletDid,
+        });
+
+        component[isGreen ? 'greenPorts' : 'ports'] = newPorts;
+        actuallyRefreshedDids.push(component.meta.did);
+        assignedInThisBatch.push(...Object.values(newPorts));
       }
-    });
+    }
 
     if (actuallyRefreshedDids.length > 0) {
       await this.updateBlocklet(did, {});
 
       // Only update ports/greenPorts to avoid overwriting status during concurrent operations
-      if (this.BlockletChildState) {
-        for (const component of blocklet.children) {
-          if (actuallyRefreshedDids.includes(component.meta?.did)) {
-            await this.BlockletChildState.updateChildPorts(blocklet.id, component.meta.did, {
-              ports: component.ports,
-              greenPorts: component.greenPorts,
-            });
-          }
+      for (const component of blocklet.children) {
+        if (actuallyRefreshedDids.includes(component.meta?.did)) {
+          await this.BlockletChildState.updateChildPorts(blocklet.id, component.meta.did, {
+            ports: component.ports,
+            greenPorts: component.greenPorts,
+          });
         }
       }
     }
@@ -924,51 +1126,78 @@ class BlockletState extends BaseState {
     return {
       refreshed: actuallyRefreshedDids.length > 0,
       componentDids: actuallyRefreshedDids,
-      isInitialAssignment: hasInitialAssignment, // 返回是否是首次分配
+      isInitialAssignment: hasInitialAssignment,
     };
   }
 
+  /**
+   * Get all services from blocklet children with SERVICE type interfaces
+   * Optimized: Single query to BlockletChildren table with DB-level JSON filtering
+   * @returns {Promise<Array<{name: string, protocol: string, port: number, upstreamPort: number}>>}
+   */
   async getServices() {
-    const blocklets = await this.getBlocklets({}, { id: 1, meta: 1, ports: 1 });
+    // Single optimized query: only children with SERVICE interfaces, only needed fields
+    const children = await this.BlockletChildState.getChildrenWithServiceInterfaces();
+
     const services = [];
+    const portSet = new Set();
+
+    for (const child of children) {
+      const serviceInterfaces = ((child.meta || {}).interfaces || []).filter(
+        (x) => x.type === BLOCKLET_INTERFACE_TYPE_SERVICE
+      );
 
-    blocklets.forEach((blocklet) => {
-      const list = getBlockletServices(blocklet);
-      list.forEach((x) => {
+      for (const iface of serviceInterfaces) {
+        const portCfg = iface.port || {};
+        // Use greenPorts when green environment is running, otherwise use regular ports
+        const isGreenRunning = child.greenStatus === BlockletStatus.running;
+        const activePorts = isGreenRunning ? child.greenPorts || {} : child.ports || {};
+
+        let externalPort = Number(portCfg.external);
+        const upstreamPort = Number(activePorts[portCfg.internal]);
+
+        // Port redirection support
         // 如果本地 53 端口被系统占用，调试可以配置： export ABT_NODE_REDIRECTION_SERVICE_PORTS="53:10053,553:101553" 等多个 Service 端口重定向
         if (process.env.ABT_NODE_REDIRECTION_SERVICE_PORTS) {
           const redirectionPorts = process.env.ABT_NODE_REDIRECTION_SERVICE_PORTS.split(',');
-          redirectionPorts.forEach((portString) => {
+          for (const portString of redirectionPorts) {
             const [portA, portB] = portString.split(':');
-            if (x.port === +portA) {
-              x.port = +portB;
+            if (externalPort === +portA) {
+              externalPort = +portB;
+              break;
             }
-          });
-        }
-        if (!x.port) {
-          logger.error('Missing service port', { appId: blocklet.meta.did, x });
-          return;
+          }
         }
 
-        if (!x.protocol) {
-          logger.error('Missing service protocol', { appId: blocklet.meta.did, x });
-          return;
+        // Validation
+        if (!externalPort) {
+          logger.error('Missing service port', { iface, childDid: child.meta?.did });
+          continue;
         }
-
-        if (!x.upstreamPort) {
-          logger.error('Missing service upstreamPort', { appId: blocklet.meta.did, x });
-          return;
+        if (!iface.protocol) {
+          logger.error('Missing service protocol', { iface, childDid: child.meta?.did });
+          continue;
+        }
+        if (!upstreamPort) {
+          logger.error('Missing service upstreamPort', { iface, ports: activePorts, childDid: child.meta?.did });
+          continue;
         }
 
-        if (services.find((s) => s.port === x.port)) {
-          // should not be here
-          logger.error('Duplicate service port', { appId: blocklet.meta.did, x });
-          return;
+        // Dedup by external port
+        if (portSet.has(externalPort)) {
+          logger.error('Duplicate service port', { port: externalPort, childDid: child.meta?.did });
+          continue;
         }
+        portSet.add(externalPort);
 
-        services.push(x);
-      });
-    });
+        services.push({
+          name: iface.name,
+          protocol: iface.protocol,
+          port: externalPort,
+          upstreamPort,
+        });
+      }
+    }
 
     return services;
   }
@@ -976,8 +1205,8 @@ class BlockletState extends BaseState {
   /**
    * @return {Object} { <did> : { interfaceName } }
    */
-  async groupAllInterfaces() {
-    const blocklets = await this.getBlocklets({}, { id: 1, meta: 1 });
+  async groupAllInterfaces(blocklets) {
+    const _blocklets = blocklets || (await this.getBlocklets({}, { id: 1, meta: 1 }));
     const result = {};
     const fillResult = (component, { id }) => {
       const { interfaces } = component.meta;
@@ -990,7 +1219,7 @@ class BlockletState extends BaseState {
       });
     };
 
-    blocklets.forEach((blocklet) => {
+    _blocklets.forEach((blocklet) => {
       forEachBlockletSync(blocklet, fillResult);
     });
 
@@ -1002,14 +1231,7 @@ class BlockletState extends BaseState {
    * 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
+    await this.BlockletChildState.reset();
     return super.reset();
   }
 
@@ -1093,7 +1315,7 @@ class BlockletState extends BaseState {
       const res = await this.updateBlocklet(did, updateData);
 
       // Update each component's status individually using BlockletChildState
-      if (this.BlockletChildState && componentsToUpdate.length > 0) {
+      if (componentsToUpdate.length > 0) {
         for (const componentDid of componentsToUpdate) {
           await this.BlockletChildState.updateChildStatus(doc.id, componentDid, {
             status,
@@ -1140,10 +1362,12 @@ class BlockletState extends BaseState {
       // get skipOccupiedCheckPorts
       const skipOccupiedCheckPorts = oldChild ? getExternalPortsFromMeta(oldChild.meta) : [];
 
+      // Use child's own DID for hash-based port allocation (deterministic per component)
       const ports = await this.getBlockletPorts({
         interfaces: childMeta.interfaces || [],
         defaultPort: _maxPort,
         skipOccupiedCheckPorts,
+        blockletDid: child.meta.did,
       });
       _maxPort = getMaxPort(ports);
 
@@ -1241,33 +1465,41 @@ class BlockletState extends BaseState {
     return this.updateBlocklet(did, { structV1Did: v1Did });
   }
 
+  /**
+   * Get all occupied ports by reading directly from BlockletChild table
+   * - Internal ports: From component's ports/greenPorts fields
+   * - External ports: From component's meta.interfaces
+   */
   async _getOccupiedPorts() {
-    const blocklets = await this.getBlocklets({}, { id: 1, port: 1, ports: 1, meta: 1 });
-
     const occupiedExternalPorts = new Map();
     const occupiedInternalPorts = new Map();
 
-    const calcPortsFromBlocklet = (blocklet) => {
-      occupiedInternalPorts.set(Number(blocklet.port), true);
+    // Read directly from BlockletChild table - only components bind to ports
+    const children = await this.BlockletChildState.getAllPorts();
 
-      if (blocklet.ports && typeof blocklet.ports === 'object') {
-        Object.keys(blocklet.ports).forEach((key) => {
-          occupiedInternalPorts.set(Number(blocklet.ports[key]), true);
+    for (const child of children) {
+      // Internal ports from component's ports field
+      if (child.ports && typeof child.ports === 'object') {
+        Object.values(child.ports).forEach((port) => {
+          if (port) occupiedInternalPorts.set(Number(port), true);
         });
       }
-
-      if (Array.isArray(blocklet.meta.interfaces)) {
-        blocklet.meta.interfaces.forEach((x) => {
+      // Green ports as well
+      if (child.greenPorts && typeof child.greenPorts === 'object') {
+        Object.values(child.greenPorts).forEach((port) => {
+          if (port) occupiedInternalPorts.set(Number(port), true);
+        });
+      }
+      // External ports from component's meta.interfaces
+      if (Array.isArray(child.meta?.interfaces)) {
+        child.meta.interfaces.forEach((x) => {
           if (x.port && x.port.external) {
             occupiedExternalPorts.set(Number(x.port.external), true);
           }
         });
       }
-    };
-
-    for (const blocklet of blocklets) {
-      await forEachBlocklet(blocklet, calcPortsFromBlocklet);
     }
+
     return {
       occupiedExternalPorts,
       occupiedInternalPorts,