weaver-work-cli 0.1.33 → 0.1.38

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

@@ -7,6 +7,57 @@ import { isWriteKind } from './catalog.js';
 export const EB_BASE = '/api/ebuilder/form/formdata/v2';
 const EB_READ_OP = { list: 'getFormDataList', detail: 'getFormDataByPk', get: 'getFormDataList' };
 const EB_WRITE_OP = { create: 'saveFormData', update: 'updateFormData', delete: 'deleteFormData' };
+/** 详情里的人员类字段：值可能是员工 id，补一份姓名回显，别让调用方把 id 当成"没填/填错了"。 */
+const PERSONNEL_FIELDS = [
+    'caller', 'contacter', 'mt_creator', 'creator', 'updater',
+    'hrm_members', 'attend_user', 'inviters', 'reporting_user', 'topic_presenter',
+];
+/**
+ * 人员字段 id → 姓名。
+ *
+ * ⛔ 2026-10-31 用户反馈「联系人那一栏显示成一串数字」：detail 接口回的是**原始值**
+ * （页面建的单存 id、工作流建的单存姓名文本），调用方看到 id 就以为字段没填好。
+ * 这里只补一份 `personnelText`（字段名 → 姓名），**不动原字段**，避免破坏既有消费方。
+ */
+async function buildPersonnelText(env, data) {
+    const ids = [];
+    for (const key of PERSONNEL_FIELDS) {
+        const raw = String(data?.[key] ?? '').trim();
+        // 已经是姓名文本（含中文/括号）就不用查；纯数字与逗号才算 id 列表
+        if (raw === '' || !/^[\d,\s]+$/u.test(raw))
+            continue;
+        ids.push(...raw.split(',').map((one) => one.trim()).filter((one) => one !== ''));
+    }
+    if (ids.length === 0)
+        return {};
+    const names = new Map();
+    try {
+        const { hrmEmployeeOperations } = await import('../../../hrm/operations/employee.js');
+        const batch = hrmEmployeeOperations.find((operation) => operation.name === 'hrm.employee.batch');
+        if (batch) {
+            const result = await batch.handler({ ids: [...new Set(ids)] }, env);
+            for (const row of (result?.data?.rows ?? result?.data?.userList ?? [])) {
+                const id = String(row.id ?? '').trim();
+                const name = String(row.name ?? '').trim();
+                if (id && name)
+                    names.set(id, name);
+            }
+        }
+    }
+    catch {
+        return {};
+    }
+    const out = {};
+    for (const key of PERSONNEL_FIELDS) {
+        const raw = String(data?.[key] ?? '').trim();
+        if (raw === '' || !/^[\d,\s]+$/u.test(raw))
+            continue;
+        const mapped = raw.split(',').map((one) => names.get(one.trim()) ?? one.trim()).filter((one) => one !== '');
+        if (mapped.length > 0)
+            out[key] = mapped.join(',');
+    }
+    return out;
+}
 const CONTINUATION_TTL_SECONDS = 600;
 /**
  * EB 响应成功判定。
@@ -71,10 +122,12 @@ function isNetworkError(error) {
  * 该缺陷曾导致 CLI 的 EB 读操作全线失败，并连带使 `meeting.env.detect` 的 EB 冒烟失败、
  * 环境被误判为 standard 版。
  */
