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

package/dist/commands/flow/node.js

@@ -32,16 +32,23 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseActionIdRef = parseActionIdRef;
 exports.resolveAction = resolveAction;
 exports.registerFlowNode = registerFlowNode;
 const fs = __importStar(require("fs"));
+const chalk_1 = __importDefault(require("chalk"));
 const flow_1 = require("@/api/flow");
 const node_1 = require("@/api/node");
 const knowledge_1 = require("@/api/knowledge");
 const flowAnalyzer_1 = require("@/services/flowAnalyzer");
 const format_1 = require("@/utils/format");
+const nodeEnvelope_1 = require("@/utils/nodeEnvelope");
+const switchBranch_1 = require("@/utils/switchBranch");
+const node_type_1 = require("@/constants/node-type");
 const helpers_1 = require("@/commands/flow/helpers");
 const output_1 = require("@/utils/output");
 const exit_code_1 = require("@/constants/exit-code");
@@ -49,7 +56,7 @@ const ACTION_ID_HELP = '动作 ID：纯数字（legacy 动作 id）、action_key
 /**
  * 解析 --action-id 的三种形式：
  * - `action_key@version` → NodePackage 精确版本
- * - 纯数字 → legacy 动作 id
+ * - 纯数字 → 先按 legacy 动作 id，未命中回退按 action_key（两个数字空间，形态无法区分）
  * - `action_key` → NodePackage 最新版（version 需经列表解析）
  */
 function parseActionIdRef(actionId) {
@@ -67,12 +74,18 @@ function parseActionIdRef(actionId) {
     return { key: actionId };
 }
 /**
- * 按解析结果获取动作（以 RCS 为标准，旧 API 已移除）：
+ * 按解析结果获取动作（以 RCS 为标准）：
  * a. `key@version` → getActionNodeSchema（NodePackage 权威 schema）
- * b. `key`（需 linkId）→ connectable 按 link_id 解析（RCS loadConnectableNodeActions 语义），
+ * b. 纯数字 → 先按 legacy 后端 id 走 getActionDetail（/acm/actions/:id，Long id
+ *    直接作创建身份）；未命中（空 data 信封 / 查询失败）回退按 action_key 走
+ *    connectable——后端 id 与 action_key 是两个数字空间，钉钉等连接器的
+ *    action_key 即长数字形态，仅凭形态无法区分归属
+ * c. `key`（需 linkId）→ connectable 按 link_id 解析（RCS loadConnectableNodeActions 语义），
  *    创建身份遵循 RCS resolveClassicCreateActionId：Long id 直接用，否则 '0' 哨兵
  *    （真实身份是 action_key + action_ver）
- * c. 纯数字 legacy 动作 id 不再支持（/acm/actions/:id 已移除）
+ *
+ * ctx.scene 为 connectable 检索场景值：MCP 流（含 MCP_TRIGGER_NODE）需传 'mcp'，
+ * 缺省空串（常规自动化）。
  */
 async function resolveAction(actionId, ctx) {
     const ref = parseActionIdRef(actionId);
@@ -80,12 +93,23 @@ async function resolveAction(actionId, ctx) {
         const nodeSchema = await (0, node_1.getActionNodeSchema)(ref.key, ref.version);
         return nodeSchemaToAction(nodeSchema);
     }
-    if (!ref.key || !ctx.linkId) {
+    if (!ref.key) {
+        try {
+            const legacy = await (0, node_1.getActionDetail)(actionId);
+            if (legacy)
+                return legacy;
+        }
+        catch {
+            // legacy 数字 id 查询失败：可能是 action_key 形态的长数字，回退 connectable
+        }
+        ref.key = actionId;
+    }
+    if (!ctx.linkId) {
         return undefined;
     }
     const result = await (0, knowledge_1.searchNodesByCategory)({
         mode: 'independent',
-        scene: '',
+        scene: ctx.scene ?? '',
         linkId: ctx.linkId,
         flowId: ctx.flowId,
         trigger: ctx.trigger || false,
@@ -101,21 +125,21 @@ async function resolveAction(actionId, ctx) {
     }
     return matched;
 }
-/** RCS classicNodeActionIdentity：创建接口需要 Long action_id；非 Long（字符串 key 等）用 '0' 哨兵 */
+/**
+ * RCS classicNodeActionIdentity：创建接口需要 Long 后端 action_id；非 Long 用 '0' 哨兵
+ * （真实身份是 action_key + action_ver）。
+ * connectable 归一化把 id 改写为 action_key（UI 身份），真后端 id 在 backend_action_id，
+ * 因此优先取后者；legacy getActionDetail 等未改写语义的数据源回退取 id。
+ * 不可误取被改写后的 id：钉钉等连接器的 action_key 是纯数字长串，会骗过 /^\d+$/，
+ * 服务端按实体 id 查不到动作直接 NPE。
+ */
 function toClassicCreateActionId(action) {
-    const raw = action.id;
+    const raw = action.backend_action_id ?? action.id;
     if (raw !== undefined && raw !== null && /^\d+$/.test(String(raw))) {
         return String(raw);
     }
     return '0';
 }
-/** 纯数字 id 已随旧 API 移除，给出引导文案 */
-function actionNotFoundMessage(actionId) {
-    if (/^\d+$/.test(actionId.trim())) {
-        return `未找到动作 ${actionId}：本版本不再支持纯数字动作 id，请使用 action_key 或 action_key@version（可用 knowledge actions 查看）`;
-    }
-    return `未找到动作 ${actionId}`;
-}
 function nodeSchemaToAction(nodeSchema) {
     return {
         // legacy 哨兵：仅创建接口需要 action_id，不能作为动作持久身份
@@ -153,12 +177,28 @@ function registerFlowNode(flowCmd) {
                 return;
             }
             if (options.json) {
-                (0, output_1.printStructuredResult)({ ok: true, data: nodeDetail });
+                // NodePackage 信封解包：properties 解包为业务字段，
+                // proxy_id / mcp_tool_description 单独识别（envelope 字段）
+                const envelope = (0, nodeEnvelope_1.unwrapNodeDetailEnvelope)(nodeDetail);
+                const data = { ...nodeDetail };
+                if (Object.keys(envelope.properties).length > 0) {
+                    data.properties = envelope.properties;
+                }
+                if (envelope.proxyId !== undefined) {
+                    data.proxy_id = envelope.proxyId;
+                }
+                if (envelope.mcpToolDescription !== undefined) {
+                    data.mcp_tool_description = envelope.mcpToolDescription;
+                }
+                (0, output_1.printStructuredResult)({ ok: true, data });
                 return;
             }
             const nd = nodeDetail;
             const pos = nd.position;
             const cs = nd.config_schema;
+            // NodePackage 信封解包：properties 可能被包裹为
+            // { properties: {...}, account_id, proxy_id, mcp_tool_description }
+            const envelope = (0, nodeEnvelope_1.unwrapNodeDetailEnvelope)(nd);
             (0, output_1.printHeader)(`节点详情: ${nd.id || nodeId}`);
             (0, output_1.printKeyValue)([
                 ['节点 ID', String(nd.n_id || nd.id || '-')],
@@ -171,7 +211,21 @@ function registerFlowNode(flowCmd) {
                 ['描述', String(nd.description || '(无)')],
                 ['账号 ID', String(nd.account_id || '(无)')],
                 ['账号 Schema ID', String(cs?.account_schema_id || nd.account_schema_id || '(无)')],
+                [
+                    '代理 ID',
+                    envelope.proxyId ? (envelope.proxyId === '0' ? '(不使用)' : envelope.proxyId) : '(无)',
+                ],
             ]);
+            if (envelope.mcpToolDescription) {
+                (0, output_1.printSubHeader)('MCP 工具描述');
+                console.log(envelope.mcpToolDescription);
+            }
+            // SwitchNode 端口约定提示：分支 id 即输出端口名，编辑名称/条件不影响端口
+            if (nd.node_type === 'SwitchNode') {
+                (0, output_1.printSubHeader)('Switch 分支端口说明');
+                (0, output_1.printInfo)('分支 id 即输出端口名（连线目标端口），修改分支名称或条件不会改变端口名');
+                (0, output_1.printInfo)(`分支 id 必须以 "branch" 开头且不得为 "default-branch"（默认分支为固定端口），修改 id 会导致原有连线断链`);
+            }
             if (cs?.sub_params && Array.isArray(cs.sub_params) && cs.sub_params.length > 0) {
                 const subParams = cs.sub_params;
                 (0, output_1.printSubHeader)(`配置参数 (${subParams.length})`);
@@ -201,9 +255,11 @@ function registerFlowNode(flowCmd) {
                 });
                 (0, output_1.printTable)(headers, rows);
             }
-            if (nodeDetail.properties && Object.keys(nodeDetail.properties).length > 0) {
+            if (nodeDetail.properties &&
+                Object.keys(nodeDetail.properties).length > 0 &&
+                Object.keys(envelope.properties).length > 0) {
                 (0, output_1.printSubHeader)('当前属性值');
-                (0, output_1.printJson)(nodeDetail.properties);
+                (0, output_1.printJson)(envelope.properties);
             }
             if (nodeDetail.error_handler) {
                 (0, output_1.printSubHeader)('错误处理配置');
@@ -269,8 +325,8 @@ function registerFlowNode(flowCmd) {
         .requiredOption('--flow-id <flowId>', '连接流 ID')
         .requiredOption('--connector-id <connectorId>', '连接器 ID')
         .requiredOption('--action-id <actionId>', ACTION_ID_HELP)
-        .option('--trigger', '作为触发器节点（流中第一个节点建议启用）', false)
-        .option('--node-type <type>', '节点类型或动作类型')
+        .option('--trigger', '作为触发器节点（等价于 --node-type StartEventNode，二者不可同时指定；流中第一个节点建议启用）', false)
+        .option('--node-type <type>', `节点类型（${helpers_1.VALID_CREATE_NODE_TYPES.join(' / ')}；默认 ActionNode，触发器为 StartEventNode）`)
         .option('--account-id <id>', '账号实例 ID（需要账号鉴权时指定）')
         .option('--error-handler-file <path>', '错误处理配置 JSON 文件')
         .option('--name <name>', '节点名称，描述节点用途')
@@ -287,13 +343,44 @@ function registerFlowNode(flowCmd) {
             const flowId = options.flowId;
             const connectorId = options.connectorId;
             const actionId = options.actionId;
+            // --trigger 与 --node-type 互斥：--trigger 等价于 --node-type StartEventNode，
+            // 同时指定时语义冲突（trigger 推断与显式类型可能矛盾），发请求前提前拦截
+            if (options.trigger && options.nodeType) {
+                const msg = '--trigger 与 --node-type 不能同时指定（--trigger 等价于 --node-type StartEventNode，二者只需其一）';
+                if (options.json) {
+                    (0, output_1.printStructuredResult)({ ok: false, message: msg });
+                }
+                else {
+                    (0, output_1.printError)(msg);
+                }
+                process.exitCode = exit_code_1.ExitCode.FAILURE;
+                return;
+            }
+            // --node-type 是显式用户输入，入口处即校验合法性（无需等动作解析，失败更快）
+            if (options.nodeType) {
+                const nodeTypeError = (0, helpers_1.validateNodeTypeValue)(options.nodeType, '--node-type 参数');
+                if (nodeTypeError) {
+                    if (options.json) {
+                        (0, output_1.printStructuredResult)({
+                            ok: false,
+                            message: nodeTypeError,
+                            validNodeTypes: [...helpers_1.VALID_CREATE_NODE_TYPES],
+                        });
+                    }
+                    else {
+                        (0, output_1.printError)(nodeTypeError);
+                    }
+                    process.exitCode = exit_code_1.ExitCode.FAILURE;
+                    return;
+                }
+            }
             (0, output_1.printInfo)(`获取连接流 ${flowId} 的详情...`);
             const flow = await (0, flow_1.getFlowDetail)(flowId);
             if ((0, helpers_1.checkFlowNotOnline)(flow, !!options.json))
                 return;
             const nodes = flow.nodes || [];
             const isFirstNode = nodes.length === 0;
-            if (isFirstNode && !options.trigger && options.node_type !== 'StartEventNode') {
+            if (isFirstNode && !options.trigger && !(0, node_type_1.isTriggerNodeType)(options.nodeType ?? '')) {
                 const msg = '流中尚无节点，建议添加 --trigger 标志创建触发器节点';
                 if (options.json) {
                     (0, output_1.printStructuredResult)({ ok: false, message: msg });
@@ -306,12 +393,19 @@ function registerFlowNode(flowCmd) {
             const defaultPos = (0, helpers_1.calcDefaultPosition)(nodes);
             let posX = options.positionX !== undefined ? Number(options.positionX) : defaultPos.x;
             let posY = options.positionY !== undefined ? Number(options.positionY) : defaultPos.y;
-            const trigger = options.trigger || options.node_type === 'StartEventNode' || false;
+            // 触发器推断：--trigger 或显式指定触发器类节点类型
+            // （StartEventNode / UserSyncAiNode / UserPushAiNode，见 constants/node-type）
+            const trigger = options.trigger || (0, node_type_1.isTriggerNodeType)(options.nodeType ?? '') || false;
+            // MCP 流场景值：流中含 MCP_TRIGGER_NODE 即 MCP 流，动作检索 scene 需传 'mcp'
+            // （本次显式创建 MCP_TRIGGER_NODE 时同样按 MCP 场景检索）
+            const isMcpScene = nodes.some((n) => n.node_type === 'MCP_TRIGGER_NODE') ||
+                options.nodeType === 'MCP_TRIGGER_NODE';
             (0, output_1.printInfo)(`解析动作 ${actionId}...`);
             const action = await resolveAction(actionId, {
                 linkId: connectorId,
                 flowId,
                 trigger,
+                scene: isMcpScene ? 'mcp' : '',
             });
             if (action && !action.id) {
                 // legacy 哨兵：创建接口要求必传 action_id，NodePackage 动作数字 id <=0，
@@ -319,7 +413,7 @@ function registerFlowNode(flowCmd) {
                 action.id = '0';
             }
             if (!action) {
-                const msg = actionNotFoundMessage(actionId);
+                const msg = `未找到动作 ${actionId}`;
                 if (options.json) {
                     (0, output_1.printStructuredResult)({ ok: false, message: msg });
                 }
@@ -368,13 +462,18 @@ function registerFlowNode(flowCmd) {
                         return;
                     }
                     else {
-                        const msg = '未找到可用账号实例，请先创建账号';
+                        const msg = `未找到可用账号实例 (account_schema_id: ${accountSchemaId})，可先运行: ai-flow flow account create ${connectorId} --account-schema-id ${accountSchemaId} --data '<凭据JSON>'`;
                         if (options.json) {
-                            (0, output_1.printStructuredResult)({ ok: false, message: msg });
+                            (0, output_1.printStructuredResult)({
+                                ok: false,
+                                message: msg,
+                                hint: `flow account create ${connectorId} --account-schema-id ${accountSchemaId}`,
+                            });
                         }
                         else {
                             (0, output_1.printError)(msg);
                         }
+                        process.exitCode = exit_code_1.ExitCode.FAILURE;
                         return;
                     }
                 }
@@ -402,19 +501,60 @@ function registerFlowNode(flowCmd) {
                 posY = Number(ovPos.y) || posY;
             }
             let config;
+            let appliedDefaults = [];
             if (hasNodeSchema) {
-                // node_schema 模式：properties 直接透传，不经过 deepMerge
-                config = {
-                    properties: overrideValues?.properties ?? {},
-                };
+                // node_schema 模式：递归填充 input_fields 默认值后，浅合并用户 override
+                const inputFields = (action.node_schema?.input_fields ?? []);
+                // PROXY 字段误写拦截：对照 input_fields 中 type=PROXY 的字段
+                const proxyMisuse = (0, helpers_1.findProxyFieldMisuse)(overrideValues?.properties, inputFields);
+                if (proxyMisuse.length > 0) {
+                    const msg = proxyMisuse.join('\n');
+                    if (options.json) {
+                        (0, output_1.printStructuredResult)({ ok: false, message: msg });
+                    }
+                    else {
+                        (0, output_1.printError)(msg);
+                    }
+                    process.exitCode = exit_code_1.ExitCode.FAILURE;
+                    return;
+                }
+                const { properties, applied } = (0, helpers_1.buildNodeSchemaDefaults)(inputFields);
+                const userProps = overrideValues?.properties ?? {};
+                const userKeys = new Set(Object.keys(userProps));
+                config = { properties: { ...properties, ...userProps } };
+                appliedDefaults = applied.filter((e) => !userKeys.has(e.field));
             }
             else {
-                config = (0, format_1.deepMerge)({ properties: action.config_schema }, overrideValues ?? {});
+                // classic 模式：先按注册表填充默认值，再 deepMerge 用户 override（override 优先）
+                const built = (0, helpers_1.buildClassicConfigWithDefaults)(action.config_schema ?? {}, overrideValues);
+                config = built.config;
+                appliedDefaults = built.applied;
             }
-            const defaultNodeType = trigger ? 'StartEventNode' : 'ActionNode';
-            const node_type = options.nodeType || action.action_type || defaultNodeType;
-            if (isFirstNode && node_type !== 'StartEventNode') {
-                const msg = '首个节点 nodeType 应该是 StartEventNode';
+            // legacy 详情接口的 action_type 是 DB 原值，不能直接当 nodeType，按 v2 规则推算
+            // （connectable/v2 的 action_type 已是终值，推算幂等；--node-type 显式指定优先）
+            const node_type = options.nodeType ||
+                (0, helpers_1.deriveNodeTypeFromAction)(action.action_type, action.node_struct, trigger);
+            // --node-type 已在入口校验；此处只兜底推算结果（推算输出恒为合法值，
+            // 此检查作为 payload 正确性的最后防线保留）
+            if (!options.nodeType) {
+                const nodeTypeError = (0, helpers_1.validateNodeTypeValue)(node_type, 'action_type 推算');
+                if (nodeTypeError) {
+                    if (options.json) {
+                        (0, output_1.printStructuredResult)({
+                            ok: false,
+                            message: nodeTypeError,
+                            validNodeTypes: [...helpers_1.VALID_CREATE_NODE_TYPES],
+                        });
+                    }
+                    else {
+                        (0, output_1.printError)(nodeTypeError);
+                    }
+                    process.exitCode = exit_code_1.ExitCode.FAILURE;
+                    return;
+                }
+            }
+            if (isFirstNode && !(0, node_type_1.isTriggerNodeType)(node_type)) {
+                const msg = `首个节点应为触发器类型（${[...node_type_1.TRIGGER_NODE_TYPES].join(' / ')}）`;
                 if (options.json) {
                     (0, output_1.printStructuredResult)({ ok: false, message: msg });
                 }
@@ -423,6 +563,13 @@ function registerFlowNode(flowCmd) {
                 }
                 return;
             }
+            // NodePackage 信封对齐：PROXY 字段提升为顶层 proxy_id（'0'=不使用）。
+            // 默认值填充可能注入 PROXY 字段（注册表默认 ''），此处统一剥除。
+            if (hasNodeSchema) {
+                const inputFields = (action.node_schema?.input_fields ?? []);
+                const extracted = (0, nodeEnvelope_1.extractProxyField)(config.properties ?? {}, inputFields);
+                config = { properties: extracted.properties };
+            }
             const payload = {
                 ...config,
                 flow_id: flowId,
@@ -436,6 +583,13 @@ function registerFlowNode(flowCmd) {
             if (accountId) {
                 payload.account_id = accountId;
             }
+            // 信封顶层宿主字段：--data 中的 proxy_id / mcp_tool_description 自动转发
+            if (overrideValues?.proxy_id !== undefined) {
+                payload.proxy_id = (0, nodeEnvelope_1.normalizeProxyId)(overrideValues.proxy_id);
+            }
+            if (overrideValues?.mcp_tool_description !== undefined) {
+                payload.mcp_tool_description = String(overrideValues.mcp_tool_description);
+            }
             if (hasNodeSchema) {
                 // node_schema.key/version 是权威身份；action_ver 直接字段兜底
                 // （node_schema 缺失但 action_ver 存在的场景）
@@ -461,15 +615,34 @@ function registerFlowNode(flowCmd) {
                 }
             }
             else if (configSchema) {
-                if ((0, helpers_1.checkPropertyValidation)((0, format_1.validateNodePropertyValues)(configSchema), !!options.json))
+                // 校验填充默认值后的 schema（value 已填充，必填校验更准确）；
+                // 类型/格式仅校验用户显式提供的字段——schema 预置值不拦 create
+                // （实测：successExp 类 JSON 控件预置 JS 表达式默认值曾被误拦）
+                if ((0, helpers_1.checkPropertyValidation)((0, format_1.validateNodePropertyValues)(config.properties ?? configSchema, { userFields: (0, format_1.collectUserFieldNames)(overrideValues?.properties) }), !!options.json))
                     return;
             }
             if (!hasNodeSchema && configSchema) {
+                // rcs 对齐：is_null / is_not_null 条件 value 提交前归一为空字符串
+                if (node_type === 'SwitchNode') {
+                    (0, switchBranch_1.normalizeSwitchBranchNullConditionValues)(payload);
+                }
                 if ((0, helpers_1.checkSpecialNodeValidation)((0, format_1.validateSpecialNodeType)(node_type, payload, configSchema), !!options.json))
                     return;
             }
             (0, output_1.printInfo)('正在创建节点...');
             const result = await (0, node_1.createNode)(payload);
+            // 服务端 200 但未返回节点数据（信封既无失败信号也无节点体）：不能当作创建成功
+            if (!result || typeof result !== 'object') {
+                const msg = '服务端未返回节点数据（节点可能未创建），请用 flow node list --flow-id 读回确认';
+                if (options.json) {
+                    (0, output_1.printStructuredResult)({ ok: false, message: msg });
+                }
+                else {
+                    (0, output_1.printError)(msg);
+                }
+                process.exitCode = exit_code_1.ExitCode.FAILURE;
+                return;
+            }
             const resultObj = result;
             // Loop/SelfLoop 需要自环边（loop → input），提示补连而不自动写流（CLI 无状态，避免隐式副作用）
             const selfLoopHint = payload.node_type === 'LoopNode' || payload.node_type === 'SelfLoopNode'
@@ -492,6 +665,19 @@ function registerFlowNode(flowCmd) {
                     jsonResult.customName = options.name;
                 if (options.note !== undefined)
                     jsonResult.note = options.note;
+                if (payload.proxy_id !== undefined)
+                    jsonResult.proxyId = payload.proxy_id;
+                if (payload.mcp_tool_description !== undefined) {
+                    jsonResult.mcpToolDescription = payload.mcp_tool_description;
+                }
+                if (appliedDefaults.length > 0) {
+                    // 区分「已填默认值」与「用户覆盖」：appliedDefaults 仅含未被 override 的默认填充
+                    jsonResult.appliedDefaults = appliedDefaults;
+                    jsonResult.appliedDefaultsCount = appliedDefaults.length;
+                }
+                if (overrideValues?.properties) {
+                    jsonResult.userOverrides = Object.keys(overrideValues.properties);
+                }
                 (0, output_1.printStructuredResult)(jsonResult);
             }
             else {
@@ -515,6 +701,15 @@ function registerFlowNode(flowCmd) {
                 if (accountId) {
                     pairs.push(['账号 ID', accountId]);
                 }
+                if (payload.proxy_id !== undefined) {
+                    pairs.push([
+                        '代理 ID',
+                        payload.proxy_id === '0' ? '(不使用)' : String(payload.proxy_id),
+                    ]);
+                }
+                if (payload.mcp_tool_description !== undefined) {
+                    pairs.push(['MCP 工具描述', String(payload.mcp_tool_description)]);
+                }
                 if (options.errorHandlerFile) {
                     pairs.push(['错误处理', options.errorHandlerFile]);
                 }
@@ -522,6 +717,13 @@ function registerFlowNode(flowCmd) {
                     pairs.push(['配置文件', options.dataFile]);
                 else if (options.data)
                     pairs.push(['配置数据', '--data']);
+                if (appliedDefaults.length > 0) {
+                    (0, output_1.printSubHeader)(`已填默认值 (${appliedDefaults.length})`);
+                    for (const d of appliedDefaults) {
+                        const displayVal = typeof d.value === 'object' ? JSON.stringify(d.value) : String(d.value);
+                        console.log(`  ${chalk_1.default.cyan(d.path)} = ${displayVal}${chalk_1.default.gray(' (默认值)')}`);
+                    }
+                }
                 (0, output_1.printKeyValue)(pairs);
                 if (selfLoopHint)
                     (0, output_1.printInfo)(selfLoopHint);
@@ -617,6 +819,10 @@ function registerFlowNode(flowCmd) {
             if ((0, helpers_1.checkFlowNotOnline)(nodeFlow, !!options.json))
                 return;
             const nd = nodeDetail;
+            // NodePackage 信封解包：properties 可能被包裹为
+            // { properties: {...}, account_id, proxy_id, mcp_tool_description }
+            const existingEnvelope = (0, nodeEnvelope_1.unwrapNodeDetailEnvelope)(nd);
+            const existingProps = existingEnvelope.properties;
             const hasNodeSchema = !!(nd.action_key && nd.action_ver);
             // node_schema 模式：优先 getActionNodeSchema 拿权威 schema（action_key@action_ver）
             let nodeSchema;
@@ -628,16 +834,20 @@ function registerFlowNode(flowCmd) {
                     // 获取失败则回退到旧模式
                 }
             }
-            // --action-id 指定时按新身份解析（三种形式）
+            // --action-id 指定时按新身份解析（三种形式）；
+            // 触发器节点与 MCP 流（含 MCP_TRIGGER_NODE）分别影响检索的 trigger / scene 参数
             let replacedAction;
             if (options.actionId) {
+                const isMcpScene = (nodeFlow.nodes || []).some((n) => n.node_type === 'MCP_TRIGGER_NODE') ||
+                    nd.node_type === 'MCP_TRIGGER_NODE';
                 replacedAction = await resolveAction(options.actionId, {
                     linkId: options.connectorId || nd.connector_id || undefined,
                     flowId,
-                    trigger: nd.node_type === 'StartEventNode',
+                    trigger: (0, node_type_1.isTriggerNodeType)(String(nd.node_type || '')),
+                    scene: isMcpScene ? 'mcp' : '',
                 });
                 if (!replacedAction) {
-                    const msg = actionNotFoundMessage(options.actionId);
+                    const msg = `未找到动作 ${options.actionId}`;
                     if (options.json)
                         (0, output_1.printStructuredResult)({ ok: false, message: msg });
                     else
@@ -650,7 +860,6 @@ function registerFlowNode(flowCmd) {
             }
             let updateData;
             if (nodeSchema) {
-                const existingProps = nd.properties ?? {};
                 const pos = nd.position ?? { x: 0, y: 0 };
                 updateData = {
                     flow_id: flowId,
@@ -665,6 +874,13 @@ function registerFlowNode(flowCmd) {
                         ? (replacedAction.node_schema?.version ?? replacedAction.action_ver)
                         : nodeSchema.version,
                 };
+                // 信封顶层宿主字段回传：proxy_id（'0'=不使用）/ mcp_tool_description
+                if (existingEnvelope.proxyId !== undefined) {
+                    updateData.proxy_id = existingEnvelope.proxyId;
+                }
+                if (existingEnvelope.mcpToolDescription !== undefined) {
+                    updateData.mcp_tool_description = existingEnvelope.mcpToolDescription;
+                }
             }
             else {
                 updateData = {
@@ -685,16 +901,38 @@ function registerFlowNode(flowCmd) {
             const configValues = (0, helpers_1.resolveDataOption)(options, helpers_1.NODE_UPDATE_DATA_SCHEMA);
             if (configValues) {
                 if (hasNodeSchema && configValues.properties) {
+                    // PROXY 字段误写拦截：对照权威 schema 的 input_fields
+                    const proxyMisuse = (0, helpers_1.findProxyFieldMisuse)(configValues.properties, nodeSchema?.input_fields ?? []);
+                    if (proxyMisuse.length > 0) {
+                        const msg = proxyMisuse.join('\n');
+                        if (options.json) {
+                            (0, output_1.printStructuredResult)({ ok: false, message: msg });
+                        }
+                        else {
+                            (0, output_1.printError)(msg);
+                        }
+                        process.exitCode = exit_code_1.ExitCode.FAILURE;
+                        return;
+                    }
                     // node_schema 模式：properties 浅合并，不经过 deepMerge
-                    const existingProps = updateData.properties ?? {};
+                    const currentProps = updateData.properties ?? {};
                     updateData.properties = {
-                        ...existingProps,
+                        ...currentProps,
                         ...configValues.properties,
                     };
                 }
                 else {
                     updateData = (0, format_1.deepMerge)(updateData, configValues);
                 }
+                // 信封顶层宿主字段：patch 中的 proxy_id / mcp_tool_description 提升为信封字段
+                if (hasNodeSchema) {
+                    if (configValues.proxy_id !== undefined) {
+                        updateData.proxy_id = (0, nodeEnvelope_1.normalizeProxyId)(configValues.proxy_id);
+                    }
+                    if (configValues.mcp_tool_description !== undefined) {
+                        updateData.mcp_tool_description = String(configValues.mcp_tool_description);
+                    }
+                }
             }
             if (options.validateVars && configValues) {
                 if (await (0, helpers_1.validateVariableRefs)(configValues, flowId, nodeId, !!options.json))
@@ -734,17 +972,27 @@ function registerFlowNode(flowCmd) {
             if (updateData.properties) {
                 if (hasNodeSchema) {
                     const inputFields = (nodeSchema?.input_fields ?? []);
+                    // 信封对齐：properties 中不允许残留 PROXY 字段（提交前统一剥除）
+                    updateData.properties = (0, nodeEnvelope_1.extractProxyField)(updateData.properties, inputFields).properties;
                     if (inputFields.length > 0) {
                         if ((0, helpers_1.checkPropertyValidation)((0, helpers_1.validateNodeSchemaProperties)(updateData.properties, inputFields), !!options.json))
                             return;
                     }
                 }
                 else {
-                    if ((0, helpers_1.checkPropertyValidation)((0, format_1.validateNodePropertyValues)(updateData.properties), !!options.json))
+                    // 类型/格式仅校验 patch 显式触达的字段：节点既有值（含 schema 预置）
+                    // 由平台负责，不因历史遗留值拦死 update
+                    if ((0, helpers_1.checkPropertyValidation)((0, format_1.validateNodePropertyValues)(updateData.properties, {
+                        userFields: (0, format_1.collectUserFieldNames)(configValues?.properties),
+                    }), !!options.json))
                         return;
                 }
             }
             if (!hasNodeSchema) {
+                // rcs 对齐：is_null / is_not_null 条件 value 提交前归一为空字符串
+                if (String(nd.node_type) === 'SwitchNode') {
+                    (0, switchBranch_1.normalizeSwitchBranchNullConditionValues)(updateData);
+                }
                 if ((0, helpers_1.checkSpecialNodeValidation)((0, format_1.validateSpecialNodeType)(String(nd.node_type), updateData, nd.config_schema), !!options.json))
                     return;
             }
@@ -780,6 +1028,11 @@ function registerFlowNode(flowCmd) {
                     result.actionId = options.actionId;
                 if (options.accountId)
                     result.accountId = options.accountId;
+                if (updateData.proxy_id !== undefined)
+                    result.proxyId = updateData.proxy_id;
+                if (updateData.mcp_tool_description !== undefined) {
+                    result.mcpToolDescription = updateData.mcp_tool_description;
+                }
                 if (sampleOutput !== null)
                     result.sampleOutput = sampleOutput;
                 (0, output_1.printStructuredResult)(result);
@@ -806,6 +1059,12 @@ function registerFlowNode(flowCmd) {
                     pairs.push(['动作', options.actionId]);
                 if (options.accountId)
                     pairs.push(['账号 ID', options.accountId]);
+                if (updateData.proxy_id !== undefined) {
+                    pairs.push([
+                        '代理 ID',
+                        updateData.proxy_id === '0' ? '(不使用)' : String(updateData.proxy_id),
+                    ]);
+                }
                 if (options.errorHandlerFile)
                     pairs.push(['错误处理', options.errorHandlerFile]);
                 if (sampleOutput !== null)

package/dist/commands/flow/offline.js

@@ -35,7 +35,8 @@ function registerFlowOffline(flowCmd) {
             const flow = await (0, flow_1.getFlowDetail)(flowId);
             const currentStatus = flow.op_status;
             if (currentStatus === 'OFFLINE' || currentStatus === 'UNPUBLISHED') {
-                const msg = `流程已处于 ${(0, helpers_1.formatOpStatus)(currentStatus)} 状态，无需重复下线`;
+                // message 需保持纯文本（--json 模式禁止 ANSI 颜色码），着色交给 printWarning/printError
+                const msg = `流程已处于 ${helpers_1.OP_STATUS_MAP[currentStatus] || currentStatus} 状态，无需重复下线`;
                 if (options.json) {
                     (0, output_1.printStructuredResult)({ ok: false, message: msg });
                 }
@@ -45,7 +46,7 @@ function registerFlowOffline(flowCmd) {
                 return;
             }
             if (currentStatus === 'ONLINE_ING') {
-                const msg = `流程正在升级中（${(0, helpers_1.formatOpStatus)(currentStatus)}），请等待升级完成后再执行下线`;
+                const msg = `流程正在升级中（${helpers_1.OP_STATUS_MAP[currentStatus] || currentStatus}），请等待升级完成后再执行下线`;
                 if (options.json) {
                     (0, output_1.printStructuredResult)({ ok: false, message: msg });
                 }