@lcap/nasl 2.18.0-beta.7 → 2.20.0-beta.1

package/src/server/naslServer.ts

@@ -61,6 +61,7 @@ import {
     BooleanLiteral,
     BatchAssignment,
     ForEachStatement,
+    Frontend,
 } from '../concepts';
 import { lsp2tspNumber, SourceMap, SourceMapItem } from '../translator';
 import axios from '../service/storage';
@@ -81,10 +82,6 @@ const EmbeddedTSFileLineMap: { [name: string]: number } = {
 const EmbeddedTSFileOffsetMap: { [name: string]: number } = {
     Variable: 12,
 };
-// 要Check的文件
-const filesToCheck: Set<string> = new Set();
-// 单个文件正在change，不允许同时两个文件一起change
-let singleFileChangeIng = false;
 
 export interface FileNode extends BaseNode {
     getEmbeddedFilePath(name?: string): string;
@@ -168,6 +165,10 @@ export class NaslServer {
     // 需要执行修改的文件
     changeStackList: Array<EventPayload> = [];
 
+    filesToCheck: Set<string>;
+
+    singleFileChangeIng: Boolean;
+
     constructor() {
         /// #if process.env.BUILD_TARGET === 'node'
         if (globalThis.process) // For TS build
@@ -179,6 +180,11 @@ export class NaslServer {
             this.worker = new Worker('/ts-worker.js');
         /// #endif
 
+        // 要Check的文件
+        this.filesToCheck = new Set();
+        // 单个文件正在change，不允许同时两个文件一起change
+        this.singleFileChangeIng = false;
+
         this.diagnosticManager = new DiagnosticManager();
 
         this.messager = new Messager({
@@ -202,7 +208,34 @@ export class NaslServer {
             // 收集到一个行为集合
             const eventValue = $event.value;
             eventValue.forEach(async (item: EventPayload) => {
-                this.changeStackList.push(item.originEvent);
+                /**
+                 * 多个行为进行合并
+                 * 合并规则是
+                 * 1.[a,b,c,c] 在cc的时候，在已有一个c，又来一个c的时候，如果他们不都是file级别的节点
+                 *   就可以前面的内容去掉，只保留最后一个
+                 * 2.[a,b,c,b,c] 在bc已存在，又来了bc 这就都要保留，因为可能顺序有相关性，不能去掉
+                 * 理论上只处理同时几个操作 合并，
+                 * 3.有field的也直接保留
+                 */
+                try {
+                    const changeEvent = item.originEvent;
+                    const changeNode = changeEvent.target;
+                    const { fileNode } = this.getCurrentSource(changeNode);
+                    if (changeNode !== fileNode || !changeEvent.field) {
+                        const findIndex = this.changeStackList.findIndex((changeStackItem: EventPayload) => {
+                            const target = changeStackItem.target;
+                            const { fileNode: targetFileNode } = this.getCurrentSource(target);
+                            return targetFileNode === fileNode;
+                        });
+                        if (findIndex === this.changeStackList.length - 1) {
+                            this.changeStackList.pop();
+                        }
+                    }
+                    this.changeStackList.push(item.originEvent);
+                } catch (err) {
+                    console.log(err);
+                    this.changeStackList.push(item.originEvent);
+                }
             });
 
             // 如果有长度开始执行状态机
@@ -249,16 +282,32 @@ export class NaslServer {
             } catch (err) {
             }
         });
-        module.frontendVariables?.forEach((frontendVariable) => {
+        (module as App).frontends?.forEach((frontend) => {
             try {
-                const result = frontendVariable.toEmbeddedTSFile();
+                const result = frontend.toEmbeddedTSFile();
                 results.push(result);
                 // sourceMap都存在目录级别内容下，在页面层级下去找
-                frontendVariable.sourceMap = result.sourceMap;
-                this.file2NodeMap.set(result.filePath, frontendVariable);
+                frontend.sourceMap = result.sourceMap;
+                this.file2NodeMap.set(result.filePath, frontend);
             } catch (err) {
                 console.log(err);
             }
+            frontend.variables?.forEach((frontendVariable) => {
+                try {
+                    const result = frontendVariable.toEmbeddedTSFile();
+                    results.push(result);
+                    // sourceMap都存在目录级别内容下，在页面层级下去找
+                    frontendVariable.sourceMap = result.sourceMap;
+                    this.file2NodeMap.set(result.filePath, frontendVariable);
+                } catch (err) {
+                    console.log(err);
+                }
+            });
+            // view的生成
+            if (!config.closeViews) {
+                this.view2TSFile(frontend.views, results);
+            }
+            frontend.componentDependencies?.forEach((item) => this.contentToFile(item, results));
         });
 
         (module as App).dataSources?.forEach((dataSource) => {
@@ -315,11 +364,6 @@ export class NaslServer {
             }
         });
 
-        // view的生成
-        if (!config.closeViews) {
-            this.view2TSFile(module.views, results);
-        }
-
         module.processes.forEach((process) => {
             try {
                 const result = process.toEmbeddedTSFile();
@@ -370,7 +414,6 @@ export class NaslServer {
             // 其他模块的创建内容
             app.dependencies.forEach((item) => this.contentToFile(item, results));
             app.interfaceDependencies.forEach((item) => this.contentToFile(item, results));
-            app.componentDependencies.forEach((item) => this.contentToFile(item, results));
         } catch (err) {
             console.log(err);
         }
@@ -615,7 +658,8 @@ export class NaslServer {
         return '';
     }
     async getDataSchemaStructureOrTypeAnnotation(node: ViewElement) {
-        if (!(node instanceof ViewElement)) return;
+        if (!(node instanceof ViewElement))
+            return;
 
         const { currentSource, fileNode } = this.getCurrentSource(node);
         const quickInfo = await this._getTypeQuickinfo({
@@ -626,16 +670,18 @@ export class NaslServer {
         if (quickInfo.responseRequired) {
             const displayString = quickInfo?.response?.displayString || '';
             const flag = displayString.includes('<') && displayString.includes('>');
-            if(!flag) return;
+            if (!flag)
+                return;
 
             const types = /\<([^()]+)\>/g.exec(displayString);
-            let typeStr = types && types[1];
+            const typeStr = types && types[1];
             const app = node.app;
             if (typeStr.includes('__name: "AStructure_')) {
                 const properties: StructureProperty[] = [];
                 typeStr
                     .replace(/([^:\s]+):\s+([^;]+);/g, ($1, name, typeKey) => {
-                        if(name === '__name') return;
+                        if (name === '__name')
+                            return;
 
                         typeKey = `app.${typeKey}`;
                         const keys = typeKey.split('.');
@@ -647,12 +693,12 @@ export class NaslServer {
                                 typeKind: 'reference',
                                 typeName,
                                 typeNamespace,
-                            })
-                        }))
+                            }),
+                        }));
                         return '';
                     });
                 return TypeAnnotation.createTypeAnonymousStructure(properties);
-            } else if(typeStr.startsWith('structures'))
+            } else if (typeStr.startsWith('structures'))
                 return app.findNodeByCompleteName(`app.${typeStr}`);
         }
     }
@@ -814,7 +860,8 @@ export class NaslServer {
             //     record.suggestionDiagnostics = record.suggestionDiagnostics.filter((item) => !item.text.includes(`implicitly has an 'any' type, but a better type may be inferred from usage.`));
             // }
             record.suggestionDiagnostics = record.suggestionDiagnostics
-                .filter((item) => [`'__LogicEmpty' is declared but its value is never read.`, `'__destinationEmpty__' is declared but its value is never read.`].includes(item.text))
+                .filter((item) => [`'__LogicEmpty' is declared but its value is never read.`, `'__destinationEmpty__' is declared but its value is never read.`
+                    , `'__UpdateNoProperty__' is declared but its value is never read.`].includes(item.text))
                 .map((diag) => this._resolveDiagnostic(diag as unknown as tsProtocol.DiagnosticWithFileName, node as FileNode, record))
                 .filter((diag) => !!diag);
 
@@ -847,7 +894,7 @@ export class NaslServer {
             }
             if (removed)
                 return diagnostics;
-            fileNode?.sourceMap.forEach(async (value, node) => {
+            fileNode?.sourceMap.forEach((value, node) => {
                 if (node instanceof Match) {
                     const { cases, expression } = node || {};
                     const typeAnnotationMap: any = {};
@@ -857,7 +904,7 @@ export class NaslServer {
                         count: 0,
                     };
                     if (Array.isArray(cases)) {
-                        cases.forEach(async (caseItem, index) => {
+                        cases.forEach((caseItem, index) => {
                             let isDisabled = false;
                             // 是最后一项
                             if (index === cases.length - 1) {
@@ -997,7 +1044,7 @@ export class NaslServer {
             if (removed)
                 return diagnostics;
 
-            fileNode?.sourceMap.forEach(async (value, node) => {
+            fileNode?.sourceMap.forEach((value, node) => {
                 if (node instanceof ViewElement && node.view === fileNode) {
                     if (node.tag) {
                         node.bindAttrs.forEach((bindAttr) => {
@@ -1111,6 +1158,40 @@ export class NaslServer {
                                 },
                             };
                             diagnostics.push(diagnostic);
+                        } else if (propertyValue.value) {
+                            const dataSource: any = fileNode;
+                            // 数据源有连接错误
+                            let envText;
+                            if (propertyValue.env === 'dev') {
+                                if (dataSource.__devConnectError) {
+                                    envText = '开发';
+                                } else if (dataSource.__devConnectError === false) {
+                                    return;
+                                }
+                            } else if (propertyValue.env === 'online') {
+                                if (dataSource.__onlineConnectError) {
+                                    envText = '生产';
+                                } else if (dataSource.__onlineConnectError === false) {
+                                    return;
+                                }
+                            }
+                            // 手动插入报错
+                            if (envText) {
+                                const diagnostic = {
+                                    node: fileNode,
+                                    severity: 'error',
+                                    message: `数据源配置：数据源 ${property.name} ${envText}环境数据源连接不通，请先检查${envText}环境数据源配置`,
+                                    // 保留原来的内容方便查询一些问题
+                                    originalDiagnostic: {
+                                        fileName: '',
+                                        start: <any>null,
+                                        end: <any>null,
+                                        category: 'error',
+                                        text: `DataSource connection error`,
+                                    },
+                                };
+                                return diagnostics.push(diagnostic);
+                            }
                         }
                     });
                 }
@@ -1121,17 +1202,18 @@ export class NaslServer {
             if (fileNode.parentNode instanceof App && !fileNode.parentNode.logics.includes(fileNode))
                 return diagnostics;
 
-            fileNode?.sourceMap.forEach(async (value, node) => {
+            fileNode?.sourceMap.forEach((value, node) => {
+                //OQL支持返回复合类型数据了
                 // SqlQueryComponent内部返回值类型，如果是嵌套的就需要报错
-                if ((node instanceof OqlQueryComponent || node instanceof SqlQueryComponent) && (node as SqlQueryComponent).getTypeBanError()) {
-                    const diagnostic = {
-                        node,
-                        severity: 'error',
-                        message: 'SQL查询：返回类型内部,不支持复杂类型。',
-                    };
-                    node.tsErrorDetail = diagnostic;
-                    diagnostics.push(diagnostic);
-                }
+                // if ((node instanceof OqlQueryComponent || node instanceof SqlQueryComponent) && (node as SqlQueryComponent).getTypeBanError()) {
+                //     const diagnostic = {
+                //         node,
+                //         severity: 'error',
+                //         message: 'SQL查询：返回类型内部,不支持复杂类型。',
+                //     };
+                //     node.tsErrorDetail = diagnostic;
+                //     diagnostics.push(diagnostic);
+                // }
                 if (node instanceof Return || node instanceof Variable) {
                     if (!node.typeAnnotation && !node.__TypeAnnotation) {
                         const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
@@ -1167,6 +1249,11 @@ export class NaslServer {
                 this.checkNodeError(node, diagnostics);
             });
         }
+        if (fileNode instanceof Process) {
+            fileNode?.sourceMap.forEach((value, node) => {
+                this.checkNodeError(node, diagnostics);
+            });
+        }
         return diagnostics;
     }
 
@@ -1244,9 +1331,30 @@ export class NaslServer {
                     node.tsErrorDetail = diagnostic;
                     diagnostics.push(diagnostic);
                 }
+                // 如果TypeAnnotation 还存在，但是本身已经不是union类型，就是已经从union换别的类型了就都要报错
+            } else if (node instanceof TypeAnnotation && matchExpressionType?.typeKind !== 'union') {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: '匹配：选择类型不存在',
+                    titleTip: '该类型已被删除',
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
+                // 如果可枚举变量的 ，变量 还存在，但是本身已经是union类型，就是已经从别的类型 换了union就都要报错
+            } else if (!(node instanceof TypeAnnotation) && matchExpressionType?.typeKind === 'union') {
+                const diagnostic = {
+                    node,
+                    severity: 'error',
+                    message: '匹配：选择值不存在',
+                    titleTip: '该值无法匹配，请重新选择类型',
+                };
+                node.tsErrorDetail = diagnostic;
+                diagnostics.push(diagnostic);
             }
             if (node.tsErrorDetail) {
-                if (matchExpressionType?.typeNamespace?.includes('enums')) {
+                // 如果父级是枚举，而且子集选的是变量，就提示枚举值已被删除
+                if (matchExpressionType?.typeNamespace?.includes('enums') && (node instanceof MemberExpression)) {
                     node.tsErrorDetail.titleTip = '该枚举值已被删除';
                 } else if (!node.tsErrorDetail.titleTip) {
                     node.tsErrorDetail.titleTip = '该值已被删除';
@@ -1263,6 +1371,25 @@ export class NaslServer {
             node.tsErrorDetail = diagnostic;
             diagnostics.push(diagnostic);
         }
+        /**
+         * 如果节点是内置函数
+         * 穷举在线上的情况，不在线上就void报错， calllogic 和 callinterface 因为原来有报错，所以就忽略掉
+         * && 他在父级中，不在body
+         * && 也不再 if的线上
+         * && 也不再 switch的线上consequent
+         * && 也不再草稿区域
+         * && 不在 parentNode.parentNode（只用处理两层的，超过两层上就需要报错，只用直接是参数位第一层的需要） 是 callfunction 和 callInfterfase中，因为这两本身有强制类型，内置函数或者一些带T的声明那种，
+         * && 而且也没有类型，就说明在槽位里，就需要报错
+         */
+        if (node instanceof CallFunction && node.parentKey !== 'body' && node.parentKey !== 'alternate' && node.parentKey !== 'playground' && node.parentKey !== 'consequent' && node.parentNode?.parentNode?.concept !== 'CallLogic' && node.parentNode?.parentNode?.concept !== 'CallInterface' && !node.__TypeAnnotation) {
+            const diagnostic = {
+                node,
+                severity: 'error',
+                message: `类型不一致，当前内置函数${node.calleeName || ''}无返回值。`,
+            };
+            node.tsErrorDetail = diagnostic;
+            diagnostics.push(diagnostic);
+        }
     }
 
     /* 接口导入查找 */
@@ -1654,7 +1781,7 @@ export class NaslServer {
                         // 因为要用下面的点位信息
                         const name = minRange.node.name;
                         // 如果name不改，那就是要改命名空间
-                        if (newValue === name) {
+                        if (node instanceof Frontend || newValue === name) {
                             const namespace = minRange.node.namespace;
                             // 先看下标位置
                             const lineText = record.lineText;
@@ -1773,6 +1900,24 @@ export class NaslServer {
                             minRange.newValue = newTsNameSpace;
                         }
                     }
+                    if (node instanceof Frontend && minRange.node instanceof Destination) {
+                        const tsCalleeNamespace = minRange.node.tsCalleeNamespace;
+                        const tsName = minRange.node.tsName;
+                        const oldValue = tsCalleeNamespace + '.' + tsName;
+                        // 先看下标位置
+                        const lineText = record.lineText;
+                        const index = lineText.indexOf(oldValue);
+                        // 在把开始结束位置的-开始位置，来知道是哪里要替换
+                        const start = record.start.offset - index - 1;
+                        const end = record.end.offset - index - 1;
+                        if (start <= tsCalleeNamespace.length) {
+                            // 新的完整的value
+                            let newTsNameSpace = tsCalleeNamespace.substring(0, start) + newValue + tsCalleeNamespace.substring(end, tsCalleeNamespace.length);
+                            minRange.setTypeMethods = 'setViewNamespace';
+                            newTsNameSpace = newTsNameSpace.replace(/\.\$/g, '.');
+                            minRange.newValue = newTsNameSpace;
+                        }
+                    }
                     // 如果是事件修改
                     // 如果是view也需要加前缀
                     // logic 和 views名称修改 可能会触发bindEvent修改
@@ -2306,7 +2451,7 @@ export class NaslServer {
             return TypeAnnotation.createPrimitive('Boolean');
         }
         // Convert和new都是自身携带类型的，就不进行修改
-        if (node instanceof CallFunction && node.calleeNamespace === 'nasl.util' && (node.calleeName === 'Convert' || node.calleeName === 'New')) {
+        if (node instanceof CallFunction && node.calleeNamespace === 'nasl.util' && (['Convert', 'New', 'FromString'].includes(node.calleeName))) {
             if (node.typeArguments.length) {
                 return node.typeArguments[0];
             }
@@ -2396,6 +2541,9 @@ export class NaslServer {
                 'Return',
                 'Variable',
                 'Match',
+                'NewComposite',
+                'NewList',
+                'NewMap',
             ].includes(node.concept))
                 return;
             // 要去ls那边获取的
@@ -2442,12 +2590,18 @@ export class NaslServer {
                 let newCode = item.code.substring(0, indexOf);
                 newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
                 fileDetail.offset = newCode.length + 'return '.length;
+            } else if (['NewComposite', 'NewList', 'NewMap'].includes(node.concept)) {
+                fileDetail.line = item.range.end.line;
+                const indexOf = item.code.indexOf('return __newComposite');
+                let newCode = item.code.substring(0, indexOf);
+                newCode = newCode.substring(newCode.lastIndexOf('\n'), indexOf);
+                fileDetail.offset = newCode.length + 'return '.length;
             }
             args.push(fileDetail);
         });
-        console.time('请求')
+        console.time('请求');
         const resultMap: any = (await this.getNaslNodeTypeFull(args)).response;
-        console.timeEnd('请求')
+        console.timeEnd('请求');
 
         // console.log(resultMap);
 
@@ -2773,7 +2927,7 @@ export class NaslServer {
         };
     }
 
-    async getCurrentTypeAnnotation(node: BaseNode) {
+    async getCurrentTypeAnnotation(node: BaseNode, outTime: number = 600) {
         if (node.__TypeAnnotation) {
             return node.__TypeAnnotation;
         }
@@ -2787,7 +2941,7 @@ export class NaslServer {
                 } else {
                     resolve(null);
                 }
-            }, 600);
+            }, outTime);
             const mySetInterval = setInterval(() => {
                 if (node.__isCorrectTypeAnnotation) {
                     resolve(node.__TypeAnnotation);
@@ -2877,7 +3031,7 @@ export class NaslServer {
         // 更新文件之后
         await this.updateFiles({ outputFiles });
 
-        newRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
+        newRefs.refs.forEach((ref) => this.filesToCheck.add(ref.file));
     }
 
     /**
@@ -2900,13 +3054,13 @@ export class NaslServer {
             offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
         });
 
-        newRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
+        newRefs.refs.forEach((ref) => this.filesToCheck.add(ref.file));
         // 唤起建立连接弹框
         // 文件级别的建立连接采取提醒
         if (action === 'create' && (targetNode as any).__init) {
             // 清除临时状态, 完成本次创建
             delete (targetNode as any).__init;
-            if (fileNode === targetNode && filesToCheck.size > 1) {
+            if (fileNode === targetNode && this.filesToCheck.size > 1) {
                 const confirmParms = {
                     actionType: 'createEstablishConnection',
                     node: fileNode,
@@ -2943,8 +3097,8 @@ export class NaslServer {
                 line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
                 offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
             });
-            oldRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
-            filesToCheck.delete(oldFilePath);
+            oldRefs.refs.forEach((ref) => this.filesToCheck.add(ref.file));
+            this.filesToCheck.delete(oldFilePath);
             // 更新文件之后
             await this.updateFiles({ outputFiles });
 
@@ -2956,7 +3110,7 @@ export class NaslServer {
             });
             const newRefFileList: Set<string> = new Set();
             newRefs.refs.forEach((ref) => {
-                filesToCheck.add(ref.file);
+                this.filesToCheck.add(ref.file);
                 newRefFileList.add(ref.file);
             });
 
@@ -2985,7 +3139,7 @@ export class NaslServer {
                 line: EmbeddedTSFileLineMap[fileNode.concept] ?? 2,
                 offset: EmbeddedTSFileOffsetMap[fileNode.concept] ?? 6,
             });
-            newRefs2.refs.forEach((ref) => filesToCheck.add(ref.file));
+            newRefs2.refs.forEach((ref) => this.filesToCheck.add(ref.file));
         } else {
             // 查一下当前属性依赖的文件
             const { currentSource, fileNode } = this.getCurrentSource(targetNode);
@@ -2999,7 +3153,7 @@ export class NaslServer {
                     line: lsp2tspNumber(currentSource.range.start.line),
                     offset: lsp2tspNumber(currentSource.range.start.character),
                 });
-                oldRefs.refs.forEach((ref) => filesToCheck.add(ref.file));
+                oldRefs.refs.forEach((ref) => this.filesToCheck.add(ref.file));
                 // 更新文件之后
                 await this.updateFiles({ outputFiles });
 
@@ -3008,7 +3162,7 @@ export class NaslServer {
                     line: lsp2tspNumber(currentSource.range.start.line),
                     offset: lsp2tspNumber(currentSource.range.start.character),
                 });
-                newRefs2.refs.forEach((ref) => filesToCheck.add(ref.file));
+                newRefs2.refs.forEach((ref) => this.filesToCheck.add(ref.file));
             }
         }
     }
@@ -3024,6 +3178,29 @@ export class NaslServer {
      */
     async incidentalAction(action: string, fileNode: BaseNode, targetNode: BaseNode, oldpath?: string) {
         if ((action === 'create' || action === 'delete' || (action === 'update' && oldpath)) && fileNode === targetNode) {
+            //删除、更改、新增端
+            if (fileNode instanceof Frontend && (fileNode.views?.length || fileNode.variables?.length)) {
+                const fileNodeChildren = [...fileNode.views, ...fileNode.variables];
+                for (let i = 0; i < fileNodeChildren.length; i++) {
+                    const fileNodeItem = fileNodeChildren[i];
+                    const result = (fileNodeItem as FileNode).toEmbeddedTSFile();
+                    fileNodeItem.sourceMap = result.sourceMap;
+                    if (action === 'create') {
+                        await this.handleChange(fileNodeItem, fileNodeItem, result, action);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem);
+                    } else if (action === 'delete') {
+                        await this.handleDelete(fileNodeItem, fileNodeItem, result);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem);
+                    } else if (action === 'update' && oldpath) {
+                        const parentPath = oldpath.replace('.ts', '/');
+                        const foldName = fileNodeItem.concept === 'View' ? 'views' : 'variables';
+                        const currentOldPath = parentPath + foldName + '/' + fileNodeItem.name + '.ts';
+                        // 因为重命名这里只有当前修改父级的 旧名称, 所以他的子集也要根据旧名称去查依赖 更新内容
+                        await this.handleRename(fileNodeItem, fileNodeItem, result, currentOldPath);
+                        await this.incidentalAction(action, fileNodeItem, fileNodeItem, currentOldPath);
+                    }
+                }
+            }
             // 删除或者新增页面
             if (fileNode instanceof View && fileNode.children?.length) {
                 const fileNodeChildren = fileNode.children;
@@ -3095,7 +3272,7 @@ export class NaslServer {
     }
 
     async receiveHandleChange($event: EventPayload) {
-        singleFileChangeIng = true;
+        this.singleFileChangeIng = true;
         // 行为
         const action = $event.action;
         const targetNode = $event.target;
@@ -3144,19 +3321,19 @@ export class NaslServer {
     }
 
     changeFileNext() {
-        if (!singleFileChangeIng) {
+        if (!this.singleFileChangeIng) {
             const item = this.changeStackList.shift();
             this.receiveHandleChange(item).catch((err) => {
                 console.log(err, 'receiveHandleChangeErr');
             }).finally(async () => {
                 // 每一个文件与change接触就把状态置为false，让下一个进入
-                singleFileChangeIng = false;
+                this.singleFileChangeIng = false;
                 if (this.changeStackList.length) {
                     this.changeFileNext();
                 } else {
-                    console.log(Array.from(filesToCheck));
-                    await this.getDiagnosticRecordsAndPushAll(Array.from(filesToCheck));
-                    filesToCheck.clear();
+                    console.log(Array.from(this.filesToCheck));
+                    await this.getDiagnosticRecordsAndPushAll(Array.from(this.filesToCheck));
+                    this.filesToCheck.clear();
                 }
             });
         }

package/src/server/process2LogicNamespace.ts

@@ -89,6 +89,10 @@ export function processToTreeFragment(process: Process) {
                 k.getNamespace = function () {
                     return path;
                 };
+                const api = `/api/${process.name}/${e.name}/${k.name}`;
+                k.getPath = function () {
+                    return api;
+                };
             });
 
             fragment.elements.push({
@@ -107,6 +111,10 @@ export function processToTreeFragment(process: Process) {
     launchLogic.getNamespace = function () {
         return path;
     };
+    const api = `/api/${process.name}/${launchLogic.name}`;
+    launchLogic.getPath = function () {
+        return api;
+    };
 
     fragment.logics.push(launchLogic);
     launchLogic.parentKey = 'readonly';