@abtnode/core 1.17.5-beta-20251209-090953-3a59e7ac → 1.17.5-beta-20251214-122206-29056e8c

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,199 @@ 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 || {},
+        environments: child.environments || [],
+        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.environments !== undefined) updates.environments = child.environments;
+
+      // Only update status-related fields if explicitly provided
+      if (child.status !== undefined) updates.status = child.status;
+      // Note: installedAt should only be set on first install, never updated
+      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 || {},
+            environments: child.environments || [],
+            installedAt: new Date(),
+            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 +463,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 +507,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 +525,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 +593,6 @@ class BlockletState extends BaseState {
         deployedFrom,
         ports,
         environments: [],
-        children,
         migratedFrom,
         externalSk,
         externalSkSource,
@@ -384,6 +600,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 +623,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 +704,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 +862,19 @@ class BlockletState extends BaseState {
     });
 
     if (actuallyRefreshedDids.length > 0) {
-      await this.updateBlocklet(did, {
-        children: blocklet.children,
-      });
+      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,
+            });
+          }
+        }
+      }
     }
 
     return {
@@ -643,7 +885,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 +923,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 +943,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
@@ -736,6 +994,8 @@ class BlockletState extends BaseState {
         return res;
       }
 
+      // Collect components to update
+      const componentsToUpdate = [];
       for (const component of doc.children || []) {
         if (component.meta.group === BlockletGroup.gateway) {
           continue;
@@ -745,6 +1005,9 @@ class BlockletState extends BaseState {
           continue;
         }
 
+        componentsToUpdate.push(component.meta.did);
+
+        // Update in-memory for return value
         component[isGreen ? 'greenStatus' : 'status'] = status;
         if (isGreenAndBlue) {
           component.greenStatus = status;
@@ -764,14 +1027,32 @@ class BlockletState extends BaseState {
 
       const shouldSetStatus = status === BlockletStatus.downloading || status === BlockletStatus.waiting;
       const updateData = {
-        children: doc.children,
         operator,
       };
       if (shouldSetStatus) {
         updateData.status = status;
       }
 
+      // Update blocklet without children to avoid overwriting status during concurrent operations
       const res = await this.updateBlocklet(did, updateData);
+
+      // Update each component's status individually using BlockletChildState
+      if (this.BlockletChildState && componentsToUpdate.length > 0) {
+        for (const componentDid of componentsToUpdate) {
+          await this.BlockletChildState.updateChildStatus(doc.id, componentDid, {
+            status,
+            isGreen,
+            isGreenAndBlue,
+            operator,
+          });
+        }
+      }
+
+      const children = await this.loadChildren(doc.id);
+
+      res.children = children;
+      // Recalculate status after children are loaded with updated status
+      res.status = getBlockletStatus(res);
       return res;
     } finally {
       await lock.releaseLock(lockName);
@@ -902,7 +1183,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/states/notification.js

@@ -965,11 +965,13 @@ class NotificationState extends BaseState {
       throw new Error('Invalid since format. Expected format: "1h", "2h", "24h", etc.');
     }
 
-    const hours = parseInt(sinceMatch[1], 10);
+    let hours = parseInt(sinceMatch[1], 10);
 
     // 验证范围：最小 1h，最大 24h
     if (hours < 1 || hours > 24) {
-      throw new Error('The since parameter must be between 1h and 24h.');
+      logger.warn('The since parameter must be between 1h and 24h.');
+      // 限制 hours 在 1-24 范围内
+      hours = Math.min(Math.max(hours, 1), 24);
     }
 
     // 计算时间范围

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;
 
@@ -1847,6 +1892,7 @@ const formatBlockletTheme = (rawTheme) => {
       themeConfig = {
         ...concept.themeConfig,
         prefer: concept.prefer,
+        name: concept.name,
       };
     } else {
       // 兼容旧数据
@@ -1855,6 +1901,7 @@ const formatBlockletTheme = (rawTheme) => {
         dark: rawTheme.dark || {},
         common: rawTheme.common || {},
         prefer: rawTheme.prefer || 'system',
+        name: rawTheme.name || 'Default',
       };
     }
   }
@@ -1970,21 +2017,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) {