@web-auto/webauto 0.1.4 → 0.1.6

package/dist/modules/xiaohongshu/app/src/workflow/blocks/WaitSearchPermitBlock.js

@@ -0,0 +1,162 @@
+/**
+ * Workflow Block: WaitSearchPermitBlock
+ *
+ * 职责：
+ * 1. 向 SearchGate 申请搜索许可
+ * 2. 如果未获许可，自动等待并重试
+ * 3. 只有拿到许可后才成功返回
+ */
+export async function execute(input) {
+    const { sessionId, keyword, gateUrl = process.env.WEBAUTO_SEARCH_GATE_URL || 'http://127.0.0.1:7790', serviceUrl = 'http://127.0.0.1:7701', maxWaitMs = 300_000 } = input;
+    // Gate errors are not actionable by waiting; fail fast instead of retry loops.
+    const failFastOnGateError = String(process.env.WEBAUTO_SEARCH_GATE_FAIL_FAST || '1') !== '0';
+    const skipIfAlreadyOnSearchResult = typeof input.skipIfAlreadyOnSearchResult === 'boolean' ? input.skipIfAlreadyOnSearchResult : true;
+    const dev = typeof input.dev === 'boolean'
+        ? input.dev
+        : (process.env.DEBUG === '1');
+    const devTag = typeof input.devTag === 'string' && input.devTag.trim()
+        ? String(input.devTag).trim()
+        : (dev ? 'dev' : '');
+    // 若已经在正确的搜索结果页，直接跳过（避免重复申请 permit 造成“看起来像连续搜索”）
+    if (skipIfAlreadyOnSearchResult && typeof keyword === 'string' && keyword.trim()) {
+        try {
+            const { urlKeywordEquals } = await import('./helpers/searchPageState.js');
+            const controllerUrl = `${serviceUrl.replace(/\/$/, '')}/v1/controller/action`;
+            const resp = await fetch(controllerUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    action: 'browser:execute',
+                    payload: { profile: sessionId, script: 'location.href' },
+                }),
+                signal: AbortSignal.timeout ? AbortSignal.timeout(5000) : undefined,
+            });
+            const data = await resp.json().catch(() => ({}));
+            const url = data?.data?.result || data?.result || '';
+            if (typeof url === 'string' && url.includes('/search_result') && urlKeywordEquals(url, keyword)) {
+                console.log(`[WaitSearchPermit] skip: already on search_result for "${keyword}"`);
+                return { success: true, granted: true, waitedMs: 0, skipped: true };
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    const permitEndpoint = `${gateUrl.replace(/\/$/, '')}/permit`;
+    const start = Date.now();
+    async function requestPermit() {
+        try {
+            const response = await fetch(permitEndpoint, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    key: sessionId,
+                    ...(typeof keyword === 'string' && keyword.trim() ? { keyword: keyword.trim() } : {}),
+                    ...(dev ? { dev: true } : {}),
+                    ...(devTag ? { devTag } : {}),
+                    windowMs: 60_000,
+                    maxCount: 2
+                }),
+                signal: AbortSignal.timeout ? AbortSignal.timeout(5000) : undefined
+            });
+            if (!response.ok) {
+                const text = await response.text().catch(() => '');
+                return { ok: false, retry: true, error: `HTTP ${response.status}${text ? `: ${text}` : ''}` };
+            }
+            const data = await response.json().catch(() => ({}));
+            return {
+                ok: true,
+                allowed: Boolean(data.allowed),
+                waitMs: Number(data.waitMs || 0),
+                retryAfterMs: typeof data.retryAfterMs === 'number' ? Number(data.retryAfterMs) : null,
+                reason: typeof data.reason === 'string' ? data.reason : null,
+                keyword: typeof data.keyword === 'string' ? data.keyword : null,
+                consecutive: typeof data.consecutive === 'number' ? data.consecutive : null,
+                deny: data.deny && typeof data.deny === 'object'
+                    ? {
+                        code: String(data.deny.code || 'unknown'),
+                        message: String(data.deny.message || 'denied'),
+                        retryAfterMs: typeof data.deny.retryAfterMs === 'number' ? Number(data.deny.retryAfterMs) : null,
+                        details: data.deny.details ?? null,
+                        suggestedActions: Array.isArray(data.deny.suggestedActions)
+                            ? data.deny.suggestedActions.map((s) => String(s))
+                            : [],
+                    }
+                    : null,
+                retry: false
+            };
+        }
+        catch (err) {
+            return { ok: false, retry: true, error: err.message };
+        }
+    }
+    console.log(`[WaitSearchPermit] Requesting permit for ${sessionId}...${typeof keyword === 'string' && keyword.trim() ? ` keyword="${keyword.trim()}"` : ''}`);
+    while (Date.now() - start < maxWaitMs) {
+        const result = await requestPermit();
+        if (result.ok && result.allowed) {
+            console.log(`[WaitSearchPermit] ✅ Permit granted (waited ${(Date.now() - start) / 1000}s)`);
+            return { success: true, granted: true, waitedMs: Date.now() - start, reason: result.reason ?? null };
+        }
+        if (result.ok && !result.allowed) {
+            // 开发阶段：禁止连续三次同 keyword 搜索，直接失败（不要无脑重试）
+            if (result.reason === 'dev_consecutive_keyword_limit' || result.deny?.code === 'dev_consecutive_keyword_limit') {
+                const denyMsg = result.deny?.message || '';
+                const actions = (result.deny?.suggestedActions || []).length > 0
+                    ? (result.deny?.suggestedActions || [])
+                    : [
+                        'Stop and inspect logs/screenshots; do not spam search retries.',
+                        'If this is a dev-only rerun and you must search the same keyword again, restart SearchGate to clear in-memory dev keyword history.',
+                        'Alternatively, wait until the dev keyword history expires (default keeps 24h).',
+                    ];
+                console.error(`[WaitSearchPermit] ❌ SearchGate denied: dev_consecutive_keyword_limit (keyword="${String(result.keyword || keyword || '')}", consecutive=${String(result.consecutive ?? '')})${denyMsg ? ` | ${denyMsg}` : ''}`);
+                for (const action of actions) {
+                    console.error(`[WaitSearchPermit]   - ${action}`);
+                }
+                return {
+                    success: false,
+                    granted: false,
+                    waitedMs: Date.now() - start,
+                    reason: result.reason ?? null,
+                    retryAfterMs: result.retryAfterMs ?? result.deny?.retryAfterMs ?? null,
+                    deny: result.deny ?? null,
+                    error: `SearchGate denied: dev_consecutive_keyword_limit (keyword="${String(result.keyword || keyword || '')}", consecutive=${String(result.consecutive ?? '')})`,
+                };
+            }
+            // 只在服务端真正计算出需要等待时才等待
+            const waitMs = Math.max(0, Number(result.retryAfterMs ?? result.waitMs ?? 0));
+            if (waitMs > 0) {
+                console.log(`[WaitSearchPermit] ⏳ Throttled${result.reason ? ` (${result.reason})` : ''}, waiting ${Math.ceil(waitMs / 1000)}s...`);
+                await new Promise(resolve => setTimeout(resolve, waitMs));
+                continue;
+            }
+            else {
+                // waitMs=0：可能是服务端拒绝但未给出等待时间；避免 busy-loop，稍等再试
+                console.warn(`[WaitSearchPermit] ⚠️ Gate denied but waitMs=0${result.reason ? ` (reason=${result.reason})` : ''}, retrying in 1s...`);
+                await new Promise(resolve => setTimeout(resolve, 1000));
+                continue;
+            }
+        }
+        if (!result.ok && result.retry) {
+            const errMsg = String(result.error || 'unknown error');
+            if (failFastOnGateError) {
+                return {
+                    success: false,
+                    granted: false,
+                    waitedMs: Date.now() - start,
+                    error: `SearchGate error: ${errMsg}`,
+                };
+            }
+            console.warn(`[WaitSearchPermit] ⚠️ Gate error (${errMsg}), retrying in 5s...`);
+            await new Promise(resolve => setTimeout(resolve, 5000));
+            continue;
+        }
+        break;
+    }
+    return {
+        success: false,
+        granted: false,
+        waitedMs: Date.now() - start,
+        error: `WaitSearchPermit timeout after ${maxWaitMs / 1000}s`
+    };
+}
+//# sourceMappingURL=WaitSearchPermitBlock.js.map

