weaver-work-cli 0.1.40 → 0.1.44

package/dist/shortcuts/reception/operations/snapshot.js

@@ -0,0 +1,68 @@
+import { join } from 'node:path';
+import { SNAPSHOT_KIND } from '../constants.js';
+import { readJson } from './shared.js';
+export function resolveSnapshot(explicitPath = '') {
+    const candidates = [
+        explicitPath,
+        process.env.RECEPTION_SNAPSHOT || '',
+        process.env.RECEPTION_SKILL_DIR ? join(process.env.RECEPTION_SKILL_DIR, 'data', 'fields-snapshot.json') : '',
+        join(process.cwd(), 'data', 'fields-snapshot.json'),
+        join(process.cwd(), '..', 'data', 'fields-snapshot.json'),
+    ].filter(Boolean);
+    for (const path of candidates) {
+        const parsed = readJson(path);
+        if (parsed && parsed.kind === SNAPSHOT_KIND)
+            return { path, snapshot: parsed };
+    }
+    return { path: '', snapshot: null };
+}
+/**
+ * 从快照路径反推技能包根目录。
+ *
+ * 技能包里 `data/fields-snapshot.json` 与 `scripts/render.py` 是固定相对位置，
+ * 因此只要拿到快照路径，就能定位渲染脚本，不需要再让调用方传第二个参数。
+ */
+export function skillRootFromSnapshot(snapshotPath) {
+    // <skill>/data/fields-snapshot.json → <skill>
+    return join(snapshotPath, '..', '..');
+}
+/** 转成与 formctx fields[] 同形的数组，便于 buildMain 直接复用。 */
+export function snapshotFields(snapshot) {
+    if (!snapshot)
+        return [];
+    return (snapshot.fields || []).map((field) => ({
+        id: field.id,
+        name: field.name,
+        componentKey: field.componentKey,
+        isBrowser: Boolean(field.isBrowser),
+        isMultiple: Boolean(field.isMultiple),
+        required: Boolean(field.required),
+        options: field.options || [],
+    }));
+}
+/** 与实时 fields 对拍：数量、名称、同名字段的 ID 是否一致。 */
+export function diffSnapshot(snapshot, liveFields) {
+    if (!snapshot) {
+        return { match: null, drift: [], expectedCount: 0, actualCount: (liveFields || []).length };
+    }
+    const want = new Map((snapshot.fields || []).map((field) => [field.name, field]));
+    const live = new Map((liveFields || []).map((field) => [String(field.name), field]));
+    const drift = [];
+    for (const [name, field] of want) {
+        const matched = live.get(name);
+        if (!matched)
+            drift.push({ type: 'missing-in-form', name, expectedId: field.id });
+        else if (matched.id && String(matched.id) !== String(field.id)) {
+            drift.push({ type: 'id-changed', name, expectedId: field.id, actualId: String(matched.id) });
+        }
+    }
+    for (const [name, field] of live) {
+        if (!want.has(name)) {
+            drift.push({ type: 'new-field', name, actualId: field.id ? String(field.id) : '' });
+        }
+    }
+    const expectedCount = snapshot.mainFieldCount || 0;
+    const actualCount = (liveFields || []).length;
+    const countOk = expectedCount === actualCount;
+    return { match: countOk && drift.length === 0, countOk, expectedCount, actualCount, drift };
+}

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

@@ -0,0 +1 @@
+export {};

package/dist/shortcuts/reception/operations.js

@@ -0,0 +1,33 @@
+import { receptionValidationError } from './errors.js';
+import { getReceptionOperation } from './operations/registry.js';
+/**
+ * operation 调度入口。
+ *
+ * 这里只做两件事：按名取 handler、拒绝凭据类入参。
+ * 业务逻辑一律在 `operations/<action>.ts` 里，不要往这层塞分支。
+ */
+const FORBIDDEN_INPUT_KEYS = new Set([
+    'access_token',
+    'app_key',
+    'app_secret',
+    'cookie',
+    'eteamsid',
+    'token',
+    'sid',
+    'eteamsId',
+]);
+export function normalizeInput(raw) {
+    return raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+}
+export async function executeReceptionOperation(operation, rawInput, context) {
+    const handler = getReceptionOperation(operation);
+    const input = normalizeInput(rawInput);
+    for (const key of Object.keys(input)) {
+        if (FORBIDDEN_INPUT_KEYS.has(key)) {
+            throw receptionValidationError('FORBIDDEN_INPUT', `禁止传入凭据字段：${key}`, {
+                hint: '凭据由 CLI 运行时统一注入，业务入参不接受',
+            });
+        }
+    }
+    return handler.execute(input, context);
+}

