@lcap/nasl 3.7.2-beta.4 → 3.7.3-beta.2

package/src/natural/getContext/index.ts

@@ -1,6 +1,6 @@
 import { App, View, Logic, BaseNode, Frontend, Namespace, Module, TypeAnnotation, Structure } from '../../concepts';
 import { shiftState, createCompilerState, TranslatorState, indent } from '../../translator';
-import { getPreDeclaration, getUILib, handleMaterial } from './getUILib';
+import { getPreDeclaration, getUILib, handleMaterial, getExtensionsMaterial } from './getUILib';
 import { getNASLStdlibMap } from './naslStdlibMap';
 
 export interface Snippet {
@@ -89,43 +89,37 @@ export function getNaslUtil() {
   return { code, naslUtil };
 }
 
-export const getNaslUI = (material: { json: any, tsDeclaration: string; } | string, requiredIndexes?: string[]) => {
+export const getNaslUI = (app: App, frontendType: 'pc' | 'h5', material: { basicMaterials: { json: any; tsDeclaration: string; }, extensionMaterials: { name: string; title: string; description: string; tsDescription: string; }[]; } | string, requiredIndexes?: string[]) => {
   const hasModuleIndexList = requiredIndexes?.length > 0;
-  // TODO: 换成动态加载 assets 的方式
-  const uiLib = typeof material === 'string' ? getUILib(material as 'pc' | 'h5') : handleMaterial(material);
+  const uiLib = typeof material === 'string' ? getUILib(material as 'pc' | 'h5') : handleMaterial(material.basicMaterials);
+  const extensionMaterials = typeof material === 'string' ? getExtensionsMaterial(app, frontendType) : material.extensionMaterials || [];
+  uiLib.push(...extensionMaterials);
 
   if (!hasModuleIndexList) {
     const naslUI = uiLib;
     const code = naslUI.map((item, index) => `[3-${index}] ${item.name} | ${item.title} | ${item.description}`).join('\n');
     return { code, naslUI };
-  } else {
-    const preDeclaration = getPreDeclaration();
-    const naslUI = uiLib.filter(
-      (item, index) =>
-        requiredIndexes.includes(`3-${index}`) ||
-        requiredIndexes.includes(item.name) ||
-        item.name.endsWith('LinearLayout') ||
-        item.name.endsWith('Text') ||
-        item.name.endsWith('Link') ||
-        item.name.endsWith('Button')
-    );
-    const code = wrapTSBlock(
-      preDeclaration +
-      '\n' +
-      naslUI
-        .map(
-          (item) =>
-            `/**
- * ${item.name}
- * ${item.title}
- * ${item.description}
- */
-` + item.tsDeclaration
-        )
-        .join('\n')
-    );
-    return { code, naslUI };
   }
+
+  const preDeclaration = getPreDeclaration();
+  const naslUI = uiLib.filter(
+    (item, index) =>
+      requiredIndexes.includes(`3-${index}`) ||
+      item.name.endsWith('LinearLayout') ||
+      item.name.endsWith('Text') ||
+      item.name.endsWith('Link') ||
+      item.name.endsWith('Button')
+  );
+  const code = wrapTSBlock(
+    `${preDeclaration}\n${naslUI.map(
+      (item) =>
+        `/**
+* ${item.name}
+* ${item.title}
+* ${item.description}
+*/
+${item.tsDeclaration}`).join('\n')}`);
+  return { code, naslUI };
 };
 
 export const getNaslUIOld = () => {
@@ -211,7 +205,7 @@ export function getLogics(app: App, currentNode: BaseNode, requiredIndexes?: str
       const needNamespace = requiredIndexes?.length >= 0;
       const tempCode = `${logic?.toNaturalTS({ needNamespace, rename, declaration: true })}`;
       const description = logic?.description || '';
-      code += `[${logicIndex}] ${description ? description + ': ' : ''}\`${tempCode}\`\n`;
+      code += `[${logicIndex}] ${description ? `${description}: ` : ''}\`${tempCode}\`\n`;
       data.push({ description, code: tempCode });
     });
   return { code, appLogics: { namespace, data } };
@@ -252,7 +246,7 @@ export function getModuleInterfaces(app: App, state: TranslatorState, requiredIn
       if (requiredIndexes?.includes(interfaceIndex)) {
         code += getLogicStructures(interface_, 'interface', { description, codeStr: tempCode }, structureNamespace);
       } else {
-        code += `[${interfaceIndex}] ${description ? description + ': ' : ''}\`${tempCode}\`\n`;
+        code += `[${interfaceIndex}] ${description ? `${description}: ` : ''}\`${tempCode}\`\n`;
       }
     });
     logics = { namespace: logicNamespace, data: logicData };
@@ -300,7 +294,7 @@ export function getConnectors(app: App, state: TranslatorState, requiredIndexes?
         if (requiredIndexes?.includes(logicIndex)) {
           code += getLogicStructures(logic, 'connector', { description, codeStr: tempCode }, structureNamespace);
         } else {
-          code += `[${logicIndex}] ${description ? description + ': ' : ''}\`${tempCode}\`\n`;
+          code += `[${logicIndex}] ${description ? `${description}: ` : ''}\`${tempCode}\`\n`;
         }
       });
     });
