weaver-work-cli 0.1.8 → 0.1.20

package/dist/shortcuts/meeting/operations/signs.js

@@ -1,5 +1,27 @@
+import { createHash } from 'node:crypto';
+import { meetingConfirmationError, meetingPartialError, meetingValidationError } from '../errors.js';
 import { meetingSuccess, SCHEMA_ID } from './types.js';
 import { extractRows, toIdString } from './shared.js';
+const CONTINUATION_TTL_SECONDS = 600;
+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 meetingConfirmationError(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 meetingValidationError('context_mismatch', '确认上下文已变化（租户或登录账号不同），请重新执行 prepare');
+    }
+    return lease;
+}
+function isNetworkError(error) {
+    return error instanceof Error && error.type === 'network';
+}
 // ---------------------------------------------------------------------------
 // 签到列表（getMeetingSignInfoList）
 // ---------------------------------------------------------------------------
@@ -8,7 +30,7 @@ const meetingSignList = {
     resource: 'sign',
     method: 'sign.list',
     action: 'meeting.sign.list',
-    summary: '查询会议签到记录（getMeetingSignInfoList）并输出已签/未签统计',
+    summary: '查询会议签到记录（getMeetingSignInfoList）并输出已签/未签统计；返回的 id 是签到记录 id，供补签/清除使用',
     capability: 'sign',
     risk: 'read',
     inputSchema: {
@@ -38,4 +60,196 @@ const meetingSignList = {
         });
     },
 };
