weaver-work-cli 0.1.29 → 0.1.31

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

@@ -0,0 +1,442 @@
+/**
+ * 会议附件上传（本地文件 → E10 文件服务附件 id）。
+ *
+ * 背景（2026-10-26 用户需求）：会议模块此前**没有任何上传能力**，纪要要挂 `doc_file` /
+ * `video_file` 只能借 im / mail 两条业务线的上传实现。本操作把这条能力收进会议线，
+ * 且不依赖那两个模块的代码（只复用底层 runtime 的 multipart 通道）。
+ *
+ * 口径（真机实测确认）：
+ * - 纪要附件字段 `doc_file` / `video_file` 的值就是**附件 id 字符串**（接口文档写「按文件id」）；
+ *  - 上传走 E10 通用两步式：`preUploadCheck`（按 md5 判重）→ `valid/upload`（实传）；
+ *  - 同一 md5 第二次上传会**秒传**（`uploadType=second`），直接返回已有 fileObj，不发文件体。
+ *
+ * ⚠️ 与"解析"无关：上传只负责把文件放进文件服务并拿到 id。
+ * 服务端**不会**因此启动 ASR / 文档文字提取（真机验证：81 秒内 `video_taskId`、`parse_content` 均不变），
+ * 解析由会议详情页或智能体自身能力完成，结果再写回 `minutes_content` / `parse_content`。
+ *
+ * ⚠️ 已知限制（真机 2026-10-23）：
+ * - 上传前会把整个文件读进内存，超大文件（>256MB）直接拒绝，避免把 CLI 进程打爆；
+ * - **上传超时后文件可能已经落地**：这里在超时/网络异常时自动重新预检一次（按 md5 查重），
+ *   能查到就按"已完成"返回（`recovered: true`），避免调用方重试产生重复文件。
+ */
+import { createHash } from 'node:crypto';
+import { createReadStream } from 'node:fs';
+import { readFile, stat } from 'node:fs/promises';
+import { extname, resolve } from 'node:path';
+import { meetingValidationError } from '../errors.js';
+import { meetingSuccess, SCHEMA_ID } from './types.js';
+import { listMeetingAttachments } from './attachment-content.js';
+/** 超过这个大小就别读了 —— `readFile` 会把整个文件压进内存。 */
+const MAX_BYTES = 256 * 1024 * 1024;
+/** 常见扩展名 → MIME。上传头里的类型只影响预览，猜错不影响入库。 */
+const MIME_BY_EXT = {
+    '.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    '.doc': 'application/msword',
+    '.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    '.xls': 'application/vnd.ms-excel',
+    '.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
+    '.ppt': 'application/vnd.ms-powerpoint',
+    '.pdf': 'application/pdf',
+    '.txt': 'text/plain',
+    '.md': 'text/markdown',
+    '.csv': 'text/csv',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.bmp': 'image/bmp',
+    '.mp3': 'audio/mpeg',
+    '.m4a': 'audio/mp4',
+    '.wav': 'audio/wav',
+    '.amr': 'audio/amr',
+    '.aac': 'audio/aac',
+    '.mp4': 'video/mp4',
+    '.mov': 'video/quicktime',
+    '.avi': 'video/x-msvideo',
+    '.zip': 'application/zip',
+};
+function mimeOf(name) {
+    return MIME_BY_EXT[extname(name).toLowerCase()] ?? 'application/octet-stream';
+}
+/** 流式计算 md5：不把整个文件读进内存（160MB 的会议录像也要能算出 md5）。 */
+async function md5OfFile(path) {
+    const hash = createHash('md5');
+    await new Promise((done, fail) => {
+        createReadStream(path)
+            .on('data', (chunk) => hash.update(chunk))
+            .on('end', () => done())
+            .on('error', fail);
+    });
+    return hash.digest('hex');
+}
+/**
+ * 从预检/上传响应里取附件 id。
+ *
+ * E10 文件服务在不同场景下用三套结构返回同一个东西（2026-10-26 真机实测）：
+ * - `data.uploadModuleDto.fileid` —— `module=meeting` 等**业务模块**上传/秒传时；
+ * - `data.imUploadInfoDto.fileObj.id` / `data.fileObj.id` —— im 模块；
+ * - `data.fileid` —— 部分端点扁平返回。
+ * 只认其中一种会导致"明明秒传成功却取不到 id"（我第一次就踩了这个坑）。
+ */
+function pickFileId(payload) {
+    const candidates = [
+        payload?.uploadModuleDto?.fileid,
+        payload?.uploadModuleDto?.id,
+        payload?.imUploadInfoDto?.fileObj?.id,
+        payload?.imUploadInfoDto?.fileObj?.fileid,
+        payload?.fileObj?.id,
+        payload?.fileObj?.fileid,
+        payload?.fileid,
+        payload?.id,
+    ];
+    for (const candidate of candidates) {
+        if (candidate !== undefined && candidate !== null && String(candidate).trim() !== '' && String(candidate) !== '0') {
+            return String(candidate);
+        }
+    }
+    return '';
+}
+/** 认证类错误要原样抛给调用方 —— 包装成"上传失败"会让人去查文件，方向就错了。 */
+function rethrowAuth(error) {
+    const type = error?.type;
+    if (type === 'authentication' || type === 'authorization')
+        throw error;
+}
+const meetingAttachmentUpload = {
+    name: 'meeting.attachment.upload',
+    resource: 'attachment',
+    method: 'upload',
+    action: 'meeting.attachment.upload',
+    summary: '上传本地文件到 E10 文件服务并返回附件 id（供纪要 doc_file / video_file 使用）；同 md5 自动秒传，上传超时会自动复核避免重复',
+    capability: 'attachment',
+    risk: 'read-before-write',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            file: { type: 'string', minLength: 1, description: '本地文件绝对路径（Windows 路径请用双反斜杠或正斜杠）' },
+            name: { type: 'string', description: '附件显示名，默认取文件名' },
+            module: {
+                type: 'string',
+                description: '文件归属模块（默认 meeting）。不同模块影响文件归属与可见范围，不确定就别传',
+            },
+            fileFrom: { type: 'string', description: '来源标记（默认 meeting_info），与 module 一起决定文件归属' },
+            refId: {
+                type: 'string',
+                description: '业务记录 id（如会议 id）。传了文件就**绑定到这条记录**（fileObj.refId 会回写该值）；'
+                    + '挂会议附件时必须传，否则只是孤立文件',
+            },
+            permission: { type: 'string', description: '文件权限（默认 3）' },
+            shareUsers: { type: 'string', description: '额外分享给的用户 uid，逗号分隔（可选）' },
+            shareGroups: { type: 'string', description: '额外分享给的群 id，逗号分隔（可选）' },
+            timeoutMs: {
+                type: 'integer',
+                minimum: 1000,
+                maximum: 600000,
+                description: '上传超时毫秒数（默认 300000=5 分钟；大文件务必不要调小）',
+            },
+        },
+        required: ['file'],
+    },
+    handler: async (args, env) => {
+        const startedAt = Date.now();
+        const filePath = resolve(String(args.file ?? ''));
+        if (!String(args.file ?? '').trim()) {
+            throw meetingValidationError('file_required', '必须提供本地文件路径（file）');
+        }
+        let info;
+        try {
+            info = await stat(filePath);
+        }
+        catch (error) {
+            throw meetingValidationError('file_not_found', `文件不存在或无法访问：${filePath}`, {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        if (!info.isFile()) {
+            throw meetingValidationError('file_invalid', `不是文件：${filePath}`);
+        }
+        if (info.size === 0) {
+            throw meetingValidationError('file_invalid', `文件为空（0 字节）：${filePath}`);
+        }
+        if (info.size > MAX_BYTES) {
+            throw meetingValidationError('file_too_large', `文件 ${(info.size / 1048576).toFixed(1)}MB 超过上限 ${MAX_BYTES / 1048576}MB（当前实现会把整文件读入内存）。`
+                + '请先压缩/切片，或等 CLI 支持流式上传后再传', { size: info.size, maxBytes: MAX_BYTES });
+        }
+        const name = String(args.name ?? '').trim() || filePath.split(/[\\/]/).pop() || 'attachment';
+        const module = String(args.module ?? '').trim() || 'meeting';
+        const fileFrom = String(args.fileFrom ?? '').trim() || 'meeting_info';
+        const permission = String(args.permission ?? '').trim() || '3';
+        const shareUsers = String(args.shareUsers ?? '');
+        const shareGroups = String(args.shareGroups ?? '');
+        const timeoutMs = typeof args.timeoutMs === 'number' ? args.timeoutMs : 300_000;
+        const mime = mimeOf(name);
+        const md5 = await md5OfFile(filePath);
+        const baseFields = {
+            module,
+            fileFrom,
+            ...(String(args.refId ?? '').trim() ? { refId: String(args.refId).trim() } : {}),
+            size: String(info.size),
+            name,
+            lastModified: String(Math.round(info.mtimeMs)),
+            lastModifiedDate: String(Math.round(info.mtimeMs)),
+            MD5: md5,
+            permission,
+            shareUsers,
+            shareGroups,
+            shareExternals: '',
+            compressImg: 'false',
+            createDoc: 'false',
+        };
+        /** 预检：按 md5 判断是否秒传；返回 preUploadId（需要实传时）或已有 fileId（秒传时）。 */
+        const precheck = async () => {
+            const form = new FormData();
+            for (const [key, value] of Object.entries(baseFields))
+                form.append(key, value);
+            const response = (await env.host.request({
+                method: 'POST',
+                path: '/api/file/preUploadCheck',
+                formData: form,
+                operation: 'meeting.attachment.upload.check',
+                timeoutMs: 120_000,
+                acceptBusiness: () => true,
+            }));
+            const data = response?.data ?? {};
+            return {
+                preUploadId: data.preUploadId ? String(data.preUploadId) : '',
+                uploadType: String(data.uploadType ?? ''),
+                existingId: pickFileId(data),
+            };
+        };
+        let prepared;
+        try {
+            prepared = await precheck();
+        }
+        catch (error) {
+            rethrowAuth(error);
+            throw meetingValidationError('upload_check_failed', `上传预检失败（未上传任何内容）：${error instanceof Error ? error.message : String(error)}`, { file: filePath, size: info.size });
+        }
+        // 秒传命中：文件已在文件服务里（同 md5），直接用已有 id
+        if (prepared.existingId) {
+            return meetingSuccess('meeting.attachment.upload', {
+                fileId: prepared.existingId,
+                name,
+                size: info.size,
+                md5,
+                module,
+                uploadType: prepared.uploadType || 'second',
+                reused: true,
+                recovered: false,
+                durationMs: Date.now() - startedAt,
+                next: `把 fileId 传给 meeting.eb.minute.create/update 的 doc_file（文档）或 video_file（音频）`,
+            }, { warnings: ['该文件已存在于 E10 文件服务（md5 相同），已直接复用，未重复上传'] });
+        }
+        if (!prepared.preUploadId) {
+            throw meetingValidationError('upload_check_failed', '上传预检未返回 preUploadId（也无法按 md5 复用），无法继续上传', { file: filePath, size: info.size, uploadType: prepared.uploadType });
+        }
+        const buffer = await readFile(filePath);
+        const uploadForm = new FormData();
+        uploadForm.append('data', new Blob([buffer], { type: mime }), name);
+        for (const [key, value] of Object.entries({
+            ...baseFields,
+            preUploadId: prepared.preUploadId,
+            uploadType: prepared.uploadType || 'common',
+        })) {
+            uploadForm.append(key, value);
+        }
+        let uploaded;
+        try {
+            uploaded = (await env.host.request({
+                method: 'POST',
+                path: '/api/file/valid/upload',
+                formData: uploadForm,
+                operation: 'meeting.attachment.upload.do',
+                timeoutMs,
+                acceptBusiness: () => true,
+            }));
+        }
+        catch (error) {
+            // ⚠️ 超时/断连时文件**可能已经落地**。重新预检一次，能按 md5 查到就当作成功，
+            // 否则调用方会重试 → 同一份文件传两遍。
+            rethrowAuth(error);
+            let recoveredId = '';
+            try {
+                const retry = await precheck();
+                recoveredId = retry.existingId;
+            }
+            catch {
+                recoveredId = '';
+            }
+            if (recoveredId) {
+                return meetingSuccess('meeting.attachment.upload', {
+                    fileId: recoveredId,
+                    name,
+                    size: info.size,
+                    md5,
+                    module,
+                    uploadType: 'second',
+                    reused: false,
+                    recovered: true,
+                    durationMs: Date.now() - startedAt,
+                }, {
+                    warnings: [
+                        `上传请求报错（${error instanceof Error ? error.message : String(error)}），但复核发现文件已落地，按成功返回；`
+                            + '请勿重复上传',
+                    ],
+                });
+            }
+            throw meetingValidationError('upload_failed', `上传失败且复核未查到文件：${error instanceof Error ? error.message : String(error)}`, { file: filePath, size: info.size, md5 });
+        }
+        const data = uploaded?.data ?? {};
+        const fileId = pickFileId(data);
+        if (!fileId) {
+            throw meetingValidationError('upload_failed', `上传接口未返回附件 id：${JSON.stringify(data).slice(0, 200)}`, { file: filePath, size: info.size, md5 });
+        }
+        return meetingSuccess('meeting.attachment.upload', {
+            fileId,
+            name,
+            size: info.size,
+            md5,
+            module,
+            uploadType: prepared.uploadType || 'common',
+            reused: false,
+            recovered: false,
+            fileObj: data.fileObj ?? data.imUploadInfoDto?.fileObj ?? null,
+            durationMs: Date.now() - startedAt,
+            next: '把 fileId 传给 meeting.eb.minute.create/update 的 doc_file（文档）或 video_file（音频）',
+        });
+    },
+};
+/** 计算挂载后的附件 id 列表（纯函数，便于单测）。 */
+export function computeAttachIds(mode, existingIds, incomingId) {
+    return mode === 'replace' ? [incomingId] : [...new Set([...existingIds, incomingId])];
+}
+const meetingAttachmentAttach = {
+    name: 'meeting.attachment.attach',
+    resource: 'attachment',
+    method: 'attach',
+    action: 'meeting.attachment.attach',
+    summary: '把本地文件（或已上传的 fileId）挂成会议附件：上传带 refId 绑定记录，并把**文件 id 列表**写进 mt_accessorys；默认追加（保留已有附件）',
+    capability: 'attachment',
+    risk: 'high-risk-write',
+    inputSchema: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            id: { ...SCHEMA_ID, description: '会议 id' },
+            file: { type: 'string', description: '本地文件路径（与 fileId 二选一）' },
+            fileId: { type: 'string', description: '已上传的附件 id（与 file 二选一，跳过上传）' },
+            name: { type: 'string', description: '附件显示名（file 模式默认取文件名；fileId 模式可省略，仅用于日志）' },
+            mode: {
+                type: 'string',
+                enum: ['append', 'replace'],
+                description: 'append（默认）保留会议已有附件、把本次文件追加进列表；replace 用本次文件**覆盖**整个附件列表。'
+                    + '现有附件 id 由 CLI 自动读取（query_mtDetail_info 的 mt_accessorys 就是 fileId 列表）',
+            },
+            existingFileIds: {
+                type: 'array',
+                items: { type: 'string' },
+                description: '可选：显式指定“现有附件 id”。不传时 CLI 自己读，通常不需要填',
+            },
+        },
+        required: ['id'],
+    },
+    handler: async (args, env) => {
+        const startedAt = Date.now();
+        const meetingId = String(args.id ?? '').trim();
+        if (!meetingId)
+            throw meetingValidationError('id_required', '必须提供会议 id（id）');
+        const filePath = String(args.file ?? '').trim();
+        const incomingFileId = String(args.fileId ?? '').trim();
+        if (!filePath && !incomingFileId) {
+            throw meetingValidationError('file_required', 'file 与 fileId 至少要给一个');
+        }
+        const explicitIds = Array.isArray(args.existingFileIds)
+            ? args.existingFileIds.map((item) => String(item).trim()).filter(Boolean)
+            : [];
+        // 读会议当前附件：必须走 `query_mtDetail_info`（`meeting.eb.meeting.list` **不投影**
+        // `mt_accessorys` / `project_files`，读出来恒为空 —— 这也是旧版误判"读回来是文件名"的根源之一）。
+        let beforeIds = [];
+        let beforeRefsLookLikeNames = false;
+        try {
+            const current = await listMeetingAttachments(env, meetingId);
+            beforeIds = current.refs.filter((ref) => ref.idLike).map((ref) => ref.fileId);
+            beforeRefsLookLikeNames = current.refs.some((ref) => !ref.idLike);
+        }
+        catch {
+            // 读不到就按空处理，后面会在 warnings 里提示
+        }
+        if (beforeRefsLookLikeNames && explicitIds.length === 0) {
+            // 服务端此刻返回的是文件名（写后立即读会出现），拿不到 id 就不能安全追加：
+            // 硬写会把原附件冲掉，这里直接拒绝并给出可执行建议。
+            throw meetingValidationError('attachment_id_unavailable', '会议当前附件返回的是文件名而不是 id（服务端在刚写完时会这样），无法安全追加。'
+                + '请稍后重试，或显式传 existingFileIds；确实要覆盖请用 mode="replace"', { id: meetingId });
+        }
+        // 默认 **append**：智能体里补传附件时，最怕把会议已有附件冲掉。
+        // 现有 id 由 CLI 自己读（`query_mtDetail_info` 的 `mt_accessorys` 本身就是 fileId 列表），
+        // 不再要求调用方传 existingFileIds（旧口径说"读回来是文件名"是误判）。
+        const mode = String(args.mode ?? '').trim() === 'replace' ? 'replace' : 'append';
+        const existingIds = explicitIds.length > 0 ? explicitIds : [];
+        if (mode === 'append' && existingIds.length === 0) {
+            existingIds.push(...beforeIds);
+        }
+        const { getMeetingOperation } = await import('./registry.js');
+        const list = getMeetingOperation('meeting.eb.meeting.list');
+        // 1) 需要的话先上传（带 refId 绑定到该会议）
+        let fileId = incomingFileId;
+        let name = String(args.name ?? '').trim();
+        let uploaded = null;
+        if (filePath) {
+            const uploadOp = getMeetingOperation('meeting.attachment.upload');
+            const result = await uploadOp.handler({ file: filePath, refId: meetingId, name: name || undefined }, env);
+            fileId = String(result.data.fileId);
+            name = name || String(result.data.name ?? '');
+            uploaded = { fileId, reused: Boolean(result.data.reused), durationMs: Number(result.data.durationMs ?? 0) };
+        }
+        // 2) mt_accessorys 里存的是**文件 id 列表**（读接口返回的是文件名）
+        const nextIds = computeAttachIds(mode, existingIds, fileId);
+        const prepare = getMeetingOperation('meeting.eb.meeting.change.prepare');
+        const apply = getMeetingOperation('meeting.eb.meeting.change.apply');
+        const prepared = await prepare.handler({ id: meetingId, operate_type: 'CHANGE', mt_accessorys: nextIds.join(',') }, env);
+        await apply.handler({ confirm: true, continuation: prepared?.data?.continuation }, env);
+        // 3) 回读校验：按 fileId 数量核对（不依赖 list 的文本渲染）
+        let afterIds = [];
+        let afterHasNames = false;
+        try {
+            const after = await listMeetingAttachments(env, meetingId);
+            afterIds = after.refs.filter((ref) => ref.idLike).map((ref) => ref.fileId);
+            afterHasNames = after.refs.some((ref) => !ref.idLike);
+        }
+        catch {
+            // 回读失败不判定失败，只提示
+        }
+        const warnings = [];
+        if (mode === 'replace' && beforeIds.length > 0) {
+            const replaced = explicitIds.length > 0 ? explicitIds : beforeIds;
+            warnings.push(`mode=replace 已**覆盖**原有 ${replaced.length} 个附件（${replaced.join('、')}）；`
+                + '如需保留原有附件，改用默认的 mode=append');
+        }
+        // 写后立即读可能返回文件名（数量仍可数），此时按 refs 总数比较，不误报
+        const afterCount = afterHasNames ? afterIds.length + 0 : afterIds.length;
+        if (!afterHasNames && afterCount !== nextIds.length) {
+            warnings.push(`回读附件数（${afterIds.length}）与写入 id 数（${nextIds.length}）不一致：`
+                + '可能是某个 id 不存在或不属于当前模块，请到页面核对');
+        }
+        return meetingSuccess('meeting.attachment.attach', {
+            id: meetingId,
+            fileId,
+            name: name || null,
+            mode,
+            writtenFileIds: nextIds,
+            accessors: afterIds,
+            accessorNamesResolved: !afterHasNames,
+            previousAccessors: beforeIds,
+            uploaded,
+            durationMs: Date.now() - startedAt,
+        }, warnings.length > 0 ? { warnings } : undefined);
+    },
+};
+export const meetingAttachmentOperations = [
+    meetingAttachmentUpload,
+    meetingAttachmentAttach,
+];

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

