weaver-work-cli 0.1.6 → 0.1.7

package/dist/shortcuts/ebuilder-form/operations/shared.js

@@ -0,0 +1,132 @@
+import { ebuilderValidationError } from '../errors.js';
+const FORBIDDEN_KEYS = new Set([
+    '__proto__',
+    'constructor',
+    'prototype',
+    'access_token',
+    'app_key',
+    'app_secret',
+    'authorization',
+    'cookie',
+    'eteamsid',
+    'sedit',
+    'token',
+]);
+export function asObject(value, field = 'input') {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw ebuilderValidationError('input_not_object', `${field} 必须是 JSON 对象`);
+    }
+    return value;
+}
+export function optionalObject(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    return asObject(value, field);
+}
+export function requiredObject(value, field) {
+    return asObject(value, field);
+}
+export function requiredArray(value, field) {
+    if (!Array.isArray(value))
+        throw ebuilderValidationError('field_invalid', `${field} 必须是数组`);
+    return value;
+}
+export function optionalArray(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    return requiredArray(value, field);
+}
+export function requiredString(value, field) {
+    if (value === undefined || value === null || value === '') {
+        throw ebuilderValidationError('field_required', `${field} 必填`);
+    }
+    if (typeof value === 'object')
+        throw ebuilderValidationError('field_invalid', `${field} 必须是字符串`);
+    return String(value);
+}
+export function optionalString(value, field) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    if (typeof value === 'object')
+        throw ebuilderValidationError('field_invalid', `${field} 必须是字符串`);
+    return String(value);
+}
+export function idString(value, field, required = true) {
+    const text = required ? requiredString(value, field) : optionalString(value, field);
+    if (!text)
+        return '';
+    if (!/^\d+$/u.test(text)) {
+        throw ebuilderValidationError('field_invalid', `${field} 必须是数字 ID 字符串`);
+    }
+    return text;
+}
+export function enumString(value, field, allowed, fallback) {
+    const text = optionalString(value, field);
+    if (!text) {
+        if (fallback !== undefined)
+            return fallback;
+        throw ebuilderValidationError('field_required', `${field} 必填`);
+    }
+    if (!allowed.includes(text)) {
+        throw ebuilderValidationError('field_invalid', `${field} 只能是：${allowed.join('、')}`);
+    }
+    return text;
+}
+export function boolValue(value, field, fallback = false) {
+    if (value === undefined || value === null || value === '')
+        return fallback;
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (['true', 'y', 'yes', '1'].includes(normalized))
+            return true;
+        if (['false', 'n', 'no', '0'].includes(normalized))
+            return false;
+    }
+    throw ebuilderValidationError('field_invalid', `${field} 必须是布尔值`);
+}
+export function intValue(value, field, options = {}) {
+    const raw = value === undefined || value === null || value === '' ? options.fallback : value;
+    if (raw === undefined)
+        throw ebuilderValidationError('field_required', `${field} 必填`);
+    const numeric = Number(raw);
+    if (!Number.isInteger(numeric))
+        throw ebuilderValidationError('field_invalid', `${field} 必须是整数`);
+    if (options.min !== undefined && numeric < options.min)
+        throw ebuilderValidationError('field_invalid', `${field} 不能小于 ${options.min}`);
+    if (options.max !== undefined && numeric > options.max)
+        throw ebuilderValidationError('field_invalid', `${field} 不能大于 ${options.max}`);
+    return numeric;
+}
+export function assertKnownKeys(input, allowed, operation) {
+    const unknown = Object.keys(input).filter((key) => !allowed.includes(key));
+    if (unknown.length > 0) {
+        throw ebuilderValidationError('unknown_field', `${operation} 不支持字段：${unknown.join('、')}`, { unknown });
+    }
+}
+export function assertNoForbiddenKeys(value, location = 'input') {
+    if (!value || typeof value !== 'object')
+        return;
+    if (Array.isArray(value)) {
+        value.forEach((item, index) => assertNoForbiddenKeys(item, `${location}[${index}]`));
+        return;
+    }
+    for (const [key, child] of Object.entries(value)) {
+        if (FORBIDDEN_KEYS.has(key) || FORBIDDEN_KEYS.has(key.toLowerCase())) {
+            throw ebuilderValidationError('field_forbidden', `禁止业务输入字段：${location}.${key}`);
+        }
+        assertNoForbiddenKeys(child, `${location}.${key}`);
+    }
+}
+export function compactJson(value) {
+    return JSON.stringify(value);
+}
+export function sha256VisibleFingerprint(value) {
+    const json = compactJson(value);
+    let hash = 0;
+    for (let index = 0; index < json.length; index += 1) {
+        hash = ((hash << 5) - hash + json.charCodeAt(index)) | 0;
+    }
+    return `len:${json.length}:h:${(hash >>> 0).toString(16)}`;
+}

