lan-low-code-cli 2.7.0 → 2.8.1

package/README.md

@@ -273,6 +273,9 @@ llc operation create --form-id <fdId> --name 批量归档 --code archive \
   --type script --script @archive.js
 llc operation create --form-id <fdId> --name 转办 --code transfer \
   --type dialog --dialog-id <对话框id>
+# 绑定动作流（按钮由后端执行动作流）
+llc operation create --form-id <fdId> --name 运行闭环验证 --code runFlow \
+  --trigger-flow <动作流fdId>
 llc operation get --id <operationId>
 llc operation update --id <operationId> --type script \
   --script @examples/operation-script-modal-table.js   # 把已有按钮改成脚本模式
@@ -283,7 +286,10 @@ llc operation delete --id <operationId> --yes   # 被页面引用时拒绝
 ```
 
 - `--type`：`link`（fdType=2 / fdViewType=4，需 `--url`）、`script`（3 / 5，需 `--script`，支持 `@文件`）、
-  `dialog`（3 / 1，需 `--dialog-id`）
+  `dialog`（3 / 1，需 `--dialog-id`）；或改用 `--trigger-flow <动作流fdId>` 绑定动作流
+  （写入 `fdTriggerType=3`、`fdTriggerId`、`fdTriggerCode`、`fdTriggerModel`，可配 `--inc-params`）
+- `--trigger-flow` 只接受 `StartActiveNode` + 已启用（`fdStatus=1`）+ `fdOperateTrigger=true` 的动作流；
+  挂载后用 `llc flow run --operation-id <opId> --view-id <listViewId> --yes` 可实际执行并校验 `success`
 - `--position`：`list`（默认，列表视图）/ `view`（查看视图）
 - 默认不要求勾选数据；需要“先勾选数据再执行”时加 `--need-select`（链接会按接口调用，`fdUrlType=2`）
 - `--dry-run` 只打印请求体；新建操作默认仅管理员可用
@@ -333,6 +339,7 @@ llc flow apply --spec @flow.json --app-code cli-test --resolve-schema       #
 llc flow apply --spec @flow.json --app-code cli-test --resolve-schema --yes --enable --json
 llc flow diff --id <flowId> --spec @flow.json --resolve-schema              # 回读比对（默认忽略坐标）
 llc flow script --id <flowId> --out call-flow.js                            # 生成 MKXFORM.flow_<code> 脚本
+llc flow run --operation-id <opId> --view-id <listViewId> --yes --json     # 执行绑定动作流的按钮
 llc flow disable --id <flowId> --yes
 llc flow delete  --id <flowId> --yes
 ```
@@ -356,6 +363,16 @@ llc flow delete  --id <flowId> --yes
 这两个端点要求 `entityId` 带 `sys-modeling#` 前缀（CLI 自动补），裸 id 会返回 500。
 失败默认只告警，`--strict-schema` 升级为错误。
 
+**节点必填校验**（复刻 IDE 规则表与豁免逻辑）：
+
+- `TransformNode`：必填 `outParam` 与 `outputParamMapping`（`valueFormula` 或非空 `pointMappings`）；
+  `outParam` 为空时平台会豁免映射校验，但 `outParam` 本身仍必填
+- `ExecuteNode` / `InterfaceNode` / `SubActionNode` / `FlowBotsNode`：必填各自编码字段，存在入参 Schema 时必填参数映射
+- `BranchNode`：必填 `conditionType` / `flowWay` 及匹配的 `formulaConfig` / `ruleConfig`（有分支出边时自动生成）
+- `LoopNode`：必填 `loopDefine.type`；`MessageNode`：按 `subjectType` / `messageLink.linkType` 校验内容与链接
+- `AddDataNode` / `AddOrUpdateNode`：分类表单或未填 `commitType` 时豁免 `flow`
+- 校验失败时输出 `field` 与修复建议，`flow validate` / `flow compile` 退出码为 `1`，不会写入环境
+
 **边界与已知限制**：
 
 - `AddDataNode` / `AddOrUpdateNode` 的 `fields` 是平台真实结构

package/dist/api/operation.js

@@ -24,4 +24,12 @@ exports.operationApi = {
         offset: 0,
         pageSize: 1000,
     }),
+    /**
+     * 执行业务操作（平台运行入口，`sysModelingMain/other`）。
+     *
+     * 实测：绑定动作流的按钮（`fdConfig.fdTriggerType=3`）会由后端执行动作流，
+     * 返回 `{ success, type:'msg', responseMsg, sysModelingOperationVO }`；
+     * 前端在 `desktop/operation/other.ts:348-357` 正是以 `data.success` 判定动作流执行成功。
+     */
+    execute: (client, request) => client.post('sys-modeling/sysModelingMain/other', request),
 };

package/dist/commands/flow.js

@@ -4,6 +4,7 @@ exports.registerFlowCommand = registerFlowCommand;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const flow_1 = require("../api/flow");
+const operation_1 = require("../api/operation");
 const client_1 = require("../client");
 const config_1 = require("../config");
 const flow_2 = require("../generator/flow");
