@web-auto/webauto 0.1.1 → 0.1.2

package/dist/modules/workflow/blocks/InitAutoScroll.js

@@ -0,0 +1,65 @@
+/**
+ * Workflow Block: InitAutoScroll
+ *
+ * 初始化滚动状态机
+ */
+/**
+ * 初始化自动滚动
+ *
+ * @param input - 输入参数
+ * @returns Promise<InitAutoScrollOutput>
+ */
+export async function execute(input) {
+    const { sessionId, scrollStrategy = 'smooth', scrollDistance = 800, serviceUrl = 'http://127.0.0.1:7704' } = input;
+    const commandUrl = `${serviceUrl}/command`;
+    try {
+        const evalRes = await fetch(commandUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'evaluate',
+                args: {
+                    profileId: sessionId,
+                    script: `
+            (() => {
+              window.__scrollState = {
+                initialized: true,
+                currentPosition: window.scrollY || 0,
+                strategy: '${scrollStrategy}',
+                distance: ${scrollDistance}
+              };
+              return window.__scrollState;
+            })()
+          `
+                }
+            })
+        });
+        const evalData = await evalRes.json();
+        if (!evalData.success) {
+            return {
+                scrollState: {
+                    initialized: true,
+                    currentPosition: 0,
+                    strategy: scrollStrategy,
+                    distance: scrollDistance
+                },
+                error: 'Failed to initialize scroll state'
+            };
+        }
+        return {
+            scrollState: evalData.data
+        };
+    }
+    catch (error) {
+        return {
+            scrollState: {
+                initialized: true,
+                currentPosition: 0,
+                strategy: scrollStrategy,
+                distance: scrollDistance
+            },
+            error: `Init error: ${error.message}`
+        };
+    }
+}
+//# sourceMappingURL=InitAutoScroll.js.map

package/dist/modules/workflow/blocks/LoadContainerDefinition.js

@@ -0,0 +1,50 @@
+/**
+ * Workflow Block: LoadContainerDefinition
+ *
+ * 从容器定义文件加载容器配置
+ */
+import fs from 'fs';
+import path from 'path';
+/**
+ * 加载容器定义
+ *
+ * @param input - 输入参数
+ * @returns Promise<LoadContainerDefinitionOutput>
+ */
+export async function execute(input) {
+    const { siteKey, containerId, containerLibraryRoot } = input;
+    if (!containerLibraryRoot) {
+        return {
+            definition: null,
+            metrics: { selectors: 0, operations: 0 },
+            error: '缺少容器库根目录'
+        };
+    }
+    const containerPath = path.join(containerLibraryRoot, siteKey, ...containerId.split('.').filter(Boolean), 'container.json');
+    if (!fs.existsSync(containerPath)) {
+        return {
+            definition: null,
+            metrics: { selectors: 0, operations: 0 },
+            error: `容器定义不存在: ${containerPath}`
+        };
+    }
+    try {
+        const content = fs.readFileSync(containerPath, 'utf-8');
+        const containerDef = JSON.parse(content);
+        return {
+            definition: containerDef,
+            metrics: {
+                selectors: Array.isArray(containerDef.selectors) ? containerDef.selectors.length : 0,
+                operations: Array.isArray(containerDef.operations) ? containerDef.operations.length : 0
+            }
+        };
+    }
+    catch (error) {
+        return {
+            definition: null,
+            metrics: { selectors: 0, operations: 0 },
+            error: `加载容器定义失败: ${error.message}`
+        };
+    }
+}
+//# sourceMappingURL=LoadContainerDefinition.js.map

package/dist/modules/workflow/blocks/LoadContainerIndex.js

@@ -0,0 +1,43 @@
+/**
+ * Workflow Block: LoadContainerIndex
+ *
+ * 从容器索引文件加载站点配置
+ */
+import fs from 'fs';
+/**
+ * 加载容器索引
+ *
+ * @param context - 执行上下文
+ * @returns Promise<LoadContainerIndexOutput>
+ */
+export async function execute(input) {
+    const { containerIndexPath } = input;
+    if (!fs.existsSync(containerIndexPath)) {
+        return {
+            index: {},
+            metrics: { sites: 0, totalContainers: 0 },
+            error: '容器索引文件不存在'
+        };
+    }
+    try {
+        const content = fs.readFileSync(containerIndexPath, 'utf-8');
+        const index = JSON.parse(content);
+        const sites = Object.keys(index);
+        const totalContainers = sites.reduce((sum, siteKey) => {
+            const site = index[siteKey];
+            return sum + (site?.containers?.length || 0);
+        }, 0);
+        return {
+            index,
+            metrics: { sites: sites.length, totalContainers }
+        };
+    }
+    catch (error) {
+        return {
+            index: {},
+            metrics: { sites: 0, totalContainers: 0 },
+            error: `加载索引失败: ${error.message}`
+        };
+    }
+}
+//# sourceMappingURL=LoadContainerIndex.js.map

