weaver-work-cli 0.1.2 → 0.1.5

package/dist/shortcuts/meeting/index.js

@@ -0,0 +1,123 @@
+import { readFile } from 'node:fs/promises';
+import { ExitCode, isCliError, toErrorEnvelope } from '../../core/errors.js';
+import { createMeetingContinuationSigner } from './continuation.js';
+import { createMeetingHost } from './host.js';
+import { meetingManifest } from './manifest.js';
+import { executeMeetingOperation } from './operations.js';
+import { meetingValidationError } from './errors.js';
+function asOptions(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+/**
+ * Windows PowerShell 的管道与 Set-Content -Encoding utf8 会在内容前写入 UTF-8 BOM，
+ * 且可能重复写入多次；JSON.parse 不接受前导 BOM，必须先剥离。
+ */
+function stripBom(value) {
+    return value.replace(/^\uFEFF+/, '');
+}
+export async function inputFrom(options, extra = {}) {
+    const opts = asOptions(options);
+    let input = {};
+    if (opts.input && opts.inputJson) {
+        throw meetingValidationError('input_conflict', '不能同时传 --input 和 --input-json');
+    }
+    if (opts.inputJson) {
+        input = parseJsonInput(String(opts.inputJson), '--input-json');
+    }
+    if (opts.input) {
+        let raw;
+        try {
+            raw = stripBom(opts.input === '-' ? await readStdin() : await readFile(String(opts.input), 'utf8'));
+        }
+        catch {
+            throw meetingValidationError('input_unreadable', `无法读取 --input：${String(opts.input)}`);
+        }
+        input = parseJsonInput(raw, '--input');
+    }
+    return {
+        ...input,
+        ...Object.fromEntries(Object.entries(extra).filter(([, value]) => value !== undefined && value !== '')),
+    };
+}
+function parseJsonInput(raw, label) {
+    try {
+        const parsed = JSON.parse(stripBom(raw));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error('input must be an object');
+        }
+        return parsed;
+    }
+    catch {
+        throw meetingValidationError('input_invalid', `${label} 不是合法 JSON 对象`);
+    }
+}
+export function successEnvelope(operation, result) {
+    return {
+        schemaVersion: 1,
+        ok: true,
+        operation,
+        data: result.data === undefined ? null : result.data,
+        ...(result.meta ? { meta: result.meta } : {}),
+        ...(result.warnings && result.warnings.length > 0 ? { warnings: result.warnings } : { warnings: [] }),
+    };
+}
+function failureEnvelope(error) {
+    const structured = error;
+    return {
+        schemaVersion: 1,
+        ok: false,
+        ...(structured?.partialData === undefined ? {} : { data: structured.partialData }),
+        error: toErrorEnvelope(error),
+    };
+}
+async function executeAndPrint(ctx, operation, input) {
+    try {
+        const result = await executeMeetingOperation(operation, input, {
+            ctx,
+            host: createMeetingHost(ctx),
+            continuation: createMeetingContinuationSigner(ctx),
+        });
+        ctx.output.write(successEnvelope(operation, result), { json: true });
+    }
+    catch (error) {
+        console.error(JSON.stringify(failureEnvelope(error), null, 2));
+        process.exitCode = isCliError(error) ? error.exitCode : ExitCode.GeneralError;
+    }
+}
+export const meetingShortcut = {
+    name: 'meeting',
+    description: '泛微E10会议管理 CLI（标准版：查询/冲突/预约/回执/签到）',
+    category: 'shortcut',
+    register({ program, action }) {
+        const meeting = program.command('meeting').description('泛微E10会议管理（模式探测/会议列表/会议室/类型/冲突检测/预约/回执/签到）');
+        meeting.command('schema')
+            .description('Print meeting operation manifest for agents')
+            .action(action((ctx) => {
+            ctx.output.write(meetingManifest, { json: true });
+        }));
+        meeting.command('run')
+            .description('Run a meeting operation with JSON input')
+            .argument('<operation>', 'operation name, e.g. meeting.room.list')
+            .option('--input <path>', 'JSON input file, or - for stdin')
+            .option('--input-json <json>', 'inline JSON input object')
+            .action(action(async (ctx, operation, options) => {
+            await executeAndPrint(ctx, String(operation), await inputFrom(options));
+        }));
+        // 高频便捷命令（薄包装，最终调用同一 operation 执行器）
+        meeting.command('today')
+            .description('查询今天的会议（meeting.list 薄包装）')
+            .action(action(async (ctx) => {
+            const today = new Date();
+            const pad = (value) => String(value).padStart(2, '0');
+            const date = `${today.getFullYear()}-${pad(today.getMonth() + 1)}-${pad(today.getDate())}`;
+            await executeAndPrint(ctx, 'meeting.list', { filterDate: date });
+        }));
+    },
+};

