@web-auto/webauto 0.1.1 → 0.1.2

package/dist/modules/workflow/definitions/xiaohongshu-full-collect-workflow-v3.js

@@ -0,0 +1,68 @@
+/**
+ * 小红书关键词完整采集 Workflow v3（Phase2 + Phase3/4 一体编排）
+ *
+ * 流程：
+ * - EnsureSession / EnsureLogin
+ * - WaitSearchPermit + GoToSearch（对话框搜索，避免 URL 直达）
+ * - XiaohongshuFullCollectBlock：列表 → 详情 → 评论 → 持久化（~/.webauto/download）
+ */
+export const xiaohongshuFullCollectWorkflowV3 = {
+    id: 'xiaohongshu-collect-full-v3',
+    name: '小红书关键词完整采集（Phase3/4 编排）',
+    steps: [
+        {
+            blockName: 'EnsureSession',
+            input: {
+                profileId: '$sessionId',
+                url: 'https://www.xiaohongshu.com',
+            },
+        },
+        {
+            blockName: 'EnsureLoginBlock',
+            input: {
+                sessionId: '$sessionId',
+                maxWaitMs: 180000,
+                checkIntervalMs: 5000,
+            },
+        },
+        {
+            blockName: 'WaitSearchPermitBlock',
+            input: {
+                sessionId: '$sessionId',
+                keyword: '$keyword',
+            },
+        },
+        {
+            blockName: 'GoToSearchBlock',
+            input: {
+                sessionId: '$sessionId',
+                keyword: '$keyword',
+            },
+        },
+        {
+            blockName: 'XiaohongshuFullCollectBlock',
+            input: {
+                sessionId: '$sessionId',
+                keyword: '$keyword',
+                env: '$env',
+                targetCount: '$targetCount',
+                maxWarmupRounds: '$maxWarmupRounds',
+                allowClickCommentButton: '$allowClickCommentButton',
+                enableOcr: true,
+                ocrLanguages: '$ocrLanguages',
+                ocrConcurrency: 1,
+            },
+        },
+        {
+            blockName: 'OrganizeXhsNotesBlock',
+            input: {
+                platform: 'xiaohongshu',
+                env: '$env',
+                keyword: '$keyword',
+                ocrLanguages: '$ocrLanguages',
+                runOcr: false,
+            },
+        },
+    ],
+};
+//# sourceMappingURL=xiaohongshu-full-collect-workflow-v3.js.map

package/dist/modules/workflow/definitions/xiaohongshu-note-collect.js

@@ -0,0 +1,49 @@
+/**
+ * 小红书单条笔记采集 Workflow（离线仿真版）
+ *
+ * 约定：
+ * - 详情页（或仿真详情页）已在当前 session 中打开，并匹配 xiaohongshu_detail.modal_shell；
+ * - 不负责打开/关闭详情，只做提取评论 + 持久化；
+ * - 适用于基于本地仿真 HTML 的离线回放测试。
+ */
+export const xiaohongshuNoteCollectWorkflow = {
+    id: 'xiaohongshu-note-collect',
+    name: '小红书单条笔记采集（离线仿真）',
+    steps: [
+        {
+            blockName: 'AnchorVerificationBlock',
+            input: {
+                sessionId: '$sessionId',
+                containerId: 'xiaohongshu_detail.modal_shell',
+                operation: 'enter',
+            },
+        },
+        {
+            blockName: 'ExtractDetailBlock',
+            input: {
+                sessionId: '$sessionId',
+            },
+        },
+        {
+            blockName: 'CollectCommentsBlock',
+            input: {
+                sessionId: '$sessionId',
+            },
+        },
+        {
+            blockName: 'PersistXhsNoteBlock',
+            input: {
+                sessionId: '$sessionId',
+                env: '$env',
+                platform: 'xiaohongshu',
+                keyword: '$keyword',
+                noteId: '$noteId',
+                detailUrl: '$detailUrl',
+                // 由 ExtractDetailBlock / CollectCommentsBlock 写入的上下文字段
+                detail: '$detail',
+                commentsResult: '$comments',
+            },
+        },
+    ],
+};
+//# sourceMappingURL=xiaohongshu-note-collect.js.map

package/dist/modules/workflow/definitions/xiaohongshu-phase1-workflow-v3.js

