@web-auto/webauto 0.1.1 → 0.1.3

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

@@ -0,0 +1,426 @@
+/**
+ * Workflow Block: EnsureSession
+ *
+ * 确保浏览器 Session 存在并处于登录状态
+ */
+import os from 'node:os';
+/**
+ * 确保浏览器 Session 存在
+ *
+ * @param input - 输入参数
+ * @returns Promise<EnsureSessionOutput>
+ */
+export async function execute(input) {
+    const { profileId, url, serviceUrl = 'http://127.0.0.1:7704', viewport } = input;
+    const headless = typeof input.headless === 'boolean' ? input.headless : false;
+    if (!profileId) {
+        return {
+            sessionId: '',
+            status: 'active',
+            currentPage: '',
+            error: 'Missing profileId'
+        };
+    }
+    try {
+        const statusUrl = `${serviceUrl}/command`;
+        const desiredViewport = viewport || {
+            width: Number(process.env.WEBAUTO_VIEWPORT_WIDTH || 1440),
+            height: Number(process.env.WEBAUTO_VIEWPORT_HEIGHT || 1100),
+        };
+        const zoomRaw = String(process.env.WEBAUTO_VIEWPORT_ZOOM ?? '').trim().toLowerCase();
+        const browserZoomRaw = String(process.env.WEBAUTO_BROWSER_ZOOM ?? '').trim().toLowerCase();
+        const allowCssZoom = String(process.env.WEBAUTO_ALLOW_CSS_ZOOM ?? '').trim() === '1';
+        const waitOnFail = String(process.env.WEBAUTO_SESSION_WAIT_ON_FAIL ?? '').trim() !== '0' &&
+            profileId.startsWith('xiaohongshu_');
+        const waitMsRaw = Number(process.env.WEBAUTO_SESSION_WAIT_MS ?? 0);
+        const waitLimitMs = waitMsRaw <= 0 ? Number.POSITIVE_INFINITY : waitMsRaw;
+        const waitIntervalMs = Math.max(1000, Number(process.env.WEBAUTO_SESSION_WAIT_INTERVAL_MS ?? 3000));
+        const waitStartTs = Date.now();
+        function clamp(n, min, max) {
+            if (!Number.isFinite(n))
+                return min;
+            return Math.min(Math.max(n, min), max);
+        }
+        function pickFirstPositive(...values) {
+            for (const value of values) {
+                const parsed = Number(value ?? 0);
+                if (Number.isFinite(parsed) && parsed > 0)
+                    return parsed;
+            }
+            return 0;
+        }
+        function resolveEffectiveMax(displayValue, browserValue) {
+            if (displayValue > 0 && browserValue > 0) {
+                return Math.min(displayValue, browserValue);
+            }
+            return displayValue > 0 ? displayValue : browserValue;
+        }
+        async function getScreenMetrics() {
+            try {
+                const res = await fetch(statusUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        action: 'evaluate',
+                        args: {
+                            profileId,
+                            script: `(() => ({
+                innerWidth: window.innerWidth,
+                innerHeight: window.innerHeight,
+                screenWidth: window.screen?.width,
+                screenHeight: window.screen?.height,
+                availWidth: window.screen?.availWidth,
+                availHeight: window.screen?.availHeight,
+                devicePixelRatio: window.devicePixelRatio
+              }))()`,
+                        },
+                    }),
+                }).then((r) => r.json().catch(() => ({})));
+                const payload = res?.body || res?.data || res;
+                const result = payload?.result || payload?.data?.result;
+                if (!result || typeof result !== 'object')
+                    return null;
+                return result;
+            }
+            catch {
+                return null;
+            }
+        }
+        let cachedMetrics = null;
+        let cachedDisplay = null;
+        async function loadMetrics() {
+            if (cachedMetrics)
+                return cachedMetrics;
+            cachedMetrics = await getScreenMetrics();
+            return cachedMetrics;
+        }
+        async function getDisplayMetrics() {
+            try {
+                const res = await fetch(statusUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ action: 'system:display' }),
+                }).then((r) => r.json().catch(() => ({})));
+                const payload = res?.body || res?.data || res;
+                const metrics = payload?.metrics || payload?.data?.metrics || null;
+                if (!metrics || typeof metrics !== 'object')
+                    return null;
+                return metrics;
+            }
+            catch {
+                return null;
+            }
+        }
+        async function loadDisplay() {
+            if (cachedDisplay)
+                return cachedDisplay;
+            cachedDisplay = await getDisplayMetrics();
+            return cachedDisplay;
+        }
+        async function resolveViewportSize() {
+            const metrics = await loadMetrics();
+            const maxW = Number(metrics?.availWidth || metrics?.screenWidth || 0);
+            const maxH = Number(metrics?.availHeight || metrics?.screenHeight || 0);
+            const innerW = Number(metrics?.innerWidth || 0);
+            const innerH = Number(metrics?.innerHeight || 0);
+            const display = await loadDisplay();
+            const displayW = pickFirstPositive(display?.workWidth, display?.width, display?.nativeWidth);
+            const displayH = pickFirstPositive(display?.workHeight, display?.height, display?.nativeHeight);
+            const effectiveMaxW = resolveEffectiveMax(displayW, maxW);
+            const effectiveMaxH = resolveEffectiveMax(displayH, maxH);
+            const widthCandidate = Number.isFinite(desiredViewport.width) ? desiredViewport.width : 1440;
+            const heightCandidate = Number.isFinite(desiredViewport.height) ? desiredViewport.height : 900;
+            const safeMaxW = effectiveMaxW > 0 ? Math.max(900, effectiveMaxW - 40) : 1920;
+            const safeMaxH = effectiveMaxH > 0 ? Math.max(700, effectiveMaxH - 40) : 1200;
+            const widthBase = effectiveMaxW > 0 ? effectiveMaxW - 40 : (innerW > 0 ? innerW : widthCandidate);
+            const heightBase = effectiveMaxH > 0 ? effectiveMaxH - 40 : (innerH > 0 ? innerH : heightCandidate);
+            const width = clamp(widthBase, 900, safeMaxW);
+            const height = clamp(heightBase, 700, safeMaxH);
+            console.log(`[EnsureSession] display metrics: browser=${maxW}x${maxH} display=${displayW}x${displayH} ` +
+                `effective=${effectiveMaxW}x${effectiveMaxH} inner=${innerW}x${innerH}`);
+            return { width: Math.floor(width), height: Math.floor(height) };
+        }
+        function resolveZoom(metrics) {
+            if (!allowCssZoom)
+                return null;
+            if (!zoomRaw)
+                return null;
+            if (zoomRaw === 'auto') {
+                const dpr = Number(metrics?.devicePixelRatio || 0);
+                if (Number.isFinite(dpr) && dpr > 1.05) {
+                    return clamp(1 / dpr, 0.5, 1);
+                }
+                return 1;
+            }
+            if (zoomRaw) {
+                const parsed = Number(zoomRaw);
+                if (Number.isFinite(parsed))
+                    return clamp(parsed, 0.25, 1);
+            }
+            return 1;
+        }
+        async function clearCssZoom() {
+            if (!profileId.startsWith('xiaohongshu_'))
+                return;
+            try {
+                await fetch(statusUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        action: 'evaluate',
+                        args: {
+                            profileId,
+                            script: `(() => {
+                if (document.documentElement) document.documentElement.style.zoom = '';
+                if (document.body) document.body.style.zoom = '';
+                return true;
+              })()`,
+                        },
+                    }),
+                }).then((r) => r.json().catch(() => ({})));
+            }
+            catch (error) {
+                console.warn(`[EnsureSession] zoom clear failed: ${error?.message || String(error)}`);
+            }
+        }
+        async function applyZoom() {
+            if (!profileId.startsWith('xiaohongshu_'))
+                return;
+            const metrics = await loadMetrics();
+            const zoom = resolveZoom(metrics);
+            if (zoom === null) {
+                await clearCssZoom();
+                return;
+            }
+            try {
+                await fetch(statusUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        action: 'evaluate',
+                        args: {
+                            profileId,
+                            script: `(() => {
+                const z = ${JSON.stringify(zoom)};
+                const normalized = Math.abs(z - 1) < 0.01 ? '' : String(z);
+                if (document.documentElement) document.documentElement.style.zoom = normalized;
+                if (document.body) document.body.style.zoom = normalized;
+                return { zoom: z };
+              })()`,
+                        },
+                    }),
+                }).then((r) => r.json().catch(() => ({})));
+                console.log(`[EnsureSession] zoom set: ${zoom} (profile=${profileId})`);
+            }
+            catch (error) {
+                console.warn(`[EnsureSession] zoom set failed: ${error?.message || String(error)}`);
+            }
+        }
+        function parseZoomValue(raw) {
+            if (!raw)
+                return null;
+            if (raw.endsWith('%')) {
+                const parsed = Number(raw.replace('%', '').trim());
+                if (Number.isFinite(parsed) && parsed > 0)
+                    return parsed / 100;
+                return null;
+            }
+            const parsed = Number(raw);
+            if (Number.isFinite(parsed) && parsed > 0)
+                return parsed;
+            return null;
+        }
+        function resolveBrowserZoomTarget() {
+            if (browserZoomRaw === '0' || browserZoomRaw === '1' || browserZoomRaw === '100%')
+                return null;
+            const explicit = parseZoomValue(browserZoomRaw);
+            if (explicit)
+                return explicit;
+            return null;
+        }
+        async function applyBrowserZoom() {
+            if (!profileId.startsWith('xiaohongshu_'))
+                return;
+            const target = resolveBrowserZoomTarget();
+            if (!target || Math.abs(target - 1) < 0.01)
+                return;
+            const zoomOutSteps = [0.9, 0.8, 0.67, 0.5, 0.33, 0.25];
+            const zoomInSteps = [1.1, 1.25, 1.5, 1.75, 2, 2.5, 3, 4, 5];
+            const steps = target < 1
+                ? Math.max(1, zoomOutSteps.reduce((best, value, idx) => {
+                    const diff = Math.abs(value - target);
+                    return diff < best.diff ? { diff, idx } : best;
+                }, { diff: Number.POSITIVE_INFINITY, idx: 0 }).idx + 1)
+                : Math.max(1, zoomInSteps.reduce((best, value, idx) => {
+                    const diff = Math.abs(value - target);
+                    return diff < best.diff ? { diff, idx } : best;
+                }, { diff: Number.POSITIVE_INFINITY, idx: 0 }).idx + 1);
+            const key = os.platform() === 'darwin'
+                ? (target < 1 ? 'Meta+-' : 'Meta++')
+                : (target < 1 ? 'Control+-' : 'Control++');
+            for (let i = 0; i < steps; i += 1) {
+                try {
+                    await fetch(statusUrl, {
+                        method: 'POST',
+                        headers: { 'Content-Type': 'application/json' },
+                        body: JSON.stringify({
+                            action: 'keyboard:press',
+                            args: { profileId, key },
+                        }),
+                    }).then((r) => r.json().catch(() => ({})));
+                    await new Promise((r) => setTimeout(r, 80));
+                }
+                catch (error) {
+                    console.warn(`[EnsureSession] browser zoom step failed: ${error?.message || String(error)}`);
+                    break;
+                }
+            }
+            console.log(`[EnsureSession] browser zoom applied target~${target} steps=${steps} key=${key} profile=${profileId}`);
+        }
+        async function resetBrowserZoom() {
+            if (!profileId.startsWith('xiaohongshu_'))
+                return;
+            if (process.env.WEBAUTO_RESET_BROWSER_ZOOM === '0')
+                return;
+            const key = os.platform() === 'darwin' ? 'Meta+0' : 'Control+0';
+            try {
+                await fetch(statusUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        action: 'keyboard:press',
+                        args: { profileId, key },
+                    }),
+                }).then((r) => r.json().catch(() => ({})));
+                console.log(`[EnsureSession] browser zoom reset (${key}) profile=${profileId}`);
+            }
+            catch (error) {
+                console.warn(`[EnsureSession] browser zoom reset failed: ${error?.message || String(error)}`);
+            }
+        }
+        async function setViewport() {
+            const resolvedViewport = await resolveViewportSize();
+            const res = await fetch(statusUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    action: 'page:setViewport',
+                    args: {
+                        profileId,
+                        width: resolvedViewport.width,
+                        height: resolvedViewport.height,
+                    },
+                }),
+            }).then((r) => r.json().catch(() => ({})));
+            const ok = !(res?.ok === false || res?.success === false);
+            if (!ok)
+                return { ok: false, error: res?.error || 'viewport_set_failed' };
+            console.log(`[EnsureSession] viewport set: ${resolvedViewport.width}x${resolvedViewport.height} (profile=${profileId})`);
+            await resetBrowserZoom();
+            await applyBrowserZoom();
+            await applyZoom();
+            return { ok: true };
+        }
+        const statusRes = await fetch(statusUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ action: 'getStatus' })
+        });
+        const statusData = await statusRes.json();
+        const sessions = statusData.sessions ||
+            statusData.data?.sessions ||
+            statusData.body?.sessions ||
+            (Array.isArray(statusData.data) ? statusData.data : []) ||
+            [];
+        const existing = Array.isArray(sessions)
+            ? sessions.find((s) => s?.profileId === profileId)
+            : null;
+        if (existing) {
+            if (url && existing.url !== url) {
+                await fetch(statusUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        action: 'goto',
+                        args: { profileId, url }
+                    })
+                });
+            }
+            // Phase1 关键约束：保证视口高度足够（避免第二排卡片误点）
+            const vp = await setViewport();
+            if (!vp.ok) {
+                return {
+                    sessionId: existing.sessionId || existing.id || profileId,
+                    status: 'active',
+                    currentPage: url || existing.url,
+                    error: vp.error,
+                };
+            }
+            return {
+                sessionId: existing.sessionId || existing.id || profileId,
+                status: 'active',
+                currentPage: url || existing.url
+            };
+        }
+        let startData = null;
+        let startError = null;
+        while (true) {
+            startError = null;
+            try {
+                const startRes = await fetch(statusUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        action: 'start',
+                        args: {
+                            profileId,
+                            url,
+                            headless
+                        }
+                    })
+                });
+                startData = await startRes.json();
+                if (!startData.ok) {
+                    startError = startData.error || 'Failed to start session';
+                }
+            }
+            catch (error) {
+                startError = error?.message || String(error);
+            }
+            if (!startError)
+                break;
+            if (!waitOnFail) {
+                throw new Error(startError);
+            }
+            if (Date.now() - waitStartTs > waitLimitMs) {
+                throw new Error(startError);
+            }
+            console.warn(`[EnsureSession] start failed: ${startError}`);
+            console.warn(`[EnsureSession] waiting ${waitIntervalMs}ms and retrying...`);
+            await new Promise((r) => setTimeout(r, waitIntervalMs));
+        }
+        const vp = await setViewport();
+        if (!vp.ok) {
+            return {
+                sessionId: startData.sessionId || profileId,
+                status: 'created',
+                currentPage: url || '',
+                error: vp.error,
+            };
+        }
+        return {
+            sessionId: startData.sessionId || profileId,
+            status: 'created',
+            currentPage: url || ''
+        };
+    }
+    catch (error) {
+        return {
+            sessionId: '',
+            status: 'active',
+            currentPage: '',
+            error: `Session error: ${error.message}`
+        };
+    }
+}
+//# sourceMappingURL=EnsureSession.js.map

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

