@web-auto/webauto 0.1.1 → 0.1.3

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

@@ -0,0 +1,54 @@
+/**
+ * Workflow Block: SaveFile
+ *
+ * 保存文件到磁盘
+ */
+import fs from 'fs';
+import path from 'path';
+/**
+ * 保存文件
+ *
+ * @param input - 输入参数
+ * @returns Promise<SaveFileOutput>
+ */
+export async function execute(input) {
+    const { content, path: filePath, encoding = 'utf-8' } = input;
+    if (!content) {
+        return {
+            saved: false,
+            path: filePath,
+            size: 0,
+            error: 'Empty content'
+        };
+    }
+    if (!filePath) {
+        return {
+            saved: false,
+            path: '',
+            size: 0,
+            error: 'Missing file path'
+        };
+    }
+    try {
+        const dir = path.dirname(filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(filePath, content, encoding);
+        const stats = fs.statSync(filePath);
+        return {
+            saved: true,
+            path: filePath,
+            size: stats.size
+        };
+    }
+    catch (error) {
+        return {
+            saved: false,
+            path: filePath,
+            size: 0,
+            error: `Save error: ${error.message}`
+        };
+    }
+}
+//# sourceMappingURL=SaveFile.js.map

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

@@ -0,0 +1,72 @@
+/**
+ * Workflow Block: ScrollNextBatch
+ *
+ * 执行一次滚动并等待稳定
+ */
+/**
+ * 执行下一批滚动
+ *
+ * @param input - 输入参数
+ * @returns Promise<ScrollNextBatchOutput>
+ */
+export async function execute(input) {
+    const { sessionId, distance = 800, serviceUrl = 'http://127.0.0.1:7704' } = input;
+    const commandUrl = `${serviceUrl}/command`;
+    try {
+        const beforeRes = await fetch(commandUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'evaluate',
+                args: {
+                    profileId: sessionId,
+                    script: 'window.scrollY || 0',
+                },
+            }),
+        });
+        const beforeData = await beforeRes.json().catch(() => ({}));
+        const previousPosition = Number(beforeData?.data?.result ?? beforeData?.body?.result ?? beforeData?.result ?? 0) || 0;
+        const wheelRes = await fetch(commandUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'mouse:wheel',
+                args: {
+                    profileId: sessionId,
+                    deltaX: 0,
+                    deltaY: Math.max(-800, Math.min(800, Number(distance) || 0)),
+                },
+            }),
+        });
+        const wheelData = await wheelRes.json().catch(() => ({}));
+        if (wheelData?.ok === false || wheelData?.success === false) {
+            return {
+                scrolled: false,
+                previousPosition,
+                newPosition: previousPosition,
+                error: wheelData?.error || 'mouse_wheel_failed',
+            };
+        }
+        await new Promise((resolve) => setTimeout(resolve, 800));
+        const afterRes = await fetch(commandUrl, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                action: 'evaluate',
+                args: { profileId: sessionId, script: 'window.scrollY || 0' },
+            }),
+        });
+        const afterData = await afterRes.json().catch(() => ({}));
+        const newPosition = Number(afterData?.data?.result ?? afterData?.body?.result ?? afterData?.result ?? previousPosition) || previousPosition;
+        return { scrolled: true, previousPosition, newPosition };
+    }
+    catch (error) {
+        return {
+            scrolled: false,
+            previousPosition: 0,
+            newPosition: 0,
+            error: `Scroll error: ${error.message}`
+        };
+    }
+}
+//# sourceMappingURL=ScrollNextBatch.js.map

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

