@web-auto/webauto 0.1.1 → 0.1.2

package/dist/modules/xiaohongshu/app/src/blocks/helpers/xhsComments.js

@@ -0,0 +1,270 @@
+import { controllerAction, delay } from '../../utils/controllerAction.js';
+export async function ensureCommentsOpened(sessionId, apiUrl) {
+    await controllerAction('container:operation', {
+        containerId: 'xiaohongshu_detail.comment_button',
+        operationId: 'highlight',
+        sessionId,
+        timeoutMs: 15000,
+        config: { duration: 1800, channel: 'xhs-comments' },
+    }, apiUrl).catch(() => null);
+    await controllerAction('container:operation', { containerId: 'xiaohongshu_detail.comment_button', operationId: 'click', sessionId, timeoutMs: 15000 }, apiUrl).catch(() => { });
+    await delay(1200);
+}
+export async function isCommentEnd(sessionId, apiUrl) {
+    const end = await controllerAction('container:operation', { containerId: 'xiaohongshu_detail.comment_section.end_marker', operationId: 'extract', sessionId, timeoutMs: 12000 }, apiUrl).catch(() => null);
+    if (end && end?.success === true) {
+        const extracted = Array.isArray(end?.extracted) ? end.extracted : [];
+        if (extracted.length > 0)
+            return true;
+    }
+    // 空评论标记："这是一片荒地"
+    try {
+        const res = await controllerAction('browser:execute', {
+            profile: sessionId,
+            timeoutMs: 12000,
+            script: `(() => {
+          const candidates = [
+            'p.no-comments-text',
+            '.no-comments-text',
+            '[class*="no-comments"]',
+            '[class*="no-comment"]',
+            '[class*="empty-comment"]',
+          ];
+          for (const sel of candidates) {
+            const el = document.querySelector(sel);
+            const t = (el?.textContent || '').replace(/\s+/g, ' ').trim();
+            if (t && (t.includes('这是一片荒地') || t.includes('荒地'))) return true;
+          }
+          return false;
+        })()`,
+        }, apiUrl);
+        if (res?.result === true)
+            return true;
+    }
+    catch {
+        // ignore
+    }
+    return false;
+}
+async function getVisibleCommentSignature(sessionId, apiUrl) {
+    try {
+        const res = await controllerAction('browser:execute', {
+            profile: sessionId,
+            timeoutMs: 12000,
+            script: `(() => {
+          const isVisible = (el) => {
+            const r = el.getBoundingClientRect();
+            return r.width > 0 && r.height > 0 && r.bottom > 0 && r.top < window.innerHeight;
+          };
+          const items = Array.from(document.querySelectorAll('.comment-item')).filter(isVisible);
+          const texts = items
+            .map((el) => {
+              const t = el.querySelector('.content')?.textContent || el.querySelector('p')?.textContent || '';
+              return t.replace(/\s+/g, ' ').trim();
+            })
+            .filter(Boolean)
+            .slice(0, 6);
+          return { count: items.length, head: texts.join('|').slice(0, 200) };
+        })()`,
+        }, apiUrl);
+        return {
+            count: Number(res?.result?.count ?? -1),
+            head: String(res?.result?.head ?? ''),
+        };
+    }
+    catch {
+        return { count: -1, head: '' };
+    }
+}
+/**
+ * 往返滚动检测（风控友好）：
+ * - 下滚无变化 -> 上滚一点 -> 再下滚
+ * - 往返 maxRounds 次仍无变化：判定到底（或评论区无法继续加载）
+ */
+export async function checkBottomWithBackAndForth(sessionId, apiUrl, maxRounds = 3) {
+    let prev = await getVisibleCommentSignature(sessionId, apiUrl);
+    for (let i = 0; i < maxRounds; i += 1) {
+        await scrollComments(sessionId, apiUrl, 420);
+        await delay(800);
+        const afterDown = await getVisibleCommentSignature(sessionId, apiUrl);
+        if (afterDown.count !== prev.count || afterDown.head !== prev.head) {
+            return { reachedBottom: false, reason: 'down_changed' };
+        }
+        // 往回滚动几次再尝试向下，防止卡住
+        await scrollComments(sessionId, apiUrl, -240);
+        await delay(500);
+        await scrollComments(sessionId, apiUrl, 240);
+        await delay(700);
+        const afterBounce = await getVisibleCommentSignature(sessionId, apiUrl);
+        if (afterBounce.count !== prev.count || afterBounce.head !== prev.head) {
+            return { reachedBottom: false, reason: 'bounce_changed' };
+        }
+        prev = afterBounce;
+    }
+    return { reachedBottom: true, reason: 'no_change_after_back_and_forth' };
+}
+export async function extractVisibleComments(sessionId, apiUrl, maxItems) {
+    const res = await controllerAction('container:operation', {
+        containerId: 'xiaohongshu_detail.comment_section.comment_item',
+        operationId: 'extract',
+        sessionId,
+        timeoutMs: 15000,
+        config: { max_items: Math.max(1, Math.min(80, Math.floor(maxItems))), visibleOnly: true },
+    }, apiUrl);
+    if (!res?.success)
+        return [];
+    const extracted = Array.isArray(res?.extracted) ? res.extracted : [];
+    // Map extracted items with their DOM index (position in selectorAll result)
+    const containerRes = await controllerAction('browser:execute', {
+        profile: sessionId,
+        timeoutMs: 12000,
+        script: `(() => {
+        const items = Array.from(document.querySelectorAll('.comment-item'));
+        return items.map((el, idx) => {
+          const rect = el.getBoundingClientRect();
+          return {
+            domIndex: idx,
+            visible: rect.top >= 0 && rect.bottom <= window.innerHeight && rect.height > 0
+          };
+        }).filter(x => x.visible);
+      })()`,
+    }, apiUrl);
+    const visibleIndices = (containerRes?.result || []).map((x) => x.domIndex);
+    return extracted.map((item, idx) => ({ ...item, domIndex: visibleIndices[idx] ?? idx }));
+}
+export async function highlightCommentRow(sessionId, index, apiUrl, channel = 'xhs-comment-row') {
+    return controllerAction('container:operation', {
+        containerId: 'xiaohongshu_detail.comment_section.comment_item',
+        operationId: 'highlight',
+        sessionId,
+        config: {
+            index,
+            target: 'self',
+            style: '6px solid #ff00ff',
+            duration: 8000,
+            channel,
+            visibleOnly: true,
+        },
+    }, apiUrl);
+}
+export async function scrollComments(sessionId, apiUrl, distance = 650) {
+    return controllerAction('container:operation', {
+        containerId: 'xiaohongshu_detail.comment_section',
+        operationId: 'scroll',
+        sessionId,
+        timeoutMs: 15000,
+        config: { direction: 'down', distance: Math.max(60, Math.min(800, Math.floor(distance))) },
+    }, apiUrl);
+}
+export async function expandAllVisibleReplyButtons(sessionId, apiUrl, options = {}) {
+    const maxPasses = Math.max(1, Math.min(12, Number(options.maxPasses || 6)));
+    const maxClicksPerPass = Math.max(1, Math.min(30, Number(options.maxClicksPerPass || 12)));
+    const probeTargets = async () => {
+        const probe = await controllerAction('browser:execute', {
+            profile: sessionId,
+            timeoutMs: 12000,
+            script: `(() => {
+          const root =
+            document.querySelector('.comments-el') ||
+            document.querySelector('.comment-list') ||
+            document.querySelector('.comments-container') ||
+            document.querySelector('[class*="comment-section"]') ||
+            document.body;
+
+          const selector = '.show-more, .reply-expand, [class*="show-more"], [class*="expand"]';
+          const nodes = Array.from(root.querySelectorAll(selector));
+          const viewportH = window.innerHeight || 0;
+          const viewportW = window.innerWidth || 0;
+
+          const targets = [];
+
+          const isVisible = (el) => {
+            const r = el.getBoundingClientRect();
+            return r.width > 0 && r.height > 0 && r.bottom > 0 && r.top < viewportH && r.right > 0 && r.left < viewportW;
+          };
+
+          for (const el of nodes) {
+            if (!(el instanceof HTMLElement)) continue;
+            if (!isVisible(el)) continue;
+
+            const text = (el.textContent || '').replace(/\s+/g, ' ').trim();
+            if (!text || !text.includes('展开')) continue;
+            if (text.includes('收起') || text.includes('折叠')) continue;
+            if (!(text.includes('回复') || text.includes('评论') || text.includes('更多'))) continue;
+
+            const r = el.getBoundingClientRect();
+            const points = [
+              { x: Math.round(r.left + r.width * 0.72), y: Math.round(r.top + r.height * 0.55) },
+              { x: Math.round(r.left + r.width * 0.55), y: Math.round(r.top + r.height * 0.55) },
+              { x: Math.round(r.left + r.width * 0.85), y: Math.round(r.top + r.height * 0.5) },
+            ];
+
+            let picked = null;
+            for (const p of points) {
+              if (!Number.isFinite(p.x) || !Number.isFinite(p.y)) continue;
+              if (p.x < 8 || p.y < 8 || p.x > viewportW - 8 || p.y > viewportH - 8) continue;
+              const hit = document.elementFromPoint(p.x, p.y);
+              if (!hit || !(hit instanceof Element)) continue;
+              if (!(hit === el || el.contains(hit) || hit.contains(el))) continue;
+              if (hit.closest && hit.closest('a[href]')) continue;
+              picked = p;
+              break;
+            }
+
+            if (!picked) continue;
+            targets.push({ x: picked.x, y: picked.y, text });
+          }
+
+          targets.sort((a, b) => (a.y - b.y) || (a.x - b.x));
+          return { targets };
+        })()`,
+        }, apiUrl).catch(() => null);
+        const raw = Array.isArray(probe?.result?.targets)
+            ? probe.result.targets
+            : Array.isArray(probe?.targets)
+                ? probe.targets
+                : [];
+        return raw
+            .map((t) => ({
+            x: Math.round(Number(t?.x)),
+            y: Math.round(Number(t?.y)),
+            text: String(t?.text || ''),
+        }))
+            .filter((t) => Number.isFinite(t.x) && Number.isFinite(t.y));
+    };
+    let totalClicked = 0;
+    let totalDetected = 0;
+    let passes = 0;
+    for (let pass = 0; pass < maxPasses; pass += 1) {
+        const targets = await probeTargets();
+        if (!targets.length)
+            break;
+        totalDetected += targets.length;
+        let clickedThisPass = 0;
+        const toClick = targets.slice(0, maxClicksPerPass);
+        for (const t of toClick) {
+            const clicked = await controllerAction('container:operation', {
+                containerId: 'xiaohongshu_detail.comment_section.show_more_button',
+                operationId: 'click',
+                sessionId,
+                timeoutMs: 15000,
+                config: {
+                    x: t.x,
+                    y: t.y,
+                },
+            }, apiUrl).catch(() => null);
+            if (clicked?.success !== false)
+                clickedThisPass += 1;
+            await delay(220);
+        }
+        passes += 1;
+        totalClicked += clickedThisPass;
+        // No successful click in this pass means target is currently not actionable.
+        if (clickedThisPass <= 0)
+            break;
+        await delay(380);
+    }
+    const remaining = (await probeTargets()).length;
+    return { clicked: totalClicked, passes, remaining, detected: totalDetected };
+}
+//# sourceMappingURL=xhsComments.js.map