package/dist/modules/workflow/blocks/LocateAndGuardBlock.js

@@ -0,0 +1,176 @@
+/**
+ * LocateAndGuardBlock - 全局自我定位与守卫模块
+ *
+ * 功能：
+ * 1. 基于容器匹配分析当前页面状态
+ * 2. 检测 hard stops (risk_control/login_guard/offsite)
+ * 3. 记录定位证据到 run-events.jsonl
+ * 4. 在关键决策点/迷失时调用，避免盲操作
+ *
+ * 使用场景：
+ * - Phase 脚本入口：确保处于预期状态
+ * - 关键操作后验证：导航/点击/滚动后确认状态
+ * - 迷失恢复：未命中预期容器时重新定位并执行最小恢复
+ */
+import { controllerAction } from './helpers/searchExecutor.js';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+function resolveRunEventsPath() {
+    const explicit = process.env.WEBAUTO_RUN_EVENTS;
+    if (explicit && explicit.trim())
+        return explicit.trim();
+    return path.join(os.homedir(), '.webauto', 'logs', 'run-events.jsonl');
+}
+async function emitRunEvent(event, data) {
+    try {
+        const filePath = resolveRunEventsPath();
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        const line = JSON.stringify({ ts: new Date().toISOString(), event, data });
+        fs.appendFileSync(filePath, `${line}\n`);
+    }
+    catch {
+        // Best-effort logging; failure should not block workflow execution.
+    }
+}
+function findContainerNode(tree, targetId) {
+    if (!tree)
+        return null;
+    const root = tree.container || tree.containers?.[0];
+    if (!root)
+        return null;
+    function search(node) {
+        if (node.id === targetId)
+            return node;
+        if (node.children) {
+            for (const child of node.children) {
+                const found = search(child);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    }
+    return search(root);
+}
+function extractContainerRect(node) {
+    return node.match?.nodes?.[0]?.rect || null;
+}
+function detectHardStop(containerTree, url) {
+    const lowerUrl = url.toLowerCase();
+    // 风控页面检测
+    if (lowerUrl.includes('/website-login/captcha') ||
+        lowerUrl.includes('verifyuuid=') ||
+        lowerUrl.includes('/website-login/verify') ||
+        lowerUrl.includes('/website-login/security')) {
+        return 'risk_control';
+    }
+    // 登录保护检测
+    const hasLoginGuard = findContainerNode(containerTree, 'xiaohongshu_login.login_guard');
+    if (hasLoginGuard)
+        return 'login_guard';
+    // 站外检测
+    if (!url.includes('xiaohongshu.com'))
+        return 'offsite';
+    return 'none';
+}
+export async function execute(input) {
+    const { sessionId, controllerUrl = process.env.WEBAUTO_UNIFIED_API_URL || 'http://127.0.0.1:7701', url, expectedContainers = [], invalidateCache = false, maxDepth = 3, maxChildren = 10, rootSelector, evidence = true, } = input;
+    const startTime = Date.now();
+    // 记录定位开始
+    if (evidence) {
+        await emitRunEvent('locate_start', {
+            sessionId,
+            expectedContainers,
+            url,
+        });
+    }
+    try {
+        const matchResult = await controllerAction(controllerUrl, 'containers:match', {
+            profile: sessionId,
+            url,
+            maxDepth,
+            maxChildren,
+            rootSelector,
+            cache: true,
+            invalidateCache,
+        });
+        const snapshot = matchResult?.snapshot || matchResult?.data?.snapshot;
+        const containerTree = snapshot?.container_tree;
+        const currentUrl = snapshot?.url || url || '';
+        const cache = matchResult?.cache || matchResult?.data?.cache || { enabled: false, hit: false, ageMs: null, ttlMs: 5000 };
+        // 检测 hard stops
+        const hardStop = detectHardStop(containerTree, currentUrl);
+        const needManualIntervention = hardStop !== 'none';
+        // 检测期望容器
+        const matchedContainers = [];
+        for (const id of expectedContainers) {
+            const node = findContainerNode(containerTree, id);
+            if (node) {
+                matchedContainers.push(id);
+            }
+        }
+        const located = expectedContainers.length === 0
+            ? true // 无期望容器时，只要有任何容器匹配就算定位成功
+            : matchedContainers.length > 0;
+        const duration = Date.now() - startTime;
+        // 记录定位结果
+        if (evidence) {
+            await emitRunEvent('locate_result', {
+                sessionId,
+                url: currentUrl,
+                expectedContainers,
+                matchedContainers,
+                located,
+                hardStop,
+                needManualIntervention,
+                cache,
+                duration,
+            });
+        }
+        return {
+            located,
+            url: currentUrl,
+            matchedContainers,
+            hardStop,
+            needManualIntervention,
+            cache,
+            duration,
+        };
+    }
+    catch (err) {
+        const duration = Date.now() - startTime;
+        if (evidence) {
+            await emitRunEvent('locate_error', {
+                sessionId,
+                expectedContainers,
+                error: err?.message || String(err),
+                duration,
+            });
+        }
+        throw err;
+    }
+}
+/**
+ * 检查是否处于预期状态，若不是则抛出错误
+ */
+export function guardOrThrow(output, context) {
+    if (output.needManualIntervention) {
+        throw new Error(`[${context}] Hard stop detected: ${output.hardStop}. URL: ${output.url}. Manual intervention required.`);
+    }
+    if (!output.located) {
+        throw new Error(`[${context}] Locate failed. Expected containers not found. URL: ${output.url}`);
+    }
+}
+/**
+ * 检查是否包含指定容器
+ */
+export function hasContainer(output, containerId) {
+    return output.matchedContainers.includes(containerId);
+}
+export default {
+    execute,
+    guardOrThrow,
+    hasContainer,
+};
+//# sourceMappingURL=LocateAndGuardBlock.js.map

package/dist/modules/workflow/blocks/LoginRecoveryBlock.js

@@ -0,0 +1,242 @@
+/**
+ * Workflow Block: LoginRecoveryBlock
+ *
+ * 职责：
+ * - 检测当前登录状态
+ * - 若未登录，尝试自动恢复（调用 Phase1 登录流程）
+ * - 提供明确的失败原因和恢复建议
+ * - 用于长时间运行任务中的登录状态保障
+ */
+import { spawn } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { logControllerActionError, logControllerActionResult, logControllerActionStart, } from './helpers/operationLogger.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = path.resolve(__dirname, '..', '..', '..');
+export async function execute(input) {
+    const { sessionId, serviceUrl = 'http://127.0.0.1:7701', maxRetries = 2, autoRecover = true } = input;
+    const controllerUrl = `${serviceUrl}/v1/controller/action`;
+    async function controllerAction(action, payload = {}) {
+        const opId = logControllerActionStart(action, payload, { source: 'LoginRecoveryBlock' });
+        try {
+            const res = await fetch(controllerUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ action, payload }),
+                signal: AbortSignal.timeout ? AbortSignal.timeout(10000) : undefined
+            });
+            if (!res.ok) {
+                throw new Error(`HTTP ${res.status}: ${await res.text()}`);
+            }
+            const data = await res.json();
+            const result = data.data || data;
+            logControllerActionResult(opId, action, result, { source: 'LoginRecoveryBlock' });
+            return result;
+        }
+        catch (error) {
+            logControllerActionError(opId, action, error, payload, { source: 'LoginRecoveryBlock' });
+            throw error;
+        }
+    }
+    /**
+     * 通过容器匹配检测登录状态（login_anchor / login_guard）
+     * - logged_in: 命中任意 *.login_anchor
+     * - not_logged_in: 命中 xiaohongshu_login.login_guard
+     * - uncertain: 未命中上述任何容器
+     * - error: containers:match 调用异常
+     */
+    async function checkLoginByContainer() {
+        try {
+            // 先拿当前 URL，再显式传给 containers:match，避免因为默认 URL（如 about:blank）
+            // 找不到 definitions 而直接 400。
+            const currentUrl = await getCurrentUrl();
+            const matchPayload = {
+                profile: sessionId,
+                maxDepth: 3,
+                maxChildren: 8
+            };
+            if (currentUrl) {
+                matchPayload.url = currentUrl;
+            }
+            const matchResult = await controllerAction('containers:match', matchPayload);
+            const snapshot = matchResult?.snapshot || matchResult;
+            const tree = snapshot?.container_tree;
+            if (!tree) {
+                return { status: 'uncertain', detail: 'no_container_tree' };
+            }
+            const findContainer = (node, pattern) => {
+                if (!node)
+                    return null;
+                if (pattern.test(node.id || node.defId || ''))
+                    return node;
+                if (Array.isArray(node.children)) {
+                    for (const child of node.children) {
+                        const found = findContainer(child, pattern);
+                        if (found)
+                            return found;
+                    }
+                }
+                return null;
+            };
+            const loginAnchor = findContainer(tree, /\.login_anchor$/);
+            if (loginAnchor) {
+                return {
+                    status: 'logged_in',
+                    detail: loginAnchor.id || loginAnchor.defId
+                };
+            }
+            const loginGuard = findContainer(tree, /xiaohongshu_login\.login_guard$/);
+            if (loginGuard) {
+                return {
+                    status: 'not_logged_in',
+                    detail: loginGuard.id || loginGuard.defId
+                };
+            }
+            return {
+                status: 'uncertain',
+                detail: 'no_login_anchor_or_guard'
+            };
+        }
+        catch (err) {
+            console.warn('[LoginRecovery] 容器检测异常:', err.message);
+            return { status: 'error', detail: err.message || 'containers:match error' };
+        }
+    }
+    async function getCurrentUrl() {
+        try {
+            const data = await controllerAction('browser:execute', {
+                profile: sessionId,
+                script: 'location.href'
+            });
+            const url = data?.result || data?.data?.result || '';
+            console.log('[LoginRecovery] getCurrentUrl:', url || '<empty>');
+            return url;
+        }
+        catch {
+            console.warn('[LoginRecovery] getCurrentUrl failed');
+            return '';
+        }
+    }
+    /**
+     * 调用 Phase1 登录脚本
+     */
+    async function runPhase1Login() {
+        console.log('[LoginRecovery] 检测到未登录，尝试自动恢复...');
+        const phase1Script = path.join(repoRoot, 'scripts', 'xiaohongshu', 'tests', 'phase1-session-login-with-gate.mjs');
+        return new Promise((resolve) => {
+            const child = spawn('node', [phase1Script], {
+                cwd: repoRoot,
+                stdio: 'inherit', // 让用户看到登录过程
+                detached: false
+            });
+            child.on('exit', async (code) => {
+                if (code === 0) {
+                    console.log('[LoginRecovery] Phase1 登录脚本执行完成');
+                    // 等待几秒让页面稳定
+                    await new Promise(r => setTimeout(r, 3000));
+                    // 重新验证登录状态
+                    const loggedIn = await checkLoginByContainer();
+                    resolve(loggedIn.status === 'logged_in');
+                }
+                else {
+                    console.error('[LoginRecovery] Phase1 登录脚本失败，退出码:', code);
+                    resolve(false);
+                }
+            });
+            child.on('error', (err) => {
+                console.error('[LoginRecovery] 启动 Phase1 脚本失败:', err.message);
+                resolve(false);
+            });
+        });
+    }
+    // 主流程
+    try {
+        console.log('[LoginRecovery] 检查登录状态...');
+        const state = await checkLoginByContainer();
+        if (state.status === 'logged_in') {
+            console.log('[LoginRecovery] ✅ 已检测到登录态（login_anchor=', state.detail || 'unknown', ')');
+            return {
+                success: true,
+                loggedIn: true,
+                recovered: false
+            };
+        }
+        if (state.status === 'uncertain') {
+            // 状态不确定时不强行自动登录，交给上层脚本决定下一步动作
+            console.warn('[LoginRecovery] ⚠️ 登录状态不确定（容器未命中 login_anchor/login_guard）');
+            return {
+                success: false,
+                loggedIn: false,
+                recovered: false,
+                error: 'login_status_uncertain',
+                suggestion: '请先运行: node scripts/xiaohongshu/tests/status-v2.mjs 或手动检查浏览器页面上的登录状态'
+            };
+        }
+        if (state.status === 'error') {
+            // 容器匹配本身失败时，尝试用 URL 做一次弱判断，避免因为单次超时就阻塞所有后续流程。
+            const url = await getCurrentUrl();
+            if (url && url.includes('xiaohongshu.com') && !url.includes('/login')) {
+                console.warn('[LoginRecovery] ⚠️ 容器检测失败，但当前仍在小红书非登录页，暂按“已登录”处理（弱判断，仅供长任务继续执行）');
+                return {
+                    success: true,
+                    loggedIn: true,
+                    recovered: false,
+                    error: `登录容器检测失败: ${state.detail}`,
+                    suggestion: '建议在前台或通过 scripts/xiaohongshu/tests/status-v2.mjs 再次确认登录锚点是否正常命中'
+                };
+            }
+            return {
+                success: false,
+                loggedIn: false,
+                recovered: false,
+                error: `登录容器检测失败: ${state.detail}`,
+                suggestion: '请检查 Unified API / Browser Service 状态，或手动运行 Phase1 登录脚本'
+            };
+        }
+        // 走到这里说明明确未登录（命中 login_guard）
+        if (!autoRecover) {
+            return {
+                success: true,
+                loggedIn: false,
+                recovered: false,
+                error: '未检测到登录态',
+                suggestion: '请先运行: node scripts/xiaohongshu/tests/phase1-session-login-with-gate.mjs'
+            };
+        }
+        // 尝试自动恢复
+        for (let i = 0; i < maxRetries; i++) {
+            console.log(`[LoginRecovery] 自动恢复尝试 ${i + 1}/${maxRetries}`);
+            const recovered = await runPhase1Login();
+            if (recovered) {
+                console.log('[LoginRecovery] ✅ 登录恢复成功');
+                return {
+                    success: true,
+                    loggedIn: true,
+                    recovered: true
+                };
+            }
+            if (i < maxRetries - 1) {
+                console.log('[LoginRecovery] 等待5秒后重试...');
+                await new Promise(resolve => setTimeout(resolve, 5000));
+            }
+        }
+        return {
+            success: false,
+            loggedIn: false,
+            recovered: false,
+            error: '自动登录恢复失败',
+            suggestion: '请手动运行: node scripts/xiaohongshu/tests/phase1-session-login-with-gate.mjs'
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            loggedIn: false,
+            recovered: false,
+            error: `登录检查异常: ${err.message}`,
+            suggestion: '请检查会话状态和网络连接'
+        };
+    }
+}
+//# sourceMappingURL=LoginRecoveryBlock.js.map

