@nextclaw/x-harness 0.0.0-stage → 0.1.1

package/dist/platform-capabilities.js

@@ -0,0 +1,19 @@
+export function createPlatformCapabilities(dependencies) {
+    const { missing, browser } = dependencies;
+    function preflight({ operation, input = {} }) {
+        const absent = missing(operation);
+        if (operation === "readCreator" &&
+            typeof browser.collectCreator !== "function")
+            absent.push("browser.collectCreator");
+        if (input.kind === "follow" || operation === "submitFollow")
+            absent.push(...(browser.capabilities?.("refreshPerson") ?? ["refreshPerson"]));
+        if (operation !== "read" && input.assets?.length)
+            absent.push(...(browser.capabilities?.("attachAssets") ?? ["attachAssets"]));
+        return {
+            covered: absent.length === 0,
+            missing: [...new Set(absent)],
+            owner: "scripts/x-harness-browser.mjs",
+        };
+    }
+    return { preflight };
+}

package/dist/platform-collections.d.ts

@@ -0,0 +1,7 @@
+import type { PlatformDependencies } from "./platform-dependencies.js";
+export declare function createPlatformCollections(dependencies: Pick<PlatformDependencies, "ready" | "observed" | "browser" | "choose">): {
+    collectSources: ({ processedIds, maxPages, limit, }?: any) => Promise<any>;
+    readCreator: (args: import("./types.js").CreatorOptions) => Promise<any>;
+    readBookmarks: ({ folder, ...window }?: any) => Promise<any>;
+    searchSources: ({ query, limit, maxPages, processedIds, }?: any) => Promise<any>;
+};

package/dist/platform-collections.js

