@nextclaw/x-harness 0.1.0 → 0.1.1

package/dist/browser-dom-network.js

@@ -0,0 +1,128 @@
+// Read-only transport diagnostics through the same real Chrome tab capability.
+// Never return credential headers, cookies or bodies; only numeric rate metadata is allowed.
+export async function readXNetworkDiagnostics(tab, { afterSequence = 0, startObserving = false } = {}) {
+    if (typeof tab?.capabilities?.get !== "function")
+        throw new Error("缺真实Chrome诊断能力");
+    const cdp = await tab.capabilities.get("cdp");
+    if (typeof cdp?.readEvents !== "function")
+        throw new Error("缺只读网络事件能力");
+    if (startObserving)
+        await cdp.send("Network.enable");
+    const result = await cdp.readEvents({
+        afterSequence,
+        limit: 1000,
+        methods: [
+            "Network.requestWillBeSent",
+            "Network.responseReceived",
+            "Network.loadingFailed",
+        ],
+    });
+    const traffic = new Map();
+    const times = [];
+    for (const event of result.events) {
+        const p = event.params ?? {};
+        let u;
+        try {
+            u = new URL(p.response?.url ?? p.request?.url);
+        }
+        catch {
+            continue;
+        }
+        if (!((u.hostname === "x.com" && u.pathname.startsWith("/i/api/")) ||
+            u.hostname === "api.x.com"))
+            continue;
+        const location = u.origin + u.pathname;
+        const row = traffic.get(location) ?? {
+            location,
+            requests: 0,
+            responses: 0,
+            statuses: {},
+        };
+        if (event.method === "Network.requestWillBeSent")
+            row.requests++;
+        if (event.method === "Network.responseReceived") {
+            row.responses++;
+            const status = p.response?.status;
+            if (Number.isInteger(status))
+                row.statuses[status] = (row.statuses[status] ?? 0) + 1;
+        }
+        if (Number.isFinite(p.timestamp))
+            times.push(p.timestamp);
+        traffic.set(location, row);
+    }
+    const rates = (headers = {}) => {
+        const allowed = {};
+        for (const [key, value] of Object.entries(headers)) {
+            const name = key.toLowerCase();
+            if (![
+                "x-rate-limit-limit",
+                "x-rate-limit-remaining",
+                "x-rate-limit-reset",
+                "retry-after",
+            ].includes(name))
+                continue;
+            if (!/^\d{1,12}$/.test(String(value).trim()))
+                continue;
+            allowed[name] = Number(value);
+        }
+        const out = {};
+        if (allowed["x-rate-limit-limit"] !== undefined)
+            out.limit = allowed["x-rate-limit-limit"];
+        if (allowed["x-rate-limit-remaining"] !== undefined)
+            out.remaining = allowed["x-rate-limit-remaining"];
+        if (allowed["x-rate-limit-reset"] !== undefined) {
+            const date = new Date(allowed["x-rate-limit-reset"] * 1000);
+            if (Number.isFinite(date.getTime()))
+                out.resetAt = date.toISOString();
+        }
+        if (allowed["retry-after"] !== undefined)
+            out.retryAfterSeconds = allowed["retry-after"];
+        return Object.keys(out).length ? out : undefined;
+    };
+    return {
+        cursor: result.cursor,
+        hasMore: result.hasMore,
+        truncated: result.truncated,
+        traffic: {
+            complete: !result.truncated && !result.hasMore,
+            requests: [...traffic.values()].reduce((n, r) => n + r.requests, 0),
+            responses: [...traffic.values()].reduce((n, r) => n + r.responses, 0),
+            durationSeconds: times.length > 1 ? Math.max(...times) - Math.min(...times) : null,
+            endpointCount: traffic.size,
+            endpoints: [...traffic.values()]
+                .sort((a, b) => b.requests - a.requests)
+                .slice(0, 10),
+        },
+        events: result.events
+            .map((e) => {
+            const p = e.params ?? {};
+            const response = p.response ?? {};
+            let location;
+            try {
+                const u = new URL(response.url ?? p.request?.url);
+                location = ["http:", "https:"].includes(u.protocol)
+                    ? u.origin + u.pathname
+                    : null;
+            }
+            catch {
+                location = null;
+            }
+            return {
+                method: e.method,
+                requestId: p.requestId,
+                location,
+                requestMethod: p.request?.method,
+                status: response.status,
+                errorText: p.errorText,
+                canceled: p.canceled,
+                timestamp: Number.isFinite(p.timestamp) ? p.timestamp : undefined,
+                rateLimit: rates(response.headers),
+            };
+        })
+            .filter((e) => e.method === "Network.loadingFailed" ||
+            (e.location &&
+                (e.status >= 400 ||
+                    e.requestMethod === "POST" ||
+                    /\/(EditTweet|CreateTweet)$/.test(e.location)))),
+    };
+}

