weaver-work-cli 0.1.8 → 0.1.21

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

@@ -0,0 +1,389 @@
+import { createHash } from 'node:crypto';
+import { meetingConfirmationError, meetingPartialError, meetingValidationError } from '../../errors.js';
+import { meetingSuccess, SCHEMA_ID } from '../types.js';
+import { assertDateTimeMinute, toIdString } from '../shared.js';
+import { isWriteKind } from './catalog.js';
+/** EB（eBuilder formdata）通用路径前缀（资料核实）。 */
+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' };
+const CONTINUATION_TTL_SECONDS = 600;
+/**
+ * EB 响应成功判定。
+ * EB 的响应体与标准版不同：成功时顶层常为 `{datajson:{...}}`（可能不带 status/code），
+ * 失败时返回 `code=100000/100001`；写操作以 `datajson.status` 表示成败。
+ * 因此不能直接套用标准版的 `isBusinessSuccess`（会误判成功响应为业务失败）。
+ */
+export function ebBusinessSuccess(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    if (value.code !== undefined && value.code !== null)
+        return Number(value.code) === 200;
+    if (value.datajson && typeof value.datajson === 'object') {
+        const status = value.datajson.status;
+        return status !== false;
+    }
+    return value.status === true;
+}
+/**
+ * 稳定序列化：对象递归**按键名排序**。
+ *
+ * `fingerprint` 用于判断「apply 的提交内容是否与 prepare 快照一致」，必须**只对内容敏感、
+ * 对键顺序不敏感** —— 否则同一份 payload 只要键顺序不同就会被误判为 `target_changed`。
+ * 2026-09-20 真机首次 apply 即踩到：prepare 与 apply 两条路径产出的键顺序不同
+ * （`hrm_members` 位置不同），字段与值完全相同却被拒绝，导致 EB 建会无法完成。
+ */
+function stableStringify(value) {
+    if (Array.isArray(value))
+        return `[${value.map(stableStringify).join(',')}]`;
+    if (value && typeof value === 'object') {
+        const entries = Object.entries(value)
+            .filter(([, item]) => item !== undefined)
+            .sort(([left], [right]) => left.localeCompare(right));
+        return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`).join(',')}}`;
+    }
+    return JSON.stringify(value ?? null);
+}
+function fingerprint(value) {
+    return createHash('sha256').update(stableStringify(value)).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';
+}
+/**
+ * 查询接口 body（list/count）：必须带 datajson，筛选走 URL query。
+ *
+ * ⚠️ `mainTable` 节点**必须存在**（空对象即可）：缺失时 EB 服务端直接返回
+ * “mainTable解析异常,请参照文档修正数据格式”（2026-09-20 真机实测）。
+ * 该缺陷曾导致 CLI 的 EB 读操作全线失败，并连带使 `meeting.env.detect` 的 EB 冒烟失败、
+ * 环境被误判为 standard 版。
+ */
+export function queryBody(userId) {
+    return { datajson: { mainTable: {}, header: { operator: userId } } };
+}
+/** 详情接口 body（getFormDataByPk）：顶层 mainTable 传 id。 */
+function detailBody(userId, id) {
+    return { datajson: { mainTable: { id }, header: { operator: userId } } };
+}
+/** 写操作 body：datas 数组包裹 mainTable（漏用 datas 会报 datas 节点未找到）。 */
+function writeBody(userId, mainTable) {
+    return {
+        datajson: {
+            operationinfo: { printCost: false, asyncPostProcess: false, asyncMark: false },
+            datas: [{ mainTable }],
+            header: { operator: userId },
+        },
+    };
+}
+/** 从 EB 响应中取数据行数组（兼容 datajson.datas / data.displayData / datajson.data）。 */
+export function extractEbRows(response) {
+    const value = response;
+    const dj = value?.datajson ?? value?.data ?? {};
+    const raw = dj?.datas ?? dj?.data ?? dj?.displayData ?? (Array.isArray(dj) ? dj : undefined);
+    if (Array.isArray(raw)) {
+        const total = typeof dj?.total === 'number' ? dj.total : typeof value?.total === 'number' ? value.total : undefined;
+        return { rows: raw, ...(total === undefined ? {} : { total }) };
+    }
+    return { rows: [] };
+}
+/** 从 count 响应中取总数（datajson.datas 为数值）。 */
+export function extractEbCount(response) {
+    const value = response;
+    const dj = value?.datajson ?? value?.data ?? {};
+    const raw = dj?.datas ?? dj?.total ?? value?.total;
+    if (typeof raw === 'number')
+        return raw;
+    if (typeof raw === 'string' && /^\d+$/u.test(raw))
+        return Number(raw);
+    if (Array.isArray(raw))
+        return raw.length;
+    return undefined;
+}
+function buildReadInputSchema(endpoint) {
+    const properties = {};
+    if (endpoint.kind === 'detail') {
+        properties.id = { ...SCHEMA_ID, description: '数据主键 id' };
+    }
+    else if (endpoint.kind === 'list') {
+        for (const param of endpoint.queryParams ?? []) {
+            properties[param] = { type: 'string', description: `EB 筛选参数（URL 占位符名 ${param}）` };
+        }
+        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，条件与列表一致）' };
+        }
+    }
+    return {
+        type: 'object',
+        additionalProperties: false,
+        properties,
+        ...(endpoint.kind === 'detail' ? { required: ['id'] } : {}),
+    };
+}
+function buildReadOperation(endpoint) {
+    const readOp = EB_READ_OP[endpoint.kind];
+    const capability = `eb.${endpoint.domain}`;
+    return {
+        name: endpoint.operation,
+        resource: 'eb',
+        method: endpoint.operation,
+        action: endpoint.operation,
+        summary: endpoint.summary,
+        capability,
+        risk: 'read',
+        inputSchema: buildReadInputSchema(endpoint),
+        handler: async (args, env) => {
+            const session = await env.host.getSession();
+            const acceptBusiness = ebBusinessSuccess;
+            const path = `${EB_BASE}/${readOp}/${endpoint.interfacePk}`;
+            if (endpoint.kind === 'detail') {
+                const id = toIdString(args.id, 'id');
+                const response = await env.host.request({
+                    method: 'POST',
+                    path,
+                    operation: endpoint.operation,
+                    body: detailBody(session.userId, id),
+                    acceptBusiness,
+                });
+                const data = response?.datajson?.mainTable ?? response?.datajson ?? response;
+                return meetingSuccess(endpoint.operation, { id, data }, endpoint.notes ? { meta: { notes: endpoint.notes } } : {});
+            }
+            const query = {};
+            for (const param of endpoint.queryParams ?? []) {
+                const value = args[param];
+                if (value !== undefined && value !== null && value !== '')
+                    query[param] = value;
+            }
+            if (endpoint.kind === 'get') {
+                const response = await env.host.request({
+                    method: 'POST',
+                    path,
+                    operation: endpoint.operation,
+                    body: queryBody(session.userId),
+                    acceptBusiness,
+                });
+                const { rows } = extractEbRows(response);
+                const data = rows[0] ?? response?.datajson ?? null;
+                return meetingSuccess(endpoint.operation, { data, count: rows.length }, endpoint.notes ? { meta: { notes: endpoint.notes } } : {});
+            }
+            const pageNo = typeof args.pageNo === 'number' ? args.pageNo : 1;
+            const pageSize = typeof args.pageSize === 'number' ? args.pageSize : 20;
+            let total;
+            if (endpoint.countPk && args.withCount !== false) {
+                const countResponse = await env.host.request({
+                    method: 'POST',
+                    path: `${EB_BASE}/getFormDataCount/${endpoint.countPk}`,
+                    operation: endpoint.operation,
+                    query,
+                    body: queryBody(session.userId),
+                    acceptBusiness,
+                });
+                total = extractEbCount(countResponse);
+            }
+            const response = await env.host.request({
+                method: 'POST',
+                path,
+                operation: endpoint.operation,
+                query: { ...query, pageNo, pageSize },
+                body: queryBody(session.userId),
+                acceptBusiness,
+            });
+            const { rows, total: listTotal } = extractEbRows(response);
+            return meetingSuccess(endpoint.operation, {
+                total: total ?? listTotal ?? rows.length,
+                pageNo,
+                pageSize,
+                count: rows.length,
+                rows,
+                filters: query,
+            }, endpoint.notes ? { meta: { notes: endpoint.notes } } : {});
+        },
+    };
+}
+/** 计算小时差（支持小数，如 1.5），用于 create_meeting 的 mt_hours。 */
+function diffHours(begin, end) {
+    const parse = (text) => {
+        const matched = text.match(/^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2})$/u);
+        if (!matched)
+            return undefined;
+        const [, y, mo, d, h, mi] = matched;
+        return Date.UTC(Number(y), Number(mo) - 1, Number(d), Number(h), Number(mi));
+    };
+    const from = parse(begin);
+    const to = parse(end);
+    if (from === undefined || to === undefined)
+        return undefined;
+    const hours = (to - from) / 3_600_000;
+    return hours > 0 ? Math.round(hours * 100) / 100 : undefined;
+}
+/** 写操作字段归一化：白名单过滤 + 日期格式校验 + 必填校验 + 会议建会特化默认值。 */
+function normalizeEbWrite(endpoint, args, userId) {
+    const fields = endpoint.kind === 'delete' ? ['id'] : endpoint.fields ?? [];
+    const out = {};
+    for (const field of fields) {
+        const value = args[field];
+        if (value === undefined || value === null || value === '')
+            continue;
+        if ((endpoint.dateFields ?? []).includes(field)) {
+            out[field] = assertDateTimeMinute(value, field);
+        }
+        else {
+            out[field] = value;
+        }
+    }
+    if (endpoint.interfacePk === 'create_meeting') {
+        if (out.caller === undefined)
+            out.caller = userId;
+        if (out.contacter === undefined)
+            out.contacter = userId;
+        const hours = typeof out.begin_datetime === 'string' && typeof out.end_datetime === 'string'
+            ? diffHours(out.begin_datetime, out.end_datetime)
+            : undefined;
+        if (hours !== undefined)
+            out.mt_hours = hours;
+    }
+    const required = endpoint.kind === 'delete' ? ['id'] : endpoint.requiredFields ?? [];
+    const missing = required.filter((field) => out[field] === undefined);
+    if (missing.length > 0) {
+        throw meetingValidationError('missing_required_field', `缺少必填字段：${missing.join(', ')}`, { missing });
+    }
+    return out;
+}
+function buildWriteInputSchema(endpoint, includeConfirm) {
+    const properties = {};
+    if (includeConfirm) {
+        properties.confirm = { const: true };
+        properties.continuation = { type: 'string', minLength: 1 };
+    }
+    if (endpoint.kind === 'delete') {
+        properties.id = { ...SCHEMA_ID, description: '数据主键 id（必填）' };
+    }
+    else {
+        for (const field of endpoint.fields ?? []) {
+            const isDate = (endpoint.dateFields ?? []).includes(field);
+            const required = (endpoint.requiredFields ?? []).includes(field);
+            properties[field] = isDate
+                ? { type: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}$', description: `${field}（yyyy-MM-dd HH:mm，不带秒）` }
+                : { type: 'string', description: `${field}${required ? '（必填）' : ''}` };
+        }
+    }
+    const requiredBase = endpoint.kind === 'delete' ? ['id'] : endpoint.requiredFields ?? [];
+    return {
+        type: 'object',
+        additionalProperties: false,
+        properties,
+        required: includeConfirm ? ['confirm', 'continuation', ...requiredBase] : requiredBase,
+    };
+}
+function buildWriteOperations(endpoint, preflight) {
+    const prepareName = `${endpoint.operation}.prepare`;
+    const applyName = `${endpoint.operation}.apply`;
+    const writeOp = EB_WRITE_OP[endpoint.kind];
+    const path = `${EB_BASE}/${writeOp}/${endpoint.interfacePk}`;
+    const capability = `eb.${endpoint.domain}`;
+    const acceptBusiness = ebBusinessSuccess;
+    const prepare = {
+        name: prepareName,
+        resource: 'eb',
+        method: prepareName,
+        action: prepareName,
+        summary: `准备${endpoint.summary}（生成确认预览，不写入）`,
+        capability,
+        risk: 'read-before-write',
+        requiresConfirmation: true,
+        inputSchema: buildWriteInputSchema(endpoint, false),
+        handler: async (args, env) => {
+            const session = await env.host.getSession();
+            const payload = normalizeEbWrite(endpoint, args, session.userId);
+            // EB 版建会缺少强制冲突检测会重复占用会议室/参会人撞会，故 prepare 阶段由钩子补齐。
+            const warnings = preflight ? await preflight({ endpoint, args, payload, env }) : [];
+            const token = await env.continuation.issue({
+                operation: applyName,
+                baseUrl: session.baseUrl,
+                profile: session.profile,
+                userId: session.userId,
+                payload,
+                fingerprint: fingerprint(payload),
+            }, CONTINUATION_TTL_SECONDS * 1000);
+            return meetingSuccess(prepareName, {
+                status: 'AWAITING_CONFIRMATION',
+                preview: {
+                    interfacePk: endpoint.interfacePk,
+                    kind: endpoint.kind,
+                    body: payload,
+                    path,
+                    notes: endpoint.notes ?? [],
+                },
+                continuation: token,
+                expiresInSeconds: CONTINUATION_TTL_SECONDS,
+            }, warnings.length > 0 ? { warnings } : {});
+        },
+    };
+    const apply = {
+        name: applyName,
+        resource: 'eb',
+        method: applyName,
+        action: applyName,
+        summary: `提交${endpoint.summary}（${writeOp}，body 用 datas 数组）；必须在用户明确确认后调用`,
+        capability,
+        risk: 'high-risk-write',
+        requiresConfirmation: true,
+        inputSchema: buildWriteInputSchema(endpoint, true),
+        handler: async (args, env) => {
+            requireConfirm(args, applyName);
+            const lease = await verifyLease(args, applyName, env);
+            const session = await env.host.getSession();
+            const payload = normalizeEbWrite(endpoint, args, session.userId);
+            if (lease.fingerprint !== fingerprint(payload)) {
+                // 带上两侧快照：`target_changed` 否则无从判断到底哪个字段变了（排查成本极高）。
+                throw meetingValidationError('target_changed', '提交内容与 prepare 时的快照不一致，请重新执行 prepare', { expected: lease.payload, actual: payload });
+            }
+            let response;
+            try {
+                response = await env.host.request({
+                    method: 'POST',
+                    path,
+                    operation: applyName,
+                    body: writeBody(session.userId, payload),
+                    acceptBusiness,
+                });
+            }
+            catch (error) {
+                if (isNetworkError(error)) {
+                    const written = endpoint.kind === 'delete' ? '删除' : '写入';
+                    throw meetingPartialError(`${endpoint.interfacePk} ${written}请求发送后连接中断，是否已生效不确定，禁止自动重试，请回查确认后再决定`, { attempted: { interfacePk: endpoint.interfacePk, body: payload } }, { stage: endpoint.operation });
+                }
+                throw error;
+            }
+            const dj = response?.datajson ?? {};
+            if (dj.status === false) {
+                throw meetingValidationError('eb_write_not_applied', `${endpoint.interfacePk} 返回 status=false，服务端未生效，请核对字段与权限后重试`);
+            }
+            return meetingSuccess(applyName, {
+                status: 'COMPLETE',
+                interfacePk: endpoint.interfacePk,
+                dataIds: dj.dataIds ?? dj.ids ?? undefined,
+                result: response,
+            });
+        },
+    };
+    return [prepare, apply];
+}
+/** 把声明式目录转换为可注册的 operation 列表（读=1 个，写=prepare+apply 2 个）。 */
+export function buildEbOperations(endpoints, options = {}) {
+    return endpoints.flatMap((endpoint) => (isWriteKind(endpoint.kind) ? buildWriteOperations(endpoint, options.preflight) : [buildReadOperation(endpoint)]));
+}

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

