@web-auto/webauto 0.1.1 → 0.1.3

package/dist/modules/workflow/workflows/WeiboFeedExtractionWorkflow.js

@@ -0,0 +1,359 @@
+/**
+ * 微博 Feed 提取 Workflow (标准化版本)
+ *
+ * 功能：
+ * 1. 事件驱动的帖子提取
+ * 2. 自动点击"展开"按钮
+ * 3. 捕获点击后的完整文本
+ * 4. 标准化接口，可作为 Workflow Chain 的一部分
+ */
+import { EventEmitter } from 'events';
+const MSG_CONTAINER_APPEAR = 'MSG_CONTAINER_APPEAR';
+const MSG_CONTAINER_OPERATION_COMPLETE = 'MSG_CONTAINER_OPERATION_COMPLETE';
+const MSG_CONTAINER_CLICK = 'MSG_CONTAINER_CLICK';
+/**
+ * 微博 Feed 提取 Workflow
+ * 标准化的事件驱动实现
+ */
+export class WeiboFeedExtractionWorkflow extends EventEmitter {
+    config;
+    context;
+    extractedPosts = [];
+    processedPostKeys = new Set();
+    isRunning = false;
+    scrollCount = 0;
+    expandButtonClicks = 0;
+    constructor(config, context) {
+        super();
+        this.config = config;
+        this.context = context;
+    }
+    /**
+     * 启动 Workflow
+     */
+    async execute() {
+        try {
+            this.isRunning = true;
+            this.emit('workflow:start', { config: this.config });
+            // Step 1: 订阅容器事件
+            await this.setupEventListeners();
+            // Step 2: 初始化会话
+            await this.initializeSession();
+            // Step 3: 匹配容器
+            const feedListId = await this.matchContainers();
+            // Step 4: 执行提取循环
+            await this.extractionLoop(feedListId);
+            // Step 5: 清理
+            await this.cleanup();
+            this.emit('workflow:complete', {
+                totalExtracted: this.extractedPosts.length,
+                expandButtonClicks: this.expandButtonClicks
+            });
+            return {
+                success: true,
+                posts: this.extractedPosts,
+                totalExtracted: this.extractedPosts.length
+            };
+        }
+        catch (error) {
+            this.emit('workflow:error', { error: error.message });
+            return {
+                success: false,
+                posts: this.extractedPosts,
+                totalExtracted: this.extractedPosts.length,
+                error: error.message
+            };
+        }
+        finally {
+            this.isRunning = false;
+        }
+    }
+    /**
+     * 设置事件监听器
+     */
+    async setupEventListeners() {
+        const { messageBus } = this.context;
+        // 监听容器出现事件
+        messageBus.subscribe(MSG_CONTAINER_APPEAR, async (event) => {
+            const { containerId, containerType } = event;
+            this.emit('container:appeared', { containerId, containerType });
+            // 如果是"展开"按钮，自动点击
+            if (containerId.includes('expand_button')) {
+                await this.handleExpandButtonAppear(event);
+            }
+        });
+        // 监听容器点击完成事件
+        messageBus.subscribe(MSG_CONTAINER_OPERATION_COMPLETE, async (event) => {
+            const { containerId, operationId, result } = event;
+            if (operationId === 'click' && containerId.includes('expand_button')) {
+                this.emit('expand:clicked', { containerId });
+                // 点击后需要重新提取父容器的内容
+                await this.reExtractAfterExpand(containerId);
+            }
+        });
+    }
+    /**
+     * 处理"展开"按钮出现
+     */
+    async handleExpandButtonAppear(event) {
+        const { containerId } = event;
+        this.emit('expand:detected', { containerId });
+        try {
+            // 发送点击操作
+            await this.context.apiClient.post('/v1/controller/action', {
+                action: 'container:operation',
+                payload: {
+                    containerId,
+                    operationId: 'click',
+                    config: { wait_after: 500 },
+                    sessionId: this.config.profile
+                }
+            });
+            this.expandButtonClicks++;
+            this.emit('expand:click-sent', { containerId, totalClicks: this.expandButtonClicks });
+        }
+        catch (error) {
+            this.emit('expand:click-failed', { containerId, error: error.message });
+        }
+    }
+    /**
+     * 点击后重新提取内容
+     */
+    async reExtractAfterExpand(expandButtonId) {
+        // 获取父容器 ID (feed_post)
+        const parentId = expandButtonId.replace('.expand_button', '');
+        try {
+            // 等待内容加载
+            await new Promise(r => setTimeout(r, 1000));
+            // 重新提取父容器内容
+            const extractResult = await this.extractPost(parentId);
+            if (extractResult) {
+                // 更新已提取的帖子内容
+                const existingIndex = this.extractedPosts.findIndex(p => p.id === parentId);
+                if (existingIndex >= 0) {
+                    this.extractedPosts[existingIndex] = { ...this.extractedPosts[existingIndex], ...extractResult };
+                    this.emit('post:updated-after-expand', { postId: parentId, content: extractResult.content });
+                }
+            }
+        }
+        catch (error) {
+            this.emit('extract:failed-after-expand', { parentId, error: error.message });
+        }
+    }
+    /**
+     * 初始化会话
+     */
+    async initializeSession() {
+        this.emit('session:init-start');
+        const sessions = await this.context.apiClient.post('/v1/controller/action', {
+            action: 'session:list',
+            payload: {}
+        });
+        const active = sessions.data?.data?.sessions?.find((s) => s.profileId === this.config.profile);
+        if (!active) {
+            await this.context.apiClient.post('/v1/controller/action', {
+                action: 'session:create',
+                payload: {
+                    profile: this.config.profile,
+                    url: this.config.url
+                }
+            });
+            await new Promise(r => setTimeout(r, 5000));
+        }
+        this.emit('session:init-complete');
+    }
+    /**
+     * 匹配容器
+     */
+    async matchContainers() {
+        this.emit('match:start');
+        const match = await this.context.apiClient.post('/v1/controller/action', {
+            action: 'containers:match',
+            payload: {
+                profile: this.config.profile,
+                url: this.config.url
+            }
+        });
+        if (!match.data?.matched) {
+            throw new Error('Root container not matched');
+        }
+        const rootId = match.data.container.id;
+        this.emit('match:root-found', { rootId });
+        // 查找 feed_list
+        const inspect = await this.context.apiClient.post('/v1/controller/action', {
+            action: 'containers:inspect-container',
+            payload: {
+                profile: this.config.profile,
+                containerId: rootId
+            }
+        });
+        const feedList = inspect.data?.data?.snapshot?.children?.find((c) => c.id?.includes('feed_list') || c.defId?.includes('feed_list'));
+        if (!feedList) {
+            throw new Error('Feed list container not found');
+        }
+        this.emit('match:feed-list-found', { feedListId: feedList.id });
+        return feedList.id;
+    }
+    /**
+     * 提取循环
+     */
+    async extractionLoop(listId) {
+        const maxScrolls = this.config.maxScrolls || 120;
+        let heightUnchangedCount = 0;
+        let lastHeight = 0;
+        this.emit('extraction:loop-start', { targetCount: this.config.targetCount });
+        while (this.extractedPosts.length < this.config.targetCount &&
+            this.scrollCount < maxScrolls &&
+            heightUnchangedCount < 3) {
+            this.emit('extraction:cycle', {
+                extracted: this.extractedPosts.length,
+                target: this.config.targetCount,
+                scroll: this.scrollCount,
+                maxScrolls
+            });
+            // 获取当前可见的帖子
+            const posts = await this.getVisiblePosts(listId);
+            // 提取每个帖子
+            for (const post of posts) {
+                if (this.extractedPosts.length >= this.config.targetCount)
+                    break;
+                const postKey = this.generatePostKey(post);
+                if (this.processedPostKeys.has(postKey))
+                    continue;
+                const extracted = await this.extractPost(post.id);
+                if (extracted && extracted.content) {
+                    this.extractedPosts.push(extracted);
+                    this.processedPostKeys.add(postKey);
+                    this.emit('post:extracted', {
+                        postId: post.id,
+                        total: this.extractedPosts.length
+                    });
+                }
+                await new Promise(r => setTimeout(r, 500));
+            }
+            // 检查页面高度
+            const currentHeight = await this.getPageHeight();
+            if (currentHeight === lastHeight) {
+                heightUnchangedCount++;
+            }
+            else {
+                heightUnchangedCount = 0;
+            }
+            lastHeight = currentHeight;
+            // 滚动加载更多
+            if (this.extractedPosts.length < this.config.targetCount && heightUnchangedCount < 3) {
+                await this.scrollPage(listId);
+                this.scrollCount++;
+                await new Promise(r => setTimeout(r, this.config.waitAfterScroll || 3000));
+            }
+        }
+        this.emit('extraction:loop-complete', {
+            totalExtracted: this.extractedPosts.length
+        });
+    }
+    /**
+     * 获取可见帖子
+     */
+    async getVisiblePosts(listId) {
+        const inspect = await this.context.apiClient.post('/v1/controller/action', {
+            action: 'containers:inspect-container',
+            payload: {
+                profile: this.config.profile,
+                containerId: listId,
+                maxChildren: 50
+            }
+        });
+        return inspect.data?.data?.snapshot?.children || [];
+    }
+    /**
+     * 提取单个帖子
+     */
+    async extractPost(postId) {
+        try {
+            const res = await this.context.apiClient.post('/v1/controller/action', {
+                action: 'container:operation',
+                payload: {
+                    containerId: postId,
+                    operationId: 'extract',
+                    config: {
+                        fields: {
+                            author: "header a[href*='weibo.com']",
+                            content: "div[class*='detail_wbtext']",
+                            timestamp: "time",
+                            url: "a[href*='weibo.com'][href*='/status/']",
+                            authorUrl: "a[href*='weibo.com/u/']"
+                        },
+                        include_text: true
+                    },
+                    sessionId: this.config.profile
+                }
+            });
+            const extracted = res.data?.data?.extracted?.[0];
+            if (extracted) {
+                return {
+                    id: postId,
+                    author: extracted.author,
+                    content: extracted.text || extracted.content,
+                    url: extracted.url,
+                    authorUrl: extracted.authorUrl,
+                    timestamp: extracted.timestamp
+                };
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * 生成帖子唯一标识
+     */
+    generatePostKey(post) {
+        return post.id || post.defId || `post-${Date.now()}`;
+    }
+    /**
+     * 获取页面高度
+     */
+    async getPageHeight() {
+        const res = await this.context.apiClient.post('/v1/controller/action', {
+            action: 'browser:execute',
+            payload: {
+                sessionId: this.config.profile,
+                script: 'document.documentElement.scrollHeight'
+            }
+        });
+        return res.data?.result || 0;
+    }
+    /**
+     * 滚动页面
+     */
+    async scrollPage(listId) {
+        await this.context.apiClient.post('/v1/controller/action', {
+            action: 'container:operation',
+            payload: {
+                containerId: listId,
+                operationId: 'scroll',
+                config: {
+                    direction: 'down',
+                    distance: this.config.scrollDistance || 800
+                },
+                sessionId: this.config.profile
+            }
+        });
+    }
+    /**
+     * 清理资源
+     */
+    async cleanup() {
+        // 取消订阅等清理工作
+        this.emit('workflow:cleanup');
+    }
+    /**
+     * 停止 Workflow
+     */
+    stop() {
+        this.isRunning = false;
+        this.emit('workflow:stopped');
+    }
+}
+//# sourceMappingURL=WeiboFeedExtractionWorkflow.js.map

package/dist/modules/workflow/workflows/XiaohongshuLoginWorkflow.js

@@ -0,0 +1,110 @@
+/**
+ * XiaohongshuLoginWorkflow
+ *
+ * 目标：
+ * - 确保指定 profile 的浏览器 Session 存在（或创建）
+ * - 基于「登录锚点容器」模型检查登录态（*.login_anchor / xiaohongshu_login.login_guard）
+ *
+ * 说明：
+ * - 这是一个最小登录 Workflow，只负责「起 Session + 判登录」，不做自动登录。
+ * - 依赖的 Block：
+ *   - EnsureSessionBlock：Browser Service /command 层的会话检查与创建
+ *   - EnsureLoginBlock：Unified API controller 层的容器驱动登录检测
+ */
+import { execute as ensureSessionExecute } from '../blocks/EnsureSession.js';
+import { execute as ensureLoginExecute } from '../blocks/EnsureLoginBlock.js';
+export async function execute(input) {
+    const { profileId, startUrl, browserServiceUrl, unifiedApiUrl } = input;
+    if (!profileId) {
+        return {
+            success: false,
+            profileId: '',
+            session: {
+                sessionId: '',
+                status: 'active',
+                currentPage: '',
+                error: 'Missing profileId',
+            },
+            login: {
+                isLoggedIn: false,
+                loginMethod: 'manual_wait',
+                error: 'Missing profileId',
+            },
+            error: 'Missing profileId',
+        };
+    }
+    try {
+        // Step 1: 确保 Session 存在（Browser Service 视角）
+        const sessionInput = {
+            profileId,
+            url: startUrl,
+            serviceUrl: browserServiceUrl || 'http://127.0.0.1:7704',
+        };
+        let sessionResult = await ensureSessionExecute(sessionInput);
+        if (sessionResult.error) {
+            const waitMsRaw = Number(process.env.WEBAUTO_SESSION_WAIT_MS || 0);
+            const waitLimitMs = waitMsRaw <= 0 ? Number.POSITIVE_INFINITY : waitMsRaw;
+            const intervalMs = Math.max(1000, Number(process.env.WEBAUTO_SESSION_WAIT_INTERVAL_MS || 3000));
+            const startTime = Date.now();
+            const waitHint = waitLimitMs === Number.POSITIVE_INFINITY
+                ? '无超时'
+                : `${waitLimitMs}ms`;
+            console.warn(`[EnsureSession] 启动失败: ${sessionResult.error}`);
+            console.warn(`[EnsureSession] 等待用户处理并重试，最大等待: ${waitHint}, 间隔: ${intervalMs}ms`);
+            while (Date.now() - startTime < waitLimitMs) {
+                await new Promise((r) => setTimeout(r, intervalMs));
+                sessionResult = await ensureSessionExecute(sessionInput);
+                if (!sessionResult.error)
+                    break;
+                console.warn(`[EnsureSession] 重试仍失败: ${sessionResult.error}`);
+            }
+        }
+        if (sessionResult.error) {
+            return {
+                success: false,
+                profileId,
+                session: sessionResult,
+                login: {
+                    isLoggedIn: false,
+                    loginMethod: 'manual_wait',
+                    error: 'EnsureSession failed',
+                },
+                error: sessionResult.error,
+            };
+        }
+        // Step 2: 基于容器的登录检测（Unified API / containers:match）
+        const loginInput = {
+            sessionId: profileId,
+            serviceUrl: unifiedApiUrl || 'http://127.0.0.1:7701',
+        };
+        const loginResult = await ensureLoginExecute(loginInput);
+        // Workflow 本身不负责自动登录，仅把状态透出给上层
+        const success = loginResult.isLoggedIn;
+        return {
+            success,
+            profileId,
+            session: sessionResult,
+            login: loginResult,
+            error: success ? undefined : loginResult.error,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            profileId,
+            session: {
+                sessionId: '',
+                status: 'active',
+                currentPage: '',
+                error: error.message || String(error),
+            },
+            login: {
+                isLoggedIn: false,
+                loginMethod: 'manual_wait',
+                error: error.message || String(error),
+            },
+            error: error.message || String(error),
+        };
+    }
+}
+//# sourceMappingURL=XiaohongshuLoginWorkflow.js.map

package/dist/modules/xiaohongshu/app/src/blocks/MatchCommentsBlock.js

@@ -0,0 +1,139 @@
+/**
+ * Block: 评论命中（MatchComments）
+ *
+ * 职责：
+ * - 基于容器提取“视口内评论”
+ * - 按可配置规则匹配关键字（任意一个/任意两个/必选过滤/排除词等）
+ * - 命中后高亮 + 截图留证（可选）
+ *
+ * 说明：
+ * - 不负责导航（safeUrl 由上层负责）
+ * - 不做 DOM click，所有交互均通过 container:operation / 系统能力
+ */
+import path from 'node:path';
+import { promises as fs } from 'node:fs';
+import { controllerAction, delay } from '../utils/controllerAction.js';
+import { isLegacyKeywordRule, matchCommentText } from './helpers/commentMatcher.js';
+import { matchCommentTextDsl } from './helpers/commentMatchDsl.js';
+import { ensureCommentsOpened, extractVisibleComments, highlightCommentRow, isCommentEnd, scrollComments, } from './helpers/xhsComments.js';
+import { resolveDownloadRoot, savePngBase64, takeScreenshotBase64 } from './helpers/evidence.js';
+export async function execute(input) {
+    const { sessionId, rule, unifiedApiUrl = 'http://127.0.0.1:7701', maxScrolls = 12, maxItems = 60, maxMatches = 3, openComments = true, highlightOnFirstMatch = true, screenshotOnFirstMatch = true, noteId = `unknown-${Date.now()}`, env = 'debug', keyword = 'unknown', } = input;
+    const matches = [];
+    const seen = new Set();
+    let rounds = 0;
+    let reachedBottom = false;
+    let firstMatchScreenshot = null;
+    try {
+        if (openComments) {
+            await ensureCommentsOpened(sessionId, unifiedApiUrl);
+        }
+        const outDir = path.join(resolveDownloadRoot(), 'xiaohongshu', env, keyword, 'comment-match', noteId);
+        for (let round = 0; round < maxScrolls; round += 1) {
+            rounds = round + 1;
+            const rows = await extractVisibleComments(sessionId, unifiedApiUrl, maxItems);
+            for (let i = 0; i < rows.length; i += 1) {
+                if (matches.length >= maxMatches)
+                    break;
+                const r = rows[i] || {};
+                const text = String(r.text || '').trim();
+                if (!text)
+                    continue;
+                const key = `${String(r.user_id || '')}:${text}`;
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                const matched = isLegacyKeywordRule(rule)
+                    ? (() => {
+                        const m = matchCommentText(text, rule);
+                        if (!m.ok)
+                            return null;
+                        return {
+                            ok: true,
+                            hits: Array.from(new Set([...m.anyHits, ...m.mustHits, ...m.shouldHits])),
+                            score: m.shouldCount * 100 + m.anyCount + m.mustHits.length,
+                            legacy: {
+                                anyHits: m.anyHits,
+                                mustHits: m.mustHits,
+                                shouldHits: m.shouldHits,
+                                anyCount: m.anyCount,
+                                shouldCount: m.shouldCount,
+                            },
+                        };
+                    })()
+                    : (() => {
+                        const d = matchCommentTextDsl(text, rule);
+                        if (!d.ok)
+                            return null;
+                        return {
+                            ok: true,
+                            hits: d.hits,
+                            score: d.score,
+                            dsl: { requireHits: d.requireHits, preferHits: d.preferHits },
+                        };
+                    })();
+                if (!matched)
+                    continue;
+                matches.push({
+                    index: i,
+                    userId: String(r.user_id || ''),
+                    userName: String(r.user_name || ''),
+                    content: text,
+                    timestamp: String(r.timestamp || ''),
+                    matched: {
+                        hits: matched.hits,
+                        score: matched.score,
+                        legacy: Object.prototype.hasOwnProperty.call(matched, 'legacy') ? matched.legacy : undefined,
+                        dsl: Object.prototype.hasOwnProperty.call(matched, 'dsl') ? matched.dsl : undefined,
+                    },
+                });
+                if (matches.length === 1 && highlightOnFirstMatch) {
+                    const hl = await highlightCommentRow(sessionId, i, unifiedApiUrl, 'comment-match-first').catch(() => null);
+                    await delay(450);
+                    if (screenshotOnFirstMatch && hl?.inViewport === true && !firstMatchScreenshot) {
+                        const base64 = await takeScreenshotBase64(sessionId, unifiedApiUrl);
+                        if (base64) {
+                            await fs.mkdir(outDir, { recursive: true });
+                            firstMatchScreenshot = await savePngBase64(base64, path.join(outDir, `match-first-${Date.now()}.png`));
+                        }
+                    }
+                }
+            }
+            if (matches.length >= maxMatches)
+                break;
+            reachedBottom = await isCommentEnd(sessionId, unifiedApiUrl);
+            if (reachedBottom)
+                break;
+            await scrollComments(sessionId, unifiedApiUrl, 650).catch(() => { });
+            await delay(900);
+        }
+        return {
+            success: true,
+            rounds,
+            reachedBottom,
+            matches,
+            evidence: { firstMatchScreenshot },
+        };
+    }
+    catch (e) {
+        return {
+            success: false,
+            rounds,
+            reachedBottom,
+            matches,
+            evidence: { firstMatchScreenshot },
+            error: e?.message || String(e),
+        };
+    }
+    finally {
+        // 尽量不破坏会话，仅清理一次高亮 channel（不强制）
+        await controllerAction('browser:execute', {
+            profile: sessionId,
+            script: `(() => {
+          try { window.__webautoRuntime?.highlight?.clear?.('comment-match-first'); } catch {}
+          return true;
+        })()`,
+        }, unifiedApiUrl).catch(() => null);
+    }
+}
+//# sourceMappingURL=MatchCommentsBlock.js.map

package/dist/modules/xiaohongshu/app/src/blocks/Phase1EnsureServicesBlock.js

@@ -0,0 +1,36 @@
+/**
+ * Phase 1 Block: 确保基础服务就绪
+ */
+export async function execute(input = {}) {
+    const { unifiedApiUrl = 'http://127.0.0.1:7701', browserServiceUrl = 'http://127.0.0.1:7704', timeout = 5000, } = input;
+    console.log('[Phase1EnsureServices] 检查服务状态...');
+    let unifiedApiOk = false;
+    try {
+        const res = await fetch(`${unifiedApiUrl}/health`, {
+            signal: AbortSignal.timeout(timeout),
+        });
+        unifiedApiOk = res.ok;
+        console.log(`[Phase1] Unified API: ${unifiedApiOk ? '✅' : '❌'}`);
+    }
+    catch (err) {
+        console.warn(`[Phase1] Unified API 不可达: ${err?.message || String(err)}`);
+    }
+    let browserServiceOk = false;
+    try {
+        const res = await fetch(`${browserServiceUrl}/health`, {
+            signal: AbortSignal.timeout(timeout),
+        });
+        browserServiceOk = res.ok;
+        console.log(`[Phase1] Browser Service: ${browserServiceOk ? '✅' : '❌'}`);
+    }
+    catch (err) {
+        console.warn(`[Phase1] Browser Service 不可达: ${err?.message || String(err)}`);
+    }
+    return {
+        unifiedApiOk,
+        browserServiceOk,
+        unifiedApiUrl,
+        browserServiceUrl,
+    };
+}
+//# sourceMappingURL=Phase1EnsureServicesBlock.js.map