@lcap/nasl 3.7.0-beta.4 → 3.7.0-beta.5

package/src/concepts/utils/asserts.ts

@@ -145,12 +145,15 @@ import type { AuthInterface } from '../AuthInterface__';
 import type { CallAuthInterface } from '../CallAuthInterface__';
 import type { TriggerEvent } from '../TriggerEvent__';
 import type { MsgTriggerEvent } from '../MsgTriggerEvent__';
+import type { InterfaceTriggerEvent } from '../InterfaceTriggerEvent__';
 import type { ConnectorTrigger } from '../ConnectorTrigger__';
 import type { TriggerLauncher } from '../TriggerLauncher__';
+import type { ConnectorTriggerLauncher } from '../ConnectorTriggerLauncher__';
 import type { MsgTriggerLauncher } from '../MsgTriggerLauncher__';
 import type { Connector } from '../Connector__';
 import type { CallConnector } from '../CallConnector__';
 import type { Connection } from '../Connection__';
+import type { ConnectorLogic } from '../ConnectorLogic__';
 import type * as types from './types';
 import type { BaseNode } from '../../common';
 import type { FileNode } from '../../utils';
@@ -2290,33 +2293,33 @@ export function isStrictCallAuthInterface(node: unknown): node is CallAuthInterf
 }
 
 /**
- * 严格判断输入为 TriggerEvent 节点
+ * 严格判断输入为 MsgTriggerEvent 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictTriggerEvent(node)) {
- *   // 在这个花括号内，node 的类型为 TriggerEvent
+ * if (isStrictMsgTriggerEvent(node)) {
+ *   // 在这个花括号内，node 的类型为 MsgTriggerEvent
  * }
  * ```
  */
-export function isStrictTriggerEvent(node: unknown): node is TriggerEvent {
-  return isBaseNode(node) && node.concept === 'TriggerEvent';
+export function isStrictMsgTriggerEvent(node: unknown): node is MsgTriggerEvent {
+  return isBaseNode(node) && node.concept === 'MsgTriggerEvent';
 }
 
 /**
- * 严格判断输入为 MsgTriggerEvent 节点
+ * 严格判断输入为 InterfaceTriggerEvent 节点
  *
  * @description 仅判断节点本身，不包含继承类
  * @example
  * ```ts
- * if (isStrictMsgTriggerEvent(node)) {
- *   // 在这个花括号内，node 的类型为 MsgTriggerEvent
+ * if (isStrictInterfaceTriggerEvent(node)) {
+ *   // 在这个花括号内，node 的类型为 InterfaceTriggerEvent
  * }
  * ```
  */
-export function isStrictMsgTriggerEvent(node: unknown): node is MsgTriggerEvent {
-  return isBaseNode(node) && node.concept === 'MsgTriggerEvent';
+export function isStrictInterfaceTriggerEvent(node: unknown): node is InterfaceTriggerEvent {
+  return isBaseNode(node) && node.concept === 'InterfaceTriggerEvent';
 }
 
 /**
@@ -2349,6 +2352,21 @@ export function isStrictTriggerLauncher(node: unknown): node is TriggerLauncher
   return isBaseNode(node) && node.concept === 'TriggerLauncher';
 }
 
+/**
+ * 严格判断输入为 ConnectorTriggerLauncher 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictConnectorTriggerLauncher(node)) {
+ *   // 在这个花括号内，node 的类型为 ConnectorTriggerLauncher
+ * }
+ * ```
+ */
+export function isStrictConnectorTriggerLauncher(node: unknown): node is ConnectorTriggerLauncher {
+  return isBaseNode(node) && node.concept === 'ConnectorTriggerLauncher';
+}
+
 /**
  * 严格判断输入为 MsgTriggerLauncher 节点
  *
@@ -2409,6 +2427,21 @@ export function isStrictConnection(node: unknown): node is Connection {
   return isBaseNode(node) && node.concept === 'Connection';
 }
 
+/**
+ * 严格判断输入为 ConnectorLogic 节点
+ *
+ * @description 仅判断节点本身，不包含继承类
+ * @example
+ * ```ts
+ * if (isStrictConnectorLogic(node)) {
+ *   // 在这个花括号内，node 的类型为 ConnectorLogic
+ * }
+ * ```
+ */
+export function isStrictConnectorLogic(node: unknown): node is ConnectorLogic {
+  return isBaseNode(node) && node.concept === 'ConnectorLogic';
+}
+
 
 
 //=========== 以下为继承类型判断 ===========
@@ -3407,7 +3440,8 @@ export function isLogic(node: unknown): node is types.LogicNode {
       node.concept === 'Logic' ||
       node.concept === 'AuthLogic' ||
       node.concept === 'AuthLogicForCallInterface' ||
-      node.concept === 'BusinessLogic'
+      node.concept === 'BusinessLogic' ||
+      node.concept === 'ConnectorLogic'
     )
   );
 }