@@ -318,7 +312,7 @@ export function getConnectors(app: App, state: TranslatorState, requiredIndexes?
         if (requiredIndexes?.includes(logicIndex)) {
           code += getLogicStructures(logic, 'connector', { description, codeStr: tempCode }, structureNamespace);
         } else {
-          code += `[${logicIndex}] ${description ? description + ': ' : ''}\`${tempCode}\`\n`;
+          code += `[${logicIndex}] ${description ? `${description}: ` : ''}\`${tempCode}\`\n`;
         }
       });
     }

package/src/natural/index.ts

@@ -1,3 +1,4 @@
 export * from './genNaturalTS';
 export * from './transformTSCode';
 export * from './transformTS2UI';
+export * from './getContext/getUILib';

package/src/natural/transformTS2UI.ts

@@ -18,6 +18,13 @@ function flatMemberExpression(node: babelTypes.Node): Array<babelTypes.Node> {
     return [...flatMemberExpression(node.object), node.property];
   return [node];
 }
+
+function flatMembers(node: naslTypes.MemberExpression): Array<naslTypes.MemberExpression> {
+  if (node.concept === 'MemberExpression')
+    return [...flatMembers(((node as any)?.object)), node];
+  return [];
+}
+
 function flatMatchPatternsExpression(node: any): Array<babelTypes.Node> {
   if (node.concept === 'BinaryExpression') {
     if (node.operator === '||') {
@@ -64,6 +71,13 @@ function transformTypeAnnotation(node: babelTypes.TSType): naslTypes.TypeAnnotat
         typeNamespace: (node as any).typeNamespace,
       });
     }
+
+    if (['ValidateResult', 'ValidateEvent'].includes(typeName)) {
+      return naslTypes.TypeAnnotation.createReference(typeName, {
+        typeNamespace: 'nasl.ui'
+      });
+    }
+
     if (typeName === 'Any' || typeName === 'any') {
       return undefined;
     }
