weaver-work-cli 0.1.38 → 0.1.40

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

@@ -0,0 +1,161 @@
+import { E10_SESSION_EXPIRED_MESSAGE } from '../../internal/e10/auth/messages.js';
+import { requireE10Session } from '../../internal/e10/context.js';
+import { getActiveProfile } from '../../internal/e10/auth/session.js';
+import { E10ApiError, createE10RequestRuntime } from '../../internal/e10/request-runtime.js';
+import { isE10SessionExpiredResponse } from '../../internal/e10/auth-recovery.js';
+import { assetIdleApiError, assetIdleAuthError, assetIdleNetworkError, assetIdleValidationError, } from './errors.js';
+/** 源接口（find-idle-assents）：POST {baseurl}/api/esb/server/event/triggerActionFlow。 */
+export const ASSET_IDLE_TRIGGER_PATH = '/api/esb/server/event/triggerActionFlow';
+/** 源资料固定参数：moduleSource=ebuilder（不暴露给调用方）。 */
+export const ASSET_IDLE_MODULE_SOURCE = 'ebuilder';
+/** 每页条数由服务端固定为 1000（源资料 2026-10-27 实测）。 */
+export const ASSET_IDLE_PAGE_SIZE = 1000;
+function assertPath(requestPath) {
+    if (typeof requestPath !== 'string' || !requestPath.startsWith('/') || requestPath.startsWith('//')) {
+        throw assetIdleValidationError('path_invalid', '请求路径必须是相对绝对路径');
+    }
+    if (/^https?:/i.test(requestPath) || /[\r\n]/.test(requestPath) || requestPath.includes('/../')) {
+        throw assetIdleValidationError('path_invalid', '请求路径不允许跨域或路径逃逸');
+    }
+    if (!requestPath.startsWith('/api/')) {
+        throw assetIdleValidationError('path_not_allowed', '闲置资产查询只能调用 /api/ 路径');
+    }
+}
+function mapRuntimeNetworkError(error) {
+    if (error instanceof E10ApiError && error.type === 'network') {
+        throw assetIdleNetworkError(error.subtype, error.message, {
+            retryable: error.retryable,
+            details: error.details,
+        });
+    }
+    throw error;
+}
+/**
+ * 源资料实测：会话失效时接口返回 {"error":"authentication required","code":-2}（HTTP 200）。
+ * 该形态由共享 runtime 的 isE10SessionExpiredResponse 兜底之外再显式识别一次。
+ */
+export function isIdleAuthRejected(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const record = value;
+    if (record.error === 'authentication required')
+        return true;
+    return String(record.code ?? '') === '-2' && typeof record.error === 'string';
+}
+/** mainTable 在 actionData.responseData.customData 下；缺失视为协议异常而不是空结果。 */
+export function pickMainTable(value) {
+    const root = value;
+    const mainTable = root?.actionData?.responseData?.customData?.mainTable;
+    if (!mainTable || typeof mainTable !== 'object' || Array.isArray(mainTable))
+        return undefined;
+    const idleAssets = Array.isArray(mainTable.idleAssets) ? mainTable.idleAssets : undefined;
+    if (idleAssets === undefined)
+        return undefined;
+    return { idleAssets, hasMore: mainTable.hasMore === true };
+}
+export function resultCodeOf(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const raw = value.resultCode;
+    if (raw === undefined || raw === null || raw === '')
+        return undefined;
+    const numeric = Number(raw);
+    return Number.isFinite(numeric) ? numeric : undefined;
+}
+export function createAssetIdleHost(ctx, dependencies = {}) {
+    let e10Session = null;
+    let sessionContext = null;
+    const requireSession = dependencies.requireSession || requireE10Session;
+    async function ensureSession() {
+        if (!e10Session) {
+            e10Session = await requireSession(ctx);
+            sessionContext = {
+                baseUrl: e10Session.getBaseUrl(),
+                profile: ctx.getGlobalOptions().profile || getActiveProfile(),
+                userId: e10Session.userId,
+                tenantKey: e10Session.tenantKey,
+            };
+        }
+        return e10Session;
+    }
+    async function getSession() {
+        await ensureSession();
+        return sessionContext;
+    }
+    async function runtime() {
+        return createE10RequestRuntime(ctx, await ensureSession(), { fetch: dependencies.fetch });
+    }
+    return {
+        async fetchPage(esbFlowId, curPage) {
+            const page = Number(curPage);
+            if (!Number.isInteger(page) || page < 1) {
+                throw assetIdleValidationError('cur_page_invalid', `curPage 必须是 >= 1 的整数，收到：${String(curPage)}`);
+            }
+            assertPath(ASSET_IDLE_TRIGGER_PATH);
+            // 请求体形状来自源接口（find-idle-assents）：esbFlowId + moduleSource + customParams.mainTable.curPage。
+            const body = {
+                esbFlowId,
+                moduleSource: ASSET_IDLE_MODULE_SOURCE,
+                customParams: { mainTable: { curPage: page } },
+            };
+            let response;
+            try {
+                response = await (await runtime()).requestJson({
+                    module: 'asset-idle',
+                    operation: 'asset-idle.idle.list',
+                    method: 'POST',
+                    path: ASSET_IDLE_TRIGGER_PATH,
+                    body,
+                    bigIntStrings: true,
+                    headers: { 'X-Requested-With': 'XMLHttpRequest' },
+                    timeoutMs: 60_000,
+                });
+            }
+            catch (error) {
+                mapRuntimeNetworkError(error);
+            }
+            if (isE10SessionExpiredResponse(response)) {
+                throw assetIdleAuthError('session_expired', E10_SESSION_EXPIRED_MESSAGE, { httpStatus: response.status });
+            }
+            if (response.parseError) {
+                if (response.status < 200 || response.status >= 300) {
+                    throw assetIdleApiError('http_error', `泛微接口 HTTP ${response.status}`, {
+                        code: response.status,
+                        details: { status: response.status },
+                    });
+                }
+                throw assetIdleNetworkError('protocol', `接口返回不是合法 JSON（HTTP ${response.status}）`, { retryable: false });
+            }
+            if (response.status < 200 || response.status >= 300) {
+                throw assetIdleApiError('http_error', `泛微接口 HTTP ${response.status}`, {
+                    code: response.status,
+                    details: { status: response.status },
+                });
+            }
+            const value = response.value;
+            if (isIdleAuthRejected(value)) {
+                throw assetIdleAuthError('session_expired', E10_SESSION_EXPIRED_MESSAGE, { details: { code: -2 } });
+            }
+            const code = resultCodeOf(value);
+            if (code === undefined) {
+                throw assetIdleNetworkError('protocol', '动作流接口未返回 resultCode，无法判定执行结果', { retryable: false });
+            }
+            if (code !== 200) {
+                const record = (value && typeof value === 'object' ? value : {});
+                const serverMessage = typeof record.resultMsg === 'string' ? record.resultMsg.trim() : '';
+                throw assetIdleApiError('actionflow_failed', `动作流执行未成功（resultCode=${code}）：${serverMessage || '服务端未返回原因'}`, {
+                    code,
+                    details: { resultCode: code, resultMsg: serverMessage },
+                });
+            }
+            const mainTable = pickMainTable(value);
+            if (!mainTable) {
+                throw assetIdleNetworkError('protocol', '返回缺少 actionData.responseData.customData.mainTable.idleAssets，无法解析判定结果', {
+                    retryable: false,
+                });
+            }
+            return { items: mainTable.idleAssets, hasMore: mainTable.hasMore, resultCode: code };
+        },
+        getSession,
+    };
+}

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