@@ -5558,7 +5592,8 @@ export function isTriggerEvent(node: unknown): node is types.TriggerEventNode {
     isBaseNode(node) &&
     (
       node.concept === 'TriggerEvent' ||
-      node.concept === 'MsgTriggerEvent'
+      node.concept === 'MsgTriggerEvent' ||
+      node.concept === 'InterfaceTriggerEvent'
     )
   );
 }
@@ -5584,6 +5619,27 @@ export function isMsgTriggerEvent(node: unknown): node is MsgTriggerEvent {
   );
 }
 
+/**
+ * 判断输入为 InterfaceTriggerEvent 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，InterfaceTriggerEvent 节点没有继承类，此判断等价于`isStrictInterfaceTriggerEvent`
+ * @example
+ * ```ts
+ * if (isInterfaceTriggerEvent(node)) {
+ *   // 在这个花括号内，node 的类型是 InterfaceTriggerEvent 或者 InterfaceTriggerEvent 继承类型
+ * }
+ * ```
+ */
+export function isInterfaceTriggerEvent(node: unknown): node is InterfaceTriggerEvent {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'InterfaceTriggerEvent'
+    )
+  );
+}
+
 /**
  * 判断输入为 ConnectorTrigger 节点实例
  *
@@ -5622,6 +5678,29 @@ export function isTriggerLauncher(node: unknown): node is types.TriggerLauncherN
     isBaseNode(node) &&
     (
       node.concept === 'TriggerLauncher' ||
+      node.concept === 'ConnectorTriggerLauncher' ||
+      node.concept === 'MsgTriggerLauncher'
+    )
+  );
+}
+
+/**
+ * 判断输入为 ConnectorTriggerLauncher 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算
+ * @example
+ * ```ts
+ * if (isConnectorTriggerLauncher(node)) {
+ *   // 在这个花括号内，node 的类型是 ConnectorTriggerLauncher 或者 ConnectorTriggerLauncher 继承类型
+ * }
+ * ```
+ */
+export function isConnectorTriggerLauncher(node: unknown): node is types.ConnectorTriggerLauncherNode {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'ConnectorTriggerLauncher' ||
       node.concept === 'MsgTriggerLauncher'
     )
   );
@@ -5711,6 +5790,27 @@ export function isConnection(node: unknown): node is Connection {
   );
 }
 
+/**
+ * 判断输入为 ConnectorLogic 节点实例
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 等价于`instanceof`运算，ConnectorLogic 节点没有继承类，此判断等价于`isStrictConnectorLogic`
+ * @example
+ * ```ts
+ * if (isConnectorLogic(node)) {
+ *   // 在这个花括号内，node 的类型是 ConnectorLogic 或者 ConnectorLogic 继承类型
+ * }
+ * ```
+ */
+export function isConnectorLogic(node: unknown): node is ConnectorLogic {
+  return (
+    isBaseNode(node) &&
+    (
+      node.concept === 'ConnectorLogic'
+    )
+  );
+}
+
 
 
 //=========== 以下为严格类型断言 ===========
