weaver-work-cli 0.1.2 → 0.1.5

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

@@ -0,0 +1,139 @@
+import { createHash } from 'node:crypto';
+import { meetingConfirmationError, meetingPartialError, meetingValidationError } from '../errors.js';
+import { meetingSuccess, SCHEMA_ID } from './types.js';
+import { assertMeetingExists, toIdString } from './shared.js';
+const CONTINUATION_TTL_SECONDS = 600;
+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';
+}
+/**
+ * 生成一组成对的「prepare（回查会议存在 + continuation）/ apply（真实写）」operation。
+ *
+ * 权限不在 CLI 侧判定：服务端 MeetingPermissionEvent 会按会议状态与会议基础设置判定，
+ * 不通过时返回本地化提示（"您没有取消权限！"/"您没有删除权限！"等），CLI 原样透传。
+ */
+function lifecyclePair(spec) {
+    const prepareName = `meeting.${spec.action}.prepare`;
+    const applyName = `meeting.${spec.action}.apply`;
+    const inputSchema = {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            id: { ...SCHEMA_ID, description: '会议 id（必填，长 id 用字符串）' },
+        },
+        required: ['id'],
+    };
+    const prepare = {
+        name: prepareName,
+        resource: spec.resource,
+        method: `${spec.action}.prepare`,
+        action: prepareName,
+        summary: spec.summaryPrepare,
+        capability: 'lifecycle',
+        risk: 'read-before-write',
+        requiresConfirmation: true,
+        inputSchema,
+        handler: async (args, env) => {
+            const id = toIdString(args.id, 'id');
+            await assertMeetingExists(id, env.host, prepareName);
+            const session = await env.host.getSession();
+            const token = await env.continuation.issue({
+                operation: applyName,
+                baseUrl: session.baseUrl,
+                profile: session.profile,
+                userId: session.userId,
+                payload: { id },
+                fingerprint: fingerprint({ id }),
+            }, CONTINUATION_TTL_SECONDS * 1000);
+            return meetingSuccess(prepareName, {
+                status: 'AWAITING_CONFIRMATION',
+                preview: { action: spec.action, id, body: spec.bodyOf(id), note: spec.note },
+                continuation: token,
+                expiresInSeconds: CONTINUATION_TTL_SECONDS,
+            });
+        },
+    };
+    const apply = {
+        name: applyName,
+        resource: spec.resource,
+        method: `${spec.action}.apply`,
+        action: applyName,
+        summary: spec.summaryApply,
+        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, description: '会议 id（必须与 prepare 时一致）' },
+            },
+            required: ['confirm', 'continuation', 'id'],
+        },
+        handler: async (args, env) => {
+            requireConfirm(args, applyName);
+            const lease = await verifyLease(args, applyName, env);
+            const id = toIdString(args.id, 'id');
+            if (lease.fingerprint !== fingerprint({ id })) {
+                throw meetingValidationError('target_changed', '会议 id 与 prepare 时的快照不一致，请重新执行 prepare');
+            }
+            let response;
+            try {
+                response = await env.host.request({
+                    method: 'POST',
+                    path: spec.path,
+                    operation: applyName,
+                    ...(spec.via === 'query' ? { query: spec.bodyOf(id) } : { body: spec.bodyOf(id) }),
+                });
+            }
+            catch (error) {
+                if (isNetworkError(error)) {
+                    throw meetingPartialError(`${spec.action} 请求发送后连接中断，结果不确定，禁止自动重试，请通过 meeting.list 或会议详情回查确认后再决定`, { attempted: { id } }, { stage: spec.action });
+                }
+                throw error;
+            }
+            return meetingSuccess(applyName, { status: 'COMPLETE', id, result: response });
+        },
+    };
+    return [prepare, apply];
+}
+export const meetingLifecycleOperations = [
+    ...lifecyclePair({
+        action: 'cancel',
+        resource: 'meeting',
+        summaryPrepare: '准备取消会议：回查会议存在性并生成确认预览，不写入（取消后会议进入取消状态）',
+        summaryApply: '提交取消会议（operateMeetingByType operateType=CANCEL，body 传参）；必须在用户明确确认后调用',
+        path: '/api/meeting/detail/operateMeetingByType',
+        via: 'body',
+        bodyOf: (id) => ({ operateType: 'CANCEL', id }),
+        note: '取消会议：会议进入取消状态，占用/回执/签到随之失效；不可逆，需用户明确确认。服务端会按会议状态判定取消权限，无权限时返回“您没有取消权限！”。',
+    }),
+    ...lifecyclePair({
+        action: 'delete',
+        resource: 'meeting',
+        summaryPrepare: '准备删除会议记录：回查会议存在性并生成确认预览，不写入（彻底删除）',
+        summaryApply: '提交删除会议记录（deleteMeetingDetail，源码为表单绑定，参数走 query）；必须在用户明确确认后调用',
+        path: '/api/meeting/detail/deleteMeetingDetail',
+        via: 'query',
+        bodyOf: (id) => ({ id }),
+        note: '删除是彻底移除会议记录（区别于取消）；不可逆，需用户明确确认。服务端会按会议状态判定删除权限，无权限时返回“您没有删除权限！”。',
+    }),
+];

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