package/dist/shortcuts/reception/upload.js

@@ -0,0 +1,218 @@
+/**
+ * 文件上传协议：teamsCheck → preUploadCheck → module/upload。
+ *
+ * **为什么不走 `/api/file/upload`**：这个接口在 E10 侧已废弃，实测会返回 200 但响应里没有
+ * fileid（或直接是登录页 HTML），表现为「上传失败但没有原因」。现行链路是三步：
+ *
+ *   1. `POST /api/baseserver/layout/teamsCheck`            —— 校验当前用户身份
+ *   2. `POST /api/file/preUploadCheck?sf_request_type=ajax` —— 预检，返回上传策略
+ *   3. `POST /api/file/module/upload?sf_request_type=ajax`  —— 按策略上传，返回 fileid
+ *
+ * 策略有三：`second`（秒传，服务端已有同 MD5 文件）、`common`（一次传完）、`chunk`（分片）。
+ *
+ * 逻辑与 `@weaver/reception-cli@0.7.1` 的 `lib/upload.js` 一致；与 `caizhilian` 的
+ * `file-upload/protocol.ts` 同源（那边为了大文件走流式 multipart，这里文件小，用 FormData）。
+ */
+import { createHash } from 'node:crypto';
+import { readFile, stat } from 'node:fs/promises';
+import { basename } from 'node:path';
+/** 上传协议层错误：`subtype` 直接进 CLI 的 error.subtype，便于按码排障。 */
+export class UploadProtocolError extends Error {
+    subtype;
+    httpStatus;
+    detail;
+    contentType;
+    constructor(subtype, message, httpStatus, detail, contentType) {
+        super(message);
+        this.subtype = subtype;
+        this.httpStatus = httpStatus;
+        this.detail = detail;
+        this.contentType = contentType;
+        this.name = 'UploadProtocolError';
+    }
+}
+const object = (value) => (value && typeof value === 'object' && !Array.isArray(value) ? value : {});
+const hasKeys = (value) => Object.keys(value).length > 0;
+/** 判定响应是否表示成功，返回可用的 data 节点。 */
+function checkedData(response) {
+    const contentType = response.headers?.get?.('content-type') || '';
+    const text = String(response.text || '');
+    const isHtml = /text\/html/i.test(contentType) || /^\s*<!DOCTYPE\s+html|^\s*<html[\s>]/i.test(text);
+    if (response.status !== 200) {
+        throw new UploadProtocolError(response.status === 401 ? 'upload_auth_expired' : 'upload_http_error', response.status === 401 ? '登录已失效，请在原登录工具中恢复后再试' : `文件服务 HTTP ${response.status}`, response.status, text.slice(0, 300) || undefined, contentType || undefined);
+    }
+    if (isHtml) {
+        throw new UploadProtocolError('upload_response_html', '文件服务返回了 HTML 页面（通常是登录页或错误页）', response.status, text.slice(0, 300), contentType);
+    }
+    const envelope = object(response.value);
+    const data = envelope.data === undefined ? envelope : object(envelope.data);
+    if (!hasKeys(data)) {
+        throw new UploadProtocolError('upload_response_invalid', '文件服务响应缺少数据对象', response.status, text.slice(0, 300) || undefined, contentType || undefined);
+    }
+    for (const record of [
+        envelope,
+        data,
+        object(data.fileObj),
+        object(data.uploadModuleDto),
+        object(data.imUploadInfoDto),
+        object(object(data.uploadModuleDto).fileObj),
+        object(object(data.imUploadInfoDto).fileObj),
+    ]) {
+        if (!hasKeys(record))
+            continue;
+        const flag = (value, literal) => value === literal || String(value).toLowerCase() === String(literal);
+        const code = record.code == null ? '' : String(record.code).toLowerCase();
+        if (flag(record.status, false)
+            || flag(record.success, false)
+            || flag(record.fail, true)
+            || (code && !['0', '200', 'success'].includes(code))) {
+            throw new UploadProtocolError('upload_business_failed', String(record.msg || record.message || '文件服务未确认操作成功'), response.status, text.slice(0, 300), contentType);
+        }
+    }
+    return data;
+}
+/**
+ * 在响应里找文件记录。
+ * 不同模块的上传接口把 fileid 放在不同层级：顶层、`fileObj`、`uploadModuleDto`、`imUploadInfoDto`。
+ * `sizes` 收齐各层的 size，用于交叉校验服务端是否真的收全了。
+ */
+function fileRecord(data) {
+    const candidates = [
+        [data, undefined],
+        [object(data.fileObj), data],
+        [object(data.uploadModuleDto), data],
+        [object(object(data.uploadModuleDto).fileObj), object(data.uploadModuleDto)],
+        [object(data.imUploadInfoDto), data],
+        [object(object(data.imUploadInfoDto).fileObj), object(data.imUploadInfoDto)],
+    ];
+    let result;
+    for (const [record, parent] of candidates) {
+        if (!hasKeys(record))
+            continue;
+        if (record.fileId && record.fileid && String(record.fileId) !== String(record.fileid)) {
+            throw new UploadProtocolError('upload_file_id_conflict', '文件服务返回冲突的文件 ID');
+        }
+        const id = record.fileId ?? record.fileid;
+        if (id === undefined || id === null || id === '')
+            continue;
+        if ((typeof id !== 'string' && typeof id !== 'number')
+            || (typeof id === 'number' && (!Number.isSafeInteger(id) || id <= 0))) {
+            throw new UploadProtocolError('upload_file_id_invalid', '文件服务返回无效文件 ID');
+        }
+        const text = String(id).trim();
+        if (!text || text === '0')
+            continue;
+        if (result && result.id !== text) {
+            throw new UploadProtocolError('upload_file_id_conflict', '文件服务返回冲突的文件 ID');
+        }
+        result ??= { id: text, sizes: [] };
+        result.sizes.push(record.size, parent?.size, data.size);
+    }
+    return result;
+}
+/** 取「已完成」的文件 ID，并校验服务端报告的文件大小。 */
+function terminal(data, expectedSize) {
+    const record = fileRecord(data);
+    if (!record || data.endChunk === false || data.endChunk === 'false') {
+        throw new UploadProtocolError('upload_not_terminal', '上传未返回已完成的文件 ID');
+    }
+    for (const value of record.sizes) {
+        if (value === undefined || value === null || value === '')
+            continue;
+        const size = Number(value);
+        if (!Number.isSafeInteger(size) || size < 0 || (size !== 0 && size !== expectedSize)) {
+            throw new UploadProtocolError('upload_size_mismatch', `服务端文件大小与本地不一致（服务端 ${value}，本地 ${expectedSize}）`);
+        }
+    }
+    return record.id;
+}
+/** 发一次 multipart 并判定成功，返回 data 节点。 */
+async function send(transport, path, fields, file) {
+    const form = new FormData();
+    for (const [key, value] of Object.entries(fields))
+        form.append(key, value);
+    if (file) {
+        form.append('file', new Blob([new Uint8Array(file.buffer.subarray(file.start, file.start + file.size))]), `e10upload.${file.ext}`);
+    }
+    return checkedData(await transport.post(path, form));
+}
+/**
+ * 走完三阶段上传，返回 fileid。
+ * 失败一律抛 `UploadProtocolError`，由调用方转成 CLI 的 error/warning。
+ */
+export async function uploadToFileService(input) {
+    const buffer = await readFile(input.filePath);
+    const info = await stat(input.filePath);
+    const name = input.name || basename(input.filePath);
+    const ext = (name.match(/\.([^.]+)$/) || [, 'bin'])[1].toLowerCase();
+    const lastModified = String(Math.floor(info.mtimeMs));
+    const fields = {
+        compressImg: 'false',
+        name,
+        size: String(buffer.length),
+        module: input.module,
+        MD5: createHash('md5').update(buffer).digest('hex'),
+        lastModified,
+        lastModifiedDate: lastModified,
+    };
+    if (input.userId)
+        fields.userid = String(input.userId);
+    // 1) 身份校验：确认服务端认到的用户与会话一致，否则后续上传会以匿名身份落盘
+    const identity = await send(input.transport, '/api/baseserver/layout/teamsCheck', {});
+    const employeeId = object(identity.currentUser).employeeId;
+    const employeeText = employeeId === undefined || employeeId === null ? '' : String(employeeId).trim();
+    if (!employeeText) {
+        throw new UploadProtocolError('upload_identity_missing', '身份校验未返回 employeeId，无法确认上传身份');
+    }
+    if (input.userId && employeeText !== String(input.userId).trim()) {
+        throw new UploadProtocolError('upload_identity_mismatch', `会话用户（${input.userId}）与文件服务认到的用户（${employeeText}）不一致，请重新登录`);
+    }
+    // 2) 预检：拿上传策略
+    const pre = await send(input.transport, '/api/file/preUploadCheck?sf_request_type=ajax', fields);
+    const type = String(pre.uploadType || '');
+    if (!['second', 'common', 'chunk'].includes(type)) {
+        throw new UploadProtocolError('upload_type_invalid', `文件服务返回未知上传策略：${type || '(空)'}`);
+    }
+    // 3) 秒传：服务端已有同 MD5 文件，预检响应里直接带 fileid
+    if (type === 'second') {
+        return { fileid: terminal(pre, buffer.length), name, size: buffer.length, kind: ext };
+    }
+    const preUploadId = String(pre.preUploadId ?? '').trim();
+    if (!preUploadId || preUploadId === '0') {
+        throw new UploadProtocolError('upload_precheck_invalid', '预检未返回有效 preUploadId');
+    }
+    const uploadFields = { ...fields, preUploadId, uploadType: type };
+    // 4) 直传：一次把整个文件发完
+    if (type === 'common') {
+        const data = await send(input.transport, '/api/file/module/upload?sf_request_type=ajax', uploadFields, {
+            name, ext, buffer, start: 0, size: buffer.length,
+        });
+        return { fileid: terminal(data, buffer.length), name, size: buffer.length, kind: ext };
+    }
+    // 5) 分片：按服务端给的 MiB 大小切片，逐片上报
+    const chunkMiB = Number(pre.chunkDto?.chunkSize);
+    if (!Number.isSafeInteger(chunkMiB) || chunkMiB <= 0 || buffer.length <= 0) {
+        throw new UploadProtocolError('upload_chunk_size_invalid', '分片上传要求非空文件与正整数 MiB 分片大小');
+    }
+    const chunkSize = chunkMiB * 1024 * 1024;
+    const count = Math.max(1, Math.ceil(buffer.length / chunkSize));
+    if (pre.chunkDto?.chunkCount !== undefined && Number(pre.chunkDto.chunkCount) !== count) {
+        throw new UploadProtocolError('upload_chunk_count_mismatch', `服务端分片数（${pre.chunkDto.chunkCount}）与本地计算（${count}）不一致`);
+    }
+    let fileid = '';
+    for (let index = 0; index < count; index += 1) {
+        const start = index * chunkSize;
+        const size = Math.min(chunkSize, buffer.length - start);
+        const data = await send(input.transport, '/api/file/module/upload?sf_request_type=ajax', { ...uploadFields, chunk: String(index), chunks: String(count), uploadShardSize: String(size) }, { name, ext, buffer, start, size });
+        if (index === count - 1) {
+            fileid = terminal(data, buffer.length);
+        }
+        else if (data.endChunk !== false || fileRecord(data)) {
+            // 中间分片必须有明确的「未完成」标记，且不能提前返回 fileid，否则说明服务端行为异常
+            throw new UploadProtocolError('upload_chunk_terminal_early', '中间分片缺少未完成标记或提前返回了文件 ID');
+        }
+    }
+    if (!fileid)
+        throw new UploadProtocolError('upload_not_terminal', '分片上传未确认完成');
+    return { fileid, name, size: buffer.length, kind: ext };
+}

