@web-auto/webauto 0.1.1 → 0.1.2

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

@@ -0,0 +1,328 @@
+/**
+ * SearchExecutor helper
+ *
+ * 处理搜索输入、焦点检查和搜索执行
+ */
+import os from 'node:os';
+import { logControllerActionError, logControllerActionResult, logControllerActionStart, } from './operationLogger.js';
+export async function controllerAction(controllerUrl, action, payload = {}) {
+    const opId = logControllerActionStart(action, payload, { source: 'searchExecutor' });
+    try {
+        const response = await fetch(controllerUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ action, payload }),
+            signal: AbortSignal.timeout ? AbortSignal.timeout(10000) : undefined
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+        }
+        const data = await response.json();
+        const result = data.data || data;
+        logControllerActionResult(opId, action, result, { source: 'searchExecutor' });
+        return result;
+    }
+    catch (error) {
+        logControllerActionError(opId, action, error, payload, { source: 'searchExecutor' });
+        throw error;
+    }
+}
+export async function verifySearchBarAnchor(config) {
+    const { profile, controllerUrl, searchInputContainerId } = config;
+    try {
+        const { verifyAnchorByContainerId } = await import('./containerAnchors.js');
+        const anchor = await verifyAnchorByContainerId(searchInputContainerId, profile, controllerUrl.replace('/v1/controller/action', ''));
+        if (!anchor.found) {
+            return {
+                found: false,
+                error: anchor.error || 'anchor_not_found',
+                selector: anchor.selector
+            };
+        }
+        return {
+            found: true,
+            selector: anchor.selector || '#search-input',
+            rect: anchor.rect
+        };
+    }
+    catch (error) {
+        return { found: false, error: error.message };
+    }
+}
+export async function isSearchInputFocused(config, selector) {
+    const { profile, controllerUrl } = config;
+    if (!selector)
+        return false;
+    const script = `(() => {
+    const el = document.querySelector(${JSON.stringify(selector)});
+    if (!el) return false;
+    const active = document.activeElement;
+    if (!active) return false;
+    return active === el || (el instanceof Element && el.contains(active));
+  })()`;
+    const response = await fetch(controllerUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            action: 'browser:execute',
+            payload: {
+                profile,
+                script,
+            },
+        }),
+    });
+    const data = await response.json();
+    return Boolean(data.data?.result ?? data.result);
+}
+export async function readSearchInputValue(config, selector) {
+    const { profile, controllerUrl } = config;
+    const sel = selector ||
+        '#search-input, input[type="search"], .search-input';
+    const script = `(() => {
+    const el = document.querySelector(${JSON.stringify(sel)});
+    if (!el) return '';
+    try {
+      if ('value' in el) return String(el.value || '');
+      if (el.isContentEditable) return String(el.textContent || '');
+      return String(el.textContent || '');
+    } catch {
+      return '';
+    }
+  })()`;
+    const response = await fetch(controllerUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            action: 'browser:execute',
+            payload: {
+                profile,
+                script,
+            },
+        }),
+    });
+    const data = await response.json();
+    const value = data.data?.result ?? data.result ?? '';
+    return typeof value === 'string' ? value : '';
+}
+export async function executeSearch(config, anchorSelector) {
+    const { profile, controllerUrl, searchInputContainerId, keyword } = config;
+    try {
+        console.log(`[SearchExecutor] Typing keyword "${keyword}"...`);
+        const selector = anchorSelector ||
+            '#search-input, input[type="search"], .search-input';
+        // ✅ 系统级输入：禁止 container:operation type（底层为 session.fill，属于非系统行为）
+        // 依赖上游已完成 focus；这里额外做一次清空 + 输入 + Enter
+        // 注意：在 mac 上 Control+A 可能导致光标跳到行首，反而造成“关键字拼接”。
+        let typedByContainer = false;
+        try {
+            const typeResp = await controllerAction(controllerUrl, 'container:operation', {
+                containerId: searchInputContainerId,
+                operationId: 'type',
+                sessionId: profile,
+                config: {
+                    selector,
+                    text: keyword,
+                    clear_first: true,
+                    human_typing: true,
+                    pause_after: 320,
+                    fullyVisible: true,
+                },
+            });
+            const ok = Boolean(typeResp?.success !== false && (typeResp?.data?.success ?? true));
+            if (!ok) {
+                console.warn('[SearchExecutor] container type failed', typeResp);
+            }
+            else {
+                typedByContainer = true;
+            }
+        }
+        catch (error) {
+            console.warn('[SearchExecutor] container type failed', error?.message || String(error));
+        }
+        if (!typedByContainer) {
+            const platform = os.platform();
+            const selectAllKey = platform === 'darwin' ? 'Meta+A' : 'Control+A';
+            await controllerAction(controllerUrl, 'keyboard:press', { profileId: profile, key: selectAllKey }).catch(() => { });
+            await controllerAction(controllerUrl, 'keyboard:press', { profileId: profile, key: 'Backspace' }).catch(() => { });
+            await controllerAction(controllerUrl, 'keyboard:press', { profileId: profile, key: 'Delete' }).catch(() => { });
+            await controllerAction(controllerUrl, 'keyboard:type', {
+                profileId: profile,
+                text: keyword,
+                delay: 80 + Math.floor(Math.random() * 60),
+            }).catch(() => { });
+        }
+        // 操作之间要等待：给输入法/站内联想一点稳定时间
+        await new Promise((r) => setTimeout(r, 420));
+        // 仅用于诊断：记录“相关搜索/推荐词”是否出现及其内容（不做点击/纠错）
+        let suggestionProbe = null;
+        try {
+            const raw = await controllerAction(controllerUrl, 'browser:execute', {
+                profile,
+                script: `(() => {
+          const wrap = document.querySelector('.query-note-wrapper');
+          if (!wrap) return { visible: false, items: [], active: null };
+          const r = wrap.getBoundingClientRect();
+          const visible =
+            r.width > 10 && r.height > 10 && r.bottom > 0 && r.top < (window.innerHeight || 0);
+          const items = Array.from(wrap.querySelectorAll('.item-text'))
+            .map((el) => (el && el.textContent ? el.textContent.trim() : ''))
+            .filter(Boolean)
+            .slice(0, 8);
+          const activeEl =
+            wrap.querySelector('.rec-query.active, .rec-query.selected, .rec-query.current, [aria-selected=\"true\"]') ||
+            null;
+          const active = activeEl && activeEl.textContent ? activeEl.textContent.trim().slice(0, 80) : null;
+          return { visible, items, active };
+        })()`,
+            });
+            suggestionProbe = raw?.result ?? raw?.data?.result ?? raw ?? null;
+        }
+        catch {
+            suggestionProbe = null;
+        }
+        // 开发阶段：必须保证输入框中确实出现目标 keyword，否则直接失败（不做无脑重试）
+        let activeValue = '';
+        try {
+            const raw = await controllerAction(controllerUrl, 'browser:execute', {
+                profile,
+                script: `(() => {
+          const el = document.activeElement;
+          if (!el) return '';
+          const tag = (el.tagName || '').toLowerCase();
+          if (tag === 'input' || tag === 'textarea') {
+            const v = el.value || '';
+            return (typeof v === 'string') ? v : String(v || '');
+          }
+          if (el.isContentEditable) return (el.textContent || '');
+          return '';
+        })()`,
+            });
+            activeValue = raw?.result ?? raw?.data?.result ?? raw ?? '';
+        }
+        catch {
+            activeValue = '';
+        }
+        const rawValue = await readSearchInputValue(config, selector).catch(() => '');
+        const trimmedExpected = String(keyword || '').trim();
+        const trimmedActive = typeof activeValue === 'string' ? activeValue.trim() : '';
+        const trimmedRaw = typeof rawValue === 'string' ? rawValue.trim() : '';
+        const matches = (trimmedActive && trimmedActive === trimmedExpected) || (trimmedRaw && trimmedRaw === trimmedExpected);
+        const valueMismatch = !matches;
+        if (valueMismatch) {
+            console.warn(`[SearchExecutor] keyword not detected in input, continue to press Enter. active="${trimmedActive}", selectorValue="${trimmedRaw}", expected="${trimmedExpected}"`);
+        }
+        async function readUrl() {
+            try {
+                const raw = await controllerAction(controllerUrl, 'browser:execute', {
+                    profile,
+                    script: 'location.href',
+                });
+                const v = raw?.result ?? raw?.data?.result ?? raw ?? '';
+                return typeof v === 'string' ? v : String(v || '');
+            }
+            catch {
+                return '';
+            }
+        }
+        async function waitForSearchResultUrl(maxWaitMs) {
+            const start = Date.now();
+            let last = '';
+            while (Date.now() - start < maxWaitMs) {
+                last = await readUrl();
+                if (typeof last === 'string' && last.includes('/search_result')) {
+                    return { ok: true, url: last };
+                }
+                await new Promise((r) => setTimeout(r, 400));
+            }
+            return { ok: false, url: last };
+        }
+        // 中文输入法下 Enter 可能先“确认输入”而不触发搜索：最多 2 次 Enter（不循环重搜）
+        let navigated = false;
+        let lastUrl = '';
+        const useSearchButton = searchInputContainerId === 'xiaohongshu_home.search_input';
+        if (useSearchButton) {
+            console.log('[SearchExecutor] Trigger search via home search button ...');
+            try {
+                const clickResp = await controllerAction(controllerUrl, 'container:operation', {
+                    containerId: 'xiaohongshu_home.search_button',
+                    operationId: 'click',
+                    sessionId: profile,
+                    config: { fullyVisible: true, useSystemMouse: true },
+                });
+                const ok = Boolean(clickResp?.success !== false && (clickResp?.data?.success ?? true));
+                if (!ok) {
+                    console.warn('[SearchExecutor] search button click failed', clickResp);
+                }
+            }
+            catch (error) {
+                console.warn('[SearchExecutor] search button click failed', error?.message || String(error));
+            }
+            await new Promise((r) => setTimeout(r, 650));
+            const waited = await waitForSearchResultUrl(9000);
+            lastUrl = waited.url;
+            navigated = waited.ok;
+        }
+        if (!navigated) {
+            for (let attempt = 1; attempt <= 2; attempt += 1) {
+                console.log(`[SearchExecutor] Press Enter (attempt=${attempt}/2) ...`);
+                await controllerAction(controllerUrl, 'keyboard:press', { profileId: profile, key: 'Enter' }).catch(() => { });
+                await new Promise((r) => setTimeout(r, 450));
+                const waited = await waitForSearchResultUrl(7000);
+                lastUrl = waited.url;
+                if (waited.ok) {
+                    navigated = true;
+                    break;
+                }
+            }
+        }
+        console.log('[SearchExecutor] Search triggered, waiting for results...');
+        if (!navigated) {
+            return {
+                success: false,
+                error: `search_not_navigated_after_enter (url="${lastUrl || ''}")`,
+                debug: {
+                    selector,
+                    searchInputContainerId,
+                    suggestions: suggestionProbe,
+                    valueMismatch,
+                    activeValue: trimmedActive,
+                    selectorValue: trimmedRaw,
+                },
+            };
+        }
+        return {
+            success: true,
+            debug: {
+                selector,
+                searchInputContainerId,
+                suggestions: suggestionProbe,
+                valueMismatch,
+                activeValue: trimmedActive,
+                selectorValue: trimmedRaw,
+            },
+        };
+    }
+    catch (error) {
+        console.error(`[SearchExecutor] Search failed: ${error.message}`);
+        return { success: false, error: error.message };
+    }
+}
+export async function performSystemClickFocus(config, selector) {
+    const { profile, controllerUrl, searchInputContainerId } = config;
+    try {
+        const clickResp = await controllerAction(controllerUrl, 'container:operation', {
+            containerId: searchInputContainerId,
+            operationId: 'click',
+            config: { selector, useSystemMouse: true, fullyVisible: true },
+            sessionId: profile
+        });
+        console.log('[SearchExecutor] System click on search bar executed', clickResp);
+        const focused = await isSearchInputFocused(config, selector);
+        return { success: true, focused };
+    }
+    catch (error) {
+        console.warn('[SearchExecutor] System click on search bar failed:', error.message);
+        return { success: false, focused: false, error: error.message };
+    }
+}
+//# sourceMappingURL=searchExecutor.js.map

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

