weaver-e10-builder 1.1.9 → 1.2.3

package/dist/commands/workflow-auth-resp.js

@@ -0,0 +1,629 @@
+import { readFileSync } from 'node:fs';
+import { AuthSession } from '../core/auth.js';
+import { ApiClient } from '../core/client.js';
+const TABLE_API = '/api/authresp/table/authRespTableSet';
+const VARIABLE_API = '/api/bs/workflow/pathdef/variable';
+const AUTH_RESP_BROWSER_API = '/api/authresp/common/browser';
+function authRespNodeType(value, fallback) {
+    const types = { start: '0', approve: '1', confirm: '2', end: '3', archive: '3', vote: '5', auto: '7' };
+    return types[String(value || '').toLowerCase()] || String(value || fallback);
+}
+function readJsonArg(value) {
+    const text = value.startsWith('@') ? readFileSync(value.slice(1), 'utf-8') : value;
+    return JSON.parse(text.replace(/^\uFEFF/, ''));
+}
+/** 接口失败即报错退出。
+ *  **直接退出而不是抛出**：这些命令体没有 try/catch，抛出会变成 Node 未捕获异常的堆栈
+ *  （本文件 30+ 处调用），对使用者毫无指向性——只想知道哪一步失败、为什么。 */
+function assertSuccess(result, action) {
+    if (result?.code !== 200 || result?.status === false || result?.fail === true) {
+        console.error(`${action}失败: ${result?.msg || result?.data?.msg || '未知错误'}`);
+        process.exit(1);
+    }
+}
+function resultData(result) {
+    return result?.data?.data ?? result?.data;
+}
+function completeDesignColumns(design) {
+    const source = Array.isArray(design?.columns) ? design.columns : [];
+    if (source.some((column) => column.name === 'creator'))
+        return source;
+    const dynamic = source.filter((column) => String(column?.name || '').startsWith('pubNode-'));
+    const firstRow = Array.isArray(design?.rows) ? design.rows[0] || {} : {};
+    // 平台把首尾信息放在 creatorMap/endMap 的 **pubNodeInfo** 里，不是它们本身：
+    //   "creatorMap": { "pubNodeInfo": { "nodeType": "1", "nodeName": "片段入口", "nodeOperator": [...] } }
+    // 取浅一层（creatorMap.nodeType）恒为 undefined → 落到兜底 '0'/'3'，把「中间片段型」权责表的
+    // 首尾改写成发起/结束，它随即失去片段身份、不能再被上层引用（多层嵌套因此做不了）。
+    // nodeName/nodeOperator 也必须带上，否则名字被重置成「发起节点/结束节点」。
+    const creatorInfo = design?.creatorMap?.pubNodeInfo || {};
+    const endInfo = design?.endMap?.pubNodeInfo || {};
+    return [
+        { header: '发起权限', name: 'creator', itemType: 'CUSTOM', resizable: true, width: 115, pubNodeInfo: { ...creatorInfo, type: 'creator', nodeType: String(creatorInfo.nodeType ?? '0') } },
+        { header: '分支场景说明', name: 'eventColumn', itemType: 'INPUT', resizable: true, width: 180 },
+        { header: '条件设置', name: 'condition', itemType: 'CUSTOM', resizable: true, width: 200, whiteSpace: 'pre-line' },
+        ...dynamic,
+        { name: 'addCol', itemType: 'CUSTOM', width: 96 },
+        { header: '结束设置', name: 'endOperator', itemType: 'CUSTOM', resizable: true, width: 115, pubNodeInfo: { ...endInfo, type: 'endOperator', nodeType: String(endInfo.nodeType ?? '3') } },
+        { header: '流程图预览', name: 'preview', itemType: 'CUSTOM', width: 96 },
+        { header: '维护权限', name: 'maintain', itemType: 'CUSTOM', width: 96 },
+    ].map((column) => {
+        if (column.name === 'creator' && firstRow.creatorNodeId)
+            column.pubNodeInfo.nodeId = String(firstRow.creatorNodeId);
+        if (column.name === 'endOperator' && firstRow.endOperatorNodeId)
+            column.pubNodeInfo.nodeId = String(firstRow.endOperatorNodeId);
+        return column;
+    });
+}
+/**
+ * 按 sourceId 在权责表列表里反查 baseId。
+ *
+ * `saveAuthRespTableSet` **以 baseId 为主键**（浏览器抓包实测）：
+ *   - 传 `id: <sourceId>` → 500「服务器发生异常」
+ *   - 漏传 `id`           → **新增一条记录**，不是原地更新
+ * 列表条目的 `id` 就是 baseId、`sourceId` 是当前版本的 sourceId，据此反查。
+ */
+async function resolveAuthRespBaseId(client, baseUrl, authRespId) {
+    const pageSize = 200;
+    for (let page = 1; page <= 20; page++) {
+        const r = await client.post(`${baseUrl}${TABLE_API}/getAuthRespList`, {
+            name: '', pageSize, current: page, isSearch: false,
+        });
+        assertSuccess(r, '查询权责表列表');
+        const rows = resultData(r)?.wfrRespBaseList || [];
+        const hit = rows.find((x) => String(x?.sourceId || '') === String(authRespId));
+        if (hit?.id)
+            return String(hit.id);
+        if (rows.length < pageSize)
+            break;
+    }
+    throw new Error(`未在权责表列表里找到 sourceId=${authRespId} 的记录，请用 --base-id 显式指定`);
+}
+async function nextId(client, baseUrl, prefix) {
+    const result = await client.post(`${baseUrl}/api/bs/workflow/pathdef/multilang/getTargetId`, {
+        targetId: '-1', onlyKey: `${prefix}_${Date.now()}_${Math.floor(Math.random() * 10000)}`,
+    });
+    assertSuccess(result, '生成配置标识');
+    return String(result.data);
+}
+async function saveAuthRespOperator(args) {
+    const { client, baseUrl, authRespId, nodeId, workflowId, operator } = args;
+    const layout = await client.post(`${baseUrl}/api/bs/workflow/pathdef/nodeOperator/getLayoutConfigInfo`, {
+        groupId: '', workflowId: '-99999999', nodeId, sourceType: '1', isOperatorRuleAuth: true,
+        isPub: '1', belongScene: '3', belongSceneId: authRespId, isAuthResp: '1',
+        isCreate: args.isCreate ? '1' : '', isVoteType: '', isArchive: args.isArchive ? '1' : '',
+    });
+    assertSuccess(layout, '初始化权责表操作者');
+    const reserveGroupId = String(layout?.data?.reserveGroupId || '');
+    if (!reserveGroupId)
+        throw new Error(`节点 ${nodeId} 未返回 reserveGroupId`);
+    let itemDatas;
+    let label = operator.label || '';
+    if (operator.type === 'raw') {
+        if (!Array.isArray(operator.itemDatas) || operator.itemDatas.length === 0)
+            throw new Error(`节点 ${nodeId} 的 raw 操作者缺少 itemDatas`);
+        itemDatas = operator.itemDatas;
+        label ||= itemDatas[0]?.groupType || '自定义操作者';
+    }
+    else if (operator.type === 'user') {
+        if (!operator.keyword)
+            throw new Error(`节点 ${nodeId} 的 user 操作者缺少 keyword`);
+        const found = await client.post(`${baseUrl}/api/hrm/common/getEmployeeByKeyWords`, {
+            keyword: operator.keyword, searchType: 1, searchCount: 5, appDetachModule: 'EM', disableAppDetach: 0, pageNo: 1, pageSize: 5,
+        });
+        const users = found?.data?.userList || [];
+        const hit = users.find((u) => u.name === operator.keyword) || (users.length === 1 ? users[0] : null);
+        if (!hit)
+            throw new Error(`人员“${operator.keyword}”未找到或不唯一`);
+        label = hit.name;
+        itemDatas = [{
+                hrmOperators: String(hit.id), hrmOperatorsCN: hit.name, signOrder: '1', signOrderCN: '会签',
+                hrmBrowserDataDtos: [hit], groupType: '指定人', groupTypeId: '101', bigTypeId: 1,
+            }];
+    }
+    else if (operator.type === 'initiator') {
+        label = '流程发起人';
+        itemDatas = [{
+                includeType: '12', includeTypeCN: '本人', objLevelType: '1', objLevelTypeCN: '全部机构',
+                objectId: '1', objectIdCN: '直接上级', signOrder: '1', signOrderCN: '会签',
+                groupType: '流程发起人', groupTypeId: '114', bigTypeId: 1, itemName: '本人', level: '',
+            }];
+    }
+    else {
+        label = '所有人';
+        itemDatas = [{ groupType: '所有人', groupTypeId: '110', bigTypeId: 1 }];
+    }
+    itemDatas = itemDatas.map((item, index) => ({
+        isOut: false, isSaveHrmOperator: false, id: String(index + 1), itemName: '', itemLevel: '',
+        endApprovers: '', hrmOperators: '', levelObj: '', workflowId: '-99999999', nodeId,
+        conditionId: '', orders: '0.00', isOpen: true, condition: '', groupCondition: '',
+        isSuportVirtualId: false, openProjectOrganization: false, isExtendType: 0,
+        ...item,
+    }));
+    const saved = await client.post(`${baseUrl}/api/bs/workflow/pathdef/nodeOperator/saveOperatorGroup`, {
+        workflowId: '-99999999', nodeId,
+        groupId: args.isCreate && workflowId !== '-99999999' ? '-1' : '',
+        isCreate: args.isCreate ? '1' : '',
+        reserveGroupId, itemDatas, oldGroupName: '', refWorkflowId: workflowId === '-99999999' ? '' : workflowId,
+        isAuthResp: '1', oldItemDatas: [], groupName: '', deleteDatas: [], isPub: '1', mustreview: 0,
+    });
+    assertSuccess(saved, `保存节点 ${nodeId} 操作者`);
+    return { id: reserveGroupId, name: label };
+}
+/**
+ * 权责表是工作流公用流转中的独立资源，不等同于 HRM matrix，也不等同于普通公共片段。
+ * 本文件只管理权责表本体、变量及表格设计；创建权责表方式的流程见
+ * workflow-create-auth-resp.ts。
+ */
+export function registerWorkflowAuthRespCommands(wf, program) {
+    const root = wf.command('auth-resp').description('权责表创建、读取、变量与表格设计');
+    root.command('list')
+        .description('查询独立权责表')
+        .option('--name <keyword>', '按名称搜索', '')
+        .option('--page <n>', '页码', '1')
+        .option('--page-size <n>', '每页条数', '200')
+        .action(async (o) => {
+        const opts = program.opts();
+        const auth = await AuthSession.fromOptions(opts);
+        if (!auth)
+            throw new Error('无法加载认证');
+        const client = new ApiClient(auth);
+        const result = await client.post(`${auth.getBaseUrl()}${TABLE_API}/getAuthRespList`, {
+            name: o.name, pageSize: Number(o.pageSize), current: Number(o.page), isSearch: true,
+        });
+        assertSuccess(result, '查询权责表');
+        console.log(JSON.stringify(resultData(result), null, 2));
+    });
+    root.command('create')
+        .description('创建独立权责表')
+        .argument('<name>', '权责表名称')
+        .option('--desc <text>', '描述', '')
+        .action(async (name, o) => {
+        const opts = program.opts();
+        const auth = await AuthSession.fromOptions(opts);
+        if (!auth)
+            throw new Error('无法加载认证');
+        const client = new ApiClient(auth);
+        const result = await client.post(`${auth.getBaseUrl()}${TABLE_API}/saveAuthRespTableSet`, {
+            name, desc: o.desc, fragmentCreate: '1',
+        });
+        assertSuccess(result, '创建权责表');
+        const data = resultData(result);
+        const authRespId = data?.sourceId || data?.authRespId || data?.id || data;
+        const baseId = data?.id || '';
+        console.log(JSON.stringify({ authRespId, baseId, name, data }, null, 2));
+    });
+    root.command('update')
+        .description('修改权责表基础信息；配置内容以读取结果为准保留')
+        .argument('<authRespId>', '权责表 ID')
+        .argument('<name>', '权责表名称')
+        .option('--desc <text>', '描述', '')
+        .option('--base-id <id>', '权责表基础记录 ID（缺省时按 sourceId 在列表里反查）')
+        .action(async (authRespId, name, o) => {
+        const opts = program.opts();
+        const auth = await AuthSession.fromOptions(opts);
+        if (!auth)
+            throw new Error('无法加载认证');
+        const client = new ApiClient(auth);
+        const baseUrl = auth.getBaseUrl();
+        const baseId = String(o.baseId || await resolveAuthRespBaseId(client, baseUrl, authRespId));
+        // 报文对齐浏览器抓包：`id` 必须是 **baseId**（传 sourceId 会 500、漏传会新增一条记录），
+        // 权责表 id 的参数名是 `sourceId`（此前误用 authRespId），另需 isListEdit。
+        const result = await client.post(`${baseUrl}${TABLE_API}/saveAuthRespTableSet`, {
+            id: baseId, sourceId: authRespId, name, desc: o.desc, fragmentCreate: 1, isListEdit: 1,
+        });
+        assertSuccess(result, '修改权责表');
+        console.log(JSON.stringify({ authRespId, baseId, name, data: resultData(result) }, null, 2));
+    });
+    root.command('read')
+        .description('读取权责表完整设计（节点列、分支行、条件引用及版本）')
+        .argument('<authRespId>', '权责表 ID')
+        .requiredOption('--base-id <id>', '权责表基础记录 ID（独立创建返回的 baseId）')
+        .option('--workflow-id <id>', '流程内权责表所属流程 ID')
+        .option('--version <n>', '版本号', '0')
+        .action(async (authRespId, o) => {
+        const opts = program.opts();
+        const auth = await AuthSession.fromOptions(opts);
+        if (!auth)
+            throw new Error('无法加载认证');
+        const client = new ApiClient(auth);
+        const info = await client.get(`${auth.getBaseUrl()}/api/bs/workflow/pathdef/publicFlow/getAuthRespSegmentInfo?segmentId=${encodeURIComponent(authRespId)}`);
+        assertSuccess(info, '读取权责表信息');
+        const result = await client.post(`${auth.getBaseUrl()}${TABLE_API}/getAuthRespTableDetailSet`, {
+            baseId: o.baseId, sourceId: authRespId, versionNum: Number(o.version),
+            fragmentCreate: o.workflowId ? '0' : '1', canEdit: 1, isReadOnly: 0,
+        });
+        assertSuccess(result, '读取权责表');
+        console.log(JSON.stringify({ info: resultData(info), design: resultData(result) }, null, 2));
+    });
+    root.command('configure')
+        .description('按结构化配置从零创建变量、节点、操作者、分支条件和路径并保存完整权责表')
+        .argument('<authRespId>', '权责表 sourceId')
+        .requiredOption('--config <json|@file>', '完整权责表配置')
+        .action(async (authRespId, o) => {
+        const config = readJsonArg(o.config);
+        if (!config.baseId || !config.name)
+            throw new Error('config 必须包含 baseId 和 name');
+        if (!Array.isArray(config.nodes) || !Array.isArray(config.branches) || config.branches.length === 0) {
+            throw new Error('config.nodes 必须是数组，config.branches 必须是非空数组');
+        }
+        for (const [i, branch] of config.branches.entries()) {
+            if (!String(branch.scenario || '').trim())
+                throw new Error(`第 ${i + 1} 个分支缺少 scenario`);
+            if (!Array.isArray(branch.condition?.childrens) || branch.condition.childrens.length === 0)
+                throw new Error(`第 ${i + 1} 个分支缺少 condition.childrens`);
+            if (!Array.isArray(branch.path) || branch.path.length === 0)
+                throw new Error(`第 ${i + 1} 个分支缺少 path`);
+        }
+        const opts = program.opts();
+        const auth = await AuthSession.fromOptions(opts);
+        if (!auth)
+            throw new Error('无法加载认证');
+        const client = new ApiClient(auth);
+        const baseUrl = auth.getBaseUrl();
+        const workflowId = String(config.workflowId || '-99999999');
+        const fragmentCreate = workflowId === '-99999999' ? '1' : '0';
+        const usage = String(config.usage || 'workflow');
+        const startNodeType = authRespNodeType(config.start?.type, usage === 'fragment' ? '1' : '0');
+        const endNodeType = authRespNodeType(config.end?.type, usage === 'fragment' ? '1' : '3');
+        if (usage === 'fragment' && (['0', '3'].includes(startNodeType) || ['0', '3'].includes(endNodeType))) {
+            throw new Error('中间片段型权责表的首尾位置均不能使用发起节点或结束节点');
+        }
+        // 新建权责表时平台会预生成开始/结束节点和若干空白分支行；优先复用这些稳定 ID。
+        // 独立权责表若尚无初始化数据，再通过 getInitAuthRespTableSet 补齐。
+        const current = await client.post(`${baseUrl}${TABLE_API}/getAuthRespTableDetailSet`, {
+            baseId: String(config.baseId), sourceId: authRespId, fragmentCreate, canEdit: 1, isReadOnly: 0,
+        });
+        assertSuccess(current, '读取权责表初始化结构');
+        const currentDesign = resultData(current) || {};
+        const presetRows = Array.isArray(currentDesign.rows) ? currentDesign.rows : [];
+        for (const variable of config.variables || []) {
+            const id = String(variable.id || -Date.now() * 1000 - Math.floor(Math.random() * 1000));
+            const saved = await client.post(`${baseUrl}${VARIABLE_API}/saveVariable`, {
+                varName: variable.name, hasEditAuth: true, hasRespAuth: true, enable: 1,
+                varSecondType: variable.secondType || 'wf_hrmresource',
+                varNameMultiLangParam: { tablefield: 'wfp_variables.var_name', targetId: id, needRecodInputValue: true },
+                id, isDetail: variable.detail ? '1' : '0', varFirstType: variable.type,
+                varSymbol: variable.symbol || '', optionTemplate: variable.optionTemplate,
+                relateBrowser: variable.relateBrowser, belongScene: '3', belongSceneId: authRespId,
+            });
+            assertSuccess(saved, `创建变量 ${variable.name}`);
+            variable.id = id;
+        }
+        let startNodeId = String(config.start?.nodeId || presetRows[0]?.creatorNodeId || '');
+        let endNodeId = String(config.end?.nodeId || presetRows[0]?.endOperatorNodeId || '');
+        if (!startNodeId || !endNodeId) {
+            const initialized = await client.post(`${baseUrl}${TABLE_API}/getInitAuthRespTableSet`, { tableCount: 2, addNode: 0, hasSeq: 0 });
+            assertSuccess(initialized, '初始化权责表开始和结束节点');
+            [startNodeId, endNodeId] = (initialized?.data?.ids || []).map(String);
+        }
+        if (!startNodeId || !endNodeId)
+            throw new Error('未取得开始或结束节点 ID');
+        if (startNodeType !== '0') {
+            const deleted = await client.get(`${baseUrl}/api/bs/workflow/pathdef/nodeOperator/deleteAuthRespOperatorSetByNodeId?nodeId=${encodeURIComponent(startNodeId)}&nodeType=0`);
+            assertSuccess(deleted, '清理原发起节点操作者');
+        }
+        if (endNodeType !== '3') {
+            const deleted = await client.get(`${baseUrl}/api/bs/workflow/pathdef/nodeOperator/deleteAuthRespOperatorSetByNodeId?nodeId=${encodeURIComponent(endNodeId)}&nodeType=3`);
+            assertSuccess(deleted, '清理原结束节点操作者');
+        }
+        const startOp = await saveAuthRespOperator({ client, baseUrl, authRespId, nodeId: String(startNodeId), workflowId, operator: config.start?.operator || { type: 'all' }, isCreate: startNodeType === '0' });
+        const endOp = await saveAuthRespOperator({ client, baseUrl, authRespId, nodeId: String(endNodeId), workflowId, operator: config.end?.operator || { type: 'initiator' }, isArchive: endNodeType === '3' });
+        const nodeMap = new Map();
+        for (const node of config.nodes) {
+            if (!node.key || !node.name)
+                throw new Error('每个中间节点必须包含 key 和 name');
+            const init = await client.post(`${baseUrl}${TABLE_API}/getInitAuthRespTableSet`, { tableCount: 1, addNode: 1, hasSeq: 0 });
+            assertSuccess(init, `初始化节点 ${node.name}`);
+            const nodeId = String(init?.data?.nodeId || '');
+            const op = await saveAuthRespOperator({ client, baseUrl, authRespId, nodeId, workflowId, operator: node.operator || { type: 'all' } });
+            const nodeType = authRespNodeType(node.type, '1');
+            nodeMap.set(node.key, { ...node, nodeId, nodeType, operator: op });
+        }
+        const rows = [];
+        for (const [index, branch] of config.branches.entries()) {
+            const sourceId = String(presetRows[index]?.sourceId || await nextId(client, baseUrl, 'auth_resp_branch'));
+            const baseContext = {
+                workflowId, conditionName: `${config.name} ${branch.scenario}`, source: 2, sourceId,
+                belongScene: 3, belongSceneId: authRespId, segmentId: authRespId,
+                isRefAuthRespRule: true, readOnly: false,
+                relation: String(branch.condition.relation || 'AND').toUpperCase() === 'OR' ? 2 : 1,
+            };
+            const conditionInit = await client.post(`${baseUrl}/api/workflow/pathdef/rule/condition/getConditionSet`, {
+                ...baseContext, needFormfield: true, templateTokenId: String(Date.now()),
+            });
+            assertSuccess(conditionInit, `读取分支条件上下文 ${branch.scenario}`);
+            const mapBaseId = String(conditionInit?.data?.mapBaseId || conditionInit?.data?.conditionKey || '');
+            if (!mapBaseId)
+                throw new Error(`分支“${branch.scenario}”未取得 mapBaseId`);
+            const context = { ...baseContext, mapBaseId };
+            const setResult = await client.post(`${baseUrl}/api/workflow/pathdef/rule/condition/saveConditionSet`, context);
+            assertSuccess(setResult, `初始化分支条件 ${branch.scenario}`);
+            const savedCondition = await client.post(`${baseUrl}/api/workflow/pathdef/rule/condition/saveCondition`, {
+                ...context, isEdit: false, isFromRuleListPage: true, childrens: branch.condition.childrens,
+            });
+            assertSuccess(savedCondition, `保存分支条件 ${branch.scenario}`);
+            if (savedCondition?.data?.result !== true || !savedCondition?.data?.conditionKey) {
+                throw new Error(`保存分支条件“${branch.scenario}”未返回有效 conditionKey: ${savedCondition?.data?.msg || 'result=false'}`);
+            }
+            const conditionKey = String(savedCondition.data.conditionKey);
+            const bound = await client.post(`${baseUrl}/api/bs/workflow/pathdef/nodeLink/saveLinkConditionKey`, {
+                workflowId: '-99999999', linkId: sourceId, conditionKey, segmentId: authRespId,
+            });
+            assertSuccess(bound, `绑定分支条件 ${branch.scenario}`);
+            const row = {
+                rowKey: index, eventColumn: branch.scenario,
+                condition: savedCondition?.data?.conditionCn || branch.condition.description || '',
+                conditionKey, sourceId, sortKey: index + 1,
+                uniqueKey: `@dataKey${Date.now()}-${index}`,
+            };
+            if (presetRows[index]?.rowId)
+                row.rowId = String(presetRows[index].rowId);
+            if (presetRows[index]?.mainTainerObjectId)
+                row.mainTainerObjectId = String(presetRows[index].mainTainerObjectId);
+            if (index === 0) {
+                row.creator = config.start?.name || '开始节点';
+                row.creatorId = startOp.id;
+                row.creatorNodeId = startNodeId;
+                row.endOperator = config.end?.name || '结束节点';
+                row.endOperatorId = endOp.id;
+                row.endOperatorNodeId = endNodeId;
+            }
+            for (const step of branch.path) {
+                const node = nodeMap.get(step.node);
+                if (!node)
+                    throw new Error(`分支“${branch.scenario}”引用未知节点 key=${step.node}`);
+                row[`pubNode-${node.nodeId}`] = { nodeInfo: [{
+                            nodeId: '', pubNodeId: `pubNode-${node.nodeId}`,
+                            nodeName: `${node.name}_${String(index + 1).padStart(2, '0')}`,
+                            nodeType: node.nodeType, approveNum: Number(step.order).toFixed(2), addMethod: '1',
+                        }] };
+            }
+            rows.push(row);
+        }
+        const columns = [
+            { name: 'creator', itemType: 'CUSTOM', resizable: true, width: 115, pubNodeInfo: { type: 'creator', nodeType: startNodeType, nodeName: config.start?.name || '开始节点', nodeOperator: [startOp] } },
+            { header: '分支场景说明', name: 'eventColumn', itemType: 'INPUT', resizable: true, width: 180 },
+            { header: '条件设置', name: 'condition', itemType: 'CUSTOM', resizable: true, width: 200, whiteSpace: 'pre-line' },
+            ...Array.from(nodeMap.values()).map((node) => ({
+                name: `pubNode-${node.nodeId}`, itemType: 'CUSTOM', resizable: true, width: 115,
+                pubNodeInfo: { id: node.nodeId, name: node.name, nodeAttr: '0', nodeType: node.nodeType,
+                    publicAttr: node.nodeType, publicSegmentId: `-${authRespId}`, nodeOperator: [node.operator], addMethod: '1' },
+            })),
+            { name: 'addCol', itemType: 'CUSTOM', width: 96 },
+            { name: 'endOperator', itemType: 'CUSTOM', resizable: true, width: 115, pubNodeInfo: { type: 'endOperator', nodeType: endNodeType, nodeName: config.end?.name || '结束节点', nodeOperator: [endOp] } },
+            { header: '流程图预览', name: 'preview', itemType: 'CUSTOM', width: 96 },
+            { header: '维护权限', name: 'maintain', itemType: 'CUSTOM', width: 96 },
+        ];
+        const savedDesign = await client.post(`${baseUrl}${TABLE_API}/saveAuthRespTableDetailSet`, {
+            baseId: String(config.baseId), sourceId: authRespId, sourceName: config.name,
+            columns, rows, saveAsType: '', hasUpdate: '1', fragmentCreate,
+            ...(workflowId !== '-99999999' ? { refWorkflowId: workflowId } : {}),
+        });
+        assertSuccess(savedDesign, '保存完整权责表');
+        const verify = await client.post(`${baseUrl}${TABLE_API}/getAuthRespTableDetailSet`, {
+            baseId: String(config.baseId), sourceId: authRespId, fragmentCreate,
+            canEdit: 1, isReadOnly: 0,
+        });
+        assertSuccess(verify, '回读完整权责表');
+        const verifiedRows = resultData(verify)?.rows || [];
+        const invalidConditionRows = verifiedRows.slice(0, rows.length).filter((row) => !row?.conditionKey || !row?.condition);
+        if (invalidConditionRows.length > 0)
+            throw new Error(`权责表已保存，但有 ${invalidConditionRows.length} 个分支条件未正确回读`);
+        console.log(JSON.stringify({ authRespId, workflowId, nodes: Array.from(nodeMap.values()).map((n) => ({ key: n.key, id: n.nodeId })), branches: rows.length, design: resultData(verify) }, null, 2));
+    });
+    const reference = root.command('reference').description('在权责表分支路径中引用可嵌套的中间型权责表');
+    reference.command('list')
+        .description('查询可嵌套且不会形成循环引用的权责表')
+        .argument('<hostBaseId>', '当前权责表 baseId')
+        .option('--name <keyword>', '按名称搜索', '')
+        .option('--page <n>', '页码', '1')
+        .option('--page-size <n>', '每页条数', '20')
+        .action(async (hostBaseId, o) => {
+        const opts = program.opts();
+        const auth = await AuthSession.fromOptions(opts);
+        if (!auth)
+            throw new Error('无法加载认证');
+        const client = new ApiClient(auth);
+        const result = await client.post(`${auth.getBaseUrl()}${AUTH_RESP_BROWSER_API}/data/publicAuthRespBrowser`, {
+            browserMultiple: true, isNotIncludeCreateEnd: '1', noCycle: '1',
+            selecteds: hostBaseId, curAuthRespId: hostBaseId,
+            pageSize: Number(o.pageSize), current: Number(o.page),
+            formDatas: { name: [{ nameCondition: 'in', name: o.name }], arDesc: [{ arDescCondition: 'in' }], creator: [{ creatorCondition: 'in' }] },
+            quickSearchDatas: o.name ? { arName: o.name } : {}, type: 'and',
+        });
+        assertSuccess(result, '查询可嵌套权责表');
+        console.log(JSON.stringify(resultData(result), null, 2));
+    });
+    reference.command('add')
+        .description('把一张中间型权责表加入宿主权责表，并指定使用它的分支与顺序')
+        .argument('<hostAuthRespId>', '宿主权责表 sourceId')
+        .requiredOption('--base-id <id>', '宿主权责表 baseId')
+        .requiredOption('--reference <json|@file>', '引用信息 {id,name,baseId,versionNum,paths:[{branch|rowKey,order}]}')
+        .option('--workflow-id <id>', '宿主权责表所属流程 ID')
+        .action(async (hostAuthRespId, o) => {
+        const ref = readJsonArg(o.reference);
+        if (!ref?.id || !ref?.name || !ref?.baseId || !Array.isArray(ref.paths) || ref.paths.length === 0) {
+            throw new Error('reference 必须包含 id、name、baseId、versionNum 和非空 paths');
+        }
+        if (String(ref.id) === hostAuthRespId || String(ref.baseId) === o.baseId)
+            throw new Error('不能引用当前权责表自身');
+        const opts = program.opts();
+        const auth = await AuthSession.fromOptions(opts);
+        if (!auth)
+            throw new Error('无法加载认证');
+        const client = new ApiClient(auth);
+        const baseUrl = auth.getBaseUrl();
+        const fragmentCreate = o.workflowId ? '0' : '1';
+        const current = await client.post(`${baseUrl}${TABLE_API}/getAuthRespTableDetailSet`, {
+            baseId: o.baseId, sourceId: hostAuthRespId, fragmentCreate, canEdit: 1, isReadOnly: 0,
+        });
+        assertSuccess(current, '读取宿主权责表');
+        const design = resultData(current) || {};
+        const columns = completeDesignColumns(design);
+        const rows = design.rows || [];
+        const columnName = `pubNode-${ref.id}`;
+        if (columns.some((c) => c.name === columnName))
+            throw new Error(`权责表“${ref.name}”已经加入宿主设计`);
+        const checked = await client.post(`${baseUrl}${TABLE_API}/checkAuthRespRef`, [{ sourceId: String(ref.id), sourceName: String(ref.name) }]);
+        assertSuccess(checked, '校验权责表引用关系');
+        const addColIndex = columns.findIndex((c) => c.name === 'addCol');
+        const refColumn = { name: columnName, itemType: 'CUSTOM', resizable: true, width: 115, pubNodeInfo: {
+                id: String(ref.id), name: String(ref.name), arDesc: String(ref.arDesc || ''), versionNum: Number(ref.versionNum || 1),
+                baseId: String(ref.baseId), fragmentCreate: 1, addMethod: '2',
+            } };
+        columns.splice(addColIndex >= 0 ? addColIndex : columns.length, 0, refColumn);
+        for (const path of ref.paths) {
+            const row = path.rowKey !== undefined
+                ? rows.find((r) => String(r.rowKey) === String(path.rowKey))
+                : rows.find((r) => String(r.eventColumn) === String(path.branch));
+            if (!row)
+                throw new Error(`未找到引用路径指定的分支: ${path.branch ?? path.rowKey}`);
+            row[columnName] = { nodeInfo: [{ nodeId: '', pubNodeId: columnName, nodeName: String(ref.name),
+                        approveNum: Number(path.order).toFixed(2), addMethod: '2', ruleIds: '', ruleDesc: '', ruleType: '1', baseId: String(ref.baseId) }] };
+        }
+        const payload = { ...design, baseId: o.baseId, sourceId: hostAuthRespId, columns, rows,
+            saveAsType: '', hasUpdate: '1', fragmentCreate, ...(o.workflowId ? { refWorkflowId: o.workflowId } : {}) };
+        const saved = await client.post(`${baseUrl}${TABLE_API}/saveAuthRespTableDetailSet`, payload);
+        assertSuccess(saved, '保存嵌套权责表');
+        console.log(JSON.stringify({ hostAuthRespId, referenceId: String(ref.id), branches: ref.paths.length, design: resultData(saved) }, null, 2));
+    });
+    reference.command('remove')
+        .description('从宿主权责表的所有分支及节点列中移除嵌套权责表')
+        .argument('<hostAuthRespId>', '宿主权责表 sourceId')
+        .argument('<referenceId>', '被引用权责表 sourceId')
+        .requiredOption('--base-id <id>', '宿主权责表 baseId')
+        .option('--workflow-id <id>', '宿主权责表所属流程 ID')
+        .action(async (hostAuthRespId, referenceId, o) => {
+        const opts = program.opts();
+        const auth = await AuthSession.fromOptions(opts);
+        if (!auth)
+            throw new Error('无法加载认证');
+        const client = new ApiClient(auth);
+        const baseUrl = auth.getBaseUrl();
+        const fragmentCreate = o.workflowId ? '0' : '1';
+        const current = await client.post(`${baseUrl}${TABLE_API}/getAuthRespTableDetailSet`, { baseId: o.baseId, sourceId: hostAuthRespId, fragmentCreate, canEdit: 1, isReadOnly: 0 });
+        assertSuccess(current, '读取宿主权责表');
+        const design = resultData(current) || {};
+        const columnName = `pubNode-${referenceId}`;
+        design.columns = completeDesignColumns(design).filter((c) => c.name !== columnName);
+        for (const row of design.rows || [])
+            delete row[columnName];
+        const saved = await client.post(`${baseUrl}${TABLE_API}/saveAuthRespTableDetailSet`, { ...design, baseId: o.baseId,
+            sourceId: hostAuthRespId, saveAsType: '', hasUpdate: '1', fragmentCreate, ...(o.workflowId ? { refWorkflowId: o.workflowId } : {}) });
+        assertSuccess(saved, '移除嵌套权责表');
+        console.log(JSON.stringify({ hostAuthRespId, referenceId, removed: true }, null, 2));
+    });
+    root.command('save-design')
+        .description('保存节点列与分支路径设计（JSON 使用 read 的结构）')
+        .argument('<authRespId>', '权责表 ID')
+        .requiredOption('--config <json|@file>', '设计 JSON，建议使用 @design.json')
+        .action(async (authRespId, o) => {
+        const opts = program.opts();
+        const auth = await AuthSession.fromOptions(opts);
+        if (!auth)
+            throw new Error('无法加载认证');
+        const design = readJsonArg(o.config);
+        const rows = Array.isArray(design.rows) ? design.rows.filter((row) => {
+            const active = String(row?.eventColumn || '').trim() || String(row?.condition || '').trim() || String(row?.conditionKey || '').trim();
+            return active && String(row?.isAddRow || '') !== '1';
+        }) : [];
+        if (!Array.isArray(design.columns) || design.columns.length === 0)
+            throw new Error('config.columns 不能为空');
+        const baseId = String(design.baseId || '');
+        if (!baseId)
+            throw new Error('设计 JSON 缺少 baseId；请把 `auth-resp read <id> --base-id <baseId>` 的输出原样作为 --config');
+        for (const [index, row] of rows.entries()) {
+            if (!String(row.eventColumn || '').trim())
+                throw new Error(`第 ${index + 1} 个有效分支缺少分支场景说明 eventColumn`);
+            if (!String(row.conditionKey || '').trim())
+                throw new Error(`第 ${index + 1} 个有效分支缺少条件 conditionKey`);
+        }
+        // 平台读回的 columns **只有** pubNode-* 动态列，固定列（发起 / 场景说明 / 条件 / 结束）不在其中。
+        // 原样回存会让平台丢掉分支场景、条件与首尾设置（creatorMap 一并被清空）——
+        // 浏览器保存报文实测是**带**固定列的，reference add / remove 也靠 completeDesignColumns 补回，
+        // 只有这里此前漏了。
+        const columns = completeDesignColumns(design);
+        const payload = {
+            ...design,
+            baseId,
+            sourceId: String(design.sourceId || authRespId),
+            columns,
+            rows,
+            fragmentCreate: String(design.fragmentCreate ?? '1'),
+            hasUpdate: String(design.hasUpdate ?? '1'),
+        };
+        const client = new ApiClient(auth);
+        const result = await client.post(`${auth.getBaseUrl()}${TABLE_API}/saveAuthRespTableDetailSet`, payload);
+        assertSuccess(result, '保存权责表设计');
+        // 保存响应本身就回吐了完整设计（含 baseId/columns/rows），先据此确认保存真的生效。
+        const saved = resultData(result) || {};
+        if (!Array.isArray(saved.columns) || saved.columns.length === 0) {
+            throw new Error('保存接口未回吐有效设计（columns 为空），请用 `auth-resp read` 核对后再重试。');
+        }
+        // 回读校验必须带 baseId：只传 sourceId 时平台返回空壳（baseId=0、无 columns/rows），
+        // 于是无论保存成功与否都会打出 saved:true —— 静默误报。
+        const verify = await client.post(`${auth.getBaseUrl()}${TABLE_API}/getAuthRespTableDetailSet`, {
+            baseId, sourceId: payload.sourceId, versionNum: 0,
+            fragmentCreate: payload.fragmentCreate, canEdit: 1, isReadOnly: 0,
+        });
+        assertSuccess(verify, '回读权责表设计');
+        const verified = resultData(verify) || {};
+        if (!Array.isArray(verified.columns) || verified.columns.length === 0) {
+            throw new Error('已提交保存，但带 baseId 回读到的设计为空（保存可能未生效）。请用 `auth-resp read` 核对。');
+        }
+        console.log(JSON.stringify({
+            authRespId: payload.sourceId, baseId, saved: true,
+            verified: { columns: verified.columns.length, rows: Array.isArray(verified.rows) ? verified.rows.length : 0 },
+            design: verified,
+        }, null, 2));
+    });
+    const variable = root.command('variable').description('权责表变量管理（变量先创建，条件再引用）');
+    variable.command('list')
+        .argument('<authRespId>', '权责表 ID')
+        .action(async (authRespId) => {
+        const opts = program.opts();
+        const auth = await AuthSession.fromOptions(opts);
+        if (!auth)
+            throw new Error('无法加载认证');
+        const client = new ApiClient(auth);
+        const result = await client.post(`${auth.getBaseUrl()}${VARIABLE_API}/getAllVariable`, {
+            belongScene: '3', belongSceneId: authRespId, pageSize: 0, current: 1,
+        });
+        assertSuccess(result, '查询权责表变量');
+        console.log(JSON.stringify(resultData(result), null, 2));
+    });
+    variable.command('add')
+        .description('新增权责表变量；类型码使用 wf_string/wf_number/wf_select/wf_browser/wf_browser_relate')
+        .argument('<authRespId>', '权责表 ID')
+        .argument('<name>', '变量名称')
+        .argument('<type>', '变量类型码')
+        .option('--second-type <type>', '浏览变量二级类型', 'wf_hrmresource')
+        .option('--detail', '明细变量')
+        .option('--option-template <json|@file>', '选项模板对象 {id,name}')
+        .option('--relate-browser <json|@file>', '关联浏览类型数组')
+        .action(async (authRespId, name, type, o) => {
+        const allowed = ['wf_string', 'wf_number', 'wf_select', 'wf_browser', 'wf_browser_relate'];
+        if (!allowed.includes(type))
+            throw new Error(`变量类型不支持: ${type}；当前支持 ${allowed.join(', ')}`);
+        const opts = program.opts();
+        const auth = await AuthSession.fromOptions(opts);
+        if (!auth)
+            throw new Error('无法加载认证');
+        const id = String(-Date.now() * 1000 - Math.floor(Math.random() * 1000));
+        const payload = {
+            varName: name, hasEditAuth: true, hasRespAuth: true, enable: 1,
+            varSecondType: o.secondType, id, isDetail: o.detail ? '1' : '0',
+            varFirstType: type, varSymbol: '', belongScene: '3', belongSceneId: authRespId,
+            varNameMultiLangParam: { tablefield: 'wfp_variables.var_name', targetId: id, needRecodInputValue: true },
+        };
+        if (o.optionTemplate)
+            payload.optionTemplate = readJsonArg(o.optionTemplate);
+        if (o.relateBrowser)
+            payload.relateBrowser = readJsonArg(o.relateBrowser);
+        const client = new ApiClient(auth);
+        const result = await client.post(`${auth.getBaseUrl()}${VARIABLE_API}/saveVariable`, payload);
+        assertSuccess(result, '新增权责表变量');
+        console.log(JSON.stringify({ authRespId, variableId: id, name, type, data: resultData(result) }, null, 2));
+    });
+}
+//# sourceMappingURL=workflow-auth-resp.js.map