weaver-work-cli 0.1.8 → 0.1.20

package/dist/shortcuts/caizhilian/operations/handlers/collab.js

@@ -0,0 +1,611 @@
+import { caizhilianValidationError } from '../../errors.js';
+import { asList, asRecord, assertToleratedBusinessSuccess, checkDocShareAddPermission, fetchDocShareEntries, isAlreadyExistsResponse, } from '../api.js';
+import { issueWriteLease } from '../confirm.js';
+import { buildObjTypeList, parseCascadeRules, parseCascadeRulesOuter, parseFieldCascadeRules, parseObjTypeOptions, parseParamOptions, } from '../form.js';
+import { fingerprint, hasNextPage, isFalsyIds, isPlainObject, parsePage, pyBool, pyGetStr, pyInt, pyStr, requireNonEmpty, requireText, } from '../shared.js';
+import { caizhilianPrepared, caizhilianSuccess } from '../types.js';
+/**
+ * 文档协作域操作（1:1 对应源 scripts/document_plugins.py 的标签 / 参与人 / 共享部分）：
+ * SearchTagsPlugin、AddDocTagPlugin、RemoveDocTagPlugin、FetchDocTagsPlugin、
+ * AddDocParticipantPlugin、FetchDocParticipantsPlugin、RemoveDocParticipantPlugin、
+ * FetchDocShareFormPlugin、FetchDocShareListPlugin、AddDocSharePlugin、DeleteDocSharePlugin。
+ *
+ * 写操作按 weaver-work-cli 规范拆成 prepare（只读回查 + 组装请求体 + 签发票据）
+ * 与 apply（真正产生副作用），业务请求体与源保持逐字段一致。
+ */
+// ── 源常量 ────────────────────────────────────────────────
+/** 源 SearchTagsPlugin._FIXED_BODY_PARAMS。 */
+const TAG_QUERY_FIXED_BODY = { order: 8, search: 1, tagGroup: 0 };
+/** 源 search_tags / fetch_doc_tags 的 type：0=公共标签，1=个人标签。 */
+const TAG_TYPES = [0, 1];
+/** 源 search_tags 的默认每页条数（parse_page_args default_page_size）。 */
+const TAG_QUERY_DEFAULT_PAGE_SIZE = 50;
+const TAG_QUERY_PATH = '/api/my/tag/query';
+const TAG_QUERY_ENTITY_PATH = '/api/my/tag/queryEntityTag';
+const TAG_ADD_ENTITY_PATH = '/api/my/tag/addEntityTag';
+const TAG_REMOVE_ENTITY_PATH = '/api/my/tag/removeEntityTag';
+const PARTICIPANT_ADD_PATH = '/api/doc/shareentry/addUser.common';
+const PARTICIPANT_REMOVE_PATH = '/api/doc/shareentry/destroy.common';
+/** 源 FetchDocParticipantsPlugin：/api/doc/document/{quote(doc_id, safe='')}/permissions。 */
+const participantPermissionsPath = (docId) => `/api/doc/document/${encodeURIComponent(docId)}/permissions`;
+const SHARE_FORM_PATH = '/api/doc/permission/data/query';
+const SHARE_ADD_PATH = '/api/doc/shareentry/addShare';
+const SHARE_DELETE_PATH = '/api/doc/shareentry/deleteShare';
+/** 源共享/权限接口固定的 permissionId。 */
+const SHARE_PERMISSION_ID = 'doc_s01';
+/** 源 document_plugins._OBJ_TYPE_TO_TARGET_TYPE。 */
+const OBJ_TYPE_TO_TARGET_TYPE = {
+    resource: 1,
+    department: 3,
+    subcompany: 3,
+    role: 4,
+    group: 5,
+    external: 7,
+    customer: 8,
+    customer_type: 9,
+    position: 10,
+};
+/**
+ * 源 AddDocSharePlugin.optional_params（顺序即写入顺序）。
+ * seclevel 未出现在对外契约 doc_share_operations.json 中，schema 也不放开，
+ * 这里保留以与源循环逐字段一致（实际永远不会命中）。
+ */
+const DOC_SHARE_OPTIONAL_PARAMS = [
+    'download',
+    'department_attribute',
+    'role_level',
+    'position_level',
+    'position_attribute',
+    'virtualCompany',
+    'createrPositionLevel',
+    'seclevel',
+];
+/** 源 AddDocSharePlugin.id_fields（顺序即写入顺序）。 */
+const DOC_SHARE_ID_FIELDS = [
+    'obj_id',
+    'obj_id_department',
+    'obj_id_subcompany',
+    'obj_id_role',
+    'obj_id_group',
+    'obj_id_external',
+    'obj_id_customer',
+    'obj_id_customer_type',
+    'obj_id_position',
+    'obj_id_manager',
+    'obj_id_grade',
+];
+// ── 写操作 apply 名（continuation 与操作绑定，防跨操作串用）──
+const PARTICIPANT_ADD_APPLY = 'caizhilian.participant.add.apply';
+const PARTICIPANT_REMOVE_APPLY = 'caizhilian.participant.remove.apply';
+const SHARE_ADD_APPLY = 'caizhilian.share.add.apply';
+const SHARE_DELETE_APPLY = 'caizhilian.share.delete.apply';
+function errorMessage(error) {
+    if (error instanceof Error && error.message)
+        return error.message;
+    return String(error);
+}
+// ── caizhilian.tag.search ─────────────────────────────────
+/**
+ * 源 `int(args.get("type", 1))`：非整数报「type 必须是整数」，
+ * 非 0/1 报「type 只能是 0（公共标签）或 1（个人标签），不支持: {原值}」。
+ */
+function parseTagType(value) {
+    let tagType;
+    try {
+        tagType = pyInt(value, 1);
+    }
+    catch {
+        throw caizhilianValidationError('number_invalid', 'type 必须是整数');
+    }
+    if (!TAG_TYPES.includes(tagType)) {
+        throw caizhilianValidationError('enum_invalid', `type 只能是 0（公共标签）或 1（个人标签），不支持: ${pyStr(value)}`);
+    }
+    return tagType;
+}
+async function searchTags(args, env) {
+    const action = 'caizhilian.tag.search';
+    const name = args.name ? String(args.name).trim() : '';
+    const { pageNo, pageSize } = parsePage(args, TAG_QUERY_DEFAULT_PAGE_SIZE);
+    const tagType = parseTagType(args.type);
+    const body = { ...TAG_QUERY_FIXED_BODY };
+    body.type = tagType;
+    body.name = name;
+    body.pageSize = pageSize;
+    body.pageNo = pageNo;
+    if (tagType === 0)
+        body.tagModules = ['document'];
+    const response = await env.host.request({
+        method: 'POST',
+        path: TAG_QUERY_PATH,
+        body,
+        operation: action,
+    });
+    const inner = asRecord(asRecord(response).data);
+    const items = asList(inner.data);
+    return caizhilianSuccess(action, {
+        page_no: pageNo,
+        page_size: pageSize,
+        has_next: hasNextPage(items, pageSize),
+        tags: items.filter(isPlainObject).map((tag) => ({
+            id: pyGetStr(tag, 'tagId'),
+            name: pyGetStr(tag, 'name'),
+            privacy: pyStr('type' in tag ? tag.type : 0) === '1',
+        })),
+    });
+}
+// ── caizhilian.tag.list ───────────────────────────────────
+/** 源 FetchDocTagsPlugin：公共(0) + 个人(1) 两次查询合并。 */
+async function listDocTags(args, env) {
+    const action = 'caizhilian.tag.list';
+    const docId = requireNonEmpty(args.doc_id, 'doc_id 不能为空');
+    const tags = [];
+    for (const tagType of TAG_TYPES) {
+        const response = await env.host.request({
+            method: 'POST',
+            path: TAG_QUERY_ENTITY_PATH,
+            body: { entityId: docId, module: 'document', type: tagType },
+            operation: action,
+        });
+        const items = asList(asRecord(response).data);
+        for (const item of items) {
+            if (!isPlainObject(item))
+                continue;
+            tags.push({
+                id: pyGetStr(item, 'tagId'),
+                name: pyGetStr(item, 'name'),
+                privacy: tagType === 1,
+            });
+        }
+    }
+    return caizhilianSuccess(action, { tags });
+}
+/** 源 _extract_valid_tags：只接受 list[dict] 且 `str(tag.get("id") or "").strip()` 非空的项。 */
+function extractValidTags(rawTags) {
+    const tags = [];
+    if (!Array.isArray(rawTags))
+        return tags;
+    for (const tag of rawTags) {
+        if (!isPlainObject(tag))
+            continue;
+        const tagId = (pyBool(tag.id) ? pyStr(tag.id) : '').trim();
+        if (!tagId)
+            continue;
+        tags.push({ id: tagId, privacy: pyBool(tag.privacy) });
+    }
+    return tags;
+}
+/** 源 _batch_tag_operation 的校验 + 分组（公共 type=0、个人 type=1，空组跳过）。 */
+function planTagBatch(args, apiPath) {
+    const docId = requireText(args.doc_id, 'doc_id');
+    const tags = extractValidTags(args.tags);
+    if (!tags.length)
+        throw caizhilianValidationError('field_invalid', 'tags 中无有效标签');
+    const publicIds = tags.filter((tag) => !tag.privacy).map((tag) => tag.id);
+    const myIds = tags.filter((tag) => tag.privacy).map((tag) => tag.id);
+    const requests = [];
+    for (const [groupIds, groupType] of [
+        [publicIds, 0],
+        [myIds, 1],
+    ]) {
+        if (!groupIds.length)
+            continue;
+        requests.push({
+            method: 'POST',
+            path: apiPath,
+            body: { tagIds: [...groupIds], entityId: docId, module: 'document', type: groupType },
+        });
+    }
+    return { docId, tagIds: [...publicIds, ...myIds], publicIds, myIds, requests };
+}
+/** add_doc_tag / remove_doc_tag 仅接口路径不同，共用一套 prepare/apply。 */
+function tagBatchHandler(action, apiPath) {
+    const applyAction = `${action}.apply`;
+    return {
+        targetKeys: ['doc_id'],
+        async prepare(args, env) {
+            const plan = planTagBatch(args, apiPath);
+            const lease = await issueWriteLease(env, applyAction, args, {
+                doc_id: plan.docId,
+                tag_ids: plan.tagIds,
+                body_fingerprint: fingerprint(plan.requests),
+            });
+            return caizhilianPrepared(action, {
+                doc_id: plan.docId,
+                tag_ids: plan.tagIds,
+                count: plan.tagIds.length,
+                public_tag_ids: plan.publicIds,
+                my_tag_ids: plan.myIds,
+                requests: plan.requests,
+            }, lease);
+        },
+        async apply(args, env, lease) {
+            const plan = planTagBatch(args, apiPath);
+            const expected = typeof lease.body_fingerprint === 'string' ? lease.body_fingerprint : '';
+            if (expected && expected !== fingerprint(plan.requests)) {
+                throw caizhilianValidationError('plan_changed', `${applyAction} 的请求体与 prepare 时不一致，请重新执行 prepare`);
+            }
+            for (const request of plan.requests) {
+                await env.host.request({ ...request, operation: applyAction });
+            }
+            return caizhilianSuccess(applyAction, {
+                doc_id: plan.docId,
+                tag_ids: plan.tagIds,
+                count: plan.tagIds.length,
+            });
+        },
+    };
+}
+// ── 参与人：公共回查 ──────────────────────────────────────
+/** 源 FetchDocParticipantsPlugin 的解析结果。 */
+async function fetchParticipants(env, docId, action) {
+    const response = await env.host.request({
+        method: 'GET',
+        path: participantPermissionsPath(docId),
+        operation: action,
+    });
+    const raw = asRecord(response).data;
+    const entries = Array.isArray(raw) ? raw : [];
+    const participants = [];
+    for (const entry of entries) {
+        if (!isPlainObject(entry))
+            continue;
+        participants.push({
+            share_entry_id: pyGetStr(entry, 'id'),
+            user_id: pyGetStr(entry, 'sid'),
+            user_name: pyGetStr(entry, 'name'),
+            can_delete: pyBool(entry.canDelete),
+        });
+    }
+    return participants;
+}
+/** prepare 阶段的最佳努力回查：失败只降级为告警，不阻断（源无此步骤）。 */
+async function tryFetchParticipants(env, docId, action, warnings) {
+    try {
+        return await fetchParticipants(env, docId, action);
+    }
+    catch (error) {
+        warnings.push(`[WARN] 参与人列表回查失败: ${errorMessage(error)}`);
+        return [];
+    }
+}
+// ── caizhilian.participant.list ───────────────────────────
+async function listParticipants(args, env) {
+    const action = 'caizhilian.participant.list';
+    const docId = requireNonEmpty(args.doc_id, 'doc_id 不能为空');
+    return caizhilianSuccess(action, { participants: await fetchParticipants(env, docId, action) });
+}
+// ── caizhilian.participant.add ────────────────────────────
+/** 源 AddDocParticipantPlugin 的固定请求体（键顺序与源一致）。 */
+function buildParticipantAddBody(docId, userId) {
+    return {
+        entityIds: docId,
+        entryType: 'user',
+        module: 'document',
+        removeIds: '',
+        shareType: 'participants',
+        sids: userId,
+    };
+}
+const participantAddHandler = {
+    targetKeys: ['doc_id', 'user_id'],
+    async prepare(args, env) {
+        const action = 'caizhilian.participant.add';
+        const docId = requireNonEmpty(args.doc_id, 'doc_id 不能为空');
+        const userId = requireNonEmpty(args.user_id, 'user_id 不能为空');
+        const warnings = [];
+        const current = await tryFetchParticipants(env, docId, action, warnings);
+        if (current.some((entry) => String(entry.user_id) === userId)) {
+            warnings.push(`[WARN] user_id=${userId} 已在参与人列表中，重复添加可能被服务端拒绝或产生重复条目`);
+        }
+        const lease = await issueWriteLease(env, PARTICIPANT_ADD_APPLY, args, { doc_id: docId, user_id: userId });
+        return caizhilianPrepared(action, {
+            doc_id: docId,
+            user_id: userId,
+            current_participants: current,
+            request: {
+                method: 'POST',
+                path: PARTICIPANT_ADD_PATH,
+                body: buildParticipantAddBody(docId, userId),
+            },
+        }, lease, warnings);
+    },
+    async apply(args, env) {
+        const action = PARTICIPANT_ADD_APPLY;
+        const docId = requireNonEmpty(args.doc_id, 'doc_id 不能为空');
+        const userId = requireNonEmpty(args.user_id, 'user_id 不能为空');
+        const response = await env.host.request({
+            method: 'POST',
+            path: PARTICIPANT_ADD_PATH,
+            body: buildParticipantAddBody(docId, userId),
+            operation: action,
+        });
+        const shareEntries = asList(asRecord(asRecord(response).data).shareEntrys);
+        if (!shareEntries.length)
+            throw caizhilianValidationError('empty_response', '返回的参与人列表为空');
+        const entry = asRecord(shareEntries[0]);
+        return caizhilianSuccess(action, {
+            share_entry_id: pyGetStr(entry, 'id'),
+            doc_id: docId,
+            user_id: userId,
+            user_name: pyGetStr(entry, 'name'),
+        });
+    },
+};
+// ── caizhilian.participant.remove ─────────────────────────
+/** 源 RemoveDocParticipantPlugin 的固定请求体。 */
+function buildParticipantRemoveBody(shareEntryId, docId) {
+    return { id: shareEntryId, module: 'document', entityIds: docId };
+}
+const participantRemoveHandler = {
+    targetKeys: ['doc_id', 'share_entry_id'],
+    async prepare(args, env) {
+        const action = 'caizhilian.participant.remove';
+        const shareEntryId = requireNonEmpty(args.share_entry_id, 'share_entry_id 不能为空');
+        const docId = requireNonEmpty(args.doc_id, 'doc_id 不能为空');
+        const warnings = [];
+        const current = await tryFetchParticipants(env, docId, action, warnings);
+        const matched = current.find((entry) => String(entry.share_entry_id) === shareEntryId);
+        if (!matched) {
+            warnings.push(`[WARN] 参与人列表中未找到 share_entry_id=${shareEntryId}，apply 仍会按源行为提交删除请求`);
+        }
+        const lease = await issueWriteLease(env, PARTICIPANT_REMOVE_APPLY, args, {
+            doc_id: docId,
+            share_entry_id: shareEntryId,
+        });
+        return caizhilianPrepared(action, {
+            doc_id: docId,
+            share_entry_id: shareEntryId,
+            target: matched ?? null,
+            request: {
+                method: 'POST',
+                path: PARTICIPANT_REMOVE_PATH,
+                body: buildParticipantRemoveBody(shareEntryId, docId),
+            },
+        }, lease, warnings);
+    },
+    async apply(args, env) {
+        const action = PARTICIPANT_REMOVE_APPLY;
+        const shareEntryId = requireNonEmpty(args.share_entry_id, 'share_entry_id 不能为空');
+        const docId = requireNonEmpty(args.doc_id, 'doc_id 不能为空');
+        await env.host.request({
+            method: 'POST',
+            path: PARTICIPANT_REMOVE_PATH,
+            body: buildParticipantRemoveBody(shareEntryId, docId),
+            operation: action,
+        });
+        return caizhilianSuccess(action, { share_entry_id: shareEntryId, doc_id: docId });
+    },
+};
+// ── caizhilian.share.form ─────────────────────────────────
+async function shareForm(args, env) {
+    const action = 'caizhilian.share.form';
+    const docId = requireNonEmpty(args.doc_id, 'doc_id 不能为空');
+    const response = await env.host.request({
+        method: 'POST',
+        path: SHARE_FORM_PATH,
+        body: {
+            sourceId: docId,
+            permissionId: SHARE_PERMISSION_ID,
+            sourceType: 1,
+            id: docId,
+            tableName: 'document',
+        },
+        operation: action,
+    });
+    const respData = asRecord(asRecord(response).data);
+    const fieldCascadeRules = parseFieldCascadeRules(respData);
+    const { nameMap, availableIds } = parseObjTypeOptions(respData);
+    // 源未传 permission_type / seclevel_allowed（文档共享表单不区分权限类型）。
+    const objTypes = buildObjTypeList({
+        cascadeRulesOuter: parseCascadeRulesOuter(respData),
+        cascadeRules: parseCascadeRules(respData),
+        objTypeNames: nameMap,
+        availableIds,
+        fieldCascadeRules,
+    });
+    return caizhilianSuccess(action, {
+        obj_types: objTypes,
+        param_options: parseParamOptions(respData, fieldCascadeRules),
+    });
+}
+// ── caizhilian.share.list ─────────────────────────────────
+async function shareList(args, env) {
+    const action = 'caizhilian.share.list';
+    const docId = requireNonEmpty(args.doc_id, 'doc_id 不能为空');
+    const result = await fetchDocShareEntries(env, docId, action);
+    return caizhilianSuccess(action, { add_visible: result.add_visible, shares: result.shares });
+}
+/** 源 AddDocSharePlugin.execute 的权限校验 + 请求体组装。 */
+async function planDocShareAdd(args, env, action) {
+    const docId = requireNonEmpty(args.doc_id, 'doc_id 不能为空');
+    const objType = requireNonEmpty(args.obj_type, 'obj_type 不能为空');
+    const shareLevel = requireNonEmpty(args.share_level, 'share_level 不能为空');
+    await checkDocShareAddPermission(env, docId, action);
+    const body = {
+        sourceId: docId,
+        permissionId: SHARE_PERMISSION_ID,
+        sourceType: 1,
+        docId,
+        objType,
+        share_level: shareLevel,
+    };
+    for (const key of DOC_SHARE_OPTIONAL_PARAMS) {
+        if (key in args)
+            body[key] = args[key];
+    }
+    let targetId;
+    for (const field of DOC_SHARE_ID_FIELDS) {
+        if (!(field in args))
+            continue;
+        const value = args[field];
+        if (Array.isArray(value)) {
+            body[field] = value;
+            if (value.length)
+                targetId = String(value[0]);
+        }
+        else if (typeof value === 'string' && value) {
+            body[field] = [value];
+            targetId = value;
+        }
+    }
+    // 源：share_level 非 "1" 时 download 自动设为可下载。
+    if (shareLevel !== '1' && !('download' in body))
+        body.download = ['download'];
+    const targetType = OBJ_TYPE_TO_TARGET_TYPE[objType];
+    if (targetType !== undefined)
+        body.targetType = targetType;
+    if (targetId)
+        body.targetId = targetId;
+    return { docId, objType, shareLevel, targetType, targetId, body };
+}
+const shareAddHandler = {
+    targetKeys: ['doc_id', 'obj_type', 'share_level'],
+    async prepare(args, env) {
+        const action = 'caizhilian.share.add';
+        const plan = await planDocShareAdd(args, env, action);
+        const lease = await issueWriteLease(env, SHARE_ADD_APPLY, args, {
+            doc_id: plan.docId,
+            obj_type: plan.objType,
+            share_level: plan.shareLevel,
+            body_fingerprint: fingerprint(plan.body),
+        });
+        return caizhilianPrepared(action, {
+            doc_id: plan.docId,
+            obj_type: plan.objType,
+            share_level: plan.shareLevel,
+            target_type: plan.targetType ?? null,
+            target_id: plan.targetId ?? null,
+            request: { method: 'POST', path: SHARE_ADD_PATH, body: plan.body },
+        }, lease);
+    },
+    async apply(args, env, lease) {
+        const action = SHARE_ADD_APPLY;
+        const plan = await planDocShareAdd(args, env, 'caizhilian.share.add');
+        const expected = typeof lease.body_fingerprint === 'string' ? lease.body_fingerprint : '';
+        if (expected && expected !== fingerprint(plan.body)) {
+            throw caizhilianValidationError('plan_changed', `${action} 的请求体与 prepare 时不一致（表单级联规则可能已变化），请重新执行 prepare`);
+        }
+        // 源直接用 client.execute（不过业务校验），因此这里容忍业务错误后自行判定。
+        const data = asRecord(await env.host.request({
+            method: 'POST',
+            path: SHARE_ADD_PATH,
+            body: plan.body,
+            operation: action,
+            tolerateBusinessError: true,
+        }));
+        if (isAlreadyExistsResponse(data)) {
+            const message = data.message || data.msg || '已存在';
+            return caizhilianSuccess(action, { added: false, message: pyStr(message) });
+        }
+        assertToleratedBusinessSuccess(data, action);
+        // 源：回读列表失败时仍算成功，只是列表为空。
+        let shares = [];
+        try {
+            shares = (await fetchDocShareEntries(env, plan.docId, action)).shares;
+        }
+        catch {
+            shares = [];
+        }
+        return caizhilianSuccess(action, { added: true, shares });
+    },
+};
+/** 源 DeleteDocSharePlugin.execute 的存在性 / can_delete 校验 + 请求体组装。 */
+async function planDocShareDelete(args, env, action) {
+    const docId = requireNonEmpty(args.doc_id, 'doc_id 不能为空');
+    const rawIds = args.ids;
+    if (isFalsyIds(rawIds))
+        throw caizhilianValidationError('field_required', 'ids 不能为空');
+    const idList = Array.isArray(rawIds) ? rawIds.map((item) => String(item)) : [String(rawIds)];
+    const { shares } = await fetchDocShareEntries(env, docId, action);
+    const shareMap = new Map(shares.map((share) => [String(share.id), share]));
+    const notFound = [];
+    const notDeletable = [];
+    const removing = [];
+    for (const shareId of idList) {
+        const share = shareMap.get(shareId);
+        if (!share) {
+            notFound.push(shareId);
+            continue;
+        }
+        if (!share.can_delete) {
+            notDeletable.push('object_name' in share ? pyStr(share.object_name) : shareId);
+            continue;
+        }
+        removing.push(share);
+    }
+    if (notFound.length) {
+        throw caizhilianValidationError('share_not_found', `以下共享条目不存在: ${notFound.join(', ')}`, { notFound });
+    }
+    if (notDeletable.length) {
+        throw caizhilianValidationError('share_not_deletable', `以下共享条目无删除权限（受权限设置限制，重试不会改变结果）: ${notDeletable.join(', ')}`, { notDeletable });
+    }
+    const idsStr = idList.join(',');
+    return {
+        docId,
+        idList,
+        removing,
+        body: {
+            sourceId: docId,
+            permissionId: SHARE_PERMISSION_ID,
+            sourceType: 1,
+            docId,
+            ids: idsStr,
+            datas: idList,
+        },
+    };
+}
+const shareDeleteHandler = {
+    targetKeys: ['doc_id'],
+    async prepare(args, env) {
+        const action = 'caizhilian.share.delete';
+        const plan = await planDocShareDelete(args, env, action);
+        const lease = await issueWriteLease(env, SHARE_DELETE_APPLY, args, {
+            doc_id: plan.docId,
+            ids: plan.idList,
+            body_fingerprint: fingerprint(plan.body),
+        });
+        return caizhilianPrepared(action, {
+            doc_id: plan.docId,
+            ids: plan.idList,
+            removing: plan.removing,
+            request: { method: 'POST', path: SHARE_DELETE_PATH, body: plan.body },
+        }, lease);
+    },
+    async apply(args, env, lease) {
+        const action = SHARE_DELETE_APPLY;
+        const plan = await planDocShareDelete(args, env, 'caizhilian.share.delete');
+        const expected = typeof lease.body_fingerprint === 'string' ? lease.body_fingerprint : '';
+        if (expected && expected !== fingerprint(plan.body)) {
+            throw caizhilianValidationError('plan_changed', `${action} 的请求体与 prepare 时不一致（共享条目可能已变化），请重新执行 prepare`);
+        }
+        await env.host.request({
+            method: 'POST',
+            path: SHARE_DELETE_PATH,
+            body: plan.body,
+            operation: action,
+        });
+        // 源：回读列表失败时仍算成功，只是列表为空。
+        let shares = [];
+        try {
+            shares = (await fetchDocShareEntries(env, plan.docId, action)).shares;
+        }
+        catch {
+            shares = [];
+        }
+        return caizhilianSuccess(action, { deleted: true, shares });
+    },
+};
+// ── 处理器汇总 ────────────────────────────────────────────
+export const caizhilianCollabHandlers = {
+    'caizhilian.tag.search': { execute: searchTags },
+    'caizhilian.tag.list': { execute: listDocTags },
+    'caizhilian.tag.add': tagBatchHandler('caizhilian.tag.add', TAG_ADD_ENTITY_PATH),
+    'caizhilian.tag.remove': tagBatchHandler('caizhilian.tag.remove', TAG_REMOVE_ENTITY_PATH),
+    'caizhilian.participant.list': { execute: listParticipants },
+    'caizhilian.participant.add': participantAddHandler,
+    'caizhilian.participant.remove': participantRemoveHandler,
+    'caizhilian.share.form': { execute: shareForm },
+    'caizhilian.share.list': { execute: shareList },
+    'caizhilian.share.add': shareAddHandler,
+    'caizhilian.share.delete': shareDeleteHandler,
+};