@mkterswingman/5mghost-wonder 0.0.13 → 0.0.15

package/dist/wecom/browser-probe.js

@@ -0,0 +1,677 @@
+// src/wecom/browser-probe.ts
+// Experimental browser runtime probe for no-export reads. This intentionally
+// records evidence summaries, not raw network bodies or cookies.
+import { spawn } from "node:child_process";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { createServer } from "node:net";
+import { join, resolve } from "node:path";
+import WebSocket from "ws";
+const CDP_CALL_TIMEOUT_MS = 5000;
+const BROWSER_START_TIMEOUT_MS = 20_000;
+const DEFAULT_CAPTURE_MS = 8_000;
+const MAX_NETWORK_CANDIDATES = 40;
+let cdpNextId = 1;
+export async function runBrowserNoExportProbe(options) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_CAPTURE_MS;
+    const browser = findInstalledBrowser(options.executablePath);
+    const port = await getFreePort();
+    const endpoint = `http://127.0.0.1:${port}`;
+    const child = spawnBrowser({
+        browser,
+        port,
+        profilePath: options.chromeProfilePath,
+        url: options.url,
+        headed: options.headed ?? false,
+    });
+    try {
+        await waitForDebugger(endpoint, BROWSER_START_TIMEOUT_MS);
+        const pageWsUrl = await waitForPageWebSocket(endpoint, options.url, BROWSER_START_TIMEOUT_MS);
+        const socket = await openDevToolsSocket(pageWsUrl);
+        const responses = [];
+        try {
+            socket.addEventListener("message", (event) => {
+                const payload = safeJsonParse(String(event.data));
+                if (payload?.method !== "Network.responseReceived")
+                    return;
+                const response = payload.params?.response;
+                const requestId = payload.params?.requestId;
+                if (!response?.url || !requestId)
+                    return;
+                if (!isInterestingNetworkUrl(response.url, response.mimeType ?? ""))
+                    return;
+                responses.push({
+                    requestId,
+                    url: response.url,
+                    status: response.status ?? 0,
+                    mimeType: response.mimeType ?? "",
+                });
+            });
+            await sendCdpCommand(socket, "Network.enable");
+            await sendCdpCommand(socket, "Page.enable");
+            await sendCdpCommand(socket, "Runtime.enable");
+            await sendCdpCommand(socket, "Page.navigate", { url: options.url });
+            await delay(timeoutMs);
+            const pageInfo = await evaluatePageInfo(socket);
+            const networkArtifacts = await collectNetworkArtifacts(socket, responses);
+            const networkCandidates = summarizeNetworkArtifacts(networkArtifacts);
+            const evidence = ["browser-page"];
+            if (pageInfo.visibleTextSample)
+                evidence.push("visible-text");
+            if (pageInfo.runtimeGlobals.length > 0)
+                evidence.push("runtime-globals");
+            if (networkCandidates.length > 0)
+                evidence.push("network-response-summary");
+            const missing = [
+                "raw structured document model",
+                "merge ranges",
+                "image original resources",
+                "image anchors",
+            ];
+            const result = {
+                mode: "browser-no-export-probe",
+                status: "partial",
+                url: redactUrl(options.url),
+                finalUrl: pageInfo.finalUrl ? redactUrl(pageInfo.finalUrl) : undefined,
+                title: pageInfo.title,
+                loginLikely: pageInfo.loginLikely,
+                visibleTextSample: pageInfo.visibleTextSample,
+                runtimeGlobals: pageInfo.runtimeGlobals,
+                networkCandidates,
+                evidence,
+                missing,
+            };
+            if (options.saveDir) {
+                mkdirSync(options.saveDir, { recursive: true });
+                const savedPath = resolve(options.saveDir, `wonder-browser-probe-${Date.now()}.json`);
+                writeFileSync(savedPath, JSON.stringify(result, null, 2), { mode: 0o600 });
+                result.savedPath = savedPath;
+            }
+            return result;
+        }
+        finally {
+            socket.close();
+        }
+    }
+    catch (err) {
+        return {
+            mode: "browser-no-export-probe",
+            status: "fail",
+            url: redactUrl(options.url),
+            loginLikely: false,
+            runtimeGlobals: [],
+            networkCandidates: [],
+            evidence: [],
+            missing: [err instanceof Error ? err.message : String(err)],
+        };
+    }
+    finally {
+        await terminateBrowserProcess(child);
+    }
+}
+export async function runBrowserNoExportRead(options) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_CAPTURE_MS;
+    const browser = findInstalledBrowser(options.executablePath);
+    const port = await getFreePort();
+    const endpoint = `http://127.0.0.1:${port}`;
+    const child = spawnBrowser({
+        browser,
+        port,
+        profilePath: options.chromeProfilePath,
+        url: options.url,
+        headed: options.headed ?? false,
+    });
+    try {
+        await waitForDebugger(endpoint, BROWSER_START_TIMEOUT_MS);
+        const pageWsUrl = await waitForPageWebSocket(endpoint, options.url, BROWSER_START_TIMEOUT_MS);
+        const socket = await openDevToolsSocket(pageWsUrl);
+        const responses = [];
+        try {
+            socket.addEventListener("message", (event) => {
+                const payload = safeJsonParse(String(event.data));
+                if (payload?.method !== "Network.responseReceived")
+                    return;
+                const response = payload.params?.response;
+                const requestId = payload.params?.requestId;
+                if (!response?.url || !requestId)
+                    return;
+                if (!isInterestingNetworkUrl(response.url, response.mimeType ?? ""))
+                    return;
+                responses.push({
+                    requestId,
+                    url: response.url,
+                    status: response.status ?? 0,
+                    mimeType: response.mimeType ?? "",
+                });
+            });
+            await sendCdpCommand(socket, "Network.enable");
+            await sendCdpCommand(socket, "Page.enable");
+            await sendCdpCommand(socket, "Runtime.enable");
+            await sendCdpCommand(socket, "Page.navigate", { url: options.url });
+            await delay(timeoutMs);
+            const pageInfo = await evaluatePageInfo(socket);
+            const networkArtifacts = await collectNetworkArtifacts(socket, responses);
+            const opendoc = networkArtifacts.find((artifact) => artifact.rawUrl.includes("/dop-api/opendoc") && artifact.body);
+            const extracted = opendoc?.body ? extractTextFromOpendoc(opendoc.body) : null;
+            const evidence = ["browser-page", "network-response-summary"];
+            if (opendoc)
+                evidence.push("opendoc-response");
+            if (extracted?.text)
+                evidence.push("initial-attributed-text");
+            const result = {
+                mode: "browser-no-export-read",
+                status: extracted?.text ? "partial" : "fail",
+                url: redactUrl(options.url),
+                finalUrl: pageInfo.finalUrl ? redactUrl(pageInfo.finalUrl) : undefined,
+                title: extracted?.title ?? pageInfo.title,
+                padType: extracted?.padType,
+                text: extracted?.text,
+                textLength: extracted?.text.length,
+                imageUrls: extracted?.imageUrls,
+                extraction: extracted?.text ? "opendoc-initial-attributed-text" : "none",
+                evidence,
+                warnings: extracted?.warnings ?? [
+                    "No readable opendoc initialAttributedText was captured.",
+                ],
+                missing: [
+                    "table merge ranges",
+                    ...(extracted?.imageUrls && extracted.imageUrls.length > 0 ? [] : ["image original resources"]),
+                    "image anchors",
+                    "floating vs fixed image classification",
+                ],
+            };
+            if (options.saveDir) {
+                mkdirSync(options.saveDir, { recursive: true });
+                const savedPath = resolve(options.saveDir, `wonder-browser-read-${Date.now()}.json`);
+                writeFileSync(savedPath, JSON.stringify(result, null, 2), { mode: 0o600 });
+                result.savedPath = savedPath;
+            }
+            return result;
+        }
+        finally {
+            socket.close();
+        }
+    }
+    catch (err) {
+        return {
+            mode: "browser-no-export-read",
+            status: "fail",
+            url: redactUrl(options.url),
+            extraction: "none",
+            evidence: [],
+            warnings: [],
+            missing: [err instanceof Error ? err.message : String(err)],
+        };
+    }
+    finally {
+        await terminateBrowserProcess(child);
+    }
+}
+async function evaluatePageInfo(socket) {
+    const expression = `(() => {
+    const text = (document.body && document.body.innerText || "").replace(/\\s+/g, " ").trim();
+    const globals = Object.keys(window)
+      .filter((key) => /doc|sheet|wecom|weixin|store|redux|editor|canvas/i.test(key))
+      .slice(0, 80);
+    const loginLikely = /登录|扫码|二维码|login|sign in/i.test(text);
+    return {
+      finalUrl: location.href,
+      title: document.title,
+      loginLikely,
+      visibleTextSample: text.slice(0, 2000),
+      runtimeGlobals: globals
+    };
+  })()`;
+    const payload = await sendCdpCommand(socket, "Runtime.evaluate", {
+        expression,
+        returnByValue: true,
+        awaitPromise: false,
+    });
+    const value = payload.result?.value;
+    return {
+        finalUrl: value?.finalUrl,
+        title: value?.title,
+        loginLikely: value?.loginLikely ?? false,
+        visibleTextSample: value?.visibleTextSample,
+        runtimeGlobals: value?.runtimeGlobals ?? [],
+    };
+}
+async function collectNetworkArtifacts(socket, responses) {
+    const unique = new Map();
+    for (const response of responses) {
+        if (unique.size >= MAX_NETWORK_CANDIDATES)
+            break;
+        unique.set(response.requestId, response);
+    }
+    const artifacts = [];
+    for (const response of unique.values()) {
+        let body = "";
+        let base64Encoded = false;
+        try {
+            const payload = await sendCdpCommand(socket, "Network.getResponseBody", { requestId: response.requestId });
+            body = payload.body ?? "";
+            base64Encoded = payload.base64Encoded ?? false;
+        }
+        catch {
+            // Some responses are streamed, cached, too large, or not retained.
+        }
+        const signals = detectBodySignals(body, response.mimeType);
+        artifacts.push({
+            requestId: response.requestId,
+            rawUrl: response.url,
+            url: redactUrl(response.url),
+            status: response.status,
+            mimeType: response.mimeType,
+            bodyLength: body ? body.length : undefined,
+            base64Encoded: body ? base64Encoded : undefined,
+            signals,
+            body,
+        });
+    }
+    return artifacts;
+}
+function summarizeNetworkArtifacts(artifacts) {
+    return artifacts.map((artifact) => ({
+        url: artifact.url,
+        status: artifact.status,
+        mimeType: artifact.mimeType,
+        bodyLength: artifact.bodyLength,
+        base64Encoded: artifact.base64Encoded,
+        signals: artifact.signals,
+    }));
+}
+export function extractTextFromOpendoc(body) {
+    let payload;
+    try {
+        payload = JSON.parse(body);
+    }
+    catch {
+        return null;
+    }
+    const initialText = payload.clientVars?.collab_client_vars?.initialAttributedText?.text;
+    const chunks = Array.isArray(initialText) ? initialText : [];
+    const decodedChunks = chunks
+        .filter((chunk) => typeof chunk === "string")
+        .flatMap((chunk) => extractInitialAttributedTextCandidates(chunk));
+    const textCandidate = chooseTextCandidate(decodedChunks);
+    const text = normalizeExtractedText(textCandidate ?? decodedChunks.join("\n"));
+    if (!text)
+        return null;
+    const imageUrls = extractImageUrls(decodedChunks.join("\n"));
+    return {
+        title: payload.clientVars?.title ?? payload.clientVars?.initialTitle,
+        padType: payload.clientVars?.padType ?? payload.padType,
+        text,
+        imageUrls,
+        warnings: [
+            "No-export text is decoded from opendoc initialAttributedText; rich styles are not reconstructed yet.",
+            ...(imageUrls.length > 0
+                ? ["Image resource URLs were detected, but image anchors and fixed/floating placement are not reconstructed yet."]
+                : []),
+        ],
+    };
+}
+function extractInitialAttributedTextCandidates(chunk) {
+    let decoded;
+    try {
+        decoded = Buffer.from(chunk, "base64");
+    }
+    catch {
+        decoded = Buffer.from(chunk, "utf8");
+    }
+    const candidates = collectProtobufStringCandidates(decoded);
+    if (candidates.length > 0)
+        return candidates.map((candidate) => candidate.text);
+    return [decoded.toString("utf8")];
+}
+function chooseTextCandidate(candidates) {
+    const scored = candidates
+        .map((text) => ({
+        text,
+        score: text.length +
+            (/\[[^\]]+\]/.test(text) ? 200 : 0) +
+            (/[\u4e00-\u9fff]/.test(text) ? 200 : 0) -
+            ((text.match(/https?:\/\//g)?.length ?? 0) * 100),
+    }))
+        .filter((candidate) => candidate.text.length > 0)
+        .sort((a, b) => b.score - a.score);
+    return scored[0]?.text ?? null;
+}
+function collectProtobufStringCandidates(buffer) {
+    const candidates = [];
+    walkProtobuf(buffer, 0, buffer.length, 0, candidates);
+    return candidates
+        .filter((candidate) => candidate.byteLength >= 2 &&
+        candidate.printableRatio >= 0.8 &&
+        /[\p{L}\p{N}\[]/u.test(candidate.text))
+        .sort((a, b) => b.byteLength - a.byteLength);
+}
+function walkProtobuf(buffer, start, end, depth, candidates) {
+    if (depth > 6)
+        return;
+    let offset = start;
+    let fieldsSeen = 0;
+    while (offset < end && fieldsSeen < 10_000) {
+        fieldsSeen++;
+        const key = readVarint(buffer, offset, end);
+        if (!key)
+            return;
+        offset = key.nextOffset;
+        const wireType = key.value & 7;
+        if (wireType === 0) {
+            const value = readVarint(buffer, offset, end);
+            if (!value)
+                return;
+            offset = value.nextOffset;
+        }
+        else if (wireType === 1) {
+            offset += 8;
+        }
+        else if (wireType === 5) {
+            offset += 4;
+        }
+        else if (wireType === 2) {
+            const length = readVarint(buffer, offset, end);
+            if (!length)
+                return;
+            offset = length.nextOffset;
+            const fieldEnd = offset + length.value;
+            if (fieldEnd > end)
+                return;
+            const raw = buffer.subarray(offset, fieldEnd);
+            const text = raw.toString("utf8");
+            candidates.push({
+                text,
+                byteLength: length.value,
+                printableRatio: printableRatio(text),
+            });
+            if (length.value > 2) {
+                walkProtobuf(buffer, offset, fieldEnd, depth + 1, candidates);
+            }
+            offset = fieldEnd;
+        }
+        else {
+            return;
+        }
+    }
+}
+function readVarint(buffer, offset, end) {
+    let value = 0n;
+    let shift = 0n;
+    let current = offset;
+    while (current < end) {
+        const byte = buffer[current++];
+        value |= BigInt(byte & 0x7f) << shift;
+        if ((byte & 0x80) === 0) {
+            return { value: Number(value), nextOffset: current };
+        }
+        shift += 7n;
+        if (shift > 63n)
+            return null;
+    }
+    return null;
+}
+function printableRatio(text) {
+    if (!text)
+        return 0;
+    let printable = 0;
+    for (const char of text) {
+        if (/[\p{L}\p{N}\p{P}\p{Zs}\r\n\t]/u.test(char))
+            printable++;
+    }
+    return printable / text.length;
+}
+function extractImageUrls(text) {
+    const urls = text.match(/https?:\/\/[^\s"'<>\\\u0000-\u001f]+/g) ?? [];
+    return Array.from(new Set(urls
+        .map((url) => url.replace(/[)*,.;:]+$/g, ""))
+        .filter((url) => /qpic\.cn|weixin\.qq\.com|doc\.weixin\.qq\.com/i.test(url))));
+}
+function normalizeExtractedText(text) {
+    return text
+        .replace(/p\.\d{8,}/g, "")
+        .replace(/\b\d{12,}@eJ\b/g, "")
+        .replace(/[^\S\r\n]+/g, " ")
+        .replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]+/g, "\n")
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .filter((line) => line.length > 1 || /[\u4e00-\u9fff]/.test(line))
+        .filter((line) => !line.includes("\uFFFD"))
+        .filter((line) => /[\p{L}\p{N}\]\)]/u.test(line))
+        .join("\n")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+function detectBodySignals(body, mimeType) {
+    const haystack = `${mimeType}\n${body.slice(0, 200_000)}`;
+    const signals = [];
+    if (/merge|merged|rowspan|colspan|mergeCell|mergeCells/i.test(haystack))
+        signals.push("merge-like");
+    if (/image|img|pic|picture|media|download_url|url/i.test(haystack))
+        signals.push("image-like");
+    if (/cell|row|column|sheet|workbook|table/i.test(haystack))
+        signals.push("table-like");
+    if (/text|paragraph|content|doc|delta|operation|op/i.test(haystack))
+        signals.push("document-like");
+    if (/websocket|realtime|sync/i.test(haystack))
+        signals.push("realtime-like");
+    return signals;
+}
+function spawnBrowser(args) {
+    mkdirSync(args.profilePath, { recursive: true });
+    const browserArgs = [
+        `--remote-debugging-port=${args.port}`,
+        `--user-data-dir=${args.profilePath}`,
+        "--no-first-run",
+        "--no-default-browser-check",
+        "--disable-features=DialMediaRouteProvider",
+    ];
+    if (!args.headed) {
+        browserArgs.push("--headless=new");
+        browserArgs.push("--disable-gpu");
+    }
+    browserArgs.push(args.url);
+    return spawn(args.browser.executablePath, browserArgs, {
+        stdio: "ignore",
+        detached: process.platform !== "win32",
+    });
+}
+function getKnownBrowserPaths() {
+    if (process.platform === "darwin") {
+        return [
+            {
+                label: "Google Chrome",
+                executablePath: "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+            },
+            {
+                label: "Microsoft Edge",
+                executablePath: "/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge",
+            },
+        ];
+    }
+    if (process.platform === "win32") {
+        const lad = process.env["LOCALAPPDATA"] ?? "";
+        const pf = process.env["PROGRAMFILES"] ?? "C:\\Program Files";
+        const pf86 = process.env["PROGRAMFILES(X86)"] ?? "C:\\Program Files (x86)";
+        return [
+            { label: "Google Chrome", executablePath: join(lad, "Google", "Chrome", "Application", "chrome.exe") },
+            { label: "Google Chrome", executablePath: join(pf, "Google", "Chrome", "Application", "chrome.exe") },
+            { label: "Google Chrome", executablePath: join(pf86, "Google", "Chrome", "Application", "chrome.exe") },
+            { label: "Microsoft Edge", executablePath: join(pf, "Microsoft", "Edge", "Application", "msedge.exe") },
+            { label: "Microsoft Edge", executablePath: join(pf86, "Microsoft", "Edge", "Application", "msedge.exe") },
+            { label: "Microsoft Edge", executablePath: join(lad, "Microsoft", "Edge", "Application", "msedge.exe") },
+        ];
+    }
+    return [
+        { label: "Google Chrome", executablePath: "/usr/bin/google-chrome-stable" },
+        { label: "Google Chrome", executablePath: "/usr/bin/google-chrome" },
+        { label: "Chromium", executablePath: "/usr/bin/chromium" },
+        { label: "Chromium", executablePath: "/usr/bin/chromium-browser" },
+        { label: "Microsoft Edge", executablePath: "/usr/bin/microsoft-edge" },
+    ];
+}
+function findInstalledBrowser(executablePath) {
+    if (executablePath) {
+        if (!existsSync(executablePath)) {
+            throw new Error(`Configured browser not found: ${executablePath}`);
+        }
+        return { label: "Configured browser", executablePath };
+    }
+    for (const candidate of getKnownBrowserPaths()) {
+        if (existsSync(candidate.executablePath))
+            return candidate;
+    }
+    throw new Error("Could not find a supported Chrome/Edge installation");
+}
+async function getFreePort() {
+    return new Promise((resolve, reject) => {
+        const server = createServer();
+        server.listen(0, "127.0.0.1", () => {
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                server.close();
+                reject(new Error("Failed to allocate a browser debugging port"));
+                return;
+            }
+            const port = address.port;
+            server.close((err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve(port);
+            });
+        });
+        server.on("error", reject);
+    });
+}
+async function waitForDebugger(endpoint, timeoutMs) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        try {
+            const res = await fetch(`${endpoint}/json/version`);
+            if (res.ok)
+                return;
+        }
+        catch {
+            // Startup race.
+        }
+        await delay(500);
+    }
+    throw new Error("Browser did not expose the remote debugging endpoint in time");
+}
+async function waitForPageWebSocket(endpoint, expectedUrl, timeoutMs) {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < timeoutMs) {
+        try {
+            const res = await fetch(`${endpoint}/json/list`);
+            if (res.ok) {
+                const targets = (await res.json());
+                const expectedHost = new URL(expectedUrl).host;
+                const target = targets.find((t) => t.type === "page" &&
+                    t.webSocketDebuggerUrl &&
+                    (t.url?.includes(expectedHost) || targets.length === 1));
+                if (target?.webSocketDebuggerUrl)
+                    return target.webSocketDebuggerUrl;
+            }
+        }
+        catch {
+            // Startup race.
+        }
+        await delay(500);
+    }
+    throw new Error("Browser did not expose a page DevTools websocket in time");
+}
+async function openDevToolsSocket(url) {
+    return new Promise((resolve, reject) => {
+        const socket = new WebSocket(url);
+        const timer = setTimeout(() => {
+            socket.close();
+            reject(new Error("Timed out connecting to browser DevTools websocket"));
+        }, CDP_CALL_TIMEOUT_MS);
+        socket.once("open", () => {
+            clearTimeout(timer);
+            resolve(socket);
+        });
+        socket.once("error", () => {
+            clearTimeout(timer);
+            reject(new Error("Failed to connect to browser DevTools websocket"));
+        });
+    });
+}
+async function sendCdpCommand(socket, method, params = {}) {
+    const id = cdpNextId++;
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            socket.removeEventListener("message", handleMessage);
+            reject(new Error(`CDP timeout: ${method}`));
+        }, CDP_CALL_TIMEOUT_MS);
+        const handleMessage = (event) => {
+            const payload = safeJsonParse(String(event.data));
+            if (payload?.id !== id)
+                return;
+            clearTimeout(timer);
+            socket.removeEventListener("message", handleMessage);
+            if (payload.error)
+                reject(new Error(payload.error.message ?? `CDP error: ${method}`));
+            else
+                resolve((payload.result ?? {}));
+        };
+        socket.addEventListener("message", handleMessage);
+        socket.send(JSON.stringify({ id, method, params }));
+    });
+}
+async function terminateBrowserProcess(child) {
+    if (child.exitCode !== null)
+        return;
+    if (process.platform !== "win32" && child.pid) {
+        try {
+            process.kill(-child.pid, "SIGTERM");
+        }
+        catch {
+            child.kill();
+        }
+    }
+    else {
+        child.kill();
+    }
+    await delay(500);
+    if (child.exitCode === null) {
+        try {
+            if (process.platform !== "win32" && child.pid)
+                process.kill(-child.pid, "SIGKILL");
+            else
+                child.kill("SIGKILL");
+        }
+        catch {
+            // Already exited.
+        }
+    }
+}
+function isInterestingNetworkUrl(url, mimeType) {
+    if (!/doc\.weixin\.qq\.com|weixin\.qq\.com|wecom/i.test(url))
+        return false;
+    return /json|text|javascript|octet-stream|protobuf|grpc|xml|html/i.test(mimeType) ||
+        /cgi|api|doc|sheet|media|image|file|sync|ws/i.test(url);
+}
+function redactUrl(rawUrl) {
+    try {
+        const u = new URL(rawUrl);
+        u.search = "";
+        u.hash = "";
+        return u.toString();
+    }
+    catch {
+        return rawUrl.split("?")[0] ?? rawUrl;
+    }
+}
+function safeJsonParse(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mkterswingman/5mghost-wonder",
-  "version": "0.0.13",
+  "version": "0.0.15",
   "description": "企微文档读取 CLI — WeCom document reader",
   "type": "module",
   "engines": {
@@ -25,7 +25,8 @@
   "scripts": {
     "build": "rm -rf dist && tsc && chmod +x dist/cli.js",
     "typecheck": "tsc --noEmit",
-    "test": "node dist/wecom/url.test.js && node --test tests/sheet-parity.test.mjs && node --test tests/export-sanitize.test.mjs && node --test tests/format.test.mjs && node --test tests/cookies-validation.test.mjs",
+    "check:skills": "node scripts/check-skills.mjs",
+    "test": "npm run check:skills && node dist/wecom/url.test.js && node --test tests/sheet-parity.test.mjs && node --test tests/export-sanitize.test.mjs && node --test tests/format.test.mjs && node --test tests/cookies-validation.test.mjs && node --test tests/browser-read.test.mjs",
     "smoke": "npm run build && node dist/cli.js help > /dev/null",
     "postinstall": "node scripts/postinstall.mjs"
   },