@web-auto/webauto 0.1.1 → 0.1.3

package/dist/modules/workflow/blocks/helpers/anchorVerify.js

@@ -0,0 +1,198 @@
+/**
+ * 锚点验证辅助函数
+ * 用于 Block 中验证容器锚点 + 高亮 + Rect 回环
+ */
+/**
+ * 验证锚点容器：找到 + 高亮 + 获取 Rect
+ */
+export async function verifyAnchor(containerId, sessionId, serviceUrl = 'http://127.0.0.1:7701') {
+    try {
+        // 1. 高亮容器
+        const highlighted = await highlightContainer(containerId, sessionId, serviceUrl);
+        if (!highlighted) {
+            return {
+                found: false,
+                highlighted: false,
+                error: `Failed to highlight container: ${containerId}`
+            };
+        }
+        // 2. 获取 Rect
+        const rect = await getContainerRect(containerId, sessionId, serviceUrl);
+        if (!rect || rect.width === 0 || rect.height === 0) {
+            return {
+                found: true,
+                highlighted: true,
+                rect,
+                error: `Container ${containerId} has invalid rect: ${JSON.stringify(rect)}`
+            };
+        }
+        return {
+            found: true,
+            highlighted: true,
+            rect
+        };
+    }
+    catch (error) {
+        return {
+            found: false,
+            highlighted: false,
+            error: `verifyAnchor failed: ${error.message}`
+        };
+    }
+}
+/**
+ * 高亮容器
+ */
+export async function highlightContainer(containerId, sessionId, serviceUrl = 'http://127.0.0.1:7701', options = {}) {
+    try {
+        const { style = '3px solid #ff4444', duration = 2000 } = options;
+        const response = await fetch(`${serviceUrl}/v1/controller/action`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'container:operation',
+                payload: {
+                    containerId,
+                    operationId: 'highlight',
+                    config: { style, duration },
+                    sessionId
+                }
+            })
+        });
+        if (!response.ok) {
+            console.error(`[highlightContainer] HTTP ${response.status}: ${await response.text()}`);
+            return false;
+        }
+        const data = await response.json();
+        return data.success === true;
+    }
+    catch (error) {
+        console.error(`[highlightContainer] Error:`, error.message);
+        return false;
+    }
+}
+/**
+ * 获取容器的 Rect（通过 browser:execute + getBoundingClientRect）
+ */
+export async function getContainerRect(containerId, sessionId, serviceUrl = 'http://127.0.0.1:7701') {
+    try {
+        // 先获取当前页面 URL，避免 containers:match 依赖 session-manager CLI 查询会话
+        let currentUrl = null;
+        try {
+            const urlResp = await fetch(`${serviceUrl}/v1/controller/action`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    action: 'browser:execute',
+                    payload: {
+                        profile: sessionId,
+                        script: 'location.href',
+                    },
+                }),
+                signal: AbortSignal.timeout ? AbortSignal.timeout(8000) : undefined,
+            });
+            if (urlResp.ok) {
+                const urlData = await urlResp.json();
+                currentUrl = urlData.data?.result || urlData.result || null;
+            }
+        }
+        catch (e) {
+            console.warn('[getContainerRect] failed to read current url:', e?.message || e);
+        }
+        // 先通过 containers:match 获取容器的 selector
+        const matchResponse = await fetch(`${serviceUrl}/v1/controller/action`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'containers:match',
+                payload: {
+                    profile: sessionId,
+                    ...(currentUrl ? { url: currentUrl } : {}),
+                    maxDepth: 5,
+                    maxChildren: 20
+                }
+            }),
+            // 避免长时间挂起：为 containers:match 增加超时
+            // Node >=16 支持 AbortSignal.timeout
+            signal: AbortSignal.timeout ? AbortSignal.timeout(10000) : undefined
+        });
+        if (!matchResponse.ok) {
+            console.error(`[getContainerRect] containers:match failed: ${matchResponse.status}`);
+            return null;
+        }
+        const matchData = await matchResponse.json();
+        const tree = matchData.data?.snapshot?.container_tree || matchData.snapshot?.container_tree;
+        // 递归查找容器
+        function findContainer(node, targetId) {
+            if (!node)
+                return null;
+            if (node.id === targetId || node.defId === targetId)
+                return node;
+            if (Array.isArray(node.children)) {
+                for (const child of node.children) {
+                    const found = findContainer(child, targetId);
+                    if (found)
+                        return found;
+                }
+            }
+            return null;
+        }
+        const container = findContainer(tree, containerId);
+        if (!container) {
+            console.error(`[getContainerRect] Container ${containerId} not found in container_tree`);
+            return null;
+        }
+        const selector = typeof container.selector === 'string'
+            ? container.selector
+            : Array.isArray(container.selectors) && container.selectors.length
+                ? container.selectors[0].css
+                : undefined;
+        if (!selector) {
+            console.error(`[getContainerRect] Container ${containerId} has no selector; selectors field:`, JSON.stringify(container.selectors || container.selector || null));
+            return null;
+        }
+        // 通过 browser:execute 获取 Rect
+        const script = `
+      (() => {
+        const el = document.querySelector('${selector.replace(/'/g, "\\'")}');
+        if (!el) return null;
+        const rect = el.getBoundingClientRect();
+        return {
+          x: rect.x,
+          y: rect.y,
+          width: rect.width,
+          height: rect.height
+        };
+      })()
+    `;
+        const execResponse = await fetch(`${serviceUrl}/v1/controller/action`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'browser:execute',
+                payload: {
+                    profile: sessionId,
+                    script
+                }
+            }),
+            // browser:execute 也加一个防御性超时
+            signal: AbortSignal.timeout ? AbortSignal.timeout(10000) : undefined
+        });
+        if (!execResponse.ok) {
+            console.error(`[getContainerRect] browser:execute failed: ${execResponse.status}`);
+            return null;
+        }
+        const execData = await execResponse.json();
+        const result = execData.data?.result || execData.result || null;
+        // 兼容 promise 结果为 { ok, rect } 的脚本返回格式
+        if (result && typeof result === 'object' && 'rect' in result && !('x' in result)) {
+            return result.rect || null;
+        }
+        return result;
+    }
+    catch (error) {
+        console.error(`[getContainerRect] Error:`, error.message);
+        return null;
+    }
+}
+//# sourceMappingURL=anchorVerify.js.map