package/dist/modules/xiaohongshu/app/src/workflow/blocks/helpers/containerAnchors.d.ts

@@ -0,0 +1,36 @@
+/**
+ * 容器锚点验证辅助函数（不依赖 containers:match）
+ * 直接从容器定义 JSON 读取 selector，然后用 browser:execute 高亮 + Rect 回环
+ *
+ * 注意：这里不使用 dist 里的 ContainerDefinitionLoader（V2 结构只保留了 classes，丢失 css），
+ * 而是直接读取 container-library 下的原始 JSON，保证 selector.css 可用。
+ */
+export interface ContainerDefinition {
+    id: string;
+    selectors?: Array<{
+        css?: string;
+        variant?: string;
+        score?: number;
+    }>;
+    extractors?: Record<string, {
+        selectors?: string[];
+        attr?: string;
+    }>;
+}
+export interface AnchorRect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface AnchorVerifyResult {
+    found: boolean;
+    highlighted: boolean;
+    rect?: AnchorRect;
+    selector?: string;
+    error?: string;
+}
+export declare function getPrimarySelectorByContainerId(containerId: string): Promise<string | null>;
+export declare function getContainerExtractorsById(containerId: string): Promise<ContainerDefinition['extractors'] | null>;
+export declare function verifyAnchorByContainerId(containerId: string, sessionId: string, serviceUrl?: string, highlightStyle?: string, highlightDuration?: number): Promise<AnchorVerifyResult>;
+//# sourceMappingURL=containerAnchors.d.ts.map