@@ -0,0 +1,223 @@
+import { xURL, source } from "./platform-rules.js";
+export function createPlatformCollections(dependencies) {
+    const { ready, observed, browser, choose } = dependencies;
+    async function collectSources({ processedIds = [], maxPages = 3, limit = 1, } = {}) {
+        if (!Array.isArray(processedIds) ||
+            !Number.isInteger(maxPages) ||
+            maxPages < 1 ||
+            maxPages > 10 ||
+            !Number.isInteger(limit) ||
+            limit < 1 ||
+            limit > 5)
+            throw new Error("来源窗口须为1–5，页面上限1–10及已处理ID数组");
+        const seen = new Set(processedIds), sources = [], missing = [];
+        let last, previousIds = "", offset = 0, firstDOMId;
+        for (let page = 0; page < maxPages && sources.length < limit; page++) {
+            last = await ready({ view: "posts", offset, limit: 5 });
+            if (page === 0)
+                firstDOMId = last.posts?.[0]?.id;
+            if (last.needsStateCheck || last.alerts?.length)
+                return {
+                    ...last,
+                    sources,
+                    complete: false,
+                    missing: ["source-page-unconfirmed"],
+                };
+            if (offset && !last.posts?.length) {
+                missing.push("source-window-not-yet-rendered");
+                break;
+            }
+            const ids = (last.posts ?? []).map((p) => p.id).join(",");
+            if (page && ids === previousIds) {
+                missing.push("pagination-did-not-advance");
+                break;
+            }
+            previousIds = ids;
+            for (const candidate of last.posts ?? []) {
+                if (!candidate.id || seen.has(candidate.id))
+                    continue;
+                seen.add(candidate.id);
+                let post = candidate;
+                if (candidate.needsExpansion) {
+                    const target = await observed({
+                        view: "posts",
+                        targetId: candidate.id,
+                        limit: 1,
+                    });
+                    if (target.posts?.length !== 1) {
+                        missing.push("expansion-target-unconfirmed");
+                        continue;
+                    }
+                    await browser.act({ operation: "expandPost", postId: candidate.id });
+                    const expanded = await ready({
+                        view: "posts",
+                        targetId: candidate.id,
+                        limit: 1,
+                    });
+                    if (expanded.needsStateCheck || expanded.alerts?.length)
+                        return {
+                            ...expanded,
+                            sources,
+                            complete: false,
+                            missing: ["expanded-source-unconfirmed"],
+                        };
+                    post = expanded.posts?.[0];
+                }
+                if (!post ||
+                    post.needsExpansion ||
+                    !post.body ||
+                    !post.author ||
+                    !Number.isFinite(Date.parse(post.datetime))) {
+                    missing.push(`incomplete-source:${candidate.id}`);
+                    continue;
+                }
+                sources.push(source(post, last.page));
+                if (sources.length >= limit)
+                    break;
+            }
+            if (sources.length < limit && page + 1 < maxPages) {
+                // Expansion narrowed the semantic window; restore the list before scrolling.
+                last = await observed({ view: "posts", offset, limit: 5 });
+                if (last.moreInDOM)
+                    offset += 5;
+                else {
+                    await browser.act({ operation: "nextPosts" });
+                    const advanced = await ready({ view: "posts", limit: 5 });
+                    // Retained DOM prefixes include a partial final window too; skip
+                    // exactly the consumed cards, while virtualized replacements restart.
+                    offset =
+                        firstDOMId && advanced.posts?.[0]?.id === firstDOMId
+                            ? offset + (last.posts?.length ?? 0)
+                            : 0;
+                    firstDOMId = advanced.posts?.[0]?.id;
+                }
+            }
+        }
+        return {
+            page: last?.page,
+            accountHandle: last?.accountHandle,
+            observedAt: last?.observedAt,
+            fresh: true,
+            sources,
+            complete: sources.length >= limit,
+            pageComplete: false,
+            missing: sources.length >= limit
+                ? []
+                : [...new Set([...missing, "bounded-source-window-exhausted"])],
+        };
+    }
+    async function readCreator(args) {
+        if (typeof browser.collectCreator !== "function")
+            return {
+                status: "needsCapability",
+                complete: false,
+                missing: ["browser.collectCreator"],
+            };
+        const value = await browser.collectCreator(args);
+        const absent = [
+            ...new Set([
+                ...(value.missing ?? []),
+                ...(value.profile?.alerts ?? []),
+                ...(value.meta?.missing ?? []),
+            ]),
+        ];
+        return {
+            ...value,
+            sources: value.posts,
+            page: `https://x.com/${args.handle}`,
+            pageComplete: false,
+            complete: value.complete === true && !absent.length && !value.alerts?.length,
+            missing: absent,
+        };
+    }
+    async function readBookmarks({ folder, ...window } = {}) {
+        if (typeof folder !== "string" || !folder.trim())
+            throw new Error("需指定收藏文件夹；不以全部书签冒充命名文件夹");
+        let nav = await ready({ view: "navigation", targetLabel: folder });
+        const bookmark = (c) => /^(书签|收藏|Bookmarks)$/i.test(c.label);
+        if (!(await choose(nav, bookmark, { activateSelected: true }))) {
+            if (await choose(nav, (c) => /^(更多菜单项|More menu items)$/i.test(c.label))) {
+                nav = await ready({ view: "menu" });
+                if (!(await choose(nav, bookmark))) {
+                    if (nav.items?.length)
+                        await browser.act({ operation: "dismissMenu" });
+                    nav = await ready({ view: "navigation", targetLabel: folder });
+                    if (!(await choose(nav, (c) => /^(历史|History)$/i.test(c.label))))
+                        return {
+                            status: "needsCapability",
+                            owner: "scripts/x-harness-browser.mjs",
+                            missing: ["bookmarks-entry-not-observed"],
+                        };
+                }
+            }
+            else if (!(await choose(nav, (c) => /^(历史|History)$/i.test(c.label))))
+                return {
+                    status: "needsCapability",
+                    owner: "scripts/x-harness-browser.mjs",
+                    missing: ["bookmarks-entry-not-observed"],
+                };
+        }
+        nav = await ready({ view: "navigation", targetLabel: folder });
+        const tabs = (nav.controls ?? []).filter((c) => c.role === "tab" && bookmark(c));
+        if (tabs.length === 1 &&
+            (!tabs[0].selected ||
+                !(nav.controls ?? []).some((c) => c.label.split("\n")[0] === folder))) {
+            await choose(nav, (c) => c === tabs[0], {
+                activateSelected: true,
+            });
+            nav = await ready({ view: "navigation", targetLabel: folder });
+        }
+        if (!(nav.controls ?? []).some((c) => c.label.split("\n")[0] === folder)) {
+            try {
+                await browser.act({ operation: "waitForFolder", folder });
+            }
+            catch (error) {
+                if (!/timed out|timeout/i.test(error.message))
+                    throw error;
+            }
+            nav = await ready({ view: "navigation", targetLabel: folder });
+        }
+        if (!(await choose(nav, (c) => c.label.split("\n")[0] === folder)))
+            return {
+                status: "needsCapability",
+                owner: "scripts/x-harness-browser.mjs",
+                page: nav.page,
+                missing: ["named-bookmark-folder-not-observed"],
+                folder,
+                controls: nav.controls,
+            };
+        const selected = await ready({ view: "navigation" });
+        if (selected.page === nav.page && !selected.headings?.includes(folder))
+            return {
+                status: "needsDecision",
+                complete: false,
+                missing: ["folder-selection-unconfirmed"],
+                folder,
+                page: selected.page,
+            };
+        const value = await collectSources(window);
+        return {
+            ...value,
+            folder,
+            folderEvidence: {
+                entryPage: nav.page,
+                selectedPage: selected.page,
+                name: folder,
+            },
+        };
+    }
+    async function searchSources({ query, limit = 3, maxPages = 1, processedIds = [], } = {}) {
+        await browser.act({ operation: "searchSources", query });
+        const value = await collectSources({ limit, maxPages, processedIds });
+        if (!value.page ||
+            xURL(value.page).pathname !== "/search" ||
+            xURL(value.page).searchParams.get("q") !== query)
+            return {
+                ...value,
+                complete: false,
+                missing: ["search-query-unconfirmed"],
+            };
+        return { ...value, query };
+    }
+    return { collectSources, readCreator, readBookmarks, searchSources };
+}