@@ -0,0 +1,22 @@
+import { EB_ENDPOINTS } from './catalog.js';
+import { buildEbOperations } from './factory.js';
+import { ebMeetingWritePreflight, meetingEbConflictOperations } from './conflict.js';
+/**
+ * 会议 EB 版（eBuilder）operations。
+ *
+ * 目录 `catalog.ts` 覆盖 EB 版全部 interfacePk（会议 6.x / 会议室 2.x / 占用 5.x /
+ * 签到 1.x / 回执 4.x / 纪要 3.x / 会议类型 3.5 / 议题类型 8.x / 会议议题 9.x / 应用设置 7.x），
+ * 读操作 1 个 interfacePk → 1 个 operation，写操作 → prepare + apply 两个 operation
+ * （沿用标准版的确认链约定）。
+ *
+ * 冲突检测（2026-09-20 补齐）：
+ * - `ebMeetingWritePreflight` 挂到 prepare 阶段 → 建会/变更前强制执行会议室与参会人冲突检测
+ *   （与标准版 create.prepare 的 runMandatoryConflictChecks 语义对齐：命中禁止提交直接拒绝、
+ *   仅提醒只给 warnings、检测失败视为冲突）；
+ * - `meetingEbConflictOperations` 另提供「只查不建」的 `meeting.eb.conflict.room` /
+ *   `meeting.eb.conflict.member`（后者为 2 次请求方案，无 N+1）。
+ */
+export const meetingEbOperations = [
+    ...buildEbOperations(EB_ENDPOINTS, { preflight: ebMeetingWritePreflight }),
+    ...meetingEbConflictOperations,
+];

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