@@ -0,0 +1,73 @@
+import { meetingSuccess, SCHEMA_DATE } from './types.js';
+import { assertDate, extractRows } from './shared.js';
+// ---------------------------------------------------------------------------
+// 会议列表（getMeetingList；body 过滤实测不生效，客户端过滤）
+// ---------------------------------------------------------------------------
+/**
+ * 与目标日期有重叠：begin < 当天 23:59:59 且 end > 当天 00:00:00。
+ * beginDatetime/endDatetime 格式 yyyy-MM-dd HH:mm（缺失视为不过滤该边界）。
+ */
+function overlapsDate(beginDatetime, endDatetime, date) {
+    if (typeof beginDatetime !== 'string' && typeof endDatetime !== 'string')
+        return true;
+    const dayStart = `${date} 00:00`;
+    const dayEnd = `${date} 23:59`;
+    const begin = typeof beginDatetime === 'string' ? beginDatetime : '';
+    const end = typeof endDatetime === 'string' ? endDatetime : '';
+    if (begin && end)
+        return begin.slice(0, 16) <= dayEnd && end.slice(0, 16) >= dayStart;
+    if (begin)
+        return begin.slice(0, 10) === date;
+    if (end)
+        return end.slice(0, 10) === date;
+    return true;
+}
+const meetingList = {
+    name: 'meeting.list',
+    resource: 'meeting',
+    method: 'list',
+    action: 'meeting.list',
+    summary: '查询当前用户可见的会议列表（getMeetingList 空 body 拉全量 + 客户端按日期过滤）',
+    capability: 'meeting',
+    risk: 'read',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            filterDate: { ...SCHEMA_DATE, description: '客户端过滤：仅返回与该日期重叠的会议（如今天）' },
+            pageSize: { type: 'integer', description: '自动翻页每页条数（默认 50，上限 200）' },
+            returnLimit: { type: 'integer', description: '返回条数上限（过滤后截取）' },
+        },
+    },
+    handler: async (args, { host }) => {
+        // 实测（standalone skill）：getMeetingList body 传日期/参会人过滤不生效，禁止现场试 body。
+        // 但分页字段生效（实测默认仅返回 10 条）→ 自动翻页拉全量，再做客户端过滤。
+        const pageSize = typeof args.pageSize === 'number' && args.pageSize > 0 ? Math.min(args.pageSize, 200) : 50;
+        const maxPages = 10;
+        const allRows = [];
+        let total;
+        for (let current = 1; current <= maxPages; current++) {
+            const response = await host.request({
+                method: 'POST',
+                path: '/api/meeting/search/getMeetingList',
+                operation: 'meeting.list',
+                body: { current, pageSize },
+            });
+            const page = extractRows(response);
+            total = page.total ?? total;
+            allRows.push(...page.rows);
+            if (page.rows.length === 0 || (total !== undefined && allRows.length >= total))
+                break;
+        }
+        let filtered = allRows;
+        if (args.filterDate !== undefined) {
+            const date = assertDate(args.filterDate, 'filterDate');
+            filtered = allRows.filter((row) => overlapsDate(row?.beginDatetime, row?.endDatetime, date));
+        }
+        if (typeof args.returnLimit === 'number' && args.returnLimit > 0) {
+            filtered = filtered.slice(0, args.returnLimit);
+        }
+        return meetingSuccess('meeting.list', { total: filtered.length, sourceTotal: total, meetings: filtered });
+    },
+};
+export const meetingListOperations = [meetingList];

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