@@ -0,0 +1,73 @@
+/**
+ * Workflow Block: SessionHealthBlock
+ *
+ * 职责：
+ * - 检查当前会话健康状态（浏览器响应、页面可访问、容器匹配正常）
+ * - 提供轻量级健康检查，不干扰现有会话
+ * - 用于长时间运行任务中的定期健康监控
+ */
+import { logControllerActionError, logControllerActionResult, logControllerActionStart, } from './helpers/operationLogger.js';
+export async function execute(input) {
+    const { sessionId, serviceUrl = 'http://127.0.0.1:7701', timeoutMs = 10000 } = input;
+    const controllerUrl = `${serviceUrl}/v1/controller/action`;
+    async function controllerAction(action, payload = {}) {
+        const opId = logControllerActionStart(action, payload, { source: 'SessionHealthBlock' });
+        try {
+            const res = await fetch(controllerUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ action, payload }),
+                signal: AbortSignal.timeout ? AbortSignal.timeout(timeoutMs) : 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: 'SessionHealthBlock' });
+            return result;
+        }
+        catch (error) {
+            logControllerActionError(opId, action, error, payload, { source: 'SessionHealthBlock' });
+            throw error;
+        }
+    }
+    const checks = {
+        browserResponsive: false,
+        pageAccessible: false,
+        containersMatchable: false
+    };
+    let currentUrl;
+    try {
+        // 1. 检查浏览器是否响应
+        const urlData = await controllerAction('browser:execute', {
+            profile: sessionId,
+            script: 'location.href'
+        });
+        currentUrl = urlData?.result || urlData?.data?.result;
+        if (typeof currentUrl === 'string' && currentUrl.includes('xiaohongshu.com')) {
+            checks.browserResponsive = true;
+            checks.pageAccessible = true;
+        }
+    }
+    catch (err) {
+        return {
+            success: false,
+            healthy: false,
+            checks,
+            error: `Browser not responsive: ${err.message}`
+        };
+    }
+    // 2. 容器层健康：出于稳定性考虑，这里不再强依赖 containers:match，
+    //    仅以浏览器可响应 + 页面可访问 作为“健康”判定的硬条件。
+    //    containersMatchable 字段保留用于诊断，但不作为失败条件。
+    checks.containersMatchable = true;
+    const healthy = checks.browserResponsive && checks.pageAccessible;
+    return {
+        success: true,
+        healthy,
+        checks,
+        currentUrl
+    };
+}
+//# sourceMappingURL=SessionHealthBlock.js.map

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

@@ -0,0 +1,45 @@
+/**
+ * Workflow Block: StartBrowserService
+ *
+ * 确保浏览器服务可用
+ */
+/**
+ * 确保浏览器服务可用
+ *
+ * @param input - 输入参数
+ * @returns Promise<StartBrowserServiceOutput>
+ */
+export async function execute(input) {
+    const { host = '127.0.0.1', port = 7704, wsPort = 8765 } = input;
+    const healthUrl = `http://${host}:${port}/health`;
+    try {
+        const response = await fetch(healthUrl);
+        if (!response.ok) {
+            throw new Error(`Browser Service returned ${response.status}`);
+        }
+        const data = await response.json();
+        if (!data.ok) {
+            throw new Error('Browser Service health check failed');
+        }
+        return {
+            status: 'connected',
+            host,
+            port,
+            wsPort,
+            service: 'browser-service',
+            timestamp: new Date().toISOString()
+        };
+    }
+    catch (error) {
+        return {
+            status: 'error',
+            host,
+            port,
+            wsPort,
+            service: 'browser-service',
+            timestamp: new Date().toISOString(),
+            error: `Browser Service not available at ${healthUrl}: ${error.message}`
+        };
+    }
+}
+//# sourceMappingURL=StartBrowserService.js.map

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

