weaver-work-cli 0.1.38 → 0.1.40

package/dist/shortcuts/archive/operations/prelib.js

@@ -0,0 +1,472 @@
+import { randomBytes } from 'node:crypto';
+import { archiveValidationError } from '../errors.js';
+import { READ, WRITE, archiveSuccess, schemaOf, } from './types.js';
+import { positiveInt, toStringIdList, unwrapData } from './shared.js';
+import { issueLease, verifyLease } from './confirm.js';
+/**
+ * 预归档电子文件库列表链路。
+ *
+ * 链路（依据真实抓包）：
+ *   1. getTree（treeType=4, menuSign=preLib）→ 识别电子文件库节点 treeId 与节点名
+ *   2. getTreeDetail（treeId）→ url1（列表视图地址，尾段即 listId）+ extraParams（metaFormId / tag）
+ *   3. getListDatas（passid=cid=metaFormId）→ 列表列与数据行
+ *
+ * 智能识别：勾选列表行 → intelligentCate（treeId + checkIds + formId）→ 返回识别任务 taskId。
+ */
+const PRELIB_MENU_SIGN = 'preLib';
+const PRELIB_TREE_TYPE = '4';
+const PRELIB_NODE_TYPE = 2;
+const PRELIB_FORM_TAG = '["",""]';
+const INTELLIGENT_APPLY = 'archive.prelib.intelligent.apply';
+/** 提交整理：勾选列表行 -> prefileBatch/batchSave（treeId + checkIds + formId + autoBatchProduct）。 */
+const ARRANGE_APPLY = 'archive.prelib.arrange.apply';
+/** 永不展示的字段：内部标识，或后续操作要用的隐藏值（id 是智能识别/整理 checkIds 的来源）。 */
+const NON_DISPLAY_FIELDS = new Set([
+    'id',
+    'rowKey',
+    'flowId',
+    'form_data_id',
+    'form_table_id',
+    'ebrecord_rowkey',
+    'isFollow',
+    'is_flow',
+    'isToDo',
+    'todoPropSpan',
+    'data_status_value',
+]);
+/** 电子文件库节点判定：id 形如 {appId}_{appId}（下划线前后一致）。 */
+function isEfileLibNode(id) {
+    if (typeof id !== 'string' || !id.includes('_'))
+        return false;
+    const [left, right] = id.split('_');
+    return Boolean(left && left === right);
+}
+function optionalText(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const text = value.trim();
+    return text ? text : undefined;
+}
+/** 定位电子文件库节点：未传 treeId 时取预归档树第一个电子文件库节点。 */
+async function resolveEfileNode(host, treeId) {
+    const response = await host.request({
+        method: 'POST',
+        path: '/api/archive/core/archivetree/getTree',
+        body: {
+            treeType: PRELIB_TREE_TYPE,
+            menuSign: PRELIB_MENU_SIGN,
+            logFlag: PRELIB_MENU_SIGN,
+            needControl: true,
+            needSysn: true,
+        },
+    });
+    const data = unwrapData(response);
+    const nodes = Array.isArray(data) ? data : [];
+    const efileNodes = nodes
+        .filter((item) => isEfileLibNode(item?.id))
+        .map((item) => ({ treeId: String(item.id), nodeName: String(item.content ?? '') }));
+    if (treeId) {
+        const matched = efileNodes.find((item) => item.treeId === treeId);
+        // 传入的 treeId 即使不在树里也允许继续，由 getTreeDetail 决定是否报错
+        return matched ?? { treeId, nodeName: '' };
+    }
+    if (efileNodes.length === 0) {
+        throw archiveValidationError('prelib_node_missing', '未找到电子文件库节点（预归档树返回为空）。请先重新获取一次：重试本 operation，或用已知 treeId 显式传入；若仍然获取不到，通常是当前账号没有该预归档库权限，此时应停止后续操作（不要猜测 treeId，也不要继续上传）。');
+    }
+    return efileNodes[0];
+}
+/** getTreeDetail：取列表视图地址与表单标识。 */
+async function fetchTreeDetail(host, treeId) {
+    const response = await host.request({
+        method: 'POST',
+        path: '/api/archive/core/archivetree/getTreeDetail',
+        body: {
+            treeType: PRELIB_TREE_TYPE,
+            rootNode: '',
+            rootNodeTag: '',
+            needControl: true,
+            formTag: PRELIB_FORM_TAG,
+            preFileFilterId: '',
+            menuSign: PRELIB_MENU_SIGN,
+            treeId,
+            nodeType: PRELIB_NODE_TYPE,
+            logFlag: PRELIB_MENU_SIGN,
+        },
+    });
+    const data = (unwrapData(response) ?? {});
+    const url1 = String(data.url1 ?? '').trim();
+    const matched = url1.match(/(\d+)\s*$/u);
+    const listId = matched?.[1] ?? '';
+    const extra = (data.extraParams ?? {});
+    const metaFormId = String(extra.metaFormId ?? '').trim();
+    const tag = String(extra.tag ?? '').trim();
+    if (!listId || !metaFormId) {
+        throw archiveValidationError('prelib_detail_invalid', `getTreeDetail 未返回有效的列表视图（url1=${url1 || '空'}，metaFormId=${metaFormId || '空'}）`);
+    }
+    const boxUrl = String(data.boxUrl ?? '').trim();
+    return { listId, metaFormId, tag, url1, ...(boxUrl ? { boxUrl } : {}) };
+}
+/** getListDatas：按抓包还原的请求体查询电子文件库列表数据。 */
+async function fetchPrelibDatas(host, node, detail, pageNo) {
+    const current = positiveInt(pageNo, 'pageNo', 1);
+    const [appId] = node.treeId.split('_');
+    const paramsJson = JSON.stringify({
+        treeType: PRELIB_TREE_TYPE,
+        rootNode: '',
+        rootNodeTag: '',
+        needControl: true,
+        formTag: PRELIB_FORM_TAG,
+        preFileFilterId: '',
+        menuSign: PRELIB_MENU_SIGN,
+        id: node.treeId,
+        nodeType: PRELIB_NODE_TYPE,
+        isLeaf: true,
+        content: node.nodeName,
+    });
+    const response = await host.request({
+        method: 'POST',
+        path: '/api/ebuilder/form/list/getListDatas',
+        query: { passid: detail.metaFormId, cid: detail.metaFormId },
+        body: {
+            current,
+            requiredMatch: 1,
+            tableuid: randomBytes(16).toString('hex'),
+            mapResult: '1',
+            recheckQuery: '1',
+            metaFormId: detail.metaFormId,
+            tag: detail.tag,
+            treeId: node.treeId,
+            nodeType: PRELIB_NODE_TYPE,
+            systemId: appId,
+            metaId: appId,
+            hasBtn: '1',
+            paramsJson,
+            metaName: node.nodeName,
+            menuSign: PRELIB_MENU_SIGN,
+            searchParamData: { type: 'and', searchType: '2', commonSearchFields: {}, groupFields: {} },
+            listId: detail.listId,
+            isFollow: 0,
+            isShareToMe: 0,
+            filterCondition: {},
+            browser: 'Chrome',
+        },
+    });
+    const data = (unwrapData(response) ?? {});
+    // 列定义只保留展示需要的三个字段：接口原始列里带大段 Action 配置，
+    // 原样返回会被输出层按 arrayLimit 截断，导致 hide 判断缺列
+    const columns = (Array.isArray(data.columns) ? data.columns : []).map((item) => ({
+        title: String(item?.title ?? ''),
+        dataIndex: String(item?.dataIndex ?? ''),
+        hide: item?.hide === true,
+    }));
+    const rows = Array.isArray(data.data)
+        ? data.data
+        : Array.isArray(data.displayData)
+            ? data.displayData
+            : [];
+    const displayData = Array.isArray(data.displayData)
+        ? data.displayData
+        : [];
+    const visibleColumns = columns
+        .filter((item) => item?.hide !== true)
+        .map((item) => ({ title: String(item?.title ?? ''), dataIndex: String(item?.dataIndex ?? '') }));
+    // 接口 columns 通常只配置了一部分列（187 只返回 5 列），但数据里字段更多；
+    // 这里汇总数据中实际存在且可展示的字段，供展示时补齐，避免"显示不全"
+    const fieldNames = new Set();
+    for (const row of [...rows, ...displayData]) {
+        for (const key of Object.keys(row)) {
+            if (!key || NON_DISPLAY_FIELDS.has(key) || /(?:Action|Span)$/.test(key))
+                continue;
+            fieldNames.add(key);
+        }
+    }
+    const dataFields = [...fieldNames];
+    const pageSize = data.pageSize === undefined ? undefined : Number(data.pageSize);
+    const total = data.total === undefined ? undefined : Number(data.total);
+    return {
+        columns,
+        visibleColumns,
+        rows,
+        displayData,
+        dataFields,
+        pageNo: Number(data.current ?? current),
+        ...(pageSize === undefined ? {} : { pageSize }),
+        ...(total === undefined ? {} : { total }),
+    };
+}
+const prelibList = {
+    name: 'archive.prelib.list',
+    resource: 'prelib',
+    method: 'list',
+    action: 'archive.prelib.list',
+    summary: '查询预归档电子文件库列表：treeId → getTreeDetail 取列表视图（url1/metaFormId/tag）→ getListDatas 取列与数据行（只读）',
+    capability: 'prelib',
+    risk: READ,
+    inputSchema: schemaOf({
+        treeId: {
+            type: 'string',
+            description: '电子文件库节点 treeId（形如 {appId}_{appId}）；不传时取预归档树第一个电子文件库节点',
+        },
+        pageNo: { type: 'integer', minimum: 1, description: '页码，默认 1' },
+    }, { description: '查询电子文件库列表' }),
+    handler: async (args, { host }) => {
+        const node = await resolveEfileNode(host, optionalText(args.treeId));
+        const detail = await fetchTreeDetail(host, node.treeId);
+        const page = await fetchPrelibDatas(host, node, detail, args.pageNo);
+        // 每行对应的档案打开链接（与 archive.prelib.open 同一模板），供列表第一列渲染成超链接
+        const session = await host.getSession();
+        const root = String(session?.baseUrl ?? '').replace(/\/+$/, '');
+        const openUrls = page.rows.map((row) => {
+            const id = String(row?.id ?? '').trim();
+            const path = `${PRELIB_FILE_LIB_EDIT_PATH}?${new URLSearchParams({ singleMetaId: id, treeId: node.treeId }).toString()}`;
+            return id && root ? `${root}${path}` : '';
+        });
+        return archiveSuccess('archive.prelib.list', {
+            treeId: node.treeId,
+            nodeName: node.nodeName,
+            listId: detail.listId,
+            metaFormId: detail.metaFormId,
+            tag: detail.tag,
+            url1: detail.url1,
+            ...(detail.boxUrl ? { boxUrl: detail.boxUrl } : {}),
+            ...page,
+            openUrls,
+        }, { count: page.rows.length, nodeName: node.nodeName });
+    },
+};
+const intelligentPrepare = {
+    name: 'archive.prelib.intelligent.prepare',
+    resource: 'prelib',
+    method: 'intelligent',
+    action: 'archive.prelib.intelligent.prepare',
+    summary: '对电子文件库列表里勾选的数据发起智能识别（预检，不写数据）：解析 treeId/formId 并生成确认票据',
+    capability: 'prelib',
+    risk: READ,
+    inputSchema: schemaOf({
+        treeId: {
+            type: 'string',
+            description: '电子文件库节点 treeId；不传时取预归档树第一个电子文件库节点',
+        },
+        checkIds: {
+            type: 'array',
+            items: { type: 'string' },
+            description: '勾选的数据 ID 列表（取自 archive.prelib.list 返回行的 id）',
+        },
+        formId: {
+            type: 'string',
+            description: '表单 ID；不传时取 getTreeDetail 的 extraParams.metaFormId',
+        },
+    }, { required: ['checkIds'], description: '智能识别预检' }),
+    handler: async (args, env) => {
+        const checkIds = toStringIdList(args.checkIds, 'checkIds');
+        if (!checkIds || checkIds.length === 0) {
+            throw archiveValidationError('id_list_required', 'checkIds 必填且至少一项');
+        }
+        const node = await resolveEfileNode(env.host, optionalText(args.treeId));
+        const detail = await fetchTreeDetail(env.host, node.treeId);
+        const formId = optionalText(args.formId) ?? detail.metaFormId;
+        const { continuation, expiresInMs } = await issueLease(env, INTELLIGENT_APPLY, {
+            treeId: node.treeId,
+            formId,
+            checkIds,
+        });
+        return archiveSuccess('archive.prelib.intelligent.prepare', {
+            preview: { treeId: node.treeId, nodeName: node.nodeName, formId, count: checkIds.length, checkIds },
+            hint: `确认后调用 ${INTELLIGENT_APPLY}（CLI：archive run ${INTELLIGENT_APPLY} --input-json '{"continuation":"<token>","confirm":true}'）`,
+            continuation,
+        }, { requiresConfirmation: true, expiresInMs });
+    },
+};
+const intelligentApply = {
+    name: INTELLIGENT_APPLY,
+    resource: 'prelib',
+    method: 'intelligent',
+    action: INTELLIGENT_APPLY,
+    summary: '对电子文件库列表里勾选的数据发起智能识别（写操作）：调用 intelligentCate 提交识别任务，返回 taskId',
+    capability: 'prelib',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        continuation: { type: 'string', description: 'prepare 返回的确认票据' },
+        confirm: { type: 'boolean', description: '必须为 true（CLI --yes）' },
+    }, { required: ['continuation', 'confirm'], description: '提交智能识别任务' }),
+    handler: async (args, env) => {
+        const lease = await verifyLease(args, INTELLIGENT_APPLY, env);
+        const treeId = String(lease.treeId ?? '').trim();
+        const formId = String(lease.formId ?? '').trim();
+        const checkIds = Array.isArray(lease.checkIds) ? lease.checkIds.map(String) : [];
+        if (!treeId || !formId || checkIds.length === 0) {
+            throw archiveValidationError('continuation_payload_invalid', '确认票据缺少 treeId / formId / checkIds');
+        }
+        const response = await env.host.request({
+            method: 'POST',
+            path: '/api/archive/core/intelligent/intelligentCate',
+            body: {
+                treeId,
+                checkIds: checkIds.join(','),
+                formId,
+                logFlag: PRELIB_MENU_SIGN,
+            },
+        });
+        const data = (unwrapData(response) ?? {});
+        const taskId = String(data.taskId ?? '').trim();
+        return archiveSuccess(INTELLIGENT_APPLY, {
+            treeId,
+            formId,
+            checkIds,
+            ...(taskId ? { taskId } : {}),
+            hint: '智能识别为异步任务，返回 taskId 表示已提交；识别结果需在系统中查看',
+        }, { wrote: true, count: checkIds.length });
+    },
+};
+/** 提交整理预检：与智能识别同参，仅接口不同。 */
+const arrangePrepare = {
+    name: 'archive.prelib.arrange.prepare',
+    resource: 'prelib',
+    method: 'arrange',
+    action: 'archive.prelib.arrange.prepare',
+    summary: '对电子文件库列表里勾选的数据提交整理（预检，不写数据）：解析 treeId/formId 并生成确认票据',
+    capability: 'prelib',
+    risk: READ,
+    inputSchema: schemaOf({
+        treeId: {
+            type: 'string',
+            description: '电子文件库节点 treeId；不传时取预归档树第一个电子文件库节点',
+        },
+        checkIds: {
+            type: 'array',
+            items: { type: 'string' },
+            description: '勾选的数据 ID 列表（取自 archive.prelib.list 返回行的 id）',
+        },
+        formId: {
+            type: 'string',
+            description: '表单 ID；不传时取 getTreeDetail 的 extraParams.metaFormId',
+        },
+    }, { required: ['checkIds'], description: '提交整理预检' }),
+    handler: async (args, env) => {
+        const checkIds = toStringIdList(args.checkIds, 'checkIds');
+        if (!checkIds || checkIds.length === 0) {
+            throw archiveValidationError('id_list_required', 'checkIds 必填且至少一项');
+        }
+        const node = await resolveEfileNode(env.host, optionalText(args.treeId));
+        const detail = await fetchTreeDetail(env.host, node.treeId);
+        const formId = optionalText(args.formId) ?? detail.metaFormId;
+        const { continuation, expiresInMs } = await issueLease(env, ARRANGE_APPLY, {
+            treeId: node.treeId,
+            formId,
+            checkIds,
+        });
+        return archiveSuccess('archive.prelib.arrange.prepare', {
+            preview: { treeId: node.treeId, nodeName: node.nodeName, formId, count: checkIds.length, checkIds },
+            hint: `只有识别状态为「已识别」的数据才会被整理；未识别 / 识别中 / 识别异常的行提交后也会被服务端过滤掉（不报错但实际不处理），建议先做智能识别并确认识别成功。确认后调用 ${ARRANGE_APPLY}；服务端会返回实际处理条数，不要声称全部整理完成`,
+            continuation,
+        }, { requiresConfirmation: true, expiresInMs });
+    },
+};
+/** 提交整理写操作：调 prefileBatch/batchSave，响应只有 msg（无 data）。 */
+const arrangeApply = {
+    name: ARRANGE_APPLY,
+    resource: 'prelib',
+    method: 'arrange',
+    action: ARRANGE_APPLY,
+    summary: '对电子文件库列表里勾选的数据提交整理（写操作）：调用 prefileBatch/batchSave，返回服务端处理说明',
+    capability: 'prelib',
+    risk: WRITE,
+    requiresConfirmation: true,
+    inputSchema: schemaOf({
+        continuation: { type: 'string', description: 'prepare 返回的确认票据' },
+        confirm: { type: 'boolean', description: '必须为 true（CLI --yes）' },
+    }, { required: ['continuation', 'confirm'], description: '提交整理' }),
+    handler: async (args, env) => {
+        const lease = await verifyLease(args, ARRANGE_APPLY, env);
+        const treeId = String(lease.treeId ?? '').trim();
+        const formId = String(lease.formId ?? '').trim();
+        const checkIds = Array.isArray(lease.checkIds) ? lease.checkIds.map(String) : [];
+        if (!treeId || !formId || checkIds.length === 0) {
+            throw archiveValidationError('continuation_payload_invalid', '确认票据缺少 treeId / formId / checkIds');
+        }
+        const response = await env.host.request({
+            method: 'POST',
+            path: '/api/archive/core/prefileBatch/batchSave',
+            body: {
+                treeId,
+                autoBatchProduct: true,
+                formId,
+                checkIds: checkIds.join(','),
+                logFlag: PRELIB_MENU_SIGN,
+            },
+        });
+        // 该接口不返回 data，处理说明在顶层 msg（例如"选中1条数据包含1条异常数据，系统仅处理0条识别成功的数据！"）
+        const raw = response;
+        const message = String(raw?.msg ?? '').trim();
+        return archiveSuccess(ARRANGE_APPLY, {
+            treeId,
+            formId,
+            checkIds,
+            ...(message ? { message } : {}),
+            hint: '提交整理只处理识别状态为「已识别」的数据；未识别 / 识别中 / 识别异常的行会被服务端过滤。必须把服务端 message 如实转达，不要声称全部整理完成；若处理条数为 0，提示用户先做智能识别且识别成功后再整理',
+        }, { wrote: true, count: checkIds.length });
+    },
+};
+/**
+ * 打开档案链接：/sp/custom/archive/fileLibEdit?singleMetaId=行id&treeId=节点treeId
+ * treeId 本身就是 ${systemId}_${metadataId} 形式，无需另行拼装 metadataId。
+ */
+const PRELIB_FILE_LIB_EDIT_PATH = '/sp/custom/archive/fileLibEdit';
+const prelibOpen = {
+    name: 'archive.prelib.open',
+    resource: 'prelib',
+    method: 'open',
+    action: 'archive.prelib.open',
+    summary: '生成预归档电子文件库里指定数据的档案打开链接（只读）：按行 id（singleMetaId）与节点 treeId 拼出 fileLibEdit 链接',
+    capability: 'prelib',
+    risk: READ,
+    inputSchema: schemaOf({
+        checkIds: {
+            type: 'array',
+            items: { type: 'string' },
+            description: '数据 ID 列表（取自 archive.prelib.list 返回行的 id），即链接的 singleMetaId',
+        },
+        treeId: {
+            type: 'string',
+            description: '电子文件库节点 treeId；不传时自动取。treeId 本身即 ${systemId}_${metadataId}',
+        },
+    }, { required: ['checkIds'], description: '生成档案打开链接' }),
+    handler: async (args, env) => {
+        const checkIds = toStringIdList(args.checkIds, 'checkIds');
+        if (!checkIds || checkIds.length === 0) {
+            throw archiveValidationError('id_list_required', 'checkIds 必填且至少一项');
+        }
+        const node = await resolveEfileNode(env.host, optionalText(args.treeId));
+        const [systemId, metadataId = ''] = node.treeId.split('_');
+        // 与流程链接（flow-url）保持一致：返回拼好 baseUrl 的完整 URL，可直接点击打开
+        const session = await env.host.getSession();
+        const root = String(session?.baseUrl ?? '').replace(/\/+$/, '');
+        const links = checkIds.map((id) => {
+            const path = `${PRELIB_FILE_LIB_EDIT_PATH}?${new URLSearchParams({ singleMetaId: id, treeId: node.treeId }).toString()}`;
+            return {
+                singleMetaId: id,
+                treeId: node.treeId,
+                path,
+                url: root ? `${root}${path}` : path,
+            };
+        });
+        return archiveSuccess('archive.prelib.open', {
+            nodeName: node.nodeName,
+            systemId,
+            metadataId,
+            count: links.length,
+            links,
+            ...(links.length === 1 ? { url: links[0].url } : {}),
+            hint: 'CLI 不自动打开浏览器，请在浏览器中打开该 URL（需已登录该环境且有该档案查看权限）',
+        });
+    },
+};
+export const prelibOperations = [
+    prelibList,
+    intelligentPrepare,
+    intelligentApply,
+    arrangePrepare,
+    arrangeApply,
+    prelibOpen,
+];

