weaver-work-cli 0.1.1 → 0.1.4

package/dist/shortcuts/calendar/operations/shared.js

@@ -0,0 +1,132 @@
+import { calendarValidationError } from '../errors.js';
+/** 原型污染防护：禁止出现在输入对象中的键。 */
+const FORBIDDEN_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+export function asObject(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw calendarValidationError('input_not_object', '输入必须是 JSON 对象');
+    }
+    return value;
+}
+export function assertNoForbiddenKeys(input) {
+    for (const key of Object.keys(input)) {
+        if (FORBIDDEN_KEYS.has(key)) {
+            throw calendarValidationError('forbidden_key', `输入包含非法字段：${key}`);
+        }
+    }
+}
+/** 校验枚举取值。 */
+export function assertEnum(value, allowed, field) {
+    const text = typeof value === 'string' ? value : String(value);
+    if (!allowed.includes(text)) {
+        throw calendarValidationError('enum_invalid', `${field} 取值必须是 ${allowed.join(' / ')} 之一`);
+    }
+    return text;
+}
+/** Switch 字段：必须传数字 0/1，禁止布尔值。 */
+export function assertSwitch(value, field) {
+    if (value === undefined || value === null) {
+        throw calendarValidationError('switch_required', `${field} 必须传数字 0 或 1，不能传布尔值`);
+    }
+    if (typeof value === 'boolean') {
+        throw calendarValidationError('switch_invalid', `${field} 必须传数字 0 或 1，不能传布尔值`);
+    }
+    const numeric = Number(value);
+    if (!Number.isFinite(numeric) || (numeric !== 0 && numeric !== 1)) {
+        throw calendarValidationError('switch_invalid', `${field} 必须传数字 0 或 1`);
+    }
+    return numeric;
+}
+/** 校验 yyyy-MM-dd HH:mm 时间格式。 */
+export function assertDateTimeMinute(value, field) {
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}$/.test(value)) {
+        throw calendarValidationError('datetime_invalid', `${field} 必须是 yyyy-MM-dd HH:mm 格式`);
+    }
+    return value;
+}
+/** 校验 yyyy-MM-dd 日期格式。 */
+export function assertDate(value, field) {
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+        throw calendarValidationError('date_invalid', `${field} 必须是 yyyy-MM-dd 格式`);
+    }
+    return value;
+}
+/** 移除值为 undefined 的键。 */
+export function compact(body) {
+    for (const key of Object.keys(body)) {
+        if (body[key] === undefined)
+            delete body[key];
+    }
+    return body;
+}
+export function pickDefined(value, keys) {
+    const result = {};
+    for (const key of keys) {
+        if (value[key] !== undefined)
+            result[key] = value[key];
+    }
+    return result;
+}
+/** 选项 ID 归一化：接受数字或数字字符串，转为字符串。 */
+export function toIdString(value, field) {
+    if (value === undefined || value === null || value === '') {
+        throw calendarValidationError('id_invalid', `${field} 必须是日程数据 ID`);
+    }
+    const text = String(value);
+    if (!/^\d+$/.test(text)) {
+        throw calendarValidationError('id_invalid', `${field} 必须是日程数据 ID`);
+    }
+    return text;
+}
+/**
+ * 从详情接口的选项字段（[{name,id}] 数组）提取选项 ID 标量。
+ * 详情返回 `[{name:"会议日程",id:"1147539996611665922"}]`，写入时需传 `"1147539996611665922"`。
+ */
+export function optionId(value) {
+    if (Array.isArray(value) && value.length > 0 && typeof value[0] === 'object' && value[0] !== null) {
+        const id = value[0].id;
+        if (id !== undefined && id !== null && id !== '')
+            return String(id);
+        return undefined;
+    }
+    if (typeof value === 'string' && value)
+        return value;
+    if (typeof value === 'number')
+        return String(value);
+    return undefined;
+}
+/**
+ * 参与人字段：详情返回人员 ID 字符串（多个逗号分隔），写入时也传字符串。
+ * 原样透传，不做拆分。
+ */
+export function participantIds(value) {
+    if (typeof value === 'string' && value)
+        return value;
+    if (Array.isArray(value))
+        return value.map((item) => String(item)).join(',');
+    return undefined;
+}
+/** 日程持续时间默认 1 小时：只给 start_time 时补 end_time。 */
+export function defaultEndTime(startTime) {
+    const match = /^(\d{4}-\d{2}-\d{2}) (\d{2}):(\d{2})$/.exec(startTime);
+    if (!match)
+        return startTime;
+    const [, date, hour, minute] = match;
+    let nextHour = Number(hour) + 1;
+    let nextDay = date;
+    if (nextHour >= 24) {
+        nextHour -= 24;
+        const [y, m, d] = date.split('-').map(Number);
+        const tomorrow = new Date(Date.UTC(y, m - 1, d + 1));
+        nextDay = `${tomorrow.getUTCFullYear()}-${String(tomorrow.getUTCMonth() + 1).padStart(2, '0')}-${String(tomorrow.getUTCDate()).padStart(2, '0')}`;
+    }
+    return `${nextDay} ${String(nextHour).padStart(2, '0')}:${minute}`;
+}
+// ---------------------------------------------------------------------------
+// 业务枚举（来自源资料单接口文档）
+// ---------------------------------------------------------------------------
+export const START_REMINDER_VALUES = ['NOW', 'M5', 'M15', 'H1', 'D1', 'CUSTOM'];
+export const REMIND_TYPE_VALUES = ['system', 'message', 'email'];
+export const REPEAT_TYPE_VALUES = ['NONE', 'D1', 'W1', 'W2', 'M1', 'CUSTOM'];
+export const REPEAT_CUSTOM_TYPE_VALUES = ['D', 'W', 'M'];
+export const REPEAT_WEEK_UNIT_VALUES = ['MO', 'TU', 'WE', 'TH', 'FR', 'SA', 'SU'];
+export const REPEAT_END_TYPE_VALUES = ['0', '1', '2'];

