weaver-work-cli 0.1.8 → 0.1.21

package/dist/shortcuts/blog/operations/edit.js

@@ -0,0 +1,131 @@
+import { blogConfirmationError, blogPartialError, blogValidationError, isBlogNetworkError, } from '../errors.js';
+import { asDate, ensureHtml, fetchDetailsByDate, htmlToText, objectFingerprint, resolveTargetUser, sessionMatches, } from './shared.js';
+import { workflow } from './types.js';
+/** 编辑 prepare：回查原内容 + 差异摘要 + 目标指纹，签发 continuation */
+export class BlogEditPrepareOperation {
+    name = 'blog.edit.prepare';
+    async execute(input, { host, continuation }) {
+        const date = asDate(input.date, 'date');
+        const rawContent = typeof input.content === 'string' ? input.content.trim() : '';
+        if (!rawContent)
+            throw blogValidationError('input_invalid', 'content 必须是非空字符串');
+        const content = ensureHtml(rawContent);
+        const { userId, userName } = await resolveTargetUser(input, host);
+        const detail = await fetchDetailsByDate(host, date, userId);
+        if (!detail.found || !detail.blog) {
+            throw blogValidationError('edit_target_missing', `对应日期 ${date} 人员 ${userName ?? userId} 无日报，不可编辑；如需新建请使用 blog.publish.prepare`);
+        }
+        const original = detail.blog;
+        const originalText = htmlToText(original.content);
+        const newText = htmlToText(content);
+        if (originalText === newText) {
+            throw blogValidationError('changes_noop', '新内容与当前日报内容相同');
+        }
+        const session = await host.getSession();
+        const continuationToken = await continuation.issue({
+            operation: 'blog.edit.apply',
+            workflow: workflow('blog.edit', 'AWAITING_CONFIRMATION'),
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            date,
+            targetUserId: userId,
+            blogId: original.id,
+            content,
+            fingerprint: objectFingerprint(original),
+        });
+        return {
+            status: 'AWAITING_CONFIRMATION',
+            data: {
+                date,
+                target: { user_id: userId, name: userName },
+                blog_id: original.id,
+                original: { content: original.content, content_text: originalText, submit_time: original.create_time_str },
+                new: { content, content_text: newText },
+                continuation: continuationToken,
+                expires_in_seconds: 600,
+                workflow: workflow('blog.edit', 'AWAITING_CONFIRMATION'),
+                next: '向用户复述原内容与新内容，用户确认后调用 blog.edit.apply 并传 confirm=true',
+            },
+        };
+    }
+}
+/** 编辑 apply：确认 + continuation + 目标指纹校验 + 写后回查内容一致性 */
+export class BlogEditApplyOperation {
+    name = 'blog.edit.apply';
+    async execute(input, { host, continuation }) {
+        if (input.confirm !== true) {
+            throw blogConfirmationError('blog.edit.apply', { hint: '重新调用时传入 confirm=true' });
+        }
+        const lease = await continuation.verify(input.continuation, 'blog.edit.apply');
+        if (typeof lease.blogId !== 'string' || typeof lease.content !== 'string' || typeof lease.fingerprint !== 'string') {
+            throw blogValidationError('continuation_invalid', '编辑 continuation 缺少有效目标、内容或指纹');
+        }
+        const session = await host.getSession();
+        if (!sessionMatches(lease, session)) {
+            throw blogValidationError('context_mismatch', '确认上下文已变化，请重新准备编辑');
+        }
+        // 目标指纹校验：确认期间日报被他人/自己改过则拒绝
+        const current = await fetchDetailsByDate(host, lease.date, lease.targetUserId);
+        if (!current.found || !current.blog || objectFingerprint(current.blog) !== lease.fingerprint) {
+            throw blogValidationError('target_changed', '日报在确认后发生变化，请重新准备编辑');
+        }
+        let result;
+        try {
+            result = await host.blogRequest({
+                path: '/api/blog/prior/updateBlog',
+                body: {
+                    timezoneOffset: -8,
+                    blog: {
+                        id: lease.blogId,
+                        content: lease.content,
+                        client: 'pc',
+                        attachmentIds: '',
+                        atLinkList: [],
+                        isTm: 0,
+                        isDbCheck: 0,
+                    },
+                },
+                operation: 'blog.edit.apply',
+            });
+        }
+        catch (error) {
+            if (isBlogNetworkError(error)) {
+                throw blogPartialError('编辑请求发送后连接中断，结果不确定，禁止自动重试；请先用 blog.query_user 回查', {
+                    blog_id: lease.blogId,
+                    workflow: workflow('blog.edit', 'EXECUTING'),
+                }, { stage: 'update' });
+            }
+            throw error;
+        }
+        const after = await fetchDetailsByDate(host, lease.date, lease.targetUserId);
+        if (!after.found || !after.blog) {
+            throw blogPartialError('编辑接口已返回成功，但详情回查失败，结果不确定', {
+                blog_id: lease.blogId,
+                result,
+                workflow: workflow('blog.edit', 'VERIFYING'),
+            }, { stage: 'readback' });
+        }
+        if (htmlToText(after.blog.content) !== htmlToText(lease.content)) {
+            throw blogPartialError('编辑接口已返回成功，但回查内容与新内容不一致', {
+                blog_id: lease.blogId,
+                expected: htmlToText(lease.content),
+                actual: after.blog.content_text,
+                result,
+                workflow: workflow('blog.edit', 'VERIFYING'),
+            }, { stage: 'readback' });
+        }
+        return {
+            status: 'COMPLETE',
+            data: {
+                blog_id: lease.blogId,
+                date: lease.date,
+                updated: true,
+                verified: true,
+                content_text: after.blog.content_text,
+                result,
+                workflow: workflow('blog.edit', 'COMPLETE'),
+            },
+        };
+    }
+}