package/dist/modules/workflow/blocks/helpers/asyncWorkQueue.js

@@ -0,0 +1,53 @@
+export class AsyncWorkQueue {
+    concurrency;
+    label;
+    running = 0;
+    pending = [];
+    drainResolvers = [];
+    constructor(opts = {}) {
+        this.concurrency = Math.max(1, Math.floor(opts.concurrency ?? 1));
+        this.label = opts.label || 'queue';
+    }
+    getPendingCount() {
+        return this.pending.length;
+    }
+    getRunningCount() {
+        return this.running;
+    }
+    async enqueue(fn) {
+        return await new Promise((resolve, reject) => {
+            this.pending.push({ run: fn, resolve, reject });
+            this.pump();
+        });
+    }
+    async drain() {
+        if (this.pending.length === 0 && this.running === 0)
+            return;
+        await new Promise((resolve) => {
+            this.drainResolvers.push(resolve);
+            this.pump();
+        });
+    }
+    pump() {
+        while (this.running < this.concurrency && this.pending.length > 0) {
+            const job = this.pending.shift();
+            this.running += 1;
+            Promise.resolve()
+                .then(job.run)
+                .then(job.resolve, job.reject)
+                .finally(() => {
+                this.running -= 1;
+                if (this.pending.length === 0 && this.running === 0) {
+                    const resolvers = this.drainResolvers.slice();
+                    this.drainResolvers = [];
+                    for (const r of resolvers)
+                        r();
+                }
+                else {
+                    this.pump();
+                }
+            });
+        }
+    }
+}
+//# sourceMappingURL=asyncWorkQueue.js.map

package/dist/modules/workflow/blocks/helpers/commentScroller.js