@@ -0,0 +1,30 @@
+/**
+ * 小红书 Phase1 Workflow v3（仅会话 + 登录）
+ *
+ * 流程：
+ * - EnsureSession（固定高视口，降低第二排误点）
+ * - EnsureLoginBlock（容器驱动登录探针）
+ */
+export const xiaohongshuPhase1WorkflowV3 = {
+    id: 'xiaohongshu-phase1-v3',
+    name: '小红书 Phase1（会话 + 登录）',
+    steps: [
+        {
+            blockName: 'EnsureSession',
+            input: {
+                profileId: '$sessionId',
+                url: 'https://www.xiaohongshu.com',
+                headless: '$headless',
+            },
+        },
+        {
+            blockName: 'EnsureLoginBlock',
+            input: {
+                sessionId: '$sessionId',
+                maxWaitMs: 0,
+                checkIntervalMs: 5000,
+            },
+        },
+    ],
+};
+//# sourceMappingURL=xiaohongshu-phase1-workflow-v3.js.map

package/dist/modules/workflow/definitions/xiaohongshu-phase2-links-workflow-v3.js

@@ -0,0 +1,40 @@
+/**
+ * 小红书 Phase2 Workflow v3（搜索 + 链接采集）
+ *
+ * 流程：
+ * - WaitSearchPermit（SearchGate）
+ * - GoToSearch（对话框搜索，禁止 URL 直达）
+ * - XiaohongshuCollectLinksBlock（点击采集安全链接，searchUrl 严格一致）
+ */
+export const xiaohongshuPhase2LinksWorkflowV3 = {
+    id: 'xiaohongshu-phase2-links-v3',
+    name: '小红书 Phase2（搜索 + 链接采集）',
+    steps: [
+        {
+            blockName: 'WaitSearchPermitBlock',
+            input: {
+                sessionId: '$sessionId',
+                keyword: '$keyword',
+            },
+        },
+        {
+            blockName: 'GoToSearchBlock',
+            input: {
+                sessionId: '$sessionId',
+                keyword: '$keyword',
+                env: '$env',
+            },
+        },
+        {
+            blockName: 'XiaohongshuCollectLinksBlock',
+            input: {
+                sessionId: '$sessionId',
+                keyword: '$keyword',
+                env: '$env',
+                targetCount: '$targetCount',
+                targetCountMode: '$targetCountMode',
+            },
+        },
+    ],
+};
+//# sourceMappingURL=xiaohongshu-phase2-links-workflow-v3.js.map

package/dist/modules/workflow/definitions/xiaohongshu-phase3-collect-workflow-v1.js

@@ -0,0 +1,54 @@
+/**
+ * 小红书 Phase3 采集 Workflow v1（仅详情落盘）
+ *
+ * 流程：
+ * - EnsureSession / EnsureLogin
+ * - WaitSearchPermit + GoToSearch（对话框搜索）
+ * - XiaohongshuFullCollectBlock(mode=phase3)：列表 → 详情 → 持久化（~/.webauto/download）
+ */
+export const xiaohongshuPhase3CollectWorkflowV1 = {
+    id: 'xiaohongshu-collect-phase3-v1',
+    name: '小红书 Phase3 采集（仅详情）',
+    steps: [
+        {
+            blockName: 'EnsureSession',
+            input: {
+                profileId: '$sessionId',
+                url: 'https://www.xiaohongshu.com',
+            },
+        },
+        {
+            blockName: 'EnsureLoginBlock',
+            input: {
+                sessionId: '$sessionId',
+                maxWaitMs: 180000,
+                checkIntervalMs: 5000,
+            },
+        },
+        {
+            blockName: 'WaitSearchPermitBlock',
+            input: {
+                sessionId: '$sessionId',
+                keyword: '$keyword',
+            },
+        },
+        {
+            blockName: 'GoToSearchBlock',
+            input: {
+                sessionId: '$sessionId',
+                keyword: '$keyword',
+            },
+        },
+        {
+            blockName: 'XiaohongshuFullCollectBlock',
+            input: {
+                sessionId: '$sessionId',
+                keyword: '$keyword',
+                env: '$env',
+                targetCount: '$targetCount',
+                mode: 'phase3',
+            },
+        },
+    ],
+};
+//# sourceMappingURL=xiaohongshu-phase3-collect-workflow-v1.js.map