package/dist/shortcuts/blog/operations/export.js

@@ -0,0 +1,46 @@
+import { ExitCode } from '../../../core/errors.js';
+import { BlogCliError } from '../errors.js';
+import { asDate, asInteger, asNonEmptyString, resolveExportOutput, writeExportFile } from './shared.js';
+/** 日报报表导出：全量（当前账号可见范围）xlsx 文件流，落盘前校验 PK 魔数并拒绝覆盖 */
+export class BlogExportOperation {
+    name = 'blog.export';
+    async execute(input, { host }) {
+        const startDate = asDate(input.start_date, 'start_date');
+        const endDate = asDate(input.end_date, 'end_date');
+        const output = asNonEmptyString(input.output, 'output');
+        const pageSize = asInteger(input.page_size, 'page_size', { min: 1, max: 500, dflt: 200 });
+        const resolved = await resolveExportOutput(output);
+        const result = await host.blogBinaryRequest({
+            path: '/api/blog/report/exportAllBlog',
+            body: {
+                startDate,
+                endDate,
+                blogType: 'all',
+                searchType: 'all',
+                disableType: 'all',
+                pageNo: 1,
+                pageSize,
+                isNeedConvert: false,
+            },
+            operation: 'blog.export',
+        });
+        const magicOk = result.content.subarray(0, 2).toString('latin1') === 'PK';
+        if (!magicOk) {
+            throw new BlogCliError('api', 'export_failed', '导出响应不是合法的 xlsx 文件流（缺少 PK 魔数）', {
+                details: { contentType: result.contentType, preview: result.content.subarray(0, 200).toString('utf8') },
+                exitCode: ExitCode.GeneralError,
+            });
+        }
+        await writeExportFile(resolved, result.content);
+        return {
+            status: 'COMPLETE',
+            data: {
+                output: resolved,
+                bytes: result.content.length,
+                content_type: result.contentType,
+                range: { start_date: startDate, end_date: endDate },
+                note: '导出范围为当前账号有权限查看的全部日报（不限于本人）',
+            },
+        };
+    }
+}

package/dist/shortcuts/blog/operations/like.js

