befly 3.16.5 → 3.16.7

package/dist/befly.js

@@ -2499,7 +2499,7 @@ var require_bn = __commonJS((exports, module) => {
       }
       assert(false, "Base should be between 2 and 36");
     };
-    BN.prototype.toNumber = function toNumber() {
+    BN.prototype.toNumber = function toNumber2() {
       var ret = this.words[0];
       if (this.length === 2) {
         ret += this.words[1] * 67108864;
@@ -2918,7 +2918,7 @@ var require_bn = __commonJS((exports, module) => {
       }
       return out.strip();
     }
-    var comb10MulTo = function comb10MulTo(self, num, out) {
+    var comb10MulTo = function comb10MulTo2(self, num, out) {
       var a = self.words;
       var b = num.words;
       var o = out.words;
@@ -4603,20 +4603,20 @@ var require_bn = __commonJS((exports, module) => {
     BN._prime = function prime(name) {
       if (primes[name])
         return primes[name];
-      var prime;
+      var prime2;
       if (name === "k256") {
-        prime = new K256;
+        prime2 = new K256;
       } else if (name === "p224") {
-        prime = new P224;
+        prime2 = new P224;
       } else if (name === "p192") {
-        prime = new P192;
+        prime2 = new P192;
       } else if (name === "p25519") {
-        prime = new P25519;
+        prime2 = new P25519;
       } else {
         throw new Error("Unknown prime " + name);
       }
-      primes[name] = prime;
-      return prime;
+      primes[name] = prime2;
+      return prime2;
     };
     function Red(m) {
       if (typeof m === "string") {
@@ -5161,7 +5161,7 @@ var require_buffer = __commonJS((exports) => {
     const isCompatible = typeof data === "object" && data.constructor.name === "EncoderBuffer" && typeof data.length === "number" && typeof data.join === "function";
     return isCompatible;
   };
-  EncoderBuffer.prototype.join = function join(out, offset) {
+  EncoderBuffer.prototype.join = function join3(out, offset) {
     if (!out)
       out = Buffer2.alloc(this.length);
     if (!offset)
@@ -9833,6 +9833,7 @@ async function syncCache(ctx) {
   await ctx.cache.cacheApis();
   await ctx.cache.cacheMenus();
   await ctx.cache.rebuildRoleApiPermissions();
+  await ctx.cache.rebuildRoleMenuPermissions();
 }
 
 // lib/cipher.ts
@@ -11482,32 +11483,6 @@ var calcPerfTime = (startTime, endTime = Bun.nanoseconds()) => {
   }
 };
 
-// utils/processInfo.ts
-function getProcessRole(env) {
-  const runtimeEnv = env || {};
-  const bunWorkerId = runtimeEnv["BUN_WORKER_ID"];
-  const pm2InstanceId = runtimeEnv["PM2_INSTANCE_ID"];
-  if (bunWorkerId !== undefined) {
-    return {
-      role: bunWorkerId === "" ? "primary" : "worker",
-      instanceId: bunWorkerId || "0",
-      env: "bun-cluster"
-    };
-  }
-  if (pm2InstanceId !== undefined) {
-    return {
-      role: pm2InstanceId === "0" ? "primary" : "worker",
-      instanceId: pm2InstanceId,
-      env: "pm2-cluster"
-    };
-  }
-  return {
-    role: "primary",
-    instanceId: null,
-    env: "standalone"
-  };
-}
-
 // utils/scanSources.ts
 init_dist();
 
@@ -11598,7 +11573,7 @@ var corsHook = {
 };
 var cors_default = corsHook;
 
-// ../../node_modules/.bun/fast-xml-parser@5.3.3/node_modules/fast-xml-parser/src/util.js
+// ../../node_modules/.bun/fast-xml-parser@5.3.4/node_modules/fast-xml-parser/src/util.js
 var nameStartChar = ":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
 var nameChar = nameStartChar + "\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
 var nameRegexp = "[" + nameStartChar + "][" + nameChar + "]*";
@@ -11626,7 +11601,7 @@ function isExist(v) {
   return typeof v !== "undefined";
 }
 
-// ../../node_modules/.bun/fast-xml-parser@5.3.3/node_modules/fast-xml-parser/src/validator.js
+// ../../node_modules/.bun/fast-xml-parser@5.3.4/node_modules/fast-xml-parser/src/validator.js
 var defaultOptions2 = {
   allowBooleanAttributes: false,
   unpairedTags: []
@@ -11928,7 +11903,7 @@ function getPositionFromMatch(match) {
   return match.startIndex + match[1].length;
 }
 
-// ../../node_modules/.bun/fast-xml-parser@5.3.3/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
+// ../../node_modules/.bun/fast-xml-parser@5.3.4/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
 var defaultOptions3 = {
   preserveOrder: false,
   attributeNamePrefix: "@_",
@@ -11972,7 +11947,7 @@ var buildOptions = function(options) {
   return Object.assign({}, defaultOptions3, options);
 };
 
-// ../../node_modules/.bun/fast-xml-parser@5.3.3/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js
+// ../../node_modules/.bun/fast-xml-parser@5.3.4/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js
 var METADATA_SYMBOL;
 if (typeof Symbol !== "function") {
   METADATA_SYMBOL = "@@xmlMetadata";
@@ -12008,7 +11983,7 @@ class XmlNode {
   }
 }
 
-// ../../node_modules/.bun/fast-xml-parser@5.3.3/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
+// ../../node_modules/.bun/fast-xml-parser@5.3.4/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
 class DocTypeReader {
   constructor(processEntities) {
     this.suppressValidationErr = !processEntities;
@@ -12385,7 +12360,7 @@ function parse_int(numStr, base) {
     throw new Error("parseInt, Number.parseInt, window.parseInt are not supported");
 }
 
-// ../../node_modules/.bun/fast-xml-parser@5.3.3/node_modules/fast-xml-parser/src/ignoreAttributes.js
+// ../../node_modules/.bun/fast-xml-parser@5.3.4/node_modules/fast-xml-parser/src/ignoreAttributes.js
 function getIgnoreAttributesFn(ignoreAttributes) {
   if (typeof ignoreAttributes === "function") {
     return ignoreAttributes;
@@ -12405,7 +12380,7 @@ function getIgnoreAttributesFn(ignoreAttributes) {
   return () => false;
 }
 
-// ../../node_modules/.bun/fast-xml-parser@5.3.3/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js
+// ../../node_modules/.bun/fast-xml-parser@5.3.4/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js
 class OrderedObjParser {
   constructor(options) {
     this.options = options;
@@ -12428,8 +12403,8 @@ class OrderedObjParser {
       copyright: { regex: /&(copy|#169);/g, val: "\xA9" },
       reg: { regex: /&(reg|#174);/g, val: "\xAE" },
       inr: { regex: /&(inr|#8377);/g, val: "\u20B9" },
-      num_dec: { regex: /&#([0-9]{1,7});/g, val: (_, str) => String.fromCodePoint(Number.parseInt(str, 10)) },
-      num_hex: { regex: /&#x([0-9a-fA-F]{1,6});/g, val: (_, str) => String.fromCodePoint(Number.parseInt(str, 16)) }
+      num_dec: { regex: /&#([0-9]{1,7});/g, val: (_, str) => fromCodePoint(str, 10, "&#") },
+      num_hex: { regex: /&#x([0-9a-fA-F]{1,6});/g, val: (_, str) => fromCodePoint(str, 16, "&#x") }
     };
     this.addExternalEntities = addExternalEntities;
     this.parseXml = parseXml;
@@ -12907,8 +12882,16 @@ function parseValue(val, shouldParse, options) {
     }
   }
 }
+function fromCodePoint(str, base, prefix) {
+  const codePoint = Number.parseInt(str, base);
+  if (codePoint >= 0 && codePoint <= 1114111) {
+    return String.fromCodePoint(codePoint);
+  } else {
+    return prefix + str + ";";
+  }
+}
 
-// ../../node_modules/.bun/fast-xml-parser@5.3.3/node_modules/fast-xml-parser/src/xmlparser/node2json.js
+// ../../node_modules/.bun/fast-xml-parser@5.3.4/node_modules/fast-xml-parser/src/xmlparser/node2json.js
 var METADATA_SYMBOL2 = XmlNode.getMetaDataSymbol();
 function prettify(node, options) {
   return compress(node, options);
@@ -13002,7 +12985,7 @@ function isLeafTag(obj, options) {
   return false;
 }
 
-// ../../node_modules/.bun/fast-xml-parser@5.3.3/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js
+// ../../node_modules/.bun/fast-xml-parser@5.3.4/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js
 class XMLParser {
   constructor(options) {
     this.externalEntities = {};
@@ -13109,6 +13092,9 @@ class CacheKeys {
   static roleInfo(roleCode) {
     return `role:info:${roleCode}`;
   }
+  static roleMenus(roleCode) {
+    return `role:menus:${roleCode}`;
+  }
   static roleApis(roleCode) {
     return `role:apis:${roleCode}`;
   }
@@ -13694,6 +13680,25 @@ class CacheHelper {
     }
     return trimmed;
   }
+  assertMenuPathname(value, errorPrefix) {
+    if (typeof value !== "string") {
+      throw new Error(`${errorPrefix} \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+      throw new Error(`${errorPrefix} \u4E0D\u5141\u8BB8\u4E3A\u7A7A\u5B57\u7B26\u4E32`);
+    }
+    if (!trimmed.startsWith("/")) {
+      throw new Error(`${errorPrefix} \u5FC5\u987B\u662F pathname\uFF08\u4EE5 / \u5F00\u5934\uFF09`);
+    }
+    if (trimmed.includes(" ")) {
+      throw new Error(`${errorPrefix} \u4E0D\u5141\u8BB8\u5305\u542B\u7A7A\u683C`);
+    }
+    if (trimmed.length > 1 && trimmed.endsWith("/")) {
+      throw new Error(`${errorPrefix} \u4E0D\u5141\u8BB8\u4EE5 / \u7ED3\u5C3E`);
+    }
+    return trimmed;
+  }
   assertApiPathList(value, roleCode) {
     if (value === null || value === undefined)
       return [];
@@ -13721,6 +13726,33 @@ class CacheHelper {
     }
     return out;
   }
+  assertMenuPathList(value, roleCode) {
+    if (value === null || value === undefined)
+      return [];
+    let list = value;
+    if (typeof list === "string") {
+      const trimmed = list.trim();
+      if (trimmed === "" || trimmed === "null") {
+        return [];
+      }
+      if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+        try {
+          list = JSON.parse(trimmed);
+        } catch {
+          throw new Error(`\u89D2\u8272\u83DC\u5355\u6743\u9650\u6570\u636E\u4E0D\u5408\u6CD5\uFF1Aaddon_admin_role.menus JSON \u89E3\u6790\u5931\u8D25\uFF0CroleCode=${roleCode}`);
+        }
+      }
+    }
+    if (!Array.isArray(list)) {
+      const typeLabel = typeof list;
+      throw new Error(`\u89D2\u8272\u83DC\u5355\u6743\u9650\u6570\u636E\u4E0D\u5408\u6CD5\uFF1Aaddon_admin_role.menus \u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u6570\u7EC4\u6216 JSON \u6570\u7EC4\u5B57\u7B26\u4E32\uFF0CroleCode=${roleCode}\uFF0Ctype=${typeLabel}`);
+    }
+    const out = [];
+    for (const item of list) {
+      out.push(this.assertMenuPathname(item, `\u89D2\u8272\u83DC\u5355\u6743\u9650\u6570\u636E\u4E0D\u5408\u6CD5\uFF1Aaddon_admin_role.menus \u5143\u7D20\uFF0CroleCode=${roleCode}`));
+    }
+    return out;
+  }
   async cacheApis() {
     try {
       const tableExists = await this.db.tableExists("addon_admin_api");
@@ -13807,6 +13839,56 @@ class CacheHelper {
       });
     }
   }
+  async rebuildRoleMenuPermissions() {
+    try {
+      const roleTableExists = await this.db.tableExists("addon_admin_role");
+      if (!roleTableExists.data) {
+        Logger.warn("\u26A0\uFE0F \u89D2\u8272\u8868\u4E0D\u5B58\u5728\uFF0C\u8DF3\u8FC7\u89D2\u8272\u83DC\u5355\u6743\u9650\u7F13\u5B58");
+        return;
+      }
+      const roles = await this.db.getAll({
+        table: "addon_admin_role",
+        fields: ["code", "menus"]
+      });
+      const roleMenuPathsMap = new Map;
+      for (const role of roles.data.lists) {
+        if (!role?.code)
+          continue;
+        const menuPaths = this.assertMenuPathList(role.menus, role.code);
+        roleMenuPathsMap.set(role.code, menuPaths);
+      }
+      const roleCodes = Array.from(roleMenuPathsMap.keys());
+      if (roleCodes.length === 0) {
+        Logger.info("\u2705 \u6CA1\u6709\u9700\u8981\u7F13\u5B58\u7684\u89D2\u8272\u83DC\u5355\u6743\u9650");
+        return;
+      }
+      const roleKeys = roleCodes.map((code) => CacheKeys.roleMenus(code));
+      await this.redis.delBatch(roleKeys);
+      const items = [];
+      for (const roleCode of roleCodes) {
+        const menuPaths = roleMenuPathsMap.get(roleCode) || [];
+        const members = Array.from(new Set(menuPaths)).sort();
+        if (members.length > 0) {
+          items.push({ key: CacheKeys.roleMenus(roleCode), members });
+        }
+      }
+      if (items.length > 0) {
+        await this.redis.saddBatch(items);
+      }
+    } catch (error) {
+      Logger.error({ err: error, msg: "\u26A0\uFE0F \u89D2\u8272\u83DC\u5355\u6743\u9650\u7F13\u5B58\u5F02\u5E38\uFF08\u5C06\u963B\u65AD\u542F\u52A8\uFF09" });
+      throw new CoreError({
+        kind: "runtime",
+        message: "\u26A0\uFE0F \u89D2\u8272\u83DC\u5355\u6743\u9650\u7F13\u5B58\u5F02\u5E38\uFF08\u5C06\u963B\u65AD\u542F\u52A8\uFF09",
+        logged: true,
+        cause: error,
+        meta: {
+          subsystem: "cache",
+          operation: "rebuildRoleMenuPermissions"
+        }
+      });
+    }
+  }
   async refreshRoleApiPermissions(roleCode, apiPaths) {
     if (!roleCode || typeof roleCode !== "string") {
       throw new Error("roleCode \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
@@ -13826,10 +13908,30 @@ class CacheHelper {
       await this.redis.sadd(roleKey, members);
     }
   }
+  async refreshRoleMenuPermissions(roleCode, menuPaths) {
+    if (!roleCode || typeof roleCode !== "string") {
+      throw new Error("roleCode \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+    }
+    if (!Array.isArray(menuPaths)) {
+      throw new Error("menuPaths \u5FC5\u987B\u662F\u6570\u7EC4");
+    }
+    const normalizedPaths = menuPaths.map((p) => this.assertMenuPathname(p, `refreshRoleMenuPermissions: menuPaths \u5143\u7D20\uFF0CroleCode=${roleCode}`));
+    const roleKey = CacheKeys.roleMenus(roleCode);
+    if (normalizedPaths.length === 0) {
+      await this.redis.del(roleKey);
+      return;
+    }
+    const members = Array.from(new Set(normalizedPaths));
+    await this.redis.del(roleKey);
+    if (members.length > 0) {
+      await this.redis.sadd(roleKey, members);
+    }
+  }
   async cacheAll() {
     await this.cacheApis();
     await this.cacheMenus();
     await this.rebuildRoleApiPermissions();
+    await this.rebuildRoleMenuPermissions();
   }
   async getApis() {
     try {
@@ -13858,6 +13960,15 @@ class CacheHelper {
       return [];
     }
   }
+  async getRoleMenuPermissions(roleCode) {
+    try {
+      const permissions = await this.redis.smembers(CacheKeys.roleMenus(roleCode));
+      return permissions || [];
+    } catch (error) {
+      Logger.error({ err: error, roleCode, msg: "\u83B7\u53D6\u89D2\u8272\u83DC\u5355\u6743\u9650\u7F13\u5B58\u5931\u8D25" });
+      return [];
+    }
+  }
   async checkRolePermission(roleCode, apiPath) {
     try {
       const pathname = this.assertApiPathname(apiPath, "checkRolePermission: apiPath");
@@ -13867,6 +13978,15 @@ class CacheHelper {
       return false;
     }
   }
+  async checkRoleMenuPermission(roleCode, menuPath) {
+    try {
+      const pathname = this.assertMenuPathname(menuPath, "checkRoleMenuPermission: menuPath");
+      return await this.redis.sismember(CacheKeys.roleMenus(roleCode), pathname);
+    } catch (error) {
+      Logger.error({ err: error, roleCode, msg: "\u68C0\u67E5\u89D2\u8272\u83DC\u5355\u6743\u9650\u5931\u8D25" });
+      return false;
+    }
+  }
   async deleteRolePermissions(roleCode) {
     try {
       const result = await this.redis.del(CacheKeys.roleApis(roleCode));
@@ -13880,6 +14000,19 @@ class CacheHelper {
       return false;
     }
   }
+  async deleteRoleMenuPermissions(roleCode) {
+    try {
+      const result = await this.redis.del(CacheKeys.roleMenus(roleCode));
+      if (result > 0) {
+        Logger.info(`\u2705 \u5DF2\u5220\u9664\u89D2\u8272 ${roleCode} \u7684\u83DC\u5355\u6743\u9650\u7F13\u5B58`);
+        return true;
+      }
+      return false;
+    } catch (error) {
+      Logger.error({ err: error, roleCode, msg: "\u5220\u9664\u89D2\u8272\u83DC\u5355\u6743\u9650\u7F13\u5B58\u5931\u8D25" });
+      return false;
+    }
+  }
 }
 
 // plugins/cache.ts
@@ -16293,6 +16426,52 @@ class RedisHelper {
       return null;
     }
   }
+  async tryAcquireLock(key, token, ttlMs) {
+    try {
+      if (!key || typeof key !== "string") {
+        throw new Error("tryAcquireLock: key \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+      }
+      if (!token || typeof token !== "string") {
+        throw new Error("tryAcquireLock: token \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+      }
+      if (!(typeof ttlMs === "number" && Number.isFinite(ttlMs) && ttlMs > 0)) {
+        throw new Error("tryAcquireLock: ttlMs \u5FC5\u987B\u662F\u6B63\u6570");
+      }
+      const pkey = `${this.prefix}${key}`;
+      const startTime = Date.now();
+      const ttlMsString = String(Math.floor(ttlMs));
+      const res = await this.client.set(pkey, token, "NX", "PX", ttlMsString);
+      const duration = Date.now() - startTime;
+      this.logSlow("SET NX PX", pkey, duration, { ttlMs });
+      return res === "OK";
+    } catch (error) {
+      Logger.error({ err: error, msg: "Redis tryAcquireLock \u9519\u8BEF" });
+      return false;
+    }
+  }
+  async releaseLock(key, token) {
+    try {
+      if (!key || typeof key !== "string") {
+        throw new Error("releaseLock: key \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+      }
+      if (!token || typeof token !== "string") {
+        throw new Error("releaseLock: token \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32");
+      }
+      const pkey = `${this.prefix}${key}`;
+      const startTime = Date.now();
+      const current = await this.client.get(pkey);
+      if (current !== token) {
+        return false;
+      }
+      const deleted = await this.client.del(pkey);
+      const duration = Date.now() - startTime;
+      this.logSlow("GET+DEL", pkey, duration);
+      return deleted > 0;
+    } catch (error) {
+      Logger.error({ err: error, msg: "Redis releaseLock \u9519\u8BEF" });
+      return false;
+    }
+  }
   async getString(key) {
     try {
       const pkey = `${this.prefix}${key}`;
@@ -16394,7 +16573,9 @@ class RedisHelper {
       const startTime = Date.now();
       const res = await this.client.sadd(pkey, ...members);
       const duration = Date.now() - startTime;
-      this.logSlow("SADD", pkey, duration, { membersCount: members.length });
+      this.logSlow("SADD", pkey, duration, {
+        membersCount: members.length
+      });
       return res;
     } catch (error) {
       Logger.error({ err: error, msg: "Redis sadd \u9519\u8BEF" });
@@ -16884,17 +17065,57 @@ class Befly {
       });
       this.plugins = await loadPlugins(plugins, this.context);
       this.assertStartContextReady();
-      await new SyncTable(this.context).run(tables);
-      await syncApi(this.context, apis);
-      await syncMenu(this.context, checkedMenus);
-      const devEmail = this.config.devEmail;
-      const devPassword = this.config.devPassword;
-      if (typeof devEmail === "string" && devEmail.length > 0 && typeof devPassword === "string" && devPassword.length > 0) {
-        await syncDev(this.context, { devEmail, devPassword });
+      const syncLockKey = "sync:lock";
+      const syncReadyKey = "sync:ready";
+      const syncLockTtlMs = 10 * 60 * 1000;
+      const syncWaitReadyMaxMs = 120 * 1000;
+      const syncWaitPollMs = 250;
+      const syncToken = `${process.pid}:${Bun.nanoseconds()}`;
+      const ctx = this.context;
+      const acquired = await ctx.redis.tryAcquireLock(syncLockKey, syncToken, syncLockTtlMs);
+      if (acquired) {
+        Logger.info({ key: syncLockKey, msg: "\u2705 \u5DF2\u83B7\u53D6\u542F\u52A8\u540C\u6B65\u9501\uFF0C\u5C06\u6267\u884C\u81EA\u52A8\u540C\u6B65" });
+        await ctx.redis.del(syncReadyKey);
+        try {
+          await new SyncTable(ctx).run(tables);
+          await syncApi(ctx, apis);
+          await syncMenu(ctx, checkedMenus);
+          const devEmail = this.config.devEmail;
+          const devPassword = this.config.devPassword;
+          if (typeof devEmail === "string" && devEmail.length > 0 && typeof devPassword === "string" && devPassword.length > 0) {
+            await syncDev(ctx, { devEmail, devPassword });
+          } else {
+            Logger.debug("\u8DF3\u8FC7 syncDev\uFF1A\u672A\u914D\u7F6E devEmail/devPassword");
+          }
+          await syncCache(ctx);
+          await ctx.redis.setString(syncReadyKey, String(Date.now()), 60 * 60);
+        } finally {
+          const released = await ctx.redis.releaseLock(syncLockKey, syncToken);
+          if (!released) {
+            Logger.warn({ key: syncLockKey, msg: "\u540C\u6B65\u9501\u672A\u80FD\u4E3B\u52A8\u91CA\u653E\uFF08\u5C06\u4F9D\u8D56 TTL \u81EA\u52A8\u91CA\u653E\uFF09" });
+          }
+        }
       } else {
-        Logger.debug("\u8DF3\u8FC7 syncDev\uFF1A\u672A\u914D\u7F6E devEmail/devPassword");
+        Logger.info({ key: syncLockKey, msg: "\u542F\u52A8\u540C\u6B65\u9501\u88AB\u5360\u7528\uFF1A\u7B49\u5F85\u540C\u6B65\u5B8C\u6210\u6807\u8BB0" });
+        const waitStart = Date.now();
+        while (true) {
+          const ready = await ctx.redis.getString(syncReadyKey);
+          if (typeof ready === "string" && ready.length > 0) {
+            Logger.info({ key: syncReadyKey, msg: "\u2705 \u68C0\u6D4B\u5230\u540C\u6B65\u5B8C\u6210\u6807\u8BB0\uFF0C\u5C06\u8DF3\u8FC7\u81EA\u52A8\u540C\u6B65" });
+            break;
+          }
+          const elapsed = Date.now() - waitStart;
+          if (elapsed >= syncWaitReadyMaxMs) {
+            throw new CoreError({
+              kind: "runtime",
+              message: `\u542F\u52A8\u7B49\u5F85\u540C\u6B65\u5B8C\u6210\u8D85\u65F6\uFF08${syncWaitReadyMaxMs}ms\uFF09\uFF1A\u8BF7\u68C0\u67E5\u662F\u5426\u6709\u5B9E\u4F8B\u5361\u5728\u540C\u6B65\u9636\u6BB5\u6216 Redis \u9501 TTL \u8FC7\u957F`,
+              logged: true,
+              meta: { subsystem: "start", operation: "waitSyncReady" }
+            });
+          }
+          await Bun.sleep(syncWaitPollMs);
+        }
       }
-      await syncCache(this.context);
       this.hooks = await loadHooks(hooks);
       this.apis = await loadApis(apis);
       const apiFetch = apiHandler(this.apis, this.hooks, this.context);
@@ -16930,10 +17151,7 @@ class Befly {
         }
       });
       const finalStartupTime = calcPerfTime(serverStartTime);
-      const processRole = getProcessRole(env);
-      const roleLabel = processRole.role === "primary" ? "\u4E3B\u8FDB\u7A0B" : `\u5DE5\u4F5C\u8FDB\u7A0B #${processRole.instanceId}`;
-      const envLabel = processRole.env === "standalone" ? "" : ` [${processRole.env}]`;
-      Logger.info(`${this.config.appName} \u542F\u52A8\u6210\u529F! (${roleLabel}${envLabel})`);
+      Logger.info(`${this.config.appName} \u542F\u52A8\u6210\u529F!`);
       Logger.info(`\u670D\u52A1\u5668\u542F\u52A8\u8017\u65F6: ${finalStartupTime}`);
       Logger.info(`\u670D\u52A1\u5668\u76D1\u542C\u5730\u5740: ${server.url}`);
       return server;