package/dist/modules/xiaohongshu/app/src/index.js

@@ -0,0 +1,9 @@
+/**
+ * 小红书 App 模块入口
+ */
+export * as Phase1EnsureServicesBlock from './blocks/Phase1EnsureServicesBlock.js';
+export * as Phase1StartProfileBlock from './blocks/Phase1StartProfileBlock.js';
+export * as Phase1MonitorCookieBlock from './blocks/Phase1MonitorCookieBlock.js';
+export * as Phase2SearchBlock from './blocks/Phase2SearchBlock.js';
+export * as Phase2CollectLinksBlock from './blocks/Phase2CollectLinksBlock.js';
+//# sourceMappingURL=index.js.map

package/dist/modules/xiaohongshu/app/src/utils/checkpoints.js

@@ -0,0 +1,222 @@
+import { execute as detectPageState } from '../../../../workflow/blocks/DetectPageStateBlock.js';
+import { execute as anchorVerify } from '../../../../workflow/blocks/AnchorVerificationBlock.js';
+import { execute as errorRecovery } from '../../../../workflow/blocks/ErrorRecoveryBlock.js';
+function hasAny(matchIds, ids) {
+    const set = new Set(matchIds || []);
+    return ids.some((x) => set.has(x));
+}
+function hasAll(matchIds, ids) {
+    const set = new Set(matchIds || []);
+    return ids.every((x) => set.has(x));
+}
+export async function detectXhsCheckpoint(input) {
+    const { sessionId, serviceUrl = 'http://127.0.0.1:7701' } = input;
+    const state = await detectPageState({ sessionId, platform: 'xiaohongshu', serviceUrl });
+    const url = String(state?.url || '').trim();
+    const stage = String(state?.stage || 'unknown');
+    const rootId = state?.rootId ?? null;
+    const matchIds = Array.isArray(state?.matchIds) ? state.matchIds : [];
+    const dom = {
+        hasDetailMask: typeof state?.dom?.hasDetailMask === 'boolean' ? state.dom.hasDetailMask : undefined,
+        hasSearchInput: typeof state?.dom?.hasSearchInput === 'boolean' ? state.dom.hasSearchInput : undefined,
+        readyState: typeof state?.dom?.readyState === 'string' ? state.dom.readyState : undefined,
+        title: typeof state?.dom?.title === 'string' ? state.dom.title : undefined,
+    };
+    const signals = [];
+    const allIds = [String(rootId || ''), ...matchIds].filter(Boolean);
+    // Priority 0 (DOM-first): XHS may keep /explore/<id> in the URL even after closing the detail modal.
+    // In that case URL-based assumptions are wrong; prefer DOM signals.
+    if (dom.hasDetailMask === false && dom.hasSearchInput === true) {
+        const isInSearch = url.includes('/search_result') || url.includes('keyword=');
+        const checkpoint = isInSearch ? 'search_ready' : 'home_ready';
+        return {
+            success: true,
+            checkpoint,
+            stage,
+            url,
+            rootId,
+            matchIds,
+            signals: ['no_detail_mask', 'has_search_input', checkpoint],
+            dom,
+            error: state?.error,
+        };
+    }
+    // Risk-control / captcha URL patterns are hard stops (even if container match fails).
+    // We must avoid any automated retries here to reduce further risk-control triggers.
+    const lowerUrl = url.toLowerCase();
+    if (lowerUrl.includes('/website-login/captcha') ||
+        lowerUrl.includes('verifyuuid=') ||
+        lowerUrl.includes('verifytype=') ||
+        lowerUrl.includes('verifybiz=') ||
+        lowerUrl.includes('/website-login/verify') ||
+        lowerUrl.includes('/website-login/security')) {
+        return {
+            success: true,
+            checkpoint: 'risk_control',
+            stage,
+            url,
+            rootId,
+            matchIds,
+            signals: ['risk_control_url'],
+            dom,
+            error: state?.error,
+        };
+    }
+    // offsite is a hard stop
+    if (!url || !url.includes('xiaohongshu.com')) {
+        return { success: false, checkpoint: 'offsite', stage, url, rootId, matchIds, signals: ['offsite'], dom, error: state?.error };
+    }
+    // login guard
+    if (hasAny(allIds, ['xiaohongshu_login.login_guard'])) {
+        return { success: true, checkpoint: 'login_guard', stage, url, rootId, matchIds, signals: ['login_guard'], dom };
+    }
+    // risk control (placeholder ids; extend as container library grows)
+    if (hasAny(allIds, ['xiaohongshu_login.qrcode_guard', 'xiaohongshu_login.captcha_guard'])) {
+        return { success: true, checkpoint: 'risk_control', stage, url, rootId, matchIds, signals: ['risk_control'], dom };
+    }
+    // comments_ready
+    if (hasAny(allIds, [
+        'xiaohongshu_detail.comment_section',
+        'xiaohongshu_detail.comment_section.comment_item',
+        'xiaohongshu_detail.end_marker',
+    ])) {
+        return { success: true, checkpoint: 'comments_ready', stage, url, rootId, matchIds, signals: ['comments_anchor'], dom };
+    }
+    // detail_ready
+    if (hasAll(allIds, ['xiaohongshu_detail.modal_shell', 'xiaohongshu_detail.content_anchor'])) {
+        return { success: true, checkpoint: 'detail_ready', stage, url, rootId, matchIds, signals: ['detail_shell', 'content_anchor'], dom };
+    }
+    // search_ready
+    if (hasAll(allIds, ['xiaohongshu_search.search_bar', 'xiaohongshu_search.search_result_list'])) {
+        return { success: true, checkpoint: 'search_ready', stage, url, rootId, matchIds, signals: ['search_bar', 'search_result_list'], dom };
+    }
+    // home_ready
+    if (hasAny(allIds, ['xiaohongshu_home.search_input', 'xiaohongshu_home'])) {
+        // IMPORTANT:
+        // On XHS, the URL may still contain /explore/<noteId>?xsec_token=... even after the detail modal is closed.
+        // We must prefer DOM/container evidence over URL.
+        // If detail mask is absent and home/search anchors are present, treat as home_ready.
+        return { success: true, checkpoint: 'home_ready', stage, url, rootId, matchIds, signals: ['home'], dom };
+    }
+    return {
+        success: stage !== 'unknown',
+        checkpoint: 'unknown',
+        stage,
+        url,
+        rootId,
+        matchIds,
+        signals,
+        dom,
+        error: state?.error,
+    };
+}
+async function highlightAnchors(sessionId, serviceUrl, ids, ms) {
+    for (const id of ids) {
+        try {
+            await anchorVerify({ sessionId, containerId: id, operation: 'enter', serviceUrl });
+            return;
+        }
+        catch {
+            // try next
+        }
+    }
+}
+function fallbackTarget(target) {
+    // one-level-up policy
+    if (target === 'search_ready')
+        return 'home_ready';
+    if (target === 'comments_ready')
+        return 'detail_ready';
+    if (target === 'detail_ready')
+        return 'search_ready';
+    return null;
+}
+export async function ensureXhsCheckpoint(input) {
+    const { sessionId, target, serviceUrl = 'http://127.0.0.1:7701', timeoutMs = 15000, allowOneLevelUpFallback = true, evidence = { highlightMs: 1200 }, } = input;
+    const start = Date.now();
+    const attempts = [];
+    const det0 = await detectXhsCheckpoint({ sessionId, serviceUrl });
+    const from = det0.checkpoint;
+    let last = det0;
+    // quick success
+    if (from === target) {
+        return { success: true, from, to: target, reached: target, url: det0.url, stage: det0.stage, attempts, signals: det0.signals };
+    }
+    while (Date.now() - start < timeoutMs) {
+        last = await detectXhsCheckpoint({ sessionId, serviceUrl });
+        if (last.checkpoint === target) {
+            return { success: true, from, to: target, reached: target, url: last.url, stage: last.stage, attempts, signals: last.signals };
+        }
+        // Always highlight best-effort so user sees where we are.
+        const hm = Math.max(200, Math.min(2000, Number(evidence.highlightMs || 1200)));
+        if (last.checkpoint === 'detail_ready' || last.checkpoint === 'comments_ready') {
+            await highlightAnchors(sessionId, serviceUrl, ['xiaohongshu_detail.modal_shell', 'xiaohongshu_detail.content_anchor'], hm);
+        }
+        else if (last.checkpoint === 'search_ready') {
+            await highlightAnchors(sessionId, serviceUrl, ['xiaohongshu_search.search_bar', 'xiaohongshu_search.search_result_list'], hm);
+        }
+        else if (last.checkpoint === 'home_ready') {
+            await highlightAnchors(sessionId, serviceUrl, ['xiaohongshu_home.search_input'], hm);
+        }
+        // Recovery actions: conservative (ESC-based).
+        if ((target === 'search_ready' || target === 'home_ready') &&
+            (last.checkpoint === 'detail_ready' || last.checkpoint === 'comments_ready')) {
+            try {
+                await errorRecovery({
+                    sessionId,
+                    fromStage: 'detail',
+                    targetStage: target === 'home_ready' ? 'home' : 'search',
+                    recoveryMode: 'esc',
+                    serviceUrl,
+                    maxRetries: 3,
+                });
+                attempts.push({ action: 'esc', ok: true });
+            }
+            catch (e) {
+                attempts.push({ action: 'esc', ok: false, reason: e?.message || String(e) });
+            }
+            continue;
+        }
+        // No safe automated path; break to fallback or fail.
+        break;
+    }
+    // one-level-up fallback
+    if (allowOneLevelUpFallback) {
+        const up = fallbackTarget(target);
+        if (up && up !== target) {
+            const res = await ensureXhsCheckpoint({
+                sessionId,
+                target: up,
+                serviceUrl,
+                timeoutMs,
+                allowOneLevelUpFallback: false,
+                evidence,
+            });
+            if (res.success) {
+                return {
+                    success: false,
+                    from,
+                    to: target,
+                    reached: up,
+                    url: res.url,
+                    stage: res.stage,
+                    attempts: [...attempts, ...res.attempts, { action: 'need_user_action', ok: false, reason: `need to reach ${target}` }],
+                    signals: res.signals,
+                    error: `fallback_reached_${up}_need_${target}`,
+                };
+            }
+        }
+    }
+    return {
+        success: false,
+        from,
+        to: target,
+        reached: last.checkpoint,
+        url: last.url,
+        stage: last.stage,
+        attempts,
+        signals: last.signals,
+        error: `ensure_checkpoint_failed target=${target} reached=${last.checkpoint}`,
+    };
+}
+//# sourceMappingURL=checkpoints.js.map

