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

package/dist/services/portValidator.js

@@ -12,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 &&
@@ -26,11 +25,8 @@ 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 多协议兼容逻辑） */
@@ -89,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 = [];
@@ -96,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 };
 }
@@ -137,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;
     }
@@ -168,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;
     }
@@ -220,33 +240,25 @@ function validateRequiredInputs(entries, edges) {
     }
     return violations;
 }
-/** 边 handle 规范化：废弃 handle 名（chat_model/memory/tools 等）替换为新名（对齐 RCS 加载迁移） */
-function normalizeEdgeHandles(edges) {
-    return edges.map((edge) => ({
-        ...edge,
-        sourceHandle: (0, classicNodePorts_1.normalizeLegacyHandleName)(edge.sourceHandle),
-        targetHandle: (0, classicNodePorts_1.normalizeLegacyHandleName)(edge.targetHandle),
-    }));
-}
 /**
- * 对 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);
-    const edges = normalizeEdgeHandles(input.edges);
     const violations = [];
-    for (const edge of edges) {
+    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, edges));
+            violations.push(...validateEdge(edge, sourceEntry, targetEntry, input.edges));
         }
     }
-    violations.push(...validateRequiredInputs(entries, edges));
+    violations.push(...validateRequiredInputs(entries, input.edges));
     return {
         violations,
         checkedNodeCount: entries.size,
@@ -255,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);
@@ -269,19 +280,14 @@ async function validateSingleEdge(input) {
         id: '(new-edge)',
         source: input.newEdge.source,
         target: input.newEdge.target,
-        sourceHandle: (0, classicNodePorts_1.normalizeLegacyHandleName)(input.newEdge.sourceHandle),
-        targetHandle: (0, classicNodePorts_1.normalizeLegacyHandleName)(input.newEdge.targetHandle),
+        sourceHandle: input.newEdge.sourceHandle,
+        targetHandle: input.newEdge.targetHandle,
     };
-    return validateEdge(edge, sourceEntry, targetEntry, [
-        ...normalizeEdgeHandles(input.existingEdges),
-        edge,
-    ]);
+    return validateEdge(edge, sourceEntry, targetEntry, [...input.existingEdges, edge]);
 }
 /**
- * 解析连线的保存 type（对齐 RCS EdgeFactory ef7558b 语义）：
- * 仅 NodePackage 节点的 handle 参与——源侧为 NP 时取其 schema 输出项的 type，
- * 否则目标侧为 NP 时取其 schema 输入项的 type，都不是则 'main'。
- * classic 节点的协议不写入连线 type。
+ * 连线保存 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);