@@ -0,0 +1,80 @@
+import { blogConfirmationError, blogPartialError, blogValidationError, isBlogNetworkError, } from '../errors.js';
+import { objectFingerprint, resolveTargetBlog, sessionMatches } from './shared.js';
+import { workflow } from './types.js';
+/** 点赞 / 取消点赞 prepare：定位目标日报，签发 continuation */
+export class BlogLikePrepareOperation {
+    name = 'blog.like.prepare';
+    async execute(input, { host, continuation }) {
+        const cancel = input.cancel === true;
+        const target = await resolveTargetBlog(input, host, cancel ? '取消点赞' : '点赞');
+        const session = await host.getSession();
+        const continuationToken = await continuation.issue({
+            operation: 'blog.like.apply',
+            workflow: workflow('blog.like', 'AWAITING_CONFIRMATION'),
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            blogId: target.blogId,
+            cancel,
+            fingerprint: objectFingerprint(target.blog ? { id: target.blog.id } : { id: target.blogId }),
+        });
+        return {
+            status: 'AWAITING_CONFIRMATION',
+            data: {
+                blog_id: target.blogId,
+                action: cancel ? 'cancelVote' : 'vote',
+                target: target.date ? { date: target.date, user_id: target.userId } : undefined,
+                continuation: continuationToken,
+                expires_in_seconds: 600,
+                workflow: workflow('blog.like', 'AWAITING_CONFIRMATION'),
+                next: '用户确认后调用 blog.like.apply 并传 confirm=true',
+            },
+        };
+    }
+}
+/** 点赞 apply：vote / cancelVote 二选一，以业务码作为生效依据（无只读回查接口） */
+export class BlogLikeApplyOperation {
+    name = 'blog.like.apply';
+    async execute(input, { host, continuation }) {
+        if (input.confirm !== true) {
+            throw blogConfirmationError('blog.like.apply', { hint: '重新调用时传入 confirm=true' });
+        }
+        const lease = await continuation.verify(input.continuation, 'blog.like.apply');
+        if (typeof lease.blogId !== 'string' || typeof lease.cancel !== 'boolean') {
+            throw blogValidationError('continuation_invalid', '点赞 continuation 缺少有效目标或动作');
+        }
+        const session = await host.getSession();
+        if (!sessionMatches(lease, session)) {
+            throw blogValidationError('context_mismatch', '确认上下文已变化，请重新准备');
+        }
+        let result;
+        try {
+            result = await host.blogRequest({
+                path: lease.cancel ? '/api/blog/common/upvoteComponent/cancelVote' : '/api/blog/common/upvoteComponent/vote',
+                body: { componentId: lease.blogId, upvote: true },
+                operation: 'blog.like.apply',
+            });
+        }
+        catch (error) {
+            if (isBlogNetworkError(error)) {
+                throw blogPartialError('点赞请求发送后连接中断，结果不确定，禁止自动重试', {
+                    blog_id: lease.blogId,
+                    workflow: workflow('blog.like', 'EXECUTING'),
+                }, { stage: 'vote' });
+            }
+            throw error;
+        }
+        return {
+            status: 'COMPLETE',
+            data: {
+                blog_id: lease.blogId,
+                action: lease.cancel ? 'cancelVote' : 'vote',
+                // detailsByDate 不返回点赞数，动作是否生效以业务码（code=200, fail=false）为准
+                receipt: typeof result?.data === 'string' ? result.data : null,
+                verified: false,
+                note: '点赞状态无只读回查接口，动作生效以接口业务码为准',
+                workflow: workflow('blog.like', 'COMPLETE'),
+            },
+        };
+    }
+}

package/dist/shortcuts/blog/operations/publish.js