@@ -0,0 +1,195 @@
+import { createHash } from 'node:crypto';
+import { meetingPartialError, meetingValidationError } from '../errors.js';
+import { meetingSuccess, SCHEMA_ID } from './types.js';
+import { extractRows, toIdString } from './shared.js';
+const CONTINUATION_TTL_SECONDS = 600;
+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 meetingValidationError('confirmation_required', `${action} 需要用户明确确认（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';
+}
+// ---------------------------------------------------------------------------
+// 回执列表（getMeetingReceiptMemberInfoList；isMobile 必传否则 NPE→500）
+// ---------------------------------------------------------------------------
+const meetingReceiptList = {
+    name: 'meeting.receipt.list',
+    resource: 'receipt',
+    method: 'receipt.list',
+    action: 'meeting.receipt.list',
+    summary: '查询会议回执列表（getMeetingReceiptMemberInfoList；isMobile 缺省 false，缺失会导致后端 NPE）',
+    capability: 'receipt',
+    risk: 'read',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            mtId: { ...SCHEMA_ID, description: '会议 id（必填）' },
+            memberType: { type: 'integer', enum: [1, 2, 3], description: '人员类型：1=人员 2=客户 3=其他（默认 1）' },
+            isMobile: { type: 'boolean', description: '移动端标记（默认 false）' },
+            current: { type: 'integer' },
+            pageSize: { type: 'integer' },
+        },
+        required: ['mtId'],
+    },
+    handler: async (args, { host }) => {
+        const body = {
+            mtId: toIdString(args.mtId, 'mtId'),
+            isMobile: args.isMobile === undefined ? false : args.isMobile === true,
+            current: typeof args.current === 'number' && args.current > 0 ? args.current : 1,
+            pageSize: typeof args.pageSize === 'number' && args.pageSize > 0 ? args.pageSize : 50,
+        };
+        if (args.memberType !== undefined)
+            body.memberType = args.memberType;
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/meeting/receiptMember/getMeetingReceiptMemberInfoList',
+            operation: 'meeting.receipt.list',
+            body,
+        });
+        const { rows, total } = extractRows(response);
+        return meetingSuccess('meeting.receipt.list', { total, receipts: rows });
+    },
+};
+// ---------------------------------------------------------------------------
+// 更新回执（operateMeetingReceiptMember；必须传回执记录 id 而非 memberId）
+// ---------------------------------------------------------------------------
+function normalizeReceiptUpdate(args) {
+    const mtId = toIdString(args.mtId, 'mtId');
+    const memberId = toIdString(args.memberId, 'memberId');
+    const attendStatus = args.attendStatus;
+    if (attendStatus !== 0 && attendStatus !== 1 && attendStatus !== 2) {
+        throw meetingValidationError('attendStatus_invalid', 'attendStatus 仅允许 0=未填写 1=参加 2=不参加（回执"否"传 2）');
+    }
+    return {
+        mtId,
+        memberId,
+        attendStatus,
+        ...(args.remark !== undefined ? { remark: String(args.remark) } : {}),
+    };
+}
+/** 回查回执列表，按 memberId 定位回执记录 id（建会时后端自动生成，每参会人一条）。 */
+async function locateReceiptId(mtId, memberId, env) {
+    const response = await env.host.request({
+        method: 'POST',
+        path: '/api/meeting/receiptMember/getMeetingReceiptMemberInfoList',
+        operation: 'meeting.receipt.update.prepare',
+        body: { mtId, memberType: 1, isMobile: false, current: 1, pageSize: 100 },
+    });
+    const { rows } = extractRows(response);
+    const hit = rows.find((row) => String(row?.memberId) === memberId);
+    if (!hit || hit.id === undefined) {
+        throw meetingValidationError('receipt_not_found', `未找到该参会人（memberId=${memberId}）的回执记录，请先通过 meeting.receipt.list 核对`);
+    }
+    return String(hit.id);
+}
+const meetingReceiptUpdatePrepare = {
+    name: 'meeting.receipt.update.prepare',
+    resource: 'receipt',
+    method: 'receipt.update.prepare',
+    action: 'meeting.receipt.update.prepare',
+    summary: '准备更新回执：先回查回执记录 id（更新必须传回执主键而非 memberId），生成确认预览，不写入',
+    capability: 'receipt',
+    risk: 'read-before-write',
+    requiresConfirmation: true,
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            mtId: { ...SCHEMA_ID, description: '会议 id' },
+            memberId: { ...SCHEMA_ID, description: '参会人员 id（用于定位回执记录）' },
+            attendStatus: { type: 'integer', enum: [0, 1, 2], description: '0=未填写 1=参加 2=不参加' },
+            remark: { type: 'string', description: '备注（如"请假"）' },
+        },
+        required: ['mtId', 'memberId', 'attendStatus'],
+    },
+    handler: async (args, env) => {
+        const normalized = normalizeReceiptUpdate(args);
+        const receiptId = await locateReceiptId(String(normalized.mtId), String(normalized.memberId), env);
+        const session = await env.host.getSession();
+        const payload = { id: receiptId, ...normalized };
+        const token = await env.continuation.issue({
+            operation: 'meeting.receipt.update.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            payload,
+            fingerprint: fingerprint(normalized),
+        }, CONTINUATION_TTL_SECONDS * 1000);
+        return meetingSuccess('meeting.receipt.update.prepare', {
+            status: 'AWAITING_CONFIRMATION',
+            preview: payload,
+            continuation: token,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
+        });
+    },
+};
+const meetingReceiptUpdateApply = {
+    name: 'meeting.receipt.update.apply',
+    resource: 'receipt',
+    method: 'receipt.update.apply',
+    action: 'meeting.receipt.update.apply',
+    summary: '提交回执更新（operateMeetingReceiptMember）；必须在用户明确确认后调用，要求 prepare 返回的 continuation',
+    capability: 'receipt',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            confirm: { const: true },
+            continuation: { type: 'string', minLength: 1 },
+            mtId: SCHEMA_ID,
+            memberId: SCHEMA_ID,
+            attendStatus: { type: 'integer', enum: [0, 1, 2] },
+            remark: { type: 'string' },
+        },
+        required: ['confirm', 'continuation', 'mtId', 'memberId', 'attendStatus'],
+    },
+    handler: async (args, env) => {
+        requireConfirm(args, 'meeting.receipt.update.apply');
+        const lease = await verifyLease(args, 'meeting.receipt.update.apply', env);
+        const normalized = normalizeReceiptUpdate(args);
+        if (lease.fingerprint !== fingerprint(normalized)) {
+            throw meetingValidationError('target_changed', '回执内容与 prepare 时的快照不一致，请重新执行 prepare');
+        }
+        const payload = lease.payload;
+        let response;
+        try {
+            response = await env.host.request({
+                method: 'POST',
+                path: '/api/meeting/receiptMember/operateMeetingReceiptMember',
+                operation: 'meeting.receipt.update.apply',
+                body: payload,
+            });
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw meetingPartialError('回执更新请求发送后连接中断，是否已生效不确定，禁止自动重试，请通过 meeting.receipt.list 复核', { attempted: { mtId: normalized.mtId, memberId: normalized.memberId } }, { stage: 'receipt-update' });
+            }
+            throw error;
+        }
+        return meetingSuccess('meeting.receipt.update.apply', {
+            status: 'COMPLETE',
+            result: response,
+        });
+    },
+};
+export const meetingReceiptOperations = [
+    meetingReceiptList,
+    meetingReceiptUpdatePrepare,
+    meetingReceiptUpdateApply,
+];

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

@@ -0,0 +1,47 @@
+import { meetingValidationError } from '../errors.js';
+import { meetingEnvOperations } from './env.js';
+import { meetingListOperations } from './meetings.js';
+import { meetingRoomOperations } from './rooms.js';
+import { meetingCatalogOperations } from './catalogs.js';
+import { meetingConflictOperations } from './conflicts.js';
+import { meetingChangeOperations } from './change.js';
+import { meetingCreateOperations } from './create.js';
+import { meetingLifecycleOperations } from './lifecycle.js';
+import { meetingReceiptOperations } from './receipts.js';
+import { meetingSignOperations } from './signs.js';
+function buildRegistry() {
+    const registry = new Map();
+    const definitions = [
+        ...meetingEnvOperations,
+        ...meetingListOperations,
+        ...meetingRoomOperations,
+        ...meetingCatalogOperations,
+        ...meetingConflictOperations,
+        ...meetingCreateOperations,
+        ...meetingLifecycleOperations,
+        ...meetingChangeOperations,
+        ...meetingReceiptOperations,
+        ...meetingSignOperations,
+    ];
+    for (const definition of definitions) {
+        if (registry.has(definition.name)) {
+            throw new Error(`duplicate meeting operation: ${definition.name}`);
+        }
+        registry.set(definition.name, definition);
+    }
+    return registry;
+}
+const meetingOperationRegistry = buildRegistry();
+export function meetingOperationDefinitions() {
+    return [...meetingOperationRegistry.values()];
+}
+export function getMeetingOperation(operation) {
+    const definition = meetingOperationRegistry.get(operation);
+    if (!definition) {
+        throw meetingValidationError('operation_unknown', `会议模块不支持操作：${operation}`);
+    }
+    return definition;
+}
+export function hasMeetingOperation(operation) {
+    return meetingOperationRegistry.has(operation);
+}

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

@@ -0,0 +1,132 @@
+import { meetingValidationError } from '../errors.js';
+import { meetingSuccess, SCHEMA_DATETIME_MINUTE, SCHEMA_ID } from './types.js';
+import { assertDateTimeMinute, extractRows, toIdString } from './shared.js';
+/** browser 组件通用 body 骨架（mt_room/mt_type 共用）。 */
+function browserBody(options) {
+    const formDatas = {};
+    if (typeof options.nameFilter === 'string' && options.nameFilter.trim()) {
+        formDatas.name = [{ nameCondition: 'in', name: options.nameFilter.trim() }];
+    }
+    return {
+        browserMultiple: options.multiple ?? true,
+        current: typeof options.current === 'number' && options.current > 0 ? options.current : 1,
+        pageSize: typeof options.pageSize === 'number' && options.pageSize > 0 ? options.pageSize : 100,
+        ...options.extra,
+        formDatas,
+        quickSearchDatas: {},
+        type: 'and',
+    };
+}
+/** disabled 归一化：接口可能返回 boolean 或 "true"/"false" 字符串。 */
+function isDisabled(value) {
+    return value === true || String(value).toLowerCase() === 'true';
+}
+// ---------------------------------------------------------------------------
+// 会议室列表（mt_room，权限友好；带时间范围即返回占用判断 disabled）
+// ---------------------------------------------------------------------------
+const meetingRoomList = {
+    name: 'meeting.room.list',
+    resource: 'room',
+    method: 'room.list',
+    action: 'meeting.room.list',
+    summary: '查询会议室列表（mt_room browser 组件；带 beginDate/endDate 时返回 disabled 占用判断，禁用 getMeetingRoomInfoList）',
+    capability: 'room',
+    risk: 'read',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            beginDate: { ...SCHEMA_DATETIME_MINUTE, description: '占用判断起始 yyyy-MM-dd HH:mm；与 endDate 成对提供' },
+            endDate: { ...SCHEMA_DATETIME_MINUTE, description: '占用判断结束 yyyy-MM-dd HH:mm；与 beginDate 成对提供' },
+            name: { type: 'string', description: '按会议室名称过滤（标准版不支持按地点查询）' },
+            totalMember: { type: 'string', description: '参会人数（默认 "0"）' },
+            current: { type: 'integer', description: '页码，默认 1' },
+            pageSize: { type: 'integer', description: '页大小，默认 100' },
+            onlyAvailable: { type: 'boolean', description: '仅返回 disabled!=true 的空闲会议室' },
+        },
+    },
+    handler: async (args, { host }) => {
+        if ((args.beginDate === undefined) !== (args.endDate === undefined)) {
+            throw meetingValidationError('period_incomplete', 'beginDate 与 endDate 必须成对提供（用于占用判断）');
+        }
+        const extra = {};
+        if (args.beginDate !== undefined) {
+            extra.beginDate = assertDateTimeMinute(args.beginDate, 'beginDate');
+            extra.endDate = assertDateTimeMinute(args.endDate, 'endDate');
+        }
+        if (args.totalMember !== undefined)
+            extra.totalMember = String(args.totalMember);
+        const body = browserBody({
+            current: args.current,
+            pageSize: args.pageSize,
+            nameFilter: args.name,
+            multiple: true,
+            extra,
+        });
+        const response = await host.request({
+            method: 'POST',
+            path: '/api/meeting/common/browser/data/mt_room',
+            operation: 'meeting.room.list',
+            body,
+        });
+        const { rows, total } = extractRows(response);
+        const rooms = rows.map((row) => ({ ...row, disabled: isDisabled(row?.disabled) }));
+        const available = rooms.filter((room) => !room.disabled);
+        return meetingSuccess('meeting.room.list', {
+            total,
+            ...(args.onlyAvailable === true ? { rooms: available } : { rooms, availableRooms: available }),
+        }, {
+            warnings: args.beginDate !== undefined
+                ? ['disabled=true 表示该会议室在时间段内已被占用；预约推荐必须排除']
+                : [],
+        });
+    },
+};
+// ---------------------------------------------------------------------------
+// 会议室占用视图（getRoomUsageData；无分页，返回全部占用记录）
+// ---------------------------------------------------------------------------
+const meetingRoomUsage = {
+    name: 'meeting.room.usage',
+    resource: 'room',
+    method: 'room.usage',
+    action: 'meeting.room.usage',
+    summary: '查询会议室占用视图（getRoomUsageData）：bywhat 2=月 3=周 4=日，可按 roomid 限定',
+    capability: 'room',
+    risk: 'read',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            roomid: { ...SCHEMA_ID, description: '会议室 id（限定单个会议室）' },
+            roomname: { type: 'string', description: '会议室名称筛选' },
+            bywhat: { type: 'integer', enum: [2, 3, 4], description: '查询类型：2=月 3=周 4=日' },
+            currentdate: { type: 'string', description: '查询日期 yyyy-MM-dd' },
+            orgId: SCHEMA_ID,
+        },
+    },
+    handler: async (args, { host }) => {
+        const query = {};
+        if (args.roomid !== undefined)
+            query.roomid = toIdString(args.roomid, 'roomid');
+        if (args.roomname !== undefined)
+            query.roomname = args.roomname;
+        if (args.bywhat !== undefined)
+            query.bywhat = args.bywhat;
+        if (args.currentdate !== undefined)
+            query.currentdate = args.currentdate;
+        if (args.orgId !== undefined)
+            query.orgId = toIdString(args.orgId, 'orgId');
+        const response = await host.request({
+            method: 'GET',
+            path: '/api/meeting/roomUsage/getRoomUsageData',
+            operation: 'meeting.room.usage',
+            query,
+        });
+        const { rows, total } = extractRows(response);
+        return meetingSuccess('meeting.room.usage', { total, usages: rows });
+    },
+};
+export const meetingRoomOperations = [
+    meetingRoomList,
+    meetingRoomUsage,
+];