@@ -0,0 +1,46 @@
+/**
+ * SearchGate helper
+ *
+ * 处理搜索节流请求，避免因频繁搜索触发风控
+ */
+export async function waitSearchPermit(config) {
+    const { profileId, windowMs = 60_000, maxCount = 2, gateUrl = process.env.WEBAUTO_SEARCH_GATE_URL || 'http://127.0.0.1:7790/permit', maxRetries = 5 } = config;
+    async function requestOnce() {
+        const response = await fetch(gateUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                profileId,
+                windowMs,
+                maxCount
+            }),
+            signal: AbortSignal.timeout ? AbortSignal.timeout(5000) : undefined
+        });
+        if (!response.ok) {
+            throw new Error(`SearchGate HTTP ${response.status}`);
+        }
+        const data = await response.json();
+        return {
+            allowed: Boolean(data.allowed),
+            waitMs: Number(data.waitMs || 0)
+        };
+    }
+    try {
+        for (let i = 0; i < maxRetries; i++) {
+            const { allowed, waitMs } = await requestOnce();
+            if (allowed) {
+                console.log('[SearchGate] Permit granted');
+                return;
+            }
+            const safeWait = Math.min(Math.max(waitMs, 5_000), 65_000);
+            console.log(`[SearchGate] Throttling, wait ${safeWait}ms`);
+            await new Promise(resolve => setTimeout(resolve, safeWait));
+        }
+        throw new Error('SearchGate throttling: too many retries');
+    }
+    catch (err) {
+        console.error('[SearchGate] Not available:', err.message);
+        throw new Error('SearchGate not available, 请先在另一终端运行 node scripts/search-gate-server.mjs');
+    }
+}
+//# sourceMappingURL=searchGate.js.map

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