@@ -0,0 +1,114 @@
+import { readFile } from 'node:fs/promises';
+import { ExitCode, isCliError, toErrorEnvelope } from '../../core/errors.js';
+import { createAssetIdleHost } from './host.js';
+import { assetIdleManifest } from './manifest.js';
+import { executeAssetIdleOperation } from './operations.js';
+import { assetIdleValidationError } from './errors.js';
+function asOptions(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}
+/**
+ * Windows PowerShell 的管道与 Set-Content -Encoding utf8 会在内容前写入 UTF-8 BOM，
+ * 且可能重复写入多次；JSON.parse 不接受前导 BOM，必须先剥离。
+ */
+function stripBom(value) {
+    return value.replace(/^\uFEFF+/, '');
+}
+export async function inputFrom(options, extra = {}) {
+    const opts = asOptions(options);
+    let input = {};
+    if (opts.input && opts.inputJson) {
+        throw assetIdleValidationError('input_conflict', '不能同时传 --input 和 --input-json');
+    }
+    if (opts.inputJson) {
+        input = parseJsonInput(String(opts.inputJson), '--input-json');
+    }
+    if (opts.input) {
+        let raw;
+        try {
+            raw = stripBom(opts.input === '-' ? await readStdin() : await readFile(String(opts.input), 'utf8'));
+        }
+        catch {
+            throw assetIdleValidationError('input_unreadable', `无法读取 --input：${String(opts.input)}`);
+        }
+        input = parseJsonInput(raw, '--input');
+    }
+    return {
+        ...input,
+        ...Object.fromEntries(Object.entries(extra).filter(([, value]) => value !== undefined && value !== '')),
+    };
+}
+function parseJsonInput(raw, label) {
+    try {
+        const parsed = JSON.parse(stripBom(raw));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            throw new Error('input must be an object');
+        }
+        return parsed;
+    }
+    catch {
+        throw assetIdleValidationError('input_invalid', `${label} 不是合法 JSON 对象`);
+    }
+}
+export function successEnvelope(operation, result) {
+    return {
+        schemaVersion: 1,
+        ok: true,
+        operation,
+        data: result.data === undefined ? null : result.data,
+        ...(result.meta ? { meta: result.meta } : {}),
+        warnings: result.warnings ?? [],
+    };
+}
+function failureEnvelope(error) {
+    return {
+        schemaVersion: 1,
+        ok: false,
+        error: toErrorEnvelope(error),
+    };
+}
+async function executeAndPrint(ctx, operation, input) {
+    try {
+        const result = await executeAssetIdleOperation(operation, input, {
+            ctx,
+            host: createAssetIdleHost(ctx),
+        });
+        ctx.output.write(successEnvelope(operation, result), { json: true });
+    }
+    catch (error) {
+        console.error(JSON.stringify(failureEnvelope(error), null, 2));
+        process.exitCode = isCliError(error) ? error.exitCode : ExitCode.GeneralError;
+    }
+}
+export const assetIdleShortcut = {
+    name: 'asset-idle',
+    description: 'E10 闲置资产判定结果查询 CLI（分页获取/聚合统计）',
+    category: 'shortcut',
+    register({ program, action }) {
+        const assetIdle = program
+            .command('asset-idle')
+            .description('E10 闲置资产判定结果查询（服务端已判定，只读）');
+        assetIdle
+            .command('schema')
+            .description('Print asset-idle operation manifest for agents')
+            .action(action((ctx) => {
+            ctx.output.write(assetIdleManifest, { json: true });
+        }));
+        assetIdle
+            .command('run')
+            .description('Run an asset-idle operation with JSON input')
+            .argument('<operation>', 'operation name, e.g. asset-idle.idle.list')
+            .option('--input <path>', 'JSON input file, or - for stdin')
+            .option('--input-json <json>', 'inline JSON input object')
+            .action(action(async (ctx, operation, options) => {
+            await executeAndPrint(ctx, String(operation), await inputFrom(options));
+        }));
+    },
+};

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