@@ -0,0 +1,164 @@
+/**
+ * ErrorClassifier - 错误分类与重试策略（P2.2 增强版）
+ *
+ * 用于区分：
+ * - 临时性错误（可重试）：网络抖动、超时
+ * - 永久性错误（应跳过）：404、无效选择器
+ * - 系统性错误（必须终止）：session 失效、频繁风控
+ * - 可降级错误（可继续但降级处理）：评论展开部分失败、图片下载失败
+ *
+ * P2.2 改进：
+ * - 细化错误分类，区分"跳过当前条目"和"终止整个任务"
+ * - 避免临时错误触发重型恢复（如回首页）
+ * - 对降级错误提供明确的 fallback 建议
+ */
+/**
+ * 细化错误分类
+ *
+ * @param error - 错误对象或消息
+ * @param context - 错误发生的上下文（如 'search', 'detail', 'comment'）
+ * @returns ErrorClassification
+ */
+export function classifyError(error, context) {
+    const msg = String(error?.message || error || '').toLowerCase();
+    // 1. 系统性错误：必须终止整个任务
+    if (msg.includes('session') ||
+        msg.includes('unauthorized') ||
+        msg.includes('blocked') ||
+        msg.includes('login_status_uncertain') ||
+        msg.includes('频繁') ||
+        msg.includes('risk control')) {
+        return {
+            type: 'SYSTEMIC',
+            action: 'ABORT_TASK',
+            retryable: false,
+            fatal: true,
+            suggestion: '会话失效或触发风控，建议手动检查浏览器状态并重新登录'
+        };
+    }
+    // 2. 临时性错误：可重试，但不要过度重试
+    if (msg.includes('timeout') ||
+        msg.includes('etimedout') ||
+        msg.includes('network') ||
+        msg.includes('econnrefused') ||
+        msg.includes('fetch failed')) {
+        return {
+            type: 'TEMPORARY',
+            action: 'RETRY',
+            retryable: true,
+            backoffMs: 3000,
+            suggestion: '网络抖动或临时超时，已自动重试'
+        };
+    }
+    // 3. 永久性错误：跳过当前条目
+    if (msg.includes('not found') ||
+        msg.includes('404') ||
+        msg.includes('error_code=300031') || // 小红书 404 笔记
+        msg.includes('invalid selector') ||
+        msg.includes('容器未找到') ||
+        msg.includes('未获取到容器树')) {
+        return {
+            type: 'PERMANENT',
+            action: 'SKIP_ITEM',
+            retryable: false,
+            suggestion: '资源不存在或容器定义过时，跳过当前条目'
+        };
+    }
+    // 4. 可降级错误：部分功能失败但可继续
+    //    例如：评论展开失败、图片下载失败、锚点验证失败（但 DOM 存在）
+    if (msg.includes('comment') ||
+        msg.includes('image download') ||
+        msg.includes('anchor verification failed') ||
+        msg.includes('rect') ||
+        msg.includes('highlight failed')) {
+        // 根据上下文决定降级策略
+        if (context === 'comment') {
+            return {
+                type: 'DEGRADED',
+                action: 'GRACEFUL_DEGRADE',
+                retryable: false,
+                suggestion: '评论采集部分失败，保存已有数据并标记 commentsPartial=true'
+            };
+        }
+        if (context === 'detail') {
+            return {
+                type: 'DEGRADED',
+                action: 'GRACEFUL_DEGRADE',
+                retryable: false,
+                suggestion: '详情部分字段缺失，保存已提取内容并标记 detailPartial=true'
+            };
+        }
+        // 默认：锚点验证失败等非关键错误
+        return {
+            type: 'DEGRADED',
+            action: 'GRACEFUL_DEGRADE',
+            retryable: false,
+            suggestion: '非关键功能失败，继续执行后续步骤'
+        };
+    }
+    // 5. 默认未分类错误：跳过当前条目（保守策略）
+    return {
+        type: 'PERMANENT',
+        action: 'SKIP_ITEM',
+        retryable: false,
+        suggestion: '未知错误，跳过当前条目以避免阻塞后续采集'
+    };
+}
+/**
+ * 重试包装器（指数退避 + 随机抖动）
+ *
+ * P2.2 改进：
+ * - 支持上下文传递，用于细化错误分类
+ * - 对非 retryable 错误立即抛出（不浪费重试次数）
+ */
+export async function retryWithBackoff(fn, maxRetries = 3, baseDelay = 1000, context) {
+    let lastError;
+    for (let i = 0; i < maxRetries; i++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastError = err;
+            const classified = classifyError(err, context);
+            // 系统性错误或永久性错误：立即抛出，不重试
+            if (classified.action === 'ABORT_TASK' || classified.action === 'SKIP_ITEM') {
+                console.warn(`[Retry] ${classified.type} error (${classified.action}): ${classified.suggestion}`);
+                throw err;
+            }
+            // 可降级错误：立即抛出，由上层决定是否降级
+            if (classified.action === 'GRACEFUL_DEGRADE') {
+                console.warn(`[Retry] ${classified.type} error: ${classified.suggestion}`);
+                throw err;
+            }
+            // 临时性错误：重试
+            if (classified.retryable && i < maxRetries - 1) {
+                const delay = (classified.backoffMs || baseDelay) * Math.pow(2, i) + Math.random() * 1000;
+                console.log(`[Retry] ${classified.type} error, retry ${i + 1}/${maxRetries} in ${Math.round(delay)}ms`);
+                await new Promise(resolve => setTimeout(resolve, delay));
+            }
+            else {
+                // 重试次数耗尽
+                console.warn(`[Retry] Max retries reached for ${classified.type} error`);
+                throw err;
+            }
+        }
+    }
+    throw lastError;
+}
+/**
+ * 根据错误分类决定下一步动作
+ *
+ * @param error - 错误对象
+ * @param context - 错误上下文
+ * @returns 建议的恢复动作
+ */
+export function getRecoveryAction(error, context) {
+    const classified = classifyError(error, context);
+    return {
+        action: classified.action,
+        suggestion: classified.suggestion || '',
+        shouldLog: true,
+        shouldSavePartial: classified.action === 'GRACEFUL_DEGRADE'
+    };
+}
+//# sourceMappingURL=ErrorClassifier.js.map