@web-auto/webauto 0.1.1 → 0.1.3

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

@@ -0,0 +1,120 @@
+/**
+ * Workflow Block: WarmupCommentsBlock
+ *
+ * 第一阶段：只负责把评论区滚到底并自动展开「展开 N 条回复」，不做内容提取。
+ * 目标是让 DOM 中尽可能多地渲染出 .comment-item，再交给后续 ExpandCommentsBlock 做纯提取。
+ */
+import { clickCommentButtonByContainerId, locateCommentSection, } from './helpers/commentSectionLocator.js';
+import { scrollCommentSection, } from './helpers/commentScroller.js';
+import { expandRepliesInView } from './helpers/replyExpander.js';
+export async function execute(input) {
+    const { sessionId, maxRounds, serviceUrl = 'http://127.0.0.1:7701', allowClickCommentButton, } = input;
+    const profile = sessionId;
+    const controllerUrl = `${serviceUrl}/v1/controller/action`;
+    const browserServiceUrl = process.env.WEBAUTO_BROWSER_SERVICE_URL || 'http://127.0.0.1:7704';
+    const canClickCommentButton = allowClickCommentButton !== false;
+    const commentSectionContainerId = 'xiaohongshu_detail.comment_section';
+    const commentButtonContainerId = 'xiaohongshu_detail.comment_button';
+    const showMoreContainerId = 'xiaohongshu_detail.comment_section.show_more_button';
+    try {
+        const { getPrimarySelectorByContainerId } = await import('./helpers/containerAnchors.js');
+        let showMoreSelector = null;
+        try {
+            showMoreSelector = await getPrimarySelectorByContainerId(showMoreContainerId);
+            if (!showMoreSelector) {
+                console.warn('[WarmupComments] primary selector not found for show_more_button');
+            }
+            else {
+                console.log(`[WarmupComments] show_more_button selector: ${showMoreSelector}`);
+            }
+        }
+        catch (e) {
+            console.warn(`[WarmupComments] getPrimarySelectorByContainerId error: ${e?.message || e}`);
+        }
+        // 1) 锚定评论区（高亮 + rect 回环）
+        const locateResult = await locateCommentSection({
+            profile,
+            serviceUrl,
+            controllerUrl,
+            commentSectionContainerId,
+            commentButtonContainerId,
+            canClickCommentButton,
+            highlightStyle: '2px solid #ffaa00',
+            highlightMs: 2000,
+        });
+        if (!locateResult.found || !locateResult.rect) {
+            return {
+                success: false,
+                reachedEnd: false,
+                totalFromHeader: null,
+                finalCount: 0,
+                anchor: {
+                    commentSectionContainerId,
+                    commentSectionRect: undefined,
+                },
+                error: locateResult.error || 'comment_section anchor not found',
+            };
+        }
+        const focusRect = locateResult.rect;
+        // 2) 滚动评论区到“到底/空态”，每轮尝试展开可见的回复按钮
+        let commentButtonClicked = Boolean(locateResult.clickedCommentButton);
+        const activateComments = async (reason) => {
+            if (!canClickCommentButton)
+                return;
+            if (commentButtonClicked)
+                return;
+            const res = await clickCommentButtonByContainerId({
+                profile,
+                serviceUrl,
+                controllerUrl,
+                commentButtonContainerId,
+            });
+            if (res.clicked) {
+                commentButtonClicked = true;
+                console.log(`[WarmupComments] comment_button clicked (${reason})`);
+            }
+        };
+        const scrollResult = await scrollCommentSection({
+            controllerUrl,
+            profile,
+            browserServiceUrl,
+            ...(typeof maxRounds === 'number' && maxRounds > 0 ? { maxRounds } : {}),
+            focusRect,
+            logPrefix: '[WarmupComments]',
+            activateComments,
+            expand: async ({ round, focusPoint }) => {
+                await expandRepliesInView({
+                    controllerUrl,
+                    profile,
+                    browserServiceUrl,
+                    focusPoint,
+                    showMoreContainerId,
+                    showMoreSelector,
+                    logPrefix: '[WarmupComments]',
+                    round,
+                });
+            },
+        });
+        return {
+            success: true,
+            reachedEnd: scrollResult.reachedEnd,
+            totalFromHeader: scrollResult.totalFromHeader,
+            finalCount: scrollResult.finalCount,
+            anchor: {
+                commentSectionContainerId,
+                commentSectionRect: locateResult.rect,
+            },
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            reachedEnd: false,
+            totalFromHeader: null,
+            finalCount: 0,
+            anchor: { commentSectionContainerId, commentSectionRect: undefined },
+            error: `WarmupComments failed: ${error?.message || error}`,
+        };
+    }
+}
+//# sourceMappingURL=WarmupCommentsBlock.js.map

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

