weaver-work-cli 0.1.2 → 0.1.5

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

@@ -0,0 +1,349 @@
+import { createHash } from 'node:crypto';
+import { meetingConflictError, meetingConfirmationError, meetingPartialError, meetingValidationError } from '../errors.js';
+import { meetingSuccess, SCHEMA_DATETIME_MINUTE, SCHEMA_ID } from './types.js';
+import { assertDateTimeMinute, extractConflict, toIdCsv, 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';
+}
+// ---------------------------------------------------------------------------
+// MeetingDetailBean 归一化（纯函数，prepare/apply 共用，保证 fingerprint 一致）
+// ---------------------------------------------------------------------------
+const REPEAT_TYPE_LABELS = { 1: '天', 2: '周', 4: '月', 5: '年', 6: '自定义周期' };
+const BYDAY_LABELS = {
+    MO: '周一', TU: '周二', WE: '周三', TH: '周四', FR: '周五', SA: '周六', SU: '周日',
+};
+/** 周期概述 repeatDesc：后端不生成，按前端 calculateRepeatDesc 规则拼接。 */
+function buildRepeatDesc(args) {
+    const interval = typeof args.interval === 'number' && args.interval > 0 ? args.interval : 1;
+    const frequent = typeof args.frequent === 'number' ? args.frequent : 1;
+    const freqLabel = frequent === 1 ? '天' : frequent === 2 ? '周' : frequent === 3 ? '月' : '年';
+    const cadence = interval === 1 ? `每 1 ${freqLabel}` : `每 ${interval} ${freqLabel}`;
+    const byDay = typeof args.byDay === 'string' && args.byDay.trim()
+        ? args.byDay.split(',').map((item) => BYDAY_LABELS[item.trim().toUpperCase()] || item.trim()).join(' ')
+        : '';
+    const finishLabel = args.finishAt === 1 && args.count !== undefined
+        ? `重复${args.count}次`
+        : args.until !== undefined ? `截止${args.until}` : '';
+    return [cadence, byDay, finishLabel, '非工作日正常召开'].filter(Boolean).join(' ');
+}
+export function normalizeCreateInput(args, currentUserId) {
+    const name = typeof args.name === 'string' ? args.name.trim() : '';
+    if (!name)
+        throw meetingValidationError('name_required', 'name（会议名称）必填');
+    const beginDatetime = assertDateTimeMinute(args.beginDatetime, 'beginDatetime');
+    const endDatetime = assertDateTimeMinute(args.endDatetime, 'endDatetime');
+    const body = {
+        operateType: 'SUBMIT',
+        id: '',
+        name,
+        beginDatetime,
+        endDatetime,
+        caller: toIdString(args.caller ?? currentUserId, 'caller'),
+        contacter: toIdString(args.contacter ?? currentUserId, 'contacter'),
+    };
+    if (args.address !== undefined)
+        body.address = toIdString(args.address, 'address');
+    if (args.customizeAddress !== undefined)
+        body.customizeAddress = String(args.customizeAddress);
+    if (args.mtType !== undefined)
+        body.mtType = toIdString(args.mtType, 'mtType');
+    const hrmMembers = toIdCsv(args.hrmMembers, 'hrmMembers');
+    if (hrmMembers !== undefined)
+        body.hrmMembers = hrmMembers;
+    const orgMembers = toIdCsv(args.orgMembers, 'orgMembers');
+    if (orgMembers !== undefined)
+        body.orgMembers = orgMembers;
+    if (args.otherMembers !== undefined)
+        body.otherMembers = String(args.otherMembers);
+    const crmMembers = toIdCsv(args.crmMembers, 'crmMembers');
+    if (crmMembers !== undefined)
+        body.crmMembers = crmMembers;
+    if (args.totalMember !== undefined)
+        body.totalMember = args.totalMember;
+    // 周期字段（有任一即视为周期会议）
+    const repeatKeys = ['repeatType', 'frequent', 'interval', 'finishAt', 'count', 'until', 'byDay', 'byMonthDay', 'byMonth', 'byWeekNo', 'byDateType'];
+    const hasRepeat = repeatKeys.some((key) => args[key] !== undefined);
+    if (hasRepeat) {
+        if (args.repeatType === undefined) {
+            throw meetingValidationError('repeatType_required', '周期会议必须提供 repeatType（1=每天 2=每周 4=每月 5=每年 6=自定义）');
+        }
+        body.repeatType = args.repeatType;
+        if (args.frequent !== undefined)
+            body.frequent = args.frequent;
+        if (args.interval !== undefined)
+            body.interval = args.interval;
+        // finishAt 周期会议必填（当前租户 options 仅 1=次数 / 2=日期，禁止 0=永不）
+        if (args.finishAt === undefined) {
+            throw meetingValidationError('finishAt_required', '周期会议必须提供 finishAt（1=重复次数 2=结束日期）；禁止传 0（永不）');
+        }
+        if (args.finishAt !== 1 && args.finishAt !== 2) {
+            throw meetingValidationError('finishAt_invalid', 'finishAt 仅允许 1=重复次数 或 2=结束日期');
+        }
+        body.finishAt = args.finishAt;
+        if (args.finishAt === 1 && args.count === undefined) {
+            throw meetingValidationError('count_required', 'finishAt=1（按次数）时必须提供 count');
+        }
+        if (args.finishAt === 2 && args.until === undefined) {
+            throw meetingValidationError('until_required', 'finishAt=2（按日期）时必须提供 until（yyyy-MM-dd）');
+        }
+        if (args.count !== undefined)
+            body.count = args.count;
+        if (args.until !== undefined) {
+            if (typeof args.until !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(args.until)) {
+                throw meetingValidationError('until_invalid', 'until 必须是 yyyy-MM-dd 格式');
+            }
+            body.until = args.until;
+        }
+        if (args.byDay !== undefined)
+            body.byDay = String(args.byDay);
+        if (args.byMonthDay !== undefined)
+            body.byMonthDay = String(args.byMonthDay);
+        if (args.byMonth !== undefined)
+            body.byMonth = String(args.byMonth);
+        if (args.byWeekNo !== undefined)
+            body.byWeekNo = String(args.byWeekNo);
+        if (args.byDateType !== undefined)
+            body.byDateType = args.byDateType;
+        // repeatDesc 后端不生成：用户未提供时按规则自动拼接
+        body.repeatDesc = typeof args.repeatDesc === 'string' && args.repeatDesc.trim()
+            ? args.repeatDesc.trim()
+            : buildRepeatDesc(args);
+    }
+    return body;
+}
+// ---------------------------------------------------------------------------
+// prepare 前置检查：建会路径（onlyFlowCreate/周期工作流）与强制冲突检测
+// ---------------------------------------------------------------------------
+async function assertCreatePathAllowed(args, env) {
+    const isRepeat = ['repeatType', 'finishAt', 'byDay', 'until', 'count'].some((key) => args[key] !== undefined);
+    const response = await env.host.request({
+        method: 'GET',
+        path: '/api/meeting/detail/getCalendarBaseData',
+        operation: 'meeting.create.prepare',
+    });
+    const base = response?.data?.createBaseData ?? {};
+    const repeatWorkflowIds = typeof base.repeatWorkFlowBaseIds === 'string' ? base.repeatWorkFlowBaseIds.trim() : '';
+    if (isRepeat && repeatWorkflowIds) {
+        throw meetingConflictError('conflict_rejected', '该租户为周期会议配置了工作流（repeatWorkFlowBaseIds 非空），周期会议必须走流程建会；CLI v1 未集成工作流发起，请通过工作流流程创建', { repeatWorkFlowBaseIds: repeatWorkflowIds });
+    }
+    if (!isRepeat && Number(base.onlyFlowCreate) === 1) {
+        throw meetingConflictError('conflict_rejected', '该租户 onlyFlowCreate=1：会议只能通过流程创建；CLI v1 未集成工作流发起，请通过工作流流程创建', { workFlowBaseIds: base.workFlowBaseIds ?? '' });
+    }
+}
+/** 强制冲突检测：接口失败视为冲突（拒绝建会），cansub=false 拒绝提交。 */
+async function runMandatoryConflictChecks(body, args, env) {
+    const warnings = [];
+    const beginDatetime = String(body.beginDatetime);
+    const endDatetime = String(body.endDatetime);
+    const common = {
+        beginDatetime,
+        endDatetime,
+        ...(args.mtId !== undefined ? { mtId: args.mtId } : {}),
+    };
+    if (body.address !== undefined) {
+        let roomConflict;
+        try {
+            const response = await env.host.request({
+                method: 'POST',
+                path: '/api/meeting/detail/meetingChkRoom',
+                operation: 'meeting.create.prepare',
+                body: { ...common, address: body.address, ...(body.frequent !== undefined ? { frequent: body.frequent } : {}), ...(body.repeatRuleEx !== undefined ? { repeatRuleEx: body.repeatRuleEx } : {}) },
+            });
+            roomConflict = extractConflict(response);
+        }
+        catch (error) {
+            throw meetingConflictError('conflict_check_failed', `会议室冲突检测失败（视为冲突，拒绝建会）：${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (roomConflict.cansub === false) {
+            throw meetingConflictError('conflict_rejected', `会议室冲突，禁止提交：${roomConflict.message || '该时间段会议室已被占用'}`);
+        }
+        if (roomConflict.message)
+            warnings.push(`会议室冲突提醒（可提交）：${roomConflict.message}`);
+    }
+    if (body.hrmMembers !== undefined) {
+        let memberConflict;
+        try {
+            const response = await env.host.request({
+                method: 'POST',
+                path: '/api/meeting/detail/meetingChkMember',
+                operation: 'meeting.create.prepare',
+                body: { ...common, hrmids: body.hrmMembers, ...(body.totalMember !== undefined ? { totalmember: body.totalMember } : {}) },
+            });
+            memberConflict = extractConflict(response);
+        }
+        catch (error) {
+            throw meetingConflictError('conflict_check_failed', `参会人员冲突检测失败（视为冲突，拒绝建会）：${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (memberConflict.cansub === false) {
+            throw meetingConflictError('conflict_rejected', `参会人员冲突，禁止提交：${memberConflict.message || '参会人在该时间段已有其他会议'}`);
+        }
+        if (memberConflict.message)
+            warnings.push(`参会人员冲突提醒（可提交）：${memberConflict.message}`);
+    }
+    return warnings;
+}
+// ---------------------------------------------------------------------------
+// 预约会议（标准版 operateMeetingByType SUBMIT，后端自动生成占用/回执/签到）
+// ---------------------------------------------------------------------------
+const meetingCreatePrepare = {
+    name: 'meeting.create.prepare',
+    resource: 'meeting',
+    method: 'create.prepare',
+    action: 'meeting.create.prepare',
+    summary: '准备预约会议：归一化 MeetingDetailBean、执行建会路径检查（onlyFlowCreate/周期工作流）与强制冲突检测（cansub=false 拒绝），生成确认预览，不写入',
+    capability: 'meeting',
+    risk: 'read-before-write',
+    requiresConfirmation: true,
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            name: { type: 'string', minLength: 1, description: '会议名称（必填）' },
+            beginDatetime: { ...SCHEMA_DATETIME_MINUTE, description: '开始时间（必填）' },
+            endDatetime: { ...SCHEMA_DATETIME_MINUTE, description: '结束时间（必填）' },
+            address: { ...SCHEMA_ID, description: '会议室 id（长 id 用字符串）' },
+            customizeAddress: { type: 'string', description: '自定义地点' },
+            mtType: { ...SCHEMA_ID, description: '会议类型 id（先通过 meeting.type.list 获取）' },
+            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，缺省当前用户（必须显式传，后端无兜底）' },
+            repeatType: { type: 'integer', enum: [1, 2, 4, 5, 6], description: '周期类型：1=每天 2=每周 4=每月 5=每年 6=自定义' },
+            frequent: { type: 'integer', enum: [1, 2, 3, 4], description: '重复频率：1=天 2=周 3=月 4=年' },
+            interval: { type: 'integer', description: '重复间隔（默认 1）' },
+            finishAt: { type: 'integer', enum: [1, 2], description: '结束重复于：1=次数 2=日期（周期会议必填，禁止 0）' },
+            count: { type: 'integer', description: '重复次数（finishAt=1 时必填）' },
+            until: { type: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2}$', description: '重复结束日期（finishAt=2 时必填）' },
+            byDay: { type: 'string', description: '一周某天 MO,TU,WE,TH,FR,SA,SU（每周重复时必填）' },
+            byMonthDay: { type: 'string', description: '一月的第几天（1-31 或 -31~-1）' },
+            byMonth: { type: 'string', description: '一年中的第几个月（1-12）' },
+            byWeekNo: { type: 'string', description: '一年的第几周（1-53）' },
+            byDateType: { type: 'integer', enum: [0, 1], description: '按月/年重复：0=按日期 1=按星期' },
+            repeatDesc: { type: 'string', description: '周期概述；缺省按规则自动拼接' },
+            serviceItems: { type: 'string', description: '会议服务需求（提供时触发会议室属性检测）' },
+        },
+        required: ['name', 'beginDatetime', 'endDatetime'],
+    },
+    handler: async (args, env) => {
+        const session = await env.host.getSession();
+        const body = normalizeCreateInput(args, session.userId);
+        // 建会路径检查（周期工作流 / onlyFlowCreate）
+        await assertCreatePathAllowed(args, env);
+        // 强制冲突检测（cansub=false / 检测失败 → 拒绝）
+        const warnings = await runMandatoryConflictChecks(body, args, env);
+        const token = await env.continuation.issue({
+            operation: 'meeting.create.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            payload: body,
+            fingerprint: fingerprint(body),
+        }, CONTINUATION_TTL_SECONDS * 1000);
+        return meetingSuccess('meeting.create.prepare', {
+            status: 'AWAITING_CONFIRMATION',
+            preview: body,
+            continuation: token,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
+        }, { warnings });
+    },
+};
+const meetingCreateApply = {
+    name: 'meeting.create.apply',
+    resource: 'meeting',
+    method: 'create.apply',
+    action: 'meeting.create.apply',
+    summary: '提交预约会议（operateMeetingByType SUBMIT + id 留空）；必须在用户明确确认后调用，要求 prepare 返回的 continuation',
+    capability: 'meeting',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            confirm: { const: true },
+            continuation: { type: 'string', minLength: 1 },
+            name: { type: 'string', minLength: 1 },
+            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,
+            repeatType: { type: 'integer', enum: [1, 2, 4, 5, 6] },
+            frequent: { type: 'integer', enum: [1, 2, 3, 4] },
+            interval: { type: 'integer' },
+            finishAt: { type: 'integer', enum: [1, 2] },
+            count: { type: 'integer' },
+            until: { type: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2}$' },
+            byDay: { type: 'string' },
+            byMonthDay: { type: 'string' },
+            byMonth: { type: 'string' },
+            byWeekNo: { type: 'string' },
+            byDateType: { type: 'integer', enum: [0, 1] },
+            repeatDesc: { type: 'string' },
+            serviceItems: { type: 'string' },
+        },
+        required: ['confirm', 'continuation', 'name', 'beginDatetime', 'endDatetime'],
+    },
+    handler: async (args, env) => {
+        requireConfirm(args, 'meeting.create.apply');
+        const lease = await verifyLease(args, 'meeting.create.apply', env);
+        const session = await env.host.getSession();
+        const body = normalizeCreateInput(args, session.userId);
+        if (lease.fingerprint !== fingerprint(body)) {
+            throw meetingValidationError('target_changed', '会议内容与 prepare 时的快照不一致，请重新执行 prepare');
+        }
+        let response;
+        try {
+            response = await env.host.request({
+                method: 'POST',
+                path: '/api/meeting/detail/operateMeetingByType',
+                operation: 'meeting.create.apply',
+                body,
+            });
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw meetingPartialError('建会请求发送后连接中断，会议是否已创建不确定，禁止自动重试，请通过 meeting.list 复核后再决定', { attempted: { name: body.name, beginDatetime: body.beginDatetime } }, { stage: 'create' });
+            }
+            throw error;
+        }
+        const value = response;
+        const meetingId = value?.id ?? value?.data?.id ?? value?.data?.meetingId ?? null;
+        return meetingSuccess('meeting.create.apply', {
+            status: 'COMPLETE',
+            meetingId: meetingId === null ? undefined : String(meetingId),
+            result: response,
+        });
+    },
+};
+export const meetingCreateOperations = [
+    meetingCreatePrepare,
+    meetingCreateApply,
+];

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

