befly-vscode 1.1.0

package/configs/obfuscator.config.json

@@ -0,0 +1,32 @@
+{
+    "target": "node",
+
+    "compact": true,
+    "optionsPreset": "default",
+
+    "sourceMap": false,
+
+    "identifierNamesGenerator": "hexadecimal",
+    "renameGlobals": false,
+    "renameProperties": false,
+    "transformObjectKeys": false,
+
+    "ignoreImports": true,
+
+    "stringArray": true,
+    "stringArrayCallsTransform": true,
+    "stringArrayRotate": true,
+    "stringArrayShuffle": true,
+    "splitStrings": true,
+    "splitStringsChunkLength": 8,
+    "stringArrayEncoding": ["base64"],
+    "stringArrayThreshold": 1,
+
+    "controlFlowFlattening": false,
+    "deadCodeInjection": false,
+    "selfDefending": false,
+    "debugProtection": false,
+    "disableConsoleOutput": false,
+
+    "reservedNames": ["^activate$", "^deactivate$"]
+}

package/configs/tsdown.config.js

@@ -0,0 +1,23 @@
+import * as path from "node:path";
+
+import { defineConfig } from "tsdown";
+
+const pkgDir = process.cwd();
+
+export default defineConfig(() => ({
+    platform: "node",
+    target: "node22",
+    format: "esm",
+    fixedExtension: true,
+    clean: true,
+    sourcemap: false,
+    dts: false,
+    deps: {
+        onlyBundle: false,
+        neverBundle: ["vscode"]
+    },
+    entry: {
+        extension: path.join(pkgDir, "extension", "extension.js")
+    },
+    outDir: path.join(pkgDir, "dist")
+}));

package/configs/vite.config.js

@@ -0,0 +1,54 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import vue from "@vitejs/plugin-vue";
+import analyzer from "vite-bundle-analyzer";
+
+const pkgDir = process.cwd();
+const webviewRoot = path.join(pkgDir, "webview");
+const outDir = path.join(pkgDir, "dist");
+const publicDirCandidate = path.join(pkgDir, "public");
+const publicDir = fs.existsSync(publicDirCandidate) ? publicDirCandidate : undefined;
+const isBuild = process.env.NODE_ENV === "production";
+
+export default {
+    plugins: [
+        vue(),
+        analyzer({
+            enabled: isBuild,
+            analyzerMode: "static",
+            openAnalyzer: false,
+            fileName: "bundle-analyzer.html",
+            reportTitle: "WebView Bundle",
+            defaultSizes: "gzip"
+        })
+    ],
+    root: webviewRoot,
+    base: "./",
+    publicDir: publicDir,
+    resolve: {
+        alias: {
+            "@": webviewRoot
+        }
+    },
+    server: {
+        port: 5200,
+        origin: "http://localhost:5200",
+        cors: true,
+        hmr: {
+            host: "localhost"
+        },
+        fs: {
+            allow: [webviewRoot, pkgDir]
+        }
+    },
+    build: {
+        outDir: outDir,
+        emptyOutDir: false,
+        assetsDir: "assets",
+        sourcemap: false
+    },
+    define: {
+        "process.env": {}
+    }
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+    "name": "befly-vscode",
+    "version": "1.1.0",
+    "private": false,
+    "description": "Befly VSCode - VSCode 扩展构建工具集",
+    "bin": {
+        "vscode-release": "scripts/release.mjs"
+    },
+    "files": [
+        "utils/",
+        "configs/",
+        "scripts/",
+        "package.json"
+    ],
+    "type": "module",
+    "exports": {
+        "./*": {
+            "import": "./*.js",
+            "default": "./*.js"
+        }
+    },
+    "dependencies": {
+        "@vitejs/plugin-vue": "^6.0.7",
+        "@vscode/vsce": "^3.9.2",
+        "@vue/compiler-sfc": "^3.5.35",
+        "bumpp": "^11.1.0",
+        "javascript-obfuscator": "^5.4.3",
+        "sass-embedded": "^1.100.0",
+        "tsdown": "^0.22.2",
+        "vite": "^8.0.16",
+        "vite-bundle-analyzer": "^1.3.8",
+        "vue": "^3.5.35"
+    },
+    "engines": {
+        "bun": ">=1.3.0"
+    }
+}

