@web-auto/webauto 0.1.1 → 0.1.3

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

@@ -0,0 +1,229 @@
+/**
+ * 标准化微博采集 Workflow
+ *
+ * 输入：数量和输出文件
+ * 输出：指定数量的微博帖子到MD文件
+ */
+import fs from 'fs/promises';
+const UNIFIED_API = 'http://127.0.0.1:7701';
+const PROFILE = 'weibo_fresh';
+async function executeScript(script) {
+    const response = await fetch(`${UNIFIED_API}/v1/controller/action`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            action: 'browser:execute',
+            payload: {
+                sessionId: PROFILE,
+                script
+            }
+        })
+    });
+    const result = await response.json();
+    return result.data?.result ?? result.data;
+}
+async function mouseWheel(deltaY) {
+    await fetch(`${UNIFIED_API}/v1/controller/action`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            action: 'mouse:wheel',
+            payload: {
+                profileId: PROFILE,
+                deltaX: 0,
+                deltaY: Math.max(-800, Math.min(800, Number(deltaY) || 0)),
+            },
+        }),
+    }).then((r) => r.json().catch(() => ({})));
+}
+async function collectWeiboPosts(targetCount) {
+    console.log('🔄 Starting Weibo Collection');
+    console.log('========================================');
+    console.log(`📊 Target: ${targetCount} posts`);
+    console.log('');
+    const collectedPosts = new Map();
+    let scrollCount = 0;
+    let lastHeight = 0;
+    let noChangeCount = 0;
+    const maxNoChangeCount = 3;
+    while (collectedPosts.size < targetCount && scrollCount < 120 && noChangeCount < maxNoChangeCount) {
+        console.log(`📊 Progress: ${collectedPosts.size}/${targetCount} posts | Scroll: ${scrollCount} | No-change: ${noChangeCount}/${maxNoChangeCount}`);
+        // 获取当前页面的帖子
+        const extractScript = `
+      (function() {
+        const posts = document.querySelectorAll('[class*="Feed_wrap_"], [class*="Feed_body_"], article');
+        const results = [];
+
+        posts.forEach((post, index) => {
+          const data = {};
+
+          // 内容链接 - 优先查找包含status的微博链接
+          const statusLink = post.querySelector('a[href*="weibo.com"][href*="/status/"]');
+          if (statusLink) {
+            data.url = statusLink.href;
+          } else {
+            // 备选：查找包含Q开头的链接（微博短链接）
+            const shortLink = post.querySelector('a[href*="weibo.com/"][href*="Q"]');
+            if (shortLink) {
+              data.url = shortLink.href;
+            }
+          }
+
+          // 作者链接 - 查找用户主页链接
+          const userLink = post.querySelector('a[href*="weibo.com/u/"]');
+          if (userLink) {
+            data.authorUrl = userLink.href;
+            data.author = userLink.textContent?.trim() || '未知作者';
+          } else {
+            // 备选：查找其他作者链接
+            const authorSelectors = [
+              'header a[href*="weibo.com"]',
+              'a[href*="weibo.com"][href*="/u/"]',
+              'a[href*="weibo.com"]'
+            ];
+            for (const sel of authorSelectors) {
+              const authorEl = post.querySelector(sel);
+              if (authorEl && authorEl.textContent && authorEl.textContent.trim()) {
+                data.author = authorEl.textContent.trim();
+                data.authorUrl = authorEl.href;
+                break;
+              }
+            }
+          }
+
+          // 内容 - 尝试多个选择器
+          const contentSelectors = [
+            '[class*="detail_wbtext"]',
+            '[class*="wbtext"]',
+            '[class*="content"]',
+            '[class*="text"]'
+          ];
+          for (const sel of contentSelectors) {
+            const contentEl = post.querySelector(sel);
+            if (contentEl && contentEl.textContent && contentEl.textContent.trim()) {
+              data.content = contentEl.textContent.trim().substring(0, 500); // 限制长度
+              break;
+            }
+          }
+
+          // 时间
+          const timeEl = post.querySelector('time');
+          if (timeEl) {
+            data.timestamp = timeEl.textContent?.trim() || timeEl.getAttribute('datetime');
+          }
+
+          // 只收集有内容的帖子
+          if (data.content) {
+            results.push(data);
+          }
+        });
+
+        return results;
+      })()
+    `;
+        const posts = await executeScript(extractScript);
+        // 去重并收集
+        if (Array.isArray(posts)) {
+            let newPosts = 0;
+            posts.forEach((post, index) => {
+                // 使用内容作为唯一标识，避免重复
+                const uniqueKey = post.url || (post.content ? post.content.substring(0, 50) : index);
+                if (uniqueKey && !collectedPosts.has(uniqueKey)) {
+                    collectedPosts.set(uniqueKey, post);
+                    newPosts++;
+                }
+            });
+            console.log(`   ✅ Found ${posts.length} posts on page, added ${newPosts} new, total unique: ${collectedPosts.size}`);
+        }
+        // 检查页面高度是否变化，判断是否到底部
+        const currentHeight = await executeScript('document.documentElement.scrollHeight');
+        console.log(`   📏 Page height: ${currentHeight}, last: ${lastHeight}`);
+        if (currentHeight === lastHeight) {
+            noChangeCount++;
+            console.log(`   ⚠️  Height unchanged (${noChangeCount}/${maxNoChangeCount})`);
+        }
+        else {
+            noChangeCount = 0; // 重置计数
+        }
+        lastHeight = currentHeight;
+        // 如果还需要更多，滚动
+        if (collectedPosts.size < targetCount && noChangeCount < maxNoChangeCount) {
+            console.log('   🔄 Scrolling down...');
+            await mouseWheel(800);
+            await mouseWheel(800);
+            await new Promise(r => setTimeout(r, 3000)); // 等待加载
+            scrollCount++;
+        }
+        else {
+            if (collectedPosts.size >= targetCount) {
+                console.log('   ✅ Target count reached!');
+            }
+            else if (noChangeCount >= maxNoChangeCount) {
+                console.log('   ✅ Reached bottom of page!');
+            }
+        }
+    }
+    console.log(`\n✅ Collection completed! Total: ${collectedPosts.size} posts`);
+    return Array.from(collectedPosts.values());
+}
+async function generateMarkdown(posts, filename) {
+    const lines = [
+        '# 微博采集结果',
+        '',
+        `采集时间：${new Date().toLocaleString('zh-CN')}`,
+        `帖子数量：${posts.length}`,
+        '',
+        '---',
+        ''
+    ];
+    posts.forEach((post, index) => {
+        lines.push(`## ${index + 1}. ${post.author || '未知作者'}`);
+        lines.push('');
+        if (post.content) {
+            lines.push(`**内容：** ${post.content.substring(0, 500)}${post.content.length > 500 ? '...' : ''}`);
+            lines.push('');
+        }
+        if (post.url) {
+            lines.push(`**链接：** ${post.url}`);
+            lines.push('');
+        }
+        if (post.timestamp) {
+            lines.push(`**时间：** ${post.timestamp}`);
+            lines.push('');
+        }
+        if (post.authorUrl) {
+            lines.push(`**作者链接：** ${post.authorUrl}`);
+            lines.push('');
+        }
+        lines.push('---');
+        lines.push('');
+    });
+    const content = lines.join('\n');
+    await fs.writeFile(filename, content, 'utf-8');
+    console.log(`✅ Markdown saved to: ${filename}`);
+}
+async function main(input) {
+    const { count = 250, output = 'weibo_posts_250.md' } = input;
+    try {
+        // 采集帖子
+        const posts = await collectWeiboPosts(count);
+        if (posts.length === 0) {
+            console.log('⚠️  No posts collected.');
+            return;
+        }
+        // 生成 Markdown
+        console.log('\n2️⃣ Generating Markdown report...');
+        await generateMarkdown(posts, output);
+        // 显示结果摘要
+        console.log('\n📋 Collection Summary:');
+        console.log(`   ✅ Total posts: ${posts.length}`);
+        console.log(`   📁 Output file: ${output}`);
+        console.log('\n🎉 Collection completed!');
+    }
+    catch (error) {
+        console.error('❌ Error:', error.message);
+        throw error;
+    }
+}
+export { main as execute };
+//# sourceMappingURL=CollectWeiboPosts.js.map

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