package/dist/modules/workflow/definitions/xiaohongshu-phase34-from-links-workflow-v3.js

@@ -0,0 +1,25 @@
+/**
+ * 小红书 Phase3/4 Workflow v3（基于 Phase2 links）
+ *
+ * 流程：
+ * - XiaohongshuCollectFromLinksBlock：按 phase2-links.jsonl 逐条新开详情 tab → 详情+评论 → 落盘
+ *   - 评论：rotate4（每 tab 50 条，开满 4 个后循环）
+ */
+export const xiaohongshuPhase34FromLinksWorkflowV3 = {
+    id: 'xiaohongshu-phase34-from-links-v3',
+    name: '小红书 Phase3/4（从 Phase2 links 采集详情+评论）',
+    steps: [
+        {
+            blockName: 'XiaohongshuCollectFromLinksBlock',
+            input: {
+                sessionId: '$sessionId',
+                keyword: '$keyword',
+                env: '$env',
+                targetCount: '$targetCount',
+                targetCountMode: '$targetCountMode',
+                maxComments: '$maxComments',
+            },
+        },
+    ],
+};
+//# sourceMappingURL=xiaohongshu-phase34-from-links-workflow-v3.js.map

package/dist/modules/workflow/src/WeiboEventDrivenWorkflowRunner.js