@@ -0,0 +1,159 @@
+/** 动作流 ID 在源资料示例中为长整型数字串，一律按字符串传递，避免精度丢失。 */
+const flowId = { type: 'string', pattern: '^\\d+$', minLength: 1, maxLength: 32 };
+const listInputProperties = {
+    esbFlowId: {
+        ...flowId,
+        description: '「自用-skill获取闲置资产」动作流 ID。按名称解析需要 ESB 应用列表查询接口，本模块未实现（见 withheldOperations）；可由用户在 ESB 中心查得后传入',
+    },
+    maxPages: {
+        type: 'integer',
+        minimum: 1,
+        maximum: 100,
+        default: 20,
+        description: '单次最多翻页数（每页 1000 条，服务端固定）；超过即停止并在 warnings 标记 truncated',
+    },
+};
+/** 服务端已判定的闲置资产条目字段（2026-10-30 起动作流返回判定结果集，字段为拼音缩写）。 */
+const idleItemSchema = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        zclx: { type: ['string', 'null'], description: '资产类型，如 笔记本电脑 / 显示器 / 乘用车' },
+        xzsz: { type: ['string', 'null'], description: '闲置时长（天），字符串数字，服务端已算好，直接使用；缺失标「无法判断」' },
+        pdyj: { type: ['string', 'null'], description: '判定依据，原样展示，不重新表述' },
+        zxd: { type: ['number', 'null'], description: '置信度，服务端给出（实测 0.8 / 0.85 / 0.9 / 0.95）' },
+        czjy: { type: ['string', 'null'], description: '处置建议编码：0=待调拨、1=待调剂、2=待评估；缺失标「无法判断」' },
+        xzdj: { type: ['string', 'null'], description: '闲置等级编码（0/1/2），含义待确认，原样透出' },
+        zcmc: { type: ['string', 'null'], description: '资产标识，当前返回资产记录 ID（不是名称）' },
+        unique_key: { type: ['string', 'null'], description: '记录主键' },
+        id: { type: ['string', 'null'], description: '记录主键' },
+    },
+};
+const listOutputProperties = {
+    esbFlowId: { type: 'string', description: '本次查询使用的动作流 ID' },
+    items: { type: 'array', items: idleItemSchema, description: '各页 idleAssets 合并后的判定结果集，返回条数即服务端判定的闲置资产全集' },
+    total: { type: 'integer', minimum: 0, description: '合并后的总条数（统计分母）' },
+    pages: { type: 'integer', minimum: 0, description: '实际请求页数' },
+    hasMore: { type: 'boolean', description: '停止时服务端是否仍标记有下一页' },
+    truncated: { type: 'boolean', description: '是否因达到 maxPages 上限提前停止' },
+};
+const agingBucketSchema = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        bucket: { type: 'string', enum: ['1个月以内', '1～3个月', '3～6个月', '6～12个月', '一年以上'], description: '闲置时长档位（1 个月按 30 天计，边界值归前一档）' },
+        minDays: { type: 'integer', description: '档位下界（天，含）' },
+        maxDays: { type: ['integer', 'null'], description: '档位上界（天，含）；一年以上为 null' },
+        count: { type: 'integer', minimum: 0, description: '档位内条数；数量为 0 的档位不出现' },
+    },
+};
+const statsOutputProperties = {
+    esbFlowId: { type: 'string', description: '本次查询使用的动作流 ID' },
+    total: { type: 'integer', minimum: 0, description: '服务端判定结果集总条数（统计分母）' },
+    pages: { type: 'integer', minimum: 0, description: '实际请求页数' },
+    truncated: { type: 'boolean', description: '是否因达到 maxPages 上限提前停止（此时统计不完整）' },
+    czjyCounts: {
+        type: 'array',
+        description: '处置建议分组计数（编码映射固定：0=待调拨、1=待调剂、2=待评估；缺失标「无法判断」）',
+        items: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                code: { type: ['string', 'null'], description: 'czjy 编码；缺失为 null' },
+                label: { type: 'string', enum: ['待调拨', '待调剂', '待评估', '无法判断'] },
+                count: { type: 'integer', minimum: 0 },
+            },
+        },
+    },
+    typeCounts: {
+        type: 'array',
+        description: '按 zclx 计数，降序；Top10 + 其他 的合并展示由渲染侧处理',
+        items: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string', description: 'zclx 资产类型；缺失按「未知类型」计入' },
+                count: { type: 'integer', minimum: 0 },
+            },
+        },
+    },
+    agingBuckets: {
+        type: 'array',
+        items: agingBucketSchema,
+        description: '闲置时长分档计数，固定顺序，仅含数量大于 0 的档位；xzsz 缺失的记录排除出所有档位',
+    },
+    unableToJudge: {
+        type: 'integer',
+        minimum: 0,
+        description: 'xzsz 缺失（无法判断）条数：不参与类型统计与时长分档，也不计入 agingBuckets',
+    },
+    unableToJudgeByType: {
+        type: 'integer',
+        minimum: 0,
+        description: 'zclx 也缺失且 xzsz 缺失的条数（既不进类型统计也不进时长分档的口径提示）',
+    },
+};
+export const assetIdleOperations = [
+    {
+        name: 'asset-idle.idle.list',
+        summary: '触发「自用-skill获取闲置资产」动作流，按 hasMore 自动翻页并合并各页闲置资产判定结果（只读查询）',
+        risk: 'read',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: listInputProperties,
+            required: ['esbFlowId'],
+        },
+        outputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: listOutputProperties,
+        },
+    },
+    {
+        name: 'asset-idle.idle.stats',
+        summary: '在 idle.list 合并结果上做聚合统计：czjy 处置建议分组、zclx 类型计数、xzsz 闲置时长分档（不做判定、不重算）',
+        risk: 'read',
+        inputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: listInputProperties,
+            required: ['esbFlowId'],
+        },
+        outputSchema: {
+            type: 'object',
+            additionalProperties: false,
+            properties: statsOutputProperties,
+        },
+    },
+];
+export const assetIdleManifest = {
+    schemaVersion: 1,
+    name: 'asset-idle',
+    title: 'E10 闲置资产判定结果查询',
+    version: '0.1.0',
+    host: 'e10-asset-idle',
+    status: 'builtin',
+    sourceSkill: 'weaver-e10-ziguanjia-idle',
+    operations: assetIdleOperations,
+    withheldOperations: [
+        {
+            name: 'asset-idle.flow.resolve',
+            reason: '按名称解析「自用-skill获取闲置资产」动作流 ID 需要 ESB 应用列表查询接口；源资料只提供旧版 e10-cli 的 actionflow application-list 命令名，没有 weaver-work-cli 可用的接口路径、请求字段与返回结构，无法安全实现。esbFlowId 必须由调用方传入（可在旧版 e10-cli 执行 actionflow application-list 按 name 精确匹配 moudle=ebuilder 取 id，匹配不到或多条同名时停止）。',
+        },
+    ],
+    /** 源资料明确：接口不返回 idle_date / stockindate / use_term 等原始台账字段，不做基于日期的判定与阈值反推。 */
+    disabledCapabilities: [
+        {
+            name: 'idle-date-recalculation',
+            reason: '闲置判定由服务端动作流完成（xzsz / pdyj / zxd / czjy 直接使用），CLI 不做二次判定、不重算、不补算、不改写结论；接口不返回 idle_date / stockindate / use_term，不得反查或推算日期补齐。',
+        },
+        {
+            name: 'display-only-fields',
+            reason: 'czjy_obj / xzdj_obj / yjzczt_obj / czlc / czlc_obj / zcxzczrq 实测恒为空，不可依赖，条目归一化时不透出；字段语义变化时以 source-manifest 的更新检测为准。',
+        },
+    ],
+};
+export function hasAssetIdleOperation(operation) {
+    return assetIdleOperations.some((item) => item.name === operation);
+}

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

