@nextclaw/x-harness 0.1.0 → 0.1.1

package/dist/platform-writing.js

@@ -0,0 +1,171 @@
+import { xURL, sameHandle, sameText, samePublishedText, } from "./platform-rules.js";
+export function createPlatformWriting(dependencies) {
+    const { observed, browser, followStage, readPerson, open, clock, readPost } = dependencies;
+    async function compose(action) {
+        let value = await observed({ view: "composer" });
+        if (value.needsStateCheck ||
+            value.alerts?.length ||
+            typeof value.editorText !== "string" ||
+            value.editorText.trim() !== "" ||
+            (action.kind === "reply" && value.replyToId !== action.postId))
+            throw new Error("编辑器不为空或回复上下文未绑定");
+        if (action.assets?.length)
+            await browser.act({ operation: "attachAssets", assets: action.assets });
+        await browser.act({ operation: "fillComposer", text: action.text });
+        value = await observed({ view: "composer" });
+        if (!sameText(value.editorText, action.text) ||
+            value.needsStateCheck ||
+            value.alerts?.length ||
+            (action.kind === "reply" && value.replyToId !== action.postId) ||
+            (action.accountHandle &&
+                !sameHandle(value.accountHandle, action.accountHandle)))
+            throw new Error(`提交前账号/正文/目标未核实 ${JSON.stringify({ textMatches: sameText(value.editorText, action.text), needsStateCheck: value.needsStateCheck, alerts: value.alerts, accountHandle: value.accountHandle, replyToId: value.replyToId })}`);
+        return browser.act({
+            operation: action.kind === "reply" ? "submitReply" : "submitPost",
+            beforeSubmit: action.beforeSubmit,
+            ...(action.activation ? { activation: action.activation } : {}),
+        });
+    }
+    async function findSubmission(action) {
+        if (action.kind === "follow") {
+            let value = await followStage(action, "verify-read", () => readPerson(action));
+            if (!value.needsStateCheck) {
+                const absent = browser.capabilities?.("refreshPerson") ?? [
+                    "refreshPerson",
+                ];
+                if (absent.length)
+                    return {
+                        ...value,
+                        verified: false,
+                        missing: absent,
+                        needsStateCheck: true,
+                    };
+                await followStage(action, "verify-refresh", () => browser.act({
+                    operation: "refreshPerson",
+                    handle: action.handle,
+                    url: action.url,
+                    evidenceRef: action.evidenceRef,
+                }));
+                value = await followStage(action, "verify-after-refresh", () => readPerson(action));
+            }
+            return {
+                ...value,
+                verified: !value.needsStateCheck &&
+                    !value.alerts?.length &&
+                    value.relationship === "following" &&
+                    (!action.accountHandle ||
+                        sameHandle(value.accountHandle, action.accountHandle)),
+                publicId: null,
+            };
+        }
+        // A bounded window cannot prove absence. Reply receipts use the observed target conversation.
+        const observedReceipt = ["reply", "original"].includes(action.kind) &&
+            action.observedPublicURL &&
+            action.observedPublicEvidenceRef;
+        const receiptPath = observedReceipt
+            ? xURL(action.observedPublicURL).pathname.split("/")
+            : [];
+        if (observedReceipt &&
+            (receiptPath.length !== 4 ||
+                !sameHandle(receiptPath[1], action.accountHandle) ||
+                receiptPath[2] !== "status" ||
+                !/^[0-9]+$/.test(receiptPath[3])))
+            throw new Error("已观察回复回执须属于原账号");
+        const receiptTarget = observedReceipt
+            ? {
+                url: action.observedPublicURL,
+                evidenceRef: action.observedPublicEvidenceRef,
+            }
+            : action.kind === "reply" && action.url && action.evidenceRef
+                ? { url: action.url, evidenceRef: action.evidenceRef }
+                : { url: action.accountURL, evidenceRef: action.accountEvidenceRef };
+        let value = await open(receiptTarget, { view: "posts", limit: 5 });
+        if (!(action.kind === "original" && observedReceipt) &&
+            !value.needsStateCheck &&
+            !(browser.capabilities?.("refreshPosts") ?? ["refreshPosts"]).length) {
+            await browser.act({
+                operation: "refreshPosts",
+                url: receiptTarget.url,
+                evidenceRef: receiptTarget.evidenceRef,
+            });
+            value = await observed({ view: "posts", limit: 5 });
+        }
+        const matchesContent = (post) => sameHandle(post.author, action.accountHandle) &&
+            samePublishedText(post.body, action.text) &&
+            /^\d+$/.test(post.id ?? "") &&
+            (!action.assets?.length ||
+                action.assets.every((asset) => post.images?.some((image) => image.alt === asset.alt))) &&
+            !(action.beforeIds ?? []).includes(post.id) &&
+            Number.isFinite(Date.parse(post.datetime)) &&
+            Date.parse(post.datetime) >= Date.parse(action.intentAt) &&
+            Date.parse(post.datetime) <= clock() + 5000 &&
+            !post.needsExpansion;
+        let matches = (value.posts ?? []).filter(matchesContent);
+        if (action.kind === "reply" &&
+            matches.length === 1 &&
+            matches[0].replyToId == null &&
+            matches[0].primary) {
+            // The candidate URL comes from this fresh public observation, not from a guessed ID path.
+            const candidate = matches[0];
+            const url = xURL(new URL(candidate.primary, xURL(value.page).origin).href);
+            if (url.pathname.toLowerCase() ===
+                `/${action.accountHandle}/status/${candidate.id}`.toLowerCase()) {
+                value = await open({
+                    url: url.href,
+                    evidenceRef: {
+                        page: value.page,
+                        observedAt: value.observedAt,
+                        publicId: candidate.id,
+                        primary: candidate.primary,
+                    },
+                }, {
+                    view: "posts",
+                    targetId: candidate.id,
+                    replyTargetId: action.postId,
+                });
+                matches = (value.posts ?? []).filter(matchesContent);
+            }
+        }
+        if (action.kind === "reply")
+            matches = matches.filter((post) => post.replyToId === action.postId);
+        return {
+            ...value,
+            verified: !value.needsStateCheck && !value.alerts?.length && matches.length === 1,
+            publicId: matches.length === 1 ? matches[0].id : null,
+            missing: matches.length === 1 ? [] : ["unique-public-submission-unconfirmed"],
+        };
+    }
+    async function submitFollow(action) {
+        const value = await followStage(action, "submit-preflight-read", () => readPerson(action));
+        if (value.needsStateCheck ||
+            value.alerts?.length ||
+            !["not-following", "follows-you"].includes(value.relationship) ||
+            (action.accountHandle &&
+                !sameHandle(value.accountHandle, action.accountHandle)))
+            throw new Error("fresh账号/人物关系不允许关注");
+        await followStage(action, "submit-guard", () => action.beforeSubmit?.());
+        // A returned click is not a receipt from X; durable success still requires fresh verification.
+        const clicked = await followStage(action, "click", () => browser.act({ operation: "follow", handle: action.handle }));
+        try {
+            await followStage(action, "click-ui-observation", () => observed({ view: "person", handle: action.handle }));
+        }
+        catch {
+            /* The click may have committed; retain diagnostic failure and use the original fresh receipt path. */
+        }
+        return clicked;
+    }
+    async function submitPost(action) {
+        await open({ url: action.composeURL, evidenceRef: action.composeEvidenceRef }, { view: "composer" });
+        return compose(action);
+    }
+    async function submitReply(action) {
+        const value = await readPost(action);
+        if (value.needsStateCheck ||
+            value.alerts?.length ||
+            !(value.posts ?? []).some((p) => p.id === action.postId))
+            throw new Error("回复主帖身份未核实");
+        await browser.act({ operation: "openReply", postId: action.postId });
+        return compose(action);
+    }
+    return { compose, findSubmission, submitFollow, submitPost, submitReply };
+}

package/dist/platform.d.ts

@@ -1,2 +1,2 @@
-export declare function xURL(value: any): any;
+export { xURL } from "./platform-rules.js";
 export declare function createXPlatform(browser: any, { clock }?: any): any;