@@ -0,0 +1,157 @@
+import { blogConfirmationError, blogPartialError, blogValidationError, isBlogNetworkError, } from '../errors.js';
+import { asDate, ensureHtml, fetchDetailsByDate, htmlToText, localDateStr, objectFingerprint, sessionMatches, } from './shared.js';
+import { workflow } from './types.js';
+/** 某日期的默认共享对象；prepare 阶段回填进 addBlog 的 permissionList */
+export class BlogDefaultPermissionOperation {
+    name = 'blog.default_permission';
+    async execute(input, { host }) {
+        const date = asDate(input.date, 'date');
+        const value = await host.blogRequest({
+            method: 'GET',
+            path: '/api/blog/share/getDefaultPermission',
+            query: { blogTime: date },
+            operation: 'blog.default_permission',
+        });
+        return {
+            status: 'COMPLETE',
+            data: {
+                date,
+                add: value?.data?.add ?? null,
+                list: Array.isArray(value?.data?.list) ? value.data.list : [],
+            },
+        };
+    }
+}
+/**
+ * 发布 prepare：只读查重 + 默认共享回填 + 签发 continuation。
+ * 服务端不限制同日重复提交，因此必须在发布前先查当日是否已有日报。
+ */
+export class BlogPublishPrepareOperation {
+    name = 'blog.publish.prepare';
+    async execute(input, { host, continuation }) {
+        const date = asDate(input.date, 'date');
+        const rawContent = typeof input.content === 'string' ? input.content.trim() : '';
+        if (!rawContent)
+            throw blogValidationError('input_invalid', 'content 必须是非空字符串');
+        const content = ensureHtml(rawContent);
+        const shareDefault = input.share_default === undefined ? true : input.share_default === true;
+        const session = await host.getSession();
+        const existing = await fetchDetailsByDate(host, date, session.userId);
+        if (existing.found && existing.blog) {
+            throw blogValidationError('publish_already_exists', `${date} 已有日报（id=${existing.blog.id}），不可重复发布；如需修改请使用 blog.edit.prepare`, {
+                date,
+                blog_id: existing.blog.id,
+            });
+        }
+        let permissionList = [];
+        if (shareDefault) {
+            const perm = await host.blogRequest({
+                method: 'GET',
+                path: '/api/blog/share/getDefaultPermission',
+                query: { blogTime: date },
+                operation: 'blog.publish.prepare',
+            });
+            permissionList = Array.isArray(perm?.data?.list) ? perm.data.list : [];
+        }
+        const continuationToken = await continuation.issue({
+            operation: 'blog.publish.apply',
+            workflow: workflow('blog.publish', 'AWAITING_CONFIRMATION'),
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            date,
+            content,
+            permissionList,
+            fingerprint: objectFingerprint({ date, content, permissionList }),
+        });
+        return {
+            status: 'AWAITING_CONFIRMATION',
+            data: {
+                date,
+                content,
+                content_text: htmlToText(content),
+                share: { default: shareDefault, permission_count: permissionList.length },
+                continuation: continuationToken,
+                expires_in_seconds: 600,
+                workflow: workflow('blog.publish', 'AWAITING_CONFIRMATION'),
+                next: '向用户复述日期与内容，用户确认后调用 blog.publish.apply 并传 confirm=true',
+            },
+        };
+    }
+}
+/** 发布 apply：确认 + continuation + 上下文/指纹校验 + 写前查重 + 写后回查 */
+export class BlogPublishApplyOperation {
+    name = 'blog.publish.apply';
+    async execute(input, { host, continuation }) {
+        if (input.confirm !== true) {
+            throw blogConfirmationError('blog.publish.apply', { hint: '重新调用时传入 confirm=true' });
+        }
+        const lease = await continuation.verify(input.continuation, 'blog.publish.apply');
+        if (typeof lease.date !== 'string' || typeof lease.content !== 'string' || typeof lease.fingerprint !== 'string') {
+            throw blogValidationError('continuation_invalid', '发布 continuation 缺少有效日期、内容或指纹');
+        }
+        const session = await host.getSession();
+        if (!sessionMatches(lease, session)) {
+            throw blogValidationError('context_mismatch', '确认上下文已变化，请重新准备发布');
+        }
+        const existing = await fetchDetailsByDate(host, lease.date, session.userId);
+        if (existing.found && existing.blog) {
+            throw blogValidationError('target_changed', `${lease.date} 在确认后出现了日报（id=${existing.blog.id}），请重新准备发布`);
+        }
+        if (objectFingerprint({ date: lease.date, content: lease.content, permissionList: lease.permissionList }) !== lease.fingerprint) {
+            throw blogValidationError('continuation_invalid', '发布 continuation 指纹校验失败');
+        }
+        let result;
+        try {
+            result = await host.blogRequest({
+                path: '/api/blog/prior/addBlog',
+                body: {
+                    blog: {
+                        blogTime: lease.date,
+                        content: lease.content,
+                        permissionList: Array.isArray(lease.permissionList) ? lease.permissionList : [],
+                        isTm: 0,
+                        isDbCheck: 0,
+                        formData: '0',
+                        attachmentIds: '',
+                        atLinkList: [],
+                        deleteTargetType: [],
+                        client: 'pc',
+                    },
+                    timezoneOffset: -8,
+                },
+                operation: 'blog.publish.apply',
+            });
+        }
+        catch (error) {
+            if (isBlogNetworkError(error)) {
+                throw blogPartialError('发布请求发送后连接中断，结果不确定，禁止自动重试；请先用 blog.query_user 回查', {
+                    date: lease.date,
+                    workflow: workflow('blog.publish', 'EXECUTING'),
+                }, { stage: 'publish' });
+            }
+            throw error;
+        }
+        const after = await fetchDetailsByDate(host, lease.date, session.userId);
+        if (!after.found || !after.blog) {
+            throw blogPartialError('发布接口已返回，但回查未发现新日报，结果不确定', {
+                date: lease.date,
+                result,
+                workflow: workflow('blog.publish', 'VERIFYING'),
+            }, { stage: 'readback' });
+        }
+        const submitStatus = after.blog.create_time !== null && after.blog.blog_time !== null
+            && localDateStr(after.blog.create_time) === localDateStr(after.blog.blog_time) ? '正常' : '补交';
+        return {
+            status: 'COMPLETE',
+            data: {
+                date: lease.date,
+                blog_id: after.blog.id,
+                submit_status: submitStatus,
+                verified: true,
+                result,
+                workflow: workflow('blog.publish', 'COMPLETE'),
+            },
+        };
+    }
+}