package/dist/shortcuts/ebuilder-form/operations/types.js

@@ -0,0 +1,19 @@
+export function ebuilderSuccess(action, data, meta, warnings = []) {
+    const payload = { ok: true, action, data };
+    if (meta && Object.keys(meta).length > 0)
+        payload.meta = meta;
+    if (warnings.length > 0)
+        payload.warnings = warnings;
+    return payload;
+}
+export function schemaOf(properties, options = {}) {
+    return {
+        type: 'object',
+        additionalProperties: false,
+        properties,
+        ...(options.required?.length ? { required: options.required } : {}),
+        ...(options.description ? { description: options.description } : {}),
+        ...(options.oneOf ? { oneOf: options.oneOf } : {}),
+        ...(options.anyOf ? { anyOf: options.anyOf } : {}),
+    };
+}

package/dist/shortcuts/ebuilder-form/operations/write.js

@@ -0,0 +1,277 @@
+import { ebuilderConfirmationError, ebuilderValidationError } from '../errors.js';
+import { ebuilderSuccess } from './types.js';
+import { asObject, assertKnownKeys, assertNoForbiddenKeys, optionalArray, optionalObject, optionalString, requiredArray, requiredString, sha256VisibleFingerprint, } from './shared.js';
+const CONTEXT_KEYS = [
+    'context',
+    'menuKeywords',
+    'menu',
+    'menuId',
+    'url',
+    'appId',
+    'apiPrefix',
+    'objId',
+    'listId',
+    'hostPageId',
+    'listKind',
+    'menuUrl',
+    'entryUrl',
+];
+export class EbuilderOpenapiPrepareOperation {
+    endpoint;
+    name;
+    applyName;
+    constructor(endpoint) {
+        this.endpoint = endpoint;
+        this.name = `ebuilder-form.openapi.${endpoint}.prepare`;
+        this.applyName = `ebuilder-form.openapi.${endpoint}.apply`;
+    }
+    async execute(input, env) {
+        const allowed = [
+            ...CONTEXT_KEYS,
+            'dataId',
+            'mainTable',
+            'datas',
+            'operationinfo',
+        ];
+        assertKnownKeys(input, allowed, this.name);
+        assertNoForbiddenKeys(input);
+        const prepared = await prepareOpenapi(this.endpoint, input, env.host);
+        const session = await env.host.getSession();
+        const continuation = await env.continuation.issue({
+            operation: this.applyName,
+            actor: { userId: session.userId, baseUrl: session.baseUrl, profile: session.profile },
+            kind: 'openapi',
+            endpoint: this.endpoint,
+            datajson: { ...prepared.datajson, __context: prepared.context },
+            target: prepared.target,
+            fingerprint: sha256VisibleFingerprint(prepared.datajson),
+        });
+        return ebuilderSuccess(this.name, {
+            context: prepared.context,
+            target: prepared.target,
+            requestPreview: { datajson: prepared.datajson },
+            continuation,
+            expiresInSeconds: 600,
+        }, { status: 'PREPARED' }, prepared.warnings);
+    }
+}
+export class EbuilderOpenapiApplyOperation {
+    endpoint;
+    name;
+    constructor(endpoint) {
+        this.endpoint = endpoint;
+        this.name = `ebuilder-form.openapi.${endpoint}.apply`;
+    }
+    async execute(input, env) {
+        assertKnownKeys(input, ['confirm', 'continuation'], this.name);
+        if (input.confirm !== true)
+            throw ebuilderConfirmationError(this.name);
+        const record = await env.continuation.verify(requiredString(input.continuation, 'continuation'), this.name);
+        assertContinuation(record, await env.host.getSession(), 'openapi', this.endpoint);
+        const datajson = asObject(record.datajson, 'continuation.datajson');
+        const result = await env.host.openapiWrite(this.endpoint, datajson, this.name);
+        return ebuilderSuccess(this.name, summarizeWriteResult(result, env.host, this.endpoint === 'delete'), { status: 'COMPLETE' });
+    }
+}
+export class EbuilderCustomPrepareOperation {
+    endpoint;
+    name;
+    applyName;
+    constructor(endpoint) {
+        this.endpoint = endpoint;
+        this.name = `ebuilder-form.custom.${endpoint}.prepare`;
+        this.applyName = `ebuilder-form.custom.${endpoint}.apply`;
+    }
+    async execute(input, env) {
+        const allowed = [
+            ...CONTEXT_KEYS,
+            'interfacePk',
+            'dataIds',
+            'datas',
+            'operationinfo',
+        ];
+        assertKnownKeys(input, allowed, this.name);
+        assertNoForbiddenKeys(input);
+        const prepared = await prepareCustom(this.endpoint, input, env.host);
+        const session = await env.host.getSession();
+        const continuation = await env.continuation.issue({
+            operation: this.applyName,
+            actor: { userId: session.userId, baseUrl: session.baseUrl, profile: session.profile },
+            kind: 'custom',
+            endpoint: this.endpoint,
+            interfacePk: prepared.interfacePk,
+            datajson: { ...prepared.datajson, __context: prepared.context },
+            target: prepared.target,
+            fingerprint: sha256VisibleFingerprint(prepared.datajson),
+        });
+        return ebuilderSuccess(this.name, {
+            context: prepared.context,
+            interfacePk: prepared.interfacePk,
+            target: prepared.target,
+            requestPreview: { datajson: prepared.datajson },
+            continuation,
+            expiresInSeconds: 600,
+        }, { status: 'PREPARED' }, prepared.warnings);
+    }
+}
+export class EbuilderCustomApplyOperation {
+    endpoint;
+    name;
+    constructor(endpoint) {
+        this.endpoint = endpoint;
+        this.name = `ebuilder-form.custom.${endpoint}.apply`;
+    }
+    async execute(input, env) {
+        assertKnownKeys(input, ['confirm', 'continuation'], this.name);
+        if (input.confirm !== true)
+            throw ebuilderConfirmationError(this.name);
+        const record = await env.continuation.verify(requiredString(input.continuation, 'continuation'), this.name);
+        assertContinuation(record, await env.host.getSession(), 'custom', this.endpoint);
+        const datajson = asObject(record.datajson, 'continuation.datajson');
+        const interfacePk = requiredString(record.interfacePk, 'continuation.interfacePk');
+        const result = await env.host.customWrite(this.endpoint, interfacePk, datajson, this.name);
+        return ebuilderSuccess(this.name, summarizeWriteResult(result, env.host, this.endpoint === 'delete'), { status: 'COMPLETE' });
+    }
+}
+async function prepareOpenapi(endpoint, input, host) {
+    const context = await host.resolveContext(input);
+    const operationinfo = optionalObject(input.operationinfo, 'operationinfo') || {};
+    if (endpoint === 'add') {
+        const datas = requiredArray(input.datas, 'datas');
+        return {
+            context,
+            datajson: {
+                datas,
+                header: { objId: context.objId },
+                operationinfo: {
+                    fieldNoFindIgnore: 'false',
+                    checkRight: 'true',
+                    doAction: 'false',
+                    printCost: 'true',
+                    ...operationinfo,
+                },
+            },
+            target: { endpoint, objId: context.objId, count: datas.length },
+            warnings: fieldKeyWarnings(datas),
+        };
+    }
+    if (endpoint === 'update') {
+        const datas = requiredArray(input.datas, 'datas');
+        return {
+            context,
+            datajson: {
+                datas,
+                header: { objId: context.objId },
+                operationinfo: {
+                    updateType: 'ids',
+                    needAdd: 'false',
+                    fieldNoFindIgnore: 'false',
+                    checkRight: 'true',
+                    doAction: 'false',
+                    printCost: 'true',
+                    ...operationinfo,
+                },
+            },
+            target: { endpoint, objId: context.objId, dataIds: collectDataIds(datas) },
+            warnings: fieldKeyWarnings(datas),
+        };
+    }
+    const mainTable = {
+        ...(optionalObject(input.mainTable, 'mainTable') || {}),
+        ...(input.dataId ? { id: requiredString(input.dataId, 'dataId') } : {}),
+    };
+    if (Object.keys(mainTable).length === 0) {
+        throw ebuilderValidationError('delete_target_required', '删除必须提供 dataId 或 mainTable 条件');
+    }
+    return {
+        context,
+        datajson: {
+            header: { objId: context.objId },
+            mainTable,
+            operationinfo: {
+                fieldNoFindIgnore: 'false',
+                checkRight: 'true',
+                doAction: 'false',
+                printCost: 'true',
+                ...operationinfo,
+            },
+        },
+        target: { endpoint, objId: context.objId, mainTable },
+        warnings: ['删除不可逆；apply 前必须确认 objId、删除条件和当前操作人均正确'],
+    };
+}
+async function prepareCustom(endpoint, input, host) {
+    const context = await host.resolveContext(input);
+    const interfacePk = requiredString(input.interfacePk, 'interfacePk');
+    const operationinfo = {
+        printCost: false,
+        asyncPostProcess: false,
+        asyncMark: false,
+        ...(optionalObject(input.operationinfo, 'operationinfo') || {}),
+    };
+    const session = await host.getSession();
+    if (endpoint === 'delete') {
+        const dataIds = requiredArray(input.dataIds, 'dataIds').map((item) => requiredString(item, 'dataIds[]'));
+        return {
+            context,
+            interfacePk,
+            datajson: {
+                datas: dataIds.map((id) => ({ mainTable: { id } })),
+                header: { operator: session.userId },
+            },
+            target: { endpoint, interfacePk, dataIds },
+            warnings: ['删除不可逆；apply 前必须确认 interfacePk、目标 dataId 和当前操作人均正确'],
+        };
+    }
+    const datas = requiredArray(input.datas, 'datas');
+    return {
+        context,
+        interfacePk,
+        datajson: {
+            operationinfo,
+            datas,
+            header: { operator: session.userId },
+        },
+        target: { endpoint, interfacePk, count: datas.length, dataIds: collectDataIds(datas) },
+        warnings: fieldKeyWarnings(datas),
+    };
+}
+function assertContinuation(record, session, kind, endpoint) {
+    if (record.kind !== kind || record.endpoint !== endpoint) {
+        throw ebuilderValidationError('continuation_mismatch', 'continuation 的接口族或 operation 与当前 apply 不一致');
+    }
+    const actor = asObject(record.actor, 'continuation.actor');
+    if (actor.userId !== session.userId || actor.baseUrl !== session.baseUrl) {
+        throw ebuilderValidationError('continuation_actor_changed', 'continuation 签发时的登录环境或用户与当前会话不一致，请重新执行 prepare');
+    }
+}
+function summarizeWriteResult(result, host, deleted) {
+    const context = asObject(result.context || {}, 'context');
+    const payload = asObject(result.result || {}, 'result');
+    const dataIds = Array.isArray(payload.dataIds) ? payload.dataIds : [];
+    return {
+        context,
+        result: payload,
+        records: dataIds.map((dataId) => ({
+            dataId,
+            url: host.buildDataUrl(context, dataId, deleted),
+        })),
+        listUrl: host.buildListUrl(context),
+    };
+}
+function collectDataIds(datas) {
+    return datas
+        .map((item) => optionalString(asObject(item, 'datas[]').mainTable?.id, 'mainTable.id'))
+        .filter((item) => Boolean(item));
+}
+function fieldKeyWarnings(datas) {
+    const warnings = [];
+    const text = JSON.stringify(datas);
+    if (/"\d{16,}"/u.test(text)) {
+        warnings.push('检测到长数字字段键；如果字段定义中 name 等于 id，请确认写入键已改用 config.dataKey，否则 eBuilder 可能返回成功但字段值为空');
+    }
+    if (optionalArray(datas, 'datas')?.some((item) => JSON.stringify(item).includes('"fieldNoFindIgnore"'))) {
+        warnings.push('fieldNoFindIgnore 应放在 operationinfo；字段名错误不能通过忽略字段绕过');
+    }
+    return warnings;
+}

