@lcap/nasl 2.22.0-beta.0 → 2.22.0-beta.1

package/src/server/naslServer.ts

@@ -72,6 +72,7 @@ import {
     LogicItem,
     JSBlock,
     NewComposite,
+    Integration,
 } from '../concepts';
 import { lsp2tspNumber, SourceMap, SourceMapItem } from '../translator';
 import axios from '../service/storage';
@@ -88,6 +89,8 @@ import { EventEmitter } from '../common/EventEmitter';
 
 import { traverse } from '../utils';
 
+import { Decimal } from 'decimal.js';
+
 const EmbeddedTSFileLineMap: { [name: string]: number } = {
     Entity: 3,
 };
@@ -255,12 +258,12 @@ export class NaslServer {
                     const changeNode = changeEvent.target;
                     const { fileNode } = this.getCurrentSource(changeNode);
                     if (changeNode !== fileNode || !changeEvent.field) {
-                        const findIndex = this.changeStackList.findIndex((changeStackItem: EventPayload) => {
+                        const findLastIndex = this.changeStackList.findLastIndex((changeStackItem: EventPayload) => {
                             const target = changeStackItem.target;
                             const { fileNode: targetFileNode } = this.getCurrentSource(target);
                             return targetFileNode === fileNode;
                         });
-                        if (findIndex === this.changeStackList.length - 1) {
+                        if (findLastIndex === this.changeStackList.length - 1) {
                             this.changeStackList.pop();
                         }
                     }
@@ -305,6 +308,10 @@ export class NaslServer {
     }
 
     contentToFile(module: Module | App, results: Array<ReturnType<Structure['toEmbeddedTSFile']>>) {
+        // 禁用的依赖库不生成代码 区分 undefined 和 false
+        if (module instanceof Module && module.type === 'extension' && module.enable === false) {
+            return;
+        }
         module.structures.forEach((structure) => {
             try {
                 const result = structure.toEmbeddedTSFile();
@@ -622,6 +629,9 @@ export class NaslServer {
              * fileNode
              */
             const { currentSource, fileNode } = this.getCurrentSource(callFunction);
+            if (!currentSource) {
+                return [];
+            }
             try {
                 const quickInfo = await this._getTypeQuickinfo({
                     file: (fileNode as FileNode).getEmbeddedFilePath(),
@@ -658,8 +668,8 @@ export class NaslServer {
     }
 
     /**
-     * 获取表单的dataschema类型
-     * @param node 当前表单节点
+     * 获取表格的dataschema类型
+     * @param node 当前表格节点
      * @param allType 是不是需要全部类型 默认不要
      * @returns 全部类型的str 或者 最后一个.后的内容
      */
@@ -667,7 +677,9 @@ export class NaslServer {
         if (!(node instanceof ViewElement))
             return;
         const { currentSource, fileNode } = this.getCurrentSource(node);
-
+        if (!currentSource) {
+            return;
+        }
         const quickInfo = await this._getTypeQuickinfo({
             file: (fileNode as FileNode).getEmbeddedFilePath(),
             line: lsp2tspNumber(currentSource.range.start.line),
@@ -725,6 +737,9 @@ export class NaslServer {
             return;
 
         const { currentSource, fileNode } = this.getCurrentSource(node);
+        if (!currentSource) {
+            return;
+        }
         const quickInfo = await this._getTypeQuickinfo({
             file: (fileNode as FileNode).getEmbeddedFilePath(),
             line: lsp2tspNumber(currentSource.range.start.line),
@@ -926,11 +941,6 @@ export class NaslServer {
                         if (diagnostic.severity === 'warning') {
                             record.suggestionDiagnostics.push(diagnostic);
                             return null;
-                        } else if (currentNode.concept === 'DataSource' && diagnostic.originalDiagnostic?.text === 'DataSource connection error') {
-                            // 数据源警告类型降级
-                            diagnostic.severity = 'warning';
-                            record.suggestionDiagnostics.push(diagnostic);
-                            return null;
                         } else if (currentNode.concept === 'OqlQueryComponent') {
                             // OQL别名错误降级为警告
                             if (diagnostic.originalDiagnostic && diagnostic.originalDiagnostic?.text.includes('__OQL_ALIAS_WARNING__')) {
@@ -996,6 +1006,12 @@ export class NaslServer {
                 } else if ((diag.text).includes(` is declared but its value is never read.`)) {
                     // 局部变量和输入变量未使用的警告
                     if ((node.concept === 'View' || node.concept === 'Logic') && node.parentNode.concept !== 'Module') {
+                        /**
+                         * javalogic不用提示
+                         */
+                        if (node.concept === 'Logic' && this._isJavalogic(node as Logic)) {
+                            return;
+                        }
                         const minRange = this._findMinRange(diag as unknown as tsProtocol.DiagnosticWithFileName, node as FileNode);
                         if (minRange) {
                             /**
@@ -1029,6 +1045,18 @@ export class NaslServer {
         return records;
     }
 
+    /**
+     * 判断是否是Javalogic
+     */
+    _isJavalogic(node: Logic) {
+        const body = node.body || [];
+
+        if (body && body.length && body[0].concept === 'JavaLogic') {
+            return true;
+        }
+        return false;
+    }
+
     /**
      * 额外的建议诊断
      * @param fileNode 文件级别的节点
@@ -1038,7 +1066,8 @@ export class NaslServer {
         const diagnostics: Diagnostic[] = [];
         if (fileNode instanceof Logic || fileNode instanceof View) {
             fileNode?.sourceMap.forEach((value, node) => {
-                if (node instanceof Match) {
+                // 表达式模式才需要校验返回值类型
+                if (node instanceof Match && node.isExpression) {
                     const { cases, expression } = node || {};
                     const typeAnnotationMap: any = {};
                     // 最多数的类型
@@ -1530,14 +1559,14 @@ export class NaslServer {
                         if (!propertyValue.value && fileNode.name !== 'defaultDS') {
                             const diagnostic = {
                                 node: fileNode,
-                                severity: 'warning',
+                                severity: 'error',
                                 message: `数据源配置：数据源${property.name}${propertyValue.env === 'dev' ? '开发环境' : '生产环境'}未配置数据信息`,
                                 // 保留原来的内容方便查询一些问题
                                 originalDiagnostic: {
                                     fileName: '',
                                     start: <any>null,
                                     end: <any>null,
-                                    category: 'warning',
+                                    category: 'error',
                                     text: `Data Source is not config`,
                                 },
                             };
@@ -1588,107 +1617,218 @@ export class NaslServer {
             const { origin, properties } = entity || {};
             if (dbType && !['excel', 'table'].includes(origin) && Array.isArray(properties) && properties.length) {
                 properties.forEach((property) => {
-                    const { typeAnnotation, databaseTypeAnnotation, rules } = property || {};
-                    if (property && databaseTypeAnnotation) {
-                        const { typeName: databaseTypeName } = databaseTypeAnnotation;
+                    if (property) {
+                        const { typeAnnotation, databaseTypeAnnotation, rules } = property;
                         const { typeName } = typeAnnotation || {};
-                        const dataBaseTypeMap = property.dataBaseTypeMap || {};
-                        const dataBaseTyp = dataBaseTypeMap[databaseTypeName];
-                        const diagnostic: any = {
+                        const rulesMap: any = {};
+                        if (Array.isArray(rules)) {
+                            rules.forEach((rule) => {
+                                const match = rule.match(/^([^()]+)\(([\d\-.]+)\)$/);
+                                if (match) {
+                                    const [, key, value] = match;
+                                    rulesMap[key] = value;
+                                }
+                            });
+                        }
+                        const diagnostic = {
                             node: property,
                             severity: 'error',
                             message: '',
-                            errorPos: {},
                         };
+                        const dataBaseTyp = property.currentDataBaseType;
                         typeAnnotation.tsErrorDetail = null;
-                        databaseTypeAnnotation.tsErrorDetail = null;
-                        if (!dataBaseTyp) {
-                            diagnostic.message = `平台目前暂不支持${dbType}数据库的${databaseTypeName}存储类型`;
-                            diagnostic.errorPos.typeName = `平台目前暂不支持${dbType}数据库的${databaseTypeName}存储类型`;
-                            databaseTypeAnnotation.tsErrorDetail = diagnostic;
+                        if (!dataBaseTyp && databaseTypeAnnotation) {
+                            const { typeName: databaseTypeName } = databaseTypeAnnotation;
+                            const errorMsg = `平台目前暂不支持${dbType}数据库的${databaseTypeName}存储类型`;
+                            diagnostic.message = errorMsg;
+                            const tsErrorDetail: any = {
+                                severity: 'error',
+                                errorPos: {
+                                    typeName: errorMsg,
+                                },
+                            };
+                            databaseTypeAnnotation.tsErrorDetail = tsErrorDetail;
                         } else {
-                            const { options } = dataBaseTyp;
+                            const { options } = dataBaseTyp || {};
                             if (options) {
-                                for (const key in options) {
-                                    const option = options[key];
-                                    const { comment, require, min, max } = option || {};
-                                    const databaseTypeArg = (databaseTypeAnnotation.arguments as any)?.[key];
-                                    // 如果必填的值没有填，报错
-                                    if (require && !databaseTypeArg && key !== 'scale') {
-                                        diagnostic.message = `${comment}不能为空`;
-                                        diagnostic.errorPos[key] = `${comment}不能为空`;
-                                    } else if (min && +min > +databaseTypeArg) {
-                                        diagnostic.message = `${comment}不能小于最小值${min}`;
-                                        diagnostic.errorPos[key] = `${comment}不能小于最小值${min}`;
-                                    } else if (max && +max < +databaseTypeArg) {
-                                        diagnostic.message = `${comment}不能大于最大值${max}`;
-                                        diagnostic.errorPos[key] = `${comment}不能大于最大值${max}`;
-                                    }
-                                    if (diagnostic.message) {
-                                        databaseTypeAnnotation.tsErrorDetail = diagnostic;
-                                    }
-                                }
-                                const rulesMap: any = {};
-                                if (Array.isArray(rules)) {
-                                    rules.forEach((rule) => {
-                                        const match = rule.match(/^([^()]+)\(([\d\-.]+)\)$/);
-                                        if (match) {
-                                            const [, key, value] = match;
-                                            rulesMap[key] = value;
+                                if (databaseTypeAnnotation) {
+                                    databaseTypeAnnotation.tsErrorDetail = null;
+                                    const databaseTypeAnnotationErrorDetail: any = {
+                                        severity: 'error',
+                                        errorPos: {},
+                                    };
+                                    for (const key in options) {
+                                        const option = options[key];
+                                        const { comment, require, min, max } = option || {};
+                                        const databaseTypeArg = (databaseTypeAnnotation.arguments as any)?.[key];
+                                        // 如果必填的值没有填，报错
+                                        if (require && !databaseTypeArg && key !== 'scale') {
+                                            diagnostic.message = `${comment}不能为空`;
+                                            databaseTypeAnnotationErrorDetail.errorPos[key] = `${comment}不能为空`;
+                                        } else if (min && +min > +databaseTypeArg) {
+                                            diagnostic.message = `${comment}不能小于最小值${min}`;
+                                            databaseTypeAnnotationErrorDetail.errorPos[key] = `${comment}不能小于最小值${min}`;
+                                        } else if (max && +max < +databaseTypeArg) {
+                                            diagnostic.message = `${comment}不能大于最大值${max}`;
+                                            databaseTypeAnnotationErrorDetail.errorPos[key] = `${comment}不能大于最大值${max}`;
                                         }
-                                    });
+                                        if (Object.keys(databaseTypeAnnotationErrorDetail.errorPos).length) {
+                                            databaseTypeAnnotation.tsErrorDetail = databaseTypeAnnotationErrorDetail;
+                                        }
+                                    }
                                 }
+                                const typeAnnotationErrorDetail: any = {
+                                    severity: 'warning',
+                                    errorPos: {},
+                                };
+                                const precisionOption = options?.precision;
+                                const { default: defaultVal } = precisionOption || {};
+                                const precision = databaseTypeAnnotation ? (databaseTypeAnnotation.arguments as any)?.precision : defaultVal;
+                                const ruleScale = (typeAnnotation?.ruleMap as any)?.scale;
+                                const scale = ruleScale !== undefined ? ruleScale + '' : '';
+                                let ensureScale = true;
                                 switch (typeName) {
+                                    case 'String': {
+                                        const defaultVal = options.length?.default;
+                                        const length = databaseTypeAnnotation ? (databaseTypeAnnotation.arguments as any)?.length : defaultVal;
+                                        if (length) {
+                                            [
+                                                {
+                                                    key: 'minLength',
+                                                    text: '小',
+                                                },
+                                                {
+                                                    key: 'maxLength',
+                                                    text: '大',
+                                                },
+                                            ].forEach(({ key, text }) => {
+                                                const curLength = rulesMap[key];
+                                                if (+curLength > +length) {
+                                                    const errorMsg = `最${text}长度超出存储长度`;
+                                                    const diag: any = {
+                                                        node: property,
+                                                        severity: 'warning',
+                                                        message: errorMsg,
+                                                    };
+                                                    diagnostics.push(diag);
+                                                    typeAnnotationErrorDetail.errorPos[key] = errorMsg;
+                                                }
+                                            });
+                                        }
+                                    }
                                     case 'Long': {
                                         const { min: ruleMin, max: ruleMax } = dataBaseTyp;
                                         const minVal = rulesMap.min;
                                         const maxVal = rulesMap.max;
-                                        const tsErrorDetail: any = {
-                                            errorPos: {},
-                                        };
-                                        if (ruleMin && minVal && +ruleMin > +minVal) { // 最小值超出存储上限
-                                            const diag: any = {
-                                                node: property,
-                                                severity: 'warning',
-                                                message: `最小值超出存储下限${ruleMin}`,
-                                            };
-                                            tsErrorDetail.severity = 'warning';
-                                            tsErrorDetail.errorPos.min = '最小值超出存储下限';
-                                            diagnostics.push(diag);
-                                        }
-                                        if (ruleMax && maxVal && +ruleMax < +maxVal) { // 最大值超出存储上限
-                                            const diag = {
-                                                node: property,
-                                                severity: 'warning',
-                                                message: `最大值超出存储上限${ruleMax}`,
-                                            };
-                                            tsErrorDetail.severity = 'warning';
-                                            tsErrorDetail.errorPos.max = '最大值超出存储上限';
-                                            diagnostics.push(diag);
-                                        }
-                                        typeAnnotation.tsErrorDetail = tsErrorDetail;
+                                        // 最大最小值都要校验存储上下限
+                                        [
+                                            {
+                                                key: 'min',
+                                                name: '最小值',
+                                                value: minVal,
+                                            },
+                                            {
+                                                key: 'max',
+                                                name: '最大值',
+                                                value: maxVal,
+                                            },
+                                        ].forEach(({ key, name, value }) => {
+                                            if (ruleMin && value && new Decimal(ruleMin).greaterThan(new Decimal(value))) { // 超出存储下限
+                                                const diag: any = {
+                                                    node: property,
+                                                    severity: 'warning',
+                                                    message: `${name}超出存储下限${ruleMin}`,
+                                                };
+                                                diagnostics.push(diag);
+                                                typeAnnotationErrorDetail.errorPos[key] = `${name}超出存储下限`;
+                                            }
+                                            if (ruleMax && value && new Decimal(ruleMax).lessThan(new Decimal(value))) { // 超出存储上限
+                                                const diag = {
+                                                    node: property,
+                                                    severity: 'warning',
+                                                    message: `${name}超出存储上限${ruleMax}`,
+                                                };
+                                                diagnostics.push(diag);
+                                                typeAnnotationErrorDetail.errorPos[key] = `${name}超出存储上限`;
+                                            }
+                                        });
                                         break;
                                     }
                                     case 'Decimal': {
-                                        const precisionOption = options?.precision;
-                                        const { default: defaultVal } = precisionOption || {};
-                                        const precision = databaseTypeAnnotation ? (databaseTypeAnnotation.arguments as any)?.precision : defaultVal;
-                                        const scale = (typeAnnotation?.ruleMap as any)?.scale + '';
-                                        if (+precision < +scale) {
-                                            const diag: any = {
-                                                node: property,
-                                                severity: 'error',
-                                                message: '',
-                                                errorPos: {},
-                                            };
-                                            diag.message = `小数位数必须小于或等于精度${precision}`;
-                                            diag.errorPos.scale = `小数位数必须小于或等于精度${precision}`;
-                                            typeAnnotation.tsErrorDetail = diag;
-                                            diagnostics.push(diag);
+                                        if (precisionOption) {
+                                            if (+precision < +scale) {
+                                                const diag: any = {
+                                                    node: property,
+                                                    severity: 'error',
+                                                    message: '',
+                                                };
+                                                const errorMsg = `小数位数必须小于或等于精度${precision}`;
+                                                diag.message = errorMsg;
+                                                diagnostics.push(diag);
+                                                ensureScale = false;
+                                                typeAnnotationErrorDetail.errorPos.scale = errorMsg;
+                                            }
                                         }
                                         break;
                                     }
                                 }
+                                const minVal = rulesMap.min;
+                                const maxVal = rulesMap.max;
+                                // 最 大/小 值不能 大/于 由精度和小数位数 确定的范围
+                                if (precisionOption && ensureScale) {
+                                    const memoryStr = '9'.repeat(+precision);
+                                    // 储存整数部分
+                                    const memoryIntAbsStr = memoryStr.slice(0, +precision - +(scale || '0')) || '0';
+                                    // 储存小数部分
+                                    const memoryScaleStr = memoryStr.slice(0, +(scale || '0'));
+                                    // 储存绝对值
+                                    const memoryAbsVal = memoryIntAbsStr + (memoryScaleStr ? '.' + memoryScaleStr : '');
+                                    const decimalMemoryAbsVal = new Decimal(memoryAbsVal);
+                                    [
+                                        {
+                                            key: 'min',
+                                            text: '小',
+                                            val: minVal,
+                                        },
+                                        {
+                                            key: 'max',
+                                            text: '大',
+                                            val: maxVal,
+                                        },
+                                    ].forEach(({ key, text, val }) => {
+                                        if (val) {
+                                            const decimalVal = new Decimal(val);
+                                            // 是否是负数
+                                            const isNegative = decimalVal.isNegative();
+                                            // 填入的值的绝对值是否大于存储绝对值
+                                            if (decimalMemoryAbsVal.lessThan(decimalVal.abs())) {
+                                                const errorMsg = `最${text}值不得${isNegative ? '小' : '大'}于${isNegative ? '-' : ''}${memoryAbsVal}`;
+                                                const diag: any = {
+                                                    node: property,
+                                                    severity: 'warning',
+                                                    message: errorMsg,
+                                                };
+                                                diagnostics.push(diag);
+                                                typeAnnotationErrorDetail.errorPos[key] = errorMsg;
+                                            }
+                                        }
+                                    });
+                                }
+                                if (['Long', 'Decimal'].includes(typeName) && !typeAnnotationErrorDetail.errorPos.min) {
+                                    if (minVal && maxVal && new Decimal(maxVal).lessThan(minVal)) {
+                                        const errorMsg = '最小值不得大于最大值';
+                                        const diag: any = {
+                                            node: property,
+                                            severity: 'warning',
+                                            message: errorMsg,
+                                        };
+                                        diagnostics.push(diag);
+                                        typeAnnotationErrorDetail.errorPos.min = errorMsg;
+                                    }
+                                }
+                                if (Object.keys(typeAnnotationErrorDetail.errorPos).length) {
+                                    typeAnnotation.tsErrorDetail = typeAnnotationErrorDetail;
+                                }
                             }
                         }
                         if (diagnostic.message) {
@@ -2065,8 +2205,13 @@ export class NaslServer {
      */
     _resolveDiagnostic(diagnostic: tsProtocol.DiagnosticWithFileName, fileNode: FileNode, record: DiagnosticRecord): Diagnostic {
         // 拓展模块中的翻译先过滤掉，因为有错用户也不能修改
-        if ((fileNode as any).module && !(fileNode instanceof ConfigProperty))
+        if ((fileNode as any).module && !(fileNode instanceof ConfigProperty)) {
             return;
+        }
+        // 过滤掉java依赖库的报错
+        // if ('compilerInfoMap' in fileNode && (fileNode as any).compilerInfoMap?.java) {
+        //     return;
+        // }
 
         const minRange = this._findMinRange(diagnostic, fileNode);
         const tsErrorDetail = {
@@ -2120,8 +2265,23 @@ export class NaslServer {
                 } else {
                     // 没有节点 或者 行差比较小比已有的小就可以
                     // 一般出现在一大块上，多半是if for 等等没有参数
-                    if (!minRange || item.range.end.line - item.range.start.line < minRange.item.range.end.line - minRange.item.range.start.line) {
+                    if (!minRange) {
                         minRange = { node, item };
+                    } else if (lsp2tspNumber(item.range.start.line) === diagnostic.start.line && diagnostic.start.offset >= lsp2tspNumber(item.range.start.character)) {
+                        // 如果当前遍历的内容的行和列都 小于之前的， 而且是有效的
+                        // 如果两个内容位置行数是一样的，就比较下找到内容的位置信息
+                        // 找到的内容的开始位置， 要大于申明内容开始的位置，要不就不包含在内了
+                        if (diagnostic.start.offset - item.range.start.character <= diagnostic.start.offset - minRange.item.range.start.character) {
+                            minRange = { node, item };
+                        } else {
+                            if (diagnostic.start.offset < lsp2tspNumber(minRange.item.range.start.character)) {
+                                minRange = { node, item };
+                            }
+                        }
+                    } else if (item.range.end.line - item.range.start.line <= minRange.item.range.end.line - minRange.item.range.start.line) {
+                        if (minRange.item.range.start.line !== diagnostic.start.line) {
+                            minRange = { node, item };
+                        }
                     }
                 }
             }
@@ -2323,10 +2483,14 @@ export class NaslServer {
                 const prefix = '__ProcessIdentification__';
                 const positions = [];
                 let pos = code.indexOf(prefix);
+                pos = code.indexOf(node.name, pos + prefix.length);
+                // pos === -1：两种情况：
+                // 1、找到最后一个节点了，继续找找不下去了。
+                // 2、创建、删除节点的时候也会找不到（本身这两种操作就不应该进到这个方法）
                 while (pos !== -1) {
-                    pos = code.indexOf(node.name, pos + prefix.length);
                     positions.push(pos);
                     pos = code.indexOf(prefix, pos + prefix.length);
+                    pos = pos === -1 ? pos : code.indexOf(node.name, pos + prefix.length);
                 }
                 positions.shift();
                 // 拿到标识下定义的参数名字
@@ -2373,12 +2537,16 @@ export class NaslServer {
                 let pos = code.indexOf(prefix);
                 // 需要再次定位到processelement对象上，避免process上存在同名参数
                 pos = code.indexOf(node.parentNode.name, pos + prefix.length);
+                pos = pos === -1 ? pos : code.indexOf(node.name, pos + prefix.length);
+                // pos === -1：两种情况：
+                // 1、找到最后一个节点了，继续找找不下去了。
+                // 2、创建、删除节点的时候也会找不到（本身这两种操作就不应该进到这个方法）
                 while (pos !== -1) {
-                    pos = code.indexOf(node.name, pos + prefix.length);
                     positions.push(pos);
                     pos = code.indexOf(prefix, pos + prefix.length);
                     // 需要再次定位到processelement对象上，避免process上存在同名参数
-                    pos = code.indexOf(node.parentNode.name, pos + node.parentNode.name.length);
+                    pos = pos === -1 ? pos : code.indexOf(node.parentNode.name, pos + node.parentNode.name.length);
+                    pos = pos === -1 ? pos : code.indexOf(node.name, pos + prefix.length);
                 }
                 // 拿到标识下定义的参数名字
                 const promises = positions.map((item) => this.references({
@@ -3498,6 +3666,7 @@ export class NaslServer {
                 });
             }
         });
+        console.time('全量标注');
         const typesMap = await this.getQuickInfoNodesTypeMap(nodes, true);
         // console.log(typesMap, 'typesMap')
         console.timeEnd('全量标注');
@@ -3558,7 +3727,7 @@ export class NaslServer {
                 }
             }
             // 旧版本数据查询需要确认是匿名数据结构的 ListTotal 类型
-            if (node instanceof CallQueryComponent && node.ideVersion !== '2.11') {
+            if (node instanceof CallQueryComponent && !node.isAutoInfer()) {
                 const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
                 jsonNode.typeAnnotation = {
                     concept: 'TypeAnnotation',
@@ -3629,7 +3798,7 @@ export class NaslServer {
                     jsonNode.typeAnnotation = (value as TypeAnnotation).toJSON();
                 }
             }
-            if (node instanceof NewComposite && node.typeAnnotation.typeKind === 'anonymousStructure') {
+            if (node instanceof NewComposite && node.typeAnnotation?.typeKind === 'anonymousStructure') {
                 const jsonNode = jsoner.queryNodeByPath(json, node.getNodePath(false));
                 jsonNode.typeAnnotation = (value as TypeAnnotation).toJSON();
             }
@@ -4045,7 +4214,7 @@ export class NaslServer {
         // 当前操作的文件节点
         const { fileNode } = this.getCurrentSource(targetNode);
         // 如果是导入模块就，就引入对应模块,先不处理module和Configuration，下面的内容会自动创建
-        if (!fileNode || fileNode instanceof Module || fileNode instanceof Configuration) {
+        if (!fileNode || fileNode instanceof Module || fileNode instanceof Configuration || fileNode instanceof Integration) {
             // module单独处理
             if (fileNode instanceof Module) {
                 await this.incidentalAction(action, fileNode, targetNode);
@@ -4097,7 +4266,7 @@ export class NaslServer {
                 if (this.changeStackList.length) {
                     this.changeFileNext();
                 } else {
-                    console.log(Array.from(this.filesToCheck));
+                    console.info(Array.from(this.filesToCheck));
                     await this.getDiagnosticRecordsAndPushAll(Array.from(this.filesToCheck));
                     this.filesToCheck.clear();
                 }