package/dist/modules/xiaohongshu/app/src/workflow/blocks/helpers/containerAnchors.js

@@ -0,0 +1,301 @@
+/**
+ * 容器锚点验证辅助函数（不依赖 containers:match）
+ * 直接从容器定义 JSON 读取 selector，然后用 browser:execute 高亮 + Rect 回环
+ *
+ * 注意：这里不使用 dist 里的 ContainerDefinitionLoader（V2 结构只保留了 classes，丢失 css），
+ * 而是直接读取 container-library 下的原始 JSON，保证 selector.css 可用。
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { logError, logOperation } from './operationLogger.js';
+const repoRoot = path.resolve(process.cwd());
+const userContainerRoot = process.env.WEBAUTO_USER_CONTAINER_ROOT || path.join(os.homedir(), '.webauto', 'container-lib');
+const containerIndexPath = process.env.WEBAUTO_CONTAINER_INDEX || path.join(repoRoot, 'apps/webauto/resources/container-library.index.json');
+const definitionCache = new Map();
+function loadContainerIndex() {
+    try {
+        const content = fs.readFileSync(containerIndexPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+function findSiteKeyForContainer(containerId, index) {
+    if (!index)
+        return null;
+    const keys = Object.keys(index);
+    for (const key of keys) {
+        if (containerId.startsWith(`${key}_`))
+            return key;
+    }
+    return null;
+}
+function findContainerJsonPath(containerId) {
+    const index = loadContainerIndex();
+    const siteKey = findSiteKeyForContainer(containerId, index) || 'xiaohongshu';
+    const rootDir = path.join(repoRoot, 'apps/webauto/resources/container-library', siteKey);
+    if (!fs.existsSync(rootDir)) {
+        return null;
+    }
+    const stack = [rootDir];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        const stat = fs.statSync(current);
+        if (stat.isDirectory()) {
+            const entries = fs.readdirSync(current);
+            for (const entry of entries) {
+                stack.push(path.join(current, entry));
+            }
+        }
+        else if (current.endsWith('.json')) {
+            try {
+                const content = fs.readFileSync(current, 'utf-8');
+                const json = JSON.parse(content);
+                if (json && json.id === containerId) {
+                    return current;
+                }
+            }
+            catch {
+                // ignore malformed JSON
+            }
+        }
+    }
+    return null;
+}
+async function findContainerDefinition(containerId) {
+    if (definitionCache.has(containerId)) {
+        const cached = definitionCache.get(containerId);
+        if (cached) {
+            return cached;
+        }
+        // 如果之前没有找到（缓存为 null），重新扫描一次，避免负缓存长期生效
+    }
+    // 优先从用户自定义容器根查找
+    if (userContainerRoot && fs.existsSync(userContainerRoot)) {
+        const userRoot = path.join(userContainerRoot, 'xiaohongshu');
+        if (fs.existsSync(userRoot)) {
+            const stack = [userRoot];
+            while (stack.length > 0) {
+                const current = stack.pop();
+                const stat = fs.statSync(current);
+                if (stat.isDirectory()) {
+                    const entries = fs.readdirSync(current);
+                    for (const entry of entries) {
+                        stack.push(path.join(current, entry));
+                    }
+                }
+                else if (current.endsWith('.json')) {
+                    try {
+                        const content = fs.readFileSync(current, 'utf-8');
+                        const json = JSON.parse(content);
+                        if (json && json.id === containerId) {
+                            definitionCache.set(containerId, json);
+                            return json;
+                        }
+                    }
+                    catch {
+                        // ignore
+                    }
+                }
+            }
+        }
+    }
+    const jsonPath = findContainerJsonPath(containerId);
+    if (!jsonPath) {
+        return null;
+    }
+    try {
+        const content = fs.readFileSync(jsonPath, 'utf-8');
+        const json = JSON.parse(content);
+        definitionCache.set(containerId, json);
+        return json;
+    }
+    catch (error) {
+        return null;
+    }
+}
+function pickPrimarySelector(container) {
+    const selectors = container.selectors || [];
+    if (!selectors.length)
+        return null;
+    const primary = selectors.find((item) => item.variant === 'primary') || selectors[0];
+    return primary?.css || null;
+}
+export async function getPrimarySelectorByContainerId(containerId) {
+    const container = await findContainerDefinition(containerId);
+    if (!container) {
+        return null;
+    }
+    return pickPrimarySelector(container);
+}
+export async function getContainerExtractorsById(containerId) {
+    const container = await findContainerDefinition(containerId);
+    if (!container || !container.extractors || typeof container.extractors !== 'object') {
+        return null;
+    }
+    return container.extractors;
+}
+export async function verifyAnchorByContainerId(containerId, sessionId, serviceUrl = 'http://127.0.0.1:7701', highlightStyle = '3px solid #ff4444', highlightDuration = 2000) {
+    console.log(`[verifyAnchorByContainerId] Looking for container: ${containerId}`);
+    console.log(`[verifyAnchorByContainerId] containerIndexPath: ${containerIndexPath}`);
+    console.log(`[verifyAnchorByContainerId] repoRoot: ${repoRoot}`);
+    const container = await findContainerDefinition(containerId);
+    if (!container) {
+        console.error(`[verifyAnchorByContainerId] Container not found: ${containerId}`);
+        return { found: false, highlighted: false, error: `Container not found: ${containerId}` };
+    }
+    const selectors = (container.selectors || [])
+        .map((s) => s?.css)
+        .filter((css) => typeof css === 'string' && css.trim().length > 0);
+    if (!selectors.length) {
+        return { found: false, highlighted: false, error: `No selector defined for: ${containerId}` };
+    }
+    const matchOpId = logOperation({
+        kind: 'anchor_match_start',
+        action: 'anchor:verify',
+        sessionId,
+        payload: {
+            containerId,
+            selectorsCount: selectors.length,
+            serviceUrl,
+        },
+    });
+    try {
+        const selectorsJson = JSON.stringify(selectors);
+        const script = `(() => {
+      const selectors = ${selectorsJson};
+
+      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 el = null;
+      let usedSelector = null;
+      for (const sel of selectors) {
+        const candidate = document.querySelector(sel);
+        if (candidate && isVisible(candidate)) {
+          el = candidate;
+          usedSelector = sel;
+          break;
+        }
+      }
+
+      if (!el) {
+        return { found: false, error: 'Element not found' };
+      }
+
+      // 创建或复用一个 overlay 高亮框，避免被页面样式覆盖
+      let overlay = document.getElementById('webauto-anchor-highlight');
+      if (!overlay) {
+        overlay = document.createElement('div');
+        overlay.id = 'webauto-anchor-highlight';
+        overlay.style.position = 'fixed';
+        overlay.style.pointerEvents = 'none';
+        overlay.style.zIndex = '2147483647';
+        document.body.appendChild(overlay);
+      }
+      const r = el.getBoundingClientRect();
+      overlay.style.left = r.x + 'px';
+      overlay.style.top = r.y + 'px';
+      overlay.style.width = r.width + 'px';
+      overlay.style.height = r.height + 'px';
+      overlay.style.border = '${highlightStyle.replace(/'/g, "\\'")}';
+      overlay.style.boxSizing = 'border-box';
+      overlay.style.background = 'transparent';
+
+      setTimeout(() => {
+        if (overlay && overlay.parentElement) {
+          overlay.parentElement.removeChild(overlay);
+        }
+      }, ${highlightDuration});
+      const rect = el.getBoundingClientRect();
+      return {
+        found: true,
+        selector: usedSelector,
+        rect: { x: rect.x, y: rect.y, width: rect.width, height: rect.height }
+      };
+    })()`;
+        const response = await fetch(`${serviceUrl}/v1/controller/action`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'browser:execute',
+                payload: {
+                    profile: sessionId,
+                    script,
+                },
+            }),
+            // 本地 Unified API 调用在部分页面初始化时可能稍慢，适当放宽超时时间
+            signal: AbortSignal.timeout ? AbortSignal.timeout(30000) : undefined,
+        });
+        if (!response.ok) {
+            return {
+                found: false,
+                highlighted: false,
+                error: `HTTP ${response.status}: ${await response.text()}`,
+            };
+        }
+        const data = await response.json();
+        const result = data.data?.result || data.result;
+        if (!result?.found) {
+            logOperation({
+                kind: 'anchor_match_result',
+                action: 'anchor:verify',
+                sessionId,
+                result: {
+                    found: false,
+                    selector: result?.selector || null,
+                    error: result?.error || 'Element not found',
+                },
+                meta: { opId: matchOpId, containerId },
+            });
+            return {
+                found: false,
+                highlighted: false,
+                selector: result?.selector,
+                error: result?.error || 'Element not found',
+            };
+        }
+        logOperation({
+            kind: 'anchor_match_result',
+            action: 'anchor:verify',
+            sessionId,
+            result: {
+                found: true,
+                selector: result?.selector || null,
+                rect: result?.rect || null,
+            },
+            meta: { opId: matchOpId, containerId },
+        });
+        return {
+            found: true,
+            highlighted: true,
+            rect: result.rect,
+            selector: result.selector,
+        };
+    }
+    catch (error) {
+        logError({
+            kind: 'anchor_match_error',
+            action: 'anchor:verify',
+            sessionId,
+            error: error?.message || String(error),
+            payload: { containerId, serviceUrl },
+            meta: { opId: matchOpId },
+        });
+        return {
+            found: false,
+            highlighted: false,
+            error: `verifyAnchor failed: ${error.message}`,
+        };
+    }
+}
+//# sourceMappingURL=containerAnchors.js.map

package/dist/modules/xiaohongshu/app/src/workflow/blocks/helpers/operationLogger.d.ts

@@ -0,0 +1,29 @@
+export interface OperationLogEntry {
+    kind: string;
+    action?: string;
+    sessionId?: string;
+    context?: string;
+    reason?: string;
+    payload?: Record<string, any> | null;
+    result?: Record<string, any> | null;
+    target?: Record<string, any> | null;
+    meta?: Record<string, any> | null;
+    opId?: number;
+}
+export interface ErrorLogEntry {
+    kind: string;
+    action?: string;
+    sessionId?: string;
+    context?: string;
+    reason?: string;
+    error?: string;
+    payload?: Record<string, any> | null;
+    meta?: Record<string, any> | null;
+    opId?: number;
+}
+export declare function logOperation(entry: OperationLogEntry): number;
+export declare function logError(entry: ErrorLogEntry): number;
+export declare function logControllerActionStart(action: string, payload: any, meta?: Record<string, any>): number;
+export declare function logControllerActionResult(opId: number, action: string, result: any, meta?: Record<string, any>): void;
+export declare function logControllerActionError(opId: number, action: string, error: unknown, payload: any, meta?: Record<string, any>): void;
+//# sourceMappingURL=operationLogger.d.ts.map