@@ -0,0 +1,47 @@
+import { assetIdleSuccess } from './types.js';
+import { aggregateIdleAssets, maxPagesOf, normalizeIdleAsset, requiredFlowId, } from './shared.js';
+/**
+ * 分页合并循环：源资料口径——curPage 从 1 开始；resultCode=200 且 hasMore=true 则 curPage+1 继续；
+ * hasMore=false 表示分页查询完成；每页数据在 idleAssets 数组里，各页合并成总列表。
+ */
+export async function fetchAllIdleAssets(esbFlowId, maxPages, env) {
+    const items = [];
+    let curPage = 1;
+    let hasMore = true;
+    let truncated = false;
+    while (hasMore) {
+        const page = await env.host.fetchPage(esbFlowId, curPage);
+        for (const raw of page.items) {
+            items.push(normalizeIdleAsset(raw));
+        }
+        hasMore = page.hasMore;
+        if (hasMore && curPage >= maxPages) {
+            truncated = true;
+            break;
+        }
+        curPage += 1;
+    }
+    return { items, pages: truncated ? maxPages : curPage - 1, hasMore, truncated };
+}
+function listWarnings(truncated) {
+    const warnings = [];
+    if (truncated) {
+        warnings.push(`已达单次翻页上限，hasMore 仍为 true：返回结果可能不是闲置资产全集，统计前请增大 maxPages 后重查`);
+    }
+    return warnings;
+}
+export const assetIdleHandlers = {
+    'asset-idle.idle.list': async (input, env) => {
+        const esbFlowId = requiredFlowId(input.esbFlowId);
+        const maxPages = maxPagesOf(input.maxPages);
+        const { items, pages, hasMore, truncated } = await fetchAllIdleAssets(esbFlowId, maxPages, env);
+        return assetIdleSuccess('asset-idle.idle.list', { esbFlowId, items, total: items.length, pages, hasMore, truncated }, { status: 'COMPLETE' }, listWarnings(truncated));
+    },
+    'asset-idle.idle.stats': async (input, env) => {
+        const esbFlowId = requiredFlowId(input.esbFlowId);
+        const maxPages = maxPagesOf(input.maxPages);
+        const { items, pages, truncated } = await fetchAllIdleAssets(esbFlowId, maxPages, env);
+        const stats = aggregateIdleAssets(items);
+        return assetIdleSuccess('asset-idle.idle.stats', { esbFlowId, total: items.length, pages, truncated, ...stats }, { status: 'COMPLETE' }, listWarnings(truncated));
+    },
+};