@@ -0,0 +1,308 @@
+/**
+ * 微博事件驱动工作流驱动器
+ * 支持配置驱动的容器操作和事件处理
+ */
+import { EventEmitter } from 'events';
+export class WeiboEventDrivenWorkflowRunner extends EventEmitter {
+    config;
+    context;
+    posts = [];
+    variables = new Map();
+    isRunning = false;
+    currentStepId = null;
+    constructor(config, context) {
+        super();
+        this.config = config;
+        this.context = context;
+    }
+    async execute() {
+        try {
+            this.isRunning = true;
+            this.emit('workflow:start', { config: this.config });
+            // Step 1: 初始化会话
+            await this.ensureSession();
+            // Step 2: 执行步骤
+            await this.runSteps();
+            // Step 3: 输出结果
+            await this.generateOutput();
+            this.emit('workflow:complete', { totalExtracted: this.posts.length });
+            return {
+                success: true,
+                posts: this.posts,
+                totalExtracted: this.posts.length
+            };
+        }
+        catch (error) {
+            this.emit('workflow:error', { error: error.message });
+            return {
+                success: false,
+                posts: this.posts,
+                totalExtracted: this.posts.length,
+                error: error.message
+            };
+        }
+        finally {
+            this.isRunning = false;
+        }
+    }
+    async runSteps() {
+        // 初始步骤
+        const firstStep = this.config.steps[0];
+        if (firstStep) {
+            await this.executeStep(firstStep);
+        }
+        // 后续步骤根据状态驱动
+        while (this.isRunning) {
+            const nextStep = this.findNextStep();
+            if (!nextStep)
+                break;
+            await this.executeStep(nextStep);
+        }
+    }
+    findNextStep() {
+        for (const step of this.config.steps) {
+            if (step.status === 'idle' && step.enter) {
+                const prevStep = this.config.steps.find(s => s.id === step.enter?.when.step);
+                if (prevStep && prevStep.status === step.enter.when.status) {
+                    return step;
+                }
+            }
+        }
+        return null;
+    }
+    async executeStep(step) {
+        this.currentStepId = step.id;
+        step.status = 'running';
+        this.emit('step:start', { step });
+        try {
+            // 检查条件
+            if (step.condition && !this.evaluateCondition(step.condition)) {
+                step.status = 'skipped';
+                this.emit('step:skip', { step, reason: 'condition not met' });
+                return;
+            }
+            // 执行动作（支持重复）
+            if (step.repeat) {
+                await this.executeRepeatActions(step);
+            }
+            else {
+                for (const action of step.actions) {
+                    await this.executeAction(action);
+                }
+            }
+            step.status = 'completed';
+            this.emit('step:complete', { step });
+        }
+        catch (error) {
+            step.status = 'failed';
+            this.emit('step:failed', { step, error: error.message });
+            throw error;
+        }
+    }
+    async executeRepeatActions(step) {
+        const max = this.parseValue(step.repeat?.max || 1);
+        let count = 0;
+        while (count < max && this.isRunning) {
+            // 检查退出条件
+            if (step.repeat?.until?.condition) {
+                if (this.evaluateCondition(step.repeat.until.condition)) {
+                    break;
+                }
+            }
+            for (const action of step.actions) {
+                await this.executeAction(action);
+            }
+            count++;
+        }
+    }
+    parseValue(value) {
+        if (typeof value === 'number')
+            return value;
+        if (typeof value === 'string' && value.startsWith('{{') && value.endsWith('}}')) {
+            const key = value.slice(2, -2).trim();
+            if (key.startsWith('config.')) {
+                const val = this.config.config[key.split('.')[1]];
+                return typeof val === 'number' ? val : Number(val);
+            }
+        }
+        return Number(value);
+    }
+    async ensureSession() {
+        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.config.profile);
+        if (!active) {
+            await this.context.apiClient.post('/v1/controller/action', {
+                action: 'session:create',
+                payload: {
+                    profile: this.config.config.profile,
+                    url: this.config.config.url
+                }
+            });
+            await new Promise(r => setTimeout(r, 5000));
+        }
+        this.emit('session:init-complete');
+    }
+    async executeAction(action) {
+        switch (action.type) {
+            case 'session.ensure':
+                await this.ensureSession();
+                break;
+            case 'container.match':
+                await this.matchContainers(this.resolveConfig(action.config));
+                break;
+            case 'container.operation':
+                await this.executeContainerOperation(action);
+                break;
+            case 'extract':
+                await this.extractPost(action);
+                break;
+            case 'variable.set':
+                this.setVariable(action.containerId || 'root', action.config?.variable, action.config?.value);
+                break;
+            case 'variable.increment':
+                this.incrementVariable(action.containerId || 'root', action.config?.variable);
+                break;
+            case 'format.output':
+                await this.generateOutput(); // Use internal method directly
+                break;
+            default:
+                this.emit('action:unknown', { action });
+        }
+        if (action.delay) {
+            const delayMs = this.parseValue(action.delay);
+            if (delayMs > 0) {
+                await new Promise(r => setTimeout(r, delayMs));
+            }
+        }
+    }
+    resolveConfig(config) {
+        if (!config)
+            return {};
+        const resolved = {};
+        for (const [key, value] of Object.entries(config)) {
+            if (typeof value === 'string' && value.startsWith('{{') && value.endsWith('}}')) {
+                const varKey = value.slice(2, -2).trim();
+                if (varKey.startsWith('config.')) {
+                    resolved[key] = this.config.config[varKey.split('.')[1]];
+                }
+                else {
+                    resolved[key] = value;
+                }
+            }
+            else {
+                resolved[key] = value;
+            }
+        }
+        return resolved;
+    }
+    async matchContainers(config) {
+        const result = await this.context.apiClient.post('/v1/controller/action', {
+            action: 'containers:match',
+            payload: config
+        });
+        if (!result.data?.matched) {
+            throw new Error('Root container not matched');
+        }
+        this.setVariable('root', 'rootContainerId', result.data.container.id);
+        this.emit('container:match', { rootId: result.data.container.id });
+    }
+    async executeContainerOperation(action) {
+        if (!action.containerId || !action.operationId) {
+            throw new Error('containerId and operationId are required for container.operation');
+        }
+        const config = this.resolveConfig(action.config);
+        await this.context.apiClient.post('/v1/controller/action', {
+            action: 'container:operation',
+            payload: {
+                containerId: action.containerId,
+                operationId: action.operationId,
+                config,
+                sessionId: this.config.config.profile
+            }
+        });
+        this.emit('container:operation', { action });
+    }
+    async extractPost(action) {
+        if (!action.containerId)
+            return;
+        const res = await this.context.apiClient.post('/v1/controller/action', {
+            action: 'container:operation',
+            payload: {
+                containerId: action.containerId,
+                operationId: 'extract',
+                config: action.config || {},
+                sessionId: this.config.config.profile
+            }
+        });
+        const extracted = res.data?.data?.extracted?.[0];
+        if (extracted) {
+            this.posts.push(extracted);
+            this.emit('post:extracted', { extracted, total: this.posts.length });
+        }
+    }
+    setVariable(containerId, key, value) {
+        this.variables.set(`${containerId}.${key}`, value);
+        this.emit('variable:set', { containerId, key, value });
+    }
+    incrementVariable(containerId, key) {
+        const current = this.variables.get(`${containerId}.${key}`) || 0;
+        this.variables.set(`${containerId}.${key}`, current + 1);
+        this.emit('variable:increment', { containerId, key, value: current + 1 });
+    }
+    evaluateCondition(condition) {
+        const key = `${condition.scope}.${condition.variable}`;
+        const value = this.variables.get(key) || 0;
+        const targetValue = this.parseValue(condition.value);
+        switch (condition.operator) {
+            case 'lt': return value < targetValue;
+            case 'lte': return value <= targetValue;
+            case 'gt': return value > targetValue;
+            case 'gte': return value >= targetValue;
+            case 'eq': return value === targetValue;
+            default: return false;
+        }
+    }
+    async generateOutput() {
+        if (this.config.outputs.format !== 'markdown')
+            return;
+        const fs = await import('fs/promises');
+        const lines = [
+            '# 微博主页采集结果 (事件驱动版)',
+            '',
+            `采集时间：${new Date().toLocaleString('zh-CN')}`,
+            `帖子数量：${this.posts.length}`,
+            '',
+            '---',
+            ''
+        ];
+        this.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('');
+        });
+        await fs.writeFile(this.config.outputs.file, lines.join('\n'), 'utf-8');
+        this.emit('output:generated', { file: this.config.outputs.file });
+    }
+}
+//# sourceMappingURL=WeiboEventDrivenWorkflowRunner.js.map

