digitalsee-ai-flow-cli 0.9.23-beta → 0.9.29-beta

package/dist/services/portValidator.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_PORT_TYPE = void 0;
 exports.validateFlowPorts = validateFlowPorts;
 exports.validateSingleEdge = validateSingleEdge;
+exports.resolveEdgeSaveType = resolveEdgeSaveType;
 const nodeSchemaCache_1 = require("@/utils/nodeSchemaCache");
 const classicNodePorts_1 = require("@/services/classicNodePorts");
 exports.DEFAULT_PORT_TYPE = 'main';
@@ -11,7 +12,6 @@ const normalizeNodeKeyList = (value) => Array.isArray(value)
     : [];
 const normalizePort = (port) => ({
     name: port.name,
-    displayName: port.display_name || port.name,
     type: typeof port.type === 'string' && port.type.trim() ? port.type.trim() : exports.DEFAULT_PORT_TYPE,
     required: Boolean(port.required),
     maxConnections: port.max_connections !== undefined &&
@@ -25,17 +25,21 @@ const normalizePort = (port) => ({
     deniedTargetNodeKeys: normalizeNodeKeyList(port.denied_target_node_keys),
 });
 const displayHandle = (handle) => handle || '(未指定)';
-const formatHandleList = (ports) => ports.length
-    ? ports
-        .map((p) => p.displayName && p.displayName !== p.name ? `${p.name}（${p.displayName}）` : p.name)
-        .join('、')
-    : '（无）';
+/** 错误信息附带的合法端口清单提示（如 "，合法输出端口: true, false"） */
+const formatPortHint = (ports) => ports.length ? `，合法端口: ${ports.map((p) => p.name).join(', ')}` : '（该节点无可用端口）';
 const includesKey = (keys, identity) => Boolean(identity && keys.includes(identity));
 const rejectedByAllowlist = (keys, identity) => Boolean(keys.length && !includesKey(keys, identity));
+/** 协议/type 列表交集匹配（大小写不敏感；对齐 RCS connectionCheck 多协议兼容逻辑） */
+function protocolListsOverlap(sourceType, targetType) {
+    const sourceList = sourceType.split(',').map((p) => p.trim().toLowerCase());
+    const targetList = targetType.split(',').map((p) => p.trim().toLowerCase());
+    return sourceList.some((sp) => targetList.includes(sp));
+}
 /** 端口间协议/白黑名单规则校验（不含 max_connections 与 required，二者按端口聚合检查） */
 function checkPortRules(sourcePort, targetPort, sourceIdentity, targetIdentity) {
-    // 协议/type 比较大小写不敏感（对齐 RCS connectionCheck；对存量只放宽不收紧）
-    if (sourcePort.type.toLowerCase() !== targetPort.type.toLowerCase()) {
+    // 协议/type 比较大小写不敏感，支持逗号分隔多协议列表交集（对齐 RCS connectionCheck）
+    if (sourcePort.type.toLowerCase() !== targetPort.type.toLowerCase() &&
+        !protocolListsOverlap(sourcePort.type, targetPort.type)) {
         return 'PORT_TYPE_MISMATCH';
     }
     // 黑名单优先于白名单：同一个 node key 同时出现时必须拒绝
@@ -81,6 +85,30 @@ function countPortConnections(edges, nodeId, portName, side) {
             edge.source !== edge.target);
     }).length;
 }
+const normalizeClassicPort = (port) => ({
+    name: port.name,
+    type: port.type || exports.DEFAULT_PORT_TYPE,
+    required: false,
+    maxConnections: port.maxConnections,
+    allowedSourceNodeKeys: [],
+    allowedTargetNodeKeys: [],
+    deniedSourceNodeKeys: [],
+    deniedTargetNodeKeys: [],
+});
+/** classic 端口表来源：无 node_schema 身份的节点用 node_type 解析回退端口 */
+function buildClassicEntry(node) {
+    const classic = (0, classicNodePorts_1.resolveClassicNodePorts)(node);
+    if (!classic)
+        return null;
+    const nodeId = node.n_id || node.id;
+    return {
+        nodeId,
+        schemaKey: node.node_type || 'ActionNode',
+        inputs: classic.inputs.map(normalizeClassicPort),
+        outputs: classic.outputs.map(normalizeClassicPort),
+        classicNode: node,
+    };
+}
 async function resolveNodeSchemas(nodes) {
     const entries = new Map();
     const unresolved = [];
@@ -88,34 +116,32 @@ async function resolveNodeSchemas(nodes) {
         const nodeId = node.n_id || node.id;
         const actionKey = node.action_key;
         const actionVer = node.action_ver;
-        if (actionKey && actionVer !== undefined && actionVer !== null) {
-            // NodePackage 节点：远端 schema + switch 实例分支派生 + Loop/SelfLoop 自环兜底
-            let schema = await (0, nodeSchemaCache_1.getNodePackageSchema)(String(actionKey), Number(actionVer));
-            if (!schema) {
-                unresolved.push({ nodeId, actionKey: String(actionKey), actionVer: Number(actionVer) });
-                return;
+        // legacy 节点（无 action_key/action_ver，即无 node_schema 身份）回退 classic 端口表
+        if (!actionKey || actionVer === undefined || actionVer === null) {
+            const classicEntry = buildClassicEntry(node);
+            if (classicEntry) {
+                entries.set(nodeId, classicEntry);
             }
-            schema = (0, classicNodePorts_1.applySwitchBranchesToSchema)(schema, node);
-            entries.set(nodeId, {
-                nodeId,
-                schemaKey: schema.key,
-                inputs: (schema.inputs || []).map(normalizePort),
-                outputs: (schema.outputs || []).map(normalizePort),
-                autoConnect: (0, classicNodePorts_1.getAutoConnectRulesForNodeType)(node.node_type),
-            });
             return;
         }
-        // classic/legacy 节点：内置端口表（未知 node_type 跳过，避免误报）
-        const classic = (0, classicNodePorts_1.resolveClassicNodeSchema)(node);
-        if (classic) {
-            entries.set(nodeId, {
-                nodeId,
-                schemaKey: classic.schemaKey,
-                inputs: classic.inputs.map(normalizePort),
-                outputs: classic.outputs.map(normalizePort),
-                autoConnect: classic.autoConnect,
-            });
+        const schema = await (0, nodeSchemaCache_1.getNodePackageSchema)(String(actionKey), Number(actionVer));
+        if (!schema) {
+            // schema 拉取失败：有 classic 端口表则回退，否则记入 unresolved
+            const classicEntry = buildClassicEntry(node);
+            if (classicEntry) {
+                entries.set(nodeId, classicEntry);
+                return;
+            }
+            unresolved.push({ nodeId, actionKey: String(actionKey), actionVer: Number(actionVer) });
+            return;
         }
+        entries.set(nodeId, {
+            nodeId,
+            schemaKey: schema.key,
+            inputs: (schema.inputs || []).map(normalizePort),
+            outputs: (schema.outputs || []).map(normalizePort),
+            classicNode: null,
+        });
     }));
     return { entries, unresolved };
 }
@@ -129,29 +155,31 @@ function validateEdge(edge, sourceEntry, targetEntry, allEdges) {
         targetHandle: edge.targetHandle,
     };
     if (edge.source === edge.target) {
-        // 自环边须命中节点声明的 autoConnect 配对（如 LOOP 的 loop → input）才放行
-        const allowed = sourceEntry.autoConnect.some((rule) => rule.source === edge.sourceHandle && rule.target === edge.targetHandle);
+        // 自环必须命中节点声明的 auto_connect 规则（rcs connectionCheck.ts:43-56 语义，
+        // 如 LoopNode/SelfLoopNode 的 loop → input）
+        const selfNode = sourceEntry.classicNode ?? null;
+        const allowed = selfNode !== null &&
+            (0, classicNodePorts_1.isClassicSelfConnectionAllowed)(selfNode, edge.sourceHandle || exports.DEFAULT_PORT_TYPE, edge.targetHandle || exports.DEFAULT_PORT_TYPE);
         if (!allowed) {
-            const hint = sourceEntry.autoConnect.length
-                ? `；允许的自环端口对: ${sourceEntry.autoConnect
-                    .map((rule) => `${rule.source} → ${rule.target}`)
-                    .join('、')}`
-                : '';
             violations.push({
                 ...base,
                 code: 'SELF_CONNECTION_NOT_ALLOWED',
-                message: `节点 ${edge.source} 不能连接到自身${hint}`,
+                message: `节点 ${edge.source} 不能连接到自身（端口对未在 auto_connect 规则中声明）`,
             });
             return violations;
         }
-        // 命中 autoConnect：放行并继续端口存在性 / type / max 校验
     }
-    const sourcePort = sourceEntry.outputs.find((p) => p.name === (edge.sourceHandle || exports.DEFAULT_PORT_TYPE));
+    let sourcePort = sourceEntry.outputs.find((p) => p.name === (edge.sourceHandle || exports.DEFAULT_PORT_TYPE));
+    // classic slave 桩方向翻转（RCS 6fc6de5）：Agent/Browser 的 ai_* 入桩在画布连线中
+    // 以边源形态出现（agent → tool），源端口查找需回退 classic 入桩表
+    if (!sourcePort && sourceEntry.classicNode) {
+        sourcePort = sourceEntry.inputs.find((p) => p.name === (edge.sourceHandle || exports.DEFAULT_PORT_TYPE));
+    }
     if (!sourcePort) {
         violations.push({
             ...base,
             code: 'SOURCE_PORT_NOT_FOUND',
-            message: `源节点不存在输出端口 ${displayHandle(edge.sourceHandle)}，可用输出端口: ${formatHandleList(sourceEntry.outputs)}`,
+            message: `源节点不存在输出端口 ${displayHandle(edge.sourceHandle)}${formatPortHint(sourceEntry.outputs)}`,
         });
         return violations;
     }
@@ -160,7 +188,7 @@ function validateEdge(edge, sourceEntry, targetEntry, allEdges) {
         violations.push({
             ...base,
             code: 'TARGET_PORT_NOT_FOUND',
-            message: `目标节点不存在输入端口 ${displayHandle(edge.targetHandle)}，可用输入端口: ${formatHandleList(targetEntry.inputs)}`,
+            message: `目标节点不存在输入端口 ${displayHandle(edge.targetHandle)}${formatPortHint(targetEntry.inputs)}`,
         });
         return violations;
     }
@@ -213,10 +241,11 @@ function validateRequiredInputs(entries, edges) {
     return violations;
 }
 /**
- * 对 flow 全量 nodes + edges 做 node_schema 端口级校验。
+ * 对 flow 全量 nodes + edges 做端口级校验。
  *
- * classic 节点（无 action_key/action_ver）按内置端口表（classicNodePorts）参与校验，
- * 未知 node_type 的 legacy 节点跳过；NodePackage schema 拉取失败记入 unresolvedNodes 并跳过。
+ * NodePackage 节点优先走 node_schema；legacy 节点（无 action_key/action_ver）
+ * 回退 classicNodePorts 静态端口表（未知 node_type 跳过，行为不回退）；
+ * schema 拉取失败且无 classic 端口表的节点记入 unresolvedNodes 并跳过。
  */
 async function validateFlowPorts(input) {
     const { entries, unresolved } = await resolveNodeSchemas(input.nodes);
@@ -224,7 +253,7 @@ async function validateFlowPorts(input) {
     for (const edge of input.edges) {
         const sourceEntry = entries.get(edge.source);
         const targetEntry = entries.get(edge.target);
-        // 只有两端都有 node_schema 时才做端口级校验（legacy 端跳过，避免误报）
+        // 只有两端都能解析端口表（node_schema 或 classic 回退）时才做端口级校验
         if (sourceEntry && targetEntry) {
             violations.push(...validateEdge(edge, sourceEntry, targetEntry, input.edges));
         }
@@ -238,8 +267,7 @@ async function validateFlowPorts(input) {
 }
 /**
  * 单边预检：校验一条准备创建的边（尚未加入现有 edges）。
- * 两端均可解析端口（NodePackage schema 或 classic 内置表）时才校验；
- * 任一端为未知 node_type 的 legacy 节点返回空数组。
+ * 两端任一节点无法解析端口表（node_schema 或 classic 均失败）时返回空数组。
  */
 async function validateSingleEdge(input) {
     const { entries } = await resolveNodeSchemas(input.nodes);
@@ -257,4 +285,26 @@ async function validateSingleEdge(input) {
     };
     return validateEdge(edge, sourceEntry, targetEntry, [...input.existingEdges, edge]);
 }
+/**
+ * 连线保存 type 解析（对齐 RCS EdgeFactory）：NodePackage 端 schema 上 handle
+ * 对应端口声明的 type 优先（source/target 任一命中），否则回退 main。
+ */
+async function resolveEdgeSaveType(nodes, edge) {
+    const findNode = (id) => nodes.find((n) => (n.n_id || n.id) === id);
+    const sourceNode = findNode(edge.source);
+    if (sourceNode?.action_key && sourceNode.action_ver !== undefined) {
+        const schema = await (0, nodeSchemaCache_1.getNodePackageSchema)(String(sourceNode.action_key), Number(sourceNode.action_ver));
+        const port = schema?.outputs?.find((p) => p.name === ((0, classicNodePorts_1.normalizeLegacyHandleName)(edge.sourceHandle) || exports.DEFAULT_PORT_TYPE));
+        if (port?.type)
+            return port.type;
+    }
+    const targetNode = findNode(edge.target);
+    if (targetNode?.action_key && targetNode.action_ver !== undefined) {
+        const schema = await (0, nodeSchemaCache_1.getNodePackageSchema)(String(targetNode.action_key), Number(targetNode.action_ver));
+        const port = schema?.inputs?.find((p) => p.name === ((0, classicNodePorts_1.normalizeLegacyHandleName)(edge.targetHandle) || exports.DEFAULT_PORT_TYPE));
+        if (port?.type)
+            return port.type;
+    }
+    return exports.DEFAULT_PORT_TYPE;
+}
 //# sourceMappingURL=portValidator.js.map