package/dist/platform-dependencies.d.ts

@@ -0,0 +1,43 @@
+import type { CreatorOptions } from "./types.js";
+import type { BoundaryRecord } from "./boundary.js";
+export interface PlatformDependencies {
+    browser: BoundaryRecord;
+    clock: () => number;
+    followStage: (action: any, stage: any, run: any) => Promise<any>;
+    missing: (operation: any) => any[];
+    observed: (query: any) => Promise<any>;
+    open: (target: any, query: any) => Promise<any>;
+    ready: (query: any) => Promise<any>;
+    choose: (value: any, pattern: any, { activateSelected }?: any) => Promise<any>;
+    source: (post: any, page: any) => {
+        id: any;
+        author: any;
+        datetime: any;
+        url: string | null;
+        body: any;
+        images: any;
+        media: any;
+        links: any;
+        needsExpansion: any;
+        missing: any[];
+    };
+    collectSources: ({ processedIds, maxPages, limit }?: any) => Promise<any>;
+    compose: (action: any) => Promise<any>;
+    preflight: ({ operation, input }: any) => any;
+    readCreator: (args: CreatorOptions) => Promise<any>;
+    readAccount: () => Promise<any>;
+    readBookmarks: ({ folder, ...window }?: any) => Promise<any>;
+    searchSources: ({ query, limit, maxPages, processedIds, }?: any) => Promise<any>;
+    readFeedback: ({ targets, replyLimit }?: any) => Promise<any>;
+    readPerson: (target: any) => Promise<any>;
+    readPost: (target: any) => Promise<any>;
+    findSubmission: (action: any) => Promise<any>;
+    submitFollow: (action: any) => Promise<any>;
+    submitPost: (action: any) => Promise<any>;
+    submitReply: (action: any) => Promise<any>;
+    captureProof: ({ observation }: any) => {
+        followDiagnostics?: any[] | undefined;
+        capturedAt: string;
+        observation: any;
+    };
+}

package/dist/platform-diagnostics.d.ts

@@ -0,0 +1,9 @@
+import type { PlatformDependencies } from "./platform-dependencies.js";
+export declare function createPlatformDiagnostics(dependencies: Pick<PlatformDependencies, "clock">): {
+    followStage: (action: any, stage: any, run: any) => Promise<any>;
+    captureProof: ({ observation }: any) => {
+        followDiagnostics?: any[] | undefined;
+        capturedAt: string;
+        observation: any;
+    };
+};

package/dist/platform-diagnostics.js

