1214 lines
39 KiB
JavaScript
1214 lines
39 KiB
JavaScript
#!/usr/bin/env node
|
||
|
||
const fs = require('node:fs');
|
||
const path = require('node:path');
|
||
const orderRegistry = require('./erp_order_registry');
|
||
const defaultTaskLock = require('./erp_task_lock');
|
||
const travelerLists = require('./erp_traveler_list');
|
||
const { validateTaskEnvelope } = require('./erp_task_contract');
|
||
|
||
const ROOT = path.resolve(__dirname, '..');
|
||
const DEFAULT_CONFIG = path.join(ROOT, 'config', 'erp-deployment.example.json');
|
||
const DEFAULT_AUDIT_DIR = path.join(ROOT, 'runtime', 'erp-order-entry', 'audit');
|
||
const KNOWN_ROUTES = new Set(['team_single', 'team_batch', 'split_parent', 'split_child']);
|
||
const KNOWN_OPERATIONS = new Set(['create_order', 'update_order', 'export_confirmation']);
|
||
const DEFAULT_NO_SAVE_BLOCK_WINDOW_MS = 60 * 60 * 1000;
|
||
const DEFAULT_UPDATE_DUPLICATE_WINDOW_MS = 2 * 60 * 60 * 1000;
|
||
|
||
function timestamp() {
|
||
return new Date().toISOString().replace(/[-:T.Z]/g, '').slice(0, 14);
|
||
}
|
||
|
||
function safeFilePart(value) {
|
||
return String(value || 'task')
|
||
.replace(/[^a-zA-Z0-9._-]+/g, '-')
|
||
.replace(/^-+|-+$/g, '')
|
||
.slice(0, 80) || 'task';
|
||
}
|
||
|
||
function resolvePath(filePath, cwd = process.cwd()) {
|
||
if (!filePath) return '';
|
||
return path.isAbsolute(filePath) ? filePath : path.join(cwd, filePath);
|
||
}
|
||
|
||
function readJson(filePath) {
|
||
const text = fs.readFileSync(filePath, 'utf8').replace(/^\uFEFF/, '');
|
||
return JSON.parse(text);
|
||
}
|
||
|
||
function readConfig(configPath) {
|
||
const resolved = configPath ? resolvePath(configPath) : DEFAULT_CONFIG;
|
||
if (!fs.existsSync(resolved)) return { safety: { allowRealSubmit: false } };
|
||
return readJson(resolved);
|
||
}
|
||
|
||
function liveSessionConfig(config = {}) {
|
||
return (config.browser && config.browser.liveSession) || {};
|
||
}
|
||
|
||
function liveSessionEnabled(config = {}) {
|
||
return Boolean(liveSessionConfig(config).enabled);
|
||
}
|
||
|
||
function liveSessionLockPath(config = {}, auditDir = DEFAULT_AUDIT_DIR) {
|
||
const paths = config.paths || {};
|
||
const workRoot = paths.workRoot ? resolvePath(paths.workRoot) : path.dirname(auditDir);
|
||
return path.join(workRoot, 'erp-live-session.lock');
|
||
}
|
||
|
||
async function runExecutionHandler(handler, task, handlerOptions, dispatcherOptions, auditDir) {
|
||
const config = handlerOptions.config || {};
|
||
if (!liveSessionEnabled(config)) return handler(task, handlerOptions);
|
||
const live = liveSessionConfig(config);
|
||
const taskLock = dispatcherOptions.taskLock || defaultTaskLock;
|
||
return taskLock.withFileLock(
|
||
liveSessionLockPath(config, auditDir),
|
||
() => handler(task, handlerOptions),
|
||
{
|
||
timeoutMs: Number(live.lockTimeoutMs || 10 * 60 * 1000),
|
||
pollMs: Number(live.lockPollMs || 1000),
|
||
}
|
||
);
|
||
}
|
||
|
||
function normalizeMode(mode) {
|
||
const normalized = String(mode || 'dry-run').trim().toLowerCase();
|
||
if (normalized === 'execute' || normalized === 'dry-run') return normalized;
|
||
throw new Error(`Unsupported dispatcher mode: ${mode}`);
|
||
}
|
||
|
||
function normalizeEnvelope(input) {
|
||
if (!input || typeof input !== 'object') {
|
||
return { status: 'invalid', task: null, reason: 'invalid_input' };
|
||
}
|
||
if (input.status) return input;
|
||
if (input.route) {
|
||
return {
|
||
status: 'ready',
|
||
operation: input.operation || 'create_order',
|
||
route: input.route,
|
||
task: input,
|
||
};
|
||
}
|
||
if (input.operation) {
|
||
return {
|
||
status: 'ready',
|
||
operation: input.operation,
|
||
route: input.route || '',
|
||
task: input.task || input,
|
||
};
|
||
}
|
||
return { status: 'invalid', task: null, reason: 'missing_task_operation' };
|
||
}
|
||
|
||
function auditFileName(result) {
|
||
const task = result.task || {};
|
||
const taskId = task.taskId || result.taskId || result.route || result.reason || result.status;
|
||
return `dispatch-${timestamp()}-${safeFilePart(taskId)}.json`;
|
||
}
|
||
|
||
function writeAudit(result, auditDir) {
|
||
const targetDir = auditDir || DEFAULT_AUDIT_DIR;
|
||
fs.mkdirSync(targetDir, { recursive: true });
|
||
const auditPath = path.join(targetDir, auditFileName(result));
|
||
const payload = { ...result, auditPath };
|
||
fs.writeFileSync(auditPath, JSON.stringify(cloneForAudit(payload), null, 2), 'utf8');
|
||
return payload;
|
||
}
|
||
|
||
const TRAVELER_PII_FIELDS = new Set([
|
||
'name',
|
||
'chineseName',
|
||
'englishName',
|
||
'idNo',
|
||
'birthDate',
|
||
'passportNo',
|
||
'phone',
|
||
'remark',
|
||
'raw',
|
||
]);
|
||
|
||
function redactValue(value) {
|
||
return value ? '[redacted]' : '';
|
||
}
|
||
|
||
function sanitizeTravelerRows(rows = []) {
|
||
if (!Array.isArray(rows)) return rows;
|
||
return rows.map((row) => {
|
||
if (!row || typeof row !== 'object') return row;
|
||
const safe = { ...row };
|
||
for (const field of TRAVELER_PII_FIELDS) {
|
||
if (Object.prototype.hasOwnProperty.call(safe, field)) safe[field] = redactValue(safe[field]);
|
||
}
|
||
return safe;
|
||
});
|
||
}
|
||
|
||
function redactTravelerRowInPlace(row) {
|
||
if (!row || typeof row !== 'object') return row;
|
||
for (const field of TRAVELER_PII_FIELDS) {
|
||
if (Object.prototype.hasOwnProperty.call(row, field)) row[field] = redactValue(row[field]);
|
||
}
|
||
return row;
|
||
}
|
||
|
||
function looksLikeTravelerList(value) {
|
||
return value && typeof value === 'object' && Array.isArray(value.rows)
|
||
&& value.rows.some((row) => row && typeof row === 'object' && (
|
||
Object.prototype.hasOwnProperty.call(row, 'passportNo')
|
||
|| Object.prototype.hasOwnProperty.call(row, 'chineseName')
|
||
|| Object.prototype.hasOwnProperty.call(row, 'englishName')
|
||
));
|
||
}
|
||
|
||
function sanitizeAuditNode(value, seen = new Set()) {
|
||
if (!value || typeof value !== 'object' || seen.has(value)) return value;
|
||
seen.add(value);
|
||
|
||
if (Array.isArray(value)) {
|
||
value.forEach((item) => sanitizeAuditNode(item, seen));
|
||
return value;
|
||
}
|
||
|
||
if (looksLikeTravelerList(value)) {
|
||
Object.assign(value, travelerLists.sanitizeTravelerListForAudit(value));
|
||
}
|
||
redactTravelerRowInPlace(value);
|
||
if (value.travelerList && typeof value.travelerList === 'object') {
|
||
value.travelerList = travelerLists.sanitizeTravelerListForAudit(value.travelerList);
|
||
}
|
||
if (Array.isArray(value.travelers)) {
|
||
value.travelers = sanitizeTravelerRows(value.travelers);
|
||
}
|
||
for (const item of Object.values(value)) sanitizeAuditNode(item, seen);
|
||
return value;
|
||
}
|
||
|
||
function cloneForAudit(value) {
|
||
const clone = JSON.parse(JSON.stringify(value || {}));
|
||
return sanitizeAuditNode(clone);
|
||
}
|
||
|
||
function blocked(reason, customerMessage, extra = {}) {
|
||
return {
|
||
status: 'blocked',
|
||
reason,
|
||
customerMessage,
|
||
...extra,
|
||
};
|
||
}
|
||
|
||
function dispatcherErrorCustomerMessage(operation, route) {
|
||
if (operation === 'update_order') {
|
||
return 'ERP 修改未完成，系统已记录原因，请稍后重试或由管理员继续处理。';
|
||
}
|
||
if (operation === 'export_confirmation') {
|
||
return 'ERP 确认件导出未完成，系统已记录原因，请稍后重试或由管理员继续处理。';
|
||
}
|
||
const label = routeLabel(route);
|
||
return `ERP 执行未完成（${label}），系统已记录原因，请稍后重试或由管理员继续处理。`;
|
||
}
|
||
|
||
function routeLabel(route) {
|
||
return {
|
||
team_single: 'team single order',
|
||
team_batch: 'team batch order',
|
||
split_parent: 'split parent plan',
|
||
split_child: 'split child order',
|
||
}[route] || route || 'unknown route';
|
||
}
|
||
|
||
function taskOperation(task, envelope = {}) {
|
||
return task && task.operation
|
||
? task.operation
|
||
: envelope.operation || 'create_order';
|
||
}
|
||
|
||
function operationHandlerKey(task, envelope = {}) {
|
||
const operation = taskOperation(task, envelope);
|
||
return operation === 'create_order' ? task.route : operation;
|
||
}
|
||
|
||
function operationLabel(operation, route) {
|
||
if (operation === 'create_order') return `ERP execution: ${routeLabel(route)}`;
|
||
return {
|
||
update_order: 'ERP order update',
|
||
export_confirmation: 'ERP confirmation export',
|
||
}[operation] || `ERP operation: ${operation}`;
|
||
}
|
||
|
||
function orderTextForbidsRealSubmit(task) {
|
||
const fields = (task && task.fields) || {};
|
||
const text = [
|
||
task && task.originalText,
|
||
fields.remark,
|
||
fields.notes,
|
||
fields.note,
|
||
].filter(Boolean).join('\n');
|
||
|
||
return /dry[-\s]?run|干跑|只解析|仅解析|不要真实(?:保存|提交|操作)|不(?:要)?真实(?:保存|提交|操作)|不要(?:保存|提交).*ERP|不要.*ERP.*(?:保存|提交|操作)|不要触碰\s*ERP/i.test(text);
|
||
}
|
||
|
||
function orderTextConfirmsRealSubmit(task) {
|
||
const fields = (task && task.fields) || {};
|
||
const text = [
|
||
task && task.originalText,
|
||
fields.remark,
|
||
fields.notes,
|
||
fields.note,
|
||
].filter(Boolean).join('\n');
|
||
|
||
return /confirm\s+real\s+(?:erp\s+)?(?:submit|save)|确认真实(?:保存|提交|操作)\s*ERP|确认(?:保存|提交|操作).*ERP/i.test(text);
|
||
}
|
||
|
||
function taskTextForSafety(task) {
|
||
const fields = (task && task.fields) || {};
|
||
return [
|
||
task && task.originalText,
|
||
fields.remark,
|
||
fields.notes,
|
||
fields.note,
|
||
].filter(Boolean).join('\n');
|
||
}
|
||
|
||
function normalizeWhitelistValue(value) {
|
||
return String(value || '').trim().replace(/\s+/g, ' ').toLowerCase();
|
||
}
|
||
|
||
function arrayFromConfig(value) {
|
||
if (!value) return [];
|
||
if (Array.isArray(value)) return value;
|
||
if (typeof value === 'string') {
|
||
return value.split(/[,\n;]/).map((item) => item.trim()).filter(Boolean);
|
||
}
|
||
return [];
|
||
}
|
||
|
||
function configuredWhitelist(config) {
|
||
const safety = (config && config.safety) || {};
|
||
const whitelist = safety.realSubmitWhitelist || safety.realSubmitAllowlist || {};
|
||
return {
|
||
enabled: Boolean(whitelist.enabled),
|
||
allowedSenders: [
|
||
...arrayFromConfig(whitelist.allowedSenders),
|
||
...arrayFromConfig(whitelist.allowedSenderIds),
|
||
...arrayFromConfig(whitelist.allowedSenderNames),
|
||
...arrayFromConfig(whitelist.allowedWechatIds),
|
||
...arrayFromConfig(whitelist.allowedWeChatIds),
|
||
],
|
||
allowedChannels: [
|
||
...arrayFromConfig(whitelist.allowedChannels),
|
||
...arrayFromConfig(whitelist.allowedChannelIds),
|
||
...arrayFromConfig(whitelist.allowedChatIds),
|
||
],
|
||
authorizationCodes: arrayFromConfig(whitelist.authorizationCodes || whitelist.allowedAuthorizationCodes),
|
||
allowAuthorizationCodeFallback: whitelist.allowAuthorizationCodeFallback === true,
|
||
};
|
||
}
|
||
|
||
function collectSourceValues(source) {
|
||
const values = [];
|
||
const add = (value) => {
|
||
if (value === undefined || value === null) return;
|
||
if (Array.isArray(value)) {
|
||
value.forEach(add);
|
||
return;
|
||
}
|
||
if (typeof value === 'object') return;
|
||
const normalized = normalizeWhitelistValue(value);
|
||
if (normalized) values.push(normalized);
|
||
};
|
||
|
||
if (typeof source === 'string') {
|
||
add(source);
|
||
return [...new Set(values)];
|
||
}
|
||
|
||
const scan = (object) => {
|
||
if (!object || typeof object !== 'object') return;
|
||
[
|
||
'sender',
|
||
'senderId',
|
||
'senderName',
|
||
'from',
|
||
'fromUser',
|
||
'fromUserId',
|
||
'fromUserName',
|
||
'user',
|
||
'userId',
|
||
'userName',
|
||
'author',
|
||
'authorId',
|
||
'authorName',
|
||
'wechatId',
|
||
'weChatId',
|
||
'wxid',
|
||
'openId',
|
||
'unionId',
|
||
'contactId',
|
||
'contactName',
|
||
'chatId',
|
||
'channelId',
|
||
'conversationId',
|
||
'roomId',
|
||
].forEach((key) => add(object[key]));
|
||
};
|
||
|
||
scan(source);
|
||
scan(source && source.wechat);
|
||
scan(source && source.weChat);
|
||
scan(source && source.message);
|
||
scan(source && source.contact);
|
||
scan(source && source.channel);
|
||
return [...new Set(values)];
|
||
}
|
||
|
||
function sourceFromEnvelope(envelope, task, options = {}) {
|
||
return {
|
||
...(envelope && envelope.source && typeof envelope.source === 'object' ? envelope.source : {}),
|
||
...(task && task.source && typeof task.source === 'object' ? task.source : {}),
|
||
...(task && task.metadata && task.metadata.source && typeof task.metadata.source === 'object' ? task.metadata.source : {}),
|
||
...(options.source && typeof options.source === 'object' ? options.source : {}),
|
||
sender: options.sender || (options.source && options.source.sender) || undefined,
|
||
senderId: options.senderId || (options.source && options.source.senderId) || undefined,
|
||
senderName: options.senderName || (options.source && options.source.senderName) || undefined,
|
||
chatId: options.chatId || (options.source && options.source.chatId) || undefined,
|
||
channelId: options.channelId || (options.source && options.source.channelId) || undefined,
|
||
};
|
||
}
|
||
|
||
function extractAuthorizationCodes(task) {
|
||
const text = taskTextForSafety(task);
|
||
const codes = [];
|
||
const regex = /(?:真实保存授权码|ERP\s*授权码|授权码)\s*[：:]\s*([A-Za-z0-9._-]{4,80})/gi;
|
||
for (const match of text.matchAll(regex)) {
|
||
codes.push(normalizeWhitelistValue(match[1]));
|
||
}
|
||
return [...new Set(codes)];
|
||
}
|
||
|
||
function checkRealSubmitWhitelist(task, config, envelope, options = {}) {
|
||
const whitelist = configuredWhitelist(config);
|
||
if (!whitelist.enabled) {
|
||
return { ok: true, enabled: false };
|
||
}
|
||
|
||
const allowed = new Set([
|
||
...whitelist.allowedSenders,
|
||
...whitelist.allowedChannels,
|
||
].map(normalizeWhitelistValue).filter(Boolean));
|
||
const sourceValues = collectSourceValues(sourceFromEnvelope(envelope, task, options));
|
||
const matchedSource = sourceValues.find((value) => allowed.has(value));
|
||
if (matchedSource) {
|
||
return {
|
||
ok: true,
|
||
enabled: true,
|
||
method: 'sender',
|
||
matchedSource,
|
||
sourceValues,
|
||
};
|
||
}
|
||
|
||
const allowedCodes = new Set(whitelist.authorizationCodes.map(normalizeWhitelistValue).filter(Boolean));
|
||
const submittedCodes = extractAuthorizationCodes(task);
|
||
if (whitelist.allowAuthorizationCodeFallback && submittedCodes.some((code) => allowedCodes.has(code))) {
|
||
return {
|
||
ok: true,
|
||
enabled: true,
|
||
method: 'authorization_code',
|
||
sourceValues,
|
||
authorizationCodeProvided: true,
|
||
};
|
||
}
|
||
|
||
return {
|
||
ok: false,
|
||
enabled: true,
|
||
sourceValues,
|
||
configuredSenderCount: whitelist.allowedSenders.length,
|
||
configuredChannelCount: whitelist.allowedChannels.length,
|
||
authorizationCodeProvided: submittedCodes.length > 0,
|
||
};
|
||
}
|
||
|
||
function normalizeIdentityPart(value) {
|
||
return String(value || '').trim().replace(/\s+/g, '').toLowerCase();
|
||
}
|
||
|
||
function uniqueSorted(values) {
|
||
return [...new Set(values.filter(Boolean).map(String))].sort();
|
||
}
|
||
|
||
function extractTaskDates(task) {
|
||
const fields = (task && task.fields) || {};
|
||
if (Array.isArray(fields.departureDates) && fields.departureDates.length) {
|
||
return uniqueSorted(fields.departureDates);
|
||
}
|
||
if (fields.departureDate) return uniqueSorted([fields.departureDate]);
|
||
if (fields.dateRange && (fields.dateRange.start || fields.dateRange.end)) {
|
||
return uniqueSorted([`${fields.dateRange.start || ''}..${fields.dateRange.end || ''}`]);
|
||
}
|
||
return [];
|
||
}
|
||
|
||
function taskIdentity(task) {
|
||
const fields = (task && task.fields) || {};
|
||
const customer = normalizeIdentityPart(fields.bookingCustomer || fields.channelCustomer || fields.customer);
|
||
const product = normalizeIdentityPart(fields.productName || fields.productRoute || fields.routeProduct);
|
||
const parentGroupNo = normalizeIdentityPart(fields.parentGroupNo);
|
||
|
||
return {
|
||
route: normalizeIdentityPart(task && task.route),
|
||
dates: extractTaskDates(task),
|
||
primary: parentGroupNo || [customer, product].filter(Boolean).join('|') || product || customer,
|
||
};
|
||
}
|
||
|
||
function sameTaskIdentity(leftTask, rightTask) {
|
||
const left = taskIdentity(leftTask);
|
||
const right = taskIdentity(rightTask);
|
||
if (!left.route || left.route !== right.route) return false;
|
||
if (!left.primary || left.primary !== right.primary) return false;
|
||
if (left.dates.length !== right.dates.length) return false;
|
||
return left.dates.every((date, index) => date === right.dates[index]);
|
||
}
|
||
|
||
function normalizeUpdateText(value) {
|
||
return String(value || '')
|
||
.replace(/\r\n/g, '\n')
|
||
.replace(/\r/g, '\n')
|
||
.split('\n')
|
||
.map((line) => line.trim().replace(/\s+/g, ' '))
|
||
.filter(Boolean)
|
||
.join('\n');
|
||
}
|
||
|
||
function canonicalValue(value) {
|
||
if (value === null || value === undefined) return value;
|
||
if (typeof value === 'number') return Number.isFinite(value) ? value : String(value);
|
||
if (typeof value === 'boolean') return value;
|
||
if (typeof value === 'string') return value.trim().replace(/\s+/g, ' ');
|
||
if (Array.isArray(value)) return value.map(canonicalValue);
|
||
if (typeof value === 'object') {
|
||
return Object.keys(value).sort().reduce((acc, key) => {
|
||
acc[key] = canonicalValue(value[key]);
|
||
return acc;
|
||
}, {});
|
||
}
|
||
return String(value);
|
||
}
|
||
|
||
function stableJson(value) {
|
||
return JSON.stringify(canonicalValue(value));
|
||
}
|
||
|
||
function canonicalUpdateActions(updatePlan = {}) {
|
||
return (Array.isArray(updatePlan.actions) ? updatePlan.actions : [])
|
||
.map((action) => ({
|
||
target: normalizeIdentityPart(action && action.target),
|
||
operation: normalizeIdentityPart(action && action.operation),
|
||
value: canonicalValue(action && action.value),
|
||
}))
|
||
.sort((left, right) => stableJson(left).localeCompare(stableJson(right)));
|
||
}
|
||
|
||
function updateTaskFingerprint(task = {}) {
|
||
const actions = canonicalUpdateActions(task.updatePlan || {});
|
||
const payload = {
|
||
operation: 'update_order',
|
||
identifier: normalizeIdentityPart(task.identifier),
|
||
actions,
|
||
};
|
||
if (!actions.length) {
|
||
payload.updateText = normalizeUpdateText(task.updateText || task.originalText || '');
|
||
}
|
||
return stableJson(payload);
|
||
}
|
||
|
||
function updateTaskRequestsDuplicateOverride(task = {}) {
|
||
const text = normalizeUpdateText([
|
||
task.updateText,
|
||
task.originalText,
|
||
].filter(Boolean).join('\n'));
|
||
return /force[_\s-]?duplicate[_\s-]?update|again[_\s-]?same[_\s-]?update|再次执行相同修改|确认再次执行相同修改/i.test(text);
|
||
}
|
||
|
||
function auditCreatedAtMs(auditPath, payload) {
|
||
const createdAt = payload && payload.task && payload.task.createdAt;
|
||
const parsed = createdAt ? Date.parse(createdAt) : NaN;
|
||
if (Number.isFinite(parsed)) return parsed;
|
||
try {
|
||
return fs.statSync(auditPath).mtimeMs;
|
||
} catch {
|
||
return 0;
|
||
}
|
||
}
|
||
|
||
function findRecentNoSaveBlockForSameOrder(task, auditDir, options = {}) {
|
||
if (!auditDir || !fs.existsSync(auditDir)) return null;
|
||
|
||
const nowMs = Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
|
||
const windowMs = Number.isFinite(options.windowMs) ? options.windowMs : DEFAULT_NO_SAVE_BLOCK_WINDOW_MS;
|
||
const files = fs.readdirSync(auditDir)
|
||
.filter((file) => file.endsWith('.json'))
|
||
.map((file) => path.join(auditDir, file))
|
||
.sort((left, right) => {
|
||
try {
|
||
return fs.statSync(right).mtimeMs - fs.statSync(left).mtimeMs;
|
||
} catch {
|
||
return 0;
|
||
}
|
||
})
|
||
.slice(0, 200);
|
||
|
||
for (const filePath of files) {
|
||
let payload;
|
||
try {
|
||
payload = readJson(filePath);
|
||
} catch {
|
||
continue;
|
||
}
|
||
if (!payload || payload.status !== 'blocked') continue;
|
||
if (payload.reason !== 'order_text_forbids_real_submit') continue;
|
||
if (!payload.task || !sameTaskIdentity(task, payload.task)) continue;
|
||
|
||
const createdAtMs = auditCreatedAtMs(filePath, payload);
|
||
if (!createdAtMs || nowMs - createdAtMs > windowMs) continue;
|
||
|
||
return {
|
||
auditPath: payload.auditPath || filePath,
|
||
createdAt: payload.task.createdAt || new Date(createdAtMs).toISOString(),
|
||
};
|
||
}
|
||
return null;
|
||
}
|
||
|
||
function findRecentCompletedUpdateForSameChange(task, auditDir, options = {}) {
|
||
if (!auditDir || !fs.existsSync(auditDir)) return null;
|
||
|
||
const targetFingerprint = updateTaskFingerprint(task);
|
||
const nowMs = Number.isFinite(options.nowMs) ? options.nowMs : Date.now();
|
||
const windowMs = Number.isFinite(options.windowMs) ? options.windowMs : DEFAULT_UPDATE_DUPLICATE_WINDOW_MS;
|
||
const files = fs.readdirSync(auditDir)
|
||
.filter((file) => file.endsWith('.json'))
|
||
.map((file) => path.join(auditDir, file))
|
||
.sort((left, right) => {
|
||
try {
|
||
return fs.statSync(right).mtimeMs - fs.statSync(left).mtimeMs;
|
||
} catch {
|
||
return 0;
|
||
}
|
||
})
|
||
.slice(0, 300);
|
||
|
||
for (const filePath of files) {
|
||
let payload;
|
||
try {
|
||
payload = readJson(filePath);
|
||
} catch {
|
||
continue;
|
||
}
|
||
if (!payload || payload.status !== 'completed') continue;
|
||
if (payload.operation !== 'update_order') continue;
|
||
if (!payload.task || updateTaskFingerprint(payload.task) !== targetFingerprint) continue;
|
||
|
||
const createdAtMs = auditCreatedAtMs(filePath, payload);
|
||
if (!createdAtMs || (windowMs >= 0 && nowMs - createdAtMs > windowMs)) continue;
|
||
|
||
return {
|
||
auditPath: payload.auditPath || filePath,
|
||
createdAt: payload.task.createdAt || new Date(createdAtMs).toISOString(),
|
||
identifier: payload.task.identifier || '',
|
||
};
|
||
}
|
||
return null;
|
||
}
|
||
|
||
function formatIdentifierLines(identifiers) {
|
||
if (!identifiers || typeof identifiers !== 'object') return [];
|
||
|
||
if (identifiers.dateToGroupNo) {
|
||
return Object.entries(identifiers.dateToGroupNo).map(([date, groupNo]) => `- ${date}: ${groupNo}`);
|
||
}
|
||
if (identifiers.dateToParentGroupNo) {
|
||
return Object.entries(identifiers.dateToParentGroupNo).map(([date, groupNo]) => `- ${date}: ${groupNo}`);
|
||
}
|
||
if (identifiers.groupNo) return [`- ERP group no: ${identifiers.groupNo}`];
|
||
if (identifiers.parentGroupNo || identifiers.childOrderNo) {
|
||
const lines = [];
|
||
if (identifiers.parentGroupNo) lines.push(`- Parent group no: ${identifiers.parentGroupNo}`);
|
||
if (identifiers.childOrderNo) lines.push(`- Child order no: ${identifiers.childOrderNo}`);
|
||
return lines;
|
||
}
|
||
return Object.entries(identifiers).map(([key, value]) => `- ${key}: ${value}`);
|
||
}
|
||
|
||
function collectWarningMessages(executionResult = {}) {
|
||
const warnings = [];
|
||
const add = (items) => {
|
||
if (!Array.isArray(items)) return;
|
||
for (const item of items) {
|
||
const message = item && (item.message || item.customerMessage || item.reason);
|
||
if (message) warnings.push(String(message));
|
||
}
|
||
};
|
||
add(executionResult.warnings);
|
||
add(executionResult.rawExecutionResult && executionResult.rawExecutionResult.warnings);
|
||
add(executionResult.rawExecutionResult
|
||
&& executionResult.rawExecutionResult.stageResults
|
||
&& executionResult.rawExecutionResult.stageResults.submit
|
||
&& executionResult.rawExecutionResult.stageResults.submit.warnings);
|
||
return [...new Set(warnings)];
|
||
}
|
||
|
||
function formatCompletionMessage(task, executionResult) {
|
||
const lines = [
|
||
'ERP execution completed.',
|
||
`Route: ${routeLabel(task.route)}`,
|
||
];
|
||
const warningMessages = collectWarningMessages(executionResult);
|
||
if (warningMessages.length) {
|
||
lines.push('提醒：');
|
||
lines.push(...warningMessages.map((message) => `- ${message}`));
|
||
}
|
||
const identifierLines = formatIdentifierLines(executionResult.identifiers);
|
||
if (identifierLines.length) {
|
||
lines.push('Identifiers:');
|
||
lines.push(...identifierLines);
|
||
}
|
||
if (executionResult.artifacts && executionResult.artifacts.length) {
|
||
lines.push('PDF files are ready or queued for delivery.');
|
||
}
|
||
return lines.join('\n');
|
||
}
|
||
|
||
function defaultHandlers() {
|
||
const handlers = {};
|
||
try {
|
||
const operationHandlers = require('./erp_operation_handlers');
|
||
handlers.update_order = operationHandlers.executeUpdateOrder;
|
||
handlers.export_confirmation = operationHandlers.executeExportConfirmation;
|
||
} catch {
|
||
// Keep dispatcher usable when operation handlers are absent.
|
||
}
|
||
try {
|
||
handlers.team_single = require('./erp_team_single_executor').executeTeamSingle;
|
||
} catch {
|
||
// Keep dispatcher usable when optional route executors are absent.
|
||
}
|
||
try {
|
||
handlers.team_batch = require('./erp_team_batch_executor').executeTeamBatch;
|
||
} catch {
|
||
// Keep dispatcher usable when optional route executors are absent.
|
||
}
|
||
try {
|
||
handlers.split_parent = require('./erp_split_parent_executor').executeSplitParent;
|
||
} catch {
|
||
// Keep dispatcher usable when optional route executors are absent.
|
||
}
|
||
try {
|
||
handlers.split_child = require('./erp_split_child_executor').executeSplitChild;
|
||
} catch {
|
||
// Keep dispatcher usable when optional route executors are absent.
|
||
}
|
||
return handlers;
|
||
}
|
||
|
||
async function dispatchTask(input, options = {}) {
|
||
const mode = normalizeMode(options.mode || 'dry-run');
|
||
const config = options.config || {};
|
||
const auditDir = options.auditDir || (config.paths && config.paths.auditDir) || DEFAULT_AUDIT_DIR;
|
||
const handlers = options.handlers || defaultHandlers();
|
||
let envelope = normalizeEnvelope(input);
|
||
|
||
let result;
|
||
try {
|
||
if (envelope.status !== 'ready') {
|
||
result = blocked(
|
||
envelope.status === 'invalid' ? envelope.reason || 'invalid_input' : 'adapter_not_ready',
|
||
envelope.customerMessage || 'The incoming order is not ready for ERP execution.',
|
||
{
|
||
mode,
|
||
route: envelope.route || null,
|
||
adapterStatus: envelope.status,
|
||
}
|
||
);
|
||
return writeAudit(result, auditDir);
|
||
}
|
||
|
||
const taskValidation = validateTaskEnvelope(envelope);
|
||
if (!taskValidation.valid) {
|
||
result = blocked(
|
||
taskValidation.status === 'needs_clarification' ? 'adapter_not_ready' : 'invalid_task',
|
||
taskValidation.status === 'needs_clarification'
|
||
? 'The incoming order is not ready for ERP execution.'
|
||
: 'The ERP task JSON is invalid and was not sent to an executor.',
|
||
{
|
||
mode,
|
||
operation: taskValidation.task && taskValidation.task.operation || envelope.operation || null,
|
||
route: taskValidation.task && taskValidation.task.route || envelope.route || null,
|
||
task: taskValidation.task,
|
||
violations: taskValidation.violations,
|
||
}
|
||
);
|
||
return writeAudit(result, auditDir);
|
||
}
|
||
|
||
envelope = taskValidation.envelope;
|
||
const task = taskValidation.task;
|
||
if (!task) {
|
||
result = blocked('missing_task', 'The ready envelope is missing a task.', {
|
||
mode,
|
||
route: null,
|
||
operation: envelope.operation || null,
|
||
task: null,
|
||
});
|
||
return writeAudit(result, auditDir);
|
||
}
|
||
|
||
const operation = taskOperation(task, envelope);
|
||
const handlerKey = operationHandlerKey(task, envelope);
|
||
const route = task.route || envelope.route || null;
|
||
|
||
if (!KNOWN_OPERATIONS.has(operation)) {
|
||
result = blocked('unsupported_operation', `Unsupported ERP operation: ${operation}.`, {
|
||
mode,
|
||
operation,
|
||
route,
|
||
task,
|
||
});
|
||
return writeAudit(result, auditDir);
|
||
}
|
||
|
||
if (operation === 'create_order' && !task.route) {
|
||
result = blocked('missing_task_route', 'The ready task is missing a route.', {
|
||
mode,
|
||
operation,
|
||
route: null,
|
||
task,
|
||
});
|
||
return writeAudit(result, auditDir);
|
||
}
|
||
|
||
if (mode === 'dry-run') {
|
||
result = {
|
||
status: 'dry_run',
|
||
mode,
|
||
operation,
|
||
route,
|
||
plannedExecutor: handlerKey,
|
||
task,
|
||
customerMessage: `Task is ready for ${operationLabel(operation, task.route)}.`,
|
||
};
|
||
return writeAudit(result, auditDir);
|
||
}
|
||
|
||
const allowRealSubmit = Boolean(config.safety && config.safety.allowRealSubmit);
|
||
if (!allowRealSubmit) {
|
||
result = blocked('real_submit_disabled', 'Real ERP submit is disabled by config safety.allowRealSubmit.', {
|
||
mode,
|
||
operation,
|
||
route,
|
||
task,
|
||
});
|
||
return writeAudit(result, auditDir);
|
||
}
|
||
|
||
if (orderTextForbidsRealSubmit(task)) {
|
||
result = blocked('order_text_forbids_real_submit', 'The order text forbids real ERP submit. Run dry-run or remove the no-save instruction before execute.', {
|
||
mode,
|
||
operation,
|
||
route,
|
||
task,
|
||
});
|
||
return writeAudit(result, auditDir);
|
||
}
|
||
|
||
const whitelistCheck = checkRealSubmitWhitelist(task, config, envelope, options);
|
||
if (!whitelistCheck.ok) {
|
||
result = blocked(
|
||
'real_submit_sender_not_authorized',
|
||
'真实保存 ERP 已被白名单拦截：当前微信发送人不在允许名单中。请使用已授权微信号发送，或联系管理员加入白名单。',
|
||
{
|
||
mode,
|
||
operation,
|
||
route,
|
||
task,
|
||
whitelist: whitelistCheck,
|
||
}
|
||
);
|
||
return writeAudit(result, auditDir);
|
||
}
|
||
|
||
if (!orderTextConfirmsRealSubmit(task)) {
|
||
const safety = (config && config.safety) || {};
|
||
const windowMs = Number.isFinite(Number(safety.noSaveBlockWindowMinutes))
|
||
? Number(safety.noSaveBlockWindowMinutes) * 60 * 1000
|
||
: DEFAULT_NO_SAVE_BLOCK_WINDOW_MS;
|
||
const recentNoSaveBlock = findRecentNoSaveBlockForSameOrder(task, auditDir, { windowMs });
|
||
if (recentNoSaveBlock) {
|
||
result = blocked(
|
||
'recent_no_save_block_for_same_order',
|
||
'A recent no-save block exists for the same order. Stop instead of retrying a rewritten execute task; add an explicit real-save confirmation before executing.',
|
||
{
|
||
mode,
|
||
operation,
|
||
route,
|
||
task,
|
||
recentNoSaveBlock,
|
||
}
|
||
);
|
||
return writeAudit(result, auditDir);
|
||
}
|
||
}
|
||
|
||
if (operation === 'update_order' && !updateTaskRequestsDuplicateOverride(task)) {
|
||
const safety = (config && config.safety) || {};
|
||
const windowMs = Number.isFinite(Number(safety.updateDuplicateBlockWindowMinutes))
|
||
? Number(safety.updateDuplicateBlockWindowMinutes) * 60 * 1000
|
||
: DEFAULT_UPDATE_DUPLICATE_WINDOW_MS;
|
||
const recentDuplicateUpdate = findRecentCompletedUpdateForSameChange(task, auditDir, { windowMs });
|
||
if (recentDuplicateUpdate) {
|
||
result = blocked(
|
||
'recent_duplicate_update_order',
|
||
'检测到同一个订单号和相同修改内容近期已经执行成功，已拦截本次重复修改，避免相同增量被执行两次。如确实要再次执行同样修改，请在指令中加入“再次执行相同修改”。',
|
||
{
|
||
mode,
|
||
operation,
|
||
route,
|
||
task,
|
||
recentDuplicateUpdate,
|
||
}
|
||
);
|
||
return writeAudit(result, auditDir);
|
||
}
|
||
}
|
||
|
||
const handler = handlers[handlerKey];
|
||
const knownHandlerKey = operation === 'create_order' ? KNOWN_ROUTES.has(task.route) : KNOWN_OPERATIONS.has(operation);
|
||
if (!knownHandlerKey || typeof handler !== 'function') {
|
||
result = blocked('executor_missing', `No executor is connected for operation: ${handlerKey}.`, {
|
||
mode,
|
||
operation,
|
||
route,
|
||
plannedExecutor: handlerKey,
|
||
task,
|
||
});
|
||
return writeAudit(result, auditDir);
|
||
}
|
||
|
||
const executionResult = await runExecutionHandler(
|
||
handler,
|
||
task,
|
||
{ config, mode, operation },
|
||
options,
|
||
auditDir
|
||
);
|
||
if (executionResult.status === 'blocked') {
|
||
result = {
|
||
...executionResult,
|
||
mode,
|
||
operation,
|
||
route,
|
||
task,
|
||
};
|
||
return writeAudit(result, auditDir);
|
||
}
|
||
const completed = {
|
||
status: executionResult.status || 'completed',
|
||
mode,
|
||
operation,
|
||
route,
|
||
task,
|
||
identifiers: executionResult.identifiers || {},
|
||
artifacts: executionResult.artifacts || [],
|
||
warnings: executionResult.warnings || [],
|
||
rawExecutionResult: executionResult,
|
||
};
|
||
completed.customerMessage = executionResult.customerMessage || formatCompletionMessage(task, completed);
|
||
const audited = writeAudit(completed, auditDir);
|
||
const registryPath = options.registryPath || (config.paths && config.paths.orderRegistry) || '';
|
||
if (operation === 'create_order' && registryPath) {
|
||
audited.registryRecords = orderRegistry.appendOrderRecord(audited, { registryPath });
|
||
fs.writeFileSync(audited.auditPath, JSON.stringify(cloneForAudit(audited), null, 2), 'utf8');
|
||
}
|
||
return audited;
|
||
} catch (error) {
|
||
const operation = envelope.operation || (envelope.task && envelope.task.operation) || null;
|
||
const route = envelope.route || (envelope.task && envelope.task.route) || null;
|
||
result = blocked('dispatcher_error', dispatcherErrorCustomerMessage(operation, route), {
|
||
mode,
|
||
operation,
|
||
route,
|
||
error: {
|
||
name: error.name,
|
||
code: error.code,
|
||
message: error.message,
|
||
details: error.details,
|
||
stack: error.stack,
|
||
},
|
||
});
|
||
return writeAudit(result, auditDir);
|
||
}
|
||
}
|
||
|
||
function parseArgs(argv) {
|
||
const args = {
|
||
task: '',
|
||
order: '',
|
||
config: '',
|
||
auditDir: '',
|
||
sender: '',
|
||
senderId: '',
|
||
senderName: '',
|
||
chatId: '',
|
||
channelId: '',
|
||
attachments: [],
|
||
mode: 'dry-run',
|
||
json: false,
|
||
help: false,
|
||
};
|
||
for (let index = 0; index < argv.length; index += 1) {
|
||
const arg = argv[index];
|
||
if (arg === '--task') {
|
||
args.task = argv[index + 1];
|
||
index += 1;
|
||
} else if (arg.startsWith('--task=')) {
|
||
args.task = arg.slice('--task='.length);
|
||
} else if (arg === '--order') {
|
||
args.order = argv[index + 1];
|
||
index += 1;
|
||
} else if (arg.startsWith('--order=')) {
|
||
args.order = arg.slice('--order='.length);
|
||
} else if (arg === '--config') {
|
||
args.config = argv[index + 1];
|
||
index += 1;
|
||
} else if (arg.startsWith('--config=')) {
|
||
args.config = arg.slice('--config='.length);
|
||
} else if (arg === '--audit-dir') {
|
||
args.auditDir = argv[index + 1];
|
||
index += 1;
|
||
} else if (arg.startsWith('--audit-dir=')) {
|
||
args.auditDir = arg.slice('--audit-dir='.length);
|
||
} else if (arg === '--sender') {
|
||
args.sender = argv[index + 1];
|
||
index += 1;
|
||
} else if (arg.startsWith('--sender=')) {
|
||
args.sender = arg.slice('--sender='.length);
|
||
} else if (arg === '--sender-id') {
|
||
args.senderId = argv[index + 1];
|
||
index += 1;
|
||
} else if (arg.startsWith('--sender-id=')) {
|
||
args.senderId = arg.slice('--sender-id='.length);
|
||
} else if (arg === '--sender-name') {
|
||
args.senderName = argv[index + 1];
|
||
index += 1;
|
||
} else if (arg.startsWith('--sender-name=')) {
|
||
args.senderName = arg.slice('--sender-name='.length);
|
||
} else if (arg === '--chat-id') {
|
||
args.chatId = argv[index + 1];
|
||
index += 1;
|
||
} else if (arg.startsWith('--chat-id=')) {
|
||
args.chatId = arg.slice('--chat-id='.length);
|
||
} else if (arg === '--channel-id') {
|
||
args.channelId = argv[index + 1];
|
||
index += 1;
|
||
} else if (arg.startsWith('--channel-id=')) {
|
||
args.channelId = arg.slice('--channel-id='.length);
|
||
} else if (arg === '--attachment') {
|
||
args.attachments.push(argv[index + 1]);
|
||
index += 1;
|
||
} else if (arg.startsWith('--attachment=')) {
|
||
args.attachments.push(arg.slice('--attachment='.length));
|
||
} else if (arg === '--mode') {
|
||
args.mode = argv[index + 1];
|
||
index += 1;
|
||
} else if (arg.startsWith('--mode=')) {
|
||
args.mode = arg.slice('--mode='.length);
|
||
} else if (arg === '--json') {
|
||
args.json = true;
|
||
} else if (arg === '--help' || arg === '-h') {
|
||
args.help = true;
|
||
}
|
||
}
|
||
return args;
|
||
}
|
||
|
||
function helpText() {
|
||
return [
|
||
'Usage:',
|
||
' node tools/erp_task_dispatcher.js --order order.txt [--mode dry-run|execute] [--config config.json] [--sender-id wxid] [--json]',
|
||
' node tools/erp_task_dispatcher.js --task adapter-output.json [--mode dry-run|execute] [--config config.json] [--sender-id wxid] [--json]',
|
||
'',
|
||
'Dispatches a normalized WeChat ERP task to the route executor layer.',
|
||
'By default this is a dry-run. Real ERP submit requires config.safety.allowRealSubmit=true, an authorized sender when whitelist is enabled, and a connected executor.',
|
||
].join('\n');
|
||
}
|
||
|
||
function pickKeys(source = {}, keys = []) {
|
||
const target = {};
|
||
for (const key of keys) {
|
||
if (source[key] !== undefined && source[key] !== null && source[key] !== '') {
|
||
target[key] = source[key];
|
||
}
|
||
}
|
||
return target;
|
||
}
|
||
|
||
function summarizeTravelerImport(importResult = {}) {
|
||
return pickKeys(importResult, [
|
||
'attempted',
|
||
'imported',
|
||
'method',
|
||
'expectedRows',
|
||
'beforeRows',
|
||
'beforeFilledRows',
|
||
'afterRows',
|
||
'afterFilledRows',
|
||
'pasteRows',
|
||
'reason',
|
||
]);
|
||
}
|
||
|
||
function collectTravelerImports(value, results = [], seen = new Set(), depth = 0) {
|
||
if (!value || typeof value !== 'object' || depth > 12 || seen.has(value)) return results;
|
||
seen.add(value);
|
||
if (value.travelerImport && typeof value.travelerImport === 'object') {
|
||
results.push(summarizeTravelerImport(value.travelerImport));
|
||
}
|
||
if (Array.isArray(value)) {
|
||
for (const item of value) collectTravelerImports(item, results, seen, depth + 1);
|
||
return results;
|
||
}
|
||
for (const [key, item] of Object.entries(value)) {
|
||
if (key === 'task' || key === 'travelerList' || key === 'travelers') continue;
|
||
collectTravelerImports(item, results, seen, depth + 1);
|
||
}
|
||
return results;
|
||
}
|
||
|
||
function summarizeRegistryRecords(records = []) {
|
||
if (!Array.isArray(records)) return [];
|
||
return records.map((record) => pickKeys(record, [
|
||
'operation',
|
||
'route',
|
||
'identifier',
|
||
'groupNo',
|
||
'childOrderNo',
|
||
'parentGroupNo',
|
||
'departureDate',
|
||
'ddid',
|
||
'did',
|
||
'tid',
|
||
'parentTid',
|
||
'childDid',
|
||
'updatedAt',
|
||
]));
|
||
}
|
||
|
||
function summarizeCliResult(result = {}) {
|
||
const summary = pickKeys(result, [
|
||
'status',
|
||
'reason',
|
||
'mode',
|
||
'operation',
|
||
'route',
|
||
'plannedExecutor',
|
||
'customerMessage',
|
||
'auditPath',
|
||
]);
|
||
if (result.identifiers) summary.identifiers = result.identifiers;
|
||
if (Array.isArray(result.artifacts)) summary.artifacts = result.artifacts;
|
||
if (Array.isArray(result.warnings)) summary.warnings = result.warnings;
|
||
const travelerImports = collectTravelerImports(result)
|
||
.filter((item) => Object.keys(item).length > 0);
|
||
if (travelerImports.length) summary.travelerImports = travelerImports;
|
||
const registryRecords = summarizeRegistryRecords(result.registryRecords);
|
||
if (registryRecords.length) summary.registryRecords = registryRecords;
|
||
if (result.error) summary.error = pickKeys(result.error, ['name', 'code', 'message']);
|
||
return summary;
|
||
}
|
||
|
||
async function loadInputEnvelope(args) {
|
||
if (args.order) {
|
||
const adapter = require('./erp_operation_adapter');
|
||
const orderPath = resolvePath(args.order);
|
||
const text = fs.readFileSync(orderPath, 'utf8');
|
||
return adapter.handleIncomingMessage(text, {
|
||
auditDir: args.auditDir ? resolvePath(args.auditDir) : undefined,
|
||
attachments: (args.attachments || []).map((item) => resolvePath(item)),
|
||
});
|
||
}
|
||
if (args.task) {
|
||
return readJson(resolvePath(args.task));
|
||
}
|
||
throw new Error('Missing --order or --task.');
|
||
}
|
||
|
||
async function main() {
|
||
const args = parseArgs(process.argv.slice(2));
|
||
if (args.help || (!args.order && !args.task)) {
|
||
console.log(helpText());
|
||
process.exitCode = args.help ? 0 : 1;
|
||
return;
|
||
}
|
||
|
||
const config = readConfig(args.config);
|
||
const auditDir = args.auditDir ? resolvePath(args.auditDir) : undefined;
|
||
const envelope = await loadInputEnvelope(args);
|
||
const result = await dispatchTask(envelope, {
|
||
mode: args.mode,
|
||
config,
|
||
auditDir,
|
||
source: {
|
||
sender: args.sender,
|
||
senderId: args.senderId,
|
||
senderName: args.senderName,
|
||
chatId: args.chatId,
|
||
channelId: args.channelId,
|
||
},
|
||
});
|
||
|
||
if (args.json) {
|
||
console.log(JSON.stringify(summarizeCliResult(result), null, 2));
|
||
} else {
|
||
console.log(result.customerMessage);
|
||
console.log(`audit: ${result.auditPath}`);
|
||
}
|
||
if (result.status === 'blocked') process.exitCode = 2;
|
||
await new Promise((resolve) => process.stdout.write('', resolve));
|
||
process.exit(process.exitCode || 0);
|
||
}
|
||
|
||
if (require.main === module) {
|
||
main().catch((error) => {
|
||
console.error(error.stack || error.message);
|
||
process.exit(1);
|
||
});
|
||
}
|
||
|
||
module.exports = {
|
||
KNOWN_ROUTES,
|
||
KNOWN_OPERATIONS,
|
||
normalizeEnvelope,
|
||
readConfig,
|
||
dispatchTask,
|
||
formatCompletionMessage,
|
||
collectWarningMessages,
|
||
taskOperation,
|
||
operationHandlerKey,
|
||
summarizeCliResult,
|
||
orderTextForbidsRealSubmit,
|
||
orderTextConfirmsRealSubmit,
|
||
checkRealSubmitWhitelist,
|
||
collectSourceValues,
|
||
extractAuthorizationCodes,
|
||
findRecentNoSaveBlockForSameOrder,
|
||
findRecentCompletedUpdateForSameChange,
|
||
updateTaskFingerprint,
|
||
updateTaskRequestsDuplicateOverride,
|
||
loadInputEnvelope,
|
||
parseArgs,
|
||
summarizeCliResult,
|
||
};
|