package/dist/shortcuts/asset-idle/operations/registry.js

@@ -0,0 +1,33 @@
+import { assetIdleManifest } from '../manifest.js';
+import { assetIdleValidationError } from '../errors.js';
+import { assetIdleHandlers } from './idle.js';
+/**
+ * manifest 提供 WHAT（name/summary/risk/inputSchema/outputSchema），handler 提供 HOW。
+ * 两侧必须严格一一对应：任一侧多出条目都直接抛错，避免 schema 与实际能力漂移。
+ */
+function buildRegistry() {
+    const registry = new Map();
+    const handlerMap = assetIdleHandlers;
+    for (const contract of assetIdleManifest.operations) {
+        const handler = handlerMap[contract.name];
+        if (!handler)
+            throw new Error(`asset-idle operation ${contract.name} has no handler`);
+        registry.set(contract.name, { ...contract, handler });
+    }
+    for (const name of Object.keys(handlerMap)) {
+        if (!registry.has(name))
+            throw new Error(`asset-idle handler ${name} is not declared in manifest`);
+    }
+    return registry;
+}
+const assetIdleOperationRegistry = buildRegistry();
+export function getAssetIdleOperation(operation) {
+    const definition = assetIdleOperationRegistry.get(operation);
+    if (!definition) {
+        throw assetIdleValidationError('operation_unknown', `闲置资产查询不支持操作：${operation}`);
+    }
+    return definition;
+}
+export function assetIdleOperationDefinitions() {
+    return [...assetIdleOperationRegistry.values()];
+}