-export const meetingSignOperations = [meetingSignList];
+// ---------------------------------------------------------------------------
+// 签到写操作：补签 / 补签退 / 清除签到记录
+//
+// 源码依据（MeetingSignController + MeetingSignServiceImpl）：
+// - signMeetingByHandOne(params, tenant, user)：读取 params.id（**签到记录 id**）与
+//   params.meetingid，把 signtime 置为当前时间；任一为空或记录不存在时返回 false。
+// - signBackMeetingByHandOne：同上，写 signbackTime。
+// - delSign(params, user)：清空 signtime/signbackTime/site/flag 等（复位为未签到）。
+// - controller 自行注入 ip（Utils.getIp(request)）与 tenantKey，CLI 不传。
+// - 返回 WeaResult.success(false) 表示"未生效"，必须在 CLI 侧识别为失败。
+// - 目标记录回查用 getMeetingSignInfo（GET，@RequestParam id，返回单条 MeetingSign）。
+// ---------------------------------------------------------------------------
+const SIGN_RECORD_PATH = '/api/meeting/sign/getMeetingSignInfo';
+const SIGN_WRITE_SPECS = [
+    {
+        action: 'mark',
+        path: '/api/meeting/sign/signMeetingByHandOne',
+        summaryPrepare: '准备补签（单一补录签到）：回查签到记录并展示目标人员/会议，生成确认预览，不写入',
+        summaryApply: '提交补签（signMeetingByHandOne，body 传参）；必须在用户明确确认后调用',
+        note: '补签会把该人员的签到时间写为当前时间，属于改写签到事实；仅会议召集人/有权限者应执行，且需用户明确确认。',
+        effect: '把签到时间补录为当前时间（若原本已有签到时间会被覆盖）',
+    },
+    {
+        action: 'back',
+        path: '/api/meeting/sign/signBackMeetingByHandOne',
+        summaryPrepare: '准备补签退（补录签退时间）：回查签到记录并展示目标人员/会议，生成确认预览，不写入',
+        summaryApply: '提交补签退（signBackMeetingByHandOne，body 传参）；必须在用户明确确认后调用',
+        note: '补签退会把该人员的签退时间写为当前时间，属于改写签到事实，需用户明确确认。',
+        effect: '把签退时间补录为当前时间',
+    },
+    {
+        action: 'clear',
+        path: '/api/meeting/sign/delSign',
+        summaryPrepare: '准备清除签到记录（复位为未签到）：回查签到记录并展示目标人员/会议，生成确认预览，不写入',
+        summaryApply: '提交清除签到记录（delSign，body 传参）；必须在用户明确确认后调用',
+        note: '清除签到记录会复位签到/签退时间与地点，等于该人员回到"未签到"状态；不可通过 CLI 恢复，需用户明确确认。',
+        effect: '清空签到时间、签退时间与签到地点，复位为未签到',
+    },
+];
+async function resolveSignTarget(args, env, operation) {
+    const signRecordId = toIdString(args.id, 'id');
+    let response;
+    try {
+        response = await env.host.request({
+            method: 'GET',
+            path: SIGN_RECORD_PATH,
+            operation,
+            query: { id: signRecordId },
+        });
+    }
+    catch (error) {
+        throw meetingValidationError('sign_record_unreadable', `未能回查签到记录 ${signRecordId}（getMeetingSignInfo 失败）：${error instanceof Error ? error.message : String(error)}`);
+    }
+    const record = response?.data;
+    if (!record || typeof record !== 'object') {
+        throw meetingValidationError('sign_record_not_found', `未找到签到记录 ${signRecordId}：id 必须是签到记录 id（来自 meeting.sign.list 的 signs[].id），不是会议 id，也不是人员 id`);
+    }
+    const recordMeetingId = record.mtId !== undefined && record.mtId !== null ? String(record.mtId) : '';
+    const passedMeetingId = args.mtId !== undefined && args.mtId !== null ? toIdString(args.mtId, 'mtId') : '';
+    if (passedMeetingId && recordMeetingId && passedMeetingId !== recordMeetingId) {
+        throw meetingValidationError('sign_record_mismatch', `签到记录 ${signRecordId} 属于会议 ${recordMeetingId}，与传入的 mtId=${passedMeetingId} 不一致，请核对后重试`);
+    }
+    const meetingId = passedMeetingId || recordMeetingId;
+    if (!meetingId) {
+        throw meetingValidationError('meeting_id_required', `签到记录 ${signRecordId} 未返回会议 id，请显式传入 mtId（会议 id）后重试`);
+    }
+    return { signRecordId, meetingId, record };
+}
+function signWritePair(spec) {
+    const prepareName = `meeting.sign.${spec.action}.prepare`;
+    const applyName = `meeting.sign.${spec.action}.apply`;
+    const inputProps = {
+        id: { ...SCHEMA_ID, description: '签到记录 id（必填，来自 meeting.sign.list 的 signs[].id）' },
+        mtId: { ...SCHEMA_ID, description: '会议 id（可选：省略时按签到记录回查；传入则必须与记录一致）' },
+    };
+    const prepare = {
+        name: prepareName,
+        resource: 'sign',
+        method: `sign.${spec.action}.prepare`,
+        action: prepareName,
+        summary: spec.summaryPrepare,
+        capability: 'sign',
+        risk: 'read-before-write',
+        requiresConfirmation: true,
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: inputProps,
+            required: ['id'],
+        },
+        handler: async (args, env) => {
+            const target = await resolveSignTarget(args, env, prepareName);
+            const payload = { id: target.signRecordId, meetingid: target.meetingId };
+            const session = await env.host.getSession();
+            const token = await env.continuation.issue({
+                operation: applyName,
+                baseUrl: session.baseUrl,
+                profile: session.profile,
+                userId: session.userId,
+                payload,
+                fingerprint: fingerprint(payload),
+            }, CONTINUATION_TTL_SECONDS * 1000);
+            const record = target.record;
+            const alreadySigned = record.signtime !== undefined && record.signtime !== null && record.signtime !== '';
+            const alreadyBack = record.signbackTime !== undefined && record.signbackTime !== null && record.signbackTime !== '';
+            const warnings = [];
+            if (spec.action === 'mark' && alreadySigned) {
+                warnings.push(`该人员已有签到时间（${record.signtime}），补签会覆盖为当前时间`);
+            }
+            if (spec.action === 'back' && !alreadySigned) {
+                warnings.push('该人员尚未签到，先补签退可能不符合业务预期');
+            }
+            if (spec.action === 'back' && alreadyBack) {
+                warnings.push(`该人员已有签退时间（${record.signbackTime}），补签退会覆盖为当前时间`);
+            }
+            if (spec.action === 'clear' && !alreadySigned && !alreadyBack) {
+                warnings.push('该人员当前没有签到/签退记录，清除操作不会改变数据');
+            }
+            return meetingSuccess(prepareName, {
+                status: 'AWAITING_CONFIRMATION',
+                preview: {
+                    action: spec.action,
+                    signRecordId: target.signRecordId,
+                    meetingId: target.meetingId,
+                    userid: record.userid !== undefined && record.userid !== null ? String(record.userid) : undefined,
+                    current: { signtime: record.signtime ?? null, signbackTime: record.signbackTime ?? null, flag: record.flag ?? null },
+                    effect: spec.effect,
+                    warnings,
+                    note: spec.note,
+                },
+                continuation: token,
+                expiresInSeconds: CONTINUATION_TTL_SECONDS,
+            });
+        },
+    };
+    const apply = {
+        name: applyName,
+        resource: 'sign',
+        method: `sign.${spec.action}.apply`,
+        action: applyName,
+        summary: spec.summaryApply,
+        capability: 'sign',
+        risk: 'high-risk-write',
+        requiresConfirmation: true,
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                confirm: { const: true },
+                continuation: { type: 'string', minLength: 1 },
+                ...inputProps,
+            },
+            required: ['confirm', 'continuation', 'id'],
+        },
+        handler: async (args, env) => {
+            requireConfirm(args, applyName);
+            const lease = await verifyLease(args, applyName, env);
+            const target = await resolveSignTarget(args, env, applyName);
+            const payload = { id: target.signRecordId, meetingid: target.meetingId };
+            if (lease.fingerprint !== fingerprint(payload)) {
+                throw meetingValidationError('target_changed', '签到记录或会议与 prepare 时的快照不一致，请重新执行 prepare');
+            }
+            let response;
+            try {
+                response = await env.host.request({
+                    method: 'POST',
+                    path: spec.path,
+                    operation: applyName,
+                    // controller 自行注入 ip 与 tenantKey；此处只传业务参数。
+                    body: payload,
+                });
+            }
+            catch (error) {
+                if (isNetworkError(error)) {
+                    throw meetingPartialError(`${spec.action} 请求发送后连接中断，是否已生效不确定，禁止自动重试，请用 meeting.sign.list 回查后再决定`, { attempted: payload }, { stage: `sign.${spec.action}` });
+                }
+                throw error;
+            }
+            // 源码：接口返回 WeaResult.success(false) 表示未生效（记录不存在/参数缺失），
+            // 业务包装层不会报错，必须在此识别为失败，避免向用户谎报成功。
+            const applied = response?.data;
+            if (applied === false) {
+                throw meetingValidationError('sign_not_applied', `服务端未生效（${spec.action} 返回 false）：签到记录可能已被删除或参数不匹配，请先用 meeting.sign.list 复查`);
+            }
+            return meetingSuccess(applyName, { status: 'COMPLETE', action: spec.action, ...payload });
+        },
+    };
+    return [prepare, apply];
+}
+export const meetingSignOperations = [
+    meetingSignList,
+    ...SIGN_WRITE_SPECS.flatMap((spec) => signWritePair(spec)),
+];