@@ -0,0 +1,259 @@
+/**
+ * Workflow Block: DetectPageStateBlock
+ *
+ * 基于 URL + 容器匹配检测当前页面阶段：
+ * - xiaohongshu: login / detail / search / home / unknown
+ * - weibo: login / detail / search / home / unknown
+ *
+ * 用于在进入各 Phase 前做“入口锚点”判定。
+ */
+import { logControllerActionError, logControllerActionResult, logControllerActionStart, } from './helpers/operationLogger.js';
+const PLATFORM_CONTAINERS = {
+    xiaohongshu: [
+        { id: 'xiaohongshu_login.login_guard', name: '登录页', urlPattern: /\/login/ },
+        { id: 'xiaohongshu_detail.modal_shell', name: '详情页', urlPattern: /\/explore\// },
+        {
+            id: 'xiaohongshu_search.search_result_list',
+            name: '搜索结果页',
+            urlPattern: /\/search_result/,
+        },
+        { id: 'xiaohongshu_home', name: '主页/推荐流', urlPattern: /\/explore/ },
+    ],
+    weibo: [
+        { id: 'weibo_login.login_guard', name: '登录页', urlPattern: /\/signin/ },
+        { id: 'weibo_detail.modal_shell', name: '详情页', urlPattern: /\/\d+\// },
+        { id: 'weibo_search.feed_list', name: '搜索结果页', urlPattern: /\/search/ },
+        { id: 'weibo_home.feed_list', name: '主页', urlPattern: /^https:\/\/weibo\.com\/?$/ },
+    ],
+};
+function detectPlatformFromUrl(url) {
+    if (url.includes('xiaohongshu.com'))
+        return 'xiaohongshu';
+    if (url.includes('weibo.com'))
+        return 'weibo';
+    return 'unknown';
+}
+function detectPageByUrl(url, platformContainers) {
+    for (const def of platformContainers) {
+        if (def.urlPattern && def.urlPattern.test(url)) {
+            return def;
+        }
+    }
+    return null;
+}
+function detectPageByContainer(matchIds, platformContainers, currentUrl) {
+    const containerIds = new Set(matchIds);
+    for (const def of platformContainers) {
+        if (containerIds.has(def.id)) {
+            // 对于小红书搜索结果页，额外检查 URL 是否包含 search_result，避免误把首页当成搜索页
+            if (def.id === 'xiaohongshu_search.search_result_list' && !currentUrl.includes('search_result')) {
+                continue;
+            }
+            return def;
+        }
+    }
+    return null;
+}
+function mapContainerIdToStage(platform, containerId) {
+    if (!containerId)
+        return 'unknown';
+    if (platform === 'xiaohongshu') {
+        if (containerId === 'xiaohongshu_login.login_guard')
+            return 'login';
+        if (containerId === 'xiaohongshu_detail.modal_shell')
+            return 'detail';
+        if (containerId === 'xiaohongshu_search.search_result_list')
+            return 'search';
+        if (containerId === 'xiaohongshu_home')
+            return 'home';
+        return 'unknown';
+    }
+    if (platform === 'weibo') {
+        if (containerId === 'weibo_login.login_guard')
+            return 'login';
+        if (containerId === 'weibo_detail.modal_shell')
+            return 'detail';
+        if (containerId === 'weibo_search.feed_list')
+            return 'search';
+        if (containerId === 'weibo_home.feed_list')
+            return 'home';
+        return 'unknown';
+    }
+    return 'unknown';
+}
+function detectRiskControlByUrl(url, platform) {
+    const u = url.toLowerCase();
+    if (platform === 'xiaohongshu') {
+        return (u.includes('/website-login/captcha') ||
+            u.includes('/website-login/verify') ||
+            u.includes('/website-login/security') ||
+            u.includes('verifyuuid=') ||
+            u.includes('verifytype=') ||
+            u.includes('verifybiz='));
+    }
+    if (platform === 'weibo') {
+        return u.includes('/signup/verify') || u.includes('/security/') || u.includes('/sina/verify');
+    }
+    return false;
+}
+function detectLoginByUrl(url, platform) {
+    if (platform === 'xiaohongshu')
+        return /\/login/.test(url);
+    if (platform === 'weibo')
+        return /\/signin/.test(url);
+    return false;
+}
+export async function execute(input) {
+    const { sessionId, platform: platformHint = 'auto', serviceUrl = 'http://127.0.0.1:7701', } = input;
+    const controllerUrl = `${serviceUrl}/v1/controller/action`;
+    async function controllerAction(action, payload = {}) {
+        const opId = logControllerActionStart(action, payload, { source: 'DetectPageStateBlock' });
+        try {
+            const res = await fetch(controllerUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ action, payload }),
+            });
+            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: 'DetectPageStateBlock' });
+            return result;
+        }
+        catch (error) {
+            logControllerActionError(opId, action, error, payload, { source: 'DetectPageStateBlock' });
+            throw error;
+        }
+    }
+    async function getCurrentUrl() {
+        const data = await controllerAction('browser:execute', {
+            profile: sessionId,
+            script: 'window.location.href',
+        });
+        return data?.result || data?.data?.result || '';
+    }
+    async function getDomSummary() {
+        try {
+            const data = await controllerAction('browser:execute', {
+                profile: sessionId,
+                script: `(() => {
+          const hasDetailMask = !!document.querySelector('.note-detail-mask');
+          const hasSearchInput = !!document.querySelector('input[type="search"], #search-input');
+          return {
+            hasDetailMask,
+            hasSearchInput,
+            readyState: document.readyState,
+            title: document.title
+          };
+        })()`
+            });
+            const result = data?.result || data?.data?.result || null;
+            if (result && typeof result === 'object')
+                return result;
+            return {};
+        }
+        catch {
+            return {};
+        }
+    }
+    async function matchContainers() {
+        // Controller's containers:match requires an explicit URL.
+        // Use the current page URL as the match target; this keeps matching aligned with the active document.
+        const currentUrl = await getCurrentUrl().catch(() => '');
+        const data = await controllerAction('containers:match', {
+            profile: sessionId,
+            url: currentUrl,
+        });
+        const rootId = data?.container?.id || data?.data?.container?.id || null;
+        const matches = data?.snapshot?.matches || data?.data?.snapshot?.matches || {};
+        const matchIds = Object.entries(matches)
+            .filter(([, info]) => {
+            const mc = info?.match_count ?? info?.matchCount ?? 0;
+            return mc > 0;
+        })
+            .map(([id]) => id);
+        return { rootId, matchIds };
+    }
+    // 1) 始终优先尝试通过 URL 判定平台和大致页面
+    const url = await getCurrentUrl().catch(() => '');
+    let platform;
+    if (platformHint === 'auto') {
+        platform = url ? detectPlatformFromUrl(url) : 'unknown';
+    }
+    else {
+        platform = platformHint;
+    }
+    if (platform === 'unknown') {
+        return {
+            success: false,
+            sessionId,
+            platform,
+            url,
+            stage: 'unknown',
+            error: url ? 'Unknown platform from URL' : 'URL unavailable',
+        };
+    }
+    // Hard-stop detection (URL-based) to avoid triggering risk-control via repeated container matching.
+    if (url && detectRiskControlByUrl(url, platform)) {
+        return {
+            success: true,
+            sessionId,
+            platform,
+            url,
+            stage: 'login',
+            pageName: 'risk_control',
+            rootId: null,
+            matchIds: [],
+            dom: await getDomSummary(),
+        };
+    }
+    if (url && detectLoginByUrl(url, platform)) {
+        return {
+            success: true,
+            sessionId,
+            platform,
+            url,
+            stage: 'login',
+            pageName: 'login_page',
+            rootId: null,
+            matchIds: [],
+            dom: await getDomSummary(),
+        };
+    }
+    const platformContainers = PLATFORM_CONTAINERS[platform] || [];
+    const urlDetection = url ? detectPageByUrl(url, platformContainers) : null;
+    // 2) 再尝试做一次容器匹配；如果失败则回退到 URL-only 的判定，而不是直接失败
+    let rootId = null;
+    let matchIds = [];
+    let matchError;
+    const dom = await getDomSummary();
+    try {
+        const matched = await matchContainers();
+        rootId = matched.rootId;
+        matchIds = matched.matchIds;
+    }
+    catch (error) {
+        matchError = error?.message || String(error);
+    }
+    const containerDetection = matchIds.length > 0
+        ? detectPageByContainer([rootId, ...matchIds].filter(Boolean), platformContainers, url)
+        : null;
+    // 以容器检测为主，URL 为辅；若容器匹配失败则退回 URL-only
+    const effectiveDetection = containerDetection || urlDetection || null;
+    const stage = mapContainerIdToStage(platform, effectiveDetection?.id);
+    return {
+        success: true,
+        sessionId,
+        platform,
+        url,
+        stage,
+        pageName: effectiveDetection?.name,
+        rootId,
+        matchIds,
+        dom,
+        error: matchError,
+    };
+}
+//# sourceMappingURL=DetectPageStateBlock.js.map

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