package/dist/shortcuts/meeting/manifest.js

@@ -0,0 +1,64 @@
+import { meetingOperationDefinitions } from './operations/registry.js';
+/**
+ * 未实现能力（禁用边界，不得编造或绕过）：
+ * - EB 版业务链路（query_mtDetail_list / create_meeting / 三件套 / 议题 / 纪要 / 报表）：
+ *   依赖 eBuilder formdata 动态字段与工作流集成，未随 v1 实现。
+ * - 周期会议走工作流（repeatWorkFlowBaseIds 非空）与 onlyFlowCreate=1 的流程建会：
+ *   需要 workflow 集成，create.prepare 会主动拒绝并提示。
+ * - 提前结束会议（meeting.over）：服务端为空实现（假成功），CLI 不提供。
+ * - 签到二维码（getQrCode 入参契约未确认）、签到写操作（signMeeting 等）、
+ *   会议室/会议类型管理（add/update/delete/lock/详情）：待后续版本评估。
+ *
+ * 已实现的生命周期写操作：meeting.change（变更：按会议状态自动选 operateType，
+ * 草稿=UPDATE / 正常=CHANGE）、meeting.cancel（取消）、meeting.delete（彻底删除），
+ * 均走 prepare→apply 确认链。权限由服务端按会议状态判定并返回原文提示，CLI 原样透传。
+ */
+const WITHHELD = [
+    {
+        name: 'meeting.eb.*',
+        reason: 'EB 版业务链路依赖 eBuilder formdata 动态字段结构与工作流集成，v1 未实现；请使用 EB 版独立流程或后续版本。',
+    },
+    {
+        name: 'meeting.create.workflow',
+        reason: 'onlyFlowCreate=1 或周期会议配置工作流时必须走流程建会；CLI v1 未集成工作流发起，create.prepare 会主动拒绝。',
+    },
+    {
+        name: 'meeting.over',
+        reason: '服务端提前结束会议（overMeeting）为空实现：MeetingDetailController.overMeetingDetail 中 service 调用被注释，接口直接返回成功但不生效；CLI 不提供该能力，禁止绕过（调用只会得到“假成功”）。',
+    },
+    {
+        name: 'meeting.sign.qrcode',
+        reason: '签到二维码接口（getQrCode）入参契约未在源资料中确认，未实现，不得猜测参数。',
+    },
+    {
+        name: 'meeting.sign.submit',
+        reason: '签到写操作（signMeeting 等）未实现，不得绕过确认链直接调用。',
+    },
+    {
+        name: 'meeting.room.admin / meeting.type.admin',
+        reason: '会议室/会议类型管理（add/update/delete/lock/详情）未实现，待后续版本评估。',
+    },
+];
+function buildOperations() {
+    return meetingOperationDefinitions().map((definition) => ({
+        name: definition.name,
+        resource: definition.resource,
+        summary: definition.summary,
+        capability: definition.capability,
+        risk: definition.risk,
+        ...(definition.requiresConfirmation ? { requiresConfirmation: true } : {}),
+        inputSchema: definition.inputSchema,
+    }));
+}
+export const meetingManifest = {
+    schemaVersion: 1,
+    name: 'meeting',
+    title: '泛微E10会议管理（标准版：查询/冲突/预约/取消/回执/签到）',
+    version: '1.0.0',
+    host: 'e10-meeting',
+    status: 'builtin',
+    sourceSkill: 'weaver-e10-meeting',
+    capabilities: ['env', 'meeting', 'room', 'type', 'conflict', 'lifecycle', 'receipt', 'sign'],
+    operations: buildOperations(),
+    withheldOperations: WITHHELD,
+};

