weaver-work-cli 0.1.39 → 0.1.42

package/dist/shortcuts/meeting/operations/eb/group-chat.js

@@ -0,0 +1,605 @@
+import { mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { meetingSuccess, schemaOf } from '../types.js';
+import { meetingValidationError } from '../../errors.js';
+import { meetingStateDir } from '../env.js';
+/**
+ * 建会同步建群聊（2026-11-02 用户要求）：
+ *
+ * ```
+ * 会议要素（名称/起止/参会人 id/会议室）
+ *   → ESB 动作流 1333212605456498718（一次调用做完两件事：建群 + 群里发会议信息）
+ *   → 动作流 responseData 是空对象、不回群 id
+ *   → im.group.search 按「群名 = 建会时的会议名称」反查群 id（异步，要重试）
+ *   → 会议 id 已知时回写 imchat_groupid；不知道就落一条「待绑」记录，等用户提交后再绑
+ * ```
+ *
+ * ⛔ 三个现场定案：
+ * 1. 入参字段名是 `mt_name` / `begindatetime` / `enddatetime` / `hrmmembers` / `address`，
+ *    `hrmmembers` **必须是人员 id、逗号分隔**（传姓名建出来的群没有成员）。
+ * 2. 动作流**不返回群 id**（`{"resultCode":200,"resultMsg":"执行成功","actionData":{"responseData":{}}}`），
+ *    所以只能反查；反查不到就如实返回 `groupId:null`，**不许编一个 id 回写**。
+ * 3. 事后补绑**只认 requestId，不认会议名称**（2026-11-02 用户纠正）：
+ *    用户在表单里可能改名、也可能有同名会议 —— 会议记录里的 `request_id` 才是唯一凭据。
+ */
+/** 建群动作流 id（本租户配置）；换租户用入参 `flowId` 覆盖。 */
+export const DEFAULT_MEETING_GROUP_FLOW_ID = '1333212605456498718';
+/** 会议表里存群 id 的字段。 */
+const GROUP_FIELD = 'imchat_groupid';
+/** 待绑记录目录（浏览器填单那一档落盘，等用户提交后再补绑）。 */
+const PENDING_DIR = 'pending-forms';
+async function buildEsbEnv(env) {
+    const { createEsbHost } = await import('../../../esb/host.js');
+    const { createEsbContinuationSigner } = await import('../../../esb/continuation.js');
+    return { ctx: env.ctx, host: createEsbHost(env.ctx), continuation: createEsbContinuationSigner(env.ctx) };
+}
+export async function buildImEnv(env) {
+    const { createImHost } = await import('../../../im/host.js');
+    const { createImContinuationSigner } = await import('../../../im/continuation.js');
+    return { ctx: env.ctx, host: createImHost(env.ctx), continuation: createImContinuationSigner(env.ctx) };
+}
+async function buildWorkflowEnv(env) {
+    const { createWorkflowHost } = await import('../../../workflow/host.js');
+    const { createWorkflowContinuationSigner } = await import('../../../workflow/continuation.js');
+    return { ctx: env.ctx, host: createWorkflowHost(env.ctx), continuation: createWorkflowContinuationSigner(env.ctx) };
+}
+/** 本地时间串 → 毫秒（`2026-11-02 22:25:59` / `2026/11/2 22:25` 都认）。 */
+function parseLocalTime(value) {
+    const text = String(value ?? '').trim();
+    if (text === '')
+        return 0;
+    const normalized = /^\d{4}-\d{2}-\d{2}$/u.test(text) ? `${text} 00:00:00` : text;
+    const ts = new Date(normalized.replace(/-/g, '/')).getTime();
+    return Number.isFinite(ts) ? ts : 0;
+}
+function formatLocalTime(date) {
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} `
+        + `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+// ---------------------------------------------------------------------------
+// 待绑记录（浏览器填单那一档）
+// ---------------------------------------------------------------------------
+function pendingDirOf(env) {
+    return resolve(meetingStateDir(env.ctx), PENDING_DIR);
+}
+/** 表单交给用户时落一条记录：群已建好，但还没有会议 id —— 等用户提交后按 requestId 补绑。 */
+export async function savePendingForm(env, record) {
+    try {
+        const dir = pendingDirOf(env);
+        await mkdir(dir, { recursive: true });
+        const preparedAt = String(record.preparedAt ?? '').trim() || formatLocalTime(new Date());
+        // 基线：此刻「我发起的」里最新的一张单。之后新冒出来的那张才是这次提交的 ——
+        // workflow.search 的卡片没有创建时间、createTime 过滤在本环境也不生效，只能靠这个办法定位。
+        let baselineRequestId = '';
+        try {
+            const latest = await searchMyRequests(env, {
+                ...(record.workflowId ? { workflowId: record.workflowId } : {}),
+            });
+            baselineRequestId = latest[0]?.requestId ?? '';
+        }
+        catch {
+            baselineRequestId = '';
+        }
+        const body = { ...record, preparedAt, baselineRequestId };
+        const file = resolve(dir, `${Date.now()}-${String(record.workflowId || 'wf')}.json`);
+        await writeFile(file, `${JSON.stringify(body, null, 2)}\n`, 'utf8');
+        // 只留最近 30 条，避免长期堆积
+        const files = (await readdir(dir)).filter((one) => one.endsWith('.json')).sort();
+        for (const stale of files.slice(0, Math.max(0, files.length - 30))) {
+            await rm(resolve(dir, stale), { force: true });
+        }
+    }
+    catch {
+        // 落盘失败不影响建会：补绑时可以改传 requestId
+    }
+}
+/** 读最近一条待绑记录（按文件名倒序 = 时间倒序）。 */
+async function loadLatestPending(env) {
+    try {
+        const dir = pendingDirOf(env);
+        const files = (await readdir(dir)).filter((one) => one.endsWith('.json')).sort().reverse();
+        for (const file of files) {
+            try {
+                const parsed = JSON.parse(await readFile(resolve(dir, file), 'utf8'));
+                if (parsed && String(parsed.groupId ?? '').trim() !== '')
+                    return parsed;
+            }
+            catch {
+                // 坏文件跳过
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+// ---------------------------------------------------------------------------
+// 群：建 / 查 / 绑
+// ---------------------------------------------------------------------------
+/** 在动作流返回里找群 id：只认键名带 group/chat 的，避免把会议 id、动作流 id 当成群 id。 */
+function pickGroupId(value, depth = 0) {
+    if (value === null || value === undefined || depth > 6)
+        return '';
+    if (Array.isArray(value)) {
+        for (const one of value) {
+            const hit = pickGroupId(one, depth + 1);
+            if (hit)
+                return hit;
+        }
+        return '';
+    }
+    if (typeof value !== 'object')
+        return '';
+    const obj = value;
+    for (const [key, raw] of Object.entries(obj)) {
+        const normalized = key.toLowerCase().replace(/[_-]/gu, '');
+        if (normalized.includes('group') || normalized.includes('chat')) {
+            const text = raw === null || raw === undefined ? '' : String(raw).trim();
+            if (/^\d{6,}$/u.test(text))
+                return text;
+        }
+    }
+    for (const raw of Object.values(obj)) {
+        const hit = pickGroupId(raw, depth + 1);
+        if (hit)
+            return hit;
+    }
+    return '';
+}
+/** 按群名反查群 id：精确同名优先，再取创建时间最新的一个；多候选且非精确时宁可不认。 */
+async function findGroupByName(env, name) {
+    const target = name.trim();
+    if (target === '')
+        return null;
+    try {
+        const { getImOperation } = await import('../../../im/operations/registry.js');
+        const search = getImOperation('im.group.search');
+        const imEnv = await buildImEnv(env);
+        const found = await search.handler({ name: target }, imEnv);
+        const groups = (found?.data?.groups ?? [])
+            .map((one) => ({
+            id: String(one.id ?? '').trim(),
+            name: String(one.name ?? '').trim(),
+            createTime: String(one.createTime ?? '').trim(),
+        }))
+            .filter((one) => one.id !== '');
+        if (groups.length === 0)
+            return null;
+        const exact = groups.filter((one) => one.name === target);
+        const pool = exact.length > 0 ? exact : groups;
+        if (exact.length === 0 && pool.length > 1)
+            return null;
+        pool.sort((a, b) => parseLocalTime(b.createTime) - parseLocalTime(a.createTime));
+        return { ...pool[0], exact: exact.length > 0 };
+    }
+    catch {
+        return null;
+    }
+}
+/** 反查群 id 带重试：动作流建群是**异步**的（实测 apply 返回后立刻查是 0 条，1~3 秒后才出现）。 */
+async function findGroupWithRetry(env, name) {
+    const delays = [0, 1200, 2500, 4000];
+    for (let index = 0; index < delays.length; index += 1) {
+        if (delays[index] > 0)
+            await new Promise((done) => setTimeout(done, delays[index]));
+        const hit = await findGroupByName(env, name);
+        if (hit)
+            return hit;
+    }
+    return null;
+}
+/** 触发建群动作流（建群 + 群内发会议信息一次完成）。 */
+async function triggerGroupFlow(env, input, meetingName, memberIds) {
+    const session = await env.host.getSession();
+    const employeeId = String(input.employeeId ?? session?.userId ?? '').trim();
+    if (!employeeId) {
+        return { actionData: null, error: '取不到当前登录用户 id，无法触发建群动作流' };
+    }
+    const mainTable = {
+        mt_name: meetingName,
+        begindatetime: String(input.beginDatetime ?? ''),
+        enddatetime: String(input.endDatetime ?? ''),
+        hrmmembers: memberIds.join(','),
+    };
+    if (input.address) {
+        // ⛔ 2026-11-04 用户反馈：建群动作流把 `address` **原样打进群消息**（「会议地点：100502820000000226」）。
+        // ESB 模板改不了，所以这里先把它解析成会议室名称再传；解析不到才退回原值。
+        // 另外入参可能是 `{id,name}` 对象或被 String() 过的 "[object Object]"，一并兜住。
+        const raw = input.address;
+        let addressText = raw && typeof raw === 'object'
+            ? String(raw.name ?? raw.id ?? '')
+            : String(raw).trim();
+        if (addressText === '[object Object]')
+            addressText = '';
+        if (addressText) {
+            try {
+                const { resolveAddressRoom } = await import('./create-flow.js');
+                const room = await resolveAddressRoom(env, addressText);
+                if (room?.name)
+                    addressText = room.name;
+            }
+            catch {
+                // 台账读不到不影响建群，退回原值
+            }
+        }
+        if (addressText)
+            mainTable.address = addressText;
+    }
+    try {
+        const { getEsbOperation } = await import('../../../esb/operations/registry.js');
+        const esbEnv = await buildEsbEnv(env);
+        const prepare = getEsbOperation('esb.trigger.prepare');
+        const apply = getEsbOperation('esb.trigger.apply');
+        const pre = await prepare.handler({
+            esbFlowId: String(input.flowId ?? '').trim() || DEFAULT_MEETING_GROUP_FLOW_ID,
+            employeeId,
+            customParams: { mainTable },
+            moduleSource: '',
+        }, esbEnv);
+        const applied = await apply.handler({ continuation: pre?.data?.continuation, confirm: true }, esbEnv);
+        if (applied?.ok === false) {
+            return {
+                actionData: applied?.data ?? null,
+                error: String(applied?.error?.message ?? applied?.message ?? '建群动作流执行失败').slice(0, 300),
+            };
+        }
+        return { actionData: applied?.data?.actionData ?? null };
+    }
+    catch (error) {
+        return { actionData: null, error: String(error?.message ?? error).slice(0, 300) };
+    }
+}
+/** 把群 id 写进会议表 `imchat_groupid`，并回读确认（接口不回该字段时如实返回 undefined）。 */
+async function bindGroupToMeeting(env, meetingId, groupId) {
+    const id = String(meetingId).trim();
+    const group = String(groupId).trim();
+    if (id === '' || group === '')
+        return { ok: false, error: '没有会议 id 或群 id' };
+    try {
+        const { EB_BASE, ebBusinessSuccess, writeBody } = await import('./factory.js');
+        const session = await env.host.getSession();
+        // 走 updateFormData 直写：`imchat_groupid` 是系统维护字段，不在 change_meeting 的内置白名单里，
+        // 用 prepare/apply 链会被字段过滤掉；这里与原先补写客户字段同一条已验证通路。
+        await env.host.request({
+            method: 'POST',
+            path: `${EB_BASE}/updateFormData/change_meeting`,
+            query: { id },
+            operation: 'meeting.eb.meeting.group.ensure',
+            body: writeBody(String(session.userId), {
+                mainTable: { id, operate_type: 'UPDATE', [GROUP_FIELD]: group },
+                details: {},
+                operateType: {},
+            }),
+            acceptBusiness: ebBusinessSuccess,
+        });
+    }
+    catch (error) {
+        return { ok: false, error: String(error?.message ?? error).slice(0, 300) };
+    }
+    try {
+        const { getMeetingOperation } = await import('../registry.js');
+        const detail = getMeetingOperation('meeting.eb.meeting.detail');
+        const read = await detail.handler({ id }, env);
+        const main = (read?.data?.data ?? read?.data?.main ?? {});
+        const value = main[GROUP_FIELD];
+        if (value === undefined || value === null)
+            return { ok: true };
+        const text = String(value).trim();
+        if (text === group)
+            return { ok: true, readBack: text };
+        if (text !== '')
+            return { ok: false, error: `回读不一致：${text}` };
+        return { ok: true };
+    }
+    catch {
+        return { ok: true };
+    }
+}
+// ---------------------------------------------------------------------------
+// 按 requestId 反查会议（唯一凭据：会议记录的 request_id）
+// ---------------------------------------------------------------------------
+/** 我发起的流程（最近一页，按创建时间倒序），供「用户刚提交完」这种场景找单号。 */
+async function searchMyRequests(env, options = {}) {
+    try {
+        const { getWorkflowOperation } = await import('../../../workflow/operations/registry.js');
+        const op = getWorkflowOperation('workflow.search');
+        const wfEnv = await buildWorkflowEnv(env);
+        // 卡片里没有创建时间字段（实测 createdAt 为空），所以时间必须走服务端 createTime 过滤，
+        // 否则「今天所有我发起的单」都会进来，等于没筛。
+        const args = { category: 'mine', pageSize: 20, sort: 'createTime:desc' };
+        if (options.sinceMs) {
+            const from = formatLocalTime(new Date(options.sinceMs)).slice(0, 16);
+            const to = formatLocalTime(new Date()).slice(0, 16);
+            args.createTime = `${from}~${to}`;
+        }
+        const res = await op.handler(args, wfEnv);
+        const cards = (res?.data?.cards ?? [])
+            .map((one) => ({
+            requestId: String(one.requestId ?? '').trim(),
+            flowName: String(one.flowName ?? '').trim(),
+            workflowId: String(one.workflowId ?? '').trim(),
+            createdAt: String(one.createdAt ?? one.createTime ?? '').trim(),
+        }))
+            .filter((one) => one.requestId !== '');
+        return cards.filter((one) => {
+            if (options.workflowId && one.workflowId !== options.workflowId)
+                return false;
+            if (options.sinceMs) {
+                const created = parseLocalTime(one.createdAt);
+                if (created !== 0 && created < options.sinceMs)
+                    return false;
+            }
+            return true;
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * 按 requestId 找会议：列表接口的 `request_id` 过滤参数**实测无效**（传什么都回全量），
+ * 所以只能「取最新若干条会议 → 逐个 detail 比对 request_id」。候选用 `create_time >= since` 收窄，
+ * 一次补绑最多查 10 条，正常只有 1~2 条。
+ */
+async function resolveMeetingByRequestId(env, requestId, sinceMs) {
+    const target = String(requestId).trim();
+    if (target === '')
+        return null;
+    try {
+        const { getMeetingOperation } = await import('../registry.js');
+        const list = getMeetingOperation('meeting.eb.meeting.list');
+        const detail = getMeetingOperation('meeting.eb.meeting.detail');
+        // ① 直连过滤走不通：`request_id` 不是查询接口的入参（接口文档 2026-11-02 确认），
+        //    出参又是「按显示名称」（回流程标题）。只能扫表 + detail 比对单号。
+        // ② 取最新若干条，按创建时间收窄后逐个比对 request_id（detail 的出参是「按选项值」，回真单号）
+        const page = await list.handler({ pageSize: 30 }, env);
+        const rows = (page?.data?.rows ?? [])
+            .map((row) => (row?.mainTable ?? row ?? {}))
+            .filter((main) => String(main.id ?? '').trim() !== '');
+        const candidates = rows
+            .filter((main) => {
+            const created = parseLocalTime(main.create_time);
+            // create_time 缺失时不排除，交给 detail 判定
+            return created === 0 || sinceMs === 0 || created >= sinceMs - 120_000;
+        })
+            .slice(0, 10);
+        for (const candidate of candidates) {
+            const id = String(candidate.id).trim();
+            try {
+                const read = await detail.handler({ id }, env);
+                const main = (read?.data?.data ?? read?.data?.main ?? {});
+                if (String(main.request_id ?? '').trim() === target) {
+                    return {
+                        id,
+                        name: String(main.mt_name ?? candidate.mt_name ?? '').trim(),
+                        begin: String(main.begin_datetime ?? candidate.begin_datetime ?? '').trim(),
+                        requestId: target,
+                    };
+                }
+            }
+            catch {
+                // 单条读失败不影响继续找
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 建会时同步建群 + 绑定（供 create.flow.apply / quick 内部调用，也单独暴露成 operation）。
+ *
+ * 幂等：同名群已存在时**不重复建**，直接复用；补绑只认 requestId（不认名称）。
+ */
+export async function ensureMeetingGroupChat(env, input) {
+    const memberIds = (input.memberIds ?? []).map((one) => String(one).trim()).filter((one) => one !== '');
+    const pending = input.lookupPending === true ? await loadLatestPending(env) : null;
+    let meetingName = String(input.meetingName ?? pending?.mtName ?? '').trim();
+    let meetingId = String(input.meetingId ?? '').trim();
+    let requestId = String(input.requestId ?? '').trim();
+    let meetingLookup = null;
+    let requestCandidates;
+    // 补绑场景：没有会议 id 时，按「待绑记录 → 流程单 → 会议」这条链走（名称不参与判定）
+    if (meetingId === '' && (input.lookupPending === true || requestId !== '')) {
+        const sinceMs = parseLocalTime(pending?.preparedAt) || (Date.now() - 2 * 3600_000);
+        if (requestId === '') {
+            const requests = await searchMyRequests(env, {
+                ...(pending?.workflowId ? { workflowId: pending.workflowId } : {}),
+            });
+            // 用建群时记下的基线切分：排在基线上面的（更新）才是用户这次提交的单。
+            // 找不到基线就只认最新一条，并把候选交给用户确认（不猜）。
+            const baseline = String(pending?.baselineRequestId ?? '').trim();
+            const baselineIndex = baseline === '' ? -1 : requests.findIndex((one) => one.requestId === baseline);
+            const fresh = baselineIndex > 0
+                ? requests.slice(0, baselineIndex)
+                : baselineIndex === 0
+                    ? []
+                    : requests.slice(0, 3);
+            if (fresh.length === 1) {
+                requestId = fresh[0].requestId;
+            }
+            else if (fresh.length > 1) {
+                requestCandidates = fresh.slice(0, 5).map((one) => ({
+                    requestId: one.requestId,
+                    flowName: one.flowName,
+                    createdAt: one.createdAt,
+                }));
+            }
+        }
+        if (requestId !== '') {
+            meetingLookup = await resolveMeetingByRequestId(env, requestId, sinceMs);
+            if (meetingLookup) {
+                meetingId = meetingLookup.id;
+                // 名称只用来**找群**（群名就是建群时的会议名）；定位会议始终靠 requestId
+                if (meetingName === '')
+                    meetingName = meetingLookup.name;
+            }
+        }
+    }
+    if (meetingName === '' && input.groupId === undefined && pending === null) {
+        return {
+            ok: false,
+            groupId: null,
+            groupName: null,
+            created: false,
+            bound: false,
+            meetingId: meetingId || null,
+            requestId: requestId || null,
+            error: '既没有会议名称，也没有本机待绑记录/群 id，无法建群或补绑',
+        };
+    }
+    // ① 已知群 id（重试/补绑场景）；补绑时群 id 来自待绑记录
+    const knownGroupId = String(input.groupId ?? pending?.groupId ?? '').trim();
+    if (knownGroupId !== '') {
+        const bound = meetingId
+            ? await bindGroupToMeeting(env, meetingId, knownGroupId)
+            : {
+                ok: false,
+                error: requestCandidates
+                    ? '同一时间窗有多个流程单，先让用户确认是哪一张（见 requestCandidates），再传 requestId'
+                    : requestId
+                        ? `流程单 ${requestId} 对应不到会议（可能还在审批、或会议尚未同步）`
+                        : '没拿到流程单 id，无法定位会议',
+            };
+        return {
+            ok: bound.ok,
+            groupId: knownGroupId,
+            groupName: pending?.groupName ?? null,
+            created: false,
+            bound: bound.ok,
+            meetingId: meetingId || null,
+            requestId: requestId || null,
+            ...(input.lookupPending === true || requestId !== '' ? { meetingLookup } : {}),
+            ...(requestCandidates ? { requestCandidates } : {}),
+            ...(bound.readBack ? { readBack: bound.readBack } : {}),
+            ...(bound.error ? { error: bound.error } : {}),
+        };
+    }
+    // ② 已有同名群 → 直接复用（幂等，不重复建）
+    const existing = await findGroupByName(env, meetingName);
+    let groupId = existing?.id ?? '';
+    let groupName = existing?.name ?? '';
+    let created = false;
+    let error;
+    if (groupId === '') {
+        const triggered = await triggerGroupFlow(env, input, meetingName, memberIds);
+        error = triggered.error;
+        groupId = pickGroupId(triggered.actionData);
+        if (groupId === '') {
+            const newest = await findGroupWithRetry(env, meetingName);
+            groupId = newest?.id ?? '';
+            groupName = newest?.name ?? '';
+        }
+        created = groupId !== '';
+    }
+    if (groupId === '') {
+        return {
+            ok: false,
+            groupId: null,
+            groupName: null,
+            created: false,
+            bound: false,
+            meetingId: meetingId || null,
+            requestId: requestId || null,
+            ...(requestCandidates ? { requestCandidates } : {}),
+            ...(error ? { error } : { error: '建群动作流已触发，但没能反查到群 id（群名与会议名称不一致？）' }),
+        };
+    }
+    // ③ 有会议 id 才回写；没有就只回报群信息（等用户提交后按 requestId 补绑）
+    if (meetingId === '') {
+        return {
+            ok: true,
+            groupId,
+            groupName: groupName || meetingName,
+            created,
+            bound: false,
+            meetingId: null,
+            requestId: requestId || null,
+            ...(requestCandidates ? { requestCandidates } : {}),
+            ...(input.lookupPending === true && !requestCandidates
+                ? { error: '群已建好，但还没找到对应流程单（可能用户还没提交，或刚提交还没同步）' }
+                : {}),
+        };
+    }
+    const bound = await bindGroupToMeeting(env, meetingId, groupId);
+    return {
+        ok: bound.ok,
+        groupId,
+        groupName: groupName || meetingName,
+        created,
+        bound: bound.ok,
+        meetingId,
+        requestId: requestId || null,
+        ...(input.lookupPending === true || requestId !== '' ? { meetingLookup } : {}),
+        ...(requestCandidates ? { requestCandidates } : {}),
+        ...(bound.readBack ? { readBack: bound.readBack } : {}),
+        ...(bound.error ? { error: bound.error } : {}),
+    };
+}
+const ebMeetingGroupEnsure = {
+    name: 'meeting.eb.meeting.group.ensure',
+    resource: 'eb',
+    method: 'meeting.eb.meeting.group.ensure',
+    action: 'meeting.eb.meeting.group.ensure',
+    summary: '建会同步建群聊：按会议名称/起止/参会人调建群动作流（群内发会议信息），反查群 id；'
+        + '补绑会议记录时按 requestId 反查（不按会议名称）',
+    capability: 'eb.meeting',
+    // 建群是写操作但不破坏数据（可解散重建），按「先确认会议要素再调」的口径标注
+    risk: 'read-before-write',
+    inputSchema: schemaOf({
+        mt_name: { type: 'string', description: '建会时的会议名称（=群名称）。补绑时可不传，自动读本机待绑记录' },
+        begin_datetime: { type: 'string', description: '会议开始时间（yyyy-MM-dd HH:mm）' },
+        end_datetime: { type: 'string', description: '会议结束时间（yyyy-MM-dd HH:mm）' },
+        hrm_members: { type: 'string', description: '参会人员员工 id，逗号分隔（动作流要求 id，不要传姓名）' },
+        address: { type: 'string', description: '会议室 id（可选）' },
+        meetingId: { type: 'string', description: '会议 id：传了就只做绑群' },
+        requestId: { type: 'string', description: '流程单据 id：按它反查会议（会议记录的 request_id），比名称可靠' },
+        groupId: { type: 'string', description: '已知群 id：传入则跳过建群，直接绑定' },
+        lookupPending: {
+            type: 'boolean',
+            description: '补绑模式：读本机「表单已发出」记录，按流程单反查会议再绑群（用户点提交后用这个）',
+        },
+        flowId: { type: 'string', description: `覆盖建群动作流 id（默认 ${DEFAULT_MEETING_GROUP_FLOW_ID}）` },
+        employeeId: { type: 'string', description: '覆盖触发人员 id（默认当前登录用户）' },
+    }, {}),
+    handler: async (args, env) => {
+        const result = await ensureMeetingGroupChat(env, {
+            ...(args.mt_name ? { meetingName: String(args.mt_name).trim() } : {}),
+            ...(args.begin_datetime ? { beginDatetime: String(args.begin_datetime).trim() } : {}),
+            ...(args.end_datetime ? { endDatetime: String(args.end_datetime).trim() } : {}),
+            memberIds: String(args.hrm_members ?? '')
+                .split(/[,;，；\s]+/u)
+                .map((one) => one.trim())
+                .filter((one) => one !== ''),
+            ...(args.address ? { address: String(args.address).trim() } : {}),
+            ...(args.meetingId ? { meetingId: String(args.meetingId).trim() } : {}),
+            ...(args.requestId ? { requestId: String(args.requestId).trim() } : {}),
+            ...(args.groupId ? { groupId: String(args.groupId).trim() } : {}),
+            ...(args.lookupPending === true ? { lookupPending: true } : {}),
+            ...(args.flowId ? { flowId: String(args.flowId).trim() } : {}),
+            ...(args.employeeId ? { employeeId: String(args.employeeId).trim() } : {}),
+        });
+        if (!result.ok && !result.groupId) {
+            throw meetingValidationError('group_create_failed', result.error ?? '建群失败', { requestId: result.requestId ?? null, requestCandidates: result.requestCandidates ?? [] });
+        }
+        const warnings = [];
+        if (result.requestCandidates && result.requestCandidates.length > 0) {
+            warnings.push(`同一时间窗查到 ${result.requestCandidates.length} 张流程单，没法确定是哪一张：`
+                + result.requestCandidates.map((one) => `${one.flowName || '(无标题)'} ${one.requestId}`).join('、')
+                + '。⛔ 不要自己猜 —— 让用户确认是哪一张，再把它的 requestId 传进来。');
+        }
+        if (result.bound) {
+            warnings.push(`群已绑定到会议记录（imchat_groupid=${result.groupId}${result.readBack ? '，回读一致' : ''}）。`);
+        }
+        else if (!result.meetingId) {
+            warnings.push(result.error
+                ? `群已建好（群 id ${result.groupId}），但还没绑上：${result.error}`
+                : '群已建好，但还没有会议 id：用户提交后带 lookupPending:true（或 requestId）再跑一次即可补绑。');
+        }
+        return meetingSuccess('meeting.eb.meeting.group.ensure', { ...result }, warnings.length > 0 ? { warnings } : {});
+    },
+};
+export const meetingEbGroupChatOperations = [ebMeetingGroupEnsure];

package/dist/shortcuts/meeting/operations/eb/index.js

@@ -8,6 +8,7 @@ import { meetingValidationError } from '../../errors.js';
 import { meetingEbScheduleOperations } from './schedule.js';
 import { meetingEbCrmOperations } from './crm-search.js';
 import { meetingEbCreateFlowOperations } from './create-flow.js';
+import { meetingEbGroupChatOperations } from './group-chat.js';
 /**
  * 会议 EB 版（eBuilder）operations。
  *
@@ -170,5 +171,6 @@ export const meetingEbOperations = [
     ...meetingEbScheduleOperations,
     ...meetingEbCrmOperations,
     ...meetingEbCreateFlowOperations,
+    ...meetingEbGroupChatOperations,
     ebRoomRecommendOperation,
 ];