weaver-work-cli 0.1.32 → 0.1.36

package/dist/shortcuts/cowork/operations/member-write.js

@@ -0,0 +1,283 @@
+import { CoworkCliError, coworkNotFoundError, coworkPartialError, coworkValidationError } from '../errors.js';
+import { READ_BEFORE_WRITE, WRITE, SCHEMA_ID, coworkSuccess, schemaOf, } from './types.js';
+import { assertEnum, compact, normalizeList, requireConfirm, toId, toIdList, toPositiveInt, unwrapData, verifyLease, } from './shared.js';
+function isNetworkError(error) {
+    return error instanceof CoworkCliError && error.type === 'network';
+}
+const MEMBER_ACTIONS = ['invite', 'rejoin', 'join'];
+/** 三动作的接口与表单形状（invite/rejoin 由 behavior 域、join 由 apply 域承担）。 */
+const MEMBER_SPECS = {
+    invite: { path: '/api/cowork/behavior/inviteJoin' },
+    rejoin: { path: '/api/cowork/behavior/reJoin' },
+    join: { path: '/api/cowork/apply/applyCwItem' },
+};
+/** 已在协作内的人员（用参与人列表判定，仅作重复邀请提示，不作为存在性判据）。 */
+async function currentParticipantIds(env, coworkId) {
+    try {
+        const response = await env.host.request({
+            method: 'POST',
+            path: '/api/cowork/view/participationAllList',
+            body: { id: coworkId, participationFrom: 'participant', current: 1, pageSize: 100 },
+            operation: 'cowork.member.action.prepare',
+        });
+        const { data } = normalizeList(response);
+        const rows = Array.isArray(data) ? data : [];
+        return new Set(rows.map((row) => String(row.id ?? row.userId ?? '')).filter(Boolean));
+    }
+    catch {
+        // 参与人列表失败不阻断主流程：它只用于"可能重复邀请"的提示。
+        return new Set();
+    }
+}
+const memberActionPrepare = {
+    name: 'cowork.member.action.prepare',
+    resource: 'cowork',
+    method: 'member.action.prepare',
+    action: 'cowork.member.action.prepare',
+    summary: '成员动作摘要：invite 邀请 / rejoin 重新加入 / join 申请加入；先读协作详情确认存在，并提示已在协作内的人员，不写入',
+    risk: READ_BEFORE_WRITE,
+    inputSchema: schemaOf({
+        action: { type: 'string', enum: [...MEMBER_ACTIONS], description: 'invite 邀请他人 / rejoin 重新加入 / join 申请加入（我）' },
+        coworkId: { ...SCHEMA_ID, description: '协作 id' },
+        userIds: {
+            type: 'array',
+            items: SCHEMA_ID,
+            maxItems: 50,
+            description: 'invite / rejoin 必填：人员 id 数组（join 不需要）',
+        },
+    }, { required: ['action', 'coworkId'] }),
+    handler: async (args, env) => {
+        const action = assertEnum(args.action, MEMBER_ACTIONS, 'action');
+        const coworkId = toId(args.coworkId, 'coworkId');
+        const detailResponse = await env.host.request({
+            method: 'POST',
+            path: '/api/cowork/view/viewCowork',
+            form: { id: coworkId },
+            operation: 'cowork.member.action.prepare',
+        });
+        const detail = (unwrapData(detailResponse) ?? {});
+        if (!detail || Object.keys(detail).length === 0) {
+            throw coworkNotFoundError('item_not_found', `协作 ${coworkId} 不存在或无权查看`);
+        }
+        let userIds;
+        let alreadyIn = [];
+        if (action !== 'join') {
+            userIds = toIdList(args.userIds, 'userIds');
+            if (!userIds || userIds.length === 0) {
+                throw coworkValidationError('user_ids_required', `${action} 必须提供 userIds（人员 id 数组）`);
+            }
+            const current = await currentParticipantIds(env, coworkId);
+            alreadyIn = userIds.filter((id) => current.has(id));
+        }
+        const session = await env.host.getSession();
+        const continuation = await env.continuation.issue({
+            operation: 'cowork.member.action.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            action,
+            coworkId,
+            userIds: userIds ?? [],
+        });
+        return coworkSuccess('cowork.member.action.prepare', {
+            summary: {
+                action,
+                coworkId,
+                itemName: detail.itemName ?? '',
+                userIds: userIds ?? undefined,
+                userCount: userIds?.length,
+                alreadyParticipant: alreadyIn.length > 0 ? alreadyIn : undefined,
+                note: alreadyIn.length > 0
+                    ? '上述人员已在协作参与人列表中，重复邀请可能被服务端判为无变化；请与用户确认后决定'
+                    : undefined,
+            },
+            continuation,
+        });
+    },
+};
+const memberActionApply = {
+    name: 'cowork.member.action.apply',
+    resource: 'cowork',
+    method: 'member.action.apply',
+    action: 'cowork.member.action.apply',
+    summary: '执行成员动作（invite / rejoin / join），需 confirm=true 与 continuation',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        action: { type: 'string', enum: [...MEMBER_ACTIONS] },
+        coworkId: { ...SCHEMA_ID },
+        userIds: { type: 'array', items: SCHEMA_ID, maxItems: 50 },
+        confirm: { type: 'boolean' },
+        continuation: { type: 'string' },
+    }, { required: ['action', 'coworkId', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        requireConfirm(args, 'cowork.member.action.apply');
+        const lease = await verifyLease(args, 'cowork.member.action.apply', env);
+        const action = assertEnum(args.action, MEMBER_ACTIONS, 'action');
+        const coworkId = toId(args.coworkId, 'coworkId');
+        if (lease.action !== action || lease.coworkId !== coworkId) {
+            throw coworkValidationError('target_changed', '与 prepare 时的目标不一致，请重新执行 prepare');
+        }
+        let form;
+        if (action === 'join') {
+            form = { ids: coworkId };
+        }
+        else {
+            const userIds = toIdList(args.userIds, 'userIds') ?? lease.userIds ?? [];
+            const leaseIds = lease.userIds ?? [];
+            if (userIds.join(',') !== leaseIds.join(',')) {
+                throw coworkValidationError('target_changed', '人员名单与 prepare 时不一致，请重新执行 prepare');
+            }
+            if (userIds.length === 0) {
+                throw coworkValidationError('user_ids_required', `${action} 必须提供 userIds`);
+            }
+            form = { ids: userIds.join(','), coworkId };
+        }
+        let response;
+        try {
+            response = await env.host.request({
+                method: 'POST',
+                path: MEMBER_SPECS[action].path,
+                form,
+                operation: 'cowork.member.action.apply',
+            });
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw coworkPartialError('成员动作请求已发出但未收到确定结果，禁止自动重试：请用 cowork.participant.list 核对参与人', { action, coworkId });
+            }
+            throw error;
+        }
+        return coworkSuccess('cowork.member.action.apply', {
+            action,
+            coworkId,
+            userIds: action === 'join' ? undefined : String(form.ids).split(','),
+            result: unwrapData(response) ?? null,
+        });
+    },
+};
+const DECISIONS = ['approve', 'refuse'];
+const DECISION_PATHS = {
+    approve: '/api/cowork/apply/approveCwItem',
+    refuse: '/api/cowork/apply/refuseCwItem',
+};
+/** 在待审批列表里定位申请记录（写动作必须先查真实 id，禁止猜）。 */
+async function locateApplyRecord(env, applyId, maxPages = 5, pageSize = 50) {
+    for (let page = 1; page <= maxPages; page++) {
+        const response = await env.host.request({
+            method: 'POST',
+            path: '/api/cowork/apply/getCoworkApplyApproveList',
+            body: {
+                current: page,
+                applyerCondition: 'bl',
+                applyer: '',
+                applyerDeptCondition: 'bl',
+                applyerDept: '',
+                itemNameCondition: 'in',
+                type: 'and',
+            },
+            operation: 'cowork.apply.decide.prepare',
+        });
+        const { data } = normalizeList(response);
+        const rows = Array.isArray(data) ? data : [];
+        if (rows.length === 0)
+            return null;
+        const hit = rows.find((row) => String(row.id ?? '') === applyId);
+        if (hit)
+            return hit;
+        if (rows.length < pageSize)
+            return null;
+    }
+    return null;
+}
+const applyDecidePrepare = {
+    name: 'cowork.apply.decide.prepare',
+    resource: 'cowork',
+    method: 'apply.decide.prepare',
+    action: 'cowork.apply.decide.prepare',
+    summary: '加入申请审批摘要（approve 通过 / refuse 拒绝）：在待审批列表中定位申请记录并回显申请人与协作主题，不写入',
+    risk: READ_BEFORE_WRITE,
+    inputSchema: schemaOf({
+        decision: { type: 'string', enum: [...DECISIONS], description: 'approve 通过 / refuse 拒绝' },
+        applyId: { ...SCHEMA_ID, description: '申请记录 id（来自 cowork.list scope=approve）' },
+        maxPages: { type: 'integer', minimum: 1, maximum: 20, description: '定位记录的翻页上限，默认 5' },
+    }, { required: ['decision', 'applyId'] }),
+    handler: async (args, env) => {
+        const decision = assertEnum(args.decision, DECISIONS, 'decision');
+        const applyId = toId(args.applyId, 'applyId');
+        const maxPages = toPositiveInt(args.maxPages, 'maxPages') ?? 5;
+        const hit = await locateApplyRecord(env, applyId, maxPages);
+        if (!hit) {
+            throw coworkNotFoundError('apply_not_found', `在前 ${maxPages} 页待审批列表中未找到申请记录 ${applyId}：请先用 cowork.list（scope=approve）确认，禁止对未确认的记录审批`);
+        }
+        const session = await env.host.getSession();
+        const continuation = await env.continuation.issue({
+            operation: 'cowork.apply.decide.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            decision,
+            applyId,
+        });
+        return coworkSuccess('cowork.apply.decide.prepare', {
+            summary: {
+                decision,
+                applyId,
+                itemName: hit.itemName ?? null,
+                applyer: hit.applyerName ?? hit.applyer ?? null,
+                applyTime: hit.applyTime ?? hit.createTime ?? null,
+            },
+            continuation,
+        });
+    },
+};
+const applyDecideApply = {
+    name: 'cowork.apply.decide.apply',
+    resource: 'cowork',
+    method: 'apply.decide.apply',
+    action: 'cowork.apply.decide.apply',
+    summary: '执行加入申请审批（approve / refuse），需 confirm=true 与 continuation',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        decision: { type: 'string', enum: [...DECISIONS] },
+        applyId: { ...SCHEMA_ID },
+        confirm: { type: 'boolean' },
+        continuation: { type: 'string' },
+    }, { required: ['decision', 'applyId', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        requireConfirm(args, 'cowork.apply.decide.apply');
+        const lease = await verifyLease(args, 'cowork.apply.decide.apply', env);
+        const decision = assertEnum(args.decision, DECISIONS, 'decision');
+        const applyId = toId(args.applyId, 'applyId');
+        if (lease.decision !== decision || lease.applyId !== applyId) {
+            throw coworkValidationError('target_changed', '与 prepare 时的目标不一致，请重新执行 prepare');
+        }
+        let response;
+        try {
+            response = await env.host.request({
+                method: 'POST',
+                path: DECISION_PATHS[decision],
+                form: compact({ ids: applyId }),
+                operation: 'cowork.apply.decide.apply',
+            });
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw coworkPartialError('审批请求已发出但未收到确定结果，禁止自动重试：请用 cowork.list（scope=approve）核对是否已消失', { decision, applyId });
+            }
+            throw error;
+        }
+        return coworkSuccess('cowork.apply.decide.apply', {
+            decision,
+            applyId,
+            result: unwrapData(response) ?? null,
+        });
+    },
+};
+export const coworkMemberWriteOperations = [
+    memberActionPrepare,
+    memberActionApply,
+    applyDecidePrepare,
+    applyDecideApply,
+];

