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

package/dist/services/fieldTypeRegistry.js

@@ -0,0 +1,496 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAuthToken = generateAuthToken;
+exports.resetFieldTypesCache = resetFieldTypesCache;
+exports.findFieldTypeContract = findFieldTypeContract;
+exports.isKnownFieldType = isKnownFieldType;
+exports.getDefaultValueForType = getDefaultValueForType;
+exports.validateByContract = validateByContract;
+exports.validateNodeSchemaValueByContract = validateNodeSchemaValueByContract;
+exports.getDefaultValueForSchemaField = getDefaultValueForSchemaField;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const conditionRules_1 = require("@/utils/conditionRules");
+const config_1 = require("@/utils/config");
+const FIELD_TYPES_FILE_PREFIX = 'field-types';
+function isPlainObject(value) {
+    return (value !== null &&
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        Object.prototype.toString.call(value) === '[object Object]');
+}
+function typeError(field, rule, message, sample) {
+    return {
+        field: String(field.name || ''),
+        rule,
+        message: `${field.page_control || field.type} 字段 "${field.display_name || field.name}" ${message}`,
+        sample,
+    };
+}
+const TOKEN_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+/** 生成 32 位随机 token（对齐 rcs AuthTokenField 行为） */
+function generateAuthToken(length = 32) {
+    let token = '';
+    for (let i = 0; i < length; i++) {
+        token += TOKEN_CHARS[Math.floor(Math.random() * TOKEN_CHARS.length)];
+    }
+    return token;
+}
+const HH_MM_SS_PATTERN = /^([01]\d|2[0-3]):[0-5]\d:[0-5]\d$/;
+function validateGuardRules(value, field) {
+    if (!Array.isArray(value)) {
+        return [
+            typeError(field, 'type', `期望 GuardRule[] (array) 类型，实际为 ${typeof value}`, (0, conditionRules_1.safeSample)(value)),
+        ];
+    }
+    const errors = [];
+    value.forEach((rule, i) => {
+        if (!isPlainObject(rule)) {
+            errors.push(typeError(field, 'type', `的第 ${i} 项期望 object 类型，实际为 ${typeof rule}`, (0, conditionRules_1.safeSample)(rule)));
+        }
+    });
+    return errors;
+}
+function validateMultiRowExtract(value, field) {
+    if (!Array.isArray(value)) {
+        return [typeError(field, 'type', `期望 array 类型，实际为 ${typeof value}`, (0, conditionRules_1.safeSample)(value))];
+    }
+    const errors = [];
+    value.forEach((row, i) => {
+        if (!isPlainObject(row)) {
+            errors.push(typeError(field, 'type', `的第 ${i} 项期望 object 类型，实际为 ${typeof row}`, (0, conditionRules_1.safeSample)(row)));
+        }
+    });
+    return errors;
+}
+function validateKeyValueArray(value, field) {
+    if (!Array.isArray(value)) {
+        return [
+            typeError(field, 'type', `期望 Array<{key,value}> 类型，实际为 ${typeof value}`, (0, conditionRules_1.safeSample)(value)),
+        ];
+    }
+    const errors = [];
+    value.forEach((kv, i) => {
+        if (!isPlainObject(kv)) {
+            errors.push(typeError(field, 'type', `的第 ${i} 项期望 {key,value} object 类型，实际为 ${typeof kv}`, (0, conditionRules_1.safeSample)(kv)));
+        }
+    });
+    return errors;
+}
+function validateStringArray(value, field) {
+    if (!Array.isArray(value)) {
+        return [
+            typeError(field, 'type', `期望 string[] 类型，实际为 ${typeof value}`, (0, conditionRules_1.safeSample)(value)),
+        ];
+    }
+    const errors = [];
+    value.forEach((item, i) => {
+        if (typeof item !== 'string') {
+            errors.push(typeError(field, 'type', `的第 ${i} 项期望 string 类型，实际为 ${typeof item}`, (0, conditionRules_1.safeSample)(item)));
+        }
+    });
+    return errors;
+}
+function validateRecordArray(value, field) {
+    if (!Array.isArray(value)) {
+        return [
+            typeError(field, 'type', `期望 Record[] (array) 类型，实际为 ${typeof value}`, (0, conditionRules_1.safeSample)(value)),
+        ];
+    }
+    const errors = [];
+    value.forEach((item, i) => {
+        if (!isPlainObject(item)) {
+            errors.push(typeError(field, 'type', `的第 ${i} 项期望 Record (object) 类型，实际为 ${typeof item}`, (0, conditionRules_1.safeSample)(item)));
+        }
+    });
+    return errors;
+}
+function validateSyncFilteringRules(value, field) {
+    if (!isPlainObject(value)) {
+        return [
+            typeError(field, 'type', `期望 {or_list:[...]} object 类型，实际为 ${typeof value}`, (0, conditionRules_1.safeSample)(value)),
+        ];
+    }
+    if (value.or_list === undefined || value.or_list === null) {
+        return [typeError(field, 'required', '缺少 or_list 属性', '')];
+    }
+    return (0, conditionRules_1.validateOrList)(value.or_list, String(field.name || ''));
+}
+function validateSyncAccountLinkage(value, field) {
+    if (!Array.isArray(value)) {
+        return [
+            typeError(field, 'type', `期望 Array<{source_exp,target_path}> 类型，实际为 ${typeof value}`, (0, conditionRules_1.safeSample)(value)),
+        ];
+    }
+    const errors = [];
+    value.forEach((item, i) => {
+        if (!isPlainObject(item)) {
+            errors.push(typeError(field, 'type', `的第 ${i} 项期望 object 类型，实际为 ${typeof item}`, (0, conditionRules_1.safeSample)(item)));
+            return;
+        }
+        if (typeof item.source_exp !== 'string' || !item.source_exp.trim()) {
+            errors.push(typeError(field, 'required', `的第 ${i} 项缺少有效 source_exp`, (0, conditionRules_1.safeSample)(item.source_exp)));
+        }
+        if (typeof item.target_path !== 'string' || !item.target_path.trim()) {
+            errors.push(typeError(field, 'required', `的第 ${i} 项缺少有效 target_path`, (0, conditionRules_1.safeSample)(item.target_path)));
+        }
+    });
+    return errors;
+}
+function validateSyncHourMinute(value, field) {
+    if (typeof value !== 'string') {
+        return [
+            typeError(field, 'type', `期望 HH:mm:00 时间字符串，实际为 ${typeof value}`, (0, conditionRules_1.safeSample)(value)),
+        ];
+    }
+    if (!HH_MM_SS_PATTERN.test(value)) {
+        return [
+            typeError(field, 'format', `的值 "${value}" 不符合 HH:mm:00 时间格式`, value.substring(0, 80)),
+        ];
+    }
+    return [];
+}
+function validateConfigSubFlow(value, field) {
+    if (!isPlainObject(value)) {
+        return [
+            typeError(field, 'type', `期望 {flowId,input} object 类型，实际为 ${typeof value}`, (0, conditionRules_1.safeSample)(value)),
+        ];
+    }
+    const errors = [];
+    if (typeof value.flowId !== 'string' || !value.flowId.trim()) {
+        errors.push(typeError(field, 'required', '缺少有效 flowId', (0, conditionRules_1.safeSample)(value.flowId)));
+    }
+    return errors;
+}
+function validateSyncDefaultMounting(value, field) {
+    if (!isPlainObject(value)) {
+        return [
+            typeError(field, 'type', `期望 org 节点 object 类型，实际为 ${typeof value}`, (0, conditionRules_1.safeSample)(value)),
+        ];
+    }
+    const errors = [];
+    if (typeof value.id !== 'string' || !value.id.trim()) {
+        errors.push(typeError(field, 'format', '的 id 属性缺失或为空', (0, conditionRules_1.safeSample)(value.id)));
+    }
+    return errors;
+}
+function validateArray(value, field) {
+    if (!Array.isArray(value)) {
+        return [typeError(field, 'type', `期望 array 类型，实际为 ${typeof value}`, (0, conditionRules_1.safeSample)(value))];
+    }
+    return [];
+}
+function validateRecord(value, field) {
+    if (!isPlainObject(value)) {
+        return [
+            typeError(field, 'type', `期望 Record (object) 类型，实际为 ${typeof value}`, (0, conditionRules_1.safeSample)(value)),
+        ];
+    }
+    return [];
+}
+function validateBoolean(value, field) {
+    if (typeof value !== 'boolean') {
+        return [
+            typeError(field, 'type', `期望 boolean 类型，实际为 ${typeof value}`, (0, conditionRules_1.safeSample)(value)),
+        ];
+    }
+    return [];
+}
+function validateNumber(value, field) {
+    if (typeof value !== 'number') {
+        return [
+            typeError(field, 'type', `期望 number 类型，实际为 ${typeof value}`, (0, conditionRules_1.safeSample)(value)),
+        ];
+    }
+    return [];
+}
+function validateString(value, field) {
+    if (typeof value !== 'string') {
+        return [
+            typeError(field, 'type', `期望 string 类型，实际为 ${typeof value}`, (0, conditionRules_1.safeSample)(value)),
+        ];
+    }
+    return [];
+}
+/**
+ * 种子契约表。
+ *
+ * 三组来源：
+ * 1. DIP 复杂类型（OBJECT / ARRAY / DYNAMIC_ARRAY / KEYVALUE / CODE / PROXY / GLOBAL_VARIABLE_KEY）
+ * 2. rcs 内置特殊 page_control（MULTI_ROW_EXTRACT / MULTI_ROW_GUARD / MULTI_SELECT_LIST /
+ *    SYNC_HOUR_MINUTE / AUTH_TOKEN / SECRET_KEY / CONFIG_SUB_FLOW）
+ * 3. iam-console 宿主注册类型（MCP_SCOPE / SYNC_ACCOUNT_LINKAGE / SYNC_ORG_TREE /
+ *    SYNC_FILTERING_RULES / SYNC_DEFAULT_MOUNTING / SYNC_MAPPING_CHECK）
+ */
+const SEED_CONTRACTS = [
+    // ── DIP 复杂类型 ────────────────────────────────────────────
+    { name: 'OBJECT', kind: 'record', default: () => ({}) },
+    { name: 'ARRAY', kind: 'array', default: () => [] },
+    {
+        name: 'DYNAMIC_ARRAY',
+        kind: 'recordArray',
+        default: (field) => ((field.value_type || '').toUpperCase() === 'OBJECT' ? [{}] : []),
+        validate: validateRecordArray,
+    },
+    { name: 'KEYVALUE', kind: 'keyValueArray', default: () => [], validate: validateKeyValueArray },
+    { name: 'CODE', kind: 'code', default: () => '' },
+    { name: 'PROXY', kind: 'string', default: () => '' },
+    { name: 'GLOBAL_VARIABLE_KEY', kind: 'string', default: () => '' },
+    // ── rcs 内置特殊 page_control ───────────────────────────────
+    {
+        name: 'MULTI_ROW_EXTRACT',
+        kind: 'multiRowExtract',
+        default: () => [],
+        validate: validateMultiRowExtract,
+    },
+    { name: 'MULTI_ROW_GUARD', kind: 'guardRules', default: () => [], validate: validateGuardRules },
+    { name: 'MULTI_SELECT_LIST', kind: 'array', default: () => [] },
+    {
+        name: 'SYNC_HOUR_MINUTE',
+        kind: 'time',
+        default: () => '00:00:00',
+        validate: validateSyncHourMinute,
+    },
+    { name: 'AUTH_TOKEN', kind: 'token', default: () => generateAuthToken() },
+    { name: 'SECRET_KEY', kind: 'token', default: () => generateAuthToken() },
+    {
+        name: 'CONFIG_SUB_FLOW',
+        kind: 'flowRef',
+        default: () => ({ flowId: '', input: {} }),
+        validate: validateConfigSubFlow,
+    },
+    // ── iam-console 宿主注册类型 ────────────────────────────────
+    { name: 'MCP_SCOPE', kind: 'stringArray', default: () => [], validate: validateStringArray },
+    {
+        name: 'SYNC_ACCOUNT_LINKAGE',
+        kind: 'array',
+        default: () => [],
+        validate: validateSyncAccountLinkage,
+    },
+    { name: 'SYNC_ORG_TREE', kind: 'stringArray', default: () => [], validate: validateStringArray },
+    {
+        name: 'SYNC_FILTERING_RULES',
+        kind: 'orList',
+        default: () => ({ or_list: [] }),
+        validate: validateSyncFilteringRules,
+    },
+    {
+        name: 'SYNC_DEFAULT_MOUNTING',
+        kind: 'orgNode',
+        default: () => null,
+        validate: validateSyncDefaultMounting,
+    },
+    { name: 'SYNC_MAPPING_CHECK', kind: 'boolean', default: () => false, validate: validateBoolean },
+];
+const KIND_FALLBACK_DEFAULTS = {
+    string: '',
+    number: 0,
+    boolean: false,
+    object: {},
+    array: [],
+    record: {},
+    recordArray: [],
+    keyValueArray: [],
+    stringArray: [],
+    token: '',
+    time: null,
+    code: '',
+    flowRef: null,
+    guardRules: [],
+    orList: null,
+    orgNode: null,
+    multiRowExtract: [],
+};
+const KIND_FALLBACK_VALIDATORS = {
+    string: validateString,
+    number: validateNumber,
+    boolean: validateBoolean,
+    record: validateRecord,
+    array: validateArray,
+    object: validateRecord,
+    stringArray: validateStringArray,
+    recordArray: validateRecordArray,
+    keyValueArray: validateKeyValueArray,
+    time: validateSyncHourMinute,
+    guardRules: validateGuardRules,
+    multiRowExtract: validateMultiRowExtract,
+    token: undefined,
+    code: undefined,
+    flowRef: undefined,
+    orList: undefined,
+    orgNode: undefined,
+};
+/* ── 内置类型（内置 switch 已处理，注册表跳过） ─────────────── */
+const BUILT_IN_TYPES = new Set([
+    'SELECT',
+    'NUMBER',
+    'BOOLEAN',
+    'SWITCH',
+    'DATE',
+    'TIME',
+    'DATETIME',
+    'JSON',
+    'EXTEND_OBJ',
+    'FIXED_OBJ',
+    'ORG_TREE',
+    'TEXT',
+    'TEXTAREA',
+    'PASSWORD',
+    'HIDDEN',
+    'LABEL',
+    'STRING',
+    'INTEGER',
+    'FLOAT',
+]);
+/* ── 逃生舱：~/.ai-flow-cli/field-types-<profile>.json ─────── */
+let customContractsCache = null;
+function getFieldTypesFilePath() {
+    return path.join(os.homedir(), '.ai-flow-cli', `${FIELD_TYPES_FILE_PREFIX}-${(0, config_1.getActiveProfile)()}.json`);
+}
+function normalizeKind(raw) {
+    if (typeof raw !== 'string')
+        return undefined;
+    const kind = raw.trim();
+    return kind in KIND_FALLBACK_DEFAULTS ? kind : undefined;
+}
+function loadCustomContracts() {
+    if (customContractsCache)
+        return customContractsCache;
+    const map = new Map();
+    try {
+        const filePath = getFieldTypesFilePath();
+        if (fs.existsSync(filePath)) {
+            const raw = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+            for (const [typeName, decl] of Object.entries(raw)) {
+                if (!decl || typeof decl !== 'object')
+                    continue;
+                const { kind, default: defaultValue } = decl;
+                const normalizedKind = normalizeKind(kind);
+                if (!normalizedKind)
+                    continue;
+                map.set(typeName.toUpperCase(), {
+                    name: typeName.toUpperCase(),
+                    kind: normalizedKind,
+                    default: defaultValue === undefined
+                        ? () => KIND_FALLBACK_DEFAULTS[normalizedKind]
+                        : () => defaultValue,
+                });
+            }
+        }
+    }
+    catch {
+        // 逃生舱文件损坏时静默忽略，仅使用种子契约
+    }
+    customContractsCache = map;
+    return map;
+}
+/** 重置逃生舱契约缓存（测试用） */
+function resetFieldTypesCache() {
+    customContractsCache = null;
+}
+/* ── 查询接口 ─────────────────────────────────────────────── */
+const seedContractIndex = new Map(SEED_CONTRACTS.map((c) => [c.name, c]));
+/**
+ * 按类型名查找契约（大小写不敏感）。
+ * 逃生舱声明优先于种子数据，允许覆盖内置以外的类型形状。
+ */
+function findFieldTypeContract(typeName) {
+    if (!typeName)
+        return undefined;
+    const key = typeName.toUpperCase();
+    if (BUILT_IN_TYPES.has(key))
+        return undefined;
+    const custom = loadCustomContracts().get(key);
+    if (custom)
+        return custom;
+    return seedContractIndex.get(key);
+}
+/** 按类型名是否为已知契约类型 */
+function isKnownFieldType(typeName) {
+    return findFieldTypeContract(typeName) !== undefined;
+}
+/**
+ * 推断字段默认值：先查注册表契约，未命中返回 undefined（由调用方兜底）。
+ */
+function getDefaultValueForType(param) {
+    const typeName = String(param.page_control || param.type || '');
+    const contract = findFieldTypeContract(typeName);
+    if (!contract)
+        return undefined;
+    if (contract.default)
+        return contract.default(param);
+    return KIND_FALLBACK_DEFAULTS[contract.kind];
+}
+/**
+ * 按契约校验字段值。返回错误数组；类型未命中注册表时返回 null（调用方放行）。
+ */
+function validateByContract(value, param) {
+    const typeName = String(param.page_control || param.type || '');
+    const contract = findFieldTypeContract(typeName);
+    if (!contract)
+        return null;
+    const validate = contract.validate ?? KIND_FALLBACK_VALIDATORS[contract.kind];
+    if (!validate)
+        return [];
+    return validate(value, param);
+}
+/** NodeSchemaInputField 适配为 ConfigSchemaItem 以复用契约校验 */
+function schemaFieldToConfigItem(field) {
+    return {
+        ui_id: '',
+        name: field.key,
+        type: field.type,
+        display_name: field.label,
+        required: field.required,
+    };
+}
+/**
+ * 按 node_schema.field.type 契约校验 properties 值。
+ * 返回错误数组；类型未命中注册表时返回 null（调用方放行）。
+ */
+function validateNodeSchemaValueByContract(value, field) {
+    return validateByContract(value, schemaFieldToConfigItem(field));
+}
+/**
+ * 推断 node_schema 字段默认值（先查注册表，未命中返回 undefined）。
+ */
+function getDefaultValueForSchemaField(field) {
+    if (field.default_value !== undefined && field.default_value !== null)
+        return field.default_value;
+    return getDefaultValueForType(schemaFieldToConfigItem(field));
+}
+//# sourceMappingURL=fieldTypeRegistry.js.map