package/dist/shortcuts/calendar/operations/types.js

@@ -0,0 +1,25 @@
+export function calendarSuccess(action, data, meta) {
+    const payload = { ok: true, action, data };
+    if (meta && Object.keys(meta).length > 0)
+        payload.meta = meta;
+    return payload;
+}
+/** 构造「对象类型 + 严格禁止额外字段」的 JSON Schema。 */
+export function schemaOf(properties, options = {}) {
+    return {
+        type: 'object',
+        additionalProperties: false,
+        properties,
+        ...(options.required?.length ? { required: options.required } : {}),
+        ...(options.description ? { description: options.description } : {}),
+    };
+}
+/** 日程数据 ID：源资料返回字符串，请求也接受数字或数字字符串。 */
+export const SCHEMA_ID = { oneOf: [{ type: 'integer' }, { type: 'string', pattern: '^\\d+$' }] };
+export const SCHEMA_ID_LIST = { type: 'array', items: SCHEMA_ID };
+/** 日程时间格式 yyyy-MM-dd HH:mm（不含秒）。 */
+export const SCHEMA_DATETIME_MINUTE = { type: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}$' };
+/** 日期格式 yyyy-MM-dd。 */
+export const SCHEMA_DATE = { type: 'string', pattern: '^\\d{4}-\\d{2}-\\d{2}$' };
+/** Switch 字段：仅接受数字 0/1（布尔值会触发服务端报错）。 */
+export const SCHEMA_SWITCH = { type: 'integer', enum: [0, 1] };

package/dist/shortcuts/calendar/operations/write.js

