weaver-e10-builder 1.1.9 → 1.2.3

package/dist/commands/workflow-node.js

@@ -1,13 +1,33 @@
 import { AuthSession } from '../core/auth.js';
 import { ApiClient } from '../core/client.js';
+import { CHECKED_NODES, REJECT_REMINDS, REJECT_TYPES, SUBMIT_TYPES, codeToKey, formatRejectForm, readRejectForm, saveRejectSet, } from './workflow-node-reject.js';
+import { FLOW_TYPE_BY_ID, OVERTIME_FLOW_TYPES, formatDhm, listOvertimeRules, saveOvertimeRemind, saveOvertimeRule, setOvertimeRuleUsed, verifyOvertimeRule, } from '../services/workflow-overtime.js';
+import { applyMenuPatch, findMenu, getNodeMenus, menuLabel, menuNames, saveNodeMenus, } from '../services/workflow-node-menu.js';
+import { bindNodeLayout, createFormLayout, getLayoutReferNodes, getNodeLayout, initNodeLayout, listLayoutFields, listLayoutsWithNodes, unbindNodeLayout, } from '../services/workflow-node-layout.js';
+/** `--rename 批准=发送` 这类可重复的「键=值」参数收集器 */
+export function collectPairs(value, previous) {
+    const i = value.indexOf('=');
+    if (i < 0)
+        throw new Error(`需要「菜单=值」格式，收到: ${value}`);
+    previous.set(value.slice(0, i).trim(), value.slice(i + 1));
+    return previous;
+}
 export function registerWorkflowNodeCommands(wf, program) {
-    const nodeCmd = wf.command('node').description('节点维度设置（菜单 / 退回 / 超时 / 投票 / 字段权限）');
+    const nodeCmd = wf.command('node').description('节点维度设置（菜单 / 退回 / 超时 / 投票 / 字段权限 / 独立布局）');
     // ======== node menu ========
+    // 平台把菜单分 topmenu（快捷）/ moremenu（更多）两个数组返回，保存时 menuStr 要两组合并。
+    // 旧实现只读 moremenu，所以**快捷菜单一个都切不了**（批准/保存/退回/加签/强制收回全在 topmenu）。
     nodeCmd.command('menu')
-        .description('查看/切换节点操作菜单启用状态')
+        .description('查看/配置节点操作菜单（快捷菜单 / 更多菜单：启用、改名、默认意见、分组）')
         .argument('<workflowId>', '流程 ID')
         .argument('<nodeId>', '节点 ID')
-        .option('--toggle <menuId>', '切换指定菜单的启用状态（传菜单 ID）')
+        .option('--toggle <菜单>', '切换单个菜单的启用状态（菜单名或类型码，两组都会找）')
+        .option('--quick <names...>', '快捷菜单只启用这些（其余快捷菜单关闭）；不在快捷组的会移进来')
+        .option('--more <names...>', '更多菜单只启用这些（其余更多菜单关闭）；不在更多组的会移进来')
+        .option('--enable <names...>', '启用这些菜单（不动分组）')
+        .option('--disable <names...>', '关闭这些菜单')
+        .option('--rename <menu=newName>', '改菜单显示名，可重复（新名留空则恢复默认名）', collectPairs, new Map())
+        .option('--sign <menu=sign>', '设置默认签字意见，可重复', collectPairs, new Map())
         .action(async (workflowId, nodeId, cmdOpts) => {
         const opts = program.opts();
         const auth = await AuthSession.fromOptions(opts);
@@ -15,64 +35,75 @@ export function registerWorkflowNodeCommands(wf, program) {
             process.exit(1);
         const client = new ApiClient(auth);
         const baseUrl = auth.getBaseUrl();
-        // 1. Get current menu info
-        const getRes = await client.get(`${baseUrl}/api/bs/workflow/pathdef/nodeMenu/getWfpNodeMenuInfo?workflowId=${workflowId}&nodeId=${nodeId}`);
-        if (getRes?.code !== 200 || !getRes?.status) {
-            console.error(`查询失败: ${getRes?.msg || '未知错误'}`);
-            process.exit(1);
-        }
-        const menusRaw = getRes?.data?.moremenu || getRes?.data?.data || getRes?.data || [];
-        const menus = Array.isArray(menusRaw) ? menusRaw : (menusRaw.menus || menusRaw.list || []);
-        // Toggle mode
-        if (cmdOpts.toggle) {
-            let found = false;
-            for (const m of menus) {
-                if (String(m.id) === cmdOpts.toggle || String(m.menuId) === cmdOpts.toggle) {
-                    m.useable = (m.useable === 1 || m.useable === '1' || m.useable === true) ? 0 : 1;
-                    found = true;
-                    break;
+        try {
+            const set = await getNodeMenus(client, baseUrl, workflowId, nodeId);
+            const hasChange = cmdOpts.toggle || cmdOpts.quick || cmdOpts.more || cmdOpts.enable
+                || cmdOpts.disable || cmdOpts.rename?.size || cmdOpts.sign?.size;
+            if (!hasChange) {
+                if (opts.json) {
+                    console.log(JSON.stringify(set, null, 2));
+                    return;
                 }
+                console.log(`节点 ${nodeId} 操作菜单: 快捷菜单 ${set.quick.length} 个 / 更多菜单 ${set.more.length} 个\n`);
+                for (const [groupName, list] of [['快捷菜单', set.quick], ['更多菜单', set.more]]) {
+                    console.log(`【${groupName}】`);
+                    for (const m of list) {
+                        const marks = [m.useable ? '✅ 启用' : '⛔ 关闭'];
+                        if (m.title)
+                            marks.push(`改名「${m.title}」`);
+                        if (m.defaultSign)
+                            marks.push(`默认意见「${m.defaultSign}」`);
+                        console.log(`  ${menuLabel(m).padEnd(14)} ${m.menutype.padEnd(20)} 序${String(m.orderid).padEnd(3)} ${marks.join('  ')}`);
+                    }
+                }
+                return;
             }
-            if (!found) {
-                console.error(`未找到菜单: ${cmdOpts.toggle}`);
-                process.exit(1);
+            const patch = {
+                quick: cmdOpts.quick, more: cmdOpts.more,
+                enable: cmdOpts.enable, disable: cmdOpts.disable,
+                rename: cmdOpts.rename, sign: cmdOpts.sign,
+            };
+            if (cmdOpts.toggle) {
+                const all = [...set.quick, ...set.more];
+                const hit = findMenu(all, cmdOpts.toggle);
+                if (!hit)
+                    throw new Error(`找不到菜单「${cmdOpts.toggle}」。可用: ${menuNames(all).join('、')}`);
+                const base = (hit.useable ? cmdOpts.disable : cmdOpts.enable) || [];
+                if (hit.useable)
+                    patch.disable = [...base, hit.id];
+                else
+                    patch.enable = [...base, hit.id];
             }
-            const changeRows = [cmdOpts.toggle];
-            const saveRes = await client.post(`${baseUrl}/api/bs/workflow/pathdef/nodeMenu/saveWfpNodeMenuInfo`, {
-                workflowId, nodeId,
-                menuStr: JSON.stringify(menus),
-                changeRows,
-                deleteMenuIds: [],
-            });
-            if (saveRes?.code === 200 && saveRes?.status) {
-                const msg = opts.json
-                    ? JSON.stringify({ success: true, workflowId, nodeId, toggled: cmdOpts.toggle })
-                    : `操作菜单已切换: ${cmdOpts.toggle}`;
-                console.log(msg);
+            const { next, changed } = applyMenuPatch(set, patch);
+            await saveNodeMenus(client, baseUrl, workflowId, nodeId, next, changed);
+            if (opts.json) {
+                console.log(JSON.stringify({ success: true, workflowId, nodeId, changed, menus: next }, null, 2));
+                return;
             }
-            else {
-                console.error(`保存失败: ${saveRes?.msg || '未知错误'}`);
-                process.exit(1);
+            if (!changed.length) {
+                console.log('菜单本来就是目标状态，没有改动');
+                return;
             }
-            return;
-        }
-        // List mode
-        if (opts.json) {
-            console.log(JSON.stringify({ menus }, null, 2));
-        }
-        else {
-            console.log(`共 ${menus.length} 个操作菜单:\n`);
-            for (const m of menus) {
-                const enabled = m.useable === 1 || m.useable === '1' || m.useable === true;
-                const icon = enabled ? '✅' : '⛔';
-                const label = m.menutype || m.menuName || m.name || '(未命名)';
-                console.log(`  ${icon} ${m.id || m.menuId}  ${label}`);
+            const after = await getNodeMenus(client, baseUrl, workflowId, nodeId);
+            const byId = new Map([...after.quick, ...after.more].map((m) => [m.id, m]));
+            console.log(`已更新 ${changed.length} 个菜单:`);
+            for (const id of changed) {
+                const m = byId.get(id);
+                if (!m)
+                    continue;
+                console.log(`  ${menuLabel(m).padEnd(14)} ${m.istop ? '快捷菜单' : '更多菜单'}  ${m.useable ? '✅ 启用' : '⛔ 关闭'}${m.title ? `  改名「${m.title}」` : ''}`);
             }
         }
+        catch (e) {
+            console.error(`操作失败: ${e.message}`);
+            process.exitCode = 1;
+        }
     });
-    // ======== node reject ========
+    // ======== node reject（已弃用，保留为 node-reject 的别名） ========
+    // 旧实现只有 4 个数值开关、拿不到 enableCustom/范围节点/提醒节点；现已共用
+    // workflow-node-reject.ts 的读/建/存一套实现，本命令只做数值码翻译 + 提示弃用。
     nodeCmd.command('reject')
-        .description('配置节点退回设置')
+        .description('[已弃用] 配置节点退回设置，请改用 `workflow node-reject`（get / set）')
         .argument('<workflowId>', '流程 ID')
         .argument('<nodeId>', '节点 ID')
         .option('--remind <n>', '退回提醒: 0=不提醒, 1=提醒所有参与人, 2=选择提醒节点, 3=用户设置')
@@ -86,59 +117,55 @@ export function registerWorkflowNodeCommands(wf, program) {
             process.exit(1);
         const client = new ApiClient(auth);
         const baseUrl = auth.getBaseUrl();
-        // 1. Get current settings
-        const getRes = await client.get(`${baseUrl}/api/bs/workflow/pathdef/rejectset/getNodeRejectSetForm?workflowId=${workflowId}&nodeId=${nodeId}`);
-        if (getRes?.code !== 200 || !getRes?.status) {
-            console.error(`查询失败: ${getRes?.msg || '未知错误'}`);
-            process.exit(1);
-        }
-        const form = getRes?.data?.data || getRes?.data || {};
+        console.error('⚠ `workflow node reject` 已弃用，请改用 `workflow node-reject`（get / set）。');
+        console.error('  本次仍按新实现执行，行为与 node-reject 一致。');
+        const hasChange = cmdOpts.remind || cmdOpts.type || cmdOpts.checkedNode || cmdOpts.submitType;
+        const form = await readRejectForm(client, baseUrl, workflowId, nodeId)
+            .catch((e) => { console.error(e.message); process.exit(1); });
         // Read-only: show current
-        if (!cmdOpts.remind && !cmdOpts.type && !cmdOpts.checkedNode && !cmdOpts.submitType) {
-            const remindLabels = { '0': '不提醒', '1': '提醒所有参与人', '2': '选择提醒节点', '3': '用户设置' };
-            const typeLabels = { '0': '自由', '1': '逐级', '2': '指定范围', '3': '按出口', '4': '上一审批人' };
-            const checkedLabels = { '0': '上一节点', '1': '发起节点', '2': '指定节点' };
-            const submitLabels = { '0': '逐级', '1': '直达本节点', '2': '直达分叉起始节点', '3': '操作者选择' };
+        if (!hasChange) {
             if (opts.json) {
                 console.log(JSON.stringify(form, null, 2));
+                return;
             }
-            else {
-                console.log(`退回提醒: ${remindLabels[form.rejectRemind] || form.rejectRemind || '-'}`);
-                console.log(`退回方式: ${typeLabels[form.rejectType] || form.rejectType || '-'}`);
-                console.log(`默认选中: ${checkedLabels[form.rejectCheckedNode] || form.rejectCheckedNode || '-'}`);
-                console.log(`退回后提交: ${submitLabels[form.rejectSubmitType] || form.rejectSubmitType || '-'}`);
-            }
+            for (const line of formatRejectForm(form))
+                console.log(line);
             return;
         }
-        // Update mode
-        if (cmdOpts.remind)
-            form.rejectRemind = cmdOpts.remind;
-        if (cmdOpts.type)
-            form.rejectType = cmdOpts.type;
-        if (cmdOpts.checkedNode)
-            form.rejectCheckedNode = cmdOpts.checkedNode;
-        if (cmdOpts.submitType)
-            form.rejectSubmitType = cmdOpts.submitType;
-        const saveRes = await client.post(`${baseUrl}/api/bs/workflow/pathdef/rejectset/saveNodeRejectSetInfo`, { workflowId, nodeId, ...form });
-        if (saveRes?.code === 200 && saveRes?.status) {
-            const msg = opts.json
-                ? JSON.stringify({ success: true, workflowId, nodeId })
-                : '退回设置已保存';
-            console.log(msg);
-        }
-        else {
-            console.error(`保存失败: ${saveRes?.msg || '未知错误'}`);
-            process.exit(1);
+        // Update mode：数值码 → 键名，交给共用实现合并保存
+        for (const [flag, map, code] of [
+            ['--remind', REJECT_REMINDS, cmdOpts.remind],
+            ['--type', REJECT_TYPES, cmdOpts.type],
+            ['--checked-node', CHECKED_NODES, cmdOpts.checkedNode],
+            ['--submit-type', SUBMIT_TYPES, cmdOpts.submitType],
+        ]) {
+            if (code && !codeToKey(map, code)) {
+                console.error(`不支持的 ${flag}: ${code}（可选: ${Object.values(map).join(' / ')}）`);
+                process.exit(1);
+            }
         }
+        await saveRejectSet(client, baseUrl, form, {
+            rejectRemind: codeToKey(REJECT_REMINDS, cmdOpts.remind),
+            rejectType: codeToKey(REJECT_TYPES, cmdOpts.type),
+            defaultNode: codeToKey(CHECKED_NODES, cmdOpts.checkedNode),
+            submitType: codeToKey(SUBMIT_TYPES, cmdOpts.submitType),
+        }, workflowId, nodeId).catch((e) => { console.error(e.message); process.exit(1); });
+        console.log(opts.json ? JSON.stringify({ success: true, workflowId, nodeId }) : '退回设置已保存');
     });
-    // ======== node timeout ========
+    // ======== node timeout（已弃用，保留为 node-overtime 的别名） ========
+    // 旧实现按 `overtime` 发超时时长、`remindTime` 发提醒偏移，平台都不认：
+    // 规则建得出来但超时时间落成 0天0小时0分钟，提醒步骤直接报「系统错误」。
+    // 现已改为共用 services/workflow-overtime.ts 的一套报文，本命令只做参数翻译 + 提示弃用。
     nodeCmd.command('timeout')
-        .description('配置节点超时处理（列表/新增）')
+        .description('[已弃用] 配置节点超时处理，请改用 `workflow node-overtime`（set / remind / list）')
         .argument('<workflowId>', '流程 ID')
         .argument('<nodeId>', '节点 ID')
-        .option('--time-type <n>', '超时来源: 1=指定时间, 2=表单字段')
+        .option('--time-type <n>', '超时来源: 1=指定时间（2=表单字段暂不支持）')
         .option('--time-value <n>', '超时小时数（time-type=1 时使用）')
         .option('--flow-type <n>', '处理方式: 1=下一操作者, 2=退回节点, 3=提交节点, 4=干预对象, 6=指定操作者')
+        .option('--flow-node <nodeId>', '退回/提交的目标节点 ID（flow-type=2|3 时需要）')
+        .option('--intervene-ids <userIds>', '干预对象用户 ID 列表，逗号分隔（flow-type=4 时需要）')
+        .option('--operator-group <groupId>', '新增操作者的操作组 ID（flow-type=6 时需要）')
         .option('--remind-type <n>', '提醒时机: 0=超时前, 1=超时后')
         .option('--remind-hours <n>', '提前/延后小时数')
         .action(async (workflowId, nodeId, cmdOpts) => {
@@ -148,95 +175,89 @@ export function registerWorkflowNodeCommands(wf, program) {
             process.exit(1);
         const client = new ApiClient(auth);
         const baseUrl = auth.getBaseUrl();
-        // 1. Get current timeout list
-        const listRes = await client.get(`${baseUrl}/api/bs/workflow/pathdef/nodeOvertime/getOvertimeList?workflowId=${workflowId}&nodeId=${nodeId}`);
-        if (listRes?.code !== 200 || !listRes?.status) {
-            console.error(`查询失败: ${listRes?.msg || '未知错误'}`);
-            process.exit(1);
-        }
-        const rules = listRes?.data?.data || listRes?.data || [];
+        console.error('⚠ `workflow node timeout` 已弃用，请改用 `workflow node-overtime`（set / remind / list）。');
+        console.error('  本次仍按新实现执行，行为与 node-overtime 一致。');
         // Read-only: show current
         if (!cmdOpts.timeType) {
-            const flowLabels = { '1': '下一操作者', '2': '退回节点', '3': '提交节点', '4': '干预对象', '6': '指定操作者' };
-            const typeLabels = { '1': '指定时间', '2': '表单字段' };
+            const rules = await listOvertimeRules(client, baseUrl, workflowId, nodeId).catch((e) => {
+                console.error(e.message);
+                process.exit(1);
+            });
             if (opts.json) {
                 console.log(JSON.stringify({ rules }, null, 2));
+                return;
             }
-            else {
-                console.log(`共 ${Array.isArray(rules) ? rules.length : 0} 条超时规则:\n`);
-                for (const r of (Array.isArray(rules) ? rules : [])) {
-                    const flowLabel = flowLabels[r.flowType] || r.flowType || '-';
-                    const typeLabel = typeLabels[r.overTimeType] || r.overTimeType || '-';
-                    console.log(`  ${r.id || ''}  ${typeLabel}  ${flowLabel}  延时${r.overTime || r.overtime || '-'}h`);
-                }
+            console.log(`共 ${rules.length} 条超时规则:\n`);
+            for (const r of rules) {
+                const used = r.isUsed === true || r.isUsed === 1;
+                console.log(`  [${r.id}] ${used ? '✅ 已启用' : '⛔ 未启用'}  ${r.overtimeSet || ''}`);
             }
             return;
         }
-        // Add mode: call getOvertimeSetCondition first, then save
-        const condRes = await client.get(`${baseUrl}/api/bs/workflow/pathdef/nodeOvertime/getOvertimeSetCondition?workflowId=${workflowId}&nodeId=${nodeId}`);
-        const condData = condRes?.data?.data || condRes?.data || {};
-        const payload = {
-            ...condData,
-            workflowId, nodeId,
-            id: '',
-            overTimeType: cmdOpts.timeType || '1',
-            flowType: cmdOpts.flowType || '1',
-            overtime: cmdOpts.timeValue || '',
-        };
-        const saveRes = await client.post(`${baseUrl}/api/bs/workflow/pathdef/nodeOvertime/saveOvertime`, payload);
-        if (saveRes?.code !== 200 || !saveRes?.status) {
-            console.error(`保存超时规则失败: ${saveRes?.msg || '未知错误'}`);
+        if (cmdOpts.timeType !== '1') {
+            console.error(`--time-type ${cmdOpts.timeType} 暂不支持（仅有「指定时间」的报文形状，表单字段取值需先确认平台字段名）`);
             process.exit(1);
         }
-        const overtimeId = saveRes?.data?.entity?.id || saveRes?.data?.id || '';
-        // Save remind if requested
-        if (cmdOpts.remindType && overtimeId) {
-            const remindPayload = {
-                workflowId, nodeId, overTimeId: overtimeId, id: '',
-                remindType: cmdOpts.remindType || '0',
-                remindTime: cmdOpts.remindHours || '1',
-                ...condData,
-            };
-            // D12: 不再吞错——remind 保存失败必须显式报错，不能假成功
-            const remindRes = await client.post(`${baseUrl}/api/bs/workflow/pathdef/nodeOvertime/saveRemind`, remindPayload).catch((e) => ({ code: -1, status: false, msg: e?.message || '网络错误' }));
-            if (remindRes?.code !== 200 || !remindRes?.status) {
-                console.error(`保存超时提醒失败: ${remindRes?.msg || '未知错误'}`);
-                process.exit(1);
-            }
-            // Save overtime list (batch + enable)：真实结构为裸数组，每项 {id, batchOrder, isUsed:0|1, workflowId, nodeId}
-            // （isUsed=1 启用 / 0 停用；batchOrder 该规则的批次，缺失取 0）。
-            let batchOrder = 0;
-            try {
-                const listBack = await client.get(`${baseUrl}/api/bs/workflow/pathdef/nodeOvertime/getOvertimeList?workflowId=${workflowId}&nodeId=${nodeId}`);
-                const found = (listBack?.data?.data || listBack?.data || []).find((x) => String(x.id) === String(overtimeId));
-                if (found && found.batchOrder !== undefined)
-                    batchOrder = Number(found.batchOrder) || 0;
-            }
-            catch { /* 批次读不到用 0 */ }
-            const listRes = await client.post(`${baseUrl}/api/bs/workflow/pathdef/nodeOvertime/saveOvertimeList`, [{ id: overtimeId, batchOrder, isUsed: 1, workflowId, nodeId }]).catch((e) => ({ code: -1, status: false, msg: e?.message || '网络错误' }));
-            if (listRes?.code !== 200 || !listRes?.status) {
-                console.error(`启用超时规则失败（规则已创建但未启用）: ${listRes?.msg || '未知错误'}`);
-                process.exit(1);
-            }
+        // 旧参数 → 新服务参数：小时数 → 天:时:分；数值 flowType → 键
+        const hours = Number(cmdOpts.timeValue);
+        if (!Number.isFinite(hours) || hours < 0) {
+            console.error(`--time-value 须为小时数（非负数），收到: ${cmdOpts.timeValue}`);
+            process.exit(1);
+        }
+        const duration = { day: Math.floor(hours / 24), hour: hours % 24, minute: 0 };
+        const flowType = FLOW_TYPE_BY_ID[cmdOpts.flowType || '1'];
+        if (!flowType) {
+            console.error(`不支持的 --flow-type: ${cmdOpts.flowType}，可选: ${Object.keys(FLOW_TYPE_BY_ID).join(', ')}`);
+            process.exit(1);
         }
-        // D12: 保存后读回核对实际状态（新建规则默认 isUsed=false 未启用）
-        let actualUsed = null;
+        let overtimeId;
         try {
-            const back = await client.get(`${baseUrl}/api/bs/workflow/pathdef/nodeOvertime/getOvertimeList?workflowId=${workflowId}&nodeId=${nodeId}`);
-            const found = (back?.data?.data || back?.data || []).find((r) => String(r.id) === String(overtimeId));
-            if (found)
-                actualUsed = found.isUsed === true || found.isUsed === 1;
+            overtimeId = await saveOvertimeRule(client, baseUrl, {
+                workflowId, nodeId, flowType, duration,
+                flowNodeId: cmdOpts.flowNode,
+                interveneIds: cmdOpts.interveneIds,
+                operatorGroupId: cmdOpts.operatorGroup,
+            });
+            // 新建规则默认未启用，显式打开后再回读核对
+            await setOvertimeRuleUsed(client, baseUrl, workflowId, nodeId, overtimeId, 1);
         }
-        catch { /* 读回失败不阻断 */ }
-        if (opts.json) {
-            console.log(JSON.stringify({ success: true, workflowId, nodeId, overtimeId, isUsed: actualUsed }, null, 2));
+        catch (e) {
+            console.error(e.message);
+            process.exit(1);
         }
-        else {
-            console.log(`超时规则已保存: ${overtimeId}${actualUsed === null ? '' : `（启用状态: ${actualUsed ? '已启用' : '未启用'}）`}`);
+        const { mismatches } = await verifyOvertimeRule(client, baseUrl, workflowId, nodeId, overtimeId, { duration, isUsed: 1 });
+        if (mismatches.length) {
+            console.error(`超时规则已提交但回读不符（规则 ID ${overtimeId}）：`);
+            for (const m of mismatches)
+                console.error(`  ⚠ ${m}`);
+            process.exit(1);
         }
-        if (actualUsed === false) {
-            console.error('  ⚠ 规则当前「未启用」（isUsed=false）：新建默认不启用，请用启用的配置路径后再用。');
+        // 可选：顺带设提醒（沿用新的 remindDay/Hour/Minute 报文）
+        if (cmdOpts.remindType) {
+            const rh = Number(cmdOpts.remindHours);
+            const offset = {
+                day: Number.isFinite(rh) ? Math.floor(rh / 24) : 0,
+                hour: Number.isFinite(rh) ? rh % 24 : 1,
+                minute: 0,
+            };
+            try {
+                await saveOvertimeRemind(client, baseUrl, {
+                    workflowId, nodeId, overtimeId,
+                    name: '超时提醒',
+                    type: Number(cmdOpts.remindType),
+                    offset,
+                });
+            }
+            catch (e) {
+                console.error(e.message);
+                process.exit(1);
+            }
+            console.log(`  提醒: ${cmdOpts.remindType === '0' ? '超时前' : '超时后'} ${formatDhm(offset)}`);
         }
+        console.log(`超时规则已保存: ${overtimeId}`);
+        console.log(`  超时时长: ${formatDhm(duration)}`);
+        console.log(`  处理方式: ${OVERTIME_FLOW_TYPES[flowType].label}`);
+        console.log(`  状态: 已启用`);
     });
     // ======== node field-permission ========
     // 节点级字段权限：控制各字段在节点上的 显示/只读/必填。
@@ -535,5 +556,253 @@ export function registerWorkflowNodeCommands(wf, program) {
             process.exit(1);
         }
     });
+    // ======== node layout ========
+    // 节点独立布局：节点上挂一套自己的表单布局，与表单默认布局并存。
+    // 一个节点同时只属于一套布局，换布局时服务端自动从旧的那套摘掉、回落默认。
+    const layoutCmd = nodeCmd
+        .command('layout')
+        .description('节点独立布局（挂哪套布局 / 新建布局 / 查引用节点）');
+    /** 建 client + base。与本文件其它子命令保持同款写法。 */
+    async function conn() {
+        const opts = program.opts();
+        const auth = await AuthSession.fromOptions(opts);
+        if (!auth)
+            throw new Error('无法加载认证');
+        return { client: new ApiClient(auth), baseUrl: auth.getBaseUrl(), json: !!opts.json };
+    }
+    layoutCmd
+        .command('list')
+        .description('列出该工作流表单的布局，以及每套被哪些节点引用')
+        .argument('<workflowId>', '工作流 ID')
+        .option('--terminal <t>', '终端：PC(默认) / MOBILE', 'PC')
+        .action(async (workflowId, o) => {
+        try {
+            const { client, json } = await conn();
+            const terminal = (o.terminal || 'PC').toUpperCase();
+            // formId 从任一节点的布局设置里反查（表单级接口需要它）
+            const refer = await getLayoutReferNodes(client, workflowId, terminal);
+            if (!refer.formId)
+                throw new Error(`读不到该工作流的表单信息（workflowId=${workflowId}）`);
+            const rows = await listLayoutsWithNodes(client, refer.formId, workflowId, terminal);
+            if (json) {
+                console.log(JSON.stringify({ workflowId, formId: refer.formId, pcDefaultLayoutId: refer.pcDefaultLayoutId, layouts: rows }, null, 2));
+                return;
+            }
+            console.log(`工作流 ${workflowId}  表单 ${refer.formId}  ${terminal} 端布局 ${rows.length} 套`);
+            for (const r of rows) {
+                console.log(`  ${r.id}\t${r.name}\t${r.layoutType}${r.isDefault ? '\t[默认]' : ''}\t引用 ${r.nodeIds.length} 个节点` +
+                    (r.nodeNames.length ? `（${r.nodeNames.join('、')}）` : ''));
+            }
+        }
+        catch (e) {
+            console.error(`读取布局失败: ${e.message}`);
+            process.exitCode = 1;
+        }
+    });
+    layoutCmd
+        .command('get')
+        .description('查看某个节点挂的是哪套布局')
+        .argument('<workflowId>', '工作流 ID')
+        .argument('<nodeId>', '节点 ID')
+        .action(async (workflowId, nodeId) => {
+        try {
+            const { client, json } = await conn();
+            const s = await getNodeLayout(client, workflowId, nodeId);
+            if (json) {
+                console.log(JSON.stringify(s, null, 2));
+                return;
+            }
+            const custom = !!s.layoutId && s.layoutId !== s.defaultLayoutId;
+            console.log(`节点 ${s.nodeId} ${s.nodeName}`);
+            console.log(`  PC 端布局: ${s.layoutId || '(默认)'}${custom ? '  ← 独立布局' : '  ← 跟随表单默认'}`);
+            console.log(`  表单默认布局: ${s.defaultLayoutId}`);
+            console.log(`  移动端: 模式=${s.mLayoutMode || '(未设)'}（0=独立布局 1=读取PC端） 独立布局=${s.mLayoutId || '(无)'}`);
+            console.log(`  字段权限: ${s.hasNodePermissionSet ? '已设置' : '未设置'}`);
+        }
+        catch (e) {
+            console.error(`读取节点布局失败: ${e.message}`);
+            process.exitCode = 1;
+        }
+    });
+    layoutCmd
+        .command('bind')
+        .description('把节点挂到指定布局上（自动从原来那套摘掉，不残留）')
+        .argument('<workflowId>', '工作流 ID')
+        .argument('<nodeId>', '节点 ID')
+        .requiredOption('--layout-id <id>', '目标布局 ID（node layout list 可查）')
+        .option('--terminal <t>', '终端：PC(默认) / MOBILE', 'PC')
+        .action(async (workflowId, nodeId, o) => {
+        try {
+            const { client, json } = await conn();
+            const r = await bindNodeLayout(client, {
+                workflowId, nodeId, layoutId: o.layoutId,
+                terminal: (o.terminal || 'PC').toUpperCase(),
+            });
+            if (json) {
+                console.log(JSON.stringify({ success: true, ...r, workflowId, nodeId, layoutId: o.layoutId }, null, 2));
+                return;
+            }
+            console.log(r.changed
+                ? `节点 ${nodeId} 已挂到布局 ${o.layoutId}（该布局现引用 ${r.nodeIds.length} 个节点）`
+                : `节点 ${nodeId} 本来就在布局 ${o.layoutId} 上，未改动`);
+        }
+        catch (e) {
+            console.error(`绑定失败: ${e.message}`);
+            process.exitCode = 1;
+        }
+    });
+    layoutCmd
+        .command('unbind')
+        .description('把节点从独立布局上摘下来，回落到表单默认布局')
+        .argument('<workflowId>', '工作流 ID')
+        .argument('<nodeId>', '节点 ID')
+        .option('--terminal <t>', '终端：PC(默认) / MOBILE', 'PC')
+        .action(async (workflowId, nodeId, o) => {
+        try {
+            const { client, json } = await conn();
+            const r = await unbindNodeLayout(client, {
+                workflowId, nodeId,
+                terminal: (o.terminal || 'PC').toUpperCase(),
+            });
+            if (json) {
+                console.log(JSON.stringify({ success: true, ...r, workflowId, nodeId }, null, 2));
+                return;
+            }
+            console.log(r.changed
+                ? `节点 ${nodeId} 已从布局 ${r.layoutId} 摘下，回落表单默认布局（该布局现引用 ${r.nodeIds.length} 个节点）`
+                : `节点 ${nodeId} 本来就没挂独立布局，未改动`);
+        }
+        catch (e) {
+            console.error(`解绑失败: ${e.message}`);
+            process.exitCode = 1;
+        }
+    });
+    layoutCmd
+        .command('init')
+        .description('重建某套布局的排版（只动这一套，默认布局与其它布局不受影响）；可只摆指定字段')
+        .argument('<workflowId>', '工作流 ID')
+        .argument('<layoutId>', '目标布局 ID（node layout list 可查）')
+        .option('--fields <names...>', '只摆这些字段（显示名）；不传 = 摆全部字段')
+        .option('--list-fields', '只列出该表单可用的字段清单，不重建')
+        .option('--style-template <name|id>', '样式模板；缺省按布局类型取（流式=标准版 / 表格式=表格版）')
+        .option('--required', '字段必填')
+        .option('--readonly', '字段只读')
+        .option('--single-row', '字段独占一行')
+        .action(async (workflowId, layoutId, o) => {
+        try {
+            const { client, json } = await conn();
+            const refer = await getLayoutReferNodes(client, workflowId, 'PC');
+            if (!refer.formId)
+                throw new Error(`读不到该工作流的表单信息（workflowId=${workflowId}）`);
+            if (o.listFields) {
+                const list = await listLayoutFields(client, refer.formId);
+                if (json) {
+                    console.log(JSON.stringify(list, null, 2));
+                    return;
+                }
+                console.log(`表单 ${refer.formId} 可摆字段 ${list.filter((x) => !x.system).length} 个（业务）：`);
+                list.filter((x) => !x.system).forEach((x) => console.log(`  ${x.label}	${x.id}`));
+                return;
+            }
+            const r = await initNodeLayout(client, {
+                formId: refer.formId,
+                workflowId,
+                layoutId,
+                fields: o.fields,
+                styleTemplateId: o.styleTemplate,
+                required: o.required,
+                readOnly: o.readonly,
+                singleRow: o.singleRow,
+            });
+            if (json) {
+                console.log(JSON.stringify({ success: true, formId: refer.formId, layoutId, ...r }, null, 2));
+                return;
+            }
+            console.log(`布局 ${layoutId} 已重建: ${r.comps} 个组件 · 类型 ${r.layoutType} · 模板 ${r.styleTemplateId}`);
+            if (r.placed.length)
+                console.log(`  摆了: ${r.placed.join('、')}`);
+        }
+        catch (e) {
+            console.error(`重建布局失败: ${e.message}`);
+            process.exitCode = 1;
+        }
+    });
+    layoutCmd
+        .command('create')
+        .description('新建一套布局（FLOW 流式 / EXCEL 表格式）；可同时挂上若干节点')
+        .argument('<workflowId>', '工作流 ID')
+        .requiredOption('--name <name>', '布局名称')
+        .option('--layout-type <t>', '布局类型：FLOW 流式 / EXCEL 表格式（默认跟随复制来源；不复制时 FLOW）')
+        .option('--terminal <t>', '终端：PC(默认) / MOBILE', 'PC')
+        .option('--describe <text>', '布局描述', '')
+        .option('--nodes <ids...>', '建完直接把这些节点挂上去')
+        .option('--from <layoutId>', '复制这套布局的内容（默认复制表单默认布局）。不传 = 建空白布局')
+        .option('--empty', '建空白布局，不复制任何内容（与 --from 互斥）')
+        .option('--init', '建完立即重建一次布局（按字段清单排版），免去手工在设计器里摆')
+        .option('--fields <names...>', '配合 --init：只摆这些字段（显示名）。不传 = 摆全部字段')
+        .option('--style-template <name|id>', '配合 --init：样式模板；缺省按布局类型取')
+        .option('--required', '配合 --init：字段必填')
+        .option('--readonly', '配合 --init：字段只读')
+        .option('--single-row', '配合 --init：字段独占一行')
+        .action(async (workflowId, o) => {
+        try {
+            const { client, json } = await conn();
+            if (o.from && o.empty)
+                throw new Error('--from 与 --empty 互斥，二选一。');
+            const terminal = (o.terminal || 'PC').toUpperCase();
+            const refer = await getLayoutReferNodes(client, workflowId, terminal);
+            if (!refer.formId)
+                throw new Error(`读不到该工作流的表单信息（workflowId=${workflowId}）`);
+            // 不指定就复制表单默认布局 —— 空布局节点上什么都显示不出来，几乎不会是想要的结果
+            const from = o.empty ? undefined : String(o.from || refer.pcDefaultLayoutId || '');
+            if (!o.empty && !from) {
+                throw new Error('该表单没有默认布局可供复制，请显式指定 --from <layoutId> 或加 --empty 建空白布局。');
+            }
+            const layout = await createFormLayout(client, {
+                formId: refer.formId,
+                workflowId,
+                name: o.name,
+                layoutType: o.layoutType ? o.layoutType.toUpperCase() : undefined,
+                terminal,
+                describe: o.describe,
+                nodeIds: o.nodes,
+                from,
+            });
+            if (json) {
+                console.log(JSON.stringify({ success: true, formId: refer.formId, copiedFrom: from || null, layout, nodes: o.nodes || [] }, null, 2));
+                return;
+            }
+            console.log(`布局已新建: ${layout.name}（${layout.layoutType === 'FLOW' ? '流式' : '表格式'}）layoutId=${layout.id}`);
+            console.log(from ? `  已从布局 ${from} 复制内容` : '  ⚠ 建的是空白布局：字段与排版都需要重新配');
+            if (o.nodes?.length)
+                console.log(`  已挂节点: ${o.nodes.join(', ')}`);
+            if (o.init) {
+                const layoutFields = await listLayoutFields(client, refer.formId);
+                // 复制模式下本来就已经排好版；再 init 会把内容按字段清单重排，只有显式 --init 才做
+                const r = await initNodeLayout(client, {
+                    formId: refer.formId,
+                    workflowId,
+                    layoutId: layout.id,
+                    fields: o.fields,
+                    styleTemplateId: o.styleTemplate,
+                    required: o.required,
+                    readOnly: o.readonly,
+                    singleRow: o.singleRow,
+                });
+                if (json) {
+                    console.log(JSON.stringify({ success: true, formId: refer.formId, copiedFrom: from || null, layout, nodes: o.nodes || [], init: { ...r, availableFields: layoutFields.length } }, null, 2));
+                    return;
+                }
+                console.log(`  已排版: ${r.comps} 个组件 · 模板 ${r.styleTemplateId}${o.fields?.length ? ` · 只摆 ${o.fields.join('、')}` : ' · 全部字段'}`);
+                if (o.fields?.length && layoutFields.length) {
+                    console.log(`  （其余 ${layoutFields.filter((x) => !x.system).length - r.comps} 个业务字段只是这套布局不显示，表单上仍在）`);
+                }
+            }
+        }
+        catch (e) {
+            console.error(`新建布局失败: ${e.message}`);
+            process.exitCode = 1;
+        }
+    });
 }
 //# sourceMappingURL=workflow-node.js.map