@@ -0,0 +1,162 @@
+/**
+ * Workflow Block: EnsureLoginBlock
+ *
+ * 通过容器匹配确保浏览器处于登录状态
+ * 基于登录锚点模型：*.login_anchor（已登录）或 xiaohongshu_login.login_guard（未登录）
+ */
+/**
+ * 确保登录状态（容器驱动版）
+ *
+ * @param input - 输入参数
+ * @returns Promise<EnsureLoginOutput>
+ */
+export async function execute(input) {
+    const { sessionId, serviceUrl = 'http://127.0.0.1:7701', maxWaitMs = 120000, // 2分钟
+    checkIntervalMs = 3000 } = input;
+    const startTime = Date.now();
+    const waitLimitMs = maxWaitMs <= 0 ? Number.POSITIVE_INFINITY : maxWaitMs;
+    // 检查登录状态的辅助函数
+    async function checkLoginStatus() {
+        try {
+            // 通过 Unified API 调用容器匹配
+            const controllerUrl = `${serviceUrl}/v1/controller/action`;
+            // 优先读取当前 URL 并传给 containers:match，避免为了匹配再额外跑 session-manager CLI（更稳定/更快）
+            let currentUrl = '';
+            try {
+                const urlResp = 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(8000) : undefined,
+                });
+                if (urlResp.ok) {
+                    const urlJson = await urlResp.json().catch(() => ({}));
+                    currentUrl = urlJson?.data?.result || urlJson?.result || '';
+                }
+            }
+            catch {
+                currentUrl = '';
+            }
+            const response = await fetch(controllerUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    action: 'containers:match',
+                    payload: {
+                        profile: sessionId,
+                        ...(currentUrl ? { url: currentUrl } : {}),
+                        // 登录锚点通常在较浅层级即可命中；避免过深/过宽导致 containers:match 超时
+                        maxDepth: 2,
+                        maxChildren: 5
+                    }
+                }),
+                // 为 containers:match 增加超时，避免长时间挂起
+                signal: AbortSignal.timeout ? AbortSignal.timeout(25000) : undefined
+            });
+            if (!response.ok) {
+                return { isLoggedIn: false, error: `HTTP ${response.status}: ${await response.text()}` };
+            }
+            const result = await response.json();
+            const data = result.data || result;
+            const tree = data.snapshot?.container_tree || data.container_tree;
+            // 递归查找匹配的容器
+            function 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 {
+                    isLoggedIn: true,
+                    containerId: loginAnchor.id || loginAnchor.defId
+                };
+            }
+            // 检查未登录容器
+            const loginGuard = findContainer(tree, /xiaohongshu_login\.login_guard$/);
+            if (loginGuard) {
+                return {
+                    isLoggedIn: false,
+                    containerId: loginGuard.id || loginGuard.defId
+                };
+            }
+            // 未匹配到任何登录相关容器
+            return {
+                isLoggedIn: false,
+                error: '未匹配到登录锚点容器（*.login_anchor 或 xiaohongshu_login.login_guard）'
+            };
+        }
+        catch (error) {
+            return {
+                isLoggedIn: false,
+                error: `容器匹配失败: ${error.message}`
+            };
+        }
+    }
+    try {
+        // 首次检查
+        let status = await checkLoginStatus();
+        if (status.isLoggedIn) {
+            return {
+                isLoggedIn: true,
+                loginMethod: 'container_match',
+                matchedContainer: status.containerId,
+                waitTimeMs: Date.now() - startTime
+            };
+        }
+        // 如果未登录，等待人工登录
+        console.log(`[EnsureLogin] 未检测到登录状态，匹配到容器: ${status.containerId || 'none'}`);
+        const waitHint = waitLimitMs === Number.POSITIVE_INFINITY
+            ? '无超时'
+            : `${waitLimitMs}ms`;
+        console.log(`[EnsureLogin] 等待人工登录，最大等待时间: ${waitHint}`);
+        while (Date.now() - startTime < waitLimitMs) {
+            await new Promise(resolve => setTimeout(resolve, checkIntervalMs));
+            status = await checkLoginStatus();
+            if (status.isLoggedIn) {
+                return {
+                    isLoggedIn: true,
+                    loginMethod: 'manual_wait',
+                    matchedContainer: status.containerId,
+                    waitTimeMs: Date.now() - startTime
+                };
+            }
+            if (status.error && !status.error.includes('未匹配到登录锚点容器')) {
+                console.warn(`[EnsureLogin] 检查时出现错误: ${status.error}`);
+            }
+            console.log(`[EnsureLogin] 登录状态检查中... (${Math.floor((Date.now() - startTime) / 1000)}s)`);
+        }
+        // 超时
+        return {
+            isLoggedIn: false,
+            loginMethod: 'timeout',
+            matchedContainer: status.containerId,
+            waitTimeMs: Date.now() - startTime,
+            error: `登录等待超时 (${waitLimitMs}ms)`
+        };
+    }
+    catch (error) {
+        return {
+            isLoggedIn: false,
+            loginMethod: 'container_match',
+            error: `EnsureLogin 执行错误: ${error.message}`
+        };
+    }
+}
+//# sourceMappingURL=EnsureLoginBlock.js.map