@@ -0,0 +1,51 @@
+export function createPlatformDiagnostics(dependencies) {
+    const { clock } = dependencies;
+    // Bounded semantic diagnostics travel with existing proof captures; no page dump or second state store.
+    const followDiagnostics = [];
+    async function followStage(action, stage, run) {
+        const started = clock();
+        const event = {
+            actionId: action.id ?? null,
+            handle: action.handle,
+            stage,
+            startedAt: new Date(started).toISOString(),
+        };
+        followDiagnostics.push(event);
+        if (followDiagnostics.length > 40)
+            followDiagnostics.shift();
+        try {
+            const value = await run();
+            Object.assign(event, {
+                status: "returned",
+                durationMs: clock() - started,
+            });
+            if (value && typeof value === "object")
+                Object.assign(event, {
+                    page: value.page,
+                    accountHandle: value.accountHandle,
+                    relationship: value.relationship,
+                    relationshipControls: value.relationshipControls,
+                    needsStateCheck: value.needsStateCheck,
+                    alerts: value.alerts,
+                    fresh: value.fresh,
+                });
+            return value;
+        }
+        catch (error) {
+            Object.assign(event, {
+                status: "error",
+                durationMs: clock() - started,
+                error: String(error.message ?? error).slice(0, 500),
+            });
+            throw error;
+        }
+    }
+    const captureProof = ({ observation }) => ({
+        capturedAt: new Date(clock()).toISOString(),
+        observation,
+        ...(followDiagnostics.length
+            ? { followDiagnostics: structuredClone(followDiagnostics) }
+            : {}),
+    });
+    return { followStage, captureProof };
+}

package/dist/platform-observation.d.ts

@@ -0,0 +1,8 @@
+import type { PlatformDependencies } from "./platform-dependencies.js";
+export declare function createPlatformObservation(dependencies: Pick<PlatformDependencies, "browser" | "clock">): {
+    missing: (operation: any) => any[];
+    observed: (query: any) => Promise<any>;
+    open: (target: any, query: any) => Promise<any>;
+    ready: (query: any) => Promise<any>;
+    choose: (value: any, pattern: any, { activateSelected }?: any) => Promise<any>;
+};

package/dist/platform-observation.js

@@ -0,0 +1,75 @@
+import { xURL } from "./platform-rules.js";
+export function createPlatformObservation(dependencies) {
+    const { browser, clock } = dependencies;
+    const methods = ["observe", "act"];
+    const missing = (operation) => [
+        ...methods.filter((name) => typeof browser?.[name] !== "function"),
+        ...(typeof browser?.capabilities === "function"
+            ? browser.capabilities(operation)
+            : ["capabilities"]),
+    ];
+    async function observed(query) {
+        const value = await browser.observe(query);
+        return {
+            ...value,
+            observedAt: new Date(clock()).toISOString(),
+            fresh: true,
+        };
+    }
+    async function open(target, query) {
+        const url = xURL(target.url);
+        if (!target.evidenceRef)
+            throw new Error("目标URL缺已观察证据");
+        let value = await observed(query);
+        let atTarget = false;
+        try {
+            atTarget = xURL(value.page).href === url.href;
+        }
+        catch {
+            /* Blank/non-X pages require observed navigation. */
+        }
+        if (!atTarget) {
+            await browser.act({
+                operation: "openObserved",
+                url: url.href,
+                evidenceRef: target.evidenceRef,
+                view: query.view,
+                handle: query.handle,
+            });
+            value = await ready(query);
+        }
+        if (!value.page || xURL(value.page).href !== url.href)
+            return {
+                ...value,
+                needsStateCheck: true,
+                missing: ["target-page-mismatch"],
+            };
+        return value;
+    }
+    async function ready(query) {
+        let value = await observed(query);
+        if (value.needsStateCheck &&
+            !value.alerts?.length &&
+            query.view === "posts") {
+            try {
+                await browser.act({ operation: "waitForPosts" });
+            }
+            catch (error) {
+                if (!/timed out|timeout/i.test(error.message))
+                    throw error;
+            }
+            value = await observed(query);
+        }
+        return value;
+    }
+    async function choose(value, pattern, { activateSelected = false } = {}) {
+        const controls = (value.controls ?? value.items ?? []).filter((c) => !c.disabled && pattern(c));
+        if (controls.length !== 1)
+            return false;
+        if (controls[0].selected && !activateSelected)
+            return true;
+        await browser.act({ operation: "openControl", ...controls[0] });
+        return true;
+    }
+    return { missing, observed, open, ready, choose };
+}

package/dist/platform-rules.d.ts

