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

package/dist/commands/flow/helpers.js

@@ -36,10 +36,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OP_STATUS_MAP = exports.NODE_UPDATE_DATA_SCHEMA = exports.NODE_CREATE_DATA_SCHEMA = exports.NODE_CONFIG_DATA_SCHEMA = exports.FLOW_CREATE_DATA_SCHEMA = void 0;
+exports.VALID_CREATE_NODE_TYPES = exports.OP_STATUS_MAP = exports.NODE_UPDATE_DATA_SCHEMA = exports.NODE_CREATE_DATA_SCHEMA = exports.NODE_CONFIG_DATA_SCHEMA = exports.FLOW_CREATE_DATA_SCHEMA = void 0;
 exports.validateDataStructure = validateDataStructure;
 exports.resolveDataOption = resolveDataOption;
 exports.checkFlowNotOnline = checkFlowNotOnline;
+exports.deriveNodeTypeFromAction = deriveNodeTypeFromAction;
+exports.validateNodeTypeValue = validateNodeTypeValue;
 exports.formatDate = formatDate;
 exports.calcDefaultPosition = calcDefaultPosition;
 exports.edgesToConnections = edgesToConnections;
@@ -51,13 +53,20 @@ exports.resolveErrorHandlerFile = resolveErrorHandlerFile;
 exports.checkPropertyValidation = checkPropertyValidation;
 exports.checkSpecialNodeValidation = checkSpecialNodeValidation;
 exports.validateVariableRefs = validateVariableRefs;
-exports.validateNodeSchemaProperties = validateNodeSchemaProperties;
 exports.printNodeSchemaFields = printNodeSchemaFields;
+exports.buildNodeSchemaDefaults = buildNodeSchemaDefaults;
+exports.buildClassicConfigWithDefaults = buildClassicConfigWithDefaults;
+exports.findProxyFieldMisuse = findProxyFieldMisuse;
+exports.validateNodeSchemaFieldMetadata = validateNodeSchemaFieldMetadata;
+exports.validateNodeSchemaProperties = validateNodeSchemaProperties;
 const fs = __importStar(require("fs"));
 const chalk_1 = __importDefault(require("chalk"));
 const output_1 = require("@/utils/output");
 const flow_1 = require("@/api/flow");
+const format_1 = require("@/utils/format");
+const fieldTypeRegistry_1 = require("@/services/fieldTypeRegistry");
 const flowAnalyzer_1 = require("@/services/flowAnalyzer");