@@ -4,6 +4,7 @@ import { homedir } from 'node:os';
 import { resolve } from 'node:path';
 import { meetingValidationError } from '../errors.js';
 import { meetingSuccess, SCHEMA_ID } from './types.js';
+import { ebBusinessSuccess } from './eb/factory.js';
 // ---------------------------------------------------------------------------
 // 环境模式探测（EB 版 / 标准版）——按 baseUrl 固化缓存，对齐 standalone 行为
 // ---------------------------------------------------------------------------
@@ -87,7 +88,13 @@ const meetingEnvDetect = {
                 method: 'POST',
                 path: EB_SMOKE_PATH,
                 operation: 'meeting.env.detect',
-                body: { datajson: { header: { operator: session.userId } } },
+                // EB list 的 datajson 内必须出现 mainTable 节点（空对象即可）：缺失时服务端报
+                // “mainTable解析异常,请参照文档修正数据格式”，冒烟会**假失败**并把 EB 环境误判为
+                // 标准版（2026-09-20 真机复现）。
+                body: { datajson: { mainTable: {}, header: { operator: session.userId } } },
+                // EB 响应不含 code/status（形如 {datajson:{datas:[...]}}），默认的 isBusinessSuccess
+                // 会判为 false → 冒烟假失败 → EB 环境被误判为标准版。
+                acceptBusiness: ebBusinessSuccess,
             });
             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);

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

@@ -9,6 +9,7 @@ import { meetingCreateOperations } from './create.js';
 import { meetingLifecycleOperations } from './lifecycle.js';
 import { meetingReceiptOperations } from './receipts.js';
 import { meetingSignOperations } from './signs.js';
+import { meetingEbOperations } from './eb/index.js';
 function buildRegistry() {
     const registry = new Map();
     const definitions = [
@@ -22,6 +23,7 @@ function buildRegistry() {
         ...meetingChangeOperations,
         ...meetingReceiptOperations,
         ...meetingSignOperations,
+        ...meetingEbOperations,
     ];
     for (const definition of definitions) {
         if (registry.has(definition.name)) {