package/dist/modules/workflow/src/context.js

@@ -0,0 +1,70 @@
+function sanitizeArg(arg) {
+    if (typeof arg === 'undefined') {
+        return null;
+    }
+    return arg;
+}
+function buildScript(fn, args) {
+    if (typeof fn === 'string' && (!args || args.length === 0)) {
+        return fn;
+    }
+    const source = typeof fn === 'function' ? fn.toString() : fn;
+    const serializedArgs = JSON.stringify((args || []).map(sanitizeArg));
+    return `(() => {
+    const __name = (target, value) => {
+      try {
+        Object.defineProperty(target, 'name', { value, configurable: true });
+      } catch {}
+      return target;
+    };
+    const __fn = ${source};
+    const __args = ${serializedArgs};
+    return Promise.resolve(__fn(...__args));
+  })()`;
+}
+export class BrowserWorkflowContextProvider {
+    serviceHost;
+    servicePort;
+    profile;
+    constructor(options) {
+        this.profile = options.profile;
+        this.serviceHost = options.host || '127.0.0.1';
+        this.servicePort = typeof options.port === 'number' ? options.port : 7704;
+    }
+    async createContext() {
+        return {
+            page: {
+                evaluate: async (fn, ...args) => this.evaluate(fn, args),
+            },
+            logger: console,
+        };
+    }
+    async evaluate(fn, args) {
+        const script = buildScript(fn, args);
+        if (process.env.WORKFLOW_CONTEXT_DEBUG === '1') {
+            console.debug('[workflow:context] evaluate fn:', typeof fn === 'function' ? fn.toString() : fn);
+            console.debug('[workflow:context] script:', script);
+        }
+        const response = await this.command('evaluate', {
+            profileId: this.profile,
+            script,
+        });
+        if (response?.ok === false) {
+            throw new Error(response?.error || 'evaluate failed');
+        }
+        return typeof response?.result === 'undefined' ? response : response.result;
+    }
+    async command(action, args) {
+        const resp = await fetch(`http://${this.serviceHost}:${this.servicePort}/command`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ action, args }),
+        });
+        const payload = await resp.json().catch(() => ({}));
+        if (!resp.ok) {
+            return { ok: false, error: payload?.error || `command ${action} failed: HTTP ${resp.status}` };
+        }
+        return payload;
+    }
+}
+//# sourceMappingURL=context.js.map

package/dist/modules/workflow/src/index.js

@@ -0,0 +1,5 @@
+export * from './runtime.js';
+export * from './context.js';
+export * from './orchestrator.js';
+export * from './runner.js';
+//# sourceMappingURL=index.js.map