package/dist/shortcuts/meeting/operations/catalogs.js

@@ -0,0 +1,58 @@
+import { meetingSuccess } from './types.js';
+import { extractRows } from './shared.js';
+// ---------------------------------------------------------------------------
+// 会议类型列表（mt_type browser 组件；总数走 count 接口）
+// ---------------------------------------------------------------------------
+const meetingTypeList = {
+    name: 'meeting.type.list',
+    resource: 'type',
+    method: 'type.list',
+    action: 'meeting.type.list',
+    summary: '查询会议类型列表（mt_type browser 组件，权限友好；includeCount=true 时再调 count/mt_type 取总数）',
+    capability: 'type',
+    risk: 'read',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            name: { type: 'string', description: '按类型名称过滤' },
+            current: { type: 'integer', description: '页码，默认 1' },
+            pageSize: { type: 'integer', description: '页大小，默认 100' },
+            includeCount: { type: 'boolean', description: '是否调用 count/mt_type 返回总数' },
+        },
+    },
+    handler: async (args, { host }) => {
+        const body = {
+            browserMultiple: false,
+            current: typeof args.current === 'number' && args.current > 0 ? args.current : 1,
+            pageSize: typeof args.pageSize === 'number' && args.pageSize > 0 ? args.pageSize : 100,
+            formDatas: typeof args.name === 'string' && args.name.trim()
+                ? { name: [{ nameCondition: 'in', name: args.name.trim() }] }
+                : {},
+            quickSearchDatas: {},
+            type: 'and',
+        };
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/meeting/common/browser/data/mt_type',
+            operation: 'meeting.type.list',
+            body,
+        });
+        const { rows } = extractRows(response);
+        let total;
+        if (args.includeCount === true) {
+            const countResponse = await host.request({
+                method: 'POST',
+                path: '/api/meeting/common/browser/count/mt_type',
+                operation: 'meeting.type.list',
+                body: { ...body, formDatas: typeof args.name === 'string' && args.name.trim() ? body.formDatas : {} },
+            });
+            total = countResponse?.data?.total;
+        }
+        return meetingSuccess('meeting.type.list', {
+            ...(total !== undefined ? { total } : {}),
+            types: rows,
+        });
+    },
+};
+export const meetingCatalogOperations = [meetingTypeList];

package/dist/shortcuts/meeting/operations/change.js