package/dist/shortcuts/ebuilder-form/operations.js

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

package/dist/shortcuts/ehr/operations/salary.js

@@ -1,6 +1,6 @@
 import { ehrValidationError } from '../errors.js';
-import { READ, SCHEMA_DATE, SCHEMA_ID, SCHEMA_ID_LIST, SCHEMA_MONTH, SCHEMA_STRING_LIST, ehrSuccess, schemaOf, } from './types.js';
-import { assertEnum, assertMonth, assertMonthRange, compact, normalizePaged, pickDefined, resolveSecondAuthToken, toIdList, toNumber, toPageQuery, } from './shared.js';
+import { READ, SCHEMA_ID, SCHEMA_MONTH, ehrSuccess, schemaOf, } from './types.js';
+import { assertMonth, compact, normalizePaged, resolveSecondAuthToken, toNumber, toPageQuery, } from './shared.js';
 /**
  * 薪资所属月范围。页面实际传 2 个元素 [开始月, 结束月]。
  * salaryMonth 超过 2 项时服务端仅保留第 1 项，因此在入口侧直接拒绝。
@@ -173,147 +173,9 @@ const salaryAdjustmentList = {
         return ehrSuccess('ehr.salary.adjustment.list', data, { page });
     },
 };
-const salarySiaccountQuery = {
-    name: 'ehr.salary.siaccount.query',
-    resource: 'salary',
-    method: 'siaccount.query',
-    action: 'ehr.salary.siaccount.query',
-    summary: '社保台账详情查询（需薪酬社保台账权限）；接口不分页且返回高度敏感数据，必须提供范围条件',
-    capability: 'salary',
-    risk: READ,
-    inputSchema: schemaOf({
-        startBillMonth: SCHEMA_MONTH,
-        endBillMonth: SCHEMA_MONTH,
-        paymentOrganizationIds: SCHEMA_ID_LIST,
-        paymentAgencyIds: SCHEMA_ID_LIST,
-        salaryAcctOrgIds: SCHEMA_ID_LIST,
-        employeeIds: SCHEMA_ID_LIST,
-        billStatus: { type: 'integer', enum: [0, 1], description: '0 未归档，1 已归档' },
-        paymentStatusList: {
-            type: 'array',
-            items: { type: 'integer', enum: [0, 1, 2, 3, 4] },
-            description: '0 正常缴纳，1 补缴，2 代缴，3 退差，4 补差',
-        },
-    }),
-    handler: async (args, { host }) => {
-        // 注意：这是月份区间（YYYY-MM），必须用 assertMonthRange；
-        // 误用 assertDateRange 会按 YYYY-MM-DD 校验而报 date_invalid。
-        assertMonthRange(args, 'startBillMonth', 'endBillMonth');
-        const employeeIds = toIdList(args.employeeIds, 'employeeIds');
-        const paymentOrganizationIds = toIdList(args.paymentOrganizationIds, 'paymentOrganizationIds');
-        const paymentAgencyIds = toIdList(args.paymentAgencyIds, 'paymentAgencyIds');
-        const salaryAcctOrgIds = toIdList(args.salaryAcctOrgIds, 'salaryAcctOrgIds');
-        // 接口不分页且返回高度敏感数据，缺少任何范围条件都可能造成大范围敏感数据返回。
-        const hasScope = Boolean((args.startBillMonth && args.endBillMonth)
-            || employeeIds?.length
-            || paymentOrganizationIds?.length
-            || paymentAgencyIds?.length
-            || salaryAcctOrgIds?.length);
-        if (!hasScope) {
-            throw ehrValidationError('siaccount_scope_required', '社保台账查询不分页且返回敏感数据，必须至少提供月份范围或人员/组织 ID 之一以收窄范围');
-        }
-        // 枚举必须在运行时校验：inputSchema 只是文档。
-        // 否则非法值（如 billStatus=9）会被服务端静默忽略并返回空数组，
-        // 调用方会误判为"没有数据"，比直接报错更危险。
-        const BILL_STATUS = ['0', '1'];
-        const PAYMENT_STATUS = ['0', '1', '2', '3', '4'];
-        const billStatus = args.billStatus === undefined
-            ? undefined
-            : Number(assertEnum(args.billStatus, BILL_STATUS, 'billStatus'));
-        let paymentStatusList;
-        if (args.paymentStatusList !== undefined) {
-            if (!Array.isArray(args.paymentStatusList)) {
-                throw ehrValidationError('enum_invalid', 'paymentStatusList 必须是数组');
-            }
-            paymentStatusList = args.paymentStatusList.map((item, index) => Number(assertEnum(item, PAYMENT_STATUS, `paymentStatusList[${index}]`)));
-        }
-        const body = {
-            startBillMonth: args.startBillMonth,
-            endBillMonth: args.endBillMonth,
-            billStatus,
-            paymentStatusList,
-            paymentOrganizationIds,
-            paymentAgencyIds,
-            salaryAcctOrgIds,
-            employeeIds,
-        };
-        const response = await host.request({
-            method: 'POST',
-            path: '/api/bs/hrmsalary/siaccount/detail/query',
-            body: compact(body),
-        });
-        return ehrSuccess('ehr.salary.siaccount.query', normalizePaged(response).data);
-    },
-};
-const salaryEmployeeList = {
-    name: 'ehr.salary.employee.list',
-    resource: 'salary',
-    method: 'employee.list',
-    action: 'ehr.salary.employee.list',
-    summary: '员工薪资明细列表（需薪酬统计权限）；按薪资所属月、人员、组织等条件分页查询',
-    capability: 'salary',
-    risk: READ,
-    inputSchema: schemaOf({
-        current: SCHEMA_ID,
-        pageSize: SCHEMA_ID,
-        keyword: { type: 'string' },
-        username: { type: 'string' },
-        jobNum: { type: 'string' },
-        idNo: { type: 'string', description: '身份证号，敏感字段' },
-        year: { type: 'integer', minimum: 1000, maximum: 9999 },
-        salaryMonth: { type: 'array', items: SCHEMA_MONTH, maxItems: 2, description: '1 项单月，2 项闭区间；超过 2 项服务端仅保留第 1 项' },
-        employeeType: { type: 'string', enum: ['ORGANIZATION', 'EXT_EMPLOYEE'] },
-        salarySendType: { type: 'string', enum: ['normal', 'import'] },
-        sortField: { type: 'string' },
-        departmentIds: SCHEMA_ID_LIST,
-        positionIds: SCHEMA_ID_LIST,
-        ids: SCHEMA_ID_LIST,
-        taxAgentIds: SCHEMA_ID_LIST,
-        salarySobIds: SCHEMA_ID_LIST,
-        personnelStatuss: SCHEMA_STRING_LIST,
-        incomeCategories: SCHEMA_STRING_LIST,
-        hiredate: { type: 'array', items: SCHEMA_DATE, minItems: 2, maxItems: 2, description: '入职日期闭区间，必须正好 2 项' },
-    }),
-    handler: async (args, { host }) => {
-        const body = {
-            ...toPageQuery(args),
-            ...pickDefined(args, [
-                'keyword',
-                'username',
-                'jobNum',
-                'idNo',
-                'employeeType',
-                'salarySendType',
-                'sortField',
-                'personnelStatuss',
-                'incomeCategories',
-                'hiredate',
-            ]),
-            departmentIds: toIdList(args.departmentIds, 'departmentIds'),
-            positionIds: toIdList(args.positionIds, 'positionIds'),
-            ids: toIdList(args.ids, 'ids'),
-            taxAgentIds: toIdList(args.taxAgentIds, 'taxAgentIds'),
-            salarySobIds: toIdList(args.salarySobIds, 'salarySobIds'),
-        };
-        if (args.year !== undefined)
-            body.year = toNumber(args.year, 'year');
-        if (args.salaryMonth !== undefined) {
-            body.salaryMonth = requireMonthRange(args.salaryMonth, 'salaryMonth');
-        }
-        const response = await host.request({
-            method: 'POST',
-            path: '/api/bs/salaryreport/salary/statistics/employee/salaryList',
-            body: compact(body),
-        });
-        const { data, page } = normalizePaged(response);
-        return ehrSuccess('ehr.salary.employee.list', data, { page });
-    },
-};
 export const salaryOperations = [
     salaryBillList,
     salaryBillGet,
     salaryWelfareList,
     salaryAdjustmentList,
-    salarySiaccountQuery,
-    salaryEmployeeList,
 ];

package/dist/shortcuts/im/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 { imValidationError } 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, 'im-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 createImContinuationSigner(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 imValidationError('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 imValidationError('continuation_invalid', 'continuation 签名校验失败');
+            let value;
+            try {
+                value = JSON.parse(Buffer.from(body, 'base64url').toString('utf8'));
+            }
+            catch {
+                throw imValidationError('continuation_invalid', 'continuation 内容无法解析');
+            }
+            if (value.operation !== expectedOperation) {
+                throw imValidationError('continuation_mismatch', 'continuation 不属于当前操作');
+            }
+            if (!Number.isSafeInteger(value.expiresAt) || value.expiresAt < Date.now()) {
+                throw imValidationError('continuation_expired', 'continuation 已过期');
+            }
+            return value;
+        },
+    };
+}