@@ -0,0 +1,17 @@
+export declare const handlePattern: RegExp;
+export declare function xURL(value: any): any;
+export declare const sameHandle: (a: any, b: any) => boolean;
+export declare const sameText: (a: any, b: any) => boolean;
+export declare const samePublishedText: (a: any, b: any) => boolean;
+export declare const source: (post: any, page: any) => {
+    id: any;
+    author: any;
+    datetime: any;
+    url: string | null;
+    body: any;
+    images: any;
+    media: any;
+    links: any;
+    needsExpansion: any;
+    missing: any[];
+};

package/dist/platform-rules.js

@@ -0,0 +1,41 @@
+export const handlePattern = /^[A-Za-z0-9_]{1,15}$/;
+export function xURL(value) {
+    const url = new URL(/^x\.com\//.test(value ?? "") ? `https://${value}` : value);
+    if (url.protocol !== "https:" ||
+        url.hostname !== "x.com" ||
+        url.username ||
+        url.password ||
+        url.port)
+        throw new Error("只接受已观察的https://x.com目标");
+    return url;
+}
+export const sameHandle = (a, b) => typeof a === "string" &&
+    typeof b === "string" &&
+    a.toLowerCase() === b.toLowerCase();
+export const sameText = (a, b) => typeof a === "string" &&
+    typeof b === "string" &&
+    a.replace(/\r\n/g, "\n").replace(/\n{3,}/g, "\n\n") ===
+        b.replace(/\r\n/g, "\n").replace(/\n{3,}/g, "\n\n");
+export const samePublishedText = (a, b) => {
+    const rendered = (value) => typeof value === "string"
+        ? value
+            .replace(/(https?:\/\/[^\s…]+)…(?=\s|$)/g, "$1")
+            .replace(/(https?:\/\/[A-Za-z0-9.-]+(?::\d+)?)\/(?=[\s`]|$)/g, "$1")
+        : value;
+    return sameText(rendered(a), rendered(b));
+};
+export const source = (post, page) => ({
+    id: post.id,
+    author: post.author,
+    datetime: post.datetime,
+    url: post.primary ? new URL(post.primary, page).href : null,
+    body: post.body,
+    images: post.images ?? [],
+    media: post.media ?? [],
+    links: post.links ?? [],
+    needsExpansion: post.needsExpansion,
+    missing: [
+        ...(post.missing ?? []),
+        ...(!post.body ? ["exact-body-unconfirmed"] : []),
+    ],
+});

package/dist/platform-targets.d.ts

@@ -0,0 +1,7 @@
+import type { PlatformDependencies } from "./platform-dependencies.js";
+export declare function createPlatformTargets(dependencies: Pick<PlatformDependencies, "observed" | "open" | "browser" | "ready">): {
+    readAccount: () => Promise<any>;
+    readFeedback: ({ targets, replyLimit, }?: any) => Promise<any>;
+    readPerson: (target: any) => Promise<any>;
+    readPost: (target: any) => Promise<any>;
+};

package/dist/platform-targets.js

@@ -0,0 +1,129 @@
+import { xURL, sameHandle, handlePattern, source } from "./platform-rules.js";
+export function createPlatformTargets(dependencies) {
+    const { observed, open, browser, ready } = dependencies;
+    const readAccount = () => observed({ view: "account" });
+    async function readFeedback({ targets, replyLimit = 3, } = {}) {
+        if (!Array.isArray(targets) || targets.length < 1 || targets.length > 5)
+            throw new Error("反馈窗口须为1–5个已发布ID");
+        if (!Number.isInteger(replyLimit) || replyLimit < 0 || replyLimit > 3)
+            throw new Error("回复核验窗口须为0–3");
+        const feedback = [];
+        for (const target of targets) {
+            const value = await readPost(target), post = value.posts?.find((p) => p.id === target.postId);
+            if (value.needsStateCheck || value.alerts?.length || !post) {
+                feedback.push({
+                    id: target.postId,
+                    missing: ["published-post-unconfirmed"],
+                });
+                continue;
+            }
+            const thread = await observed({ view: "posts", limit: 5 });
+            const replies = [], unconfirmedReplyIds = [];
+            const targetIndex = (thread.posts ?? []).findIndex((p) => p.id === post.id);
+            const candidates = targetIndex < 0
+                ? []
+                : thread.posts.slice(targetIndex + 1, targetIndex + 1 + replyLimit);
+            for (const candidate of candidates) {
+                if (!candidate.primary || !candidate.id)
+                    continue;
+                const url = new URL(candidate.primary, thread.page).href;
+                const detail = await open({
+                    url,
+                    evidenceRef: {
+                        page: thread.page,
+                        observedAt: thread.observedAt,
+                        publicId: candidate.id,
+                        primary: candidate.primary,
+                    },
+                }, {
+                    view: "posts",
+                    targetId: candidate.id,
+                    replyTargetId: target.postId,
+                    limit: 1,
+                });
+                const reply = detail.posts?.find((p) => p.id === candidate.id);
+                if (!detail.needsStateCheck &&
+                    !detail.alerts?.length &&
+                    reply?.replyToId === target.postId &&
+                    reply.body &&
+                    !reply.needsExpansion)
+                    replies.push(source(reply, detail.page));
+                else
+                    unconfirmedReplyIds.push(candidate.id);
+            }
+            feedback.push({
+                id: post.id,
+                author: post.author,
+                metrics: [...(post.buttons ?? []), ...(post.metrics ?? [])],
+                replies,
+                unconfirmedReplyIds,
+                pageComplete: false,
+                observedAt: value.observedAt,
+            });
+        }
+        return {
+            feedback,
+            fresh: true,
+            complete: feedback.every((f) => !f.missing),
+            pageComplete: false,
+        };
+    }
+    async function readPerson(target) {
+        if (!handlePattern.test(target.handle ?? ""))
+            throw new Error("无效已观察handle");
+        if (xURL(target.url).pathname.toLowerCase() !==
+            `/${target.handle}`.toLowerCase())
+            throw new Error("人物URL与handle不一致");
+        const value = await open(target, {
+            view: "person",
+            handle: target.handle,
+        });
+        return sameHandle(value.handle, target.handle)
+            ? { ...value, url: target.url }
+            : {
+                ...value,
+                needsStateCheck: true,
+                missing: ["person-identity-mismatch"],
+            };
+    }
+    async function readPost(target) {
+        if (!/^\d+$/.test(target.postId ?? "") ||
+            xURL(target.url).pathname.match(/\/status\/(\d+)$/)?.[1] !== target.postId)
+            throw new Error("帖子URL与公开ID不一致");
+        let value = await open(target, {
+            view: "posts",
+            targetId: target.postId,
+        });
+        if (!target.expand)
+            return value;
+        let posts = (value.posts ?? []).filter((p) => p.id === target.postId);
+        if (!value.needsStateCheck &&
+            !value.alerts?.length &&
+            posts.length === 1 &&
+            posts[0].needsExpansion) {
+            await browser.act({ operation: "expandPost", postId: target.postId });
+            value = await ready({ view: "posts", targetId: target.postId });
+            posts = (value.posts ?? []).filter((p) => p.id === target.postId);
+        }
+        const missing = [...(value.missing ?? [])];
+        if (posts.length !== 1)
+            missing.push("unique-target-post-unconfirmed");
+        else {
+            if (!posts[0].body)
+                missing.push("exact-body-unconfirmed");
+            if (posts[0].needsExpansion)
+                missing.push("post-expansion-unconfirmed");
+            if (!posts[0].author)
+                missing.push("post-author-unconfirmed");
+            if (!Number.isFinite(Date.parse(posts[0].datetime)))
+                missing.push("absolute-time-unconfirmed");
+        }
+        return {
+            ...value,
+            posts,
+            complete: !missing.length && !value.needsStateCheck && !value.alerts?.length,
+            missing,
+        };
+    }
+    return { readAccount, readFeedback, readPerson, readPost };
+}

package/dist/platform-writing.d.ts

@@ -0,0 +1,8 @@
+import type { PlatformDependencies } from "./platform-dependencies.js";
+export declare function createPlatformWriting(dependencies: Pick<PlatformDependencies, "observed" | "browser" | "followStage" | "readPerson" | "open" | "clock" | "readPost">): {
+    compose: (action: any) => Promise<any>;
+    findSubmission: (action: any) => Promise<any>;
+    submitFollow: (action: any) => Promise<any>;
+    submitPost: (action: any) => Promise<any>;
+    submitReply: (action: any) => Promise<any>;
+};