@@ -0,0 +1,242 @@
+import { createHash } from 'node:crypto';
+import { meetingConfirmationError, meetingPartialError, meetingValidationError } from '../errors.js';
+import { meetingSuccess, SCHEMA_DATETIME_MINUTE, SCHEMA_ID } from './types.js';
+import { assertDateTimeMinute, extractRows, toIdCsv, toIdString } from './shared.js';
+const CONTINUATION_TTL_SECONDS = 600;
+const LIST_PATH = '/api/meeting/search/getMeetingList';
+function fingerprint(value) {
+    return createHash('sha256').update(JSON.stringify(value ?? null)).digest('hex').slice(0, 32);
+}
+function requireConfirm(args, action) {
+    if (args.confirm !== true) {
+        throw meetingConfirmationError(action, { hint: '重新调用时传入 confirm=true 与 prepare 返回的 continuation' });
+    }
+}
+async function verifyLease(args, action, env) {
+    const lease = await env.continuation.verify(args.continuation, action);
+    const session = await env.host.getSession();
+    if (lease.baseUrl !== session.baseUrl || lease.profile !== session.profile || lease.userId !== session.userId) {
+        throw meetingValidationError('context_mismatch', '确认上下文已变化（租户或登录账号不同），请重新执行 prepare');
+    }
+    return lease;
+}
+function isNetworkError(error) {
+    return error instanceof Error && error.type === 'network';
+}
+/** 可变更的主表字段（与 MeetingDetailBean 对齐）。 */
+const CHANGABLE_FIELDS = [
+    'name',
+    'beginDatetime',
+    'endDatetime',
+    'address',
+    'customizeAddress',
+    'mtType',
+    'hrmMembers',
+    'orgMembers',
+    'otherMembers',
+    'crmMembers',
+    'totalMember',
+    'caller',
+    'contacter',
+];
+const DATE_FIELDS = new Set(['beginDatetime', 'endDatetime']);
+const ID_FIELDS = new Set(['address', 'mtType', 'caller', 'contacter']);
+const CSV_FIELDS = new Set(['hrmMembers', 'orgMembers', 'crmMembers']);
+/** 归一化变更输入：只提交调用方显式给出的字段。 */
+export function normalizeChangeInput(args) {
+    const id = toIdString(args.id, 'id');
+    const body = { id };
+    for (const field of CHANGABLE_FIELDS) {
+        const value = args[field];
+        if (value === undefined)
+            continue;
+        if (DATE_FIELDS.has(field)) {
+            body[field] = assertDateTimeMinute(value, field);
+        }
+        else if (ID_FIELDS.has(field)) {
+            body[field] = toIdString(value, field);
+        }
+        else if (CSV_FIELDS.has(field)) {
+            const csv = toIdCsv(value, field);
+            if (csv !== undefined)
+                body[field] = csv;
+        }
+        else if (field === 'name') {
+            const name = typeof value === 'string' ? value.trim() : '';
+            if (!name)
+                throw meetingValidationError('name_invalid', 'name 不能为空字符串');
+            body[field] = name;
+        }
+        else {
+            body[field] = value;
+        }
+    }
+    if (Object.keys(body).length <= 1) {
+        throw meetingValidationError('no_changes', '未提供任何要修改的字段：请至少提供 name / beginDatetime / endDatetime / address 等其中之一');
+    }
+    return body;
+}
+/**
+ * 按会议当前状态确定 operateType。源码依据（MeetingBaseServiceUtils.getShowButtons）：
+ * - mtStatus==0（草稿）→ 按钮 do_edit（编辑）→ operateMeetingByType(operateType=UPDATE)
+ * - mtStatus 正常（2/8/9，未结束）→ 按钮 do_change → operateMeetingByType(operateType=CHANGE)
+ * 实测列表字段：草稿会议 mtStatus="草稿"/status="0"，正常会议 mtStatus="未开始"/status="notStart"。
+ */
+function isDraftRow(row) {
+    const text = `${row?.mtStatus ?? ''}`;
+    if (text.includes('草稿'))
+        return true;
+    return row?.status !== undefined && String(row?.status) === '0';
+}
+async function resolveOperateType(id, env, operation) {
+    const pageSize = 50;
+    for (let current = 1; current <= 10; current++) {
+        const response = await env.host.request({
+            method: 'POST',
+            path: LIST_PATH,
+            operation,
+            body: { current, pageSize },
+        });
+        const { rows, total } = extractRows(response);
+        const row = rows.find((item) => String(item?.id ?? '') === id);
+        if (row) {
+            return {
+                operateType: isDraftRow(row) ? 'UPDATE' : 'CHANGE',
+                mtStatus: `${row?.mtStatus ?? ''}`,
+                name: `${row?.name ?? ''}`,
+            };
+        }
+        if (rows.length === 0 || (total !== undefined && current * pageSize >= total))
+            break;
+    }
+    throw meetingValidationError('meeting_not_found', `未在会议列表中定位到会议 ${id}：请确认 id 正确且当前账号可见（草稿走 UPDATE、正常会议走 CHANGE，二者都要求会议在列表中可见）`);
+}
+const meetingChangePrepare = {
+    name: 'meeting.change.prepare',
+    resource: 'meeting',
+    method: 'change.prepare',
+    action: 'meeting.change.prepare',
+    summary: '准备会议变更（改期/改地点/改参会人）：按会议状态自动选择 operateType（草稿=UPDATE、正常=CHANGE），生成确认预览，不写入',
+    capability: 'lifecycle',
+    risk: 'read-before-write',
+    requiresConfirmation: true,
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            id: { ...SCHEMA_ID, description: '会议 id（必填）' },
+            name: { type: 'string', minLength: 1, description: '会议名称' },
+            beginDatetime: { ...SCHEMA_DATETIME_MINUTE, description: '开始时间' },
+            endDatetime: { ...SCHEMA_DATETIME_MINUTE, description: '结束时间' },
+            address: { ...SCHEMA_ID, description: '会议室 id' },
+            customizeAddress: { type: 'string', description: '自定义地点' },
+            mtType: { ...SCHEMA_ID, description: '会议类型 id' },
+            hrmMembers: { type: 'string', description: '参会人员 id，逗号分隔字符串' },
+            orgMembers: { type: 'string', description: '参会部门 id，逗号分隔字符串' },
+            otherMembers: { type: 'string', description: '其他参会人员（文本）' },
+            crmMembers: { type: 'string', description: '参会客户 id，逗号分隔字符串' },
+            totalMember: { type: 'integer', description: '参会人数' },
+            caller: { ...SCHEMA_ID, description: '召集人 id' },
+            contacter: { ...SCHEMA_ID, description: '联系人 id' },
+        },
+        required: ['id'],
+    },
+    handler: async (args, env) => {
+        const body = normalizeChangeInput(args);
+        const id = String(body.id);
+        const { operateType, mtStatus, name } = await resolveOperateType(id, env, 'meeting.change.prepare');
+        const payload = { ...body, operateType };
+        const session = await env.host.getSession();
+        const token = await env.continuation.issue({
+            operation: 'meeting.change.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            payload,
+            fingerprint: fingerprint(payload),
+        }, CONTINUATION_TTL_SECONDS * 1000);
+        return meetingSuccess('meeting.change.prepare', {
+            status: 'AWAITING_CONFIRMATION',
+            preview: {
+                id,
+                name,
+                currentStatus: mtStatus,
+                operateType,
+                operateTypeReason: operateType === 'UPDATE' ? '草稿会议走更新（UPDATE）' : '正常会议走变更（CHANGE）',
+                changedFields: Object.keys(body).filter((key) => key !== 'id'),
+                body: payload,
+                note: '本 operation 只提交上面列出的字段；权限由服务端按会议状态判定，若无权限会返回“您没有变更权限！”等原文提示，请原样转达用户。',
+            },
+            continuation: token,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
+        });
+    },
+};
+const meetingChangeApply = {
+    name: 'meeting.change.apply',
+    resource: 'meeting',
+    method: 'change.apply',
+    action: 'meeting.change.apply',
+    summary: '提交会议变更（operateMeetingByType，草稿 UPDATE / 正常 CHANGE，body 传参）；必须在用户明确确认后调用',
+    capability: 'lifecycle',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            confirm: { const: true },
+            continuation: { type: 'string', minLength: 1 },
+            id: SCHEMA_ID,
+            name: { type: 'string' },
+            beginDatetime: SCHEMA_DATETIME_MINUTE,
+            endDatetime: SCHEMA_DATETIME_MINUTE,
+            address: SCHEMA_ID,
+            customizeAddress: { type: 'string' },
+            mtType: SCHEMA_ID,
+            hrmMembers: { type: 'string' },
+            orgMembers: { type: 'string' },
+            otherMembers: { type: 'string' },
+            crmMembers: { type: 'string' },
+            totalMember: { type: 'integer' },
+            caller: SCHEMA_ID,
+            contacter: SCHEMA_ID,
+        },
+        required: ['confirm', 'continuation', 'id'],
+    },
+    handler: async (args, env) => {
+        requireConfirm(args, 'meeting.change.apply');
+        const lease = await verifyLease(args, 'meeting.change.apply', env);
+        const body = normalizeChangeInput(args);
+        const id = String(body.id);
+        const { operateType, mtStatus } = await resolveOperateType(id, env, 'meeting.change.apply');
+        const leaseOperateType = lease.payload?.operateType;
+        if (leaseOperateType && leaseOperateType !== operateType) {
+            throw meetingValidationError('target_changed', `会议状态已变化（prepare 时按 ${leaseOperateType}、当前按 ${operateType}，当前状态：${mtStatus}），请重新执行 prepare 并向用户确认`);
+        }
+        const payload = { ...body, operateType };
+        if (lease.fingerprint !== fingerprint(payload)) {
+            throw meetingValidationError('target_changed', '变更内容与 prepare 时的快照不一致，请重新执行 prepare');
+        }
+        let response;
+        try {
+            response = await env.host.request({
+                method: 'POST',
+                path: '/api/meeting/detail/operateMeetingByType',
+                operation: 'meeting.change.apply',
+                body: payload,
+            });
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw meetingPartialError('变更请求发送后连接中断，是否已生效不确定，禁止自动重试，请通过 meeting.list 或会议详情回查确认', { attempted: { id, operateType } }, { stage: 'change' });
+            }
+            throw error;
+        }
+        return meetingSuccess('meeting.change.apply', { status: 'COMPLETE', id, operateType, result: response });
+    },
+};
+export const meetingChangeOperations = [
+    meetingChangePrepare,
+    meetingChangeApply,
+];