package/dist/shortcuts/workflow/endpoints.js

@@ -77,7 +77,8 @@ export const WORKFLOW_ENDPOINTS = {
     FORWARD_REQUEST: '/api/workflow/core/paService/v1/forward',
     CC_REQUEST: '/api/workflow/core/paService/v1/manualCC',
     ADD_REVIEW_REQUEST: '/api/workflow/core/paService/v1/addSignOperator',
-    BATCH_SUBMIT: '/api/workflow/core/paService/v1/batchSubmit',
+    /** 批量提交（2026-09-20 用户指定换成前端同款端点；旧路径 /api/workflow/core/paService/v1/batchSubmit 已停用） */
+    BATCH_SUBMIT: '/api/workflow/core/flow/batchSubmit',
     FORCE_DRAW_BACK: '/api/workflow/core/paService/v1/doForceDrawBack',
     FORCE_OVER: '/api/workflow/core/paService/v1/doForceOver',
     CONSUL: '/api/workflow/core/paService/v1/consul',

package/dist/shortcuts/workflow/errors.js

@@ -88,7 +88,8 @@ export const CLARIFICATION_SUBTYPE = 'needs_clarification';
  * 底层解析函数（`read.ts` 的 `resolveTerm` / `resolveRequestLevel` / `resolveFilterFieldItem` /
  * `resolveFieldValues`）无法直接产出信封，故仍以错误形式向上抛；**调度层（`operations.ts`）会把它
  * 转成成功信封**：`ok:true` + `data.type=workflowClarification` + `data.status=NEEDS_CLARIFICATION`。
- * 这与 `workflow.createList` 已有的 `ok:true` + `status:SELECTED/NEEDS_SELECTION` 是同一套约定。
+ * **查询侧与发起侧共用这一条通道**（发起侧由 `form.ts` 的 `resolveCreateWorkflow` 抛出，
+ * `clarificationType` 同样是 `workflow`），于是「名称→ID 拿不准」在两个方向上表现完全一致。
  *
  * 形态来源（对齐 V11.3）：`e10_workflow.py:10356-10400`（工作流名 0 命中 / 多命中分支）与
  * `resolve_system_name_condition`（L8262）都返回 `success:true` + `needClarification:true`
@@ -98,14 +99,19 @@ export const CLARIFICATION_SUBTYPE = 'needs_clarification';
  * 覆盖的两种情形（与 V11.3 一致）：
  * 1. **0 命中** —— 名称在当前环境没有对应对象（`candidates` 为空）；
  * 2. **多命中且没有唯一全名精确匹配** —— 列出候选让用户挑；有唯一全名精确匹配时**不澄清**，直接用。
+ *
+ * `extra` 供调用方补充**可判别的原因**（如 `clarificationReason: 'workflow_not_exist' | 'no_create_right'`），
+ * 由 `operations.ts` 的 `clarificationEnvelope` 原样带到信封上——不加这个字段的话，
+ * 「ID 不存在」与「ID 存在但没有发起权限」在模型眼里长得一模一样，会把后者说成前者。
  */
-export function workflowClarificationError(clarificationType, keyword, question, candidates = []) {
+export function workflowClarificationError(clarificationType, keyword, question, candidates = [], extra = {}) {
     return new WorkflowCliError('validation', CLARIFICATION_SUBTYPE, question, {
         details: {
             clarificationType,
             clarificationKeyword: keyword,
             clarificationQuestion: question,
             candidates,
+            ...extra,
         },
         exitCode: ExitCode.UsageError,
     });

package/dist/shortcuts/workflow/host.js

@@ -200,9 +200,12 @@ export function createWorkflowHost(ctx, dependencies = {}) {
                 details: { status: response.status },
             });
         }
-        const businessError = extractApiBusinessError(response.value);
-        if (businessError) {
-            throw workflowApiError('business_error', `OA 接口返回错误，本次操作已停止。接口提示：${businessError}。如果您无法处理，请联系系统管理员。`, { details: { endpointKey: operation, businessError } });
+        // `tolerateBusinessError` 的调用方要的是**响应体里的结论**，不能过滤（见 WorkflowRequest 的说明）。
+        if (request.tolerateBusinessError !== true) {
+            const businessError = extractApiBusinessError(response.value);
+            if (businessError) {
+                throw workflowApiError('business_error', `OA 接口返回错误，本次操作已停止。接口提示：${businessError}。如果您无法处理，请联系系统管理员。`, { details: { endpointKey: operation, businessError } });
+            }
         }
         return { status: response.status, value: response.value };
     }