@@ -0,0 +1,57 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { meetingStateDir } from '../env.js';
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+function cacheDir(env) {
+    return join(meetingStateDir(env.ctx), 'cache');
+}
+function cacheFile(env, key) {
+    return join(cacheDir(env), `${key}.json`);
+}
+async function identity(env) {
+    try {
+        const session = await env.host.getSession();
+        return {
+            baseUrl: String(session?.baseUrl ?? ''),
+            tenantKey: String(session?.tenantKey ?? ''),
+        };
+    }
+    catch {
+        return { baseUrl: '', tenantKey: '' };
+    }
+}
+export async function readCache(env, key, options = {}) {
+    try {
+        const raw = await readFile(cacheFile(env, key), 'utf8');
+        const parsed = JSON.parse(raw);
+        const current = await identity(env);
+        if (parsed.baseUrl !== current.baseUrl || parsed.tenantKey !== current.tenantKey)
+            return null;
+        const ageMs = Date.now() - Number(parsed.savedAt || 0);
+        const ttl = options.ttlMs ?? DEFAULT_TTL_MS;
+        if (!Number.isFinite(ageMs) || ageMs < 0 || ageMs > ttl)
+            return null;
+        return { data: parsed.data, savedAt: parsed.savedAt, ageMs };
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeCache(env, key, data) {
+    try {
+        const current = await identity(env);
+        const payload = { savedAt: Date.now(), baseUrl: current.baseUrl, tenantKey: current.tenantKey, data };
+        const file = cacheFile(env, key);
+        await mkdir(dirname(file), { recursive: true });
+        await writeFile(file, JSON.stringify(payload), 'utf8');
+    }
+    catch {
+        // 缓存写失败不影响业务
+    }
+}
+/** 缓存 key 后缀：按租户隔离，避免多环境共用同一份会议室表。 */
+export async function cacheScopeSuffix(env) {
+    const { baseUrl, tenantKey } = await identity(env);
+    const host = baseUrl.replace(/^https?:\/\//, '').replace(/[^0-9a-zA-Z]+/g, '-');
+    return `${host || 'local'}-${tenantKey || 'unknown'}`;
+}