+const nodeEnvelope_1 = require("@/utils/nodeEnvelope");
 function validateDataStructure(data, schema, path = '--data') {
     if (data === null || data === undefined) {
         throw new Error(`${path} 不能为 null`);
@@ -153,15 +162,33 @@ exports.NODE_CONFIG_DATA_SCHEMA = {
         properties: { type: 'object', required: true },
     },
 };
-/** flow node create 的 --data 结构：可选 properties 和 position，其余字段自动转发 */
+/**
+ * flow node create 的 --data 结构。
+ *
+ * 顶层为 NodePackage 提交信封（未声明的额外字段自动转发）：
+ * - `properties` — 业务配置字段
+ * - `position` — 节点坐标
+ * - `proxy_id` — 代理网关 ID（字符串，'0'=不使用）。PROXY 类型字段由宿主
+ *   处理，必须写在信封顶层，写在 properties 中会被拦截
+ * - `mcp_tool_description` — MCP 工具描述
+ * - `account_id` — 账号实例 ID（建议用 --account-id 选项）
+ */
 exports.NODE_CREATE_DATA_SCHEMA = {
     type: 'object',
     properties: {
         properties: { type: 'object', required: false },
         position: { type: 'object', required: false },
+        proxy_id: { type: 'string', required: false },
+        mcp_tool_description: { type: 'string', required: false },
+        account_id: { type: 'string', required: false },
     },
 };
-/** flow node update 的 --data 结构：可选 properties 和元数据字段，其余字段自动转发 */
+/**
+ * flow node update 的 --data/--patch 结构。
+ *
+ * 顶层为 NodePackage 提交信封：`properties` 必填，其余元数据字段可选，
+ * 未声明的额外字段自动转发。
+ */
 exports.NODE_UPDATE_DATA_SCHEMA = {
     type: 'object',
     properties: {
@@ -172,6 +199,8 @@ exports.NODE_UPDATE_DATA_SCHEMA = {
         account_id: { type: 'string', required: false },
         note: { type: 'string', required: false },
         flow_id: { type: 'string', required: false },
+        proxy_id: { type: 'string', required: false },
+        mcp_tool_description: { type: 'string', required: false },
     },
 };
 exports.OP_STATUS_MAP = {
@@ -195,6 +224,122 @@ function checkFlowNotOnline(flow, json) {
     }
     return false;
 }
+/**
+ * 服务端 NodeEnum（uep-service acm/acm-api NodeEnum.java）中创建节点可用的合法值，
+ * 顺序与枚举声明一致。START / dynamic / custom 三个前端画布渲染别名不在其中
+ * （见 INVALID_NODE_TYPE_HINTS），仅用于读路径兼容，不是节点类型。
+ */
+exports.VALID_CREATE_NODE_TYPES = [
+    'StartEventNode',
+    'ActionNode',
+    'ConditionNode',
+    'LoopNode',
+    'SwitchNode',
+    'ParallelNode',
+    'EndNode',
+    'AgentNode',
+    'VectorStoreNode',
+    'AISubNode',
+    'MCPServerNode',
+    'BuiltinMCPNode',
+    'MCPToolNode',
+    'SelfLoopNode',
+    'BrowserNode',
+    'StickyNoteNode',
+    'UserSyncAiNode',
+    'UserPushAiNode',
+    'MCP_TRIGGER_NODE',
+    'MCP_TOOLS_NODE',
+];
+/**
+ * 【仅老节点】按服务端完整换算链推算 NodeType。
+ *
+ * 适用范围：legacy 详情接口 /acm/actions/:id 返回的 action_type 是 DB 原值，
+ * 不能直接当 nodeType（曾致 'StartEvent' / 脏数据直进创建 payload）。
+ * connectable / v2 列表的 action_type 已是推算终值，经 R1 原样保留，幂等。
+ *
+ * 完整换算链（三个阶段、四条规则，对齐 AppActionDBOImpl / AppActionServiceImpl）：
+ *
+ * Stage 0 — DB 层 queryApiActions：
+ *   R0「MCP 整包改写」：请求 actionType == "MCPToolNode" 时 ① 跳过 actionType
+ *   等值过滤（库里 MCP 动作存的也是 ActionNode，按类型查会查空），② 查完后把
+ *   结果集每一行的 actionType 统一改写为 "MCPToolNode"。
+ *   ⚠️ 副作用：actionType=MCPToolNode 的 v2 请求根本不过滤类型，返回该连接器
+ *   下所有动作再全部标成 MCPToolNode——拿 v2 的 MCP 结果统计"有多少个 MCP
+ *   工具"是错的。CLI 未用该查询形态，仅备此警示。
+ *
+ * Stage 1 — Service 层 queryActionsV2 循环体（每行依次）：
+ *   R1「枚举归一化」：actionType 精确匹配（区分大小写）NodeEnum 任一名字 →
+ *   保留；否则（"StartEvent"、脏数据、大小写不符）→ ActionNode。
+ *   R2「触发翻转」：仅当 trigger 参数显式 true 且结果为 ActionNode →
+ *   StartEventNode。按真值表此翻转只命中 DB 原值就是 ActionNode 的行；
+ *   脏数据行（R1 兜成的 ActionNode）任意 trigger 均保持 ActionNode。
+ *   trigger=false 或不传 → 不翻转（不传时 DB 层已强制 isTrigger=0）。
+ *   R3「LOOP 终裁」：nodeStruct（DB 原值）== "LOOP" → 强制 SelfLoopNode，
+ *   最后执行，覆盖前面一切结果。
+ *
+ * 同循环副作用（非 actionType，影响对 v2 响应的断言）：icon 重写为默认图标；
+ * status 字段被置 null（v2 响应 status 恒空）；configSchema 中 {{server}}/
+ * {{flowId}} 占位符替换为实际 host/flowId（webhook URL 断言以替换后为准）。
+ *
+ * 最终值真值表：
+ *
+ * | DB actionType               | nodeStruct | trigger 参数 | v2 最终返回            |
+ * |-----------------------------|------------|--------------|------------------------|
+ * | 合法 NodeEnum 名             | SINGLE     | 任意         | 原值（R1）              |
+ * | "StartEvent"/脏数据/大小写不符 | SINGLE    | 任意         | ActionNode              |
+ * | ActionNode                  | SINGLE     | true         | StartEventNode（R2）    |
+ * | ActionNode                  | SINGLE     | false/不传   | ActionNode              |
+ * | 任何值                      | LOOP       | 任意         | SelfLoopNode（R3 终裁） |
+ *
+ * DB 未存 actionType（undefined/null/空串）不在规则表内：维持 CLI 既有默认
+ * （trigger → StartEventNode，否则 ActionNode）。
+ *
+ * 推论：v2 结果一定是合法 NodeEnum 名；ActionNode 与 StartEventNode 不可信为
+ * 存储值（受请求参数影响）；SelfLoopNode 有两种来路（存储原值 / R3 终裁），
+ * 不能反推存储值；R1 大小写敏感（如 "selfloopnode" 兜成 ActionNode 而非纠正）。
+ */
+function deriveNodeTypeFromAction(actionType, nodeStruct, trigger) {
+    // DB 未存 actionType（表外）：CLI 既有默认（trigger → StartEventNode）
+    let nodeType;
+    if (!actionType) {
+        nodeType = trigger ? 'StartEventNode' : 'ActionNode';
+    }
+    else {
+        // R1 枚举归一化（精确匹配，区分大小写）
+        nodeType = exports.VALID_CREATE_NODE_TYPES.includes(actionType) ? actionType : 'ActionNode';
+        // R2 触发翻转：仅对 DB 原值就是 ActionNode 的行（真值表行 3；R1 兜成的
+        // ActionNode 不翻转，见真值表行 2 "任意"）
+        if (trigger && actionType === 'ActionNode') {
+            nodeType = 'StartEventNode';
+        }
+    }
+    // R3 LOOP 终裁：最后执行，覆盖前两步（"任何值"含 DB 未存 actionType 的表外缺省）
+    if (nodeStruct === 'LOOP') {
+        nodeType = 'SelfLoopNode';
+    }
+    return nodeType;
+}
+/**
+ * 前端画布渲染别名（读路径 classicNodePorts / isTriggerNode 兼容用）→ 提示消息。
+ * 这些别名不在服务端 NodeEnum 中，实际不是节点类型，校验报错时据此附加提示。
+ */
+const INVALID_NODE_TYPE_HINTS = {
+    START: '"START" 为前端画布渲染别名，不是节点类型，请使用规范类型 StartEventNode',
+    dynamic: '"dynamic" 为前端画布渲染别名，不是节点类型，请使用规范类型 ActionNode',
+    custom: '"custom" 为前端画布渲染别名，不是节点类型，请使用规范类型 ActionNode',
+};
+/**
+ * 校验节点类型值合法性，合法返回 null，否则返回含合法值列表的错误消息。
+ * source 描述取值来源（如 '--node-type 参数'），用于错误定位。
+ */
+function validateNodeTypeValue(nodeType, source) {
+    if (exports.VALID_CREATE_NODE_TYPES.includes(nodeType))
+        return null;
+    const hint = INVALID_NODE_TYPE_HINTS[nodeType];
+    const hintSuffix = hint ? `；${hint}` : '';
+    return `节点类型 "${nodeType}" 不合法（来源: ${source}）${hintSuffix}，合法值: ${exports.VALID_CREATE_NODE_TYPES.join(', ')}`;
+}
 function formatDate(d, isSeconds = true) {
     if (!d)
         return '-';
@@ -392,69 +537,246 @@ async function validateVariableRefs(configValues, flowId, nodeId, json) {
     const refs = parseVariableRefs(configStr);
     if (refs.length === 0)
         return false;
+    const nodeRefs = refs.filter((r) => !r.kind || r.kind === 'node');
+    const globalRefs = refs.filter((r) => r.kind === 'global');
+    const builtinRefs = refs.filter((r) => r.kind === 'builtin');
     (0, output_1.printInfo)(`发现 ${refs.length} 个变量引用，正在验证...`);
     const flow = await (0, flow_1.getFlowDetail)(flowId);
-    const { getFlowOutputTree } = await Promise.resolve().then(() => __importStar(require('@/api/variables')));
+    const { getFlowOutputTree, getGlobalVariables } = await Promise.resolve().then(() => __importStar(require('@/api/variables')));
     const outputTree = await getFlowOutputTree(flowId, {
         nodeId,
         node_id: nodeId,
         edges: flow.edges || [],
     });
     const availableNodes = new Set(outputTree.map((o) => o.node_id));
-    const unresolvedRefs = refs.filter((r) => !availableNodes.has(r.nodeId));
-    if (unresolvedRefs.length > 0) {
-        const msg = `变量引用验证失败: ${unresolvedRefs.map((r) => r.raw).join(', ')} 无法在上游节点找到`;
+    const unresolvedRefs = nodeRefs.filter((r) => !availableNodes.has(r.nodeId));
+    // global 类引用做全局变量表存在性检查（复用 /acm/api/globalVariables/list）
+    const globalKeys = new Set();
+    if (globalRefs.length > 0) {
+        try {
+            const globalResult = await getGlobalVariables();
+            for (const v of globalResult.items || []) {
+                if (v.key)
+                    globalKeys.add(v.key);
+            }
+        }
+        catch (error) {
+            (0, output_1.printWarning)(`获取全局变量列表失败，跳过存在性检查: ${error.message}`);
+        }
+    }
+    const unresolvedGlobalRefs = globalRefs.filter((r) => globalKeys.size > 0 && !globalKeys.has(r.name || ''));
+    const allUnresolved = [...unresolvedRefs, ...unresolvedGlobalRefs];
+    if (allUnresolved.length > 0) {
+        const parts = [];
+        if (unresolvedRefs.length > 0) {
+            parts.push(`${unresolvedRefs.map((r) => r.raw).join(', ')} 无法在上游节点找到`);
+        }
+        if (unresolvedGlobalRefs.length > 0) {
+            parts.push(`${unresolvedGlobalRefs.map((r) => r.raw).join(', ')} 在全局变量表中不存在`);
+        }
+        const msg = `变量引用验证失败: ${parts.join('; ')}`;
         if (json)
             (0, output_1.printStructuredResult)({ ok: false, message: msg });
         else
             (0, output_1.printError)(msg);
         return true;
     }
-    (0, output_1.printInfo)('变量引用验证通过');
+    const refSummary = [
+        nodeRefs.length > 0 ? `节点引用 ${nodeRefs.length} 个` : '',
+        globalRefs.length > 0 ? `全局变量引用 ${globalRefs.length} 个` : '',
+        builtinRefs.length > 0 ? `内置变量引用 ${builtinRefs.length} 个` : '',
+    ]
+        .filter(Boolean)
+        .join(', ');
+    (0, output_1.printInfo)(`变量引用验证通过${refSummary ? `（${refSummary}）` : ''}`);
     return false;
 }
 /**
- * 校验 properties 是否符合 node_schema.input_fields 定义
+ * 打印 node_schema.input_fields 字段列表
  */
-function validateNodeSchemaProperties(properties, inputFields) {
-    const errors = [];
+function printNodeSchemaFields(inputFields) {
+    if (!inputFields || inputFields.length === 0)
+        return;
+    console.log(chalk_1.default.gray(`    配置字段 (${inputFields.length}):`));
     for (const field of inputFields) {
-        const value = properties[field.key];
-        const hasValue = value !== undefined && value !== null;
-        if (field.required && !hasValue) {
-            errors.push({
-                field: field.key,
-                rule: 'required',
-                message: `${field.label} (${field.key}) 是必填字段`,
-                sample: '',
-            });
+        const required = field.required ? chalk_1.default.red('*') : ' ';
+        const typeLabel = field.type.toLowerCase();
+        const defaultStr = field.default_value !== undefined && field.default_value !== null
+            ? chalk_1.default.dim(` [默认: ${field.default_value}]`)
+            : '';
+        const helpStr = field.help_text ? chalk_1.default.gray(` - ${field.help_text}`) : '';
+        console.log(`      ${required} ${chalk_1.default.cyan(field.key)} ${chalk_1.default.gray(`[${typeLabel}]`)} ${field.label}${defaultStr}${helpStr}`);
+    }
+}
+/**
+ * 递归推断 node_schema input_field 的默认值（OBJECT 递归 properties 嵌套）。
+ * 返回 undefined 表示该字段无默认值可填。
+ */
+function inferSchemaFieldDefault(field) {
+    const type = String(field.type || '').toUpperCase();
+    if (type === 'OBJECT' && field.properties && field.properties.length > 0) {
+        const nested = {};
+        for (const child of field.properties) {
+            const childDefault = inferSchemaFieldDefault(child);
+            if (childDefault !== undefined) {
+                nested[child.key] = childDefault;
+            }
         }
-        if (hasValue) {
-            const type = field.type.toUpperCase();
-            if ((type === 'NUMBER' || type === 'INTEGER') &&
-                typeof value !== 'number' &&
-                (typeof value !== 'string' || isNaN(Number(value)))) {
-                errors.push({
+        return nested;
+    }
+    const value = (0, fieldTypeRegistry_1.getDefaultValueForSchemaField)(field);
+    if (value !== undefined && value !== null)
+        return value;
+    // 内置基础类型兜底（对齐画布初次打开表单的默认值）
+    if (type === 'STRING' || type === 'TEXT' || type === 'TEXTAREA')
+        return '';
+    if (type === 'NUMBER' || type === 'INTEGER' || type === 'FLOAT')
+        return 0;
+    if (type === 'BOOLEAN')
+        return false;
+    return undefined;
+}
+/**
+ * 基于 node_schema.input_fields 递归生成默认 properties。
+ * 仅填充有默认值的字段；用户 override 由调用方浅合并覆盖。
+ */
+function buildNodeSchemaDefaults(inputFields) {
+    const properties = {};
+    const applied = [];
+    function fill(fields, target, pathPrefix) {
+        for (const field of fields) {
+            const type = String(field.type || '').toUpperCase();
+            if (type === 'OBJECT' && field.properties && field.properties.length > 0) {
+                const nested = {};
+                fill(field.properties, nested, pathPrefix ? `${pathPrefix}.${field.key}` : field.key);
+                target[field.key] = nested;
+                continue;
+            }
+            const value = inferSchemaFieldDefault(field);
+            if (value !== undefined) {
+                target[field.key] = value;
+                applied.push({
+                    path: pathPrefix ? `${pathPrefix}.${field.key}` : field.key,
                     field: field.key,
-                    rule: 'type',
-                    message: `${field.label} (${field.key}) 应为数字类型，实际为 ${typeof value}`,
-                    sample: '',
+                    value,
                 });
             }
-            else if (type === 'BOOLEAN' && typeof value !== 'boolean') {
+        }
+    }
+    fill(inputFields, properties, '');
+    return { properties, applied };
+}
+/**
+ * classic 路径默认值填充：先 fillConfigSchemaDefaults，再 deepMerge 用户 override。
+ * 返回填充后的 schema 与实际生效的默认值记录（用户 override 覆盖的字段已剔除）。
+ */
+function buildClassicConfigWithDefaults(configSchema, overrideValues) {
+    const applied = [];
+    const filled = (0, format_1.fillConfigSchemaDefaults)(configSchema, applied);
+    const config = (0, format_1.deepMerge)({ properties: filled }, overrideValues ?? {});
+    const overrideProps = overrideValues?.properties ?? {};
+    const effective = applied.filter((e) => !(e.field in overrideProps));
+    return { config, applied: effective };
+}
+/**
+ * 校验 --data.properties 中是否误写 PROXY 类型字段（对照 node_schema.input_fields）。
+ *
+ * PROXY 是工作流宿主能力：提交时会从 properties 中提升为信封顶层 proxy_id，
+ * 写在 properties 中服务端不会读取。返回错误消息数组（空数组表示通过）。
+ */
+function findProxyFieldMisuse(properties, inputFields) {
+    const proxyFieldKey = (0, nodeEnvelope_1.getProxyFieldKey)(inputFields);
+    if (!proxyFieldKey || !properties || !(proxyFieldKey in properties)) {
+        return [];
+    }
+    return [
+        `--data.properties 中包含 PROXY 类型字段 "${proxyFieldKey}"（代理网关选择），` +
+            `该字段由宿主处理、不属于业务参数，写在 properties 中不会生效。` +
+            `请改用信封顶层字段：{"proxy_id": "<代理ID>"}` +
+            `（不使用代理时传 "0"，或省略该字段）`,
+    ];
+}
+/**
+ * 校验 node_schema input_fields 声明的元数据：validation.pattern/min/max、
+ * validation.min_length/max_length、min_items/max_items。
+ */
+function validateNodeSchemaFieldMetadata(value, field, fieldPath) {
+    const errors = [];
+    const label = `${field.label || field.key} (${fieldPath})`;
+    const isEmpty = value === undefined || value === null;
+    if (!isEmpty) {
+        const v = field.validation;
+        if (v) {
+            if ((typeof value === 'string' || typeof value === 'number') &&
+                v.pattern &&
+                typeof v.pattern === 'string') {
+                const strValue = String(value);
+                try {
+                    if (!new RegExp(v.pattern).test(strValue)) {
+                        errors.push({
+                            field: fieldPath,
+                            rule: 'pattern',
+                            message: `${label} 的值 "${strValue.substring(0, 40)}" 不符合格式要求 /${v.pattern}/`,
+                            sample: strValue.substring(0, 80),
+                        });
+                    }
+                }
+                catch {
+                    // pattern 本身非法时跳过该校验，避免误报
+                }
+            }
+            if (typeof value === 'number') {
+                if (typeof v.min === 'number' && value < v.min) {
+                    errors.push({
+                        field: fieldPath,
+                        rule: 'min',
+                        message: `${label} 的值 ${value} 小于最小值 ${v.min}`,
+                        sample: String(value),
+                    });
+                }
+                if (typeof v.max === 'number' && value > v.max) {
+                    errors.push({
+                        field: fieldPath,
+                        rule: 'max',
+                        message: `${label} 的值 ${value} 大于最大值 ${v.max}`,
+                        sample: String(value),
+                    });
+                }
+            }
+            if (typeof value === 'string') {
+                if (typeof v.min_length === 'number' && value.length < v.min_length) {
+                    errors.push({
+                        field: fieldPath,
+                        rule: 'min_length',
+                        message: `${label} 的长度 ${value.length} 小于最小长度 ${v.min_length}`,
+                        sample: value.substring(0, 80),
+                    });
+                }
+                if (typeof v.max_length === 'number' && value.length > v.max_length) {
+                    errors.push({
+                        field: fieldPath,
+                        rule: 'max_length',
+                        message: `${label} 的长度 ${value.length} 大于最大长度 ${v.max_length}`,
+                        sample: value.substring(0, 80),
+                    });
+                }
+            }
+        }
+        if (Array.isArray(value)) {
+            if (typeof field.min_items === 'number' && value.length < field.min_items) {
                 errors.push({
-                    field: field.key,
-                    rule: 'type',
-                    message: `${field.label} (${field.key}) 应为布尔类型，实际为 ${typeof value}`,
-                    sample: '',
+                    field: fieldPath,
+                    rule: 'min_items',
+                    message: `${label} 的元素个数 ${value.length} 小于最小个数 ${field.min_items}`,
+                    sample: JSON.stringify(value).substring(0, 80),
                 });
             }
-            else if (type === 'SELECT' && typeof value !== 'string') {
+            if (typeof field.max_items === 'number' && value.length > field.max_items) {
                 errors.push({
-                    field: field.key,
-                    rule: 'type',
-                    message: `${field.label} (${field.key}) 应为字符串类型 (SELECT)，实际为 ${typeof value}`,
-                    sample: '',
+                    field: fieldPath,
+                    rule: 'max_items',
+                    message: `${label} 的元素个数 ${value.length} 大于最大个数 ${field.max_items}`,
+                    sample: JSON.stringify(value).substring(0, 80),
                 });
             }
         }
@@ -462,20 +784,84 @@ function validateNodeSchemaProperties(properties, inputFields) {
     return errors;
 }
 /**
- * 打印 node_schema.input_fields 字段列表
+ * 校验 properties 是否符合 node_schema.input_fields 定义
+ * （含 validation.pattern/min/max、min_items/max_items 元数据与嵌套 properties 递归）
  */
-function printNodeSchemaFields(inputFields) {
-    if (!inputFields || inputFields.length === 0)
-        return;
-    console.log(chalk_1.default.gray(`    配置字段 (${inputFields.length}):`));
-    for (const field of inputFields) {
-        const required = field.required ? chalk_1.default.red('*') : ' ';
-        const typeLabel = field.type.toLowerCase();
-        const defaultStr = field.default_value !== undefined && field.default_value !== null
-            ? chalk_1.default.dim(` [默认: ${field.default_value}]`)
-            : '';
-        const helpStr = field.help_text ? chalk_1.default.gray(` - ${field.help_text}`) : '';
-        console.log(`      ${required} ${chalk_1.default.cyan(field.key)} ${chalk_1.default.gray(`[${typeLabel}]`)} ${field.label}${defaultStr}${helpStr}`);
+function validateNodeSchemaProperties(properties, inputFields) {
+    const errors = [];
+    function validateFields(props, fields, pathPrefix) {
+        for (const field of fields) {
+            const value = props[field.key];
+            const fieldPath = pathPrefix ? `${pathPrefix}.${field.key}` : field.key;
+            const hasValue = value !== undefined && value !== null;
+            // 字符串空串视为未填（默认值填充 '' 后 required 校验不放宽）
+            const isFilled = hasValue && value !== '';
+            if (field.required && !isFilled) {
+                errors.push({
+                    field: fieldPath,
+                    rule: 'required',
+                    message: `${field.label} (${fieldPath}) 是必填字段`,
+                    sample: '',
+                });
+            }
+            // 嵌套 properties 递归校验（OBJECT 字段的子字段）
+            if (hasValue &&
+                field.properties &&
+                field.properties.length > 0 &&
+                typeof value === 'object' &&
+                !Array.isArray(value)) {
+                validateFields(value, field.properties, fieldPath);
+            }
+            if (hasValue) {
+                const type = field.type.toUpperCase();
+                // 值形态豁免：变量引用 / {{$fromAI}} 哨兵 / ValueMode 编码（${expr}、\$ 转义）跳过类型断言
+                if (typeof value === 'string' && (0, format_1.isExemptValueForm)(value, type)) {
+                    // 豁免类型断言，仅保留元数据校验
+                }
+                else if ((type === 'NUMBER' || type === 'INTEGER') &&
+                    typeof value !== 'number' &&
+                    (typeof value !== 'string' || isNaN(Number(value)))) {
+                    errors.push({
+                        field: fieldPath,
+                        rule: 'type',
+                        message: `${field.label} (${fieldPath}) 应为数字类型，实际为 ${typeof value}`,
+                        sample: '',
+                    });
+                }
+                else if (type === 'BOOLEAN' && typeof value !== 'boolean') {
+                    errors.push({
+                        field: fieldPath,
+                        rule: 'type',
+                        message: `${field.label} (${fieldPath}) 应为布尔类型，实际为 ${typeof value}`,
+                        sample: '',
+                    });
+                }
+                else if (type === 'SELECT' && typeof value !== 'string') {
+                    errors.push({
+                        field: fieldPath,
+                        rule: 'type',
+                        message: `${field.label} (${fieldPath}) 应为字符串类型 (SELECT)，实际为 ${typeof value}`,
+                        sample: '',
+                    });
+                }
+                else {
+                    // 注册表全量校验：DIP 复杂类型 / rcs 特殊类型 / 宿主注册类型
+                    // 未注册类型返回 null 静默放行（宿主自定义类型）
+                    const contractErrors = (0, fieldTypeRegistry_1.validateNodeSchemaValueByContract)(value, field);
+                    if (contractErrors && contractErrors.length > 0) {
+                        errors.push(...contractErrors.map((e) => ({
+                            ...e,
+                            field: e.field ? `${fieldPath}.${e.field}` : fieldPath,
+                            message: `${field.label} (${fieldPath}) ${e.message}`,
+                        })));
+                    }
+                }
+                // 元数据校验：validation.pattern/min/max/min_length/max_length、min_items/max_items
+                errors.push(...validateNodeSchemaFieldMetadata(value, field, fieldPath));
+            }
+        }
     }
+    validateFields(properties, inputFields, '');
+    return errors;
 }
 //# sourceMappingURL=helpers.js.map