package/dist/shortcuts/meeting/operations/conflicts.js

@@ -0,0 +1,142 @@
+import { meetingSuccess, SCHEMA_DATETIME_MINUTE, SCHEMA_ID } from './types.js';
+import { assertDateTimeMinute, extractConflict, toIdCsv, toIdString } from './shared.js';
+/**
+ * MeetingCheckBean 公共输入（标准版三个冲突接口共用）。
+ * 返回 verdict 归一化：ok（cansub=true 且无冲突描述）/ warn（cansub=true 但有冲突描述）
+ * / rejected（cansub=false）/ unknown（接口未返回 cansub，需人工复核）。
+ */
+function conflictProperties() {
+    return {
+        beginDatetime: { ...SCHEMA_DATETIME_MINUTE, description: '开始时间（必填）' },
+        endDatetime: { ...SCHEMA_DATETIME_MINUTE, description: '结束时间（必填）' },
+        address: { ...SCHEMA_ID, description: '会议室 id（会议室冲突目标）' },
+        hrmids: { type: 'string', description: '参会人员 id，逗号分隔字符串' },
+        crmids: { type: 'string', description: '参会客户 id，逗号分隔字符串' },
+        mtId: { ...SCHEMA_ID, description: '会议 id（变更检测时排除自身）' },
+        caller: SCHEMA_ID,
+        contacter: SCHEMA_ID,
+        requestid: { type: 'string', description: '流程 id' },
+        totalmember: { type: 'integer', description: '应到人数' },
+        frequent: { type: 'integer', enum: [1, 2, 3, 4], description: '周期频率：1=天 2=周 3=月 4=年' },
+        repeatRuleEx: { type: 'string', description: '周期规则（RRULE）' },
+        serviceItems: { type: 'string', description: '会议服务' },
+        creator: SCHEMA_ID,
+    };
+}
+function verdictOf(cansub, message) {
+    if (cansub === false)
+        return 'rejected';
+    if (cansub === true)
+        return message ? 'warn' : 'ok';
+    return message ? 'warn' : 'unknown';
+}
+async function runConflictCheck(operation, path, args, host) {
+    const body = {
+        beginDatetime: assertDateTimeMinute(args.beginDatetime, 'beginDatetime'),
+        endDatetime: assertDateTimeMinute(args.endDatetime, 'endDatetime'),
+    };
+    if (args.address !== undefined)
+        body.address = toIdString(args.address, 'address');
+    if (args.hrmids !== undefined)
+        body.hrmids = toIdCsv(args.hrmids, 'hrmids');
+    if (args.crmids !== undefined)
+        body.crmids = toIdCsv(args.crmids, 'crmids');
+    if (args.mtId !== undefined)
+        body.mtId = toIdString(args.mtId, 'mtId');
+    if (args.caller !== undefined)
+        body.caller = toIdString(args.caller, 'caller');
+    if (args.contacter !== undefined)
+        body.contacter = toIdString(args.contacter, 'contacter');
+    if (args.requestid !== undefined)
+        body.requestid = args.requestid;
+    if (args.totalmember !== undefined)
+        body.totalmember = args.totalmember;
+    if (args.frequent !== undefined)
+        body.frequent = args.frequent;
+    if (args.repeatRuleEx !== undefined)
+        body.repeatRuleEx = args.repeatRuleEx;
+    if (args.serviceItems !== undefined)
+        body.serviceItems = args.serviceItems;
+    if (args.creator !== undefined)
+        body.creator = toIdString(args.creator, 'creator');
+    const response = await host.request({ method: 'POST', path, operation, body });
+    const conflict = extractConflict(response);
+    return { ...conflict, verdict: verdictOf(conflict.cansub, conflict.message), raw: response };
+}
+const meetingConflictRoom = {
+    name: 'meeting.conflict.room',
+    resource: 'conflict',
+    method: 'conflict.room',
+    action: 'meeting.conflict.room',
+    summary: '会议室冲突检测（meetingChkRoom）：verdict=rejected 禁止提交 / warn 仅提醒 / ok 无冲突',
+    capability: 'conflict',
+    risk: 'read',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: conflictProperties(),
+        required: ['beginDatetime', 'endDatetime', 'address'],
+    },
+    handler: async (args, { host }) => {
+        const result = await runConflictCheck('meeting.conflict.room', '/api/meeting/detail/meetingChkRoom', args, host);
+        return meetingSuccess('meeting.conflict.room', {
+            verdict: result.verdict,
+            cansub: result.cansub,
+            message: result.message,
+            raw: result.raw,
+        });
+    },
+};
+const meetingConflictMember = {
+    name: 'meeting.conflict.member',
+    resource: 'conflict',
+    method: 'conflict.member',
+    action: 'meeting.conflict.member',
+    summary: '参会人员冲突检测（meetingChkMember）：verdict=rejected 禁止提交 / warn 仅提醒 / ok 无冲突',
+    capability: 'conflict',
+    risk: 'read',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: conflictProperties(),
+        required: ['beginDatetime', 'endDatetime', 'hrmids'],
+    },
+    handler: async (args, { host }) => {
+        const result = await runConflictCheck('meeting.conflict.member', '/api/meeting/detail/meetingChkMember', args, host);
+        return meetingSuccess('meeting.conflict.member', {
+            verdict: result.verdict,
+            cansub: result.cansub,
+            message: result.message,
+            raw: result.raw,
+        });
+    },
+};
+const meetingConflictRoomAttribute = {
+    name: 'meeting.conflict.roomAttribute',
+    resource: 'conflict',
+    method: 'conflict.roomAttribute',
+    action: 'meeting.conflict.roomAttribute',
+    summary: '会议室属性冲突检测（meetingChkRoomAttribute）：比对需求属性与会议室实际属性',
+    capability: 'conflict',
+    risk: 'read',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: conflictProperties(),
+        required: ['beginDatetime', 'endDatetime', 'address'],
+    },
+    handler: async (args, { host }) => {
+        const result = await runConflictCheck('meeting.conflict.roomAttribute', '/api/meeting/detail/meetingChkRoomAttribute', args, host);
+        return meetingSuccess('meeting.conflict.roomAttribute', {
+            verdict: result.verdict,
+            cansub: result.cansub,
+            message: result.message,
+            raw: result.raw,
+        });
+    },
+};
+export const meetingConflictOperations = [
+    meetingConflictRoom,
+    meetingConflictMember,
+    meetingConflictRoomAttribute,
+];