package/dist/shortcuts/blog/operations/query-user.js

@@ -0,0 +1,58 @@
+import { blogValidationError } from '../errors.js';
+import { asDate, dateRange, fetchDetailsByDate, resolveTargetUser, searchUsersByName, submitStatus, } from './shared.js';
+/** 单人日报查询：detailsByDate 逐日扫描（区间上限 62 天）；查指定个人的唯一可靠路径 */
+export async function runQueryUser(input, host) {
+    const startDate = asDate(input.date, 'date');
+    const days = input.end_date === undefined ? [startDate] : dateRange(startDate, input.end_date, 'date', 'end_date');
+    // 未指定 user_id/name 时默认查当前登录人（与 edit/comment/like/remind 口径一致，查自己的唯一路径）
+    const { userId, userName } = await resolveTargetUser(input, host);
+    const items = [];
+    for (const date of days) {
+        const detail = await fetchDetailsByDate(host, date, userId);
+        // 补交状态：有日报按 createTime vs blogTime 判定，无日报为「未提交」
+        const status = detail.blog ? submitStatus(detail.blog) : '未提交';
+        items.push({
+            date,
+            found: detail.found,
+            submitted: detail.found,
+            submit_status: status,
+            blog: detail.blog,
+        });
+    }
+    return {
+        status: 'COMPLETE',
+        data: {
+            user: { user_id: userId, name: userName },
+            range: { start_date: startDate, end_date: days[days.length - 1] },
+            total_days: days.length,
+            submitted_days: items.filter((item) => item.submitted).length,
+            normal_days: items.filter((item) => item.submit_status === '正常').length,
+            later_days: items.filter((item) => item.submit_status === '补交').length,
+            missing_days: items.filter((item) => item.submit_status === '未提交').length,
+            items,
+        },
+    };
+}
+export class BlogQueryUserOperation {
+    name = 'blog.query_user';
+    execute(input, { host }) {
+        return runQueryUser(input, host);
+    }
+}
+export class BlogResolveUsersOperation {
+    name = 'blog.resolve_users';
+    async execute(input, { host }) {
+        const name = typeof input.name === 'string' ? input.name.trim() : '';
+        if (!name)
+            throw blogValidationError('input_invalid', 'name 必须是非空字符串');
+        const users = await searchUsersByName(host, name);
+        return {
+            status: 'COMPLETE',
+            data: {
+                name,
+                matched: users.length,
+                users: users.map((user) => ({ user_id: user.id, name: user.name, department: user.department })),
+            },
+        };
+    }
+}