@@ -0,0 +1,191 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { meetingValidationError } from '../errors.js';
+import { meetingSuccess, SCHEMA_ID } from './types.js';
+// ---------------------------------------------------------------------------
+// 环境模式探测（EB 版 / 标准版）——按 baseUrl 固化缓存，对齐 standalone 行为
+// ---------------------------------------------------------------------------
+const EB_SMOKE_PATH = '/api/ebuilder/form/formdata/v2/getFormDataList/query_meeting_baseset';
+const STD_CALENDAR_PATH = '/api/meeting/detail/getCalendarBaseData';
+function stateRoot(ctx) {
+    const configured = ctx?.config?.path();
+    if (configured)
+        return resolve(configured, '..');
+    return process.env.WEAVER_WORK_CLI_HOME || process.env.WORK_CLI_HOME || resolve(homedir(), '.weaver-work-cli');
+}
+function cacheFile(ctx) {
+    return resolve(stateRoot(ctx), 'meeting', 'env-mode.json');
+}
+function emptyCache() {
+    return { schemaVersion: 1, environments: {} };
+}
+async function readCache(ctx) {
+    const file = cacheFile(ctx);
+    if (!existsSync(file))
+        return emptyCache();
+    try {
+        const parsed = JSON.parse(await readFile(file, 'utf8'));
+        if (!parsed || typeof parsed !== 'object' || !parsed.environments)
+            return emptyCache();
+        return parsed;
+    }
+    catch {
+        return emptyCache();
+    }
+}
+/** 原子性要求低（诊断缓存），写失败不阻断业务：返回 warning 文本。 */
+async function writeCache(ctx, baseUrl, mode, smokePath) {
+    try {
+        const file = cacheFile(ctx);
+        await mkdir(resolve(file, '..'), { recursive: true });
+        const cache = await readCache(ctx);
+        cache.environments[baseUrl] = { mode, smokePath, detectedAt: new Date().toISOString() };
+        await writeFile(file, JSON.stringify(cache, null, 2), 'utf8');
+        return undefined;
+    }
+    catch (error) {
+        return `环境模式缓存写入失败（不影响本次结果，下次会重新冒烟）：${error instanceof Error ? error.message : String(error)}`;
+    }
+}
+const meetingEnvDetect = {
+    name: 'meeting.env.detect',
+    resource: 'env',
+    method: 'detect',
+    action: 'meeting.env.detect',
+    summary: '探测当前环境会议模式：默认按 baseUrl 读缓存；未命中或 refresh=true 时 EB 版冒烟优先、失败回退标准版，成功后固化缓存',
+    capability: 'env',
+    risk: 'read',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            refresh: { type: 'boolean', description: 'true=忽略缓存强制重新冒烟并更新缓存（用户说"重新探测/刷新模式"时使用）' },
+            profileId: SCHEMA_ID,
+        },
+    },
+    handler: async (args, { host, ctx }) => {
+        const session = await host.getSession();
+        // ① 默认先读缓存（按 baseUrl 固化）；refresh=true 才强制重新冒烟。
+        if (args.refresh !== true) {
+            const cache = await readCache(ctx);
+            const cached = cache.environments[session.baseUrl];
+            if (cached && (cached.mode === 'eb' || cached.mode === 'standard')) {
+                return meetingSuccess('meeting.env.detect', {
+                    mode: cached.mode,
+                    smokePath: cached.smokePath,
+                    fromCache: true,
+                    detectedAt: cached.detectedAt,
+                });
+            }
+        }
+        // ② 第 1 步：EB 版冒烟（EB 优先）。接口 404/业务失败均视为「EB 未配置」。
+        let ebError;
+        try {
+            await host.request({
+                method: 'POST',
+                path: EB_SMOKE_PATH,
+                operation: 'meeting.env.detect',
+                body: { datajson: { header: { operator: session.userId } } },
+            });
+            const warning = await writeCache(ctx, session.baseUrl, 'eb', EB_SMOKE_PATH);
+            return meetingSuccess('meeting.env.detect', { mode: 'eb', smokePath: EB_SMOKE_PATH, fromCache: false }, warning ? { warnings: [warning] } : undefined);
+        }
+        catch (error) {
+            ebError = error;
+        }
+        // ③ 第 2 步：标准版冒烟（仅当 EB 冒烟未通过）。
+        try {
+            await host.request({
+                method: 'GET',
+                path: STD_CALENDAR_PATH,
+                operation: 'meeting.env.detect',
+            });
+            const ebDetail = ebError instanceof Error
+                ? `${ebError.type ?? 'api'}/${ebError.subtype ?? 'error'}: ${ebError.message}`
+                : String(ebError);
+            const warning = await writeCache(ctx, session.baseUrl, 'standard', STD_CALENDAR_PATH);
+            return meetingSuccess('meeting.env.detect', {
+                mode: 'standard',
+                smokePath: STD_CALENDAR_PATH,
+                fromCache: false,
+                ebSmokeFailed: true,
+                ebSmokeError: ebDetail,
+            }, warning ? { warnings: [warning] } : undefined);
+        }
+        catch (stdError) {
+            // 两步都不通 → 不写缓存，提示接口未配置完整。
+            throw meetingValidationError('env_unavailable', '当前环境 EB 版与标准版会议接口冒烟均未通过，请确认会议应用已安装且接口已配置完整', {
+                eb: ebError instanceof Error ? ebError.message : String(ebError),
+                standard: stdError instanceof Error ? stdError.message : String(stdError),
+            });
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// 日历/建会基础信息（建会流程判断唯一依据）
+// ---------------------------------------------------------------------------
+const meetingCalendarBase = {
+    name: 'meeting.calendar.base',
+    resource: 'env',
+    method: 'calendar.base',
+    action: 'meeting.calendar.base',
+    summary: '查询日历/建会基础信息（getCalendarBaseData）：onlyFlowCreate / workFlowBaseIds / repeatWorkFlowBaseIds / existWorkFlow',
+    capability: 'env',
+    risk: 'read',
+    inputSchema: { type: 'object', additionalProperties: false, properties: {} },
+    handler: async (_args, { host }) => {
+        const response = await host.request({
+            method: 'GET',
+            path: STD_CALENDAR_PATH,
+            operation: 'meeting.calendar.base',
+        });
+        const createBaseData = response?.data?.createBaseData ?? response?.createBaseData ?? null;
+        return meetingSuccess('meeting.calendar.base', { createBaseData, raw: response });
+    },
+};
+// ---------------------------------------------------------------------------
+// 会议详情表单结构（提醒方式/周期结束条件等 options 来源）
+// ---------------------------------------------------------------------------
+const meetingDetailField = {
+    name: 'meeting.detail.field',
+    resource: 'meeting',
+    method: 'detail.field',
+    action: 'meeting.detail.field',
+    summary: '查询会议详情表单结构与 options（getMeetingDetailField）：id / operateType / fromWorkflow / isReadOnly',
+    capability: 'meeting',
+    risk: 'read',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            id: SCHEMA_ID,
+            operateType: { type: 'string', description: '操作类型，如 SUBMIT/UPDATE/CHANGE' },
+            fromWorkflow: { type: 'integer', enum: [0, 1] },
+            isReadOnly: { type: 'integer', enum: [0, 1] },
+        },
+        required: ['id'],
+    },
+    handler: async (args, { host }) => {
+        const query = { id: String(args.id) };
+        if (args.operateType !== undefined)
+            query.operateType = args.operateType;
+        if (args.fromWorkflow !== undefined)
+            query.fromWorkflow = args.fromWorkflow;
+        if (args.isReadOnly !== undefined)
+            query.isReadOnly = args.isReadOnly;
+        const response = await host.request({
+            method: 'GET',
+            path: '/api/meeting/detail/getMeetingDetailField',
+            operation: 'meeting.detail.field',
+            query,
+        });
+        return meetingSuccess('meeting.detail.field', { data: response?.data ?? response });
+    },
+};
+export const meetingEnvOperations = [
+    meetingEnvDetect,
+    meetingCalendarBase,
+    meetingDetailField,
+];