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

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;
   /** 应用特性版本 */

package/src/manager/diagnostic.ts

@@ -38,20 +38,44 @@ export interface Diagnostic {
  */
 export interface DiagnosticRecord {
   id: string;
+
   logicId?: string;
-  // typeCheckNote: TypeCheckNote,
+
   filePath?: string;
   node: BaseNode;
   message: string;
   syntaxDiagnostics: Array<Diagnostic>;
   semanticDiagnostics: Array<Diagnostic>;
   suggestionDiagnostics: Array<Diagnostic>;
-  // processComponentId?: string,
-  // attributes?: TypeCheckAttribute[],
 }
 
 export class DiagnosticManager {
-  records: Array<DiagnosticRecord> = [];
+  private initVersionByFilePath(filePath: string) {
+    if (this.versions[filePath] === undefined) {
+      this.versions[filePath] = 0;
+    }
+    return this.versions[filePath];
+  }
+
+  incrementVersionByFilePath(filePath: string): number {
+    this.initVersionByFilePath(filePath);
+    return ++this.versions[filePath];
+  }
+
+  getVersionByFilePath(filePath: string) {
+    // 单纯 get 不需要写入
+    return this.versions[filePath] ?? 0;
+  }
+
+  deleteVersionByFilePath(filePath: string) {
+    if (!filePath) {
+      return true;
+    }
+    delete this.versions[filePath];
+  }
+
+  private versions: Record<string, number> = Object.create(null);
+  private records: Array<DiagnosticRecord> = [];
 
   push(record: DiagnosticRecord) {
     const index = this.records.findIndex((item) => item.id === record.id);
@@ -60,15 +84,7 @@ export class DiagnosticManager {
     } else {
       this.records.splice(index, 1, record);
     }
-
-    // if(record.typeCheckNote?.message?.filter)
-    //     record.typeCheckNote.message = record.typeCheckNote.message.filter((item) => !!item);
-
-    // if(!record.typeCheckNote || record.typeCheckNote.status === 'success'
-    //     || (record.typeCheckNote && record.typeCheckNote.message && record.typeCheckNote.message.length === 0))
-    //     return;
   }
-
   getRecord(id: string) {
     const index = this.records.findIndex((item) => item.id === id);
     return this.records[index];
@@ -76,27 +92,18 @@ export class DiagnosticManager {
 
   deleteOwn(id: string) {
     const index = this.records.findIndex((item) => item.id === id);
+    if (index !== -1) {
+      const path = this.records[index].filePath;
+      if (path) {
+        this.deleteVersionByFilePath(path);
+      }
+    }
     ~index && this.records.splice(index, 1);
   }
 
-  delete(id: string) {
-    // const node = vertexsMap.get(id);
-    // this.deleteOwn(id);
-    // if (node) {
-    //     const children: LogicItem[] = [];
-    //     // [...logicItemKeyOfLogicItem, ...logicItemArrayKeyOfLogicItem].forEach((key) => {
-    //     //     const item = (node as LogicItem)[key as keyof LogicItem];
-    //     //     if (item)
-    //     //         children = children.concat(item);
-    //     // });
-    //     children.forEach((item) => {
-    //         this.delete(item.id);
-    //     });
-    // }
-  }
-
   clear() {
     this.records.splice(0, this.records.length);
+    this.versions = Object.create(null);
   }
 
   pushAll(records: DiagnosticRecord[]) {
@@ -108,9 +115,6 @@ export class DiagnosticManager {
     return [].concat(
       ...this.records.map((record) => {
         const diagnostics: Diagnostic[] = [].concat(record.semanticDiagnostics, record.suggestionDiagnostics);
-        // if (!showTSError) {
-        //     diagnostics = diagnostics.filter((diagnostic) => chineseRE.test(diagnostic.message));
-        // }
         return diagnostics;
       })
     );

package/src/natural/prompt/analyzeClaims.ts

@@ -2,6 +2,7 @@ export const analyzeClaims = (params: any) => {
   const { logicType } = params;
   const claims = `
   - Knowledge 是你的知识库，你可以参考，但是你最终制定的计划中禁止包含方法或者函数名
+  - moduleIndexList 用于下一步的具体实施，需要尽可能详细的返回所有和执行计划相关的模块或方法索引
   - 如果用户没有特别指明是打印(日志/输出结果)，"输出结果"一律按照"返回输出结果"处理
   - 涉及到查询、获取数据时，先查找当前上下文[6/7/8/9]中是否有相关的方法，如果没有，再考虑实体的方法
     - 实体的 get 方法一次只能获取一条数据，返回一个对象，无法返回列表。
@@ -13,6 +14,7 @@ export const analyzeClaims = (params: any) => {
   const claimsMap = {
     global_logic: `
 - Knowledge 是你的知识库，你可以参考，但是你最终制定的计划中禁止包含方法或者函数名
+- moduleIndexList 用于下一步的具体实施，需要尽可能详细的返回所有和执行计划相关的模块或方法索引
 - 如果用户没有特别指明是打印(日志/输出结果)，"输出结果"一律按照"返回输出结果"处理
 - 如果用户的需求涉及定时或延时等操作，请提示用户：当前暂不支持定时或延时操作，请调整后重新输入。
 - 如果用户的需求需要调用某个方法并且当前上下文中不存在时，请提示用户：当前应用中暂无该方法，请先导入相关依赖库或连接器模块

package/src/natural/prompt/analyzeFormatOutput.ts

@@ -7,6 +7,7 @@ export const analyzeFormatOutput = () => {
       "text": "question",
       "executable": boolean,
       "moduleIndexList": [index],
+      "needQueryRepository": boolean
   }
 }
 \`\`\``;

package/src/natural/prompt/analyzeTasks.ts

@@ -9,6 +9,8 @@ export const analyzeTasks = () => {
   - 类型为 boolean, 如果你认为需求比较明确并且 plan 可执行, 返回 true, 否则返回 false
 - moduleIndexList
   - 类型为 Array, 你需要根据用户的执行计划，从 Context Definition 中整理出执行需要用到的模块或者方法，返回对应的索引
-  - 用于下一步的具体实施，需要尽可能详细、精准的返回和执行计划相关的模块或方法索引。例如："moduleIndexList": ['1','6-3','8-1-1-0']。
+  - 用于下一步的具体实施，需要尽可能详细的返回所有和执行计划相关的模块或方法索引。例如："moduleIndexList": ['1','6-3','8-1-1-0']。
+- needQueryRepository
+  - 类型为 boolean, 如果你认为需求相关的上下文信息不足，需要另外查询知识库时, 返回 true, 否则返回 false
 `;
 };

package/src/natural/prompt/executeClaims.ts

@@ -22,6 +22,7 @@ export const executeClaims = (params: any) => {
     -   禁止使用 Object 的所有方法，如果想使用对象或者想要获取属性的值时，请使用 Map 系列函数
     -   禁止使用三元表达式，你可以使用 if 语句或者 while 语句
     -   禁止使用 for/forEach 语句，如果需要循环或者遍历，你**必须**使用 ForEach 方法
+    -   禁止使用 import 关键字
     -   禁止频繁操作实体
     -   只获取单条数据时使用 namespace.Entity.get()
         -   namespace.Entity.get 是一个整体，禁止将 namespace 赋值给变量
@@ -29,6 +30,7 @@ export const executeClaims = (params: any) => {
     -   需要使用 nasl.ui 中类的方法时，请使用 $refs 的前缀，例如 $refs.tableView1.reload()
       -   禁止将 $ref 实例赋值给变量
       -   禁止使用 new 创建实例
+    -   提供的方法为一个整体，请完整调用，禁止将方法赋值给变量
     -   直接输出代码结果，其他描述请以注释的形式出现
 -   返回值
     -   如果用户没有特别指明是打印(日志/输出结果)，"输出结果"一律按照"返回输出结果"处理
@@ -57,6 +59,7 @@ export const executeClaims = (params: any) => {
     -   禁止使用 Object 的所有方法，如果想使用对象或者想要获取属性的值时，请使用 Map 系列函数
     -   禁止使用三元表达式，你可以使用 if 语句或者 while 语句
     -   禁止使用 for/forEach 语句，如果需要循环或者遍历，你**必须**使用 ForEach 方法
+    -   禁止使用 import 关键字
     -   禁止频繁操作实体
     -   分析用户的需求，优先使用数据库的查询和数据操纵能力，例如 JOIN、SUM、GROUP_BY 等能力，使用 SQL 语句同时实现查询和计算
     -   如果要查询，则使用 nasl.oql.query，同时分析整个需求，尽量用一句 SQL 实现
@@ -64,6 +67,7 @@ export const executeClaims = (params: any) => {
             -   namespace.Entity.get 是一个整体，禁止将 namespace 赋值给变量
         -   禁止对 nasl.oql.query 的结果进行连续调用
     -   字符串或者变量之间的拼接或者 concat 请使用字符串插值(模板字符串)语法
+    -   提供的方法为一个整体，请完整调用，禁止将方法赋值给变量
     -   直接输出代码结果，其他描述请以注释的形式出现
 -   返回值
     -   如果用户没有特别指明是打印(日志/输出结果)，"输出结果"一律按照"返回输出结果"处理

package/src/natural/transformTSCode.ts

@@ -593,7 +593,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
         return new naslTypes.CallInterface({
           calleeNamespace: generate((node.callee as any).object).code,
           calleeName: (callee[callee.length - 1] as babelTypes.Identifier).name,
-          arguments: node?.arguments?.map((arg: any) => arg?.properties.map((item: any) => new naslTypes.Argument({
+          arguments: node?.arguments?.map((arg: any) => arg?.properties?.map((item: any) => new naslTypes.Argument({
             keyword: item?.key?.name,
             expression: transformLogicNode(item?.value),
           }))).flat() as naslTypes.Argument[],
@@ -687,11 +687,36 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
         pushElseIf(node, switchStatement);
         return switchStatement;
       }
-      return new naslTypes.IfStatement({
+      let consequentIndex: number;
+      let alternateIndex: number;
+      const naslNode = new naslTypes.IfStatement({
         test: transformLogicNode(node.test),
-        consequent: !node.consequent ? [] : (node.consequent as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
-        alternate: !node.alternate ? [] : (node.alternate as babelTypes.BlockStatement).body.map((item) => transformLogicNode(item)).filter((item) => !!item),
-      });
+        consequent: !node.consequent ? [] : (node.consequent as babelTypes.BlockStatement).body.map((item: any, index: number) => {
+          if (item?.type === 'ReturnStatement') {
+            item.ends = true;
+            if (item?.argument) {
+              consequentIndex = index;
+            }
+          }
+          return transformLogicNode(item);
+        }).filter((item) => !!item),
+        alternate: !node.alternate ? [] : (node.alternate as babelTypes.BlockStatement).body.map((item: any, index: number) => {
+          if (item?.type === 'ReturnStatement') {
+            item.ends = true;
+            if (item?.argument) {
+              alternateIndex = index;
+            }
+          }
+          return transformLogicNode(item);
+        }).filter((item) => !!item),
+      }) as any;
+      if (consequentIndex !== undefined) {
+        naslNode?.consequent?.splice(consequentIndex + 1, 0, new naslTypes.End());
+      }
+      if (alternateIndex !== undefined) {
+        naslNode?.alternate?.splice(alternateIndex + 1, 0, new naslTypes.End());
+      }
+      return naslNode;
     } else if (node.type === 'WhileStatement') {
       return new naslTypes.WhileStatement({
         test: transformLogicNode(node.test),
@@ -883,6 +908,9 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
           right: transformLogicNode(node.argument),
         });
       }
+      if ((node as any)?.ends) {
+        return new naslTypes.End();
+      }
     } else if (node.type === 'EmptyStatement') {
       return node.leadingComments && new naslTypes.Comment({
         value: String(node.leadingComments[0].value),

package/src/server/extendBaseNode.ts

@@ -30,7 +30,7 @@ import { EventPayload, invokeCommand, registerCommand } from '../common';
 import { getNodeByNodeCallee, getNaslNodeByNodeCallee } from '../automate/engine/utils';
 
 import { extendSentryMonitorNaslNode } from '../sentry';
-import { ca } from 'date-fns/locale';
+import { isAuthLogicForCallInterface, isParam } from '../concepts/utils/asserts';
 
 interface SetNameNode extends BaseNode {
   setName(name: string): any;
@@ -114,6 +114,23 @@ BaseNode.prototype.nodeFindRefNodes = function nodeFindRefNodes() {
   }
 };
 
+/**
+ * AuthLogicForCallInterface 通过当前节点，查找被引用的节点
+ * 以下面代码为例由于相关文件TS代码翻译的特殊性，
+ * 导致在查找引用的时候是以类型参数为准，而不是实际参数
+ * 此种行为会导致函数体内的参数无法查找到引用
+ * ({par, pa, api}:{    par:     nasl.core.String,     pa:     nasl.core.String, api?: ApiReturn})
+ * 为此需要重新查找一次引用
+ */
+async function extensionRefForAuthLogicForCallInterfaceParams(refsList: any[], node: BaseNode, naslServer: NaslServer) {
+  const target = refsList[0];
+  const newRefs = await naslServer.references({
+    file: refsList[0].file,
+    line: target.start.line,
+    offset: target.start.offset,
+  })
+  return [...newRefs.refs];
+}
 BaseNode.prototype.changeName = async function changeName(newValue: string, updateAll: boolean = false) {
   try {
     /**
@@ -121,7 +138,13 @@ BaseNode.prototype.changeName = async function changeName(newValue: string, upda
      */
     const app = this.getAncestor('App');
     const naslServer = (app as any).naslServer as NaslServer;
-    const refsList = await naslServer._isHaveRef(this);
+    let refsList = await naslServer._isHaveRef(this);
+    // 鉴权方式 参数修改需要协同变更相关参数
+    // 但由于鉴权返回实现TS的特殊性，在查询节点的时候，只会查询类型参数的引用，导致引用查找缺失
+    // 因此需要手动更新一下
+    if (isParam(this) && isAuthLogicForCallInterface(this.parentNode)) {
+      refsList = await extensionRefForAuthLogicForCallInterfaceParams(refsList, this, naslServer);
+    }
     // 是不是有引用有的话，就返回
     /**
      * @param this 当前重命名的节点
@@ -185,8 +208,16 @@ BaseNode.prototype.changeName = async function changeName(newValue: string, upda
             } else {
               if (_this.concept === 'AuthLogicForCallInterface' && itemNode.concept === 'CallAuthInterface') {
                 const { calleewholeKey } = itemNode;
-                const targetItf: AuthInterface = getNodeByNodeCallee(App, calleewholeKey);
-                targetItf.setAuthLogic(newValue);
+                let targetItf: AuthInterface;
+                const connector = itemNode.getAncestor('Connector') as Connector;
+                if (connector) {
+                  targetItf = connector.interfaces?.find((itf: Interface | AuthInterface) => {
+                    return calleewholeKey.endsWith(itf.name);
+                  }) as AuthInterface;
+                } else {
+                  targetItf = getNodeByNodeCallee(App, calleewholeKey)
+                }
+                targetItf?.setAuthLogic?.(newValue);
                 // 需要触发更新，否则对应的ts文件不会更新会导致鉴权方式找不到报错
                 itemNode.update({});
               } else {

package/src/server/formatTsUtils.ts

@@ -231,7 +231,7 @@ function createType2Annotation(type: string, parentPrefix?: string): TypeAnnotat
   }
   return typeAnnotation;
 }
-export function getPlatformType(type: string): string {
+export function getPlatformType(type: string, node?: types.SyntaxNode): string {
   let tsType = '';
 
   if (type?.includes(': ')) {
@@ -241,7 +241,7 @@ export function getPlatformType(type: string): string {
     tsType = type;
   }
   tsType = tsType.replaceAll(' ', '');
-  const namespacePrefix = ['app', 'extensions', 'apis', 'components', 'nasl'];
+  const namespacePrefix = ['app', 'extensions', 'apis', 'components', 'nasl', 'connector'];
   if (tsType === 'String') {
     return 'nasl.core.String';
   } else if (tsType === 'Boolean') {
@@ -253,6 +253,9 @@ export function getPlatformType(type: string): string {
     const first = strTypes[0];
     // 如果不是这几个前缀就加一个namespace
     if (!namespacePrefix.includes(first)) {
+      if (node && (node as any)?.connector) {
+        return `${(node as any)?.connector?.getNamespacePrefix || ''}${tsType}`;
+      };
       return 'app.' + tsType;
     }
   }
@@ -623,7 +626,7 @@ export function formatVariableData(data: unknown | variableItem[], node: types.S
               }
             }
           }
-          typeKey = getPlatformType(currentType);
+          typeKey = getPlatformType(currentType, node);
           item.typeAnnotation = displayString2TypeAnnotation(typeKey);
         }
       } else if (item instanceof StructureProperty || item instanceof EntityProperty) {