package/dist/shortcuts/asset-idle/operations/shared.js

@@ -0,0 +1,142 @@
+import { assetIdleValidationError } from '../errors.js';
+/**
+ * 闲置资产条目归一化与聚合统计（纯函数，供单测直接断言业务口径）。
+ * 口径全部来自源 skill weaver-e10-ziguanjia-idle：
+ * - 判定由服务端完成（xzsz/pdyj/zxd/czjy 直接使用），CLI 不重算、不补算；
+ * - czjy 编码固定：0=待调拨、1=待调剂、2=待评估；缺失标「无法判断」；
+ * - xzsz 缺失的条目标「无法判断」，排除出所有统计，不参与类型统计与时长分档；
+ * - 闲置时长分档（1 个月按 30 天计，边界值归前一档）：
+ *   1个月以内 ≤30、1～3个月 31–90、3～6个月 91–180、6～12个月 181–365、一年以上 >365。
+ */
+/** 源资料实测恒为空的展示字段：不可依赖，归一化时不透出。 */
+export const DISPLAY_ONLY_FIELDS = [
+    'czjy_obj',
+    'xzdj_obj',
+    'yjzczt_obj',
+    'czlc',
+    'czlc_obj',
+    'zcxzczrq',
+];
+function asText(value) {
+    if (value === undefined || value === null)
+        return null;
+    if (typeof value === 'object')
+        return null;
+    const text = String(value).trim();
+    return text === '' ? null : text;
+}
+export function normalizeIdleAsset(raw) {
+    const record = raw && typeof raw === 'object' && !Array.isArray(raw) ? raw : {};
+    const zxdText = asText(record.zxd);
+    const zxd = zxdText === null ? null : Number.isFinite(Number(zxdText)) ? Number(zxdText) : null;
+    return {
+        zclx: asText(record.zclx),
+        xzsz: asText(record.xzsz),
+        pdyj: asText(record.pdyj),
+        zxd,
+        czjy: asText(record.czjy),
+        xzdj: asText(record.xzdj),
+        zcmc: asText(record.zcmc),
+        unique_key: asText(record.unique_key),
+        id: asText(record.id),
+    };
+}
+export const CZJY_LABELS = {
+    '0': '待调拨',
+    '1': '待调剂',
+    '2': '待评估',
+};
+/** 档位定义：maxDays 为 null 表示一年以上（>365）。 */
+export const AGING_BUCKETS = [
+    { bucket: '1个月以内', minDays: 0, maxDays: 30 },
+    { bucket: '1～3个月', minDays: 31, maxDays: 90 },
+    { bucket: '3～6个月', minDays: 91, maxDays: 180 },
+    { bucket: '6～12个月', minDays: 181, maxDays: 365 },
+    { bucket: '一年以上', minDays: 366, maxDays: null },
+];
+/** 边界值归前一档（30 天算「1个月以内」、90 天算「1～3个月」）；负数或非整数天数为无法判断。 */
+export function agingBucketOf(days) {
+    if (!Number.isInteger(days) || days < 0)
+        return null;
+    for (const bucket of AGING_BUCKETS) {
+        if (bucket.maxDays === null || days <= bucket.maxDays)
+            return bucket.bucket;
+    }
+    return null;
+}
+export function aggregateIdleAssets(items) {
+    const czjyOrder = [
+        { code: '0', label: '待调拨' },
+        { code: '1', label: '待调剂' },
+        { code: '2', label: '待评估' },
+        { code: null, label: '无法判断' },
+    ];
+    const czjyCounts = czjyOrder.map(({ code, label }) => ({
+        code,
+        label,
+        count: items.filter((item) => item.czjy === code).length,
+    }));
+    // xzsz 缺失（无法判断）的条目：排除出类型统计与时长分档。
+    const judgedItems = items.filter((item) => item.xzsz !== null);
+    const unableToJudge = items.length - judgedItems.length;
+    const typeCounter = new Map();
+    let unableToJudgeByType = 0;
+    for (const item of judgedItems) {
+        const type = item.zclx ?? '未知类型';
+        if (item.zclx === null)
+            unableToJudgeByType += 1;
+        typeCounter.set(type, (typeCounter.get(type) ?? 0) + 1);
+    }
+    const typeCounts = [...typeCounter.entries()]
+        .map(([type, count]) => ({ type, count }))
+        .sort((a, b) => b.count - a.count || a.type.localeCompare(b.type, 'zh-Hans-CN'));
+    const agingCounts = new Map();
+    for (const item of judgedItems) {
+        const days = Number(item.xzsz);
+        const bucket = Number.isFinite(days) ? agingBucketOf(Math.trunc(days)) : null;
+        if (bucket === null)
+            continue;
+        agingCounts.set(bucket, (agingCounts.get(bucket) ?? 0) + 1);
+    }
+    const agingBuckets = AGING_BUCKETS.filter(({ bucket }) => (agingCounts.get(bucket) ?? 0) > 0).map(({ bucket, minDays, maxDays }) => ({ bucket, minDays, maxDays, count: agingCounts.get(bucket) ?? 0 }));
+    return { czjyCounts, typeCounts, agingBuckets, unableToJudge, unableToJudgeByType };
+}
+/** 顶层输入白名单（与 manifest inputSchema.properties 对齐，schema 即运行时约束）。 */
+export function assertNoForbiddenKeys(input) {
+    for (const key of ['cookie', 'eteamsid', 'token', 'access_token']) {
+        if (key in input) {
+            throw assetIdleValidationError('forbidden_key', `输入不允许携带凭据类字段：${key}`);
+        }
+    }
+}
+export function assertKnownKeys(input, allowed, operation) {
+    for (const key of Object.keys(input)) {
+        if (!allowed.includes(key)) {
+            throw assetIdleValidationError('input_unknown_key', `operation ${operation} 不支持输入字段：${key}（可用字段：${allowed.join(', ') || '无'}）`);
+        }
+    }
+}
+export function asObject(value) {
+    if (value === undefined || value === null)
+        return {};
+    if (typeof value !== 'object' || Array.isArray(value)) {
+        throw assetIdleValidationError('input_invalid', '输入必须是 JSON 对象');
+    }
+    return value;
+}
+export function requiredFlowId(value) {
+    const text = typeof value === 'string' ? value.trim() : String(value ?? '');
+    if (!/^\d{1,32}$/.test(text)) {
+        throw assetIdleValidationError('input_invalid', 'esbFlowId 必须是 1-32 位数字字符串');
+    }
+    return text;
+}
+export function maxPagesOf(value) {
+    if (value === undefined || value === null || value === '')
+        return 20;
+    const num = Number(value);
+    if (!Number.isInteger(num) || num < 1 || num > 100) {
+        throw assetIdleValidationError('input_invalid', 'maxPages 必须是 1-100 的整数');
+    }
+    return num;
+}

package/dist/shortcuts/asset-idle/operations/types.js

@@ -0,0 +1,9 @@
+export const READ = 'read';
+export function assetIdleSuccess(action, data, meta, warnings = []) {
+    const payload = { ok: true, action, data };
+    if (meta && Object.keys(meta).length > 0)
+        payload.meta = meta;
+    if (warnings.length > 0)
+        payload.warnings = warnings;
+    return payload;
+}