package/dist/modules/xiaohongshu/app/src/utils/controllerAction.js

@@ -0,0 +1,43 @@
+/**
+ * Controller Action 工具函数
+ */
+export async function controllerAction(action, payload, apiUrl) {
+    const timeoutMs = typeof payload?.timeoutMs === 'number' && Number.isFinite(payload.timeoutMs) && payload.timeoutMs > 0
+        ? Math.floor(payload.timeoutMs)
+        : 60000;
+    const res = await fetch(`${apiUrl}/v1/controller/action`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        // Unified API expects payload nested under `payload`.
+        body: JSON.stringify({ action, payload: payload || {} }),
+        // 截图/容器操作在某些页面会更慢，允许调用方覆盖超时。
+        signal: AbortSignal.timeout(timeoutMs),
+    });
+    const data = await res.json().catch(() => ({}));
+    return data.data || data;
+}
+export function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+export function expandHome(p) {
+    if (!p)
+        return p;
+    if (p.startsWith('~/'))
+        return `${process.env.HOME}/${p.slice(2)}`;
+    return p;
+}
+export async function ensureDir(dir) {
+    const { mkdir } = await import('node:fs/promises');
+    await mkdir(dir, { recursive: true });
+}
+export async function writeFile(filePath, content) {
+    const { writeFile: wf } = await import('node:fs/promises');
+    await wf(filePath, content, 'utf8');
+}
+export async function downloadImage(url, destPath) {
+    const response = await fetch(url);
+    const buffer = await response.arrayBuffer();
+    const { writeFile: wf } = await import('node:fs/promises');
+    await wf(destPath, Buffer.from(buffer));
+}
+//# sourceMappingURL=controllerAction.js.map