package/dist/shortcuts/blog/operations/query.js

@@ -0,0 +1,96 @@
+import { asInteger, dateRange, localDateStr, normalizeBlogListItem, normalizeUserType, } from './shared.js';
+/** 服务端单页上限（实测 pageSize 生效、pageNo 被忽略，因此只能靠单页拉满覆盖窗口） */
+const MAX_PAGE_SIZE = 300;
+/**
+ * 群体日报查询（blogs + filter.userType）。
+ *
+ * 服务端行为（内网租户实测）：
+ * - `filter.startDate/endDate` 不生效（返回全量倒序），窗口裁剪在客户端完成；
+ * - `pageNo` 被忽略（第 1/2/3 页返回同一批数据），翻页拿不到更多数据；
+ * - `pageSize` 生效，上限 300，且会为「当天没交的人」补占位行（行数 ≈ 人数 × 天数）。
+ *
+ * 因此默认 pageSize=300 以最大化窗口覆盖；仍不够时在 `_note` 中提示缩小日期范围。
+ */
+export async function runGroupQuery(input, host) {
+    const userType = normalizeUserType(input.user_type);
+    // 复用 dateRange：同时校验日期格式、区间顺序与 62 天上限（与 blog.query_user 口径一致）
+    const days = dateRange(input.start_date, input.end_date, 'start_date', 'end_date');
+    const startDate = days[0];
+    const endDate = days[days.length - 1];
+    const keywords = typeof input.keywords === 'string' ? input.keywords : '';
+    const pageSize = asInteger(input.page_size, 'page_size', { min: 1, max: MAX_PAGE_SIZE, dflt: MAX_PAGE_SIZE });
+    const pageNo = asInteger(input.page_no, 'page_no', { min: 1, max: 10_000, dflt: 1 });
+    // 窗口边界与 localDateStr 一致按本地时区 0 点计算，避免跨时区错位
+    const startMs = new Date(`${startDate}T00:00:00`).getTime();
+    const endMs = new Date(`${endDate}T23:59:59.999`).getTime();
+    const value = await host.blogRequest({
+        method: 'POST',
+        path: '/api/blog/query/blogs',
+        body: {
+            blogType: 'order',
+            keywords,
+            pageNo,
+            pageSize,
+            filter: {
+                userType,
+                startDate,
+                endDate,
+                timezoneOffset: -8,
+            },
+        },
+        operation: 'blog.query',
+    });
+    const raw = Array.isArray(value?.blogList) ? value.blogList : [];
+    const items = raw
+        .map((item) => normalizeBlogListItem(item))
+        .filter((item) => Boolean(item))
+        .filter((item) => item.date >= startMs && item.date <= endMs);
+    const oldestRaw = raw.length
+        ? Math.min(...raw.map((item) => Number(item?.date)).filter(Number.isFinite))
+        : null;
+    // 返回行数已顶到单页上限、且最旧一行仍晚于起始日 → 窗口更早的部分没拿到
+    const truncated = raw.length >= pageSize && oldestRaw !== null && localDateStr(oldestRaw) > startDate;
+    // 对外输出统一用 YYYY-MM-DD（毫秒原值保留在 date_ms，仅供程序化比较）
+    const view = items.map((item) => ({
+        date: item.date_str,
+        date_ms: item.date,
+        user_id: item.user_id,
+        username: item.username,
+        submit_status: item.submit_status,
+        blog: item.blog,
+    }));
+    const submitted = items.filter((item) => item.submitted);
+    const people = [...new Map(items.map((item) => [item.user_id, item.username])).entries()]
+        .map(([userId, username]) => ({ user_id: userId, username }));
+    // 未提交按「人天」列出（同一人部分日期未交也要暴露），并单独给出整窗一次未交的人员
+    const missing = items
+        .filter((item) => !item.submitted)
+        .map((item) => ({ date: item.date_str, user_id: item.user_id, username: item.username }));
+    const missingPeople = people
+        .filter((person) => !items.some((item) => item.user_id === person.user_id && item.submitted))
+        .map((person) => person.username);
+    return {
+        status: 'COMPLETE',
+        data: {
+            user_type: userType,
+            range: { start_date: startDate, end_date: endDate },
+            total_rows_in_window: items.length,
+            submitted_count: submitted.length,
+            missing_count: missing.length,
+            not_submitted: missing,
+            not_submitted_people: missingPeople,
+            people,
+            items: view,
+            page: { page_size: pageSize, page_no: pageNo, rows_returned: raw.length },
+            _note: truncated
+                ? `服务端单次最多返回 ${pageSize} 行（pageNo 被服务端忽略，无法翻页），本次最旧仅到 ${localDateStr(oldestRaw)}，早于 ${startDate} 的部分未覆盖；请缩小日期范围（或减少人数范围）后重查`
+                : undefined,
+        },
+    };
+}
+export class BlogQueryOperation {
+    name = 'blog.query';
+    execute(input, { host }) {
+        return runGroupQuery(input, host);
+    }
+}

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

