郎速科技
409 lines
16 KiB
JavaScript
409 lines
16 KiB
JavaScript
(function (root, factory) {
|
|
const api = factory();
|
|
if (typeof module === "object" && module.exports) module.exports = api;
|
|
if (root) root.LskjBridgeClient = api;
|
|
})(typeof globalThis !== "undefined" ? globalThis : this, function () {
|
|
"use strict";
|
|
|
|
const PROTOCOL_VERSION = "1.0";
|
|
const SAFE_IDENTIFIER = /^[A-Za-z0-9_.:-]{8,128}$/;
|
|
const SAFE_CODE = /^[A-Za-z0-9_.:-]{1,128}$/;
|
|
const SAFE_COMMAND = /^[A-Za-z0-9_.:-]{1,128}$/;
|
|
const SAFE_PLAN_ID = /^[A-Fa-f0-9]{32}$/;
|
|
const RESPONSE_FIELDS = new Set([
|
|
"protocolVersion", "requestId", "correlationId", "success", "code", "message", "data"
|
|
]);
|
|
const REQUIRED_RESPONSE_FIELDS = [
|
|
"protocolVersion", "requestId", "correlationId", "success", "code", "data"
|
|
];
|
|
const METHODS = new Set([
|
|
"health", "capabilities.list", "context.get", "command.plan", "command.execute"
|
|
]);
|
|
const RECOVERY_ACTIONS = new Set([
|
|
"review_and_retry",
|
|
"reconcile_execution",
|
|
"restart_erp_pet",
|
|
"inspect_existing_record",
|
|
"replan",
|
|
"correct_request",
|
|
"contact_administrator",
|
|
"wait_and_retry",
|
|
"contact_support"
|
|
]);
|
|
const EXECUTE_DATA_FIELDS = ["result", "followupPlan", "followupCode"];
|
|
const EXECUTE_RESULT_FIELDS = [
|
|
"success", "code", "message", "recordId", "replayed", "data"
|
|
];
|
|
const DIAGNOSTIC_DATA_FIELDS = [
|
|
"diagnosticContextSchemaVersion", "diagnosticId", "correlationId",
|
|
"evidencePersisted", "evidenceContentHash", "outcome",
|
|
"primaryFindingCode", "moduleOpenSucceeded", "eventCount",
|
|
"failedEventCount", "slowEventCount", "traceTruncated",
|
|
"summaryTruncated", "findings", "staticDiagnosis", "contextAvailable"
|
|
];
|
|
const DIAGNOSTIC_FINDING_FIELDS = [
|
|
"severity", "code", "category", "stage", "confidence", "message",
|
|
"recommendation", "occurrenceCount", "sqlFingerprint", "caller"
|
|
];
|
|
const STATIC_DIAGNOSIS_FIELDS = [
|
|
"moduleCode", "moduleKind", "healthy", "issueCount", "issues"
|
|
];
|
|
const STATIC_ISSUE_FIELDS = ["severity", "code", "source"];
|
|
const SAFE_HASH = /^[a-f0-9]{64}$/;
|
|
const SAFE_DIAGNOSTIC_ID = /^diag-[A-Fa-f0-9]{32}$/;
|
|
const SAFE_CALLER = /^caller_(?:[0-9]{4}|overflow)$/;
|
|
|
|
function createId() {
|
|
if (globalThis.crypto && typeof globalThis.crypto.randomUUID === "function") {
|
|
return globalThis.crypto.randomUUID().replace(/-/g, "");
|
|
}
|
|
return "id" + Date.now().toString(36) + Math.random().toString(36).slice(2);
|
|
}
|
|
|
|
class WebViewTransport {
|
|
constructor(webview, timeoutMs) {
|
|
if (!webview || typeof webview.postMessage !== "function") {
|
|
throw new TypeError("WebView2 transport is unavailable.");
|
|
}
|
|
this.webview = webview;
|
|
// 写操作需要用户阅读预览并在 ERP 原生窗口再次确认，默认保留 3 分钟。
|
|
this.timeoutMs = timeoutMs || 180000;
|
|
this.pending = new Map();
|
|
this.onMessage = this.onMessage.bind(this);
|
|
this.webview.addEventListener("message", this.onMessage);
|
|
}
|
|
|
|
send(request) {
|
|
return new Promise((resolve, reject) => {
|
|
if (this.pending.has(request.requestId)) {
|
|
reject(protocolError("ERP 桥请求 ID 重复。"));
|
|
return;
|
|
}
|
|
const timer = setTimeout(() => {
|
|
this.pending.delete(request.requestId);
|
|
reject(clientError("bridge_timeout", "ERP 命令桥响应超时。"));
|
|
}, this.timeoutMs);
|
|
this.pending.set(request.requestId, { resolve, reject, timer });
|
|
this.webview.postMessage({ type: "lserp.bridge.request", request });
|
|
});
|
|
}
|
|
|
|
onMessage(event) {
|
|
const envelope = event && event.data;
|
|
if (!envelope || envelope.type !== "lserp.bridge.response" || !envelope.response) return;
|
|
const response = envelope.response;
|
|
const waiter = this.pending.get(response.requestId);
|
|
if (!waiter) return;
|
|
clearTimeout(waiter.timer);
|
|
this.pending.delete(response.requestId);
|
|
waiter.resolve(response);
|
|
}
|
|
|
|
dispose() {
|
|
this.webview.removeEventListener("message", this.onMessage);
|
|
this.pending.forEach(waiter => {
|
|
clearTimeout(waiter.timer);
|
|
waiter.reject(clientError("bridge_closed", "ERP 命令桥已关闭。"));
|
|
});
|
|
this.pending.clear();
|
|
}
|
|
}
|
|
|
|
class BridgeClient {
|
|
constructor(transport, options) {
|
|
if (!transport || typeof transport.send !== "function") {
|
|
throw new TypeError("A bridge transport is required.");
|
|
}
|
|
const settings = options || {};
|
|
this.transport = transport;
|
|
this.clientSessionId = settings.clientSessionId || createId();
|
|
if (typeof this.clientSessionId !== "string" || !SAFE_IDENTIFIER.test(this.clientSessionId)) {
|
|
throw new TypeError("clientSessionId has an invalid format.");
|
|
}
|
|
this.idempotencyByPlan = new Map();
|
|
}
|
|
|
|
async request(method, payload, correlationId) {
|
|
validateRequest(method, payload);
|
|
const trustedCorrelationId = correlationId === undefined || correlationId === null
|
|
? createId()
|
|
: correlationId;
|
|
if (typeof trustedCorrelationId !== "string"
|
|
|| !SAFE_IDENTIFIER.test(trustedCorrelationId)) {
|
|
throw protocolError("ERP 桥关联 ID 格式无效。");
|
|
}
|
|
const request = {
|
|
protocolVersion: PROTOCOL_VERSION,
|
|
requestId: createId(),
|
|
correlationId: trustedCorrelationId,
|
|
clientSessionId: this.clientSessionId,
|
|
method,
|
|
payload: payload === undefined || payload === null ? {} : payload
|
|
};
|
|
const response = validateResponse(await this.transport.send(request), request);
|
|
if (response.success !== true) {
|
|
const error = new Error(response.message || "ERP 命令执行失败。");
|
|
error.code = response.code;
|
|
error.response = response;
|
|
throw error;
|
|
}
|
|
return response.data;
|
|
}
|
|
|
|
health() {
|
|
return this.request("health");
|
|
}
|
|
|
|
context() {
|
|
return this.request("context.get");
|
|
}
|
|
|
|
capabilities() {
|
|
return this.request("capabilities.list");
|
|
}
|
|
|
|
plan(command, input) {
|
|
return this.request("command.plan", {
|
|
command,
|
|
input: input === undefined || input === null ? {} : input
|
|
});
|
|
}
|
|
|
|
async execute(planId, bridgeCorrelationId) {
|
|
if (typeof planId !== "string" || !SAFE_PLAN_ID.test(planId)
|
|
|| typeof bridgeCorrelationId !== "string"
|
|
|| !SAFE_IDENTIFIER.test(bridgeCorrelationId)) {
|
|
throw protocolError("ERP 执行请求格式无效。");
|
|
}
|
|
let key = this.idempotencyByPlan.get(planId);
|
|
if (!key) {
|
|
key = createId();
|
|
this.idempotencyByPlan.set(planId, key);
|
|
}
|
|
const data = await this.request(
|
|
"command.execute",
|
|
{ planId, idempotencyKey: key },
|
|
bridgeCorrelationId);
|
|
validateExecuteData(data, bridgeCorrelationId);
|
|
const projected = Object.assign({}, data, { bridgeCorrelationId });
|
|
if (isObject(data.followupPlan)) {
|
|
projected.followupPlan = Object.assign(
|
|
{}, data.followupPlan, { bridgeCorrelationId });
|
|
}
|
|
return projected;
|
|
}
|
|
}
|
|
|
|
function validateRequest(method, payload) {
|
|
if (!METHODS.has(method)) throw protocolError("ERP 桥方法不受支持。");
|
|
const value = payload === undefined || payload === null ? {} : payload;
|
|
if (!isObject(value)) throw protocolError("ERP 桥 payload 必须是对象。");
|
|
const fields = Object.keys(value);
|
|
if (method === "health" || method === "capabilities.list" || method === "context.get") {
|
|
if (fields.length !== 0) throw protocolError("该 ERP 桥方法不接受 payload 字段。");
|
|
return;
|
|
}
|
|
if (method === "command.plan") {
|
|
if (!hasExactFields(fields, ["command", "input"])
|
|
|| typeof value.command !== "string"
|
|
|| !SAFE_COMMAND.test(value.command)
|
|
|| !isObject(value.input)) {
|
|
throw protocolError("ERP 计划请求格式无效。");
|
|
}
|
|
return;
|
|
}
|
|
if (!hasExactFields(fields, ["planId", "idempotencyKey"])
|
|
|| typeof value.planId !== "string"
|
|
|| !SAFE_PLAN_ID.test(value.planId)
|
|
|| typeof value.idempotencyKey !== "string"
|
|
|| !SAFE_IDENTIFIER.test(value.idempotencyKey)) {
|
|
throw protocolError("ERP 执行请求格式无效。");
|
|
}
|
|
}
|
|
|
|
function validateResponse(response, request) {
|
|
if (!isObject(response)) throw protocolError("ERP 桥响应必须是对象。");
|
|
const fields = Object.keys(response);
|
|
if (fields.some(field => !RESPONSE_FIELDS.has(field))
|
|
|| REQUIRED_RESPONSE_FIELDS.some(field => !fields.includes(field))
|
|
|| response.protocolVersion !== PROTOCOL_VERSION
|
|
|| typeof response.requestId !== "string"
|
|
|| !SAFE_IDENTIFIER.test(response.requestId)
|
|
|| response.requestId !== request.requestId
|
|
|| typeof response.correlationId !== "string"
|
|
|| !SAFE_IDENTIFIER.test(response.correlationId)
|
|
|| response.correlationId !== request.correlationId
|
|
|| typeof response.success !== "boolean"
|
|
|| typeof response.code !== "string"
|
|
|| !SAFE_CODE.test(response.code)
|
|
|| !isObject(response.data)
|
|
|| (response.message !== undefined
|
|
&& response.message !== null
|
|
&& typeof response.message !== "string")
|
|
|| (typeof response.message === "string" && response.message.length > 2000)) {
|
|
throw protocolError("ERP 桥返回了无效或不匹配的协议消息。");
|
|
}
|
|
if (response.success === false) validateErrorRecovery(response);
|
|
return response;
|
|
}
|
|
|
|
function validateErrorRecovery(response) {
|
|
if (typeof response.message !== "string"
|
|
|| !safeDisplayText(response.message, 1, 2000)
|
|
|| !hasExactFields(Object.keys(response.data), ["recovery"])
|
|
|| !isObject(response.data.recovery)) {
|
|
throw protocolError("ERP 桥错误恢复契约无效。");
|
|
}
|
|
const recovery = response.data.recovery;
|
|
if (!hasExactFields(
|
|
Object.keys(recovery),
|
|
["action", "retryable", "planInvalidated", "message"])
|
|
|| typeof recovery.action !== "string"
|
|
|| !RECOVERY_ACTIONS.has(recovery.action)
|
|
|| typeof recovery.retryable !== "boolean"
|
|
|| typeof recovery.planInvalidated !== "boolean"
|
|
|| typeof recovery.message !== "string"
|
|
|| !safeDisplayText(recovery.message, 1, 300)) {
|
|
throw protocolError("ERP 桥错误恢复契约无效。");
|
|
}
|
|
}
|
|
|
|
function validateExecuteData(data, expectedCorrelationId) {
|
|
if (!isObject(data)
|
|
|| !hasExactFields(Object.keys(data), EXECUTE_DATA_FIELDS)
|
|
|| !isObject(data.result)
|
|
|| !hasExactFields(Object.keys(data.result), EXECUTE_RESULT_FIELDS)) {
|
|
throw protocolError("ERP 执行成功回执契约无效。");
|
|
}
|
|
const result = data.result;
|
|
if (result.success !== true
|
|
|| typeof result.code !== "string"
|
|
|| !SAFE_CODE.test(result.code)
|
|
|| !safeDisplayText(result.message, 1, 300)
|
|
|| (result.recordId !== null
|
|
&& !safeDisplayText(result.recordId, 1, 256))
|
|
|| typeof result.replayed !== "boolean"
|
|
|| !isObject(result.data)
|
|
|| (data.followupPlan !== null && !isObject(data.followupPlan))
|
|
|| (data.followupCode !== null
|
|
&& (typeof data.followupCode !== "string"
|
|
|| !SAFE_CODE.test(data.followupCode)))) {
|
|
throw protocolError("ERP 执行成功回执契约无效。");
|
|
}
|
|
const resultDataFields = Object.keys(result.data);
|
|
if (resultDataFields.length === 0) return;
|
|
validateDiagnosticData(result.data, expectedCorrelationId);
|
|
}
|
|
|
|
function validateDiagnosticData(data, expectedCorrelationId) {
|
|
if (!hasExactFields(Object.keys(data), DIAGNOSTIC_DATA_FIELDS)
|
|
|| data.diagnosticContextSchemaVersion !== "1.0"
|
|
|| typeof data.diagnosticId !== "string"
|
|
|| !SAFE_DIAGNOSTIC_ID.test(data.diagnosticId)
|
|
|| data.correlationId !== expectedCorrelationId
|
|
|| typeof data.evidencePersisted !== "boolean"
|
|
|| (data.evidenceContentHash !== null
|
|
&& (typeof data.evidenceContentHash !== "string"
|
|
|| !SAFE_HASH.test(data.evidenceContentHash)))
|
|
|| data.evidencePersisted !== (data.evidenceContentHash !== null)
|
|
|| !["failed", "degraded", "healthy"].includes(data.outcome)
|
|
|| typeof data.primaryFindingCode !== "string"
|
|
|| !SAFE_CODE.test(data.primaryFindingCode)
|
|
|| typeof data.moduleOpenSucceeded !== "boolean"
|
|
|| !boundedInteger(data.eventCount, 0, 200)
|
|
|| !boundedInteger(data.failedEventCount, 0, data.eventCount)
|
|
|| !boundedInteger(data.slowEventCount, 0, data.eventCount)
|
|
|| typeof data.traceTruncated !== "boolean"
|
|
|| typeof data.summaryTruncated !== "boolean"
|
|
|| data.contextAvailable !== true
|
|
|| !Array.isArray(data.findings)
|
|
|| data.findings.length < 1
|
|
|| data.findings.length > 16
|
|
|| !isObject(data.staticDiagnosis)) {
|
|
throw protocolError("ERP 初始化诊断回执契约无效。");
|
|
}
|
|
data.findings.forEach((finding, index) => {
|
|
if (!isObject(finding)
|
|
|| !hasExactFields(Object.keys(finding), DIAGNOSTIC_FINDING_FIELDS)
|
|
|| !["error", "warning", "info"].includes(finding.severity)
|
|
|| typeof finding.code !== "string"
|
|
|| !SAFE_CODE.test(finding.code)
|
|
|| typeof finding.category !== "string"
|
|
|| !SAFE_CODE.test(finding.category)
|
|
|| typeof finding.stage !== "string"
|
|
|| !SAFE_CODE.test(finding.stage)
|
|
|| !["observed", "inferred"].includes(finding.confidence)
|
|
|| !safeDisplayText(finding.message, 1, 300)
|
|
|| !safeDisplayText(finding.recommendation, 1, 500)
|
|
|| !boundedInteger(finding.occurrenceCount, 1, 200)
|
|
|| (finding.sqlFingerprint !== null
|
|
&& (typeof finding.sqlFingerprint !== "string"
|
|
|| !SAFE_HASH.test(finding.sqlFingerprint)))
|
|
|| (finding.caller !== null
|
|
&& (typeof finding.caller !== "string"
|
|
|| !SAFE_CALLER.test(finding.caller)))) {
|
|
throw protocolError("ERP 初始化诊断 finding 契约无效。");
|
|
}
|
|
if (index === 0 && finding.code !== data.primaryFindingCode) {
|
|
throw protocolError("ERP 初始化诊断主结论不一致。");
|
|
}
|
|
});
|
|
const staticDiagnosis = data.staticDiagnosis;
|
|
if (!hasExactFields(
|
|
Object.keys(staticDiagnosis),
|
|
STATIC_DIAGNOSIS_FIELDS)
|
|
|| typeof staticDiagnosis.moduleCode !== "string"
|
|
|| !SAFE_COMMAND.test(staticDiagnosis.moduleCode)
|
|
|| !["base", "bill"].includes(staticDiagnosis.moduleKind)
|
|
|| typeof staticDiagnosis.healthy !== "boolean"
|
|
|| !boundedInteger(staticDiagnosis.issueCount, 0, 200)
|
|
|| !Array.isArray(staticDiagnosis.issues)
|
|
|| staticDiagnosis.issues.length > 32
|
|
|| staticDiagnosis.issues.length > staticDiagnosis.issueCount) {
|
|
throw protocolError("ERP 静态诊断回执契约无效。");
|
|
}
|
|
staticDiagnosis.issues.forEach(issue => {
|
|
if (!isObject(issue)
|
|
|| !hasExactFields(Object.keys(issue), STATIC_ISSUE_FIELDS)
|
|
|| !["error", "warning", "info"].includes(issue.severity)
|
|
|| typeof issue.code !== "string"
|
|
|| !SAFE_CODE.test(issue.code)
|
|
|| typeof issue.source !== "string"
|
|
|| !SAFE_CODE.test(issue.source)) {
|
|
throw protocolError("ERP 静态诊断 issue 契约无效。");
|
|
}
|
|
});
|
|
}
|
|
|
|
function boundedInteger(value, minimum, maximum) {
|
|
return Number.isInteger(value) && value >= minimum && value <= maximum;
|
|
}
|
|
|
|
function safeDisplayText(value, minimumLength, maximumLength) {
|
|
return typeof value === "string"
|
|
&& value.length >= minimumLength
|
|
&& value.length <= maximumLength
|
|
&& !/[\u0000-\u001f\u007f-\u009f]/.test(value);
|
|
}
|
|
|
|
function hasExactFields(actual, expected) {
|
|
return actual.length === expected.length && expected.every(field => actual.includes(field));
|
|
}
|
|
|
|
function isObject(value) {
|
|
return value !== null && typeof value === "object" && !Array.isArray(value);
|
|
}
|
|
|
|
function protocolError(message) {
|
|
return clientError("bridge_protocol_error", message || "ERP 桥协议错误。");
|
|
}
|
|
|
|
function clientError(code, message) {
|
|
const error = new Error(message || "ERP 桥调用失败。");
|
|
error.code = code;
|
|
return error;
|
|
}
|
|
|
|
return Object.freeze({ createId, WebViewTransport, BridgeClient, validateResponse });
|
|
});
|