@@ -0,0 +1,439 @@
+import { createHash } from 'node:crypto';
+import { calendarConfirmationError, calendarPartialError, calendarValidationError, CalendarCliError } from '../errors.js';
+import { calendarSuccess, schemaOf, SCHEMA_ID, SCHEMA_DATETIME_MINUTE, SCHEMA_SWITCH, SCHEMA_DATE } from './types.js';
+import { assertDateTimeMinute, defaultEndTime, optionId, participantIds, pickDefined, } from './shared.js';
+const CONTINUATION_TTL_SECONDS = 600;
+// 日程 mainTable 可选业务字段（创建/更新共用）
+const OPTIONAL_FIELDS = [
+    'next_start_remind',
+    'next_end_remind',
+    'all_day',
+    'agn_desc',
+    'location',
+    'place',
+    'part_receipt',
+    'remind',
+    'start_reminder',
+    'remind_type',
+    'start_hours',
+    'start_mins',
+    'end_reminder',
+    'end_hours',
+    'end_mins',
+    'repeat_type',
+    'repeat_custom_type',
+    'repeat_custom_cycle',
+    'repeat_week_unit',
+    'repeat_month_unit',
+    'repeat_end_date',
+    'repeat_end_type',
+    'repeat_end_num',
+    'repeat_desc',
+];
+const MAIN_TABLE_SCHEMA = {
+    agn_name: { type: 'string', minLength: 1, description: '日程名称' },
+    start_time: SCHEMA_DATETIME_MINUTE,
+    end_time: SCHEMA_DATETIME_MINUTE,
+    participants: { type: 'string', description: '参与人人员 ID（多个逗号分隔）；缺省时自动带当前操作人' },
+    agn_type: { type: 'string', description: '日程类型选项 ID（先通过 calendar.type.list 获取）' },
+    priority: { type: 'string', description: '紧急程度选项 ID（先通过 calendar.priority.list 获取）' },
+    next_start_remind: { type: 'string', description: '下次提醒时间（开始前）yyyy-MM-dd HH:mm:ss' },
+    next_end_remind: { type: 'string', description: '下次提醒时间（结束前）yyyy-MM-dd HH:mm:ss' },
+    all_day: SCHEMA_SWITCH,
+    agn_desc: { type: 'string', description: '日程详情' },
+    location: { type: 'string', description: '位置' },
+    place: { type: 'string', description: '地点' },
+    part_receipt: SCHEMA_SWITCH,
+    remind: SCHEMA_SWITCH,
+    start_reminder: { type: 'string', enum: ['NOW', 'M5', 'M15', 'H1', 'D1', 'CUSTOM'], description: '开始前提醒' },
+    remind_type: { type: 'string', enum: ['system', 'message', 'email'], description: '提醒方式' },
+    start_hours: { type: 'integer', description: '提前小时（start_reminder=CUSTOM 时）' },
+    start_mins: { type: 'integer', description: '提前分钟（start_reminder=CUSTOM 时）' },
+    end_reminder: { type: 'string', enum: ['NOW', 'M5', 'M15', 'H1', 'D1', 'CUSTOM'], description: '结束前提醒' },
+    end_hours: { type: 'integer', description: '结束小时（end_reminder=CUSTOM 时）' },
+    end_mins: { type: 'integer', description: '结束分钟（end_reminder=CUSTOM 时）' },
+    repeat_type: { type: 'string', enum: ['NONE', 'D1', 'W1', 'W2', 'M1', 'CUSTOM'], description: '重复类型' },
+    repeat_custom_type: { type: 'string', enum: ['D', 'W', 'M'], description: '重复频率（repeat_type=CUSTOM 时）' },
+    repeat_custom_cycle: { type: 'integer', description: '重复间隔' },
+    repeat_week_unit: { type: 'string', enum: ['MO', 'TU', 'WE', 'TH', 'FR', 'SA', 'SU'], description: '每周的' },
+    repeat_month_unit: { type: 'string', description: '每月的（1~31）' },
+    repeat_end_date: SCHEMA_DATE,
+    repeat_end_type: { type: 'string', enum: ['0', '1', '2'], description: '结束类型：0 指定时间 / 1 指定次数 / 2 永不结束' },
+    repeat_end_num: { type: 'integer', description: '次数（repeat_end_type=1 时）' },
+    repeat_desc: { type: 'string', description: '重复规则描述' },
+};
+function fingerprint(value) {
+    return createHash('sha256').update(JSON.stringify(value ?? null)).digest('hex').slice(0, 32);
+}
+function requireConfirm(args, action) {
+    if (args.confirm !== true) {
+        throw calendarConfirmationError(action, { hint: '重新调用时传入 confirm=true 与 prepare 返回的 continuation' });
+    }
+}
+async function verifyLease(args, action, env) {
+    const lease = await env.continuation.verify(args.continuation, action);
+    const session = await env.host.getSession();
+    if (lease.baseUrl !== session.baseUrl || lease.profile !== session.profile || lease.userId !== session.userId) {
+        throw calendarValidationError('context_mismatch', '确认上下文已变化（租户或登录账号不同），请重新执行 prepare');
+    }
+    return lease;
+}
+function isNetworkError(error) {
+    return error instanceof CalendarCliError && error.type === 'network';
+}
+/** 构造写入接口 datajson 请求体（datas[].mainTable 结构）。 */
+async function buildWriteDatajson(host, mainTableList) {
+    const session = await host.getSession();
+    return {
+        datajson: {
+            operationinfo: { printCost: false },
+            datas: mainTableList.map((mainTable) => ({ mainTable })),
+            header: { operator: session.userId },
+        },
+    };
+}
+/**
+ * 归一化创建/更新的 mainTable：校验必填、补默认值（参与人默认当前人、时长默认 1 小时），
+ * 并拾取可选字段。返回完整 mainTable 与用于展示的 preview。
+ */
+async function normalizeMainTable(args, host) {
+    const session = await host.getSession();
+    const agnName = args.agn_name;
+    if (typeof agnName !== 'string' || !agnName.trim()) {
+        throw calendarValidationError('agn_name_required', 'agn_name（日程名称）必填');
+    }
+    const startTime = assertDateTimeMinute(args.start_time, 'start_time');
+    const endTime = args.end_time !== undefined
+        ? assertDateTimeMinute(args.end_time, 'end_time')
+        : defaultEndTime(startTime);
+    const participants = args.participants !== undefined && args.participants !== ''
+        ? args.participants
+        : session.userId;
+    const mainTable = {
+        agn_name: agnName.trim(),
+        start_time: startTime,
+        end_time: endTime,
+        participants,
+        ...pickDefined(args, [...OPTIONAL_FIELDS]),
+    };
+    // 必填但允许在 create 里显式校验（update 走全量覆盖，字段来自详情合并，可不强制）
+    if (args.agn_type !== undefined)
+        mainTable.agn_type = args.agn_type;
+    if (args.priority !== undefined)
+        mainTable.priority = args.priority;
+    return mainTable;
+}
+// ---------------------------------------------------------------------------
+// 创建日程
+// ---------------------------------------------------------------------------
+const calendarCreatePrepare = {
+    name: 'calendar.create.prepare',
+    resource: 'calendar',
+    method: 'create.prepare',
+    action: 'calendar.create.prepare',
+    summary: '准备创建日程：校验字段、补默认值（参与人默认当前人、时长默认 1 小时）并生成确认预览，不写入',
+    capability: 'calendar',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({ ...MAIN_TABLE_SCHEMA }, { required: ['agn_name', 'start_time'] }),
+    handler: async (args, { host, continuation }) => {
+        if (args.agn_type === undefined) {
+            throw calendarValidationError('agn_type_required', 'agn_type（日程类型）必填，请先通过 calendar.type.list 获取选项 ID');
+        }
+        if (args.priority === undefined) {
+            throw calendarValidationError('priority_required', 'priority（紧急程度）必填，请先通过 calendar.priority.list 获取选项 ID');
+        }
+        const mainTable = await normalizeMainTable(args, host);
+        const session = await host.getSession();
+        const preview = { ...mainTable };
+        const token = await continuation.issue({
+            operation: 'calendar.create.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            payload: mainTable,
+            fingerprint: fingerprint(mainTable),
+        }, CONTINUATION_TTL_SECONDS * 1000);
+        return calendarSuccess('calendar.create.prepare', {
+            status: 'AWAITING_CONFIRMATION',
+            preview,
+            continuation: token,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
+        });
+    },
+};
+const calendarCreateApply = {
+    name: 'calendar.create.apply',
+    resource: 'calendar',
+    method: 'create.apply',
+    action: 'calendar.create.apply',
+    summary: '提交创建日程；必须在用户明确确认后调用，且要求 prepare 返回的 continuation',
+    capability: 'calendar',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({ ...MAIN_TABLE_SCHEMA, confirm: { const: true }, continuation: { type: 'string', minLength: 1 } }, { required: ['agn_name', 'start_time', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        requireConfirm(args, 'calendar.create.apply');
+        const lease = await verifyLease(args, 'calendar.create.apply', env);
+        const mainTable = await normalizeMainTable(args, env.host);
+        if (lease.fingerprint !== fingerprint(mainTable)) {
+            throw calendarValidationError('target_changed', '日程内容与 prepare 时的快照不一致，请重新执行 prepare');
+        }
+        const body = await buildWriteDatajson(env.host, [mainTable]);
+        let response;
+        try {
+            response = await env.host.request({
+                method: 'POST',
+                path: '/api/ebuilder/form/formdata/v2/saveFormData/createAgenda',
+                operation: 'calendar.create.apply',
+                body,
+            });
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw calendarPartialError('创建请求发送后连接中断，是否已创建不确定，禁止自动重试，请通过 calendar.list 复核', { attempted: { agn_name: mainTable.agn_name } }, { stage: 'create' });
+            }
+            throw error;
+        }
+        return calendarSuccess('calendar.create.apply', {
+            status: 'COMPLETE',
+            result: response,
+        });
+    },
+};
+// ---------------------------------------------------------------------------
+// 更新日程（全量覆盖）
+// ---------------------------------------------------------------------------
+/**
+ * 查询当前日程详情并把详情字段转换为更新接口要求的标量形态。
+ * 详情接口选项字段返回 [{name,id}] 数组，更新接口需传选项 ID 标量。
+ */
+async function fetchCurrentMainTable(id, host) {
+    const session = await host.getSession();
+    const response = await host.request({
+        method: 'POST',
+        path: '/api/ebuilder/form/formdata/v2/getFormDataByPk/queryAgenda',
+        operation: 'calendar.update.prepare',
+        body: {
+            datajson: {
+                mainTable: { id },
+                header: { operator: session.userId },
+            },
+        },
+    });
+    const datas = response?.datajson?.datas;
+    const mainTable = Array.isArray(datas) && datas[0]?.mainTable ? datas[0].mainTable : undefined;
+    if (!mainTable) {
+        throw calendarValidationError('not_found', `日程 ${id} 不存在或无权查看，无法更新`);
+    }
+    return mainTable;
+}
+function mainTableToUpdateFields(mainTable) {
+    const result = { id: mainTable.id };
+    const scalarKeys = [
+        'agn_name', 'start_time', 'end_time', 'agn_desc', 'place', 'location',
+        'next_start_remind', 'next_end_remind', 'all_day', 'part_receipt', 'remind',
+        'start_hours', 'start_mins', 'end_hours', 'end_mins', 'repeat_custom_cycle',
+        'repeat_end_date', 'repeat_end_num', 'repeat_desc',
+    ];
+    for (const key of scalarKeys) {
+        if (mainTable[key] !== undefined)
+            result[key] = mainTable[key];
+    }
+    // 选项字段数组 -> 标量 ID
+    const optionKeys = ['agn_type', 'priority', 'start_reminder', 'remind_type', 'end_reminder', 'repeat_type', 'repeat_custom_type', 'repeat_week_unit', 'repeat_month_unit', 'repeat_end_type'];
+    for (const key of optionKeys) {
+        const id = optionId(mainTable[key]);
+        if (id !== undefined)
+            result[key] = id;
+    }
+    // 参与人 ID 字符串
+    const participants = participantIds(mainTable.participants);
+    if (participants !== undefined)
+        result.participants = participants;
+    return result;
+}
+const calendarUpdatePrepare = {
+    name: 'calendar.update.prepare',
+    resource: 'calendar',
+    method: 'update.prepare',
+    action: 'calendar.update.prepare',
+    summary: '准备更新日程（全量覆盖）：先查当前详情，合并用户修改并生成确认预览，不写入',
+    capability: 'calendar',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        id: SCHEMA_ID,
+        ...MAIN_TABLE_SCHEMA,
+    }, { required: ['id'] }),
+    handler: async (args, { host, continuation }) => {
+        const id = String(args.id);
+        const current = await fetchCurrentMainTable(id, host);
+        const base = mainTableToUpdateFields(current);
+        // 用户传入的字段覆盖当前值
+        const overrides = {};
+        for (const key of ['agn_name', 'start_time', 'end_time', 'participants', 'agn_type', 'priority', ...OPTIONAL_FIELDS]) {
+            if (args[key] !== undefined)
+                overrides[key] = args[key];
+        }
+        // start_time 变化而 end_time 未指定时，默认 end_time = 新 start_time + 1 小时
+        if (overrides.start_time !== undefined && overrides.end_time === undefined) {
+            overrides.end_time = defaultEndTime(String(overrides.start_time));
+        }
+        const merged = { ...base, ...overrides };
+        const session = await host.getSession();
+        const token = await continuation.issue({
+            operation: 'calendar.update.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            payload: merged,
+            fingerprint: fingerprint(merged),
+        }, CONTINUATION_TTL_SECONDS * 1000);
+        return calendarSuccess('calendar.update.prepare', {
+            status: 'AWAITING_CONFIRMATION',
+            preview: {
+                before: base,
+                after: merged,
+                changedFields: Object.keys(overrides),
+            },
+            continuation: token,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
+        });
+    },
+};
+const calendarUpdateApply = {
+    name: 'calendar.update.apply',
+    resource: 'calendar',
+    method: 'update.apply',
+    action: 'calendar.update.apply',
+    summary: '提交更新日程；必须在用户明确确认后调用，且要求 prepare 返回的 continuation',
+    capability: 'calendar',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        id: SCHEMA_ID,
+        ...MAIN_TABLE_SCHEMA,
+        confirm: { const: true },
+        continuation: { type: 'string', minLength: 1 },
+    }, { required: ['id', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        requireConfirm(args, 'calendar.update.apply');
+        const lease = await verifyLease(args, 'calendar.update.apply', env);
+        const id = String(args.id);
+        const payload = (lease.payload || {});
+        if (String(payload.id ?? '') !== id) {
+            throw calendarValidationError('target_changed', '日程 ID 与 prepare 时的快照不一致，请重新执行 prepare');
+        }
+        const body = await buildWriteDatajson(env.host, [payload]);
+        let response;
+        try {
+            response = await env.host.request({
+                method: 'POST',
+                path: '/api/ebuilder/form/formdata/v2/updateFormData/updateAgenda',
+                operation: 'calendar.update.apply',
+                body,
+            });
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw calendarPartialError('更新请求发送后连接中断，是否已更新不确定，禁止自动重试，请通过 calendar.get 复核', { attempted: { id } }, { stage: 'update' });
+            }
+            throw error;
+        }
+        return calendarSuccess('calendar.update.apply', {
+            status: 'COMPLETE',
+            result: response,
+        });
+    },
+};
+// ---------------------------------------------------------------------------
+// 删除日程
+// ---------------------------------------------------------------------------
+const calendarDeletePrepare = {
+    name: 'calendar.delete.prepare',
+    resource: 'calendar',
+    method: 'delete.prepare',
+    action: 'calendar.delete.prepare',
+    summary: '准备删除日程：查当前详情并生成确认预览，不删除',
+    capability: 'calendar',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({ id: SCHEMA_ID }, { required: ['id'] }),
+    handler: async (args, { host, continuation }) => {
+        const id = String(args.id);
+        const current = await fetchCurrentMainTable(id, host);
+        const session = await host.getSession();
+        const preview = {
+            id,
+            agn_name: current.agn_name,
+            start_time: current.start_time,
+            end_time: current.end_time,
+        };
+        const token = await continuation.issue({
+            operation: 'calendar.delete.apply',
+            baseUrl: session.baseUrl,
+            profile: session.profile,
+            userId: session.userId,
+            payload: { id },
+            fingerprint: fingerprint({ id }),
+        }, CONTINUATION_TTL_SECONDS * 1000);
+        return calendarSuccess('calendar.delete.prepare', {
+            status: 'AWAITING_CONFIRMATION',
+            preview,
+            continuation: token,
+            expiresInSeconds: CONTINUATION_TTL_SECONDS,
+        });
+    },
+};
+const calendarDeleteApply = {
+    name: 'calendar.delete.apply',
+    resource: 'calendar',
+    method: 'delete.apply',
+    action: 'calendar.delete.apply',
+    summary: '提交删除日程；不可逆，必须在用户明确确认后调用',
+    capability: 'calendar',
+    risk: 'high-risk-write',
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        id: SCHEMA_ID,
+        confirm: { const: true },
+        continuation: { type: 'string', minLength: 1 },
+    }, { required: ['id', 'confirm', 'continuation'] }),
+    handler: async (args, env) => {
+        requireConfirm(args, 'calendar.delete.apply');
+        const lease = await verifyLease(args, 'calendar.delete.apply', env);
+        const id = String(args.id);
+        if (lease.fingerprint !== fingerprint({ id })) {
+            throw calendarValidationError('target_changed', '日程 ID 与 prepare 时的快照不一致，请重新执行 prepare');
+        }
+        const body = await buildWriteDatajson(env.host, [{ id }]);
+        let response;
+        try {
+            response = await env.host.request({
+                method: 'POST',
+                path: '/api/ebuilder/form/formdata/v2/deleteFormData/deleteAgenda',
+                operation: 'calendar.delete.apply',
+                body,
+            });
+        }
+        catch (error) {
+            if (isNetworkError(error)) {
+                throw calendarPartialError('删除请求发送后连接中断，是否已删除不确定，禁止自动重试，请通过 calendar.get 复核', { attempted: { id } }, { stage: 'delete' });
+            }
+            throw error;
+        }
+        return calendarSuccess('calendar.delete.apply', {
+            status: 'COMPLETE',
+            result: response,
+        });
+    },
+};
+export const calendarWriteOperations = [
+    calendarCreatePrepare,
+    calendarCreateApply,
+    calendarUpdatePrepare,
+    calendarUpdateApply,
+    calendarDeletePrepare,
+    calendarDeleteApply,
+];