package/dist/modules/workflow/blocks/MatchContainers.js

@@ -0,0 +1,64 @@
+/**
+ * Workflow Block: MatchContainers
+ *
+ * 执行容器匹配
+ */
+/**
+ * 执行容器匹配
+ *
+ * @param input - 输入参数
+ * @returns Promise<MatchContainersOutput>
+ */
+export async function execute(input) {
+    const { sessionId, rootSelector, serviceUrl = 'http://127.0.0.1:7704' } = input;
+    const commandUrl = `${serviceUrl}/command`;
+    try {
+        const domRes = await fetch(commandUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'evaluate',
+                args: {
+                    profileId: sessionId,
+                    script: `
+            (() => {
+              const root = document.querySelector('${rootSelector || "body"}');
+              if (!root) return { error: 'Root not found' };
+              return {
+                tag: root.tagName,
+                classes: Array.from(root.classList),
+                html: root.outerHTML.slice(0, 1000)
+              };
+            })()
+          `
+                }
+            })
+        });
+        const domData = await domRes.json();
+        if (!domData.success) {
+            return {
+                snapshot: { root: null, timestamp: 0 },
+                matchCount: 0,
+                rootContainerId: '',
+                error: `Failed to access DOM: ${domData.error}`
+            };
+        }
+        return {
+            snapshot: {
+                root: domData.data,
+                timestamp: Date.now()
+            },
+            matchCount: 1,
+            rootContainerId: 'matched.container.id'
+        };
+    }
+    catch (error) {
+        return {
+            snapshot: { root: null, timestamp: 0 },
+            matchCount: 0,
+            rootContainerId: '',
+            error: `Match error: ${error.message}`
+        };
+    }
+}
+//# sourceMappingURL=MatchContainers.js.map