@@ -56,12 +57,20 @@ function buildOptions(opts) {
 function printDiagnostics(result, force) {
     const errors = result.diagnostics.filter((d) => d.level === 'error');
     const warnings = result.diagnostics.filter((d) => d.level === 'warn');
-    warnings.forEach((d) => logger_1.logger.warn(`[${d.code}] ${d.message}`));
+    warnings.forEach((d) => {
+        logger_1.logger.warn(`[${d.code}] ${d.message}`);
+        if (d.hint)
+            logger_1.logger.info(logger_1.color.gray(`    ↳ ${d.hint}`));
+    });
     if (errors.length === 0) {
         logger_1.logger.success(`离线校验通过（${result.diagnostics.length - errors.length} 条提示）`);
         return;
     }
-    errors.forEach((d) => logger_1.logger.error(`[${d.code}] ${d.message}`));
+    errors.forEach((d) => {
+        logger_1.logger.error(`[${d.code}] ${d.message}`);
+        if (d.hint)
+            logger_1.logger.info(logger_1.color.gray(`    ↳ ${d.hint}`));
+    });
     if (!force) {
         throw new Error(`离线校验未通过（${errors.length} 项错误）；修正 spec 后重试，或追加 --force 仅用于查看输出`);
     }
@@ -178,6 +187,19 @@ function stripInstanceFields(node) {
     }
     return out;
 }
+function parseFdConfig(value) {
+    if (!value)
+        return {};
+    if (typeof value === 'object')
+        return value;
+    try {
+        const parsed = JSON.parse(String(value));
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
 function writeTextFile(file, text) {
     const target = (0, path_1.resolve)(process.cwd(), file.startsWith('@') ? file.slice(1) : file);
     (0, fs_1.mkdirSync)((0, path_1.dirname)(target), { recursive: true });
@@ -580,6 +602,12 @@ function registerFlowCommand(program) {
             printDiagnostics(result, Boolean(opts.force));
         }
         const isUpdate = Boolean(spec.fdId);
+        let current;
+        if (isUpdate) {
+            current = await flow_1.flowApi.get(client, String(spec.fdId));
+            if (!current?.fdId)
+                throw new Error(`动作流不存在：${spec.fdId}`);
+        }
         if (!isUpdate) {
             let unique;
             try {
@@ -592,7 +620,15 @@ function registerFlowCommand(program) {
                 throw new Error(`流程编码 ${spec.code} 在应用 ${spec.appCode} 中已存在；更换 code，或更新已有流程时在 spec 中写 fdId`);
             }
         }
-        const payload = buildPublishPayload(result);
+        // 更新时合并现有 VO，避免把 fdStatus / dynamicProps / fdCreator 等服务端字段覆盖掉
+        const payload = isUpdate
+            ? {
+                ...current,
+                ...result.basicInfo,
+                fdStatus: current?.fdStatus ?? result.basicInfo.fdStatus,
+                fdDesign: result.fdDesign,
+            }
+            : buildPublishPayload(result);
         if (!opts.yes) {
             logger_1.logger.warn(`预览模式：未写入。目标应用 ${spec.appCode}；确认 payload 后追加 --yes`);
             logger_1.logger.json(payload);
@@ -752,4 +788,52 @@ function registerFlowCommand(program) {
         if (opts.json)
             logger_1.logger.json({ fdId: opts.id, deleted: true });
     });
+    addCommonOptions(flow
+        .command('run')
+        .description('通过绑定动作流的业务操作执行一次（sysModelingMain/other）')
+        .requiredOption('--operation-id <fdId>', '绑定动作流的业务操作 id')
+        .option('--view-id <fdId>', '列表视图 id（fdListviewId）')
+        .option('--doc-id <fdId>', '当前文档 id')
+        .option('--doc-ids <ids>', '勾选文档 id，逗号分隔')
+        .option('--inc-params <json|@file>', '附加参数（commonIncParams）')
+        .option('--yes', '确认执行（动作流可能有副作用）')
+        .option('--json', '以 JSON 输出结果')).action(async (opts) => {
+        if (!opts.yes) {
+            logger_1.logger.warn('已取消：执行动作流可能有副作用，请追加 --yes 确认');
+            return;
+        }
+        const client = createClient(opts);
+        const op = await operation_1.operationApi.get(client, String(opts.operationId));
+        if (!op?.fdId)
+            throw new Error(`业务操作不存在：${opts.operationId}`);
+        const config = parseFdConfig(op.fdConfig);
+        if (Number(config.fdTriggerType) !== 3) {
+            throw new Error('该业务操作未绑定动作流（fdConfig.fdTriggerType ≠ 3）');
+        }
+        const params = { fdOprId: op.fdId };
+        if (opts.viewId)
+            params.fdListviewId = String(opts.viewId);
+        if (opts.docId)
+            params.fdId = String(opts.docId);
+        if (opts.docIds) {
+            params.fdIds = String(opts.docIds).split(',').map((s) => s.trim()).filter(Boolean);
+        }
+        if (opts.incParams)
+            params.commonIncParams = readJsonInput(String(opts.incParams), '--inc-params');
+        logger_1.logger.step(`执行动作流按钮：${op.fdName ?? op.fdId}`);
+        const result = await operation_1.operationApi.execute(client, params);
+        if (opts.json) {
+            logger_1.logger.json({
+                operationId: op.fdId,
+                success: result.success,
+                type: result.type,
+                responseMsg: result.responseMsg,
+            });
+            return;
+        }
+        if (result.success === false) {
+            throw new Error(`执行失败：${result.responseMsg ?? result.type ?? '未知原因'}`);
+        }
+        logger_1.logger.success(result.responseMsg ?? '动作流执行成功');
+    });
 }

package/dist/commands/operation.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerOperationCommand = registerOperationCommand;
 const fs_1 = require("fs");
 const path_1 = require("path");
+const flow_1 = require("../api/flow");
 const operation_1 = require("../api/operation");
 const view_1 = require("../api/view");
 const client_1 = require("../client");
@@ -18,12 +19,16 @@ const KIND_ALIAS = {
     js: 'script',
     dialog: 'dialog',
     modal: 'dialog',
+    flow: 'flow',
 };
 const KIND_META = {
     link: { fdType: 2, fdViewType: 4, label: '打开链接' },
     script: { fdType: 3, fdViewType: 5, label: '执行脚本' },
     dialog: { fdType: 3, fdViewType: 1, label: '执行业务操作（对话框）' },
+    flow: { fdType: 3, fdViewType: 1, label: '触发动作流' },
 };
+/** 动作流 fdTriggerModel.fdModelName（addOperationModal/content.tsx:981-985） */
+const FLOW_MODEL_NAME = 'com.landray.sys.modeling.process.entity.SysModelingProcess';
 /** 解析 fdConfig（后端实体不一定有顶层 fdViewType，视图类型存在 fdConfig 中） */
 function readOperationConfig(op) {
     if (!op.fdConfig)
@@ -43,7 +48,10 @@ function operationTypeLabel(op) {
         return '对话框';
     if (op.fdType === 6)
         return 'AI 能力';
-    const viewType = Number(readOperationConfig(op).fdViewType ?? op.fdViewType);
+    const config = readOperationConfig(op);
+    if (op.fdType === 3 && Number(config.fdTriggerType) === 3)
+        return '触发动作流';
+    const viewType = Number(config.fdViewType ?? op.fdViewType);
     if (op.fdType === 3)
         return viewType === 5 ? '脚本' : '无视图';
     return '有视图';
@@ -212,19 +220,22 @@ function assertOperationCode(code) {
         throw new Error('--code 需以字母开头，仅允许字母、数字、下划线、连字符');
     }
 }
-/** 从已有操作推导类型（fdType=2 为链接；fdType=3 + fdViewType=5 为脚本，其余按对话框） */
+/** 从已有操作推导类型（fdType=2 链接；fdTriggerType=3 动作流；fdViewType=5 脚本；其余对话框） */
 function detectKind(op) {
     if (op.fdType === 2)
         return 'link';
-    const viewType = Number(readOperationConfig(op).fdViewType ?? op.fdViewType);
+    const config = readOperationConfig(op);
+    if (op.fdType === 3 && Number(config.fdTriggerType) === 3)
+        return 'flow';
+    const viewType = Number(config.fdViewType ?? op.fdViewType);
     return op.fdType === 3 && viewType === 5 ? 'script' : 'dialog';
 }
-function buildCreatePayload(opts) {
+function buildCreatePayload(opts, flow) {
     const formId = String(opts.formId ?? '').trim();
     const name = String(opts.name ?? '').trim();
     const code = String(opts.code ?? '').trim();
     const rawKind = String(opts.type ?? '').trim().toLowerCase();
-    const kind = KIND_ALIAS[rawKind];
+    const kind = opts.triggerFlow ? 'flow' : KIND_ALIAS[rawKind];
     const positionRaw = String(opts.position ?? 'list').trim().toLowerCase();
     const fdPosition = positionRaw === 'view' ? 2 : positionRaw === 'list' ? 1 : 0;
     if (!formId)
@@ -232,7 +243,10 @@ function buildCreatePayload(opts) {
     assertOperationName(name);
     assertOperationCode(code);
     if (!kind)
-        throw new Error(`未知 --type：${opts.type}（可选 link | script | dialog）`);
+        throw new Error(`请指定 --type（link | script | dialog）或 --trigger-flow <动作流 fdId>`);
+    if (opts.triggerFlow && rawKind) {
+        throw new Error('--trigger-flow 与 --type 不能同时使用；触发动作流请省略 --type');
+    }
     if (!fdPosition)
         throw new Error(`未知 --position：${opts.position}（可选 list | view）`);
     const desc = opts.desc === undefined ? '' : String(opts.desc);
@@ -264,6 +278,31 @@ function buildCreatePayload(opts) {
             throw new Error('--type script 需指定 --script <代码|@文件>');
         config.fdJavaScript = readScriptValue(script);
     }
+    else if (kind === 'flow') {
+        if (!flow)
+            throw new Error('--trigger-flow 需要先加载动作流详情');
+        assertTriggerableFlow(flow);
+        config.fdTriggerType = 3;
+        config.fdTriggerId = flow.fdId;
+        config.fdTriggerCode = flow.fdCode;
+        config.fdTriggerModel = {
+            fdId: flow.fdId,
+            fdName: flow.fdName,
+            fdModelName: FLOW_MODEL_NAME,
+            fdCode: flow.fdCode,
+        };
+        const incParams = buildIncParams(opts.incParams);
+        if (incParams !== undefined)
+            config.incParams = incParams;
+        const active = flow.fdProcessActive ?? {};
+        if (active.fdFormId) {
+            // 动作流绑定了表单：按钮按当前文档 id/ids 传参
+            config.incParams = [{
+                    field: { name: active.fdDataType === 2 ? 'fdIds' : 'fdId' },
+                    value: { val: '${fdId}' },
+                }];
+        }
+    }
     else {
         const dialogId = String(opts.dialogId ?? '').trim();
         if (!dialogId)
@@ -288,19 +327,54 @@ function buildCreatePayload(opts) {
         payload.isModal = true;
     return { payload, kind };
 }
+/**
+ * 只有「主动触发 + 已启用 + 允许操作触发」的动作流才能挂到按钮上
+ * （addOperationModal/content.tsx:332-335）。
+ */
+function assertTriggerableFlow(flow) {
+    if (flow.fdStartWay !== 'StartActiveNode') {
+        throw new Error(`动作流 ${flow.fdName ?? flow.fdId} 的启动方式是 ${flow.fdStartWay ?? '(空)'}，只有 StartActiveNode 才能挂到按钮`);
+    }
+    if (flow.fdStatus !== 1) {
+        throw new Error(`动作流 ${flow.fdName ?? flow.fdId} 当前状态为 ${flow.fdStatus ?? '(空)'}，请先发布并启用（llc flow enable --id ${flow.fdId}）`);
+    }
+    const active = flow.fdProcessActive ?? {};
+    if (active.fdOperateTrigger !== true) {
+        throw new Error(`动作流 ${flow.fdName ?? flow.fdId} 未开启「操作触发」，请在 trigger.fdRunType 中包含 operate 后重新发布`);
+    }
+}
+/** --inc-params 支持 @file 或内联 JSON；返回平台要求的 [{field:{name},value:{val}}] */
+function buildIncParams(input) {
+    if (input === undefined || input === null || input === '')
+        return undefined;
+    const raw = typeof input === 'string' ? readScriptValue(input) : JSON.stringify(input);
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`--inc-params 不是合法 JSON：${err.message}`);
+    }
+    if (!Array.isArray(parsed))
+        throw new Error('--inc-params 需为数组：[{field:{name},value:{val}}]');
+    return parsed;
+}
 /**
  * 基于现有操作构造 update 请求体。
  * 显式切换类型（--type）时会重建 fdConfig 的类型相关字段，
  * 但保留权限、默认值等与类型无关的配置。
  */
-function buildUpdatePayload(current, opts) {
+function buildUpdatePayload(current, opts, flow) {
     if (current.fdType !== 2 && current.fdType !== 3) {
-        throw new Error(`该操作类型为「${operationTypeLabel(current)}」，仅支持修改自定义的链接 / 脚本 / 对话框操作`);
+        throw new Error(`该操作类型为「${operationTypeLabel(current)}」，仅支持修改自定义的链接 / 脚本 / 对话框 / 动作流操作`);
     }
     const currentKind = detectKind(current);
     const rawKind = String(opts.type ?? '').trim().toLowerCase();
     let kind = currentKind;
-    if (rawKind) {
+    if (opts.triggerFlow) {
+        kind = 'flow';
+    }
+    else if (rawKind) {
         const resolved = KIND_ALIAS[rawKind];
         if (!resolved)
             throw new Error(`未知 --type：${opts.type}（可选 link | script | dialog）`);
@@ -353,6 +427,23 @@ function buildUpdatePayload(current, opts) {
             throw new Error('脚本操作需指定 --script <代码|@文件>');
         config.fdJavaScript = script;
     }
+    else if (kind === 'flow') {
+        if (!flow)
+            throw new Error('--trigger-flow 需要先加载动作流详情');
+        assertTriggerableFlow(flow);
+        config.fdTriggerType = 3;
+        config.fdTriggerId = flow.fdId;
+        config.fdTriggerCode = flow.fdCode;
+        config.fdTriggerModel = {
+            fdId: flow.fdId,
+            fdName: flow.fdName,
+            fdModelName: FLOW_MODEL_NAME,
+            fdCode: flow.fdCode,
+        };
+        const incParams = buildIncParams(opts.incParams);
+        if (incParams !== undefined)
+            config.incParams = incParams;
+    }
     else {
         const dialogId = opts.dialogId !== undefined
             ? String(opts.dialogId).trim()
@@ -397,6 +488,14 @@ function buildUpdatePayload(current, opts) {
         payload.isModal = true;
     else
         delete payload.isModal;
+    if (kind === 'flow') {
+        // 切换为动作流时清理对话框残留字段
+        delete config.fdModal;
+        delete config.fdModalType;
+        delete config.fdModalSizeType;
+        delete config.fdModalDetail;
+        payload.fdConfig = JSON.stringify(config);
+    }
     if (opts.mobileIcon !== undefined)
         payload.fdMobileIcon = String(opts.mobileIcon);
     if (opts.enable === true)
@@ -504,16 +603,18 @@ function registerOperationCommand(program) {
     // ---------------------------------------------------------------- create
     operation
         .command('create')
-        .description('新建业务操作（支持打开链接 / 执行脚本 / 执行对话框）')
+        .description('新建业务操作（打开链接 / 执行脚本 / 执行对话框 / 触发动作流）')
         .requiredOption('--form-id <fdId>', '表单 id')
         .requiredOption('--name <name>', '操作名称（≤30）')
         .requiredOption('--code <code>', '自定义操作编码（≤15，字母开头，可含数字/下划线/连字符）')
-        .requiredOption('--type <type>', '类型：link | script | dialog')
+        .option('--type <type>', '类型：link | script | dialog；触发动作流时改用 --trigger-flow')
         .option('--position <position>', '使用位置：list（列表视图）| view（查看视图）', 'list')
         .option('--need-select', '点击前需勾选数据（默认否；仅列表视图的自定义操作有效）')
         .option('--url <url>', '打开链接地址（--type link 必填）')
         .option('--script <code|@file>', '脚本内容或 @文件（--type script 必填）')
         .option('--dialog-id <fdId>', '对话框 id（--type dialog 必填，可在平台对话框设计中获取）')
+        .option('--trigger-flow <fdId>', '绑定动作流（需 StartActiveNode + 已启用 + operateTrigger）')
+        .option('--inc-params <json|@file>', '动作流入参：[{field:{name},value:{val}}]')
         .option('--desc <text>', '描述（≤500）')
         .option('--mobile-icon <name>', '移动端图标名')
         .option('--dry-run', '只打印请求体，不提交')
@@ -521,13 +622,16 @@ function registerOperationCommand(program) {
         .option('--token <token>', '鉴权 Token（覆盖配置）')
         .option('--json', '以 JSON 输出结果')
         .action(async (opts) => {
-        const { payload, kind } = buildCreatePayload(opts);
+        const client = createClient(opts);
+        const flow = opts.triggerFlow
+            ? await flow_1.flowApi.get(client, String(opts.triggerFlow))
+            : undefined;
+        const { payload, kind } = buildCreatePayload(opts, flow);
         if (opts.dryRun) {
             logger_1.logger.info(logger_1.color.gray(`# ${KIND_META[kind].label} · 表单 ${String(opts.formId)}（dry-run）`));
             logger_1.logger.json(payload);
             return;
         }
-        const client = createClient(opts);
         logger_1.logger.step(`新建业务操作：${String(opts.name)}（${KIND_META[kind].label}）`);
         const result = await operation_1.operationApi.add(client, payload);
         const fdId = typeof result === 'string' ? result : result?.fdId;
@@ -551,6 +655,8 @@ function registerOperationCommand(program) {
         .option('--url <url>', '打开链接地址（link）')
         .option('--script <code|@file>', '脚本内容或 @文件（script）')
         .option('--dialog-id <fdId>', '对话框 id（dialog）')
+        .option('--trigger-flow <fdId>', '切换为触发动作流（需 StartActiveNode + 已启用）')
+        .option('--inc-params <json|@file>', '动作流入参：[{field:{name},value:{val}}]')
         .option('--need-select', '点击前需勾选数据')
         .option('--no-need-select', '不需要勾选数据')
         .option('--enable', '启用该操作')
@@ -570,7 +676,10 @@ function registerOperationCommand(program) {
         const current = await operation_1.operationApi.get(client, fdId);
         if (!current?.fdId)
             throw new Error(`业务操作不存在：${fdId}`);
-        const { payload, kind } = buildUpdatePayload(current, opts);
+        const flow = opts.triggerFlow
+            ? await flow_1.flowApi.get(client, String(opts.triggerFlow))
+            : undefined;
+        const { payload, kind } = buildUpdatePayload(current, opts, flow);
         if (opts.dryRun) {
             logger_1.logger.info(logger_1.color.gray(`# ${KIND_META[kind].label} · ${current.fdName}（dry-run）`));
             logger_1.logger.json(payload);

package/dist/generator/flow/schema.js

@@ -7,7 +7,7 @@
  * 必填规则来自 `configuration/nodes/utils.tsx:37-288` 与 `validate.ts:13-17`。
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CONTEXT_KEYS = exports.FLOW_CODE_PATTERN = exports.NODE_ID_PATTERN = exports.KNOWN_START_WAYS = exports.MULTI_OUT_NODE_TYPES = exports.NODE_REQUIRED = exports.NODE_DEFAULTS = exports.NODE_FIELD_WHITELIST = void 0;
+exports.CONTEXT_KEYS = exports.FLOW_CODE_PATTERN = exports.NODE_ID_PATTERN = exports.KNOWN_START_WAYS = exports.MULTI_OUT_NODE_TYPES = exports.NODE_REQUIRED_RULES = exports.NODE_DEFAULTS = exports.NODE_FIELD_WHITELIST = void 0;
 /** 节点专属字段白名单；未列出的 nodeType 视为未知类型（透传 config 并告警） */
 exports.NODE_FIELD_WHITELIST = {
     StartNode: ['startNodeDef'],
@@ -53,25 +53,166 @@ exports.NODE_DEFAULTS = {
     LoopNode: { loopDefine: { type: 'LoopArray' } },
     MessageNode: { grantPermission: true },
 };
-/** 发布前 IDE 强校验的必填字段（configuration/nodes/utils.tsx:37-288） */
-exports.NODE_REQUIRED = {
-    AddDataNode: ['dataSourceVO', 'flow', 'fields'],
-    QueryDataNode: ['target'],
-    UpdateDataNode: ['bindNode'],
-    DeleteDataNode: ['bindNode'],
-    FilterDataNode: ['bindNode'],
-    BranchNode: ['conditionType', 'flowWay'],
-    SubActionNode: ['actionFlowCode'],
-    InterfaceNode: ['apiType', 'apiMethodPath'],
-    ExecuteNode: ['executeCode'],
-    QueryStatisticsNode: ['target'],
-    AddOrUpdateNode: ['dataSourceVO', 'flow', 'fields'],
-    LoopNode: ['loopDefine'],
-    AssignValueNode: ['assignValueRuleConfigs'],
-    CreateKmReviewNode: ['kmReviewTemplate', 'fdSubject'],
-    FlowBotsNode: ['flowBotsCode'],
-    MessageNode: ['subject', 'messageTarget'],
-    MessageEliminateNode: ['eliminateRange', 'eliminateType'],
+const record = (value) => value && typeof value === 'object' && !Array.isArray(value)
+    ? value
+    : {};
+/** 节点是否有入参 Schema（决定参数映射是否必填） */
+const hasInParam = (ctx) => {
+    const inParam = record(record(ctx.node.context).context_fdInParam);
+    return Object.keys(record(inParam.properties)).length > 0;
+};
+/** Execute/Interface/SubAction/FlowBots 共用的「code + 参数映射」规则 */
+const mappingRules = (codeField, codeMessage) => [
+    { field: codeField, message: codeMessage },
+    {
+        field: 'paramMappingWay',
+        message: '参数映射不能为空',
+        read: (config) => record(config.inputParamMapping).paramMappingWay ?? 'point',
+        skipIf: (ctx) => !hasInParam(ctx),
+    },
+    {
+        field: 'fdParam',
+        message: '参数映射不能为空',
+        hint: 'inputParamMapping 需提供 valueFormula（非 point）或非空 pointMappings',
+        read: (config) => {
+            const mapping = record(config.inputParamMapping);
+            if (Object.keys(mapping).length === 0)
+                return undefined;
+            if ((mapping.paramMappingWay ?? 'point') !== 'point')
+                return mapping.valueFormula;
+            const points = mapping.pointMappings;
+            return Array.isArray(points) && points.length > 0 ? points : undefined;
+        },
+        skipIf: (ctx) => !hasInParam(ctx),
+    },
+];
+/** 分类表单 / 未选提交方式时，AddData 不要求选流程 */
+const skipFlowRequired = (ctx) => {
+    if (!ctx.config.commitType)
+        return true;
+    return String(record(ctx.config.dataSourceVO).entityId ?? '').includes('sys-modeling-main');
+};
+exports.NODE_REQUIRED_RULES = {
+    AddDataNode: [
+        { field: 'dataSourceVO', message: '目标表单不能为空' },
+        { field: 'flow', message: '选择流程不能为空', skipIf: skipFlowRequired },
+        { field: 'fields', message: '表单字段不能为空' },
+    ],
+    AddOrUpdateNode: [
+        { field: 'dataSourceVO', message: '选择表单不能为空' },
+        { field: 'flow', message: '选择流程不能为空', skipIf: skipFlowRequired },
+    ],
+    QueryDataNode: [{ field: 'target', message: '查询对象不能为空' }],
+    QueryLoopNode: [{ field: 'target', message: '查询对象不能为空' }],
+    UpdateDataNode: [{ field: 'bindNode', message: '请选择节点' }],
+    DeleteDataNode: [{ field: 'bindNode', message: '请选择删除节点' }],
+    FilterDataNode: [{ field: 'bindNode', message: '过滤节点不能为空' }],
+    BranchNode: [
+        { field: 'conditionType', message: '请设置条件' },
+        { field: 'flowWay', message: '请设置流转方式' },
+        {
+            field: 'formulaConfig',
+            message: '请设置公式定义',
+            // rule 模式免公式；有出边时编译器会按 branchFormulas 自动生成
+            skipIf: (ctx) => ctx.config.conditionType === 'rule' || ctx.outgoing > 0,
+        },
+        { field: 'ruleConfig', message: '请设置匹配规则', skipIf: (ctx) => ctx.config.conditionType === 'formula' },
+    ],
+    LoopNode: [
+        { field: 'loopType', message: '请设置循环方式', read: (config) => record(config.loopDefine).type },
+    ],
+    TransformNode: [
+        {
+            field: 'outParam',
+            message: '出参设置不能为空',
+            hint: 'config.outParam 需为输出参数 JSON Schema 字符串；可用 llc flow templates 从真实流程抽取',
+        },
+        {
+            field: 'paramMappingWay',
+            message: '参数映射不能为空',
+            read: (config) => record(config.outputParamMapping).paramMappingWay ?? 'point',
+            skipIf: (ctx) => !ctx.config.outParam,
+        },
+        {
+            field: 'fdParam',
+            message: '参数映射不能为空',
+            hint: 'outputParamMapping 需提供 valueFormula（非 point）或非空 pointMappings',
+            read: (config) => {
+                const mapping = record(config.outputParamMapping);
+                if (Object.keys(mapping).length === 0)
+                    return undefined;
+                if ((mapping.paramMappingWay ?? 'point') !== 'point')
+                    return mapping.valueFormula;
+                const points = mapping.pointMappings;
+                return Array.isArray(points) && points.length > 0 ? points : undefined;
+            },
+            skipIf: (ctx) => !ctx.config.outParam,
+        },
+    ],
+    AssignValueNode: [{ field: 'assignValueRuleConfigs', message: '赋值规则不能为空' }],
+    ExecuteNode: mappingRules('executeCode', '集成函数不能为空'),
+    InterfaceNode: mappingRules('apiMethodPath', '内部接口不能为空'),
+    SubActionNode: mappingRules('actionFlowCode', '子动作不能为空'),
+    FlowBotsNode: mappingRules('flowBotsCode', 'flowBots不能为空'),
+    MessageNode: [
+        { field: 'notifyType', message: '通知方式不能为空' },
+        { field: 'subject', message: '消息内容不能为空', skipIf: (ctx) => ctx.config.subjectType === 'TEMPLATE' },
+        {
+            field: 'templateCode',
+            message: '请选择通知模板',
+            skipIf: (ctx) => {
+                const subjectType = ctx.config.subjectType;
+                return subjectType === undefined || subjectType === '' || subjectType === 'CUSTOM';
+            },
+        },
+        {
+            field: 'linkPage',
+            message: '视图不能为空',
+            skipIf: (ctx) => {
+                const linkType = record(ctx.config.messageLink).linkType;
+                return linkType === undefined || linkType === 'default';
+            },
+        },
+        {
+            field: 'linkUrl',
+            message: '链接不能为空',
+            read: (config) => record(config.messageLink).linkUrl,
+            skipIf: (ctx) => {
+                const linkType = record(ctx.config.messageLink).linkType;
+                return linkType === undefined || linkType === 'view' || linkType === 'edit';
+            },
+        },
+    ],
+    MessageEliminateNode: [{ field: 'eventCode', message: '事件编码不允许为空' }],
+    QueryStatisticsNode: [
+        { field: 'target', message: '查询目标不能为空' },
+        {
+            field: 'statisticsConfig',
+            message: '统计维度和统计项不能全为空',
+            read: (config) => {
+                const dimensions = Array.isArray(config.statisticsDimensions) ? config.statisticsDimensions : [];
+                const items = Array.isArray(config.statisticsItems) ? config.statisticsItems : [];
+                return dimensions.length + items.length > 0 ? { dimensions, items } : undefined;
+            },
+        },
+    ],
+    CreateKmReviewNode: [
+        { field: 'kmReviewTemplate', message: '流程模板不能为空' },
+        { field: 'fdSubject', message: '流程标题不能为空' },
+        {
+            field: 'orgElement',
+            message: '创建人不能为空',
+            read: (config) => record(config.fdCreator).orgElement,
+            skipIf: (ctx) => (record(ctx.config.fdCreator).valueRule ?? 'Fixed') === 'Var',
+        },
+        {
+            field: 'formula',
+            message: '创建人不能为空',
+            read: (config) => record(config.fdCreator).formula,
+            skipIf: (ctx) => (record(ctx.config.fdCreator).valueRule ?? 'Fixed') === 'Fixed',
+        },
+        { field: 'fields', message: '表单字段不能为空' },
+    ],
 };
 /** 允许多条出边的节点（validateCommonVertex 的 getwayMap，另有 StartNode） */
 exports.MULTI_OUT_NODE_TYPES = new Set(['BranchNode', 'parallelGateway', 'StartNode']);

package/dist/generator/flow/validate.js

@@ -17,6 +17,16 @@ const err = (code, message, nodeId) => ({
 const warn = (code, message, nodeId) => ({
     level: 'warn', code, message, nodeId,
 });
+/** 与平台 validateRequired 一致：空串、空数组、null/undefined 视为未填 */
+function isBlank(value) {
+    if (value === undefined || value === null)
+        return true;
+    if (typeof value === 'string')
+        return value.trim() === '';
+    if (Array.isArray(value))
+        return value.length === 0;
+    return false;
+}
 /** 基础信息校验 */
 function validateSpec(spec) {
     const out = [];
@@ -80,9 +90,21 @@ function validateGraph(graph, spec, startWay = 'StartActiveNode') {
         }
         // 与编译器一致：默认值（如 BranchNode.conditionType / flowWay）也算已填
         const config = { ...(schema_1.NODE_DEFAULTS[node.type] ?? {}), ...(node.config ?? {}) };
-        for (const field of schema_1.NODE_REQUIRED[node.type] ?? []) {
-            if (config[field] === undefined || config[field] === null || config[field] === '') {
-                out.push(err('NODE_FIELD_REQUIRED', `节点 ${node.id}（${node.type}）缺少必填字段 ${field}`, node.id));
+        const outgoing = graph.edges.filter((edge) => edge.from === node.id).length;
+        const ruleContext = { config, node: { context: node.context }, outgoing };
+        for (const rule of schema_1.NODE_REQUIRED_RULES[node.type] ?? []) {
+            if (rule.skipIf?.(ruleContext))
+                continue;
+            const value = rule.read ? rule.read(config) : config[rule.field];
+            if (isBlank(value)) {
+                out.push({
+                    level: 'error',
+                    code: 'NODE_FIELD_REQUIRED',
+                    message: `节点 ${node.id}（${node.type}）缺少必填字段 ${rule.field}：${rule.message}`,
+                    nodeId: node.id,
+                    field: rule.field,
+                    ...(rule.hint ? { hint: rule.hint } : {}),
+                });
             }
         }
     }

package/dist/index.js

@@ -12,7 +12,7 @@ const locale_1 = require("./commands/locale");
 const operation_1 = require("./commands/operation");
 const template_1 = require("./commands/template");
 const logger_1 = require("./utils/logger");
-const VERSION = '2.7.0';
+const VERSION = '2.8.1';
 const program = new commander_1.Command();
 exports.program = program;
 program

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lan-low-code-cli",
-  "version": "2.7.0",
+  "version": "2.8.1",
   "description": "lan-low-code cli：低代码表单引擎命令行工具（创建表单、获取可用字段、自动完善表单字段）",
   "keywords": [
     "low-code",

package/skills/lan-low-code-cli/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: lan-low-code-cli
-version: 2.7.0
+version: 2.8.1
 author: Pig George
 description: Operate the Landray low-code form engine through the `llc` CLI. Use when the user asks to create, inspect, modify, publish, or delete low-code apps and forms; generate field configs; configure layouts (grid/tabs), field permissions, options, i18n, or control actions (onChange/onLoad); or run pre-publish validation. Also use for troubleshooting form loading/rendering errors.
 tags:
@@ -93,11 +93,11 @@ Always run `llc <command> --help` before inventing flags — the CLI is the sour
 | `llc app list / create / forms / delete / delete-data` | business apps (`--code` allows letters/digits/hyphen only, **no underscore**) |
 | `llc form create / list / get / publish / autofill / delete / delete-data` | form lifecycle; `create --type category\|simpleCategory` builds a category form (no business fields; templates are created in the platform designer) |
 | `llc field list / gen-key / library` | available fields |
-| `llc operation list / get / create / update / delete / attach / detach` | form business operations (link, script, dialog), including attaching to list/view pages |
+| `llc operation list / get / create / update / delete / attach / detach` | form business operations (link, script, dialog); `--trigger-flow <flowId>` binds an action flow, `--inc-params` supplies its input |
 | `llc template list / create / add-fields / delete` | category-form templates: create/append/delete templates, porting fields/views/permissions from an existing form (auto category node, bypasses official init) |
 | `llc flow spec / compile / validate` | **offline**: generate a Flow Spec, compile it into `fdDesign` with IDE-style layout, run offline validation |
 | `llc flow list / get / category / logs / schema / templates` | **read-only** action-flow queries; `templates` extracts golden node skeletons (coordinates stripped) |
-| `llc flow apply / diff / script / enable / disable / delete` | **write** action-flow lifecycle; `apply` previews by default and needs `--yes` + `--app-code` |
+| `llc flow apply / diff / script / run / enable / disable / delete` | **write** action-flow lifecycle; `apply` previews by default and needs `--yes` + `--app-code`; `run` executes a bound button via `sysModelingMain/other` |
 | `llc control list / show` | controls installed in the environment (basis for `--add-field` third segment) |
 | `llc locale list` | languages with translations available (from control i18n resources) |
 | `llc config set / show / clear` | global credentials and defaults |

package/skills/lan-low-code-cli/SKILL.zh-CN.md

@@ -1,6 +1,6 @@
 ---
 name: lan-low-code-cli
-version: 2.7.0
+version: 2.8.1
 author: Pig George
 description: 通过 `llc` CLI 操作蓝凌低代码表单引擎。适用于：创建、查看、修改、发布或删除低代码应用与表单；生成字段配置；配置布局（栅格/页签）、字段权限、选项、多语言、控件动作（onChange/onLoad）；或执行发布前校验、排查表单加载/渲染报错。
 tags:
@@ -90,11 +90,11 @@ llc config set --base-url http://<host>/data --token <X-AUTH-TOKEN>   # 一次
 | `llc app list / create / forms / delete / delete-data` | 业务应用（`--code` 仅允许字母/数字/连字符，**不允许下划线**） |
 | `llc form create / list / get / publish / autofill / delete / delete-data` | 表单生命周期；`create --type category\|simpleCategory` 建分类表单（无业务字段，模板需在平台设计器创建） |
 | `llc field list / gen-key / library` | 可用字段 |
-| `llc operation list / get / create / update / delete / attach / detach` | 表单业务操作（链接、脚本、对话框），含挂载到列表/查看视图 |
+| `llc operation list / get / create / update / delete / attach / detach` | 表单业务操作（链接、脚本、对话框）；`--trigger-flow <动作流fdId>` 绑定动作流，`--inc-params` 传入参 |
 | `llc template list / create / add-fields / delete` | 分类表单模板：创建模板并把既有表单的字段/视图/权限移植进来，追加字段，或清理模板（自动建分类节点、跳过官方 init） |
 | `llc flow spec / compile / validate` | **纯离线**：生成 Flow Spec、编译出符合 IDE 编排布局的 `fdDesign`、离线校验 |
 | `llc flow list / get / category / logs / schema / templates` | **只读**查询动作流；`templates` 抽取 golden 节点骨架（已剥离坐标） |
-| `llc flow apply / diff / script / enable / disable / delete` | **写入**动作流全生命周期；`apply` 默认预览，需 `--yes` + `--app-code` 才提交 |
+| `llc flow apply / diff / script / run / enable / disable / delete` | **写入**动作流全生命周期；`apply` 默认预览，需 `--yes` + `--app-code`；`run` 通过 `sysModelingMain/other` 执行绑定按钮 |
 | `llc control list / show` | 环境已安装控件（`--add-field` 第三段的取值依据） |
 | `llc locale list` | 环境中有现成译文的语言（来自控件多语言资源） |
 | `llc config set / show / clear` | 全局凭据与默认值 |

package/skills/lan-low-code-cli/references/cli-contract.md

@@ -123,8 +123,8 @@ maintained by the platform; the CLI only lists them and manages **custom** opera
 |---|---|---|---|
 | `llc operation list` | `--form-id <fdId>` | `--keyword <kw>` `--page-no <n>=1` `--page-size <n>=100` `--json` | lists a form's operations (built-ins included) |
 | `llc operation get` | `--id <fdId>` | `--json` | detail; prints the parsed `fdConfig` |
-| `llc operation create` | `--form-id` `--name` `--code` `--type` | `--position list\|view` `--need-select` `--url` `--script <code\|@file>` `--dialog-id` `--desc` `--mobile-icon` `--dry-run` `--json` | creates an operation definition |
-| `llc operation update` | `--id <fdId>` | `--name` `--code` `--desc` `--position` `--type` `--url` `--script <code\|@file>` `--dialog-id` `--need-select`/`--no-need-select` `--enable`/`--disable` `--mobile-icon` `--dry-run` `--json` | edits an existing operation; `--type script` switches a button to script mode |
+| `llc operation create` | `--form-id` `--name` `--code` | `--type link\|script\|dialog` **or** `--trigger-flow <flowId>`; `--position list\|view` `--need-select` `--url` `--script <code\|@file>` `--dialog-id` `--inc-params <json\|@file>` `--desc` `--mobile-icon` `--dry-run` `--json` | creates an operation definition; `--trigger-flow` binds an action flow (`fdTriggerType=3`) |
+| `llc operation update` | `--id <fdId>` | `--name` `--code` `--desc` `--position` `--type` `--url` `--script <code\|@file>` `--dialog-id` `--trigger-flow <flowId>` `--inc-params` `--need-select`/`--no-need-select` `--enable`/`--disable` `--mobile-icon` `--dry-run` `--json` | edits an existing operation; `--type script` switches to script mode, `--trigger-flow` switches to action-flow trigger |
 | `llc operation delete` | `--id <fdId>` `--yes` | — | checks references (`listByRefer`) and refuses while still in use |
 | `llc operation attach` | `--form-id` `--operation-id` | `--target list\|view` `--view-id` `--platform desktop\|mobile` `--position top\|rightHand\|rightSide` | writes the button into the view `operationList`; auto-detects the single view when `--view-id` is omitted |
 | `llc operation detach` | `--form-id` `--operation-id` | `--target list\|view` `--view-id` `--platform` | removes the button from a view (definition kept) |
@@ -241,6 +241,7 @@ Application-scoped action flows. Every write command needs `--yes` and an explic
 | `llc flow apply` | `--spec` `--app-code` | `--draft` `--enable` `--resolve-schema` `--strict-schema` layout options `--force` `--yes` `--json` | **preview by default**; `--yes` calls `addPublish`/`addDraft` (or `update*` when the spec has `fdId`), then reads back |
 | `llc flow diff` | `--id` `--spec` | `--no-ignore-bounds` `--resolve-schema` `--strict-schema` layout options `--json` | compares local design with remote; ignores coordinates by default |
 | `llc flow script` | `--id` | `--out` `--json` | generates a `MKXFORM.flow_<fdCode>` button script |
+| `llc flow run` | `--operation-id` `--yes` | `--view-id` `--doc-id` `--doc-ids` `--inc-params` `--json` | executes a button bound to a flow via `sysModelingMain/other`; returns `success` / `responseMsg` |
 | `llc flow enable` | `--id` | `--json` | `startup` |
 | `llc flow disable` | `--id` `--yes` | `--json` | `stop` |
 | `llc flow delete` | `--id` `--yes` | `--json` | checks `listByRefer` before deleting |
@@ -284,6 +285,17 @@ Application-scoped action flows. Every write command needs `--yes` and an explic
 - `fields` of `AddDataNode` / `AddOrUpdateNode` uses the platform's real shape
   (`{field:{...},value:{format,valueJson}}`); the CLI passes it through and only validates field
   names — it does **not** synthesise formulas. Use `llc flow templates` / `flow get` for golden shapes.
+- **Per-node required fields** mirror the IDE rules table (`configuration/nodes/utils.tsx`) plus its
+  exemptions (`validate.ts`):
+  `TransformNode` requires `outParam` **and** `outputParamMapping` (`valueFormula`, or non-empty
+  `pointMappings`; mapping is exempt only when `outParam` is empty);
+  `ExecuteNode`/`InterfaceNode`/`SubActionNode`/`FlowBotsNode` require their code field
+  (`executeCode`/`apiMethodPath`/`actionFlowCode`/`flowBotsCode`) and a mapping when an inbound
+  Schema exists; `BranchNode` requires `conditionType`/`flowWay` plus the matching
+  `formulaConfig`/`ruleConfig` (auto-generated when branch edges exist); `LoopNode` requires
+  `loopDefine.type`; `MessageNode` validates `notifyType`/`subject`/`templateCode`/`linkPage`/`linkUrl`
+  by `subjectType` and `messageLink.linkType`; `AddDataNode`/`AddOrUpdateNode` skip `flow` for
+  category forms or when `commitType` is absent. Diagnostics carry `field` and `hint`; errors exit `1`.
 - Publishing derives `fdProcessActive` on the backend from `startNodeDef`; `fdStatus=1` means enabled.
   `flow logs` endpoints vary by deployment (`ModelingProcessLog/findAll` vs
   `sysModelingLog/findAllWithAppId`); use `--endpoint` if the defaults fail.

package/skills/lan-low-code-cli/references/cli-contract.zh-CN.md

@@ -116,8 +116,8 @@ llc form create --name "简版分类表单" --app-id <appId> --type simpleCatego
 |---|---|---|---|
 | `llc operation list` | `--form-id <fdId>` | `--keyword <kw>` `--page-no <n>=1` `--page-size <n>=100` `--json` | 按表单列出操作（含内置） |
 | `llc operation get` | `--id <fdId>` | `--json` | 详情；默认展开 `fdConfig` JSON |
-| `llc operation create` | `--form-id` `--name` `--code` `--type` | `--position list\|view` `--need-select` `--url` `--script <code\|@file>` `--dialog-id` `--desc` `--mobile-icon` `--dry-run` `--json` | 新建操作定义 |
-| `llc operation update` | `--id <fdId>` | `--name` `--code` `--desc` `--position` `--type` `--url` `--script <code\|@file>` `--dialog-id` `--need-select`/`--no-need-select` `--enable`/`--disable` `--mobile-icon` `--dry-run` `--json` | 修改已有操作；`--type script` 可把按钮切换为脚本模式 |
+| `llc operation create` | `--form-id` `--name` `--code` | `--type link\|script\|dialog` **或** `--trigger-flow <动作流fdId>`；`--position list\|view` `--need-select` `--url` `--script <code\|@file>` `--dialog-id` `--inc-params <json\|@file>` `--desc` `--mobile-icon` `--dry-run` `--json` | 新建操作定义；`--trigger-flow` 绑定动作流（`fdTriggerType=3`） |
+| `llc operation update` | `--id <fdId>` | `--name` `--code` `--desc` `--position` `--type` `--url` `--script <code\|@file>` `--dialog-id` `--trigger-flow <动作流fdId>` `--inc-params` `--need-select`/`--no-need-select` `--enable`/`--disable` `--mobile-icon` `--dry-run` `--json` | 修改已有操作；`--type script` 切脚本、`--trigger-flow` 切动作流触发 |
 | `llc operation delete` | `--id <fdId>` `--yes` | — | 先查引用（`listByRefer`），被引用时拒绝删除 |
 | `llc operation attach` | `--form-id` `--operation-id` | `--target list\|view` `--view-id` `--platform desktop\|mobile` `--position top\|rightHand\|rightSide` | 把按钮写入视图 `operationList`；省略 `--view-id` 时自动定位唯一视图 |
 | `llc operation detach` | `--form-id` `--operation-id` | `--target list\|view` `--view-id` `--platform` | 从视图移除按钮（保留操作定义） |
@@ -230,6 +230,7 @@ llc operation detach --form-id <fdId> --operation-id <operationId>            #
 | `llc flow apply` | `--spec` `--app-code` | `--draft` `--enable` `--resolve-schema` `--strict-schema` 布局选项 `--force` `--yes` `--json` | **默认预览**；`--yes` 才调用 `addPublish`/`addDraft`（spec 带 `fdId` 时走 `update*`），随后回读 |
 | `llc flow diff` | `--id` `--spec` | `--no-ignore-bounds` `--resolve-schema` `--strict-schema` 布局选项 `--json` | 对比本地与远端设计；默认忽略坐标 |
 | `llc flow script` | `--id` | `--out` `--json` | 生成 `MKXFORM.flow_<fdCode>` 按钮脚本 |
+| `llc flow run` | `--operation-id` `--yes` | `--view-id` `--doc-id` `--doc-ids` `--inc-params` `--json` | 通过绑定动作流的业务操作执行一次（`sysModelingMain/other`），返回 `success` / `responseMsg` |
 | `llc flow enable` | `--id` | `--json` | `startup` |
 | `llc flow disable` | `--id` `--yes` | `--json` | `stop` |
 | `llc flow delete` | `--id` `--yes` | `--json` | 删除前先查 `listByRefer` |
@@ -271,6 +272,16 @@ llc operation detach --form-id <fdId> --operation-id <operationId>            #
 - `AddDataNode` / `AddOrUpdateNode` 的 `fields` 使用平台真实结构
   （`{field:{...},value:{format,valueJson}}`）；CLI 原样透传并只校验字段名，**不臆造公式**。
   需要真实结构请用 `llc flow templates` / `flow get` 抽取 golden 骨架。
+- **节点级必填校验**复刻 IDE 规则表（`configuration/nodes/utils.tsx`）及其豁免逻辑（`validate.ts`）：
+  `TransformNode` 必填 `outParam` **和** `outputParamMapping`（`valueFormula` 或非空
+  `pointMappings`；仅当 `outParam` 为空时豁免映射）；`ExecuteNode` / `InterfaceNode` /
+  `SubActionNode` / `FlowBotsNode` 必填各自的编码字段（`executeCode` / `apiMethodPath` /
+  `actionFlowCode` / `flowBotsCode`），且存在入参 Schema 时必填参数映射；`BranchNode` 必填
+  `conditionType` / `flowWay` 及对应的 `formulaConfig` / `ruleConfig`（有分支出边时自动生成）；
+  `LoopNode` 必填 `loopDefine.type`；`MessageNode` 按 `subjectType` 与 `messageLink.linkType`
+  校验 `notifyType` / `subject` / `templateCode` / `linkPage` / `linkUrl`；
+  `AddDataNode` / `AddOrUpdateNode` 在分类表单或未填 `commitType` 时豁免 `flow`。
+  诊断会带 `field` 与 `hint`，有错误时退出码为 `1`。
 - 发布时后端从 `startNodeDef` 派生 `fdProcessActive`；`fdStatus=1` 表示已启用。
   `flow logs` 端点因部署而异（`ModelingProcessLog/findAll` 与
   `sysModelingLog/findAllWithAppId`）；默认都失败时用 `--endpoint` 指定。