package/dist/shortcuts/calendar/operations.js

@@ -0,0 +1,8 @@
+import { getCalendarOperation } from './operations/registry.js';
+import { assertNoForbiddenKeys, asObject } from './operations/shared.js';
+export async function executeCalendarOperation(operation, rawInput, context) {
+    const definition = getCalendarOperation(operation);
+    const input = asObject(rawInput);
+    assertNoForbiddenKeys(input);
+    return definition.handler(input, context);
+}

package/dist/shortcuts/ehr/continuation.js

@@ -0,0 +1,70 @@
+import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { ehrValidationError } from './errors.js';
+function stateRoot(ctx) {
+    const configured = ctx?.config?.path();
+    if (configured)
+        return resolve(configured, '..');
+    return process.env.WEAVER_WORK_CLI_HOME || process.env.WORK_CLI_HOME || resolve(homedir(), '.weaver-work-cli');
+}
+async function loadKey(ctx) {
+    const keysDir = resolve(stateRoot(ctx), 'keys');
+    const filename = resolve(keysDir, 'ehr-continuation.key');
+    await mkdir(keysDir, { recursive: true, mode: 0o700 });
+    if (existsSync(filename))
+        return readFile(filename);
+    const key = randomBytes(32);
+    try {
+        await writeFile(filename, key, { flag: 'wx', mode: 0o600 });
+        if (process.platform !== 'win32')
+            await chmod(filename, 0o600).catch(() => undefined);
+        return key;
+    }
+    catch {
+        return readFile(filename);
+    }
+}
+function encode(value) {
+    return Buffer.from(JSON.stringify(value)).toString('base64url');
+}
+function signature(payload, key) {
+    return createHmac('sha256', key).update(payload).digest('base64url');
+}
+export function createEhrContinuationSigner(ctx) {
+    return {
+        async issue(payload, ttlMs = 10 * 60_000) {
+            const issuedAt = Date.now();
+            const body = encode({ ...payload, issuedAt, expiresAt: issuedAt + ttlMs });
+            const sig = signature(body, await loadKey(ctx));
+            return `${body}.${sig}`;
+        },
+        async verify(token, expectedOperation) {
+            if (typeof token !== 'string' || !token.includes('.')) {
+                throw ehrValidationError('continuation_invalid', 'continuation 无效');
+            }
+            const [body, provided] = token.split('.');
+            const expected = signature(body, await loadKey(ctx));
+            const valid = provided.length === expected.length
+                && timingSafeEqual(Buffer.from(provided), Buffer.from(expected));
+            if (!valid)
+                throw ehrValidationError('continuation_invalid', 'continuation 签名校验失败');
+            let value;
+            try {
+                value = JSON.parse(Buffer.from(body, 'base64url').toString('utf8'));
+            }
+            catch {
+                throw ehrValidationError('continuation_invalid', 'continuation 内容无法解析');
+            }
+            if (value.operation !== expectedOperation) {
+                throw ehrValidationError('continuation_mismatch', 'continuation 不属于当前操作');
+            }
+            if (!Number.isSafeInteger(value.expiresAt) || value.expiresAt < Date.now()) {
+                throw ehrValidationError('continuation_expired', 'continuation 已过期');
+            }
+            return value;
+        },
+    };
+}