package/dist/services/flowAnalyzer.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.analyzeFlow = analyzeFlow;
 exports.formatNodeType = formatNodeType;
+const node_type_1 = require("@/constants/node-type");
 const NODE_TYPE_LABELS = {
     StartEventNode: '触发器',
     ActionNode: '动作',
@@ -9,6 +10,7 @@ const NODE_TYPE_LABELS = {
     LoopNode: '循环',
     SelfLoopNode: '自循环',
     SwitchNode: '分支',
+    ParallelNode: '并行',
     EndNode: '结束',
     AgentNode: 'AI Agent',
     AISubNode: 'AI 子节点',
@@ -16,8 +18,13 @@ const NODE_TYPE_LABELS = {
     MCPServerNode: 'MCP 服务',
     BuiltinMCPNode: '内置 MCP',
     MCPToolNode: 'MCP 工具',
+    MCP_TRIGGER_NODE: 'MCP 触发',
+    MCP_TOOLS_NODE: 'MCP 工具列表',
     VectorStoreNode: '向量存储',
     StickyNoteNode: '便签',
+    // 通讯录集成新版协议 trigger 节点（uep-service acm NodeEnum）
+    UserSyncAiNode: '通讯录集成-智能版',
+    UserPushAiNode: '通讯录同步-智能版',
     START: '开始',
 };
 function analyzeFlow(flow) {
@@ -74,7 +81,7 @@ function analyzeFlow(flow) {
 }
 function isTriggerNode(node) {
     const type = node.node_type || 'ActionNode';
-    return (type === 'StartEventNode' ||
+    return ((0, node_type_1.isTriggerNodeType)(type) ||
         type === 'START' ||
         (node.connector_name?.toLowerCase().includes('webhook') ?? false));
 }

package/dist/services/flowValidator.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectCycles = detectCycles;
+exports.validateFlowGraph = validateFlowGraph;
+const node_type_1 = require("@/constants/node-type");
+/** 与 flowAnalyzer.isTriggerNode 同语义，触发器类型集合统一取自 constants/node-type */
+function isTriggerNode(node) {
+    const type = node.node_type || 'ActionNode';
+    return ((0, node_type_1.isTriggerNodeType)(type) ||
+        type === 'START' ||
+        (node.connector_name?.toLowerCase().includes('webhook') ?? false));
+}
+/** 非参与拓扑的辅助节点类型：便签等画布装饰节点不算孤立节点 */
+const NON_EXECUTION_NODE_TYPES = new Set(['StickyNoteNode']);
+/**
+ * DFS 三色染色环检测：WHITE 未访问 / GRAY 当前栈中 / BLACK 已完成。
+ * 遇到 GRAY 邻居即找到环，从栈中截取环上节点序列。
+ */
+function detectCycles(nodes, edges) {
+    const nodeIds = nodes.map((n) => n.n_id || n.id);
+    const adjacency = new Map();
+    for (const id of nodeIds)
+        adjacency.set(id, []);
+    const nodeSet = new Set(nodeIds);
+    for (const edge of edges) {
+        if (nodeSet.has(edge.source) && nodeSet.has(edge.target)) {
+            adjacency.get(edge.source).push(edge.target);
+        }
+    }
+    const WHITE = 0;
+    const GRAY = 1;
+    const BLACK = 2;
+    const color = new Map();
+    for (const id of nodeIds)
+        color.set(id, WHITE);
+    const stack = [];
+    const stackIndex = new Map();
+    const cycles = [];
+    const seenCycleKeys = new Set();
+    function dfs(nodeId) {
+        color.set(nodeId, GRAY);
+        stackIndex.set(nodeId, stack.length);
+        stack.push(nodeId);
+        for (const next of adjacency.get(nodeId) || []) {
+            const nextColor = color.get(next);
+            if (nextColor === GRAY) {
+                // 找到环：从 next 在栈中的位置截取到栈顶
+                const startIdx = stackIndex.get(next) ?? 0;
+                const cycleNodes = stack.slice(startIdx);
+                const key = normalizeCycleKey(cycleNodes);
+                if (!seenCycleKeys.has(key)) {
+                    seenCycleKeys.add(key);
+                    cycles.push({ nodes: [...cycleNodes, next] });
+                }
+            }
+            else if (nextColor === WHITE) {
+                dfs(next);
+            }
+        }
+        stack.pop();
+        stackIndex.delete(nodeId);
+        color.set(nodeId, BLACK);
+    }
+    for (const id of nodeIds) {
+        if (color.get(id) === WHITE) {
+            dfs(id);
+        }
+    }
+    return cycles;
+}
+/** 环去重 key：旋转同构的环视为同一个 */
+function normalizeCycleKey(cycleNodes) {
+    if (cycleNodes.length <= 1)
+        return cycleNodes.join('|');
+    let minIdx = 0;
+    for (let i = 1; i < cycleNodes.length; i++) {
+        if (cycleNodes[i] < cycleNodes[minIdx])
+            minIdx = i;
+    }
+    const rotated = [];
+    for (let i = 0; i < cycleNodes.length; i++) {
+        rotated.push(cycleNodes[(minIdx + i) % cycleNodes.length]);
+    }
+    return rotated.join('|');
+}
+/**
+ * 流图结构校验：环检测（error）、孤立节点（warning）、触发器检查
+ * （多触发器 error / 无触发器 warning）。
+ */
+function validateFlowGraph(input) {
+    const { nodes, edges } = input;
+    const issues = [];
+    // 1. 环检测
+    const cycles = detectCycles(nodes, edges);
+    for (const cycle of cycles) {
+        issues.push({
+            code: 'CYCLE_DETECTED',
+            severity: 'error',
+            message: `检测到循环依赖: ${cycle.nodes.join(' → ')}`,
+        });
+    }
+    // 2. 孤立节点（无入边无出边的非触发节点）
+    if (nodes.length > 0) {
+        const connectedIds = new Set();
+        for (const edge of edges) {
+            connectedIds.add(edge.source);
+            connectedIds.add(edge.target);
+        }
+        for (const node of nodes) {
+            const nid = node.n_id || node.id;
+            const type = node.node_type || 'ActionNode';
+            if (NON_EXECUTION_NODE_TYPES.has(type))
+                continue;
+            if (isTriggerNode(node))
+                continue;
+            if (!connectedIds.has(nid)) {
+                issues.push({
+                    code: 'ORPHAN_NODE',
+                    severity: 'warning',
+                    message: `节点 ${nid} 是孤立节点（无入边无出边），不会被执行`,
+                    nodeId: nid,
+                });
+            }
+        }
+    }
+    // 3. 触发器检查
+    const triggers = nodes.filter((n) => isTriggerNode(n));
+    if (triggers.length > 1) {
+        const ids = triggers.map((n) => n.n_id || n.id);
+        issues.push({
+            code: 'MULTIPLE_TRIGGERS',
+            severity: 'error',
+            message: `流中存在 ${triggers.length} 个触发器节点 (${ids.join(', ')})，仅允许一个触发器`,
+        });
+    }
+    else if (triggers.length === 0 && nodes.length > 0) {
+        issues.push({
+            code: 'NO_TRIGGER',
+            severity: 'warning',
+            message: '流中没有触发器节点，无法启动执行',
+        });
+    }
+    return { issues, cycles };
+}
+//# sourceMappingURL=flowValidator.js.map