package/dist/shortcuts/cowork/operations/permission-write.js

@@ -0,0 +1,286 @@
+import { CoworkCliError, coworkNotFoundError, coworkPartialError, coworkValidationError } from '../errors.js';
+import { READ_BEFORE_WRITE, WRITE, SCHEMA_ID, coworkSuccess, schemaOf, } from './types.js';
+import { normalizeList, requireConfirm, toId, unwrapData, verifyLease, } from './shared.js';
+function isNetworkError(error) {
+    return error instanceof CoworkCliError && error.type === 'network';
+}
+const DEFAULT_PERMISSION_ID = '5';
+/** 共享权限列表（写操作前定位真实记录的唯一来源）。 */
+async function listSharePermissions(env, coworkId, permissionId, pageSize = 50) {
+    const response = await env.host.request({
+        method: 'POST',
+        path: '/api/cowork/permission/getCoworkSharePermissionList',
+        body: {
+            sourceId: coworkId,
+            permissionId,
+            sourceType: 1,
+            current: 1,
+            pageSize,
+            id: coworkId,
+            permissionFrom: permissionId,
+        },
+        operation: 'cowork.permission.list',
+    });
+    const { data } = normalizeList(response);
+    return Array.isArray(data) ? data : [];
+}
+const permAddPrepare = {
+    name: 'cowork.permission.add.prepare',
+    resource: 'cowork',
+    method: 'permission.add.prepare',
+    action: 'cowork.permission.add.prepare',
+    summary: '新增共享对象的摘要：先读协作详情与现有共享权限列表，提示该人员是否已在，不写入',
+    risk: READ_BEFORE_WRITE,
+    inputSchema: schemaOf({
+        coworkId: { ...SCHEMA_ID, description: '协作 id' },
+        userId: { ...SCHEMA_ID, description: '被授权人员 id' },
+        userName: { type: 'string', maxLength: 100, description: '人员姓名（接口必填，用于展示）' },
+        userDept: { type: 'string', maxLength: 200, description: '部门名（可选，缺失可能导致服务端拒绝）' },
+        userTitle: { type: 'string', maxLength: 200, description: '岗位名（可选）' },
+        userCid: { type: 'string', maxLength: 100, description: '人员 cid（部分环境必填，缺失会被拒）' },
+        permissionId: { ...SCHEMA_ID, description: `权限类型 id，默认 ${DEFAULT_PERMISSION_ID}` },
+    }, { required: ['coworkId', 'userId', 'userName'] }),
+    handler: async (args, env) => {
+        const coworkId = toId(args.coworkId, 'coworkId');
+        const userId = toId(args.userId, 'userId');
+        const userName = String(args.userName ?? '').trim();
+        if (!userName)
+            throw coworkValidationError('user_name_required', 'userName 必填（接口要求展示名）');
+        const permissionId = toId(args.permissionId, 'permissionId') ?? DEFAULT_PERMISSION_ID;
+        const detailResponse = await env.host.request({
+            method: 'POST',
+            path: '/api/cowork/view/viewCowork',
+            form: { id: coworkId },
+            operation: 'cowork.permission.add.prepare',
+        });
+        const detail = (unwrapData(detailResponse) ?? {});
+        if (!detail || Object.keys(detail).length === 0) {
+            throw coworkNotFoundError('item_not_found', `协作 ${coworkId} 不存在或无权查看`);
+        }
+        const existing = await listSharePermissions(env, coworkId, permissionId);
+        const already = existing.some((row) => {
+            const rowUserId = String(row.userid ?? row.userId ?? row.id ?? '');
+            return rowUserId === userId;
+        });
+        const session = await env.host.getSession();
+        const continuation = await env.continuation.issue({
+            operation: 'cowork.permission.add.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            coworkId,
+            targetUserId: userId,
+            userName,
+            permissionId,
+        });
+        return coworkSuccess('cowork.permission.add.prepare', {
+            summary: {
+                coworkId,
+                itemName: detail.itemName ?? '',
+                permissionId,
+                targetUser: { id: userId, name: userName, dept: args.userDept ?? null, title: args.userTitle ?? null },
+                alreadyShared: already,
+                note: already
+                    ? '该人员已在共享权限列表中，重复新增可能被服务端判为无变化'
+                    : (args.userCid ? undefined : '未提供 userCid：部分环境要求 cid/部门/岗位齐全才接受新增，失败时可补齐后重试'),
+            },
+            continuation,
+        });
+    },
+};
+const permAddApply = {
+    name: 'cowork.permission.add.apply',
+    resource: 'cowork',
+    method: 'permission.add.apply',
+    action: 'cowork.permission.add.apply',
+    summary: '新增共享对象（需 confirm=true 与 continuation）',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        coworkId: { ...SCHEMA_ID },
+        userId: { ...SCHEMA_ID },
+        userName: { type: 'string', maxLength: 100 },
+        userDept: { type: 'string', maxLength: 200 },
+        userTitle: { type: 'string', maxLength: 200 },
+        userCid: { type: 'string', maxLength: 100 },
+        permissionId: { ...SCHEMA_ID },
+        confirm: { type: 'boolean' },
+        continuation: { type: 'string' },
+    }, { required: ['coworkId', 'userId', 'userName', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        requireConfirm(args, 'cowork.permission.add.apply');
+        const lease = await verifyLease(args, 'cowork.permission.add.apply', env);
+        const coworkId = toId(args.coworkId, 'coworkId');
+        const userId = toId(args.userId, 'userId');
+        if (lease.coworkId !== coworkId || lease.targetUserId !== userId) {
+            throw coworkValidationError('target_changed', '协作或人员与 prepare 时不一致，请重新执行 prepare');
+        }
+        const userName = String(args.userName ?? '').trim();
+        if (!userName)
+            throw coworkValidationError('user_name_required', 'userName 必填');
+        const permissionId = toId(args.permissionId, 'permissionId') ?? String(lease.permissionId ?? DEFAULT_PERMISSION_ID);
+        const dept = typeof args.userDept === 'string' ? args.userDept : '';
+        const position = typeof args.userTitle === 'string' ? args.userTitle : '';
+        const obj = {
+            id: userId,
+            userid: userId,
+            name: userName,
+            content: userName,
+            title: [userName, dept, position].filter(Boolean).join('|'),
+            contentDesc: [userName, dept].filter(Boolean).join('|'),
+            statusCode: 'normal',
+            department: dept,
+            position,
+            cid: typeof args.userCid === 'string' ? args.userCid : '',
+        };
+        const body = {
+            sourceId: coworkId,
+            permissionId,
+            sourceType: 1,
+            refId: coworkId,
+            permissionFrom: permissionId,
+            objType: 'resource',
+            obj_id: [obj],
+        };
+        let response;
+        try {
+            response = await env.host.request({
+                method: 'POST',
+                path: '/api/cowork/permission/addSharePermission',
+                body,
+                operation: 'cowork.permission.add.apply',
+            });
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw coworkPartialError('新增共享对象请求已发出但未收到确定结果，禁止自动重试：请用 cowork.permission.list 核对', { coworkId, userId });
+            }
+            throw error;
+        }
+        return coworkSuccess('cowork.permission.add.apply', {
+            coworkId,
+            permissionId,
+            userId,
+            userName,
+            result: unwrapData(response) ?? null,
+        });
+    },
+};
+const permRemovePrepare = {
+    name: 'cowork.permission.remove.prepare',
+    resource: 'cowork',
+    method: 'permission.remove.prepare',
+    action: 'cowork.permission.remove.prepare',
+    summary: '删除共享对象的摘要：先按 pkId 在共享权限列表中定位真实记录并回显，不写入',
+    risk: READ_BEFORE_WRITE,
+    inputSchema: schemaOf({
+        coworkId: { ...SCHEMA_ID, description: '协作 id' },
+        pkId: { ...SCHEMA_ID, description: '共享记录 id（来自 cowork.permission.list 的行 id）' },
+        permissionId: { ...SCHEMA_ID, description: `权限类型 id，默认 ${DEFAULT_PERMISSION_ID}` },
+    }, { required: ['coworkId', 'pkId'] }),
+    handler: async (args, env) => {
+        const coworkId = toId(args.coworkId, 'coworkId');
+        const pkId = toId(args.pkId, 'pkId');
+        const permissionId = toId(args.permissionId, 'permissionId') ?? DEFAULT_PERMISSION_ID;
+        const rows = await listSharePermissions(env, coworkId, permissionId);
+        const hit = rows.find((row) => String(row.id ?? '') === pkId);
+        if (!hit) {
+            throw coworkNotFoundError('permission_record_not_found', `共享权限列表中未找到 id=${pkId} 的记录，无法删除（禁止凭空构造 datas 提交）`);
+        }
+        const session = await env.host.getSession();
+        const continuation = await env.continuation.issue({
+            operation: 'cowork.permission.remove.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            coworkId,
+            pkId,
+            permissionId,
+        });
+        return coworkSuccess('cowork.permission.remove.prepare', {
+            summary: {
+                coworkId,
+                pkId,
+                permissionId,
+                targetUser: {
+                    id: hit.userid ?? hit.userId ?? hit.id ?? null,
+                    name: hit.username ?? hit.name ?? hit.content ?? null,
+                },
+                warning: '删除共享对象后该人员将失去对应权限，页面无撤销入口',
+            },
+            continuation,
+        });
+    },
+};
+const permRemoveApply = {
+    name: 'cowork.permission.remove.apply',
+    resource: 'cowork',
+    method: 'permission.remove.apply',
+    action: 'cowork.permission.remove.apply',
+    summary: '删除共享对象（需 confirm=true 与 continuation）：apply 阶段重新取真实记录后全量回传',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        coworkId: { ...SCHEMA_ID },
+        pkId: { ...SCHEMA_ID },
+        permissionId: { ...SCHEMA_ID },
+        confirm: { type: 'boolean' },
+        continuation: { type: 'string' },
+    }, { required: ['coworkId', 'pkId', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        requireConfirm(args, 'cowork.permission.remove.apply');
+        const lease = await verifyLease(args, 'cowork.permission.remove.apply', env);
+        const coworkId = toId(args.coworkId, 'coworkId');
+        const pkId = toId(args.pkId, 'pkId');
+        if (lease.coworkId !== coworkId || lease.pkId !== pkId) {
+            throw coworkValidationError('target_changed', '协作或记录与 prepare 时不一致，请重新执行 prepare');
+        }
+        const permissionId = toId(args.permissionId, 'permissionId') ?? String(lease.permissionId ?? DEFAULT_PERMISSION_ID);
+        // 写操作纪律：删除前必须重新取当前真实记录（记录内容可能已被他人修改），全量回传。
+        const rows = await listSharePermissions(env, coworkId, permissionId);
+        const record = rows.find((row) => String(row.id ?? '') === pkId);
+        if (!record) {
+            throw coworkNotFoundError('permission_record_gone', `共享记录 ${pkId} 已不存在（可能已被他人移除），无需重复删除`);
+        }
+        const body = {
+            sourceId: coworkId,
+            permissionId,
+            sourceType: 1,
+            id: coworkId,
+            permissionFrom: permissionId,
+            ids: pkId,
+            datas: [record],
+        };
+        let response;
+        try {
+            response = await env.host.request({
+                method: 'POST',
+                path: '/api/cowork/permission/deleteSharePermissionByPKIds',
+                body,
+                operation: 'cowork.permission.remove.apply',
+            });
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw coworkPartialError('删除共享对象请求已发出但未收到确定结果，禁止自动重试：请用 cowork.permission.list 核对', { coworkId, pkId });
+            }
+            throw error;
+        }
+        // 回查：确认该记录已从列表中消失，避免"接口说成功但实际还在"。
+        const after = await listSharePermissions(env, coworkId, permissionId).catch(() => null);
+        const stillThere = after ? after.some((row) => String(row.id ?? '') === pkId) : null;
+        return coworkSuccess('cowork.permission.remove.apply', {
+            coworkId,
+            pkId,
+            removed: stillThere === false ? true : undefined,
+            verified: stillThere !== null,
+            result: unwrapData(response) ?? null,
+        });
+    },
+};
+export const coworkPermissionWriteOperations = [
+    permAddPrepare,
+    permAddApply,
+    permRemovePrepare,
+    permRemoveApply,
+];