@@ -0,0 +1,164 @@
+/**
+ * SearchPageState helper
+ *
+ * 处理搜索页面状态验证和 URL 关键词校验
+ */
+function safeDecodeURIComponent(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+export function urlKeywordEquals(url, keyword) {
+    const raw = url || '';
+    if (!raw.includes('/search_result'))
+        return false;
+    try {
+        const u = new URL(raw);
+        const kw = u.searchParams.get('keyword');
+        if (!kw)
+            return false;
+        const decoded = safeDecodeURIComponent(safeDecodeURIComponent(kw)).trim();
+        return decoded === String(keyword || '').trim();
+    }
+    catch {
+        const decodedUrl = safeDecodeURIComponent(safeDecodeURIComponent(raw));
+        if (!decodedUrl.includes('/search_result'))
+            return false;
+        try {
+            const u2 = new URL(decodedUrl);
+            const kw2 = u2.searchParams.get('keyword');
+            if (!kw2)
+                return false;
+            const decoded2 = safeDecodeURIComponent(safeDecodeURIComponent(kw2)).trim();
+            return decoded2 === String(keyword || '').trim();
+        }
+        catch {
+            return false;
+        }
+    }
+}
+export async function getCurrentUrl(config) {
+    const { profile, controllerUrl } = config;
+    const response = await fetch(controllerUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            action: 'browser:execute',
+            payload: {
+                profile,
+                script: 'location.href'
+            }
+        })
+    });
+    const data = await response.json();
+    return data.data?.result || '';
+}
+export async function ensureHomePage(config) {
+    const { profile, controllerUrl } = config;
+    const url = await getCurrentUrl({ profile, controllerUrl });
+    if (!url.includes('xiaohongshu.com')) {
+        throw new Error(`Not on xiaohongshu.com (current url=${url || 'unknown'}), please navigate manually before searching.`);
+    }
+    try {
+        const detailState = await fetch(controllerUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'browser:execute',
+                payload: {
+                    profile,
+                    script: `(() => {
+            const selectors = [
+              '.note-detail-mask',
+              '.note-detail-page',
+              '.note-detail-dialog',
+              '.note-detail',
+              '.detail-container',
+              '.media-container'
+            ];
+            const isVisible = (el) => {
+              if (!el) return false;
+              const style = window.getComputedStyle(el);
+              if (style.display === 'none' || style.visibility === 'hidden' || style.opacity === '0') return false;
+              const r = el.getBoundingClientRect();
+              if (!r.width || !r.height) return false;
+              if (r.bottom <= 0 || r.top >= window.innerHeight) return false;
+              return true;
+            };
+            let visibleOverlay = null;
+            for (const sel of selectors) {
+              const el = document.querySelector(sel);
+              if (el && isVisible(el)) {
+                visibleOverlay = el;
+                break;
+              }
+            }
+            return { hasDetailOverlayVisible: !!visibleOverlay };
+          })()`
+                },
+            }),
+        }).then((r) => r.json());
+        const payload = detailState.data?.result ?? detailState.result ?? {};
+        if (payload.hasDetailOverlayVisible) {
+            throw new Error('Currently in visible detail overlay, please exit detail before searching.');
+        }
+    }
+    catch (err) {
+        if (err?.message?.includes('Currently in detail overlay')) {
+            throw err;
+        }
+        console.warn('[SearchPageState] Detail-overlay check failed:', err?.message || err);
+    }
+    const onSearchPage = url.includes('/search_result');
+    const onCaptchaPage = url.includes('captcha') || url.includes('verify');
+    if (onCaptchaPage) {
+        throw new Error('Detected CAPTCHA page, please solve it manually.');
+    }
+    return {
+        success: true,
+        url,
+        onSearchPage,
+        onCaptchaPage
+    };
+}
+export async function probeSearchPageState(config) {
+    const { profile, controllerUrl } = config;
+    try {
+        const response = await fetch(controllerUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'browser:execute',
+                payload: {
+                    profile,
+                    script: `(() => {
+            const cards = document.querySelectorAll('.note-item').length;
+            const emptyEl =
+              document.querySelector('[class*="no-result"], [class*="noResult"], [class*="empty"], .search-empty, .empty') ||
+              null;
+            const emptyText = (emptyEl ? (emptyEl.textContent || '') : '').trim();
+            const bodyText = (document.body && document.body.innerText ? document.body.innerText.slice(0, 1200) : '');
+            const hasNoResultText =
+              emptyText.includes('没找到相关内容') ||
+              emptyText.includes('换个词试试') ||
+              bodyText.includes('没找到相关内容') ||
+              bodyText.includes('换个词试试');
+            return { cards, hasNoResultText };
+          })()`
+                },
+            }),
+            signal: AbortSignal.timeout ? AbortSignal.timeout(5000) : undefined,
+        });
+        const data = await response.json().catch(() => ({}));
+        const payload = data.data?.result ?? data.result ?? {};
+        const cards = Number(payload.cards || 0);
+        return { hasItems: cards > 0, hasNoResultText: Boolean(payload.hasNoResultText) };
+    }
+    catch {
+        return { hasItems: false, hasNoResultText: false };
+    }
+}
+//# sourceMappingURL=searchPageState.js.map

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