package/dist/shortcuts/recruit-stage/context.js

@@ -0,0 +1,231 @@
+import { join, resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { createRecruitContextLoader, } from '../ehr/operations/recruit.js';
+import { rsFail } from './errors.js';
+const flowMemo = new Map();
+/**
+ * 自用系统（selfUse=1）默认招聘流程兜底常量 —— 2026-11-05 用户明确指定写死。
+ *
+ * 背景：www.e-cology.com.cn 是自用系统，招聘流程**只有一条**「初筛+面试+offer阶段」。
+ * 该环境的运行时解析通道全部取不到值（实测）：
+ *   · 环境缓存无 defaultRecruitFlow 键、无 menus 字段
+ *   · 原接口 /api/recruit/position/recruitFlow/list 不存在（静默失败）
+ *   · 招聘流程菜单列表经 listInit + getListDatas 仍未返回可用行
+ *
+ * ⚠️ 与技能「环境 id 绝不入包、跨环境自适应」原则冲突，故**加双重守卫**：
+ *   仅当 selfUse=1 且域名等于 selfUseHost 时才使用本常量；其他环境继续走运行时解析，不受影响。
+ *   换环境或该流程数据变更时必须同步修改此处。
+ */
+const SELFUSE_DEFAULT_FLOW = {
+    selfUseHost: 'www.e-cology.com.cn',
+    id: '874896524979806209',
+    name: '初筛+面试+offer阶段',
+};
+const digitalMenuMemo = new Map();
+function cacheDirFor(baseUrl) {
+    const url = new URL(baseUrl);
+    const host = url.hostname + (url.port ? `_${url.port}` : '');
+    const envRoot = process.env.E10_SKILL_CACHE_DIR;
+    if (envRoot)
+        return join(envRoot, host);
+    const home = process.env.WEAVER_WORK_CLI_HOME || process.env.WORK_CLI_HOME || resolve(homedir(), '.weaver-work-cli');
+    return join(home, 'env-cache', 'recruit-ops', host);
+}
+/**
+ * 磁盘缓存兼容：脚本版（recruit-stage 技能）播种的缓存里若已带 defaultRecruitFlow /
+ * lists.digital_human，直接复用（同环境免请求）；CLI 侧则运行时解析一次并 memo。
+ */
+async function readLegacyCacheExtra(baseUrl) {
+    try {
+        const dir = cacheDirFor(baseUrl);
+        if (!existsSync(dir))
+            return { defaultRecruitFlow: null, digitalHumanMenu: null };
+        const files = await (await import('node:fs/promises')).readdir(dir);
+        const jsonFiles = files.filter((f) => f.endsWith('.json'));
+        // 原实现要求「目录内恰好 1 个 json 才读」，多环境/多应用共存时必然读不到 →
+        // 改为遍历全部 json，取第一个带所需键的（2026-11-05 修）。
+        let flow = null;
+        let dh = null;
+        for (const f of jsonFiles) {
+            let raw;
+            try {
+                raw = JSON.parse(await readFile(join(dir, f), 'utf8'));
+            }
+            catch {
+                continue;
+            }
+            if (!flow && raw?.defaultRecruitFlow && raw.defaultRecruitFlow.id) {
+                flow = { id: String(raw.defaultRecruitFlow.id), name: String(raw.defaultRecruitFlow.name || '') };
+            }
+            if (!dh && raw?.lists?.digital_human?.listId) {
+                dh = {
+                    menuName: String(raw.lists.digital_human.menuName || '面试数字人配置'),
+                    listId: String(raw.lists.digital_human.listId),
+                    cusMenuId: String(raw.lists.digital_human.cusMenuId || ''),
+                };
+            }
+            if (flow && dh)
+                break;
+        }
+        return { defaultRecruitFlow: flow, digitalHumanMenu: dh };
+    }
+    catch {
+        return { defaultRecruitFlow: null, digitalHumanMenu: null };
+    }
+}
+/** 从菜单树/list 里找「招聘流程」列表参数（本环境实测存在于 lists.all_search） */
+function findFlowMenu(cache) {
+    const all = ((cache.lists || {}).all_search || []);
+    const hit = all.find((m) => m && m.listId && /招聘流程/.test(String(m.menuName || '')));
+    if (hit) {
+        return { listId: String(hit.listId), cusMenuId: String(hit.cusMenuId || ''), menuName: String(hit.menuName || '招聘流程') };
+    }
+    return null;
+}
+/** 判断某行是否为「默认启用」流程：兼容多种字段命名 */
+function isDefaultFlowRow(x) {
+    if (!x)
+        return false;
+    const cands = [x.is_default, x.isDefault, x.default_flow, x.defaultFlow, x.is_enable, x.enabled, x.status];
+    for (const v of cands) {
+        if (v === true || v === 1 || v === '1')
+            return true;
+        if (String(v) === '是' || String(v) === '启用' || String(v) === '默认')
+            return true;
+    }
+    return false;
+}
+/** 默认招聘流程解析：优先 legacy 缓存 → 招聘流程菜单列表 → 旧接口兜底。失败**不缓存**（允许多次重试）。 */
+async function resolveDefaultRecruitFlow(host, baseUrl, appId, cache) {
+    const memoKey = baseUrl;
+    if (flowMemo.has(memoKey))
+        return flowMemo.get(memoKey) ?? null;
+    const legacy = await readLegacyCacheExtra(baseUrl);
+    if (legacy.defaultRecruitFlow) {
+        flowMemo.set(memoKey, legacy.defaultRecruitFlow);
+        return legacy.defaultRecruitFlow;
+    }
+    let result = null;
+    // ① 招聘流程菜单列表（本环境实测入口，原实现只调接口必然失败）
+    const menu = findFlowMenu(cache);
+    if (menu) {
+        try {
+            // getListDatas 的 passid/cid 必须是**表单 objId**，不是 listId；
+            // 先用 listInit 用 listId 反查 objId（口径同 interview-arrange 的数字人菜单解析）
+            let flowObjId = '';
+            try {
+                const liBody = {
+                    cusMenuId: menu.cusMenuId,
+                    listId: menu.listId,
+                    urlPageTitle: menu.menuName,
+                };
+                liBody['appId_' + menu.listId] = appId;
+                const li = await host.request({ path: '/api/ebuilder/form/list/listInit', body: liBody });
+                flowObjId = String(li?.data?.objid || '');
+            }
+            catch { /* listInit 不可用 → 走接口兜底 */ }
+            if (flowObjId) {
+                const body = {
+                    current: 1, pageSize: 50, tableuid: Math.random().toString(16).slice(2, 34),
+                    listId: menu.listId, searchParamData: { searchType: '3', type: 'and' },
+                    terminal: 'PC', browser: 'Chrome', requiredMatch: 1, mapResult: 1,
+                    recheckQuery: 1, isFollow: 0, isShareToMe: 0, filterCondition: {},
+                    cusMenuId: menu.cusMenuId, urlPageTitle: menu.menuName, menuName: menu.menuName,
+                };
+                const r = await host.request({
+                    path: `/api/ebuilder/form/list/getListDatas?passid=${flowObjId}&cid=${flowObjId}`,
+                    body,
+                    headers: { ebBusinessId: menu.listId },
+                });
+                const rows = (r?.data?.data || r?.data?.displayData || []);
+                const pick = rows.find(isDefaultFlowRow) || (rows.length === 1 ? rows[0] : null);
+                if (pick) {
+                    const id = String(pick.form_data_id || pick.id || '');
+                    const name = String(pick.name || pick.flow_name || pick.content || '');
+                    if (id && name)
+                        result = { id, name };
+                }
+            }
+        }
+        catch { /* 菜单通道不可用 → 走接口兜底 */ }
+    }
+    // ② 旧接口兜底（原实现唯一通道，部分环境保留）
+    if (!result) {
+        try {
+            const r = await host.request({
+                path: '/api/recruit/position/recruitFlow/list',
+                method: 'POST',
+                body: { appId, current: 1, pageSize: 50 },
+                operation: 'context.defaultRecruitFlow',
+            });
+            const rows = r?.data?.list || r?.data?.rows || r?.data || [];
+            const list = Array.isArray(rows) ? rows : [];
+            const enabled = list.find(isDefaultFlowRow) || null;
+            if (enabled?.id) {
+                result = { id: String(enabled.id), name: String(enabled.name || enabled.flow_name || '') };
+            }
+        }
+        catch { /* 接口形态不符/未开放 */ }
+    }
+    // ③ 自用系统兜底（用户指定写死）：仅 selfUse=1 且域名匹配时生效，不影响其他环境
+    if (!result) {
+        const isSelfUse = String(cache?.selfUse || '') === '1';
+        let host = '';
+        try {
+            host = new URL(baseUrl).hostname;
+        }
+        catch {
+            host = '';
+        }
+        if (isSelfUse && host === SELFUSE_DEFAULT_FLOW.selfUseHost) {
+            result = { id: SELFUSE_DEFAULT_FLOW.id, name: SELFUSE_DEFAULT_FLOW.name };
+        }
+    }
+    // 只有解析成功才写入 memo：失败若也缓存 null，进程内后续所有请求都拿不到（原实现缺陷）
+    if (result)
+        flowMemo.set(memoKey, result);
+    return result;
+}
+async function resolveDigitalHumanMenu(host, baseUrl, cache) {
+    const memoKey = baseUrl;
+    if (digitalMenuMemo.has(memoKey))
+        return digitalMenuMemo.get(memoKey) ?? null;
+    const legacy = await readLegacyCacheExtra(baseUrl);
+    if (legacy.digitalHumanMenu) {
+        digitalMenuMemo.set(memoKey, legacy.digitalHumanMenu);
+        return legacy.digitalHumanMenu;
+    }
+    // 从 all_search 菜单里按别名找（跨基线菜单名不同：面试数字人配置/数字人配置）
+    const allSearch = (cache.lists?.all_search || []);
+    const candidates = allSearch.filter((m) => m.listId);
+    let hit = (candidates.find((m) => (m.menuName || '').includes('面试数字人'))
+        || candidates.find((m) => (m.menuName || '').includes('数字人配置'))) ?? null;
+    digitalMenuMemo.set(memoKey, hit);
+    return hit;
+}
+const loaders = new Map();
+export function createRecruitStageContext() {
+    return async (host) => {
+        const loaderKey = 'shared';
+        if (!loaders.has(loaderKey))
+            loaders.set(loaderKey, createRecruitContextLoader());
+        const cache = await loaders.get(loaderKey).load(host);
+        const baseUrl = (await host.getSession()).baseUrl.replace(/\/+$/, '');
+        const [defaultRecruitFlow, digitalHumanMenu] = await Promise.all([
+            resolveDefaultRecruitFlow(host, baseUrl, cache.appId, cache),
+            resolveDigitalHumanMenu(host, baseUrl, cache),
+        ]);
+        return { ...cache, defaultRecruitFlow, digitalHumanMenu };
+    };
+}
+/** 供 operation 内直接取上下文的辅助（失败统一转 rs 错误）。 */
+export async function loadContext(host) {
+    try {
+        return await createRecruitStageContext()(host);
+    }
+    catch (e) {
+        throw rsFail(e?.message || '招聘环境上下文解析失败', { stage: 'context' });
+    }
+}

package/dist/shortcuts/recruit-stage/continuation.js

@@ -0,0 +1,74 @@
+import { CONTINUATION_TTL_MS } from '../../core/continuation-ttl.js';
+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 { rsValidationError } 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, 'recruit-stage-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 createRecruitStageContinuationSigner(ctx) {
+    return {
+        async issue(payload, ttlMs = CONTINUATION_TTL_MS) {
+            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 rsValidationError('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 rsValidationError('continuation_invalid', 'continuation 签名校验失败');
+            let payload;
+            try {
+                payload = JSON.parse(Buffer.from(body, 'base64url').toString('utf8'));
+            }
+            catch {
+                throw rsValidationError('continuation_invalid', 'continuation 载荷解析失败');
+            }
+            if (!payload || typeof payload !== 'object') {
+                throw rsValidationError('continuation_invalid', 'continuation 载荷必须是对象');
+            }
+            if (typeof payload.expiresAt === 'number' && Date.now() > payload.expiresAt) {
+                throw rsValidationError('continuation_expired', 'continuation 已过期，请重新 prepare');
+            }
+            if (payload.operation && String(payload.operation) !== String(expectedOperation)) {
+                throw rsValidationError('continuation_operation_mismatch', `continuation 属于操作 ${String(payload.operation)}，不能用于 ${expectedOperation}`);
+            }
+            return payload;
+        },
+    };
+}