@@ -218,17 +232,47 @@ function handleNewExpression(calleeName: String, node: any, type?: string) {
     const assignmentLines: any = [];
     node?.arguments?.[0]?.properties.forEach((arg: any, index: number) => {
       properties.push(transformNode2Expression(arg.key));
-      rights.push(new naslTypes.SelectMembers({
-        expression: transformNode2Expression(arg.value)
-      }));
-      if (arg?.value) {
-        assignmentLines.push(new naslTypes.AssignmentLine({
-          leftIndex: [0, index],
-          rightIndex: [index],
+      if (arg.value.type === 'MemberExpression') {
+        const expression = flatMemberExpression(arg.value);
+        const members = flatMembers(transformNode2Expression(arg.value) as any);
+        rights.push(new naslTypes.SelectMembers({
+          expression: transformNode2Expression(expression[0]),
+          members,
+        }));
+        if (arg?.value) {
+          assignmentLines.push(new naslTypes.AssignmentLine({
+            leftIndex: [0, index],
+            rightIndex: [index, index],
+          }));
+        }
+      } else {
+        rights.push(new naslTypes.SelectMembers({
+          expression: transformNode2Expression(arg.value)
         }));
+        if (arg?.value) {
+          assignmentLines.push(new naslTypes.AssignmentLine({
+            leftIndex: [0, index],
+            rightIndex: [index],
+          }));
+        }
       }
     });
-    const typeName = node?.typeParameters?.params?.[0]?.typeName?.name;
+    const parameters = node?.typeParameters?.params?.[0] || {};
+    if (parameters && parameters?.type === 'TSTypeReference' && parameters?.typeName?.type === 'TSQualifiedName') {
+      const { left, right } = parameters?.typeName || {};
+      const typeNamespace = generate(left as any)?.code;
+      const typeName = right?.name;
+      return new naslTypes.NewComposite({
+        typeAnnotation: naslTypes.TypeAnnotation.createReference(typeName, {
+          typeNamespace,
+          typeName
+        }),
+        properties,
+        rights,
+        assignmentLines
+      });
+    }
+    const typeName = parameters?.typeName?.name;
     return new naslTypes.NewComposite({
       typeAnnotation: naslTypes.TypeAnnotation.createReference(typeName, {
         typeNamespace: 'app.dataSources.defaultDS.entities',
@@ -245,14 +289,29 @@ function handleNewExpression(calleeName: String, node: any, type?: string) {
     const assignmentLines: any = [];
     node?.arguments?.[0]?.properties.forEach((arg: any, index: number) => {
       properties.push(transformNode2Expression(arg.key));
-      rights.push(new naslTypes.SelectMembers({
-        expression: transformNode2Expression(arg.value)
-      }));
-      if (arg?.value) {
-        assignmentLines.push(new naslTypes.AssignmentLine({
-          leftIndex: [0, index],
-          rightIndex: [index],
+      if (arg.value.type === 'MemberExpression') {
+        const expression = flatMemberExpression(arg.value);
+        const members = flatMembers(transformNode2Expression(arg.value) as any);
+        rights.push(new naslTypes.SelectMembers({
+          expression: transformNode2Expression(expression[0]),
+          members,
+        }));
+        if (arg?.value) {
+          assignmentLines.push(new naslTypes.AssignmentLine({
+            leftIndex: [0, index],
+            rightIndex: [index, index],
+          }));
+        }
+      } else {
+        rights.push(new naslTypes.SelectMembers({
+          expression: transformNode2Expression(arg.value)
         }));
+        if (arg?.value) {
+          assignmentLines.push(new naslTypes.AssignmentLine({
+            leftIndex: [0, index],
+            rightIndex: [index],
+          }));
+        }
       }
     });
     const parameters = node?.typeParameters?.params?.[0] || {};
@@ -288,14 +347,29 @@ function handleNewExpression(calleeName: String, node: any, type?: string) {
     const assignmentLines: any = [];
     node?.arguments?.[0]?.properties?.forEach((arg: any, index: number) => {
       properties.push(transformNode2Expression(arg.key));
-      rights.push(new naslTypes.SelectMembers({
-        expression: transformNode2Expression(arg.value)
-      }));
-      if (arg?.value) {
-        assignmentLines.push(new naslTypes.AssignmentLine({
-          leftIndex: [0, index],
-          rightIndex: [index],
+      if (arg.value.type === 'MemberExpression') {
+        const expression = flatMemberExpression(arg.value);
+        const members = flatMembers(transformNode2Expression(arg.value) as any);
+        rights.push(new naslTypes.SelectMembers({
+          expression: transformNode2Expression(expression[0]),
+          members,
+        }));
+        if (arg?.value) {
+          assignmentLines.push(new naslTypes.AssignmentLine({
+            leftIndex: [0, index],
+            rightIndex: [index, index],
+          }));
+        }
+      } else {
+        rights.push(new naslTypes.SelectMembers({
+          expression: transformNode2Expression(arg.value)
         }));
+        if (arg?.value) {
+          assignmentLines.push(new naslTypes.AssignmentLine({
+            leftIndex: [0, index],
+            rightIndex: [index],
+          }));
+        }
       }
       structureProperties.push(new naslTypes.StructureProperty({
         name: arg?.key?.name,
@@ -695,7 +769,7 @@ function transformNode2Expression(node: babelTypes.Node, type?: string): any {
     const callee = flatMemberExpression(node);
     const calleeName = generate(node)?.code;
     if (calleeName?.includes('app.enums')) {
-      const name = (callee?.[3] as babelTypes.StringLiteral)?.value || (callee?.[3] as babelTypes.Identifier)?.name || (callee?.[3] as babelTypes.NumericLiteral)?.value
+      const name = (callee?.[3] as babelTypes.StringLiteral)?.value || (callee?.[3] as babelTypes.Identifier)?.name || (callee?.[3] as babelTypes.NumericLiteral)?.value;
       return new naslTypes.MemberExpression({
         object: new naslTypes.Identifier({
           namespace: 'app.enums',
@@ -888,7 +962,7 @@ function transformNode2Logic(node: babelTypes.FunctionDeclaration, name?: string
     const param = transformParam(item);
     if (param && param.name !== 'event' && !curLogic.params.find((_: any) => _.name === param.name)) curLogic.addParam(param);
   });
-  statements.forEach((item, index: number) => {
+  statements.forEach((item) => {
     if (item.type === 'ReturnStatement' && item?.argument) {
       if (!curLogic.returns.length) {
         curLogic.returns.push(new naslTypes.Return({
@@ -901,7 +975,7 @@ function transformNode2Logic(node: babelTypes.FunctionDeclaration, name?: string
         }),
         right: transformNode2Expression(item.argument, 'logic')
       });
-      curLogic.insertItemInBodyAt(logicItem, index + 1);
+      curLogic.insertItemInBodyAt(logicItem, curLogic.body.length - 1);
     } else {
       let logicItem = transformNode2Expression(item, 'logic');
       if (logicItem) {
@@ -911,8 +985,10 @@ function transformNode2Logic(node: babelTypes.FunctionDeclaration, name?: string
             left: new naslTypes.Identifier({ name: logicItem?.name }),
             right: (logicItem as any).defaultValue?.expression || '',
           });
+          if (logicItem.right) curLogic.insertItemInBodyAt(logicItem, curLogic.body.length - 1);
+        } else {
+          curLogic.insertItemInBodyAt(logicItem, curLogic.body.length - 1);
         }
-        curLogic.insertItemInBodyAt(logicItem, index + 1);
       }
     }
   });
@@ -934,9 +1010,17 @@ function transformNode2Attribute(node: any): any {
     item = {
       name: node.key.name,
       type: 'string',
-      value: generate(node.value.body.property).code,
+      value: generate(node.value.body).code,
     };
-  } else {
+  } else if (['CallExpression'].includes(node.value.type) && node.value?.callee?.name === 'sync') {
+    item = {
+      name: node.key.name,
+      type: 'dynamic',
+      sync: true,
+      expression: transformNode2Expression(node.value.arguments[0]),
+    };
+  }
+  else {
     // ['TemplateLiteral', 'BooleanLiteral', 'NullLiteral', 'CallExpression']
     item = {
       name: node.key.name,
@@ -1154,7 +1238,7 @@ function transformNode2View(node: babelTypes.FunctionDeclaration, root?: babelTy
       const action = (item.argument as any)?.callee?.name;
       const selectedNodeName = (item.argument as any).arguments?.[0]?.property?.name;
       const newNodeBackup = cloneDeep(viewItem);
-      (viewItem as any).aiParams = { selectedNodeName, action, concept: 'ViewElement', object: newNodeBackup};
+      (viewItem as any).aiParams = { selectedNodeName, action, concept: 'ViewElement', object: newNodeBackup };
     }
     if (item.type === 'ReturnStatement' && item?.argument?.type === 'ArrayExpression') {
       viewItem?.forEach((element: any) => {
@@ -1173,7 +1257,7 @@ function transformNode2View(node: babelTypes.FunctionDeclaration, root?: babelTy
     }
   });
   // console.log("lemon ~ 转换出的 view:", view);
-  return { view, json };
+  return { view: view.toJSON(), json };
 }
 
 /**
@@ -1197,12 +1281,48 @@ const transformTS2View = (tsCode: string): any => {
   return transformNode2View(func, root);
 };
 
-export function tryTransformTS2UI(tsCode: string): any {
+const handleNodeName = (curView: any, object: any) => {
+  const list = [];
+  if (object.concept === 'ViewElement') {
+    const oldName = object.name;
+    const newName = curView?.getViewElementUniqueNameOld(oldName);
+    if (oldName !== newName) {
+      object.name = `${newName}_${genHash(new Date().getTime() + newName)}`;
+      list.push({ oldName, newName: object.name });
+    }
+    if (object?.children?.length) {
+      object.children.forEach((child: any) => {
+        handleNodeName(curView, child);
+      });
+    }
+  }
+  return { object, list };
+};
+
+export function tryTransformTS2UI(tsCode: string, curView?: any): any {
   if (tsCode.includes('```')) {
     const cap = tsCode.match(/```.*\n([\s\S]+?)```/);
     if (cap)
       tsCode = cap[1].trim();
   }
+
+  if (!curView) return transformTS2View(tsCode);
+  const newView = new naslTypes.View(curView);
+  const { json } = transformTS2View(tsCode);
+  const replaceNameList = [] as any;
+  const selectedNodeNames = [] as any;
+  json.forEach((item: any) => {
+    if (item.concept === 'ViewElement' && item.action !== 'remove') {
+      selectedNodeNames.push(item.selectedNodeName.replace('$refs.', ''));
+      const { list } = handleNodeName(newView, item.object.toJSON());
+      replaceNameList.push(...list);
+    }
+  });
+  replaceNameList.forEach((item: any) => {
+    if (!selectedNodeNames.includes(item.oldName)) {
+      tsCode = tsCode.replace(new RegExp(item.oldName, 'g'), item.newName);
+    }
+  });
   return transformTS2View(tsCode);
 }
 

package/src/natural/transformTSCode.ts

@@ -29,6 +29,13 @@ function flatMemberExpression(node: babelTypes.Node): Array<babelTypes.Node> {
     return [...flatMemberExpression(node.object), node.property];
   return [node];
 }
+
+function flatMembers(node: naslTypes.MemberExpression): Array<naslTypes.MemberExpression> {
+  if (node.concept === 'MemberExpression')
+    return [...flatMembers(((node as any)?.object)), node];
+  return [];
+}
+
 function flatMatchPatternsExpression(node: any): Array<babelTypes.Node> {
   if (node.concept === 'BinaryExpression') {
     if (node.operator === '||') {
@@ -79,6 +86,13 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
           typeNamespace: (node as any).typeNamespace,
         });
       }
+
+      if (['ValidateResult', 'ValidateEvent'].includes(typeName)) {
+        return naslTypes.TypeAnnotation.createReference(typeName, {
+          typeNamespace: 'nasl.ui'
+        });
+      }
+
       if (typeName === 'Any' || typeName === 'any') {
         return undefined;
       }
@@ -204,17 +218,47 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
       const assignmentLines: any = [];
       node?.arguments?.[0]?.properties.forEach((arg: any, index: number) => {
         properties.push(transformLogicNode(arg.key));
-        rights.push(new naslTypes.SelectMembers({
-          expression: transformLogicNode(arg.value)
-        }));
-        if (arg?.value) {
-          assignmentLines.push(new naslTypes.AssignmentLine({
-            leftIndex: [0, index],
-            rightIndex: [index],
+        if (arg.value.type === 'MemberExpression') {
+          const expression = flatMemberExpression(arg.value);
+          const members = flatMembers(transformLogicNode(arg.value) as any);
+          rights.push(new naslTypes.SelectMembers({
+            expression: transformLogicNode(expression[0]),
+            members,
           }));
+          if (arg?.value) {
+            assignmentLines.push(new naslTypes.AssignmentLine({
+              leftIndex: [0, index],
+              rightIndex: [index, index],
+            }));
+          }
+        } else {
+          rights.push(new naslTypes.SelectMembers({
+            expression: transformLogicNode(arg.value)
+          }));
+          if (arg?.value) {
+            assignmentLines.push(new naslTypes.AssignmentLine({
+              leftIndex: [0, index],
+              rightIndex: [index],
+            }));
+          }
         }
       });
-      const typeName = node?.typeParameters?.params?.[0]?.typeName?.name;
+      const parameters = node?.typeParameters?.params?.[0] || {};
+      if (parameters && parameters?.type === 'TSTypeReference' && parameters?.typeName?.type === 'TSQualifiedName') {
+        const { left, right } = parameters?.typeName || {};
+        const typeNamespace = generate(left as any)?.code;
+        const typeName = right?.name;
+        return new naslTypes.NewComposite({
+          typeAnnotation: naslTypes.TypeAnnotation.createReference(typeName, {
+            typeNamespace,
+            typeName
+          }),
+          properties,
+          rights,
+          assignmentLines
+        });
+      }
+      const typeName = parameters?.typeName?.name;
       return new naslTypes.NewComposite({
         typeAnnotation: naslTypes.TypeAnnotation.createReference(typeName, {
           typeNamespace: 'app.dataSources.defaultDS.entities',
@@ -231,14 +275,29 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
       const assignmentLines: any = [];
       node?.arguments?.[0]?.properties.forEach((arg: any, index: number) => {
         properties.push(transformLogicNode(arg.key));
-        rights.push(new naslTypes.SelectMembers({
-          expression: transformLogicNode(arg.value)
-        }));
-        if (arg?.value) {
-          assignmentLines.push(new naslTypes.AssignmentLine({
-            leftIndex: [0, index],
-            rightIndex: [index],
+        if (arg.value.type === 'MemberExpression') {
+          const expression = flatMemberExpression(arg.value);
+          const members = flatMembers(transformLogicNode(arg.value) as any);
+          rights.push(new naslTypes.SelectMembers({
+            expression: transformLogicNode(expression[0]),
+            members,
+          }));
+          if (arg?.value) {
+            assignmentLines.push(new naslTypes.AssignmentLine({
+              leftIndex: [0, index],
+              rightIndex: [index, index],
+            }));
+          }
+        } else {
+          rights.push(new naslTypes.SelectMembers({
+            expression: transformLogicNode(arg.value)
           }));
+          if (arg?.value) {
+            assignmentLines.push(new naslTypes.AssignmentLine({
+              leftIndex: [0, index],
+              rightIndex: [index],
+            }));
+          }
         }
       });
       const parameters = node?.typeParameters?.params?.[0] || {};
@@ -274,14 +333,29 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
       const assignmentLines: any = [];
       node?.arguments?.[0]?.properties?.forEach((arg: any, index: number) => {
         properties.push(transformLogicNode(arg.key));
-        rights.push(new naslTypes.SelectMembers({
-          expression: transformLogicNode(arg.value)
-        }));
-        if (arg?.value) {
-          assignmentLines.push(new naslTypes.AssignmentLine({
-            leftIndex: [0, index],
-            rightIndex: [index],
+        if (arg.value.type === 'MemberExpression') {
+          const expression = flatMemberExpression(arg.value);
+          const members = flatMembers(transformLogicNode(arg.value) as any);
+          rights.push(new naslTypes.SelectMembers({
+            expression: transformLogicNode(expression[0]),
+            members,
           }));
+          if (arg?.value) {
+            assignmentLines.push(new naslTypes.AssignmentLine({
+              leftIndex: [0, index],
+              rightIndex: [index, index],
+            }));
+          }
+        } else {
+          rights.push(new naslTypes.SelectMembers({
+            expression: transformLogicNode(arg.value)
+          }));
+          if (arg?.value) {
+            assignmentLines.push(new naslTypes.AssignmentLine({
+              leftIndex: [0, index],
+              rightIndex: [index],
+            }));
+          }
         }
         structureProperties.push(new naslTypes.StructureProperty({
           name: arg?.key?.name,
@@ -367,7 +441,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
           // const _typeAnnotation = node?.typeParameters?.params?.length > 0 ? naslTypes.TypeAnnotation.createGeneric('List', {
           //   typeArguments: node?.typeParameters?.params.map((curType: any) => transformTypeAnnotation({ ...curType })),
           // }) : null;
-          let code = generate(node.arguments[0] as any).code.trim().slice(1, -1)
+          let code = generate(node.arguments[0] as any).code.trim().slice(1, -1);
           code = code?.replace(/app\.enums\.(\w+)\[(\d+)\]/g, "app.enums.$1.$2").replace(/app\.enums\.(\w+)\['(\w+)'\]/g, "app.enums.$1.$2");
           return new naslTypes.OqlQueryComponent({
             dataSource: 'app.dataSources.defaultDS',
@@ -426,7 +500,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
           let _callee = (callee[0] as any).callee;
           while (_callee.type === 'CallExpression')
             _callee = _callee.callee;
-          curCalleeName = _callee.property.name
+          curCalleeName = _callee.property.name;
         }
         const argument = callee.length === 3 ? node.arguments : (callee[0] as any).arguments as any;
 
@@ -753,7 +827,7 @@ export function transformTSCode(tsCode: string, contextLogicName: string, type?:
       const callee = flatMemberExpression(node);
       const calleeName = generate(node)?.code;
       if (calleeName?.includes('app.enums')) {
-        const name = (callee?.[3] as babelTypes.StringLiteral)?.value || (callee?.[3] as babelTypes.Identifier)?.name || (callee?.[3] as babelTypes.NumericLiteral)?.value
+        const name = (callee?.[3] as babelTypes.StringLiteral)?.value || (callee?.[3] as babelTypes.Identifier)?.name || (callee?.[3] as babelTypes.NumericLiteral)?.value;
         return new naslTypes.MemberExpression({
           object: new naslTypes.Identifier({
             namespace: 'app.enums',

package/src/server/getLogics.ts

@@ -188,9 +188,9 @@ export function getLogicsSync(node: CallLogic | BindEvent | Identifier | Logic,
       // 连接器 相关迁移到了 conenctorDependencies 下，因此这边需要扩展
       const dependencies = [
         ...app.dependencies,
-        ...(app.connectorDependencies || [])
+        // ...(app.connectorDependencies || [])
       ]; //.filter((d) => d.enable);
-      const extensions = [...app.dependencies, ...(app.connectorDependencies || [])]
+      const extensions = [...app.dependencies]
         .map((dep) => moduleToLogicNamesapce(dep, app.overriddenLogics))
         .filter((item) => item.logics && item.logics.length);
       const dependEntityNs: Namespace[] = [];
@@ -509,12 +509,9 @@ export function getLogicsSync(node: CallLogic | BindEvent | Identifier | Logic,
     return result;
   }
   if (node?.concept === 'Identifier') {
-    // 之前 连接器 Connector 相关也存在与 app.dependencies 下，
-    // 现在迁移到 app.connectorDependencies 下，
-    // 为保证上下游逻辑与之前保持一致，这边做相应的扩展
     const extensions = [
       ...app.dependencies,
-      ...(app.connectorDependencies || [])
+      // ...(app.connectorDependencies || [])
     ]
       .map((dep) => moduleToLogicNamesapce(dep, app.overriddenLogics))
       .filter((item) => item.logics && item.logics.length);

package/src/server/naslServer.ts

@@ -36,6 +36,7 @@ import {
   EnumItem,
   Param,
   Process,
+  ProcessV2,
   Interface,
   Argument,
   ViewElement,
@@ -2407,6 +2408,47 @@ class NaslServer {
       yield* utils.wrapIteratorToGenerator(fileNode.sourceMap.entries(), ([node, value]) => {
         this.checkNodeError(node, diagnostics);
       });
+    } else if (fileNode instanceof ProcessV2) {
+      yield* utils.wrapIteratorToGenerator(fileNode.sourceMap.entries(), function* wrapIterator([node, value]) {
+        if (node instanceof Return || node instanceof Variable) {
+          const nodeTypeName = node.concept === 'Return' ? '输出参数' : '局部变量';
+          if (!node.typeAnnotation && !node.__TypeAnnotation) {
+            let used = false;
+            fileNode?.sourceMap.forEach((valueIn, nodeIn) => {
+              if (!used && nodeIn && (nodeIn instanceof BatchAssignment || (nodeIn instanceof Assignment && nodeIn.left?.name))) {
+                let jsCode = '';
+                try {
+                  jsCode = nodeIn.toJS();
+                } catch (err) {
+                  self.logger.error(err);
+                }
+                if (jsCode.startsWith(`${node.name} = `)) {
+                  used = true;
+                  if (!nodeIn.tsErrorDetail) {
+                    const diagnostic = {
+                      node: nodeIn,
+                      severity: 'error',
+                      message: `${nodeIn.label || ''}左边 ${node.name} 未设置类型，右边必须为有返回值的内容。`,
+                    };
+                    nodeIn.tsErrorDetail = diagnostic;
+                    diagnostics.push(diagnostic);
+                  }
+                }
+              }
+            });
+            const msg = used ? '必须赋值有返回值的内容。' : '未设置类型或未赋值。直接赋值系统可以自动推断类型。';
+            const diagnostic = {
+              node,
+              severity: 'error',
+              message: `${nodeTypeName} ${node.name} ${msg}`,
+            };
+            node.__aStructureError = diagnostic;
+            diagnostics.push(diagnostic);
+          } else {
+            node.__aStructureError = null;
+          }
+        }
+      });
     } else if (fileNode instanceof Connection) {
       const connectorPropertyNames = NaslServer.getPropertyNames(fileNode);
       const connectionPropertyNames = NaslServer.getPropertyNames(fileNode?.connector);