@@ -8096,36 +8196,36 @@ export function assertStrictCallAuthInterface(node: unknown): asserts node is Ca
 }
 
 /**
- * 严格断言为 TriggerEvent 节点
+ * 严格断言为 MsgTriggerEvent 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictTriggerEvent(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 TriggerEvent 类型
+ * assertStrictMsgTriggerEvent(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MsgTriggerEvent 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictTriggerEvent(node: unknown): asserts node is TriggerEvent {
-  if (!isStrictTriggerEvent(node)) {
-    throw new Error(`TriggerEvent 节点严格断言失败`);
+export function assertStrictMsgTriggerEvent(node: unknown): asserts node is MsgTriggerEvent {
+  if (!isStrictMsgTriggerEvent(node)) {
+    throw new Error(`MsgTriggerEvent 节点严格断言失败`);
   }
 }
 
 /**
- * 严格断言为 MsgTriggerEvent 节点
+ * 严格断言为 InterfaceTriggerEvent 节点
  *
  * @description 仅断言节点本身，不包含继承类
  * @example
  * ```ts
- * assertStrictMsgTriggerEvent(node);
- * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 MsgTriggerEvent 类型
+ * assertStrictInterfaceTriggerEvent(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 InterfaceTriggerEvent 类型
  * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
  * ```
  */
-export function assertStrictMsgTriggerEvent(node: unknown): asserts node is MsgTriggerEvent {
-  if (!isStrictMsgTriggerEvent(node)) {
-    throw new Error(`MsgTriggerEvent 节点严格断言失败`);
+export function assertStrictInterfaceTriggerEvent(node: unknown): asserts node is InterfaceTriggerEvent {
+  if (!isStrictInterfaceTriggerEvent(node)) {
+    throw new Error(`InterfaceTriggerEvent 节点严格断言失败`);
   }
 }
 
@@ -8163,6 +8263,23 @@ export function assertStrictTriggerLauncher(node: unknown): asserts node is Trig
   }
 }
 
+/**
+ * 严格断言为 ConnectorTriggerLauncher 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictConnectorTriggerLauncher(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConnectorTriggerLauncher 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictConnectorTriggerLauncher(node: unknown): asserts node is ConnectorTriggerLauncher {
+  if (!isStrictConnectorTriggerLauncher(node)) {
+    throw new Error(`ConnectorTriggerLauncher 节点严格断言失败`);
+  }
+}
+
 /**
  * 严格断言为 MsgTriggerLauncher 节点
  *
@@ -8231,6 +8348,23 @@ export function assertStrictConnection(node: unknown): asserts node is Connectio
   }
 }
 
+/**
+ * 严格断言为 ConnectorLogic 节点
+ *
+ * @description 仅断言节点本身，不包含继承类
+ * @example
+ * ```ts
+ * assertStrictConnectorLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConnectorLogic 类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertStrictConnectorLogic(node: unknown): asserts node is ConnectorLogic {
+  if (!isStrictConnectorLogic(node)) {
+    throw new Error(`ConnectorLogic 节点严格断言失败`);
+  }
+}
+
 
 
 //=========== 以下为继承类型断言 ===========
@@ -10881,6 +11015,24 @@ export function assertMsgTriggerEvent(node: unknown): asserts node is MsgTrigger
   }
 }
 
+/**
+ * 断言为 InterfaceTriggerEvent 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictInterfaceTriggerEvent`方法
+ * @example
+ * ```ts
+ * assertInterfaceTriggerEvent(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 InterfaceTriggerEvent 或者 InterfaceTriggerEvent 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertInterfaceTriggerEvent(node: unknown): asserts node is InterfaceTriggerEvent {
+  if (!isInterfaceTriggerEvent(node)) {
+    throw new Error(`InterfaceTriggerEvent 节点断言失败`);
+  }
+}
+
 /**
  * 断言为 ConnectorTrigger 节点
  *
@@ -10917,6 +11069,24 @@ export function assertTriggerLauncher(node: unknown): asserts node is types.Trig
   }
 }
 
+/**
+ * 断言为 ConnectorTriggerLauncher 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictConnectorTriggerLauncher`方法
+ * @example
+ * ```ts
+ * assertConnectorTriggerLauncher(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConnectorTriggerLauncher 或者 ConnectorTriggerLauncher 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertConnectorTriggerLauncher(node: unknown): asserts node is types.ConnectorTriggerLauncherNode {
+  if (!isConnectorTriggerLauncher(node)) {
+    throw new Error(`ConnectorTriggerLauncher 节点断言失败`);
+  }
+}
+
 /**
  * 断言为 MsgTriggerLauncher 节点
  *
@@ -10989,3 +11159,21 @@ export function assertConnection(node: unknown): asserts node is Connection {
   }
 }
 
+/**
+ * 断言为 ConnectorLogic 节点
+ *
+ * @description 包含节点类以及节点继承类的判断
+ * @description 节点没有继承类时，等价于`assertStrictConnectorLogic`方法
+ * @example
+ * ```ts
+ * assertConnectorLogic(node);
+ * // 当前作用域内，断言语句之后，node 的类型都将会被断言为 ConnectorLogic 或者 ConnectorLogic 继承类型
+ * // 断言失败会抛出错误，所以此函数是用在必须要严格限定节点类型的地方
+ * ```
+ */
+export function assertConnectorLogic(node: unknown): asserts node is ConnectorLogic {
+  if (!isConnectorLogic(node)) {
+    throw new Error(`ConnectorLogic 节点断言失败`);
+  }
+}
+