-export function queryBody(userId, page) {
+export function queryBody(userId, page, mainTable) {
     return {
         datajson: {
-            mainTable: {},
+            // 传入字段即过滤条件（e-builder openApi 文档：getFormDataList 的传入字段挂 mainTable 节点）。
+            // 空对象 = 不过滤。
+            mainTable: mainTable ?? {},
             // ⚠️ 分页必须放在 body 的 pageInfo 里（值为字符串）：只放 URL query 时 EB 会忽略，
             // 恒定返回首页 10 条（2026-09-21 真机暴露：pageSize=60 仍只回 10 条）。
             ...(page ? { pageInfo: { pageNo: String(page.pageNo), pageSize: String(page.pageSize) } } : {}),
@@ -82,6 +135,27 @@ export function queryBody(userId, page) {
         },
     };
 }
+/**
+ * 模糊回退最多翻几页。EB 的 pageSize 不生效（恒定回 10 条），所以翻页数直接决定能覆盖多少数据。
+ * 环境变量 `WEAVER_MEETING_EB_FALLBACK_MAX_PAGES` 可覆盖，默认 30（≈300 条）。
+ */
+function readFallbackMaxPages() {
+    const raw = Number(process.env.WEAVER_MEETING_EB_FALLBACK_MAX_PAGES ?? '');
+    if (Number.isFinite(raw) && raw >= 1)
+        return Math.min(Math.floor(raw), 100);
+    return 30;
+}
+/** 从入参里挑出「服务端过滤字段」（mainTableParams），没传的不进 body。 */
+function pickMainTableFilters(args, names) {
+    const out = {};
+    for (const name of names ?? []) {
+        const value = args[name];
+        if (value === undefined || value === null || value === '')
+            continue;
+        out[name] = typeof value === 'string' ? value : String(value);
+    }
+    return out;
+}
 /** 详情接口 body（getFormDataByPk）：顶层 mainTable 传 id。 */
 function detailBody(userId, id) {
     return { datajson: { mainTable: { id }, header: { operator: userId } } };
@@ -138,11 +212,24 @@ function buildReadInputSchema(endpoint) {
         for (const param of endpoint.queryParams ?? []) {
             properties[param] = { type: 'string', description: `EB 筛选参数（URL 占位符名 ${param}）` };
         }
+        for (const param of endpoint.mainTableParams ?? []) {
+            properties[param] = {
+                type: 'string',
+                description: `按 ${param} 过滤（走 body datajson.mainTable，服务端**精确匹配**；`
+                    + `传部分词时服务端会返回 0 条，CLI 会自动翻页扫全量并按「包含」重新筛，结果一样是模糊的）`,
+            };
+        }
         properties.pageNo = { type: 'integer', minimum: 1, description: '页码，默认 1' };
         properties.pageSize = { type: 'integer', minimum: 1, maximum: 200, description: '每页条数，默认 20' };
         if (endpoint.countPk) {
             properties.withCount = { type: 'boolean', description: '是否先查总数（默认 true，条件与列表一致）' };
         }
+        if ((endpoint.mainTableParams ?? []).length > 0) {
+            properties.noFallback = {
+                type: 'boolean',
+                description: '跳过「模糊兜底」：服务端精确匹配不到时，不再翻页扫全量（默认 false=会扫，保证部分词也能查到）',
+            };
+        }
     }
     return {
         type: 'object',
@@ -194,7 +281,15 @@ function buildReadOperation(endpoint) {
                             detailNodes[key] = value;
                     }
                 }
-                return meetingSuccess(endpoint.operation, { id, data, ...(Object.keys(detailNodes).length > 0 ? { details: detailNodes } : {}) }, endpoint.notes ? { meta: { notes: endpoint.notes } } : {});
+                const personnelText = endpoint.operation.startsWith('meeting.')
+                    ? await buildPersonnelText(env, data)
+                    : {};
+                return meetingSuccess(endpoint.operation, {
+                    id,
+                    data,
+                    ...(Object.keys(personnelText).length > 0 ? { personnelText } : {}),
+                    ...(Object.keys(detailNodes).length > 0 ? { details: detailNodes } : {}),
+                }, endpoint.notes ? { meta: { notes: endpoint.notes } } : {});
             }
             const query = {};
             for (const param of endpoint.queryParams ?? []) {
@@ -216,6 +311,9 @@ function buildReadOperation(endpoint) {
             }
             const pageNo = typeof args.pageNo === 'number' ? args.pageNo : 1;
             const pageSize = typeof args.pageSize === 'number' ? args.pageSize : 20;
+            // 服务端过滤条件：count 与 list 必须用**同一份**，否则 total 与当页行数对不上
+            // （总数是不带过滤的、列表是过滤后的，用户会看到"共 155 间"却只回 1 条）。
+            const mainTableFilters = pickMainTableFilters(args, endpoint.mainTableParams);
             let total;
             if (endpoint.countPk && args.withCount !== false) {
                 const countResponse = await env.host.request({
@@ -223,7 +321,7 @@ function buildReadOperation(endpoint) {
                     path: `${EB_BASE}/getFormDataCount/${endpoint.countPk}`,
                     operation: endpoint.operation,
                     query,
-                    body: queryBody(session.userId),
+                    body: queryBody(session.userId, undefined, mainTableFilters),
                     acceptBusiness,
                 });
                 total = extractEbCount(countResponse);
@@ -234,13 +332,61 @@ function buildReadOperation(endpoint) {
                 operation: endpoint.operation,
                 query: { ...query, pageNo, pageSize },
                 // 分页同时进 body.pageInfo：EB 只认 body 里的 pageInfo，仅放 URL query 会被忽略。
-                body: queryBody(session.userId, { pageNo, pageSize }),
+                body: queryBody(session.userId, { pageNo, pageSize }, mainTableFilters),
                 acceptBusiness,
             });
-            const { rows, total: listTotal } = extractEbRows(response);
+            const { rows: rawRows, total: listTotal } = extractEbRows(response);
+            // 服务端过滤不可靠时的兜底：2026-10-30 实测 e-cology 生产环境，
+            // `getFormDataCount/query_meeting_room_count` **完全忽略** mainTable / URL query 的过滤条件
+            // （无过滤 155、room_name=测试 155、room_name=zzz不存在 155，全是 155），
+            // 而 list 又可能只回当页 —— 只靠服务端过滤会得到"total=155 但一条都不匹配"的假结果。
+            // 所以只要调用方传了筛选字段，就在本地按同一条件再筛一遍，保证结果正确。
+            const filterKeys = Object.keys(mainTableFilters);
+            const matchesFilters = (row) => {
+                const main = (row?.mainTable ?? row ?? {});
+                return filterKeys.every((key) => {
+                    const cell = main[key];
+                    if (cell === undefined || cell === null)
+                        return false;
+                    return String(cell).includes(String(mainTableFilters[key]));
+                });
+            };
+            let rows = filterKeys.length === 0 ? rawRows : rawRows.filter(matchesFilters);
+            let fallback;
+            // ⚠️ 服务端是**精确匹配**，模糊词拿不到数据（2026-10-30 实测 e-cology：
+            //   room_name=测试会议室1 → 1 条 ✅；room_name=测试 / 重庆 → 0 条 ❌，
+            //   但全量里明明有「重庆会议室一/二」）。
+            // 传了筛选却一条没命中时，回退：不带过滤翻页拉全量，在客户端按 contains 再筛一遍。
+            // 只在首轮 0 条时触发（精确命中时零额外开销）；`noFallback:true` 可关。
+            if (filterKeys.length > 0 && rows.length === 0 && args.noFallback !== true) {
+                const maxPages = readFallbackMaxPages();
+                const collected = [];
+                let pages = 0;
+                for (let p = 1; p <= maxPages; p += 1) {
+                    const pageResponse = await env.host.request({
+                        method: 'POST',
+                        path,
+                        operation: endpoint.operation,
+                        query: { ...query, pageNo: p, pageSize },
+                        // 不带 mainTableFilters：服务端只会做精确匹配，带上就又变成 0 条了
+                        body: queryBody(session.userId, { pageNo: p, pageSize }),
+                        acceptBusiness,
+                    });
+                    const { rows: pageRows } = extractEbRows(pageResponse);
+                    pages = p;
+                    if (pageRows.length === 0)
+                        break; // 翻到空页 = 到底了
+                    collected.push(...pageRows);
+                    if (p >= maxPages)
+                        break;
+                }
+                fallback = { pages, scanned: collected.length };
+                rows = collected.filter(matchesFilters);
+            }
             // count 接口与实际行数不一致时（本租户 `query_mt_topic_count` 恒返回 0，而 list 有数据），
             // 以"实际取到的行数"为下限，避免出现 total=0 却有数据的自相矛盾结果。
-            const resolvedTotal = total ?? listTotal ?? rows.length;
+            // ⚠️ 有筛选时 count 不可信（见上），一律以本地筛完的行数为准。
+            const resolvedTotal = filterKeys.length > 0 ? rows.length : (total ?? listTotal ?? rawRows.length);
             // 结果后处理（如决议任务进度 / 签到回执出席汇总）：只**增**一个字段，原始 rows 原样返回。
             // 统一注入 `page`（本页 + 总数），避免各实现把"当页行数"误当成总数（2026-09-22 踩到：
             // 签到全量 261 条、pageSize=200 时，summary 里写的 total 只有 200）。
@@ -249,6 +395,8 @@ function buildReadOperation(endpoint) {
                 pageSize,
                 pageCount: rows.length,
                 total: Math.max(resolvedTotal, rows.length),
+                // 模糊回退时告知调用方：结果是客户端筛出来的，扫了多少条
+                ...(fallback ? { fallback } : {}),
             };
             const summarized = endpoint.summarizeRows
                 ? endpoint.summarizeRows(rows, {
@@ -278,6 +426,11 @@ function buildReadOperation(endpoint) {
                 pageWarnings.push(`本页返回 ${rows.length} 条，共 ${effectiveTotal} 条：还有 ${missing} 条未取到。`
                     + `需要全量请翻页（pageNo=${pageNo + 1} 起）或加大 pageSize，或收窄筛选条件`);
             }
+            if (fallback) {
+                pageWarnings.push(`服务端只支持「精确匹配」，按 ${filterKeys.join('/')} 过滤后 0 条；`
+                    + `已翻页扫描全量 ${fallback.scanned} 条（${fallback.pages} 页）在客户端按「包含」重新筛选，命中 ${rows.length} 条。`
+                    + `传 noFallback:true 可跳过这次扫描`);
+            }
             return meetingSuccess(endpoint.operation, {
                 total: effectiveTotal,
                 pageNo,
@@ -285,7 +438,7 @@ function buildReadOperation(endpoint) {
                 count: rows.length,
                 ...(progress ? { progress } : {}),
                 rows,
-                filters: query,
+                filters: { ...query, ...mainTableFilters },
             }, {
                 ...(endpoint.notes ? { meta: { notes: endpoint.notes } } : {}),
                 ...(pageWarnings.length > 0 ? { warnings: pageWarnings } : {}),

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

@@ -6,6 +6,7 @@ import { ebMeetingAssociation } from './association.js';
 import { ebRoomRecommendOperation, recommendRooms, rememberFrequentRoom } from './room-recommend.js';
 import { meetingValidationError } from '../../errors.js';
 import { meetingEbScheduleOperations } from './schedule.js';
+import { meetingEbCrmOperations } from './crm-search.js';
 import { meetingEbCreateFlowOperations } from './create-flow.js';
 /**
  * 会议 EB 版（eBuilder）operations。
@@ -167,6 +168,7 @@ export const meetingEbOperations = [
     ...meetingEbConflictOperations,
     ...meetingEbDecisionOperations,
     ...meetingEbScheduleOperations,
+    ...meetingEbCrmOperations,
     ...meetingEbCreateFlowOperations,
     ebRoomRecommendOperation,
 ];

package/dist/shortcuts/meeting/operations/eb/room-recommend.js

@@ -1,7 +1,14 @@
 import { meetingSuccess, schemaOf, SCHEMA_DATETIME_MINUTE } from '../types.js';
 import { EB_BASE, ebBusinessSuccess, extractEbRows, queryBody } from './factory.js';
 import { readCache, writeCache, cacheScopeSuffix } from './cache.js';
+// 会议室台账缓存 24h（用户 2026-10-30 明确要求：不要为了新鲜度把 TTL 缩到 15 分钟，太频繁）。
+// 「刚导入/新建的会议室看不到」靠两层兜底解决，而不是靠缩短 TTL：
+//   ① **建会链路强制拉最新**（create.flow.prepare / quick / create.suggest 传 refreshRooms: true）——
+//      这些是"要下单"的场景，宁可多一次请求也必须准；
+//   ② **候选为空且来自缓存 → 自动强制重拉重算**（见下方 candidates.length === 0 分支）。
+// 纯查询（room.recommend）走 24h 缓存保持快；缓存超过 STALE_NOTICE_MS 会在 warnings 提示可用 refresh 刷新。
 const ROOMS_TTL_MS = 24 * 60 * 60 * 1000;
+const STALE_NOTICE_MS = 4 * 60 * 60 * 1000;
 const FREQUENT_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 const FREQUENT_WINDOW_DAYS = 180;
 const PAGE_SIZE = 100;
@@ -176,6 +183,11 @@ export async function recommendRooms(env, input) {
     const topN = Math.max(1, Math.min(10, input.topN ?? 3));
     const roomData = await loadRooms(env, { refresh: input.refreshRooms === true });
     warnings.push(...roomData.warnings);
+    // 缓存 4 小时以上 → 提示数据可能过时（不是报错，只是让调用方知道"刚加的会议室可能还看不到"）。
+    if (roomData.fromCache && (roomData.ageSeconds ?? 0) * 1000 > STALE_NOTICE_MS) {
+        warnings.push(`会议室台账来自 ${Math.round((roomData.ageSeconds ?? 0) / 3600)} 小时前的缓存（共 ${roomData.rooms.length} 间）。`
+            + '如果最近新建/导入/封存过会议室，请带 `refresh: true` 重新查询，否则看到的是旧清单。');
+    }
     const frequent = await loadFrequentRooms(env, { refresh: input.refreshFrequent === true });
     warnings.push(...frequent.warnings);
     const busy = await fetchBusyRoomIds(env, input.beginDatetime, input.endDatetime);
@@ -195,12 +207,15 @@ export async function recommendRooms(env, input) {
             if (!input.includeBusy)
                 continue;
         }
+        let belowMinCapacity = false;
         if (memberCount !== null) {
-            // allow_maxnum = 0 视为「不限」，超出上限或低于下限都算不满足（下限只在配置了才判）
+            // allow_maxnum = 0 视为「不限」。上限不够 → 真的坐不下，必须排除。
             if (room.maxNum > 0 && room.maxNum < memberCount)
                 continue;
+            // ⚠️ 下限（建议最少人数）不满足**不再直接排除**：小会议（1~2 人）会被所有"最少 2 人"的房间全判死，
+            // 出现「可用 N 间却 0 候选」的死角（2026-10-30 真机）。改为降级候选并标注，让用户自己判断。
             if (room.minNum > 0 && room.minNum > memberCount)
-                continue;
+                belowMinCapacity = true;
         }
         if (requirement.roomAttr && room.roomAttr !== requirement.roomAttr)
             continue;
@@ -228,6 +243,10 @@ export async function recommendRooms(env, input) {
             reasons.push(`容量 ${room.maxNum} 人`);
             score += 5;
         }
+        if (belowMinCapacity) {
+            reasons.push(`该房间建议至少 ${room.minNum} 人使用（本次 ${memberCount} 人，未达建议下限，如可用请自行确认）`);
+            score -= 15;
+        }
         if (requirement.placeKeyword) {
             reasons.push(`地点匹配「${requirement.placeKeyword}」`);
             score += 10;
@@ -265,6 +284,21 @@ export async function recommendRooms(env, input) {
             return leftCap - rightCap;
         return left.name.localeCompare(right.name, 'zh-Hans-CN');
     });
+    // ⛔ 候选为空且数据来自缓存 → 缓存可能已过时（刚导入会议室、房间刚解封、容量刚改），
+    // 静默用旧缓存回答会让用户得出"系统里没有会议室/只有一间"的错误结论（2026-10-30 真机事故）。
+    // 这里自动强制重拉一次再算；只有重拉后仍为空才如实报告。不递归：refreshRooms=true 时直接跳过。
+    if (candidates.length === 0 && roomData.fromCache && input.refreshRooms !== true) {
+        const retried = await recommendRooms(env, { ...input, refreshRooms: true, refreshFrequent: true });
+        return {
+            ...retried,
+            meta: { ...retried.meta, cacheRetried: true },
+            warnings: [
+                `缓存里的会议室凑不出候选（缓存 ${Math.round((roomData.ageSeconds ?? 0) / 60)} 分钟前，`
+                    + `${roomData.rooms.length} 间）→ 已强制重新拉取台账后重算`,
+                ...retried.warnings,
+            ],
+        };
+    }
     if (candidates.length === 0) {
         if (roomData.rooms.length === 0) {
             // 2026-10-29 真机事故：0 间时只说了"放宽条件"，agent 转头去调标准版 meeting.room.list，

package/dist/shortcuts/meeting/operations/eb-fallback.js

@@ -114,6 +114,10 @@ export async function tryDegradeEbFailure(operation, error, host, ctx) {
     // 手动开关：确认某环境就是 EB 版时，关掉自动降级避免反复实探。
     if (process.env.WEAVER_MEETING_ENV_AUTOFALLBACK === '0')
         return null;
+    // 固化自用（2026-10-30）：`WEAVER_MEETING_LOCK_MODE=eb` 明确锁死 EB —— 生产环境一次接口抖动
+    // 就把模式改成 standard，后面整条链路走标准版（会议室台账、字段口径都不一样），比直接报错更难排查。
+    if (String(process.env.WEAVER_MEETING_LOCK_MODE ?? '').trim().toLowerCase() === 'eb')
+        return null;
     const type = String(error?.type ?? '');
     const subtype = String(error?.subtype ?? '');
     if (NO_FALLBACK_TYPES.has(type) || NO_FALLBACK_SUBTYPES.has(subtype))

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

@@ -136,6 +136,12 @@ async function probeAndPersist(host, ctx, knownEbError, options = {}) {
  */
 export async function resolveMeetingEnvMode(host, ctx, options = {}) {
     const session = await host.getSession();
+    // ⓪ 固化锁定（2026-10-30）：`WEAVER_MEETING_LOCK_MODE=eb` 时恒返回 EB，不读缓存、不冒烟；
+    // 只有 `refresh=true` 才允许实探（用户主动要求重新判定时）。
+    if (options.refresh !== true
+        && String(process.env.WEAVER_MEETING_LOCK_MODE ?? '').trim().toLowerCase() === 'eb') {
+        return { mode: 'eb', smokePath: EB_SMOKE_PATH, fromCache: false, assumed: true, locked: true };
+    }
     // ① refresh=true 才实探（EB 优先，失败回退标准版，结论写进缓存）。
     if (options.refresh === true) {
         return { ...(await probeAndPersist(host, ctx)), fromCache: false };