@@ -0,0 +1,54 @@
+import { blogValidationError } from '../errors.js';
+import { blogOperations } from '../manifest.js';
+import { BlogCommentsOperation } from './comments.js';
+import { BlogCommentApplyOperation, BlogCommentPrepareOperation } from './comment.js';
+import { BlogEditApplyOperation, BlogEditPrepareOperation } from './edit.js';
+import { BlogExportOperation } from './export.js';
+import { BlogLikeApplyOperation, BlogLikePrepareOperation } from './like.js';
+import { BlogDefaultPermissionOperation, BlogPublishApplyOperation, BlogPublishPrepareOperation, } from './publish.js';
+import { BlogQueryOperation } from './query.js';
+import { BlogQueryUserOperation, BlogResolveUsersOperation } from './query-user.js';
+import { BlogRemindApplyOperation, BlogRemindPrepareOperation } from './remind.js';
+/** manifest（WHAT）与 handler（HOW）一一对应；任一侧缺项在启动时即抛错。 */
+function buildRegistry() {
+    const registry = new Map();
+    const handlers = [
+        new BlogQueryOperation(),
+        new BlogQueryUserOperation(),
+        new BlogResolveUsersOperation(),
+        new BlogCommentsOperation(),
+        new BlogDefaultPermissionOperation(),
+        new BlogExportOperation(),
+        new BlogPublishPrepareOperation(),
+        new BlogPublishApplyOperation(),
+        new BlogEditPrepareOperation(),
+        new BlogEditApplyOperation(),
+        new BlogCommentPrepareOperation(),
+        new BlogCommentApplyOperation(),
+        new BlogLikePrepareOperation(),
+        new BlogLikeApplyOperation(),
+        new BlogRemindPrepareOperation(),
+        new BlogRemindApplyOperation(),
+    ];
+    for (const handler of handlers) {
+        if (registry.has(handler.name))
+            throw new Error(`duplicate blog operation handler: ${handler.name}`);
+        registry.set(handler.name, handler);
+    }
+    for (const contract of blogOperations) {
+        if (!registry.has(contract.name))
+            throw new Error(`missing blog operation handler: ${contract.name}`);
+    }
+    return registry;
+}
+const blogOperationRegistry = buildRegistry();
+export function getBlogOperation(operation) {
+    const handler = blogOperationRegistry.get(operation);
+    if (!handler) {
+        throw blogValidationError('operation_unknown', `日报模块不支持操作：${operation}`);
+    }
+    return handler;
+}
+export function listBlogOperations() {
+    return [...blogOperationRegistry.keys()];
+}