package/scripts/release.mjs

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+import { spawn } from "node:child_process";
+
+const type = process.argv[2];
+const allowed = ["major", "minor", "patch"];
+
+if (!allowed.includes(type)) {
+    console.error("用法: vscode-release <major|minor|patch>");
+    console.error("  major (rx) - 大版本");
+    console.error("  minor (ry) - 中版本");
+    console.error("  patch (rz) - 小版本");
+    process.exit(1);
+}
+
+function run(cmd, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, { stdio: "inherit", env: process.env });
+        child.on("error", reject);
+        child.on("exit", (code) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            reject(new Error(`命令执行失败: ${cmd} ${args.join(" ")}`));
+        });
+    });
+}
+
+await run("bunx", ["javascript-obfuscator", "./dist/extension.mjs", "--output", "./dist/extension.mjs", "--config", "node_modules/befly-vscode/configs/obfuscator.config.json"]);
+
+await run("bunx", ["@vscode/vsce", "publish", type, "--no-dependencies", "--no-git-tag-version", "--allow-missing-repository", "--allow-unused-files-pattern", "--skip-license", "--skip-duplicate", "--baseImagesUrl", ".", "--baseContentUrl", "."]);

package/utils/createHttp.js

@@ -0,0 +1,106 @@
+export function createHttp(options) {
+    const request = async function (url, data, dropValues = [], dropKeyValue = {}) {
+        try {
+            const fullUrl = /^https?:\/\//i.test(url) ? url : `${options.apiPath}${url}`;
+            const isForm = typeof FormData !== "undefined" && data instanceof FormData;
+            const dropList = [null, undefined, ...dropValues];
+            const dropKeyMap = {
+                ...dropKeyValue,
+                keyword: [""]
+            };
+            let payloadData = data ?? {};
+            if (isForm) {
+                const nextForm = new FormData();
+                for (const entry of payloadData.entries()) {
+                    const key = entry[0];
+                    const value = entry[1];
+                    let shouldDrop = false;
+                    for (const dropValue of dropList) {
+                        if (Object.is(value, dropValue)) {
+                            shouldDrop = true;
+                            break;
+                        }
+                    }
+                    if (!shouldDrop) {
+                        for (const dropValue of dropKeyMap[key] || []) {
+                            if (Object.is(value, dropValue)) {
+                                shouldDrop = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (!shouldDrop) {
+                        nextForm.append(key, value);
+                    }
+                }
+                payloadData = nextForm;
+            } else if (payloadData && typeof payloadData === "object") {
+                const nextData = {};
+                for (const key of Object.keys(payloadData)) {
+                    const value = payloadData[key];
+                    let shouldDrop = false;
+                    for (const dropValue of dropList) {
+                        if (Object.is(value, dropValue)) {
+                            shouldDrop = true;
+                            break;
+                        }
+                    }
+                    if (!shouldDrop) {
+                        for (const dropValue of dropKeyMap[key] || []) {
+                            if (Object.is(value, dropValue)) {
+                                shouldDrop = true;
+                                break;
+                            }
+                        }
+                    }
+                    if (!shouldDrop) {
+                        nextData[key] = value;
+                    }
+                }
+                payloadData = nextData;
+            }
+            const headers = new Headers();
+            if (!isForm) {
+                headers.set("Content-Type", "application/json");
+            }
+            const tokenValue = options.getToken();
+            if (tokenValue) {
+                headers.set("Authorization", "Bearer " + tokenValue);
+            }
+            const init = {
+                method: "POST",
+                headers: headers,
+                body: isForm ? payloadData : JSON.stringify(payloadData ?? {})
+            };
+            const res = await fetch(fullUrl, init);
+            let payload = {};
+            try {
+                payload = await res.json();
+            } catch {
+                if (res.ok) {
+                    return Promise.reject({ msg: "响应解析失败" });
+                }
+                payload = {
+                    code: res.status,
+                    msg: `请求失败：HTTP ${res.status}`
+                };
+            }
+            payload = await options.onReturn(payload);
+            if (payload?.code !== 0) {
+                return Promise.reject({
+                    msg: payload.msg ?? "请求失败",
+                    code: payload.code,
+                    detail: payload.detail
+                });
+            }
+            return Promise.resolve(payload);
+        } catch (error) {
+            if (error && typeof error === "object") {
+                return Promise.reject(error);
+            }
+            return Promise.reject({ msg: "网络连接失败" });
+        }
+    };
+
+    return request;
+}

package/utils/createReporter.js

@@ -0,0 +1,91 @@
+import { createHttp } from "./createHttp.js";
+
+const reportRequest = createHttp({
+    apiPath: "https://api.yicode.tech/api",
+    getToken: () => ""
+});
+
+const ERROR_REPORT_DEDUP_GAP = 3000;
+
+function normalizeDetail(detail) {
+    if (detail === null || typeof detail === "undefined") return "";
+    if (typeof detail === "string") {
+        return detail;
+    }
+    if (detail instanceof Error) {
+        return detail.stack || detail.message || String(detail);
+    }
+    try {
+        return JSON.stringify(detail);
+    } catch {
+        return String(detail);
+    }
+}
+
+function createBasePayload(options = {}) {
+    return {
+        source: options.source || "vscode",
+        productName: options.productName,
+        productCode: options.productCode,
+        productVersion: options.productVersion,
+        pagePath: options.pagePath,
+        pageName: options.pageName
+    };
+}
+
+function mergePagePayload(basePayload, page = {}) {
+    return {
+        ...basePayload,
+        pagePath: page.pagePath ?? basePayload.pagePath,
+        pageName: page.pageName ?? basePayload.pageName
+    };
+}
+
+async function postReport(path, payload) {
+    try {
+        await reportRequest(path, payload, ["", null, undefined]);
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+export function createReporter(options = {}) {
+    const basePayload = createBasePayload(options);
+    if (!basePayload.productCode) {
+        return null;
+    }
+
+    const requestPost = options.requestPost || postReport;
+    const fixedErrorType = basePayload.productCode || "extension";
+    let lastErrorKey = "";
+    let lastErrorTime = 0;
+
+    return {
+        reportInfo: function (page = {}) {
+            return requestPost("/core/tongJi/infoReport", mergePagePayload(basePayload, page));
+        },
+        reportError: function (input = {}, page = {}) {
+            const message = input.message || "未知错误";
+            const detail = normalizeDetail(input.detail);
+            const errorKey = `${fixedErrorType}|${message}|${detail}`;
+            const now = Date.now();
+            if (errorKey === lastErrorKey && now - lastErrorTime < ERROR_REPORT_DEDUP_GAP) {
+                return Promise.resolve(false);
+            }
+            lastErrorKey = errorKey;
+            lastErrorTime = now;
+            return requestPost("/core/tongJi/errorReport", {
+                ...mergePagePayload(basePayload, page),
+                errorType: input.errorType || fixedErrorType,
+                message: message,
+                detail: detail
+            });
+        },
+        reportOnline: function (clientId, page = {}) {
+            const payload = mergePagePayload(basePayload, page);
+            payload.clientId = clientId || "";
+            return requestPost("/core/tongJi/onlineReport", payload);
+        }
+    };
+}

package/utils/getVsCode.js

@@ -0,0 +1,18 @@
+export function getVsCode() {
+    const cacheKey = "__YICODE_VSCODE_API";
+    const cached = globalThis[cacheKey];
+    if (cached) {
+        return cached;
+    }
+    const acquire = globalThis.acquireVsCodeApi;
+    if (typeof acquire !== "function") {
+        return null;
+    }
+    try {
+        const api = acquire();
+        globalThis[cacheKey] = api;
+        return api;
+    } catch {
+        return globalThis[cacheKey] ?? null;
+    }
+}

package/utils/reporterSetup.js

@@ -0,0 +1,144 @@
+import { createReporter } from "./createReporter.js";
+
+function getPackageMeta(context) {
+    const packageJson = context.extension.packageJSON;
+    const productCode = packageJson.name;
+    if (!productCode) {
+        return null;
+    }
+    return {
+        productName: packageJson.displayName || packageJson.name,
+        productCode: productCode,
+        productVersion: packageJson.version
+    };
+}
+
+export function createExtensionReporter(context, options = {}) {
+    const packageMeta = getPackageMeta(context);
+    if (!packageMeta) {
+        return null;
+    }
+    const productCode = options.productCode || packageMeta.productCode;
+    const pageName = productCode;
+    return createReporter({
+        ...options,
+        source: options.source || "vscode",
+        productName: options.productName || packageMeta.productName,
+        productCode: productCode,
+        productVersion: options.productVersion || packageMeta.productVersion,
+        pagePath: `/${pageName}`,
+        pageName: pageName
+    });
+}
+
+const ONLINE_REPORT_HEARTBEAT_INTERVAL = 60 * 1000;
+const ONLINE_REPORT_CLIENT_ID_KEY = "befly-vscode-online-client-id";
+
+function generateClientId() {
+    return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+function readClientId(context) {
+    try {
+        const stored = context.globalState.get(ONLINE_REPORT_CLIENT_ID_KEY);
+        if (stored) {
+            return String(stored);
+        }
+    } catch {
+        // ignore
+    }
+    return "";
+}
+
+function writeClientId(context, clientId) {
+    try {
+        context.globalState.update(ONLINE_REPORT_CLIENT_ID_KEY, clientId);
+    } catch {
+        // ignore
+    }
+}
+
+function getClientId(context) {
+    const stored = readClientId(context);
+    if (stored) {
+        return stored;
+    }
+    const clientId = generateClientId();
+    writeClientId(context, clientId);
+    return clientId;
+}
+
+export function startReportHeartbeat(reporter, context) {
+    if (!reporter || !reporter.reportOnline) {
+        return () => {};
+    }
+    const clientId = getClientId(context);
+
+    const timer = setInterval(() => {
+        void reporter.reportOnline(clientId);
+    }, ONLINE_REPORT_HEARTBEAT_INTERVAL);
+
+    void reporter.reportOnline(clientId);
+
+    return () => {
+        clearInterval(timer);
+    };
+}
+
+export function setupWebviewMessageReporter(panel, reporter) {
+    if (!panel || !reporter) {
+        return () => {};
+    }
+    const disposable = panel.webview.onDidReceiveMessage((message) => {
+        if (!message || typeof message !== "object") {
+            return;
+        }
+        if (message.command === "reportPageView") {
+            void reporter.reportInfo({
+                pagePath: message.pagePath,
+                pageName: message.pageName
+            });
+        } else if (message.command === "reportError") {
+            void reporter.reportError(
+                {
+                    message: message.message,
+                    detail: message.detail,
+                    errorType: message.errorType
+                },
+                {
+                    pagePath: message.pagePath,
+                    pageName: message.pageName
+                }
+            );
+        }
+    });
+    return () => {
+        disposable.dispose();
+    };
+}
+
+export function setupExtensionErrorHandlers(reporter) {
+    if (!reporter) {
+        return () => {};
+    }
+    const handleError = (error) => {
+        void reporter.reportError({
+            message: error?.message || "扩展未捕获异常",
+            detail: error?.stack || String(error),
+            errorType: "extension"
+        });
+    };
+    const handleRejection = (reason) => {
+        void reporter.reportError({
+            message: reason?.message || "扩展未处理 Promise 拒绝",
+            detail: reason?.stack || String(reason),
+            errorType: "extension"
+        });
+    };
+    process.on("uncaughtException", handleError);
+    process.on("unhandledRejection", handleRejection);
+    return () => {
+        process.off("uncaughtException", handleError);
+        process.off("unhandledRejection", handleRejection);
+    };
+}

package/utils/webviewHtml.js

@@ -0,0 +1,171 @@
+import * as fs from "node:fs";
+
+import * as vscode from "vscode";
+
+const DEV_SERVER_ORIGIN = "http://localhost:5200";
+const DEV_SERVER_WS_ORIGIN = "ws://localhost:5200";
+
+export function createBootstrapJs(args) {
+    const devServerOrigin = args.isDev ? args.httpOrigin : "";
+    const bootstrapValues = {
+        __YICODE_IS_DEV: args.isDev === true,
+        __YICODE_MODE: args.mode || "",
+        __YICODE_PAGE_NAME: args.pageName || "main",
+        __YICODE_PAGE_PATH: args.pagePath || "/main",
+        __YICODE_DEV_SERVER_ORIGIN: devServerOrigin,
+        __YICODE_PRODUCT_NAME: args.productName || "",
+        __YICODE_PRODUCT_CODE: args.productCode || "",
+        __YICODE_PRODUCT_VERSION: args.productVersion || ""
+    };
+    return Object.entries(bootstrapValues)
+        .map(([key, value]) => `globalThis.${key}=${JSON.stringify(value)};`)
+        .join("");
+}
+
+function getPackageMeta(context) {
+    const packageJson = context.extension.packageJSON;
+    return {
+        productName: packageJson.displayName || packageJson.name || "",
+        productCode: packageJson.name || "",
+        productVersion: packageJson.version || ""
+    };
+}
+
+export function isEnvEnabled(name) {
+    const raw = process.env[name];
+    if (!raw) return false;
+    const v = raw.toLowerCase();
+    return v === "1" || v === "true" || v === "yes";
+}
+export function createNonce() {
+    const timestamp = Date.now();
+    const random6 = Math.floor(Math.random() * 1000000)
+        .toString()
+        .padStart(6, "0");
+    return `${timestamp}${random6}`;
+}
+export function createCsp(mode, args) {
+    const common = {
+        defaultSrc: "default-src 'none'",
+        imgSrc: `img-src ${args.cspSource} https: http: data: blob:`,
+        styleSrc: `style-src ${args.cspSource} 'unsafe-inline'`,
+        fontSrc: `font-src ${args.cspSource} data:`
+    };
+    if (mode === "dev") {
+        return [
+            common.defaultSrc,
+            `script-src 'nonce-${args.nonce}' 'unsafe-eval' ${args.httpOrigin}`,
+            `${common.imgSrc} ${args.httpOrigin}`,
+            `${common.styleSrc} ${args.httpOrigin}`,
+            `${common.fontSrc} ${args.httpOrigin}`,
+            `connect-src ${args.httpOrigin} ${args.wsOrigin} https://api.yicode.tech http://127.0.0.1:3020 http://localhost:3020`
+        ].join("; ");
+    }
+    return [common.defaultSrc, common.imgSrc, `script-src 'nonce-${args.nonce}'`, common.styleSrc, common.fontSrc, `connect-src ${args.cspSource} https://api.yicode.tech`].join("; ");
+}
+export function createDevHtml(args) {
+    const bootstrap = args.bootstrapJs ? `<script nonce="${args.nonce}">${args.bootstrapJs}</script>` : "";
+    return `<!doctype html>
+<html lang="zh-CN">
+    <head>
+        <meta charset="UTF-8" />
+        <meta http-equiv="Content-Security-Policy" content="${args.csp}" />
+        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+        <title>WebView（开发）</title>
+        ${bootstrap}
+    </head>
+    <body style="padding: 0">
+        <div id="app"></div>
+        <script type="module" nonce="${args.nonce}" src="${args.httpOrigin}/@vite/client"></script>
+        <script type="module" nonce="${args.nonce}" src="${args.httpOrigin}/main.js"></script>
+    </body>
+</html>`;
+}
+export function createBuildHtml(args) {
+    let out = args.html.replace(/(src|href)="\.\/([^"]+)"/g, (_match, attr, relPath) => {
+        const resourceUri = args.mapAssetUri(relPath);
+        return `${attr}="${resourceUri}"`;
+    });
+    const baseTag = `<base href="${args.baseHref}">`;
+    out = out.replace(
+        /<head(\s[^>]*)?>/i,
+        (m) => `${m}
+${baseTag}`
+    );
+    if (args.csp) {
+        const cspTag = `<meta http-equiv="Content-Security-Policy" content="${args.csp}" />`;
+        out = out.replace(
+            /<head(\s[^>]*)?>/i,
+            (m) => `${m}
+${cspTag}`
+        );
+    }
+    const bootstrapTag = `<script nonce="${args.nonce}">${args.bootstrapJs}</script>`;
+    out = out.replace(
+        /<head(\s[^>]*)?>/i,
+        (m) => `${m}
+${bootstrapTag}`
+    );
+    out = out.replace(/<script(?!\b[^>]*\bnonce=)/g, `<script nonce="${args.nonce}"`);
+    return out;
+}
+
+export async function getWebviewHtml(context, webview, options = {}) {
+    const nonce = createNonce();
+    const modeName = options.mode || "main";
+    const packageMeta = getPackageMeta(context);
+    const pageName = packageMeta.productCode || "main";
+    const pagePath = `/${pageName}`;
+    const mode = modeName === "main" ? `${context.extension.id}` : `${context.extension.id}.${modeName}`;
+
+    if (isEnvEnabled("WEBVIEW_DEV_SERVER") && context.extensionMode === vscode.ExtensionMode.Development) {
+        const httpOrigin = DEV_SERVER_ORIGIN;
+        const wsOrigin = DEV_SERVER_WS_ORIGIN;
+        const bootstrapJs = createBootstrapJs({
+            isDev: true,
+            mode: mode,
+            httpOrigin: httpOrigin,
+            pageName: pageName,
+            pagePath: pagePath,
+            productName: packageMeta.productName,
+            productCode: packageMeta.productCode,
+            productVersion: packageMeta.productVersion
+        });
+        const csp = createCsp("dev", {
+            cspSource: webview.cspSource,
+            nonce: nonce,
+            httpOrigin: httpOrigin,
+            wsOrigin: wsOrigin
+        });
+        return createDevHtml({
+            nonce: nonce,
+            csp: csp,
+            httpOrigin: httpOrigin,
+            bootstrapJs: bootstrapJs
+        });
+    }
+    const htmlPath = vscode.Uri.joinPath(context.extensionUri, "dist", "index.html");
+    const htmlContent = fs.readFileSync(htmlPath.fsPath, "utf8");
+    const distBaseUri = webview.asWebviewUri(vscode.Uri.joinPath(context.extensionUri, "dist"));
+    const baseHref = `${distBaseUri}`.endsWith("/") ? `${distBaseUri}` : `${distBaseUri}/`;
+    const bootstrapJs = createBootstrapJs({
+        isDev: false,
+        mode: mode,
+        httpOrigin: "",
+        pageName: pageName,
+        pagePath: pagePath,
+        productName: packageMeta.productName,
+        productCode: packageMeta.productCode,
+        productVersion: packageMeta.productVersion
+    });
+    return createBuildHtml({
+        html: htmlContent,
+        nonce: nonce,
+        baseHref: baseHref,
+        bootstrapJs: bootstrapJs,
+        mapAssetUri: (relPath) => {
+            const resourceUri = webview.asWebviewUri(vscode.Uri.joinPath(context.extensionUri, "dist", relPath));
+            return `${resourceUri}`;
+        }
+    });
+}

package/utils/webviewReporter.js

@@ -0,0 +1,90 @@
+import { createReporter } from "./createReporter.js";
+
+function readGlobalString(name) {
+    return globalThis[name] || "";
+}
+
+function createWebviewReporterOptions() {
+    const productCode = readGlobalString("__YICODE_PRODUCT_CODE");
+    const pageName = productCode || readGlobalString("__YICODE_PAGE_NAME") || "main";
+    return {
+        source: "vscode",
+        productName: readGlobalString("__YICODE_PRODUCT_NAME"),
+        productCode: productCode,
+        productVersion: readGlobalString("__YICODE_PRODUCT_VERSION"),
+        pagePath: `/${pageName}`,
+        pageName: pageName
+    };
+}
+
+function readRejectionMessage(reason) {
+    if (reason instanceof Error && reason.message) {
+        return reason.message;
+    }
+    if (reason?.message) return reason.message;
+    if (reason) return String(reason);
+    return "WebView Promise 未处理异常";
+}
+
+function readWindowErrorDetail(event) {
+    if (event?.error) {
+        return event.error;
+    }
+    const location = [event?.filename, event?.lineno, event?.colno].filter(Boolean).join(":");
+    if (event?.message && location) {
+        return `${event.message} @ ${location}`;
+    }
+    return event?.message || location || "";
+}
+
+export function getWebviewTongjiReporter() {
+    const cacheKey = "__YICODE_WEBVIEW_TONGJI_REPORTER";
+    const cached = globalThis?.[cacheKey];
+    if (cached) {
+        return cached;
+    }
+    const reporter = createReporter(createWebviewReporterOptions());
+    if (reporter) {
+        globalThis[cacheKey] = reporter;
+    }
+    return reporter;
+}
+
+export function reportWebviewError(message, detail) {
+    const reporter = getWebviewTongjiReporter();
+    if (!reporter) {
+        return Promise.resolve(false);
+    }
+    return reporter.reportError({
+        message: message || "WebView 异常",
+        detail: detail
+    });
+}
+
+export function registerWebviewGlobalErrorHandlers(reporter) {
+    if (!reporter) {
+        return () => {};
+    }
+
+    const handleError = (event) => {
+        void reporter.reportError({
+            message: event?.message || "WebView 运行异常",
+            detail: readWindowErrorDetail(event)
+        });
+    };
+
+    const handleRejection = (event) => {
+        void reporter.reportError({
+            message: readRejectionMessage(event?.reason),
+            detail: event?.reason
+        });
+    };
+
+    globalThis.addEventListener("error", handleError);
+    globalThis.addEventListener("unhandledrejection", handleRejection);
+
+    return () => {
+        globalThis.removeEventListener("error", handleError);
+        globalThis.removeEventListener("unhandledrejection", handleRejection);
+    };
+}