weaver-e9-assistant-cli 1.1.4 → 1.1.5

package/dist/kq.js

@@ -183,6 +183,71 @@ export async function punch(cfg, opts) {
         raw: j,
     };
 }
+// ─── 考勤统计 / 假期余额（getHrmKQReportInfo）──────────────
+/**
+ * 考勤统计 + 假期余额。POST /api/hrm/kq/report/getHrmKQReportInfo（token 鉴权）。
+ * 参数（OA 前端 bundle 逆向）：`loaddata=1` **必传**（缺了只回空壳）；`type` 1=年 / 2=月；
+ *   `typevalue` "2026" / "2026-09"；`resourceId` = 目标 hrmresource id（**可查他人**，缺省=当前登录人）。
+ * 返回四组：出勤统计（应出勤/实际出勤/缺勤）、流程时长（请假/出差/公出/加班/异常抵扣）、
+ *   异常（迟到/早退/旷工/漏签）、请假信息（年假/带薪病假/调休 的上一年可请/今年剩余/当前可请天数）。
+ */
+export async function getKqReport(cfg, opts = {}) {
+    const api = await createApiFromProfile(cfg);
+    const type = String(opts.type ?? '2');
+    const body = { loaddata: '1', type, typevalue: String(opts.typevalue ?? defaultKqTypeValue(type)) };
+    if (opts.resourceId)
+        body.resourceId = String(opts.resourceId);
+    const r = await api.post('/api/hrm/kq/report/getHrmKQReportInfo', body);
+    const j = r.json ?? {};
+    const flat = (g) => (g?.items ?? []).map((it) => ({ title: s(it.title || it.name), value: s(it.value), type: s(it.type) }));
+    const g1 = j.groupitem1 ?? {};
+    return {
+        type,
+        typevalue: body.typevalue,
+        resourceId: body.resourceId ?? '',
+        attendance: { workDays: s(g1.value), items: flat(g1) },
+        durations: flat(j.groupitem2),
+        exceptions: flat(j.groupitem3),
+        leave: (j.groupitem4?.items ?? []).map((g) => ({
+            title: s(g?.title),
+            items: (g?.item ?? []).filter((x) => x && x.title).map((x) => ({ title: s(x.title), value: s(x.value) })),
+        })),
+        status: j.status,
+        raw: j,
+    };
+}
+
+/** 月度考勤明细（签到/签退时间与 IP）。POST /api/hrm/kq/report/getHrmKQMonthReportInfo（仅月视图）。 */
+export async function getKqMonthReport(cfg, opts = {}) {
+    const api = await createApiFromProfile(cfg);
+    const body = { loaddata: '1', type: '2', typevalue: String(opts.typevalue ?? defaultKqTypeValue('2')) };
+    if (opts.resourceId)
+        body.resourceId = String(opts.resourceId);
+    const r = await api.post('/api/hrm/kq/report/getHrmKQMonthReportInfo', body);
+    const res = r.json?.result ?? {};
+    const days = Object.keys(res)
+        .sort((a, b) => Number(a) - Number(b))
+        .map((k) => {
+            const d = res[k] ?? {};
+            const all = (d.signInfo ?? []).flatMap((seg) => seg?.item ?? []);
+            const pick = (t) => s(all.find((x) => x?.title === t)?.value);
+            return {
+                date: s(d.date),
+                types: d.types ?? [],
+                signIn: pick('签到时间'), signInIp: pick('签到IP'),
+                signOut: pick('签退时间'), signOutIp: pick('签退IP'),
+            };
+        });
+    return { typevalue: body.typevalue, resourceId: body.resourceId ?? '', days, status: r.json?.status, raw: r.json };
+}
+
+/** 默认 typevalue：type=1 → "YYYY"，type=2 → "YYYY-MM"（本地时区）。 */
+function defaultKqTypeValue(type) {
+    const d = new Date();
+    const p = (n) => String(n).padStart(2, '0');
+    return String(type) === '1' ? `${d.getFullYear()}` : `${d.getFullYear()}-${p(d.getMonth() + 1)}`;
+}
+
 // ───────────────── 工具 ─────────────────
 function s(v) {
     if (v === undefined || v === null)

package/dist/nodemap.js

@@ -0,0 +1,242 @@
+/**
+ * 流程节点名解析：nodeid → nodename。
+ *
+ * 背景：待办/已办/我发起列表服务端**只给当前节点的 id**——行字段 `currentnodeid` 的值形如 "2882"，
+ *   且行里没有节点名（实测 `currentnodeidspan` 也只是 id 本身，整行不含 currentnodename/currentnodespan）。
+ *   要显示名字只能按流程另取节点表。
+ *
+ * 接口（2026-10-14 实测 e9pc.e-cology.com.cn）：
+ *   POST /api/workflow/test/getNodeInfo   body: { workflowId }
+ *     → { nodeInfo: [{id, name, type}], wfInfo: {workflowName, version}, authority, tabInfo, ... }
+ *   - 只需 workflowId；文档里的 requestid/userId/type 都非必需（逐个试过）。
+ *   - ⚠️ 路径必须带 `/api` 前缀：`/workflow/test/getNodeInfo`（无前缀）返回登录页 HTML。
+ *   - ⚠️ 接口挂在「流程测试」模块下，非所有部署/版本都有 → **一律 fail-soft**：
+ *       拿不到就返回 null，调用方退回显示节点 id，绝不让列表整体报错。
+ *   - `type`：0=发起节点 / 1=审批节点 / 3=归档节点。
+ *
+ * 缓存：`~/.e9/node_map_<envkey>.json`，按 workflowId 存，TTL 30 天
+ *   （节点表几乎不变；响应带 version，流程改版后重新拉取自然覆盖）。
+ *   - `E9_NODEMAP_CACHE_DIR` 覆盖缓存目录（测试隔离用，避免污染真实 ~/.e9）。
+ *   - `E9_NO_NODE_NAME=1` 或 CLI `--no-node-name` 整体停用解析。
+ */
+import { createApiFromProfile } from './client.js';
+import { endpointFor, profileNameFromBaseUrl } from './config.js';
+import { stripHtml } from './parse.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+/** 节点表缓存 TTL（天）。 */
+export const NODEMAP_TTL_MS = (Number(process.env.E9_NODEMAP_TTL_DAYS ?? '30') || 30) * 24 * 3600 * 1000;
+/** 并发拉取上限（一次列表页通常 ≤10 个流程，全量拉取路径可能几十个，别一次打满）。 */
+const FETCH_CHUNK = 6;
+
+function str(v) {
+    if (v === undefined || v === null || v === '')
+        return undefined;
+    return String(v);
+}
+
+/** 缓存目录（测试可用 E9_NODEMAP_CACHE_DIR 覆盖）。 */
+export function nodeMapCacheDir() {
+    return process.env.E9_NODEMAP_CACHE_DIR || path.join(os.homedir(), '.e9');
+}
+/** 缓存文件路径：~/.e9/node_map_<envkey>.json（按环境隔离，nodeid 不跨环境通用）。 */
+export function nodeMapCachePath(cfg) {
+    const baseUrl = endpointFor(cfg).baseUrl.replace(/\/+$/, '');
+    return path.join(nodeMapCacheDir(), `node_map_${profileNameFromBaseUrl(baseUrl)}.json`);
+}
+
+/** 是否停用节点名解析（E9_NO_NODE_NAME=1）。 */
+export function isNodeNameDisabled() {
+    return process.env.E9_NO_NODE_NAME === '1';
+}
+
+/**
+ * 纯函数：把 getNodeInfo 响应归一化为 { workflowName, version, nodes:{id:name} }。
+ * 结构不符（登录页/空表/非 JSON）返回 null——调用方据此 fail-soft。
+ */
+export function parseNodeInfo(json) {
+    const list = json?.nodeInfo;
+    if (!Array.isArray(list))
+        return null;
+    const nodes = {};
+    for (const n of list) {
+        const id = str(n?.id);
+        if (!id)
+            continue;
+        nodes[id] = stripHtml(n?.name) || id;
+    }
+    if (Object.keys(nodes).length === 0)
+        return null;
+    return {
+        workflowName: str(json?.wfInfo?.workflowName),
+        version: str(json?.wfInfo?.version),
+        nodes,
+    };
+}
+
+/** 读缓存文件；坏文件/不存在返回 {}。 */
+function readCache(cfg) {
+    try {
+        const p = nodeMapCachePath(cfg);
+        if (!fs.existsSync(p))
+            return {};
+        const raw = JSON.parse(fs.readFileSync(p, 'utf8'));
+        return raw && typeof raw === 'object' && raw.workflows ? raw.workflows : {};
+    }
+    catch {
+        return {};
+    }
+}
+
+/** 写回缓存（单流程）；写入失败不阻断（节点名只是锦上添花）。 */
+function writeCache(cfg, workflowId, entry) {
+    try {
+        const p = nodeMapCachePath(cfg);
+        const workflows = readCache(cfg);
+        workflows[workflowId] = entry;
+        const baseUrl = endpointFor(cfg).baseUrl.replace(/\/+$/, '');
+        fs.mkdirSync(path.dirname(p), { recursive: true });
+        fs.writeFileSync(p, JSON.stringify({
+            envkey: profileNameFromBaseUrl(baseUrl),
+            baseUrl,
+            updatedAt: new Date().toISOString(),
+            workflows,
+        }, null, 2) + '\n', 'utf8');
+    }
+    catch { /* 忽略：缓存写失败不影响本次结果 */ }
+}
+
+function isStale(entry) {
+    if (!entry || !entry.fetchedAt)
+        return true;
+    return Date.now() - new Date(entry.fetchedAt).getTime() > NODEMAP_TTL_MS;
+}
+
+/**
+ * 取某流程的节点表（带缓存）。任何失败返回 null（fail-soft，不抛）。
+ * @returns {Promise<{workflowName?:string, version?:string, nodes:Record<string,string>}|null>}
+ */
+export async function getNodeMap(cfg, workflowId, opts = {}) {
+    const wfId = str(workflowId);
+    if (!wfId)
+        return null;
+    const cached = readCache(cfg)[wfId];
+    if (!opts.refresh && cached && !isStale(cached) && cached.nodes)
+        return { workflowName: cached.workflowName, version: cached.version, nodes: cached.nodes };
+    const api = opts.api ?? await createApiFromProfile(cfg);
+    let json = null;
+    try {
+        const r = await api.post('/api/workflow/test/getNodeInfo', { workflowId: wfId });
+        json = r?.json ?? null;
+    }
+    catch {
+        json = null; // 网络/鉴权异常同上：降级，不打断列表
+    }
+    const parsed = parseNodeInfo(json);
+    if (!parsed)
+        return null;
+    writeCache(cfg, wfId, { ...parsed, workflowId: wfId, fetchedAt: new Date().toISOString() });
+    return parsed;
+}
+
+/**
+ * 列出**本地缓存**里所有流程的节点表（供「按节点名跨流程解析」用）。
+ * 缓存来自历次列表查询；从没查过的流程不在其中。
+ */
+export function listCachedNodeMaps(cfg) {
+    const workflows = readCache(cfg);
+    return Object.entries(workflows)
+        .filter(([, w]) => w && w.nodes && Object.keys(w.nodes).length)
+        .map(([workflowId, w]) => ({ workflowId: String(workflowId), workflowName: w.workflowName, nodes: w.nodes }));
+}
+
+/**
+ * 按**节点名**解析节点 id（供 CLI `--node-name`）。
+ *
+ * 节点 id 是**流程内编号**（每个流程一套），故解析必须先限定流程范围：
+ *   - 给了 `workflowId`：只在该流程的节点表内找（按需拉取，不依赖缓存）；
+ *   - 未给：在**本地缓存**的所有流程节点表内找（缓存来自历次列表查询）。
+ *
+ * 匹配规则：**先精确同名**；无精确才做模糊（互相包含）。多候选一律**全部返回**，
+ * 由调用方列给用户选——严禁自动取首条（本仓库硬规则）。
+ *
+ * @returns {Promise<{candidates:Array<{workflowId,workflowName,nodeId,nodeName,matchType}>,
+ *                    exact:Array, scoped:boolean, poolSize:number, unavailable:boolean}>}
+ *   `unavailable`：限定了流程但节点表取不到（接口不存在/异常）——与"确实没有同名节点"要区分开。
+ */
+export async function resolveNodeByName(cfg, name, opts = {}) {
+    const want = String(name ?? '').trim();
+    const empty = { candidates: [], exact: [], scoped: Boolean(opts.workflowId), poolSize: 0, unavailable: false };
+    if (!want)
+        return empty;
+    let pool = [];
+    if (opts.workflowId) {
+        const m = await getNodeMap(cfg, opts.workflowId, opts);
+        if (!m)
+            return { ...empty, unavailable: true };
+        pool = [{ workflowId: String(opts.workflowId), workflowName: m.workflowName, nodes: m.nodes }];
+    }
+    else {
+        pool = listCachedNodeMaps(cfg);
+    }
+    const candidates = [];
+    for (const w of pool) {
+        for (const [nodeId, nodeName] of Object.entries(w.nodes)) {
+            if (!nodeName)
+                continue;
+            const isExact = nodeName === want;
+            const isFuzzy = !isExact && (nodeName.includes(want) || want.includes(nodeName));
+            if (isExact || isFuzzy)
+                candidates.push({ workflowId: w.workflowId, workflowName: w.workflowName, nodeId, nodeName, matchType: isExact ? 'exact' : 'fuzzy' });
+        }
+    }
+    return {
+        candidates,
+        exact: candidates.filter((c) => c.matchType === 'exact'),
+        scoped: Boolean(opts.workflowId),
+        poolSize: pool.length,
+        unavailable: false,
+    };
+}
+
+/** 从列表行取流程 id（normalizeRow 归一字段优先，回退原始行）。 */
+function workflowIdOf(item) {
+    return str(item?.workflowId) ?? str(item?.raw?.workflowid) ?? str(item?.raw?.workflowId);
+}
+
+/**
+ * 给列表行补 `nodeName`（就地写回）。返回补上的行数。
+ *
+ * - 行需带 `node`（节点 id）；流程 id 取 `workflowId` 或 `raw.workflowid`。
+ * - 按流程去重，每个流程只请求一次；同一流程的多行共用一张表。
+ * - 任何失败都不抛：拿不到节点表的行保持原样（渲染层回退显示 id）。
+ */
+export async function annotateNodeNames(cfg, items, opts = {}) {
+    if (!Array.isArray(items) || items.length === 0)
+        return 0;
+    if (opts.disabled)
+        return 0;
+    // 只对「node 是纯数字 id」的行解析：服务端不同列表的 span 给的东西不一样——
+    // 待办/公文给的是**节点 id**（需要解析），流程代理办理记录给的是**节点名**（解析无从匹配，纯浪费请求）。
+    const rows = items.filter((it) => /^\d+$/.test(str(it?.node) ?? '') && workflowIdOf(it));
+    if (rows.length === 0)
+        return 0;
+    const wfIds = [...new Set(rows.map(workflowIdOf))];
+    const maps = new Map();
+    for (let i = 0; i < wfIds.length; i += FETCH_CHUNK) {
+        const chunk = wfIds.slice(i, i + FETCH_CHUNK);
+        const got = await Promise.all(chunk.map((w) => getNodeMap(cfg, w, opts)));
+        chunk.forEach((w, idx) => maps.set(w, got[idx]));
+    }
+    let filled = 0;
+    for (const it of rows) {
+        const name = maps.get(workflowIdOf(it))?.nodes?.[str(it.node)];
+        if (name) {
+            it.nodeName = name;
+            filled++;
+        }
+    }
+    return filled;
+}

package/dist/odoc.js

@@ -119,8 +119,13 @@ export function normalizeOdocRow(row) {
         createDate: stringify(get(['createdate'])),
         sendDepartment: stringify(get(['senddepartment'])),
         lastOperateDate: stringify(get(['lastoperatedate'])),
-        currentNodeId: stripHtml(get(['currentnodeidspan'])) || stringify(get(['currentnodeid'])),
-        currentNode: stripHtml(get(['currentnodespan'])) || stringify(get(['currentnode'])),
+        // ⚠️ E9 公文列表这两列的**字段名与内容是反的**（2026-10-14 实测 wf=552 发文）：
+        //   currentnodeidspan → "拟稿"（公文环节名，是标签不是 id）
+        //   currentnodespan   → "2868"（真正的**节点 id**，用 getNodeInfo 可解析出节点名「拟稿发起」）
+        // 故不再沿用误导性的原名，改为语义正确的 stageName / node；nodeName 由 nodemap 回填。
+        stageName: stripHtml(get(['currentnodeidspan'])) || stringify(get(['currentnodeid'])),
+        node: stripHtml(get(['currentnodespan'])) || stringify(get(['currentnode'])),
+        nodeName: undefined,
         zbr: stringify(get(['zbr'])),
         wbr: stringify(get(['wbr'])),
         docAbstract: stripHtml(get(['docabstractspan'])) || stringify(get(['docabstract'])),

package/dist/parse.js

@@ -158,7 +158,11 @@ export function normalizeRow(row, columns) {
         creatorId,
         createdate: spanOr('createdate', ['createdatespan', 'createDate']),
         receivedate: spanOr('receivedate', ['receivedate', 'recieveDate']),
+        // 注意：服务端流程列表**只有节点 id**（currentnodeidspan 实测也是 id 本身，整行无节点名），
+        // 节点名由 nodemap.annotateNodeNames 按流程节点表回填到 nodeName。
         node: stripHtml(get(['currentnodeidspan', 'currentnodespan'])) || stringify(get(['currentnodeid', 'nodeName', 'nodename'])),
+        nodeName: undefined,
+        workflowId: stringify(get(['workflowid', 'workflowId'])),
         status: stripHtml(get(['statusspan'])) || stringify(get(['status'])),
         level,
         requestmark: stringify(get(['requestmark'])),

package/dist/subordinate.js

@@ -342,6 +342,31 @@ export async function assertNamesInScope(cfg, names, opts = {}) {
     return resolved.length === 1 ? resolved[0] : resolved;
 }
 
+/**
+ * 仅把姓名解析成 uid，**不做任何范围过滤**。
+ *
+ * 与 assertNamesInScope 的区别：后者用于「查询他人」类筛选，越界要拦；
+ * 而本函数用于**给他人派活**的场景（如流程代理把待办委托给谁——委托对象不限于下属），
+ * 只需遵守「人员搜索必须走 blog at-list」这条硬规则，不施加授权集合限制。
+ * 恰 1 个候选才返回；0 个 / 多个一律抛错并**列全候选**（不自动取首条）。
+ */
+export async function resolveNameToUid(cfg, name) {
+    const n = String(name ?? '').trim();
+    if (!n)
+        throw new Error('人员姓名为空。');
+    if (/^\d+$/.test(n))
+        return n;
+    const r = await getAtAllList(cfg, { name: n });
+    const candidates = sortPersonCandidates(r.items, n);
+    if (candidates.length === 0)
+        throw new Error(`未找到「${n}」对应的人员（at-list 无候选）。`);
+    if (candidates.length > 1) {
+        const list = candidates.slice(0, 10).map((c) => `${stripHtml(String(c.name ?? ''))}(${c.uid})`).join('、');
+        throw new Error(`「${n}」匹配到 ${candidates.length} 个人员，请确认后用 --agent <用户id> 指定：${list}${candidates.length > 10 ? ' …' : ''}`);
+    }
+    return String(candidates[0].uid ?? '');
+}
+
 /** 候选过滤到授权集合（纯函数）。策略未启用（默认）时不过滤，全部视为在范围内。 */
 export function filterCandidatesToScope(scope, candidates) {
     if (!isScopeEnforced()) {

package/dist/supervise.js

@@ -0,0 +1,152 @@
+/**
+ * E9 流程督办（supervise）模块。
+ *
+ * 链路（HAR 抓包实证 + 前端 bundle 逆向）：
+ *   1) POST /api/workflow/supervise/getTree        body{menuIds,menuPathIds} → topTab[]（页签）+ treedata（流程类型树）
+ *   2) POST /api/workflow/supervise/getTreeCount   body 同上 → {flowAllCounts, flowOverCounts, treecount{}} 各类型计数
+ *   3) POST /api/workflow/supervise/getConditionInfo body 空 → conditioninfo（搜索条件定义，结构与待办同构）
+ *   4) POST /api/workflow/supervise/getSessionkey  body{同待办过滤项 + tabKey} → sessionkey（**恒顶层**）
+ *        tabKey：0=全部 / 1=未督办 / 2=已督办 / 3=我的关注
+ *   5) POST /api/ec/dev/table/datas   body{dataKey=sessionkey,current,sortParams} → columns + datas 行
+ *   6) POST /api/ec/dev/table/counts  body{dataKey} → {count}
+ *   7) POST /api/workflow/supervise/doSupervise  body{requestids,remark} → 发起督办（勾选多条用逗号分隔）
+ *
+ * 列表行 `ops` 含 4 个操作（前端 href 实证）：督办(handle) / 短信催办(smsHandle) / 邮件催办(emailHandle) / 关注(doAttention)。
+ * ⚠️ 短信/邮件催办的**实际发送接口未抓到**（前端 getSendEmailInfo 取信息后要打开弹窗填写再发），故本模块只做「督办」。
+ */
+import { endpointFor } from './config.js';
+import { createApiFromProfile } from './client.js';
+import { extractRows, extractColumns, extractTotal, pickByPaths, stripHtml } from './parse.js';
+
+/** 督办菜单 id（抓包实证：menuIds=1,235）。 */
+const SUPERVISE_MENU = { menuIds: '1,235', menuPathIds: '1,235' };
+
+/** 督办页签：tabKey ↔ 中文名（getTree.topTab 实证）。 */
+export const SUPERVISE_TABS = {
+    '全部': '0', '未督办': '1', '已督办': '2', '我的关注': '3',
+};
+
+/** 页签名/别名 → tabKey（数字直传）。 */
+export function resolveSuperviseTab(spec) {
+    const s = String(spec ?? '').trim();
+    if (!s)
+        return '0';
+    if (/^[0-3]$/.test(s))
+        return s;
+    const key = Object.keys(SUPERVISE_TABS).find((k) => k === s || k.includes(s));
+    return key ? SUPERVISE_TABS[key] : undefined;
+}
+
+/** 督办页签 + 流程类型树。POST /api/workflow/supervise/getTree */
+export async function getSuperviseTree(cfg) {
+    const api = await createApiFromProfile(cfg);
+    const r = await api.post('/api/workflow/supervise/getTree', SUPERVISE_MENU);
+    const j = r.json ?? {};
+    return {
+        tabs: (j.topTab ?? []).map((t) => ({ key: String(t.key ?? ''), title: String(t.title ?? '') })),
+        tree: j.treedata ?? [],
+        raw: j,
+    };
+}
+
+/** 督办计数。POST /api/workflow/supervise/getTreeCount（flowAllCounts=总数、flowOverCounts=未督办）。 */
+export async function getSuperviseCount(cfg) {
+    const api = await createApiFromProfile(cfg);
+    const r = await api.post('/api/workflow/supervise/getTreeCount', SUPERVISE_MENU);
+    const j = r.json ?? {};
+    return {
+        total: j.flowAllCounts ?? null,
+        pending: j.flowOverCounts ?? null,
+        treeCount: j.treecount ?? {},
+        raw: j,
+    };
+}
+
+/** 督办搜索条件（结构与待办同构）。POST /api/workflow/supervise/getConditionInfo */
+export async function getSuperviseConditions(cfg) {
+    const api = await createApiFromProfile(cfg);
+    const r = await api.post('/api/workflow/supervise/getConditionInfo', {});
+    const j = r.json ?? {};
+    const groups = (j.conditioninfo ?? []).map((g) => ({
+        title: String(g.title ?? ''),
+        items: (g.items ?? []).map((it) => ({
+            label: String(it.label ?? ''),
+            domkey: Array.isArray(it.domkey) ? it.domkey.join(',') : String(it.domkey ?? ''),
+            type: String(it.conditionType ?? ''),
+        })),
+    }));
+    return { groups, raw: j };
+}
+
+/**
+ * 督办列表。getSessionkey → table/datas → table/counts（同待办 table 链路）。
+ * opts: { tabKey, keyword, page, pageSize, ...过滤项 }
+ */
+export async function listSupervise(cfg, opts = {}) {
+    const api = await createApiFromProfile(cfg);
+    const tabKey = String(opts.tabKey ?? '0');
+    const body = {
+        requestname: opts.keyword ?? '',
+        workcode: '', requestlevel: '', creatertype: '0',
+        ownerdepartmentid: opts.creatorDept ?? '', creatersubcompanyid: opts.creatorSubcom ?? '',
+        receivedateselect: '0', receivedatefrom: '', receivedateto: '',
+        createdateselect: '0', createdatefrom: '', createdateto: '',
+        wfstatu: '1', currentnodetype: '', unophrmid: '', docids: '',
+        hrmcreaterid: opts.creator ?? '', crmids: '', proids: '',
+        ...SUPERVISE_MENU, tabKey,
+    };
+    const r1 = await api.post('/api/workflow/supervise/getSessionkey', body);
+    const sessionkey = pickByPaths(r1.json, ['sessionkey', 'data.sessionkey']);
+    if (!sessionkey)
+        throw new Error(`未拿到督办 sessionkey（getSessionkey 响应：${(r1.text ?? '').slice(0, 200)}）`);
+    const page = Number(opts.page ?? '1') || 1;
+    const r2 = await api.post('/api/ec/dev/table/datas', { dataKey: sessionkey, current: String(page), sortParams: '[]', pageSize: String(opts.pageSize ?? '10') });
+    const columns = extractColumns(r2.json);
+    const rows = extractRows(r2.json);
+    const items = rows.map((row) => normalizeSuperviseRow(row, columns));
+    let total = null;
+    let countsRaw = null;
+    try {
+        const r3 = await api.post('/api/ec/dev/table/counts', { dataKey: sessionkey });
+        countsRaw = r3.json;
+        total = extractTotal(r3.json);
+    }
+    catch { /* counts 失败不阻断 */ }
+    let pageSize = pickByPaths(r2.json, ['pageSize', 'data.pageSize']);
+    if (typeof pageSize !== 'number' && /^\d+$/.test(String(pageSize ?? '')))
+        pageSize = parseInt(String(pageSize), 10);
+    return { tabKey, page, total, pageSize: pageSize ?? null, items, sessionkey, columns, raw: { getSessionkey: r1.json, datas: r2.json, counts: countsRaw } };
+}
+
+/** 规范化一行督办（可读值优先取 `<field>span`，回退原值）。 */
+export function normalizeSuperviseRow(row, columns) {
+    if (!row || typeof row !== 'object')
+        return {};
+    void columns;
+    const get = (keys) => pickByPaths(row, keys);
+    const spanOr = (k, extra = []) => stripHtml(get([`${k}span`, k, ...extra]));
+    return {
+        requestId: String(pickByPaths(row, ['requestid', 'randomField2', 'randomFieldId']) ?? ''),
+        title: stripHtml(get(['requestnamespan'])) || String(get(['requestname', 'requestName']) ?? ''),
+        creator: spanOr('creater', ['createrName']),
+        createTime: spanOr('createtime', ['createdate']),
+        node: stripHtml(get(['currentnodeidspan', 'currentnodespan'])) || String(get(['currentnodeid', 'currentnodename']) ?? ''),
+        unoperators: stripHtml(get(['unoperatorsspan', 'unoperators'])),
+        workflowId: String(get(['workflowid', 'randomField0']) ?? ''),
+        raw: row,
+    };
+}
+
+/** 发起督办。POST /api/workflow/supervise/doSupervise（body: requestids + remark）。 */
+export async function doSupervise(cfg, opts = {}) {
+    const ep = endpointFor(cfg);
+    const requestIds = String(opts.requestIds ?? '').split(',').map((s) => s.trim()).filter(Boolean);
+    const remark = String(opts.remark ?? '');
+    if (!requestIds.length)
+        throw new Error('doSupervise 需要 requestIds（逗号分隔多个）。');
+    if (!opts.send)
+        return { sent: false, endpoint: { baseUrl: ep.baseUrl }, requestIds, remark };
+    const api = await createApiFromProfile(cfg);
+    const r = await api.post('/api/workflow/supervise/doSupervise', { requestids: requestIds.join(','), remark });
+    return { sent: true, endpoint: { baseUrl: ep.baseUrl }, requestIds, remark, response: r };
+}

package/dist/todobatch.js

@@ -39,16 +39,25 @@ function pickRandomFields(row) {
     return out;
 }
 
-/** 拉待办列表并取出与 requestIds 匹配的原始行（含 randomField）+ dataKey。跨页匹配直到全部命中或到末尾。 */
-async function loadRowsFor(cfg, requestIds) {
-    // 修复 #6：逐页定位待办是最耗时环节，实时打印进度，避免长时间无输出被误判卡死。
+/** 分类 → 人类可读列表名（用于进度与报错文案）。 */
+const CATEGORY_LABEL = { todo: '待办（待处理）', done: '已办', mine: '我发起的' };
+
+/**
+ * 在指定分类列表中取出与 requestIds 匹配的原始行（含 randomField）+ dataKey。跨页匹配直到全部命中或到末尾。
+ * opts.category：'todo'（默认，待处理）/ 'done'（已办）/ 'mine'（我发起的）——关注在三个分类里都可用；
+ *   提交/转发只对待办有意义，调用方自行传 'todo'。
+ */
+async function loadRowsFor(cfg, requestIds, opts = {}) {
+    const category = opts.category ?? 'todo';
+    const label = CATEGORY_LABEL[category] ?? category;
+    // 修复 #6：逐页定位是最耗时环节，实时打印进度，避免长时间无输出被误判卡死。
     const wanted = new Set(requestIds.map(String));
     const found = new Map();
     let dataKey = '';
-    console.error(`  [批量] 正在待办列表定位 ${requestIds.length} 条流程（按请求顺序逐页搜索）...`);
+    console.error(`  [批量] 正在「${label}」列表定位 ${requestIds.length} 条流程（按请求顺序逐页搜索）...`);
     for (let current = 1; current <= 10; current++) {
-        console.error(`  [批量] 读取待办第 ${current} 页...`);
-        const list = await getWfList(cfg, { category: 'todo', page: current, pageSize: '100' });
+        console.error(`  [批量] 读取${label}第 ${current} 页...`);
+        const list = await getWfList(cfg, { category, page: current, pageSize: '100' });
         dataKey = list.dataKey || dataKey;
         const rows = extractRows(list.raw?.datas);
         for (const row of rows) {
@@ -64,7 +73,7 @@ async function loadRowsFor(cfg, requestIds) {
     }
     const missing = requestIds.map(String).filter((id) => !found.has(id));
     if (missing.length)
-        throw new Error(`批量操作需要在待办列表中定位这 ${missing.length} 条，未找到：${missing.join(', ')}。请确认 request-id 属于当前待办（待处理），或该待办已不在列表中。`);
+        throw new Error(`批量操作需要在「${label}」列表中定位这 ${missing.length} 条，未找到：${missing.join(', ')}。请确认 request-id 属于该列表（可用 --category 切换 待办/已办/我发起），或该流程已不在列表中。`);
     // 保持调用方传入顺序，便于回执与 multiSubIds 对应
     const rows = requestIds.map((id) => found.get(String(id)));
     return { dataKey, rows };
@@ -150,12 +159,14 @@ export async function batchAttention(cfg, opts) {
     const attentionId = String(opts.attentionId ?? types[0]?.id ?? '');
     if (!attentionId)
         throw new Error('未能获取关注类型（getAttentionTypeSet 返回空），请确认该环境的“关注类型”已配置，或手动传 --attention-id。');
-    const { dataKey, rows } = await loadRowsFor(cfg, requestIds);
+    // 关注在 待办/已办/我发起 三个分类下都有「我的关注」页签，故定位列表可指定（默认待办）
+    const category = opts.category ?? 'todo';
+    const { dataKey, rows } = await loadRowsFor(cfg, requestIds, { category });
     const gate = await runGate(api, 'batchAttention', rows, dataKey);
     const result = await api.post('/api/workflow/requestAttention/saveAttention', {
         src: 'batchadd',
         requestids: requestIds.join(','),
         ids: attentionId + ',',
     });
-    return { requestIds, attentionTypes: types, attentionId, gate, result };
+    return { requestIds, category, attentionTypes: types, attentionId, gate, result };
 }

package/dist/todosubmit.js

@@ -1,6 +1,45 @@
 import { createApiFromProfile } from './client.js';
 import { getWfList } from './workflow.js';
 import { todayStr, nowTimeStr } from './util.js';
+import { findNonEditableFields } from './wfstart.js';
+
+/** viewattr 中文标签（报错文案用）。 */
+const VIEWATTR_LABEL_LOCAL = { 1: '可编辑', 2: '只读', 3: '隐藏' };
+
+/**
+ * 只做「当前节点字段属性」校验，不提交——供 CLI dry-run 提前拦截，避免"预览通过、提交才报错"。
+ * 返回被违规填值的只读/隐藏字段清单（空数组 = 通过）。
+ */
+export async function validateFieldValuesAtNode(cfg, requestId, fieldValues) {
+    if (!fieldValues || !Object.keys(fieldValues).length)
+        return [];
+    const api = await createApiFromProfile(cfg);
+    const r = await api.post('/api/workflow/reqform/loadForm', { iscreate: '0', requestid: requestId });
+    return findNonEditableFields({ tables: nodeFieldTables(r.json ?? {}) }, fieldValues);
+}
+
+/**
+ * 从 loadForm 响应的 tableInfo 抽出字段定义，供 findNonEditableFields 判定。
+ * ⚠️ 这里用的是 **iscreate=0（处理态）** 的属性——即**当前节点**的字段权限，
+ *   而非 create 路径的表单设计态（iscreate=1）。
+ */
+function nodeFieldTables(json) {
+    const tables = [];
+    for (const key of Object.keys(json?.tableInfo ?? {})) {
+        const fmap = json.tableInfo[key]?.fieldinfomap;
+        if (!fmap || typeof fmap !== 'object')
+            continue;
+        tables.push({
+            key,
+            fields: Object.values(fmap).map((f) => ({
+                id: String(f?.fieldid ?? ''),
+                label: String(f?.fieldlabel ?? ''),
+                viewattr: (f?.viewattr === undefined || f?.viewattr === null || f?.viewattr === '') ? null : Number(f.viewattr),
+            })),
+        });
+    }
+    return tables;
+}
 /**
  * 提交待办到下一节点。POST requestOperation（iscreate=0）。
  * 两步 loadForm 拿签名（先取 wf+node，再带 wf+node 取 per-request 签名）。
@@ -20,6 +59,14 @@ export async function submitTodo(cfg, opts) {
     const sp0 = j0.submitParams ?? {};
     const wfId = String(p0.workflowid ?? '');
     const nodeId = String(p0.nodeid ?? '');
+    // ★字段属性硬规则（当前节点）：--field-values 只允许改该节点「可编辑」(viewattr=1) 的字段。
+    //   依据本次 iscreate=0 的 loadForm（**处理态=当前节点字段权限**），与 create 路径的设计态判定不同。
+    //   只读(2)/隐藏(3) 一律拒绝——不得绕过节点字段权限自行填值。
+    if (opts.fieldValues && Object.keys(opts.fieldValues).length) {
+        const bad = findNonEditableFields({ tables: nodeFieldTables(j0) }, opts.fieldValues);
+        if (bad.length)
+            throw new Error(`拒绝填写当前节点的只读/隐藏字段：${bad.map((b) => `${b.label || b.id}(${VIEWATTR_LABEL_LOCAL[b.viewattr] ?? 'va=' + b.viewattr})`).join('、')}。本节点只允许修改「可编辑」字段，不得绕过节点字段权限自行填值。`);
+    }
     // 第二步 loadForm（带 wf+node）→ 拿 per-request 签名
     let p = p0;
     let sp = sp0;