1004 lines
40 KiB
JavaScript
1004 lines
40 KiB
JavaScript
'use strict';
|
||
|
||
importScripts('operation-plans.js', 'execution-guard.js');
|
||
|
||
const runningTasks = new Set();
|
||
const cancelledTasks = new Set();
|
||
const operationPlans = self.LTJTOperationPlans;
|
||
const executionGuard = self.LTJTExecutionGuard;
|
||
let storageMutationQueue = Promise.resolve();
|
||
|
||
function nowIso() {
|
||
return new Date().toISOString();
|
||
}
|
||
|
||
async function delay(ms, taskId = '') {
|
||
await new Promise((resolve) => setTimeout(resolve, ms));
|
||
throwIfTaskCancelled(taskId);
|
||
}
|
||
|
||
function taskRootId(taskId) {
|
||
return String(taskId || '').split('#')[0];
|
||
}
|
||
|
||
function isTaskCancelled(taskId) {
|
||
const normalized = String(taskId || '');
|
||
return Boolean(normalized)
|
||
&& (cancelledTasks.has(normalized) || cancelledTasks.has(taskRootId(normalized)));
|
||
}
|
||
|
||
function cancellationError(taskId) {
|
||
const error = new Error(`任务 ${taskId} 已取消。`);
|
||
error.code = 'task_cancelled';
|
||
return error;
|
||
}
|
||
|
||
function throwIfTaskCancelled(taskId) {
|
||
if (isTaskCancelled(taskId)) throw cancellationError(taskId);
|
||
}
|
||
|
||
function isBusinessSystemUrl(url) {
|
||
return /^http:\/\/(localhost|127\.0\.0\.1)(?::8765)?\//i.test(url || '');
|
||
}
|
||
|
||
function toNumber(value) {
|
||
const normalized = String(value ?? '').replace(/[，,]/g, '').trim();
|
||
const num = Number(normalized);
|
||
return Number.isFinite(num) ? num : 0;
|
||
}
|
||
|
||
function dateYyyyMD(value) {
|
||
if (typeof value !== 'string') return value;
|
||
const match = value.match(/^(\d{4})-(\d{1,2})-(\d{1,2})$/);
|
||
if (!match) return value;
|
||
return `${match[1]}-${Number(match[2])}-${Number(match[3])}`;
|
||
}
|
||
|
||
function validateOperation(operation) {
|
||
return operationPlans.validateOperation(operation).blockers;
|
||
}
|
||
|
||
function summaryFromOperation(operation) {
|
||
const operationSummary = operationPlans.operationSummary(operation);
|
||
const data = operation.data || {};
|
||
const counts = data.passenger_counts || {};
|
||
const rooms = data.room_counts || {};
|
||
const prices = data.prices || {};
|
||
const passengerTotal = ['adult', 'child_bed', 'child_no_bed', 'infant', 'leader'].reduce((sum, key) => sum + toNumber(counts[key]), 0);
|
||
const roomTotal = ['SGL', 'TWN', 'TRP', 'DBL', 'HNM', 'TL'].reduce((sum, key) => sum + toNumber(rooms[key]), 0);
|
||
const amount = (toNumber(counts.adult) * toNumber(prices.adult))
|
||
+ (toNumber(counts.child_bed) * toNumber(prices.child_bed))
|
||
+ (toNumber(counts.child_no_bed) * toNumber(prices.child_no_bed))
|
||
+ (toNumber(counts.infant) * toNumber(prices.infant))
|
||
+ (toNumber(counts.leader) * toNumber(prices.leader));
|
||
return {
|
||
action: operationSummary.action,
|
||
operation_label: operationSummary.label,
|
||
route: operationSummary.route,
|
||
order_nature: operation.order_nature,
|
||
task_id: operation.source?.task_id || operation.task_id || '',
|
||
product: data.product?.name || '',
|
||
departure_date: data.departure_dates?.[0] || '',
|
||
test_marker: data.test_marker || '',
|
||
passenger_total: passengerTotal,
|
||
room_total: roomTotal,
|
||
receivable_amount_total: amount,
|
||
op_user: data.op_user?.name || '',
|
||
sales_user: data.sales_user?.name || ''
|
||
};
|
||
}
|
||
|
||
function erpReceiptFromReport(report) {
|
||
if (report?.erp_receipt) return report.erp_receipt;
|
||
const alerts = Array.isArray(report?.alerts) ? report.alerts : [];
|
||
return alerts.map((alert) => alert.erp_receipt).find(Boolean) || null;
|
||
}
|
||
|
||
function summarizeReportForBusiness(operation, stage, report) {
|
||
const status = report?.status || 'unknown';
|
||
const erpReceipt = erpReceiptFromReport(report);
|
||
return {
|
||
stage,
|
||
status,
|
||
reason: report?.reason || '',
|
||
blockers: Array.isArray(report?.blockers) ? report.blockers : [],
|
||
warnings: Array.isArray(report?.warnings) ? report.warnings : [],
|
||
operation_plan: report?.operation_plan || undefined,
|
||
no_erp_write: report?.no_erp_write,
|
||
write_attempted: report?.write_attempted === true,
|
||
test_marker: report?.test_markers?.suffix_marker || operation?.data?.test_marker || '',
|
||
payload_sha256: report?.current_payload?.payload_sha256
|
||
|| report?.final_form?.submit_payload_sha256
|
||
|| report?.submit_intercept?.intercepted_submits?.[0]?.payload_sha256
|
||
|| '',
|
||
lookup_checks: Array.isArray(report?.lookup_checks)
|
||
? report.lookup_checks.map((check) => ({
|
||
name: check.name,
|
||
exact_match_count: check.exact_match_count,
|
||
contains_match_count: check.contains_match_count,
|
||
match_rule: check.match_rule
|
||
}))
|
||
: [],
|
||
erp_response_summary: report?.ajax_records?.[0] ? {
|
||
success_hint: Boolean(report.ajax_records[0].response_contains_success_hint),
|
||
login_timeout: Boolean(report.ajax_records[0].response_contains_login_timeout),
|
||
permission_error: Boolean(report.ajax_records[0].response_contains_permission_text),
|
||
error_hint: Boolean(report.ajax_records[0].response_contains_error_hint)
|
||
} : undefined,
|
||
erp_receipt: erpReceipt || undefined,
|
||
verification: report?.response ? {
|
||
status,
|
||
marker_occurrences: report.response.marker_occurrences || 0,
|
||
login_timeout: Boolean(report.response.contains_login_timeout_text),
|
||
permission_error: Boolean(report.response.contains_permission_text)
|
||
} : undefined
|
||
};
|
||
}
|
||
|
||
function withStorageMutation(callback) {
|
||
const run = storageMutationQueue.then(callback, callback);
|
||
storageMutationQueue = run.then(() => undefined, () => undefined);
|
||
return run;
|
||
}
|
||
|
||
async function getExecutionRecord(taskId) {
|
||
const rootId = executionGuard.rootTaskId(taskId);
|
||
const saved = await chrome.storage.local.get('businessTaskExecutions');
|
||
return saved.businessTaskExecutions?.[rootId] || null;
|
||
}
|
||
|
||
async function acceptExecution(taskId, executionId, taskPayload) {
|
||
const rootId = executionGuard.rootTaskId(taskId);
|
||
return withStorageMutation(async () => {
|
||
const saved = await chrome.storage.local.get(['businessTaskExecutions', 'businessTaskResults', 'businessTasks']);
|
||
const executions = saved.businessTaskExecutions || {};
|
||
const results = saved.businessTaskResults || {};
|
||
const tasks = saved.businessTasks || {};
|
||
const existing = executions[rootId] || null;
|
||
const decision = executionGuard.acceptanceDecision(existing, executionId);
|
||
if (!decision.accepted) {
|
||
return {
|
||
ok: true,
|
||
accepted: false,
|
||
task_id: rootId,
|
||
execution_id: executionId,
|
||
status: decision.status,
|
||
message: decision.reason,
|
||
result: results[rootId] || null
|
||
};
|
||
}
|
||
const acceptedAt = nowIso();
|
||
executions[rootId] = {
|
||
task_id: rootId,
|
||
execution_id: executionId,
|
||
state: 'running',
|
||
accepted_at: acceptedAt,
|
||
updated_at: acceptedAt
|
||
};
|
||
const acceptedTask = {
|
||
...(taskPayload || {}),
|
||
task_id: rootId,
|
||
execution_id: executionId,
|
||
received_at: taskPayload?.received_at || acceptedAt
|
||
};
|
||
if (!acceptedTask.operation) {
|
||
throw new Error('唯一执行领取成功前缺少 task.operation，已停止执行。');
|
||
}
|
||
tasks[rootId] = acceptedTask;
|
||
results[rootId] = {
|
||
...(results[rootId] || {}),
|
||
task_id: rootId,
|
||
execution_id: executionId,
|
||
stage: 'auto_executor',
|
||
status: 'accepted',
|
||
updated_at: acceptedAt,
|
||
message: '后台自动执行器已取得唯一执行权。'
|
||
};
|
||
await chrome.storage.local.set({
|
||
businessTaskExecutions: executions,
|
||
businessTaskResults: results,
|
||
businessTasks: tasks,
|
||
currentBusinessTask: acceptedTask,
|
||
currentBusinessTaskId: rootId,
|
||
lastOperation: acceptedTask.operation,
|
||
lastRawText: JSON.stringify(acceptedTask.operation, null, 2)
|
||
});
|
||
return {
|
||
ok: true,
|
||
accepted: true,
|
||
task_id: rootId,
|
||
execution_id: executionId,
|
||
status: 'accepted',
|
||
message: '后台自动执行器已取得唯一执行权。'
|
||
};
|
||
});
|
||
}
|
||
|
||
async function setExecutionState(taskId, executionId, state, details = {}) {
|
||
const rootId = executionGuard.rootTaskId(taskId);
|
||
return withStorageMutation(async () => {
|
||
const saved = await chrome.storage.local.get('businessTaskExecutions');
|
||
const executions = saved.businessTaskExecutions || {};
|
||
const existing = executions[rootId] || null;
|
||
if (!executionGuard.canTransition(existing, executionId)) {
|
||
throw new Error(`任务 ${rootId} 的持久化执行闸门与当前执行编号不一致。`);
|
||
}
|
||
if (executionGuard.TERMINAL_STATES.has(existing.state) && existing.state !== state) {
|
||
return existing;
|
||
}
|
||
const updated = {
|
||
...existing,
|
||
...details,
|
||
state,
|
||
updated_at: nowIso()
|
||
};
|
||
executions[rootId] = updated;
|
||
await chrome.storage.local.set({ businessTaskExecutions: executions });
|
||
return updated;
|
||
});
|
||
}
|
||
|
||
async function transitionCurrentExecution(taskId, state, details = {}) {
|
||
const execution = await getExecutionRecord(taskId);
|
||
if (!execution?.execution_id) {
|
||
throw new Error(`任务 ${executionGuard.rootTaskId(taskId)} 没有持久化执行编号。`);
|
||
}
|
||
return setExecutionState(taskId, execution.execution_id, state, details);
|
||
}
|
||
|
||
async function setResult(taskId, result, { allowCancelled = false } = {}) {
|
||
if (!allowCancelled && isTaskCancelled(taskId)) return;
|
||
const rootId = executionGuard.rootTaskId(taskId);
|
||
return withStorageMutation(async () => {
|
||
const saved = await chrome.storage.local.get(['businessTaskResults', 'businessTaskExecutions']);
|
||
const resultMap = saved.businessTaskResults || {};
|
||
const executions = saved.businessTaskExecutions || {};
|
||
const existingResult = resultMap[taskId] || {};
|
||
const execution = executions[rootId] || null;
|
||
const executionId = result.execution_id || existingResult.execution_id || execution?.execution_id || '';
|
||
let nextResult = {
|
||
...existingResult,
|
||
...result,
|
||
task_id: taskId,
|
||
execution_id: executionId,
|
||
updated_at: nowIso()
|
||
};
|
||
const currentStatus = String(existingResult.status || '');
|
||
const nextStatus = String(nextResult.status || '');
|
||
const terminalResult = /^(completed|dry_run|blocked|cancelled|saved_unverified|execution_uncertain|reconciliation_pending)$/;
|
||
if (terminalResult.test(currentStatus) && currentStatus !== nextStatus) return existingResult;
|
||
|
||
if (taskId === rootId && execution && execution.execution_id === executionId) {
|
||
if (nextStatus === 'completed' || nextStatus === 'dry_run') {
|
||
executions[rootId] = { ...execution, state: 'completed', updated_at: nowIso() };
|
||
} else if (/uncertain|saved_unverified|reconciliation/.test(nextStatus)) {
|
||
executions[rootId] = { ...execution, state: 'uncertain', updated_at: nowIso() };
|
||
} else if (/blocked|failed|error|cancelled|incomplete/.test(nextStatus)) {
|
||
const failureState = executionGuard.failureState(execution);
|
||
executions[rootId] = { ...execution, state: failureState, updated_at: nowIso() };
|
||
if (failureState === 'uncertain') {
|
||
nextResult = {
|
||
...nextResult,
|
||
status: 'execution_uncertain',
|
||
execution_phase: execution.state,
|
||
write_attempted: true,
|
||
no_erp_write: false,
|
||
message: 'ERP 写入已发起但未取得确定回执，已停止执行且不会自动重试。'
|
||
};
|
||
}
|
||
}
|
||
}
|
||
resultMap[taskId] = nextResult;
|
||
await chrome.storage.local.set({
|
||
businessTaskResults: resultMap,
|
||
businessTaskExecutions: executions
|
||
});
|
||
return nextResult;
|
||
});
|
||
}
|
||
|
||
async function publish(taskId, operation, stage, report, extra = {}) {
|
||
const businessSummary = summarizeReportForBusiness(operation, stage, report || {});
|
||
await setResult(taskId, {
|
||
...businessSummary,
|
||
...extra,
|
||
report
|
||
});
|
||
}
|
||
|
||
async function failTask(taskId, operation, stage, message, blockers = []) {
|
||
await publish(taskId, operation, stage, {
|
||
status: 'auto_execution_blocked',
|
||
blockers: blockers.length ? blockers : [message]
|
||
}, {
|
||
status: 'blocked',
|
||
message,
|
||
blockers: blockers.length ? blockers : [message],
|
||
no_erp_write: true,
|
||
write_attempted: false
|
||
});
|
||
}
|
||
|
||
async function erpAutomationEnabled() {
|
||
const saved = await chrome.storage.local.get('erpAutomationEnabled');
|
||
return saved.erpAutomationEnabled !== false;
|
||
}
|
||
|
||
async function waitForTabLoad(tabId, timeoutMs = 20000, taskId = '') {
|
||
const deadline = Date.now() + timeoutMs;
|
||
while (Date.now() < deadline) {
|
||
throwIfTaskCancelled(taskId);
|
||
const tab = await chrome.tabs.get(tabId);
|
||
if (tab.status === 'complete') return tab;
|
||
await delay(500, taskId);
|
||
}
|
||
throwIfTaskCancelled(taskId);
|
||
return chrome.tabs.get(tabId);
|
||
}
|
||
|
||
async function findOrOpenErpTab(taskId = '') {
|
||
throwIfTaskCancelled(taskId);
|
||
const tabs = await chrome.tabs.query({ url: 'https://ltjt.yunzhi.run/*' });
|
||
const existing = tabs.find((tab) => /\/System\/Mainlt\.asp/i.test(tab.url || '')) || tabs[0];
|
||
if (existing?.id) return waitForTabLoad(existing.id, 20000, taskId);
|
||
throwIfTaskCancelled(taskId);
|
||
const tab = await chrome.tabs.create({
|
||
url: 'https://ltjt.yunzhi.run/System/Mainlt.asp',
|
||
active: false
|
||
});
|
||
return waitForTabLoad(tab.id, 20000, taskId);
|
||
}
|
||
|
||
async function injectBridgeIntoBusinessTabs() {
|
||
const tabs = await chrome.tabs.query({
|
||
url: [
|
||
'http://localhost/*',
|
||
'http://127.0.0.1/*'
|
||
]
|
||
});
|
||
for (const tab of tabs) {
|
||
if (!tab.id) continue;
|
||
if (!isBusinessSystemUrl(tab.url)) continue;
|
||
try {
|
||
await chrome.scripting.executeScript({
|
||
target: { tabId: tab.id },
|
||
files: ['business-bridge.js']
|
||
});
|
||
} catch (error) {
|
||
console.warn('LTJT bridge injection skipped', tab.id, error);
|
||
}
|
||
}
|
||
}
|
||
|
||
async function runPageAction(tabId, action, args = [], target = {}, taskId = '') {
|
||
throwIfTaskCancelled(taskId);
|
||
const scriptTarget = target.frameIds
|
||
? { tabId, frameIds: target.frameIds }
|
||
: { tabId, allFrames: Boolean(target.allFrames) };
|
||
await chrome.scripting.executeScript({
|
||
target: scriptTarget,
|
||
world: 'MAIN',
|
||
files: ['inpage.js']
|
||
});
|
||
const results = await chrome.scripting.executeScript({
|
||
target: scriptTarget,
|
||
world: 'MAIN',
|
||
func: async (actionName, actionArgs) => {
|
||
const assistant = window.LTJTOrderAssistant;
|
||
if (!assistant || typeof assistant[actionName] !== 'function') {
|
||
return { status: 'assistant_not_injected' };
|
||
}
|
||
return assistant[actionName](...(actionArgs || []));
|
||
},
|
||
args: [action, args]
|
||
});
|
||
throwIfTaskCancelled(taskId);
|
||
return results;
|
||
}
|
||
|
||
function pickResult(results, predicate) {
|
||
for (const item of results || []) {
|
||
if (predicate(item.result)) return item;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
async function openOrderForm(tabId, operation, taskId = '') {
|
||
const fabudanwei = operation?.data?.system_defaults?.fabudanwei || '老挝联泰';
|
||
const results = await runPageAction(tabId, 'openOrderForm', [{ fabudanwei }], { allFrames: false }, taskId);
|
||
const result = results[0]?.result;
|
||
if (!result || result.status !== 'order_form_open_requested') {
|
||
throw new Error(result?.blockers?.join('; ') || result?.status || '打开下单页失败。');
|
||
}
|
||
return result;
|
||
}
|
||
|
||
async function waitForOrderFrame(tabId, entryStamp, taskId = '') {
|
||
const deadline = Date.now() + 30000;
|
||
let lastResults = [];
|
||
while (Date.now() < deadline) {
|
||
throwIfTaskCancelled(taskId);
|
||
const results = await runPageAction(tabId, 'pingOrderFrame', [], { allFrames: true }, taskId);
|
||
lastResults = results;
|
||
const exact = pickResult(results, (result) => result?.status === 'order_frame_ready' && (!entryStamp || result.entry_stamp === entryStamp));
|
||
const visible = entryStamp ? null : pickResult(results, (result) => result?.status === 'order_frame_ready' && result.visible);
|
||
const anyReady = entryStamp ? null : pickResult(results, (result) => result?.status === 'order_frame_ready');
|
||
const selected = exact || visible || anyReady;
|
||
if (selected) return selected;
|
||
await delay(600, taskId);
|
||
}
|
||
throwIfTaskCancelled(taskId);
|
||
throw new Error(`未等到本次新打开的完整下单表单。entry_stamp=${entryStamp || '<none>'}；最近状态：${JSON.stringify(lastResults.map((item) => item.result).slice(0, 8))}`);
|
||
}
|
||
|
||
async function getTask(taskId) {
|
||
const saved = await chrome.storage.local.get(['businessTasks', 'currentBusinessTask', 'currentBusinessTaskId']);
|
||
const indexedTask = taskId ? saved.businessTasks?.[taskId] : null;
|
||
if (indexedTask?.operation) return indexedTask;
|
||
const task = saved.currentBusinessTask || null;
|
||
if (!task?.operation) throw new Error('没有找到待执行业务任务。');
|
||
if (taskId && task.task_id !== taskId) throw new Error(`当前任务 ${task.task_id} 与请求任务 ${taskId} 不一致。`);
|
||
return task;
|
||
}
|
||
|
||
async function publishOperationPlan(taskId, operation, plan) {
|
||
const publicPlan = operationPlans.publicPlan(plan);
|
||
const label = publicPlan.label || publicPlan.action || 'ERP 业务';
|
||
await publish(taskId, operation, 'capability_check', {
|
||
status: 'operation_plan_ready',
|
||
operation_plan: publicPlan,
|
||
blockers: publicPlan.blockers,
|
||
warnings: publicPlan.warnings,
|
||
no_erp_write: true,
|
||
}, {
|
||
status: 'dry_run',
|
||
reason: 'operation_not_connected',
|
||
message: `已识别${label}任务，当前完成规则校验和执行规划，暂未写入 ERP。`,
|
||
operation_plan: publicPlan,
|
||
no_erp_write: true,
|
||
next_step: publicPlan.fallback
|
||
? `后续接入 ${publicPlan.fallback} 浏览器执行路径。`
|
||
: '后续接入该业务的浏览器页面操作、提交和回查路径。',
|
||
});
|
||
return { ok: true, status: 'dry_run', task_id: taskId, operation_plan: publicPlan };
|
||
}
|
||
|
||
function selectReadOnlyProbeResult(results = []) {
|
||
const preferred = [
|
||
'login_required',
|
||
'erp_order_candidate_unique',
|
||
'erp_order_candidate_ambiguous',
|
||
'erp_order_candidate_not_found',
|
||
'split_parent_page_detected',
|
||
'split_child_page_detected',
|
||
'erp_page_mismatch',
|
||
];
|
||
for (const status of preferred) {
|
||
const match = (results || []).find((item) => item?.result?.status === status);
|
||
if (match) return match.result;
|
||
}
|
||
return (results || []).map((item) => item?.result).find(Boolean) || null;
|
||
}
|
||
|
||
async function executeReadOnlyOperationPlan(taskId, operation, operationPlan) {
|
||
throwIfTaskCancelled(taskId);
|
||
const publicPlan = operationPlans.publicPlan(operationPlan);
|
||
let browserProbe = null;
|
||
let probeError = '';
|
||
try {
|
||
const tab = await findOrOpenErpTab(taskId);
|
||
const results = await runPageAction(tab.id, 'inspectOperationContext', [operation], { allFrames: true }, taskId);
|
||
browserProbe = selectReadOnlyProbeResult(results);
|
||
} catch (error) {
|
||
if (error?.code === 'task_cancelled') throw error;
|
||
probeError = error.message || String(error);
|
||
}
|
||
|
||
const candidate = browserProbe?.candidates?.length === 1 ? browserProbe.candidates[0] : {};
|
||
const confirmationPlan = operation.action === 'confirmation_export'
|
||
? operationPlans.buildConfirmationExportPlan(operation, candidate)
|
||
: undefined;
|
||
const warnings = [...(operationPlan.warnings || [])];
|
||
if (probeError) warnings.push(`浏览器只读预检未完成：${probeError}`);
|
||
if (browserProbe?.status === 'login_required') warnings.push('ERP 当前需要人工登录；插件没有尝试绕过登录或验证码。');
|
||
if (browserProbe?.status === 'erp_page_mismatch') warnings.push('当前 ERP 标签页不是目标业务列表页；本次仅保留结构化计划。');
|
||
|
||
const report = {
|
||
status: 'operation_dry_run_completed',
|
||
reason: 'read_only_browser_probe',
|
||
operation_plan: publicPlan,
|
||
browser_probe: browserProbe || undefined,
|
||
confirmation_plan: confirmationPlan,
|
||
blockers: operationPlan.blockers || [],
|
||
warnings,
|
||
no_erp_write: true,
|
||
write_attempted: false,
|
||
};
|
||
await publish(taskId, operation, 'browser_dry_run', report, {
|
||
status: 'dry_run',
|
||
reason: probeError ? 'read_only_browser_probe_unavailable' : 'read_only_browser_probe',
|
||
message: `已完成${publicPlan.label || 'ERP 业务'}的业务校验和只读浏览器预检，未写入 ERP。`,
|
||
operation_plan: publicPlan,
|
||
browser_probe: browserProbe || undefined,
|
||
confirmation_plan: confirmationPlan,
|
||
no_erp_write: true,
|
||
warnings,
|
||
});
|
||
return {
|
||
ok: true,
|
||
status: 'dry_run',
|
||
task_id: taskId,
|
||
operation_plan: publicPlan,
|
||
browser_probe: browserProbe,
|
||
confirmation_plan: confirmationPlan,
|
||
};
|
||
}
|
||
|
||
function browserExecutionAction(execution) {
|
||
return {
|
||
browser_live_split_parent: 'createSplitParentLive',
|
||
browser_live_split_child: 'createSplitChildLive',
|
||
browser_export_source: 'exportConfirmationSources'
|
||
}[execution] || '';
|
||
}
|
||
|
||
function browserExecutionStatus(report = {}) {
|
||
if (/completed$/i.test(String(report.status || '')) || report.status === 'export_source_completed') return 'completed';
|
||
if (/uncertain/i.test(String(report.status || ''))) return 'execution_uncertain';
|
||
return 'blocked';
|
||
}
|
||
|
||
async function executeConnectedBrowserOperation(taskId, operation, operationPlan) {
|
||
throwIfTaskCancelled(taskId);
|
||
const publicPlan = operationPlans.publicPlan(operationPlan);
|
||
const action = browserExecutionAction(operationPlan.execution);
|
||
if (!action) return publishOperationPlan(taskId, operation, operationPlan);
|
||
await setResult(taskId, {
|
||
stage: 'browser_execution',
|
||
status: 'running',
|
||
message: `已通过规则校验，正在执行${publicPlan.label || 'ERP 浏览器操作'}。`,
|
||
operation_plan: publicPlan,
|
||
no_erp_write: publicPlan.no_erp_write,
|
||
summary: summaryFromOperation(operation)
|
||
});
|
||
let report;
|
||
try {
|
||
const tab = await findOrOpenErpTab(taskId);
|
||
if (publicPlan.no_erp_write === false) {
|
||
await transitionCurrentExecution(taskId, 'write_started', {
|
||
write_started_at: nowIso(),
|
||
current_task_id: taskId,
|
||
browser_action: action
|
||
});
|
||
}
|
||
const results = await runPageAction(tab.id, action, [operation], { allFrames: false }, taskId);
|
||
report = results.map((item) => item?.result).find((result) => result && result.status !== 'assistant_not_injected')
|
||
|| results[0]?.result
|
||
|| { status: 'browser_action_missing', blockers: ['浏览器执行器没有返回结果。'] };
|
||
} catch (error) {
|
||
if (error?.code === 'task_cancelled') throw error;
|
||
report = {
|
||
status: 'browser_execution_error',
|
||
blockers: [error.message || String(error)],
|
||
no_erp_write: publicPlan.no_erp_write
|
||
};
|
||
}
|
||
let finalStatus = browserExecutionStatus(report);
|
||
if (publicPlan.no_erp_write === false && finalStatus !== 'completed') {
|
||
finalStatus = 'execution_uncertain';
|
||
}
|
||
if (publicPlan.no_erp_write === false && finalStatus === 'completed') {
|
||
await transitionCurrentExecution(taskId, 'submitted', {
|
||
submitted_at: nowIso(),
|
||
current_task_id: taskId,
|
||
erp_receipt: report.erp_receipt || undefined
|
||
});
|
||
}
|
||
const warnings = [...(operationPlan.warnings || []), ...(Array.isArray(report.warnings) ? report.warnings : [])];
|
||
const message = finalStatus === 'completed'
|
||
? (report.no_erp_write
|
||
? `${publicPlan.label || 'ERP 导出'}源文件回执已确认；未重保存订单，浏览器未将文件落盘状态误报为已交付。`
|
||
: `${publicPlan.label || 'ERP 业务'}已提交并完成回查。`)
|
||
: (finalStatus === 'execution_uncertain'
|
||
? `${publicPlan.label || 'ERP 业务'}已发起但回执不确定，已停止，不会自动重试。`
|
||
: `${publicPlan.label || 'ERP 业务'}未完成，已停止后续写入。`);
|
||
await publish(taskId, operation, 'browser_execution', {
|
||
...report,
|
||
operation_plan: publicPlan,
|
||
warnings,
|
||
no_erp_write: publicPlan.no_erp_write === true,
|
||
write_attempted: publicPlan.no_erp_write === false
|
||
}, {
|
||
status: finalStatus,
|
||
message,
|
||
operation_plan: publicPlan,
|
||
no_erp_write: publicPlan.no_erp_write === true,
|
||
erp_receipt: report.erp_receipt,
|
||
execution_phase: publicPlan.no_erp_write === false ? (finalStatus === 'completed' ? 'submitted' : 'write_started') : 'read_only',
|
||
write_attempted: publicPlan.no_erp_write === false,
|
||
warnings,
|
||
blockers: report.blockers || []
|
||
});
|
||
return {
|
||
ok: finalStatus === 'completed',
|
||
status: finalStatus,
|
||
task_id: taskId,
|
||
operation_plan: publicPlan,
|
||
report
|
||
};
|
||
}
|
||
|
||
async function executeTeamSingleTask(taskId, operation, options = {}) {
|
||
throwIfTaskCancelled(taskId);
|
||
const batchLabel = options.batchIndex
|
||
? `批量 fallback 第 ${options.batchIndex}/${options.batchTotal} 个日期：`
|
||
: '';
|
||
|
||
await setResult(taskId, {
|
||
stage: 'queued',
|
||
status: 'running',
|
||
message: `${batchLabel}自动执行器已接单，正在寻找已登录 ERP 页面。`,
|
||
summary: summaryFromOperation(operation)
|
||
});
|
||
|
||
const tab = await findOrOpenErpTab(taskId);
|
||
await setResult(taskId, {
|
||
stage: 'open_order_form',
|
||
status: 'running',
|
||
message: `${batchLabel}已找到 ERP 页面，正在打开团队下单表单。`
|
||
});
|
||
const opened = await openOrderForm(tab.id, operation, taskId);
|
||
|
||
await setResult(taskId, {
|
||
stage: 'wait_order_form',
|
||
status: 'running',
|
||
message: `${batchLabel}正在等待 ERP 下单表单加载完成。`,
|
||
open: opened
|
||
});
|
||
const frame = await waitForOrderFrame(tab.id, opened.entry_stamp, taskId);
|
||
await chrome.storage.local.set({ lastFrameId: frame.frameId });
|
||
|
||
await setResult(taskId, {
|
||
stage: 'preflight',
|
||
status: 'running',
|
||
message: `${batchLabel}正在校验选择项、触发产品联动并拦截提交载荷。`
|
||
});
|
||
const preflightResults = await runPageAction(tab.id, 'preflightRawInstruction', [operation, { interceptSubmit: true }], { frameIds: [frame.frameId] }, taskId);
|
||
const preflight = preflightResults[0]?.result || { status: 'missing_result', blockers: ['预检没有返回结果。'] };
|
||
await chrome.storage.local.set({ lastPreflight: preflight });
|
||
await publish(taskId, operation, 'preflight', preflight, {
|
||
status: preflight.status === 'raw_instruction_test_passed' ? 'running' : 'blocked',
|
||
message: preflight.status === 'raw_instruction_test_passed'
|
||
? `${batchLabel}预检通过，准备自动真实保存测试订单。`
|
||
: `${batchLabel}预检阻断，未保存。`
|
||
});
|
||
if (preflight.status !== 'raw_instruction_test_passed') {
|
||
return { ok: false, status: 'preflight_blocked', task_id: taskId, blockers: preflight.blockers || [] };
|
||
}
|
||
|
||
const intercepted = preflight.submit_intercept?.intercepted_submits?.[0];
|
||
if (preflight.submit_intercept?.status !== 'submit_intercept_captured' || !intercepted?.payload_sha256) {
|
||
await failTask(taskId, operation, 'preflight', `${batchLabel}预检未拿到可批准的提交哈希，未保存。`, ['submit_intercept_missing_or_invalid']);
|
||
return { ok: false, status: 'submit_intercept_missing', task_id: taskId };
|
||
}
|
||
|
||
await setResult(taskId, {
|
||
stage: 'live_submit',
|
||
status: 'running',
|
||
message: `${batchLabel}提交哈希已校验，正在自动真实保存测试订单。`
|
||
});
|
||
throwIfTaskCancelled(taskId);
|
||
await transitionCurrentExecution(taskId, 'write_started', {
|
||
write_started_at: nowIso(),
|
||
current_task_id: taskId,
|
||
payload_sha256: intercepted.payload_sha256
|
||
});
|
||
const liveSubmitResults = await runPageAction(tab.id, 'liveSubmitApproved', [{
|
||
expectedPayloadSha256: intercepted.payload_sha256,
|
||
expectedFieldCount: intercepted.payload_summary?.field_count || preflight.final_form?.serialized_field_count || 0
|
||
}], { frameIds: [frame.frameId] }, taskId);
|
||
const liveSubmit = liveSubmitResults[0]?.result || { status: 'missing_result', blockers: ['真实保存没有返回结果。'] };
|
||
const erpReceipt = erpReceiptFromReport(liveSubmit);
|
||
await chrome.storage.local.set({ lastLiveSubmit: liveSubmit });
|
||
if (liveSubmit.status === 'live_submit_completed') {
|
||
await transitionCurrentExecution(taskId, 'submitted', {
|
||
submitted_at: nowIso(),
|
||
current_task_id: taskId,
|
||
erp_receipt: erpReceipt || undefined
|
||
});
|
||
}
|
||
await publish(taskId, operation, 'live_submit', liveSubmit, {
|
||
status: liveSubmit.status === 'live_submit_completed' ? 'running' : 'execution_uncertain',
|
||
message: erpReceipt?.group_number
|
||
? `${batchLabel}ERP 已返回保存回执，团号：${erpReceipt.group_number}。正在回查测试标记。`
|
||
: (liveSubmit.status === 'live_submit_completed' ? `${batchLabel}ERP 已返回保存完成，正在回查测试标记。` : `${batchLabel}ERP 保存失败或状态不确定。`),
|
||
erp_receipt: erpReceipt || undefined,
|
||
execution_phase: liveSubmit.status === 'live_submit_completed' ? 'submitted' : 'write_started',
|
||
write_attempted: true
|
||
});
|
||
if (liveSubmit.status !== 'live_submit_completed') {
|
||
return { ok: false, status: 'live_submit_blocked', task_id: taskId, blockers: liveSubmit.blockers || [] };
|
||
}
|
||
|
||
await setResult(taskId, {
|
||
stage: 'verification',
|
||
status: 'running',
|
||
message: `${batchLabel}正在按测试标记回查订单。`
|
||
});
|
||
const marker = operation.data?.test_marker;
|
||
const date = operation.data?.departure_dates?.[0];
|
||
const verifyResults = await runPageAction(tab.id, 'verifyOrderMarker', [{ marker, dateFrom: date, dateTo: date }], { allFrames: false }, taskId);
|
||
const verification = verifyResults[0]?.result || { status: 'missing_result', blockers: ['回查没有返回结果。'] };
|
||
await chrome.storage.local.set({ lastVerification: verification });
|
||
let returnToList = null;
|
||
if (verification.status === 'order_marker_found') {
|
||
const returnResults = await runPageAction(tab.id, 'returnToOrderList', [{
|
||
marker,
|
||
dateFrom: date,
|
||
dateTo: date
|
||
}], { frameIds: [frame.frameId] }, taskId);
|
||
returnToList = returnResults[0]?.result || null;
|
||
await chrome.storage.local.set({ lastReturnToOrderList: returnToList });
|
||
}
|
||
await publish(taskId, operation, 'verification', verification, {
|
||
status: verification.status === 'order_marker_found' ? 'completed' : 'saved_unverified',
|
||
message: erpReceipt?.group_number
|
||
? `${batchLabel}测试订单已保存，团号：${erpReceipt.group_number}。${verification.status === 'order_marker_found' ? '回查已命中。' : '回查暂未命中。'}`
|
||
: (verification.status === 'order_marker_found' ? `${batchLabel}测试订单已保存并回查命中。` : `${batchLabel}测试订单已提交，但回查暂未命中。`),
|
||
erp_receipt: erpReceipt || undefined,
|
||
return_to_order_list: returnToList
|
||
});
|
||
return {
|
||
ok: verification.status === 'order_marker_found',
|
||
status: verification.status === 'order_marker_found' ? 'completed' : 'saved_unverified',
|
||
task_id: taskId,
|
||
erp_receipt: erpReceipt || undefined,
|
||
};
|
||
}
|
||
|
||
async function runAutoTask(taskId, executionId) {
|
||
const rootId = executionGuard.rootTaskId(taskId);
|
||
if (isTaskCancelled(taskId)) {
|
||
return { ok: false, status: 'cancelled', task_id: taskId };
|
||
}
|
||
let operation = null;
|
||
try {
|
||
const durableExecution = await getExecutionRecord(rootId);
|
||
if (!executionGuard.canTransition(durableExecution, executionId) || durableExecution.state !== 'running') {
|
||
return { ok: false, status: 'duplicate_blocked', task_id: rootId };
|
||
}
|
||
throwIfTaskCancelled(taskId);
|
||
const task = await getTask(taskId);
|
||
if (String(task.execution_id || '') !== String(executionId || '')) {
|
||
throw new Error('任务载荷与持久化执行编号不一致。');
|
||
}
|
||
throwIfTaskCancelled(taskId);
|
||
operation = operationPlans.normalizeOperation(task.operation);
|
||
const normalizedTaskId = task.task_id || operation.source?.task_id || taskId;
|
||
if (!(await erpAutomationEnabled())) {
|
||
throwIfTaskCancelled(normalizedTaskId);
|
||
await publish(normalizedTaskId, operation, 'automation_disabled', {
|
||
status: 'erp_automation_disabled',
|
||
blockers: ['插件已关闭 ERP 操作。'],
|
||
no_erp_write: true,
|
||
write_attempted: false
|
||
}, {
|
||
status: 'blocked',
|
||
message: '插件已关闭 ERP 操作，未打开或填写 ERP。',
|
||
blockers: ['插件开关处于关闭状态。'],
|
||
no_erp_write: true,
|
||
write_attempted: false
|
||
});
|
||
return { ok: false, status: 'automation_disabled', task_id: normalizedTaskId };
|
||
}
|
||
const operationPlan = operationPlans.validateOperation(operation);
|
||
throwIfTaskCancelled(normalizedTaskId);
|
||
const blockers = operationPlan.blockers;
|
||
if (blockers.length) {
|
||
await failTask(normalizedTaskId, operation, 'validation', '任务未通过自动执行安全校验。', blockers);
|
||
return { ok: false, status: 'validation_blocked', blockers };
|
||
}
|
||
|
||
if (operationPlan.execution === 'browser_team_single_fallback') {
|
||
const expanded = operationPlans.expandTeamBatch(operation);
|
||
const batchResults = [];
|
||
throwIfTaskCancelled(normalizedTaskId);
|
||
await setResult(normalizedTaskId, {
|
||
stage: 'batch_fallback',
|
||
status: 'running',
|
||
message: `原生批量接口未启用，将按日期串行复用 team_single：共 ${expanded.length} 个日期。`,
|
||
operation_plan: operationPlans.publicPlan(operationPlan),
|
||
no_erp_write: false,
|
||
});
|
||
for (let index = 0; index < expanded.length; index += 1) {
|
||
throwIfTaskCancelled(normalizedTaskId);
|
||
const childTaskId = `${normalizedTaskId}#${index + 1}`;
|
||
const childOperation = expanded[index];
|
||
try {
|
||
const childResult = await executeTeamSingleTask(childTaskId, childOperation, {
|
||
batchIndex: index + 1,
|
||
batchTotal: expanded.length,
|
||
});
|
||
batchResults.push({
|
||
task_id: childTaskId,
|
||
date: childOperation.data?.departure_dates?.[0] || '',
|
||
status: childResult.status,
|
||
erp_receipt: childResult.erp_receipt,
|
||
});
|
||
if (childResult.status !== 'completed') {
|
||
await publish(normalizedTaskId, operation, 'batch_fallback', {
|
||
status: 'batch_fallback_incomplete',
|
||
operation_plan: operationPlans.publicPlan(operationPlan),
|
||
blockers: childResult.blockers || ['批量 fallback 中某个日期未完成回查。'],
|
||
no_erp_write: false,
|
||
}, {
|
||
status: childResult.status === 'saved_unverified' ? 'saved_unverified' : 'blocked',
|
||
message: `批量 fallback 已停止在第 ${index + 1} 个日期，未继续后续日期。`,
|
||
batch_results: batchResults,
|
||
no_erp_write: false,
|
||
});
|
||
return { ok: false, status: 'batch_fallback_incomplete', task_id: normalizedTaskId, batch_results: batchResults };
|
||
}
|
||
} catch (error) {
|
||
if (error?.code === 'task_cancelled') {
|
||
await setResult(normalizedTaskId, {
|
||
stage: 'cancelled',
|
||
status: 'cancelled',
|
||
message: '批量任务已取消，已停止后续日期。'
|
||
});
|
||
return { ok: false, status: 'cancelled', task_id: normalizedTaskId, batch_results: batchResults };
|
||
}
|
||
await failTask(childTaskId, childOperation, 'batch_fallback_error', error.message || String(error));
|
||
batchResults.push({
|
||
task_id: childTaskId,
|
||
date: childOperation.data?.departure_dates?.[0] || '',
|
||
status: 'blocked',
|
||
error: error.message || String(error),
|
||
});
|
||
await publish(normalizedTaskId, operation, 'batch_fallback', {
|
||
status: 'batch_fallback_incomplete',
|
||
operation_plan: operationPlans.publicPlan(operationPlan),
|
||
blockers: [error.message || String(error)],
|
||
no_erp_write: false,
|
||
}, {
|
||
status: 'blocked',
|
||
message: `批量 fallback 在第 ${index + 1} 个日期发生异常，已停止后续日期。`,
|
||
batch_results: batchResults,
|
||
no_erp_write: false,
|
||
});
|
||
return { ok: false, status: 'batch_fallback_incomplete', task_id: normalizedTaskId, batch_results: batchResults };
|
||
}
|
||
}
|
||
await publish(normalizedTaskId, operation, 'batch_fallback', {
|
||
status: 'batch_fallback_completed',
|
||
operation_plan: operationPlans.publicPlan(operationPlan),
|
||
warnings: operationPlan.warnings,
|
||
no_erp_write: false,
|
||
}, {
|
||
status: 'completed',
|
||
message: `批量 fallback 已按 ${batchResults.length} 个日期逐个完成并回查。`,
|
||
batch_results: batchResults,
|
||
no_erp_write: false,
|
||
});
|
||
return { ok: true, status: 'completed', task_id: normalizedTaskId, batch_results: batchResults };
|
||
}
|
||
|
||
if (['browser_live_split_parent', 'browser_live_split_child', 'browser_export_source'].includes(operationPlan.execution)) {
|
||
return executeConnectedBrowserOperation(normalizedTaskId, operation, operationPlan);
|
||
}
|
||
if (operationPlan.execution === 'browser_dry_run') {
|
||
return executeReadOnlyOperationPlan(normalizedTaskId, operation, operationPlan);
|
||
}
|
||
if (operationPlan.execution !== 'browser_team_single') {
|
||
return publishOperationPlan(normalizedTaskId, operation, operationPlan);
|
||
}
|
||
return executeTeamSingleTask(normalizedTaskId, operation);
|
||
} catch (error) {
|
||
if (error?.code === 'task_cancelled') {
|
||
await setResult(taskId, {
|
||
stage: 'cancelled',
|
||
status: 'cancelled',
|
||
message: '任务已取消，已停止后续自动执行。'
|
||
});
|
||
return { ok: false, status: 'cancelled', task_id: taskId };
|
||
}
|
||
await failTask(taskId, operation, 'extension_error', error.message || String(error));
|
||
return { ok: false, status: 'extension_error', task_id: taskId, message: error.message || String(error) };
|
||
} finally {
|
||
runningTasks.delete(rootId);
|
||
}
|
||
}
|
||
|
||
async function cancelAutoTask(taskId) {
|
||
const normalizedTaskId = String(taskId || '').trim();
|
||
if (!normalizedTaskId) {
|
||
return { ok: false, status: 'cancel_failed', message: '缺少 task_id。' };
|
||
}
|
||
const execution = await getExecutionRecord(normalizedTaskId);
|
||
if (execution && executionGuard.WRITE_STATES.has(execution.state)) {
|
||
await setResult(normalizedTaskId, {
|
||
stage: 'reconciliation',
|
||
status: 'execution_uncertain',
|
||
execution_phase: execution.state,
|
||
write_attempted: true,
|
||
no_erp_write: false,
|
||
message: 'ERP 写入已开始，取消不能作为回滚；任务已保留并等待人工回查。'
|
||
}, { allowCancelled: true });
|
||
return {
|
||
ok: false,
|
||
status: 'cancel_blocked_after_write',
|
||
task_id: normalizedTaskId,
|
||
cancelled: false,
|
||
message: 'ERP 写入已开始，不能通过删除或取消回滚。'
|
||
};
|
||
}
|
||
cancelledTasks.add(normalizedTaskId);
|
||
const running = Array.from(runningTasks).some((runningTaskId) => (
|
||
runningTaskId === normalizedTaskId || taskRootId(runningTaskId) === normalizedTaskId
|
||
));
|
||
await setResult(normalizedTaskId, {
|
||
stage: 'cancelled',
|
||
status: 'cancelled',
|
||
message: running ? '已收到取消请求，正在停止后续自动执行。' : '任务已取消，未继续自动执行。'
|
||
}, { allowCancelled: true });
|
||
if (execution?.execution_id) {
|
||
await setExecutionState(normalizedTaskId, execution.execution_id, 'cancelled', {
|
||
cancelled_at: nowIso()
|
||
});
|
||
}
|
||
return {
|
||
ok: true,
|
||
status: 'cancelled',
|
||
task_id: normalizedTaskId,
|
||
cancelled: true,
|
||
running
|
||
};
|
||
}
|
||
|
||
chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
|
||
if (message?.type === 'LTJT_CANCEL_TASK') {
|
||
cancelAutoTask(message.task_id || '')
|
||
.then((result) => sendResponse(result))
|
||
.catch((error) => sendResponse({
|
||
ok: false,
|
||
status: 'cancel_failed',
|
||
message: error.message || String(error)
|
||
}));
|
||
return true;
|
||
}
|
||
if (message?.type !== 'LTJT_AUTO_EXECUTE_TASK') return false;
|
||
const taskId = message.task_id || '';
|
||
const executionId = message.execution_id || '';
|
||
acceptExecution(taskId, executionId, message.task)
|
||
.then((acceptance) => {
|
||
if (acceptance.accepted) {
|
||
runningTasks.add(executionGuard.rootTaskId(taskId));
|
||
runAutoTask(taskId, executionId).catch((error) => {
|
||
console.error('LTJT auto task failed', error);
|
||
});
|
||
}
|
||
sendResponse(acceptance);
|
||
})
|
||
.catch((error) => sendResponse({
|
||
ok: false,
|
||
accepted: false,
|
||
task_id: taskId,
|
||
execution_id: executionId,
|
||
status: 'execution_guard_error',
|
||
message: error.message || String(error)
|
||
}));
|
||
return true;
|
||
});
|
||
|
||
chrome.runtime.onInstalled.addListener(() => {
|
||
injectBridgeIntoBusinessTabs().catch((error) => {
|
||
console.warn('LTJT bridge injection failed after install', error);
|
||
});
|
||
});
|
||
|
||
chrome.runtime.onStartup.addListener(() => {
|
||
injectBridgeIntoBusinessTabs().catch((error) => {
|
||
console.warn('LTJT bridge injection failed after startup', error);
|
||
});
|
||
});
|