package/dist/browser-dom-submission.d.ts

@@ -0,0 +1,2 @@
+import type { DOMDependencies } from "./browser-dom-dependencies.js";
+export declare function createDOMSubmission(dependencies: Pick<DOMDependencies, "submitAX" | "session" | "tab" | "observe" | "unique" | "locator">): (command: any, prepared: any, query: any, result: any) => Promise<void>;

package/dist/browser-dom-submission.js

@@ -0,0 +1,82 @@
+import { xURL } from "./platform-rules.js";
+import { valueOf } from "./browser-common.js";
+export function createDOMSubmission(dependencies) {
+    const { submitAX, session, tab, observe, unique, locator } = dependencies;
+    return async function finishDOMAction(command, prepared, query, result) {
+        const { loc, submittedEditor } = prepared;
+        const binding = command.operation === "openReply"
+            ? {
+                page: result.page,
+                postId: command.postId,
+                body: result.posts[0].body,
+                author: result.posts[0].author,
+            }
+            : null;
+        let nativeSubmitIndex;
+        if (submitAX && ["submitPost", "submitReply"].includes(command.operation)) {
+            const native = await submitAX.observe({ mode: "composer" });
+            const editors = native.evidence?.filter((e) => /^(?:文本输入区(?:域)?|文本区域|文本栏) /.test(e.label)) ?? [];
+            const buttons = native.evidence?.filter((e) => new RegExp(command.operation === "submitReply"
+                ? "^按钮 (回复|Reply)(?:,|$)"
+                : "^按钮 (发帖|发布|Post)(?:,|$)", "i").test(e.label)) ?? [];
+            if (native.needsStateCheck ||
+                native.alerts?.length ||
+                xURL(native.page).href !== xURL(result.page).href ||
+                editors.length !== 1 ||
+                valueOf(editors[0].label)?.trim() !== result.editorText.trim() ||
+                buttons.length !== 1)
+                throw new Error("原生提交缺同页、全文及唯一按钮证据");
+            nativeSubmitIndex = buttons[0].index;
+        }
+        if (["submitPost", "submitReply"].includes(command.operation))
+            await command.beforeSubmit?.();
+        session.current = null;
+        if (nativeSubmitIndex !== undefined)
+            await submitAX.act({
+                index: nativeSubmitIndex,
+                operation: "click",
+                read: { mode: "composer" },
+            });
+        else if (command.activation === "keyboard")
+            await loc.press("Enter");
+        else
+            await loc.click();
+        if (binding) {
+            session.replyBinding = binding;
+            await tab.playwright
+                .getByRole("textbox", { name: /^(帖子文本|Post text)$/i })
+                .waitFor({ state: "visible", timeoutMs: 5000 });
+            if (xURL(await tab.url()).pathname === "/compose/post")
+                await tab.playwright
+                    .getByText(`回复 @${binding.author}`, { exact: true })
+                    .waitFor({ state: "visible", timeoutMs: 5000 });
+            const composer = await observe({ view: "composer" });
+            const quote = composer.replyQuotes?.length === 1 ? composer.replyQuotes[0] : null;
+            if (!composer.replyToId &&
+                !composer.needsStateCheck &&
+                !composer.alerts?.length &&
+                composer.editorText?.trim() === "" &&
+                composer.replyContexts?.length === 1 &&
+                composer.replyContexts[0].includes(`回复 @${binding.author}`) &&
+                /显示更多|Show more/.test(composer.replyContexts[0]) &&
+                quote?.length >= 30 &&
+                binding.body?.startsWith(quote)) {
+                // Expand the observed quote; the unchanged full-context binding gate must still pass.
+                const dialog = await unique(locator("dialog").filter({ visible: true }));
+                const more = await unique(dialog.getByRole("button", { name: /^(显示更多|Show more)$/i }));
+                session.current = null;
+                await more.click();
+                await observe({ view: "composer" });
+            }
+        }
+        // Inline replies keep the editor mounted. Wait for this submitted text to clear before
+        // receipt navigation/reload can interrupt the actual submission request.
+        if (submittedEditor)
+            await submittedEditor.waitFor({ state: "hidden", timeoutMs: 10000 });
+        if (["submitPost", "submitReply"].includes(command.operation))
+            await tab.playwright.waitForLoadState({
+                state: "networkidle",
+                timeoutMs: 8000,
+            });
+    };
+}

package/dist/browser-dom.d.ts

@@ -1,2 +1,2 @@
+export { readXNetworkDiagnostics } from "./browser-dom-network.js";
 export declare function createDOMXBrowser(tab: any, { readDOM, nativeSubmit }?: any): any;
-export declare function readXNetworkDiagnostics(tab: any, { afterSequence, startObserving }?: any): Promise<any>;