package/dist/shortcuts/archive/operations/registry.js

@@ -1,5 +1,6 @@
 import { archiveValidationError } from '../errors.js';
 import { fondsOperations } from './fonds.js';
+import { prelibOperations } from './prelib.js';
 import { archiveInfoOperations } from './archive-info.js';
 import { searchOperations } from './search.js';
 import { borrowCarOperations } from './borrow-car.js';
@@ -11,6 +12,7 @@ function buildRegistry() {
     const registry = new Map();
     const definitions = [
         ...fondsOperations,
+        ...prelibOperations,
         ...archiveInfoOperations,
         ...searchOperations,
         ...borrowCarOperations,

package/dist/shortcuts/archive/operations/upload.js

@@ -28,7 +28,7 @@ async function resolveDefaultTreeId(host) {
     }
     const nodes = data.filter(isEfileLibNode);
     if (nodes.length === 0) {
-        throw archiveValidationError('tree_id_required', '未找到电子文件库节点，请显式传入 treeId');
+        throw archiveValidationError('tree_id_required', '未找到电子文件库节点（预归档树返回为空）。请先重新获取一次：重试本 operation，或用已知 treeId 显式传入；若仍然获取不到，通常是当前账号没有该预归档库权限，此时应停止上传（不要猜测 treeId）。');
     }
     if (nodes.length > 1) {
         throw archiveValidationError('tree_id_ambiguous', `存在多个电子文件库节点（${nodes.map((item) => item.id).join('、')}），请显式传入 treeId`);

package/dist/shortcuts/asset-idle/errors.js

@@ -0,0 +1,44 @@
+import { CliError, ExitCode } from '../../core/errors.js';
+export class AssetIdleCliError extends CliError {
+    type;
+    subtype;
+    code;
+    retryable;
+    details;
+    constructor(type, subtype, message, options = {}) {
+        super(message, options.exitCode ?? ExitCode.InternalError);
+        this.name = 'AssetIdleCliError';
+        this.type = type;
+        this.subtype = subtype;
+        this.code = options.code;
+        this.retryable = options.retryable ?? false;
+        this.details = options.details;
+    }
+}
+export function assetIdleValidationError(subtype, message, details) {
+    return new AssetIdleCliError('validation', subtype, message, {
+        details,
+        exitCode: ExitCode.UsageError,
+    });
+}
+export function assetIdleAuthError(subtype, message, details) {
+    return new AssetIdleCliError('authentication', subtype, message, {
+        details,
+        exitCode: ExitCode.AuthError,
+    });
+}
+export function assetIdleNetworkError(subtype, message, options = {}) {
+    return new AssetIdleCliError('network', subtype, message, {
+        ...options,
+        retryable: options.retryable ?? true,
+        exitCode: ExitCode.NetworkError,
+    });
+}
+/** 服务端返回的业务失败（HTTP 已成功、resultCode 非 200 或业务信封异常）。 */
+export function assetIdleApiError(subtype, message, options = {}) {
+    return new AssetIdleCliError('api', subtype, message, {
+        ...options,
+        retryable: options.retryable ?? false,
+        exitCode: ExitCode.GeneralError,
+    });
+}