@@ -0,0 +1,334 @@
+/**
+ * Comment Scroller Helper
+ *
+ * 共享滚动循环：WarmupCommentsBlock / ExpandCommentsBlock
+ * - 只负责“滚到评论底部（或空态）”这一件事
+ * - 所有操作通过 systemInput（browser-service）发送系统事件
+ */
+import { computeVisibleFocusPoint, getCommentEndState, getCommentStats, getScrollContainerInfo, getScrollContainerState, getViewport, getViewportFirstComment, isInputFocused, locateCommentsFocusPoint, } from './xhsCommentDom.js';
+import { systemClickAt, systemHoverAt, systemMouseWheel, isDevMode } from './systemInput.js';
+// Back-compat re-exports (older blocks import these from commentScroller.js)
+export { getScrollStats, getViewport } from './xhsCommentDom.js';
+export { systemMouseWheel } from './systemInput.js';
+export async function scrollCommentSection(options) {
+    const { controllerUrl, profile, browserServiceUrl = 'http://127.0.0.1:7704', browserWsUrl = process.env.WEBAUTO_BROWSER_WS_URL || 'ws://127.0.0.1:8765', maxRounds, focusRect, logPrefix = '[WarmupComments]', activateComments, expand, } = options;
+    const log = (msg) => console.log(`${logPrefix} ${msg}`);
+    const warn = (msg) => console.warn(`${logPrefix} ${msg}`);
+    const viewport = await getViewport(controllerUrl, profile);
+    let focusPoint = focusRect ? computeVisibleFocusPoint(focusRect, viewport) : null;
+    const domFocus = await locateCommentsFocusPoint(controllerUrl, profile);
+    if (domFocus) {
+        focusPoint = domFocus;
+        await systemClickAt(profile, domFocus.x, domFocus.y, browserServiceUrl, 'comment_focus_dom');
+        await new Promise((r) => setTimeout(r, 450));
+    }
+    if (focusPoint) {
+        await systemHoverAt(profile, focusPoint.x, focusPoint.y, browserServiceUrl);
+        await new Promise((r) => setTimeout(r, 180));
+        if (await isInputFocused(controllerUrl, profile)) {
+            log('检测到输入框焦点，点击评论区以切换焦点...');
+            await systemClickAt(profile, focusPoint.x, focusPoint.y, browserServiceUrl, 'comment_blur_input');
+            await new Promise((r) => setTimeout(r, 350));
+        }
+    }
+    let lastCount = 0;
+    let targetTotal = null;
+    let stuckBounceFailures = 0;
+    const initialStats = await getCommentStats(controllerUrl, profile);
+    lastCount = initialStats.count;
+    targetTotal = initialStats.total;
+    if (initialStats.count === 0 &&
+        typeof initialStats.total === 'number' &&
+        Number.isFinite(initialStats.total) &&
+        initialStats.total > 0 &&
+        activateComments) {
+        log(`count=0 but headerTotal=${initialStats.total}, try activate comments`);
+        try {
+            await activateComments('count_zero_but_total_positive');
+        }
+        catch (e) {
+            warn(`activate comments failed: ${e?.message || e}`);
+        }
+        const domFocus2 = await locateCommentsFocusPoint(controllerUrl, profile);
+        if (domFocus2) {
+            focusPoint = domFocus2;
+            await systemClickAt(profile, domFocus2.x, domFocus2.y, browserServiceUrl, 'comment_focus_after_activate');
+            await new Promise((r) => setTimeout(r, 450));
+        }
+        await new Promise((r) => setTimeout(r, 600));
+        const after = await getCommentStats(controllerUrl, profile);
+        log(`after activate: count=${after.count} total=${after.total} hasMore=${after.hasMore}`);
+        lastCount = after.count;
+        targetTotal = after.total;
+    }
+    // 一些详情页会先渲染“评论区骨架/占位”但 headerTotal 不可用（null），需要先点一次 comment_button 激活
+    if (initialStats.count === 0 &&
+        (initialStats.total === null || initialStats.total === 0) &&
+        !initialStats.hasMore &&
+        activateComments) {
+        const endBefore = await getCommentEndState(controllerUrl, profile);
+        const noMoreBefore = Boolean(endBefore.endMarkerVisible || endBefore.emptyStateVisible);
+        if (!noMoreBefore) {
+            log(`count=0 total=${initialStats.total}, try activate comments (total_null_or_zero)`);
+            try {
+                await activateComments('count_zero_total_null_or_zero');
+            }
+            catch (e) {
+                warn(`activate comments failed: ${e?.message || e}`);
+            }
+            const domFocus2 = await locateCommentsFocusPoint(controllerUrl, profile);
+            if (domFocus2) {
+                focusPoint = domFocus2;
+                await systemClickAt(profile, domFocus2.x, domFocus2.y, browserServiceUrl, 'comment_focus_after_activate');
+                await new Promise((r) => setTimeout(r, 450));
+            }
+            await new Promise((r) => setTimeout(r, 900));
+            const after = await getCommentStats(controllerUrl, profile);
+            const endAfter = await getCommentEndState(controllerUrl, profile);
+            log(`after activate(total_null_or_zero): count=${after.count} total=${after.total} hasMore=${after.hasMore} endMarker=${endAfter.endMarkerVisible} empty=${endAfter.emptyStateVisible}`);
+            lastCount = after.count;
+            targetTotal = after.total;
+            if (after.count === 0 &&
+                (after.total === null || after.total === 0) &&
+                !after.hasMore &&
+                (endAfter.endMarkerVisible || endAfter.emptyStateVisible)) {
+                return {
+                    reachedEnd: true,
+                    totalFromHeader: typeof after.total === 'number' ? after.total : null,
+                    finalCount: 0,
+                    rounds: 0,
+                    focusPoint,
+                };
+            }
+        }
+    }
+    if (initialStats.count === 0 &&
+        (initialStats.total === null || initialStats.total === 0) &&
+        !initialStats.hasMore) {
+        // 严格结束条件：仅当 end_marker / empty_state 可见才视为结束
+        const endState = await getCommentEndState(controllerUrl, profile);
+        const noMore = Boolean(endState.endMarkerVisible || endState.emptyStateVisible);
+        log(`initial no-comments probe: endMarker=${endState.endMarkerVisible} empty=${endState.emptyStateVisible} noMore=${noMore}`);
+        if (noMore) {
+            return {
+                reachedEnd: true,
+                totalFromHeader: typeof initialStats.total === 'number' ? initialStats.total : null,
+                finalCount: 0,
+                rounds: 0,
+                focusPoint,
+            };
+        }
+    }
+    const dynamicMaxRounds = typeof maxRounds === 'number' && maxRounds > 0
+        ? maxRounds
+        : targetTotal && targetTotal > 0
+            ? Math.min(Math.max(Math.ceil(targetTotal / 6) * 3, 36), 900)
+            : 96;
+    let noEffectStreak = 0;
+    let roundsRan = 0;
+    for (let i = 0; i < dynamicMaxRounds; i++) {
+        roundsRan = i + 1;
+        const viewportBefore = await getViewportFirstComment(controllerUrl, profile);
+        const scrollInfo = await getScrollContainerInfo(controllerUrl, profile);
+        if (scrollInfo && viewport.innerWidth && viewport.innerHeight) {
+            const fx = clamp(scrollInfo.x, 20, viewport.innerWidth - 20);
+            const fy = clamp(scrollInfo.y, 120, viewport.innerHeight - 120);
+            focusPoint = { x: fx, y: fy };
+            log(`round=${i} refreshed focus: (${scrollInfo.x}, ${scrollInfo.y}), scrollTop=${scrollInfo.scrollTop}/${scrollInfo.scrollHeight}`);
+            await systemHoverAt(profile, fx, fy, browserServiceUrl);
+        }
+        const scrollTopBefore = scrollInfo?.scrollTop ?? null;
+        const scrollHeightBefore = scrollInfo?.scrollHeight ?? null;
+        const clientHeightBefore = scrollInfo?.clientHeight ?? null;
+        if (expand) {
+            try {
+                await expand({ round: i, focusPoint });
+            }
+            catch (e) {
+                const msg = String(e?.message || e || '');
+                // 开发阶段：风控/验证码/误点保护触发时必须停下，不允许吞错继续滚
+                if (msg.includes('captcha_modal_detected'))
+                    throw e;
+                if (msg.includes('unsafe_click_image_in_detail')) {
+                    if (isDevMode())
+                        throw e;
+                    warn(`round=${i} expand skipped unsafe click (continue): ${msg}`);
+                }
+                warn(`round=${i} expand failed: ${msg}`);
+            }
+        }
+        // 单次滚动不超过 800px（视口安全约束），但尽量加大步长以更快触达底部 end_marker
+        const deltaY = 520 + Math.floor(Math.random() * 260);
+        try {
+            await systemMouseWheel({
+                profileId: profile,
+                deltaY,
+                focusPoint,
+                browserServiceUrl,
+                browserWsUrl,
+                context: 'comment_scroll',
+            });
+            log(`round=${i} system wheel deltaY=${deltaY}`);
+        }
+        catch (e) {
+            const msg = String(e?.message || e || '');
+            if (msg.includes('captcha_modal_detected'))
+                throw e;
+            warn(`round=${i} system wheel failed: ${msg}`);
+        }
+        await new Promise((r) => setTimeout(r, 650 + Math.random() * 650));
+        const stats = await getCommentStats(controllerUrl, profile);
+        const currentCount = stats.count;
+        const viewportAfter = await getViewportFirstComment(controllerUrl, profile);
+        if (viewportBefore || viewportAfter) {
+            log(`round=${i} viewportFirst before=${JSON.stringify(viewportBefore)} after=${JSON.stringify(viewportAfter)}`);
+        }
+        let scrolled = null;
+        try {
+            const afterState = await getScrollContainerState(controllerUrl, profile);
+            const scrollTopAfter = afterState?.scrollTop ?? null;
+            const scrollHeightAfter = afterState?.scrollHeight ?? null;
+            const clientHeightAfter = afterState?.clientHeight ?? null;
+            const canScroll = (scrollHeightAfter ?? scrollHeightBefore ?? 0) -
+                (clientHeightAfter ?? clientHeightBefore ?? 0) >
+                12;
+            if (canScroll && scrollTopBefore !== null && scrollTopAfter !== null) {
+                scrolled = Math.abs(scrollTopAfter - scrollTopBefore) > 2;
+            }
+        }
+        catch {
+            // ignore
+        }
+        const keyBefore = viewportBefore?.key || '';
+        const keyAfter = viewportAfter?.key || '';
+        const firstChanged = Boolean(keyBefore && keyAfter && keyBefore !== keyAfter);
+        if (scrolled === false && !firstChanged && currentCount <= lastCount) {
+            noEffectStreak += 1;
+            warn(`round=${i} ⚠️ scroll seems ineffective (streak=${noEffectStreak})`);
+            // 卡住时：先回滚（向上滚）几次，再继续向下滚（避免虚拟列表“卡在同一批节点”）
+            if (noEffectStreak >= 2) {
+                const endStateBeforeBounce = await getCommentEndState(controllerUrl, profile);
+                const noMoreBeforeBounce = Boolean(endStateBeforeBounce.endMarkerVisible || endStateBeforeBounce.emptyStateVisible);
+                if (noMoreBeforeBounce) {
+                    log(`round=${i} endMarker=${endStateBeforeBounce.endMarkerVisible}, empty=${endStateBeforeBounce.emptyStateVisible} -> stop before bounce`);
+                    lastCount = currentCount;
+                    break;
+                }
+                // 规则：如果“回滚->再下滚”的尝试累计 3 次仍无法推进，则视为结束（避免无限卡死）
+                let stuckScrollBefore = null;
+                let stuckFirstBefore = null;
+                try {
+                    stuckScrollBefore = await getScrollContainerState(controllerUrl, profile);
+                }
+                catch {
+                    stuckScrollBefore = null;
+                }
+                try {
+                    stuckFirstBefore = await getViewportFirstComment(controllerUrl, profile);
+                }
+                catch {
+                    stuckFirstBefore = null;
+                }
+                const stuckTopBefore = stuckScrollBefore?.scrollTop ?? null;
+                const fallbackFocus = (await locateCommentsFocusPoint(controllerUrl, profile)) || focusPoint;
+                if (fallbackFocus)
+                    focusPoint = fallbackFocus;
+                const fp = focusPoint || fallbackFocus;
+                if (fp) {
+                    await systemHoverAt(profile, fp.x, fp.y, browserServiceUrl);
+                    await new Promise((r) => setTimeout(r, 150));
+                    await systemClickAt(profile, fp.x, fp.y, browserServiceUrl, 'comment_scroll_recovery');
+                    await new Promise((r) => setTimeout(r, 220));
+                }
+                const upCount = 3 + Math.floor(Math.random() * 4);
+                // 回滚 3-6 次
+                for (let k = 0; k < upCount; k += 1) {
+                    await systemMouseWheel({
+                        profileId: profile,
+                        deltaY: -(320 + Math.floor(Math.random() * 160)),
+                        focusPoint,
+                        browserServiceUrl,
+                        browserWsUrl,
+                        context: 'comment_scroll_recovery_up',
+                    });
+                    await new Promise((r) => setTimeout(r, 500 + Math.random() * 400));
+                }
+                // 再向下 3 次
+                for (let k = 0; k < 3; k += 1) {
+                    await systemMouseWheel({
+                        profileId: profile,
+                        deltaY: 540 + Math.floor(Math.random() * 220),
+                        focusPoint,
+                        browserServiceUrl,
+                        browserWsUrl,
+                        context: 'comment_scroll_recovery_down',
+                    });
+                    await new Promise((r) => setTimeout(r, 600 + Math.random() * 450));
+                }
+                let stuckScrollAfter = null;
+                let stuckFirstAfter = null;
+                try {
+                    stuckScrollAfter = await getScrollContainerState(controllerUrl, profile);
+                }
+                catch {
+                    stuckScrollAfter = null;
+                }
+                try {
+                    stuckFirstAfter = await getViewportFirstComment(controllerUrl, profile);
+                }
+                catch {
+                    stuckFirstAfter = null;
+                }
+                const stuckTopAfter = stuckScrollAfter?.scrollTop ?? null;
+                const topMoved = stuckTopBefore !== null &&
+                    stuckTopAfter !== null &&
+                    Math.abs(Number(stuckTopAfter) - Number(stuckTopBefore)) > 2;
+                const firstMoved = Boolean(stuckFirstBefore?.key && stuckFirstAfter?.key && stuckFirstBefore.key !== stuckFirstAfter.key);
+                if (!topMoved && !firstMoved) {
+                    stuckBounceFailures += 1;
+                    warn(`round=${i} ⚠️ stuck bounce failed (attempt=${stuckBounceFailures}/3)`);
+                    if (stuckBounceFailures >= 3) {
+                        warn(`round=${i} 🛑 cannot scroll after 3 bounce attempts, treat as end`);
+                        return {
+                            reachedEnd: true,
+                            endedByStuck: true,
+                            totalFromHeader: targetTotal,
+                            finalCount: currentCount,
+                            rounds: i + 1,
+                            focusPoint,
+                        };
+                    }
+                }
+                else {
+                    stuckBounceFailures = 0;
+                }
+                noEffectStreak = 0;
+            }
+        }
+        else {
+            noEffectStreak = 0;
+        }
+        // “到底算结束”：严格仅以 end_marker / empty_state 为准
+        const endState = await getCommentEndState(controllerUrl, profile);
+        const noMore = Boolean(endState.endMarkerVisible || endState.emptyStateVisible);
+        log(`round=${i} count=${currentCount}, total=${targetTotal}, hasMoreHint=${stats.hasMore}, endMarker=${endState.endMarkerVisible}, empty=${endState.emptyStateVisible}, noMore=${noMore}`);
+        lastCount = currentCount;
+        if (noMore) {
+            log('stop conditions met');
+            break;
+        }
+    }
+    const finalStats = await getCommentStats(controllerUrl, profile);
+    const finalEndState = await getCommentEndState(controllerUrl, profile);
+    return {
+        reachedEnd: Boolean(finalEndState.endMarkerVisible || finalEndState.emptyStateVisible),
+        totalFromHeader: finalStats.total,
+        finalCount: finalStats.count,
+        rounds: roundsRan,
+        focusPoint,
+    };
+}
+function clamp(n, min, max) {
+    return Math.min(Math.max(n, min), max);
+}
+//# sourceMappingURL=commentScroller.js.map