@@ -0,0 +1,156 @@
+/**
+ * Workflow Block Executor
+ *
+ * 编排和执行 workflow blocks
+ */
+import { logWorkflowEvent } from '../../logging/src/index.js';
+/**
+ * Workflow 执行器
+ */
+export class WorkflowExecutor {
+    blocks = new Map();
+    registerBlock(name, executor) {
+        this.blocks.set(name, executor);
+    }
+    async execute(definition, initialContext = {}) {
+        const results = [];
+        const errors = [];
+        const steps = [];
+        let context = { ...(initialContext || {}) };
+        const workflowId = definition.id || 'anonymous-workflow';
+        const workflowName = definition.name || workflowId;
+        for (let index = 0; index < definition.steps.length; index += 1) {
+            const step = definition.steps[index];
+            const block = this.blocks.get(step.blockName);
+            if (!block) {
+                const error = `Block not found: ${step.blockName}`;
+                errors.push(error);
+                logWorkflowEvent({
+                    workflowId,
+                    workflowName,
+                    stepIndex: index,
+                    stepName: step.blockName,
+                    status: 'error',
+                    error,
+                });
+                continue;
+            }
+            const resolvedInput = this.resolveInput(step.input, context);
+            const sessionId = resolvedInput.sessionId || resolvedInput.profileId || context.sessionId;
+            let stepOutput = undefined;
+            let stepError;
+            logWorkflowEvent({
+                workflowId,
+                workflowName,
+                stepIndex: index,
+                stepName: step.blockName,
+                status: 'start',
+                sessionId,
+                profileId: resolvedInput.profileId,
+            });
+            try {
+                const result = await block.execute(resolvedInput);
+                stepOutput = result;
+                const hasError = Boolean(result?.error) || result?.success === false;
+                if (hasError) {
+                    stepError = `${step.blockName}: ${result?.error || 'success=false'}`;
+                    errors.push(stepError);
+                }
+                results.push(result);
+                context = { ...context, ...result };
+                logWorkflowEvent({
+                    workflowId,
+                    workflowName,
+                    stepIndex: index,
+                    stepName: step.blockName,
+                    status: hasError ? 'error' : 'success',
+                    sessionId,
+                    profileId: resolvedInput.profileId,
+                    error: result?.error,
+                    anchor: result?.anchor,
+                    meta: {
+                        success: !hasError,
+                        inputSummary: this.buildInputSummary(resolvedInput),
+                    },
+                });
+                // 开发阶段：遇到 error 或 success=false 立即停止后续步骤，避免“错误后继续跑”导致污染/误操作。
+                if (hasError && !step.continueOnError) {
+                    break;
+                }
+            }
+            catch (error) {
+                const errorMsg = `${step.blockName} execution failed: ${error?.message || String(error)}`;
+                stepError = errorMsg;
+                errors.push(errorMsg);
+                logWorkflowEvent({
+                    workflowId,
+                    workflowName,
+                    stepIndex: index,
+                    stepName: step.blockName,
+                    status: 'error',
+                    sessionId,
+                    profileId: resolvedInput.profileId,
+                    error: errorMsg,
+                });
+                if (!step.continueOnError) {
+                    // fail-fast
+                    break;
+                }
+            }
+            finally {
+                steps.push({
+                    index,
+                    blockName: step.blockName,
+                    input: resolvedInput,
+                    output: stepOutput,
+                    error: stepError,
+                    contextAfterStep: { ...context },
+                });
+            }
+        }
+        return {
+            results,
+            errors,
+            success: errors.length === 0,
+            steps,
+        };
+    }
+    resolveInput(input, context) {
+        if (typeof input === 'string' && input.startsWith('$')) {
+            const key = input.substring(1);
+            return context[key];
+        }
+        if (typeof input === 'object' && input !== null) {
+            const resolved = {};
+            for (const [key, value] of Object.entries(input)) {
+                resolved[key] = this.resolveInput(value, context);
+            }
+            return resolved;
+        }
+        return input;
+    }
+    buildInputSummary(input) {
+        if (input == null || typeof input !== 'object')
+            return input;
+        const summary = {};
+        for (const [key, value] of Object.entries(input)) {
+            if (value == null) {
+                summary[key] = value;
+            }
+            else if (Array.isArray(value)) {
+                summary[key] = { type: 'array', length: value.length };
+            }
+            else if (typeof value === 'string') {
+                summary[key] = value.length > 200 ? `${value.slice(0, 200)}…` : value;
+            }
+            else if (typeof value === 'object') {
+                summary[key] = { type: 'object', keys: Object.keys(value) };
+            }
+            else {
+                summary[key] = value;
+            }
+        }
+        return summary;
+    }
+}
+//# sourceMappingURL=WorkflowExecutor.js.map