@@ -0,0 +1,64 @@
+/**
+ * SearchResultWaiter helper
+ *
+ * 处理搜索结果等待和列表锚点验证
+ */
+import { getCurrentUrl, urlKeywordEquals, probeSearchPageState } from './searchPageState.js';
+async function verifySearchResultListAnchor(profile, controllerUrl) {
+    try {
+        const serviceUrl = controllerUrl.replace('/v1/controller/action', '');
+        const { verifyAnchorByContainerId } = await import('./containerAnchors.js');
+        const anchor = await verifyAnchorByContainerId('xiaohongshu_search.search_result_list', profile, serviceUrl);
+        if (!anchor.found) {
+            return {
+                found: false,
+                error: anchor.error || 'anchor_not_found',
+                selector: anchor.selector,
+                rect: anchor.rect
+            };
+        }
+        return {
+            found: true,
+            selector: anchor.selector,
+            rect: anchor.rect
+        };
+    }
+    catch (error) {
+        return { found: false, error: error.message };
+    }
+}
+export async function waitForSearchResultsReady(config) {
+    const { profile, controllerUrl, keyword, maxWaitMs = 30000 } = config;
+    const start = Date.now();
+    let lastUrl = '';
+    while (Date.now() - start < maxWaitMs) {
+        lastUrl = await getCurrentUrl({ profile, controllerUrl });
+        if (lastUrl.includes('captcha') || lastUrl.includes('verify')) {
+            return { ok: false, noResults: false, url: lastUrl };
+        }
+        const urlLooksRight = lastUrl.includes('/search_result') && urlKeywordEquals(lastUrl, keyword);
+        if (!urlLooksRight) {
+            await new Promise(resolve => setTimeout(resolve, 800));
+            continue;
+        }
+        const listAnchor = await verifySearchResultListAnchor(profile, controllerUrl);
+        if (listAnchor.found && listAnchor.rect) {
+            return {
+                ok: true,
+                noResults: false,
+                listAnchor: { selector: listAnchor.selector, rect: listAnchor.rect },
+                url: lastUrl,
+            };
+        }
+        const probe = await probeSearchPageState({ profile, controllerUrl });
+        if (probe.hasNoResultText) {
+            return { ok: false, noResults: true, url: lastUrl };
+        }
+        if (probe.hasItems) {
+            return { ok: true, noResults: false, url: lastUrl };
+        }
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    }
+    return { ok: false, noResults: false, url: lastUrl };
+}
+//# sourceMappingURL=searchResultWaiter.js.map