package/src/concepts/utils/types.ts

@@ -145,12 +145,15 @@ import type { AuthInterface } from '../AuthInterface__';
 import type { CallAuthInterface } from '../CallAuthInterface__';
 import type { TriggerEvent } from '../TriggerEvent__';
 import type { MsgTriggerEvent } from '../MsgTriggerEvent__';
+import type { InterfaceTriggerEvent } from '../InterfaceTriggerEvent__';
 import type { ConnectorTrigger } from '../ConnectorTrigger__';
 import type { TriggerLauncher } from '../TriggerLauncher__';
+import type { ConnectorTriggerLauncher } from '../ConnectorTriggerLauncher__';
 import type { MsgTriggerLauncher } from '../MsgTriggerLauncher__';
 import type { Connector } from '../Connector__';
 import type { CallConnector } from '../CallConnector__';
 import type { Connection } from '../Connection__';
+import type { ConnectorLogic } from '../ConnectorLogic__';
 
 /** concept 与类类型映射表 */
 export interface ConceptTypeofClassMap {
@@ -301,12 +304,15 @@ export interface ConceptTypeofClassMap {
   CallAuthInterface: typeof CallAuthInterface;
   TriggerEvent: typeof TriggerEvent;
   MsgTriggerEvent: typeof MsgTriggerEvent;
+  InterfaceTriggerEvent: typeof InterfaceTriggerEvent;
   ConnectorTrigger: typeof ConnectorTrigger;
   TriggerLauncher: typeof TriggerLauncher;
+  ConnectorTriggerLauncher: typeof ConnectorTriggerLauncher;
   MsgTriggerLauncher: typeof MsgTriggerLauncher;
   Connector: typeof Connector;
   CallConnector: typeof CallConnector;
   Connection: typeof Connection;
+  ConnectorLogic: typeof ConnectorLogic;
 }
 
 /** concept 与类实例类型映射表 */
@@ -458,12 +464,15 @@ export interface ConceptClassMap {
   CallAuthInterface: CallAuthInterface;
   TriggerEvent: TriggerEvent;
   MsgTriggerEvent: MsgTriggerEvent;
+  InterfaceTriggerEvent: InterfaceTriggerEvent;
   ConnectorTrigger: ConnectorTrigger;
   TriggerLauncher: TriggerLauncher;
+  ConnectorTriggerLauncher: ConnectorTriggerLauncher;
   MsgTriggerLauncher: MsgTriggerLauncher;
   Connector: Connector;
   CallConnector: CallConnector;
   Connection: Connection;
+  ConnectorLogic: ConnectorLogic;
 }
 
 export type SyntaxNode =
@@ -607,14 +616,16 @@ export type SyntaxNode =
   | ViewBlockWithImage
   | AuthInterface
   | CallAuthInterface
-  | TriggerEvent
   | MsgTriggerEvent
+  | InterfaceTriggerEvent
   | ConnectorTrigger
   | TriggerLauncher
+  | ConnectorTriggerLauncher
   | MsgTriggerLauncher
   | Connector
   | CallConnector
-  | Connection;
+  | Connection
+  | ConnectorLogic;
 
 export type SyntaxNodeConcept = SyntaxNode['concept'];
 
@@ -640,7 +651,8 @@ export type LogicNode =
   | Logic
   | AuthLogic
   | AuthLogicForCallInterface
-  | BusinessLogic;
+  | BusinessLogic
+  | ConnectorLogic;
 
 export type LogicNodeConcept = LogicNode['concept'];
 
@@ -766,13 +778,20 @@ export type ViewBlockNode =
 export type ViewBlockNodeConcept = ViewBlockNode['concept'];
 
 export type TriggerEventNode =
-  | TriggerEvent
-  | MsgTriggerEvent;
+  | MsgTriggerEvent
+  | InterfaceTriggerEvent;
 
 export type TriggerEventNodeConcept = TriggerEventNode['concept'];
 
 export type TriggerLauncherNode =
   | TriggerLauncher
+  | ConnectorTriggerLauncher
+  | MsgTriggerLauncher;
+
+export type TriggerLauncherNodeConcept = TriggerLauncherNode['concept'];
+
+export type ConnectorTriggerLauncherNode =
+  | ConnectorTriggerLauncher
   | MsgTriggerLauncher;
 
-export type TriggerLauncherNodeConcept = TriggerLauncherNode['concept'];
+export type ConnectorTriggerLauncherNodeConcept = ConnectorTriggerLauncherNode['concept'];

package/src/generator/genBundleFiles.ts

@@ -101,6 +101,7 @@ export function genBundleFiles(app: App, frontend: Frontend, config: Config) {
 
   app.dependencies && modules.push(...app.dependencies);
   app.interfaceDependencies && modules.push(...app.interfaceDependencies);
+  app.connectorDependencies && modules.push(...app.connectorDependencies);
   frontend.views && views.push(...frontend.views);
   modules.forEach((module: Module) => {
     module.views && views.push(...module.views);
@@ -367,7 +368,6 @@ export function genBundleFiles(app: App, frontend: Frontend, config: Config) {
   const assetsInfo = app.genAllAssetsInfo(STATIC_URL, frontend.type);
   const customNames = JSON5.stringify(assetsInfo.custom.names);
 
-
   let content = `(function(){
         `;
   if (frontend.globalScaleEnabled) {
@@ -660,7 +660,12 @@ export function genBundleFiles(app: App, frontend: Frontend, config: Config) {
   if(config.isPreviewFe){
     const changeToRelativePath =(str:any)=>{
       const {pathname} = new URL(`http:${str}`)
-      return `${ pathname.split('/').filter(v=>v).slice(1).join('/')}`
+      let arr = pathname.split('/').filter(v=>v)
+      if( ['packages',config?.tenant].includes(arr[0]))  {
+        return `${arr.join('/')}`
+      }else {
+        return `${arr.slice(1).join('/')}`
+      }
     }
     jsAssetsList = jsAssetsList.map(changeToRelativePath)
     cssAssetsList = cssAssetsList.map(changeToRelativePath)
@@ -745,10 +750,15 @@ export function genBundleFiles(app: App, frontend: Frontend, config: Config) {
     }`
     }
 
-
     const loadMockAssets = `
     const loadJSWrap = (arr)=>{
-      LazyLoad.js(arr.map(url=>window.assetsDomain + url));
+      LazyLoad.js(arr.map(url=>{
+        if(url.includes('mockBundle')){
+          return window.userAssetsDomain + url
+        }else {
+          return window.assetsDomain + url
+        }
+      }));
     }
     const loadCSSWrap = (arr)=>{
       LazyLoad.css(arr.map(url=>window.assetsDomain + url));

package/src/generator/genMetaData.ts

@@ -93,6 +93,7 @@ export function genMetaData(app: App, frontend: Frontend, config: any) {
 
   app.dependencies && modules.push(...app.dependencies);
   app.interfaceDependencies && modules.push(...app.interfaceDependencies);
+  app.connectorDependencies && modules.push(...app.connectorDependencies);
 
   // 内置国际化枚举
   enums.push(...configurationEnums)

package/src/generator/permission.ts

@@ -194,6 +194,7 @@ export function getAllLogics(app: App) {
 
   app.dependencies && modules.push(...app.dependencies);
   app.interfaceDependencies && modules.push(...app.interfaceDependencies);
+  app.connectorDependencies && modules.push(...app.connectorDependencies);
 
   modules.forEach((module: Module) => {
     module.logics && logics.push(...module.logics);

package/src/generator/release-body/body.ts

@@ -16,8 +16,8 @@ async function getNaslAnnotatedJSON(app: App, opt: InternalReleaseData) {
 
   let NaslAnnotatedJSON: any;
   try {
-    NaslAnnotatedJSON = await (app as any).naslServer.getNaslAnnotatedJSON(app, true);
-    opt.logPublishFunc?.('语言', '获取类型标注成功');
+    NaslAnnotatedJSON = await app.naslServer.getNaslAnnotatedJSON(app, true);
+    await opt.logPublishFunc?.('语言', '获取类型标注成功');
 
     // // 打印传给服务端的 nasl,为了服务端排查问题方便
     // if (globalThis.window) {
@@ -47,7 +47,8 @@ async function getFrontendBundleFiles(app: App, opt: InternalReleaseData) {
   let files: utils.GetPromise<ReturnType<typeof genFrontendBundleFiles>> = [];
 
   if (opt.frontends && opt.frontends.length) {
-    opt.logPublishFunc?.('代码', '生成页面代码：开始');
+    await opt.logPublishFunc?.('代码', '生成页面代码：开始');
+    app.naslServer.logger.time('生成前端页面');
     files = await genFrontendBundleFiles(app, opt.frontends, {
       ...opt.appInfo,
       env: opt.env,
@@ -65,9 +66,11 @@ async function getFrontendBundleFiles(app: App, opt: InternalReleaseData) {
       files = replaceAssetUrl(files, opt.appInfo.USER_STATIC_URL, opt.staticUrl);
     }
 
-    opt.logPublishFunc?.('代码', '生成页面代码：完成');
+    app.naslServer.logger.timeEnd('生成前端页面');
+    await opt.logPublishFunc?.('代码', '生成页面代码：完成');
   }
 
+
   return files;
 }
 
@@ -75,7 +78,7 @@ async function mergeBodyData(app: App, opt: InternalReleaseData) {
   await utils.delay(500);
 
   const authReport: ReturnType<typeof getAuthReport> = getAuthReport(app, opt.frontends);
-  opt.logPublishFunc?.('权限',  '分析权限数据成功！');
+  await opt.logPublishFunc?.('权限',  '分析权限数据成功！');
   const logicPageResourceDtoList = await genPermissionData(app);
   const allFrontends = getFrontendByTypes(app?.frontendTypes);
   const releaseFrontends = allFrontends.map((frontend: Frontend) => ({
@@ -92,6 +95,7 @@ async function mergeBodyData(app: App, opt: InternalReleaseData) {
     reportIdList: findAllReportIdList(app, opt.frontends),
     appId: app.id,
     env: opt.env,
+    branchId: opt.branchId,
     replicas: opt.replicas,
     appSpecification: opt.appSpecification,
     callbackLogicsName: app.getExtensionsCallbackLogics(),

package/src/generator/release-body/data.ts

@@ -17,10 +17,11 @@ import { Logger, File } from '../../utils';
 export async function getReleaseData(app: App, data: ReleaseData, naslServer: NaslServer, inputLogger?: Logger) {
   const { http, logger: defaultLogger } = naslServer;
   const logger = inputLogger ?? defaultLogger;
+  defaultLogger.time('前端生成器发布');
   const appInfo =  await getAppInfo(http, data);
-  logger.info('构建环境', '获取环境信息成功');
+  await logger.info('构建环境', '获取环境信息成功');
   const { version, fullVersion, dependencies } = await getVersionDetail(http, app);
-  logger.info('构建环境', '获取版本数据成功');
+  await logger.info('构建环境', '获取版本数据成功');
   const allFrontend = getFrontendByTypes(app.frontendTypes);
   const inputFrontendNames = (data.config.frontendNames ?? []).filter(Boolean);
   const releaseFrontends = inputFrontendNames.length > 0
@@ -29,6 +30,7 @@ export async function getReleaseData(app: App, data: ReleaseData, naslServer: Na
   const result: InternalReleaseData = {
     appInfo: appInfo as any,
     env: data.env,
+    branchId: data.branchId,
     debug: data.config.debug ?? false,
     replicas: data.replicas ?? 1,
     realRelease: data.config.mode === ReleaseMode.Release,
@@ -45,13 +47,13 @@ export async function getReleaseData(app: App, data: ReleaseData, naslServer: Na
   // 设置依赖数据
   if (app.packageInfos.length === 0) {
     app.packageInfos = await getPackageInfos(http, app, dependencies, appInfo.STATIC_URL, fullVersion);
-    logger.info('构建环境', '设置依赖库内容');
+    await logger.info('构建环境', '设置依赖库内容');
   }
 
   // 私有化环境，需要同步资源；内部环境暂不需要，针对使用 CDN 场景增加判断
   if (String(appInfo.isPrivatized) === 'true') {
     result.staticUrl = await staticResourceSync(http, data.appId, data.env, releaseFrontends);
-    logger.info('构建环境', '私有化部署同步资源成功');
+    await logger.info('构建环境', '私有化部署同步资源成功');
   }
 
   // 服务端验证规则
@@ -62,18 +64,19 @@ export async function getReleaseData(app: App, data: ReleaseData, naslServer: Na
       throw new Error(result.validations);
     }
     else {
-      logger.info('生成器', '服务端验证数据获取成功');
+      await logger.info('生成器', '服务端验证数据获取成功');
     }
   }
 
-  logger.info('构建环境', '构建环境完成，开始拼装发布数据');
+  await logger.info('构建环境', '构建环境完成，开始拼装发布数据');
 
   const releaseBody = await genReleaseBody(app, {
     ...result,
     logPublishFunc: (...message: string[]) => logger.info(...message),
   });
 
-  logger.info('前端生成器', '应用发布数据准备完成');
+  await logger.info('前端生成器', '应用发布数据准备完成');
+  defaultLogger.timeEnd('前端生成器发布');
 
   return releaseBody;
 }

package/src/generator/release-body/internal.ts

@@ -12,6 +12,7 @@ export type InputServerValidationData = { [key in string]: ServerValidationData[
 export interface InternalReleaseData {
   env: string;
   debug: boolean;
+  branchId: string;
   replicas: number;
   realRelease: boolean;
   ignoreFiles?: boolean;

package/src/generator/release-body/types.ts

@@ -12,6 +12,8 @@ export interface ReleaseData {
   appId: string;
   /** 发布环境 dev | online */
   env: string;
+  /** 分支 Id */
+  branchId: string;
   /** 副本数 */
   replicas: number;
   /** 应用特性版本 */