@@ -0,0 +1,67 @@
+/**
+ * Workflow Block: ValidateContainerDefinition
+ *
+ * 验证容器定义的格式完整性
+ */
+/**
+ * 验证容器定义
+ *
+ * @param input - 输入参数
+ * @returns ValidateContainerDefinitionOutput
+ */
+export async function execute(input) {
+    const { definition } = input;
+    if (!definition) {
+        return {
+            definition: null,
+            validation: {
+                isValid: false,
+                errors: ['缺少容器定义']
+            },
+            error: '缺少容器定义'
+        };
+    }
+    const errors = [];
+    if (!definition.id) {
+        errors.push('缺少 id 字段');
+    }
+    if (!definition.name) {
+        errors.push('缺少 name 字段');
+    }
+    if (!definition.type) {
+        errors.push('缺少 type 字段');
+    }
+    if (definition.selectors) {
+        if (!Array.isArray(definition.selectors)) {
+            errors.push('selectors 不是数组');
+        }
+        else {
+            definition.selectors.forEach((sel, idx) => {
+                if (!sel.css) {
+                    errors.push(`selectors[${idx}] 缺少 css 字段`);
+                }
+                if (!sel.variant) {
+                    errors.push(`selectors[${idx}] 缺少 variant 字段`);
+                }
+                if (!sel.score) {
+                    errors.push(`selectors[${idx}] 缺少 score 字段`);
+                }
+            });
+        }
+    }
+    else {
+        errors.push('缺少 selectors 字段');
+    }
+    if (definition.operations && !Array.isArray(definition.operations)) {
+        errors.push('operations 不是数组');
+    }
+    const isValid = errors.length === 0;
+    return {
+        definition: isValid ? definition : null,
+        validation: {
+            isValid,
+            errors: errors.length > 0 ? errors : undefined
+        }
+    };
+}
+//# sourceMappingURL=ValidateContainerDefinition.js.map

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

@@ -0,0 +1,35 @@
+/**
+ * Workflow Block: ValidateExtract
+ *
+ * 校验提取数据的有效性
+ */
+/**
+ * 校验提取数据
+ *
+ * @param input - 输入参数
+ * @returns ValidateExtractOutput
+ */
+export async function execute(input) {
+    const { fields, requiredFields = ['author', 'content'] } = input;
+    if (!fields || typeof fields !== 'object') {
+        return {
+            isValid: false,
+            missingFields: requiredFields,
+            validatedFields: {},
+            error: '缺少 fields 数据'
+        };
+    }
+    const missingFields = [];
+    for (const field of requiredFields) {
+        if (!fields[field] || (typeof fields[field] === 'string' && fields[field].trim() === '')) {
+            missingFields.push(field);
+        }
+    }
+    const isValid = missingFields.length === 0;
+    return {
+        isValid,
+        missingFields,
+        validatedFields: isValid ? fields : {}
+    };
+}
+//# sourceMappingURL=ValidateExtract.js.map

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

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

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

@@ -0,0 +1,74 @@
+/**
+ * Workflow Block: WaitStable
+ *
+ * 等待页面稳定信号
+ */
+/**
+ * 等待页面稳定
+ *
+ * @param input - 输入参数
+ * @returns Promise<WaitStableOutput>
+ */
+export async function execute(input) {
+    const { sessionId, checkInterval = 500, maxWait = 10000, stableThreshold = 3, serviceUrl = 'http://127.0.0.1:7704' } = input;
+    const commandUrl = `${serviceUrl}/command`;
+    const startTime = Date.now();
+    let checks = 0;
+    let lastHeight = 0;
+    let stableCount = 0;
+    try {
+        while (Date.now() - startTime < maxWait) {
+            checks++;
+            const evalRes = await fetch(commandUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    action: 'evaluate',
+                    args: {
+                        profileId: sessionId,
+                        script: `
+              (() => {
+                return document.body.scrollHeight;
+              })()
+            `
+                    }
+                })
+            });
+            const evalData = await evalRes.json();
+            if (evalData.success && evalData.data !== undefined) {
+                const currentHeight = evalData.data;
+                if (currentHeight === lastHeight) {
+                    stableCount++;
+                    if (stableCount >= stableThreshold) {
+                        const waitTime = Date.now() - startTime;
+                        return {
+                            isStable: true,
+                            waitTime,
+                            checks
+                        };
+                    }
+                }
+                else {
+                    stableCount = 0;
+                }
+                lastHeight = currentHeight;
+            }
+            await new Promise(resolve => setTimeout(resolve, checkInterval));
+        }
+        return {
+            isStable: false,
+            waitTime: maxWait,
+            checks,
+            error: 'Timeout waiting for page stability'
+        };
+    }
+    catch (error) {
+        return {
+            isStable: false,
+            waitTime: Date.now() - startTime,
+            checks,
+            error: `WaitStable error: ${error.message}`
+        };
+    }
+}
+//# sourceMappingURL=WaitStable.js.map