@web-auto/webauto 0.1.1 → 0.1.2

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

@@ -0,0 +1,230 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import WebSocket from 'ws';
+import { ContainerRegistry } from '../../container-registry/src/index.js';
+import { WorkflowRuntime } from './runtime.js';
+import { BrowserWorkflowContextProvider } from './context.js';
+class MockWorkflowContextProvider {
+    async createContext() {
+        return {
+            page: {
+                async evaluate() {
+                    return { success: true, mock: true };
+                },
+            },
+            logger: console,
+        };
+    }
+}
+export class WorkflowOrchestrator {
+    options;
+    registry = new ContainerRegistry();
+    runtime = null;
+    ws = null;
+    constructor(options) {
+        this.options = options;
+    }
+    async start() {
+        const workflows = this.loadDefinitions();
+        if (!workflows.length) {
+            throw new Error('No workflow definitions loaded');
+        }
+        const contextProvider = this.options.testMode
+            ? new MockWorkflowContextProvider()
+            : new BrowserWorkflowContextProvider({
+                profile: this.options.profile,
+                host: this.options.browserHost,
+                port: this.options.browserPort,
+            });
+        this.runtime = new WorkflowRuntime({
+            contextProvider: () => contextProvider.createContext(),
+        });
+        this.attachRuntimeEvents(this.runtime);
+        for (const wf of workflows) {
+            this.runtime.registerWorkflow(wf.definition);
+        }
+        console.log(`[workflow] Registered ${workflows.length} workflow(s)`);
+        if (this.options.testMode) {
+            await this.runTestMode(workflows);
+            return;
+        }
+        await this.connectWebSocket(this.collectTopics(workflows));
+    }
+    attachRuntimeEvents(runtime) {
+        runtime.on('task:queued', ({ task }) => {
+            console.log(`[workflow] task queued ${task.container.id} -> ${task.operationId}`);
+        });
+        runtime.on('task:started', ({ task }) => {
+            console.log(`[workflow] task started ${task.container.id} -> ${task.operationId}`);
+        });
+        runtime.on('task:completed', ({ task, result }) => {
+            console.log(`[workflow] task completed ${task.container.id} -> ${task.operationId}`, result);
+        });
+        runtime.on('task:failed', ({ task, error }) => {
+            console.warn(`[workflow] task failed ${task.container.id} -> ${task.operationId}: ${error}`);
+        });
+    }
+    async stop() {
+        if (this.ws) {
+            this.ws.removeAllListeners();
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+    async runTestMode(workflows) {
+        if (!this.runtime)
+            return;
+        console.log('[workflow] test mode: emitting triggers once');
+        const topics = this.collectTopics(workflows);
+        for (const topic of topics) {
+            await this.runtime.dispatchEvent(topic, { source: 'workflow:test-mode' });
+        }
+        console.log('[workflow] test mode completed');
+    }
+    collectTopics(workflows) {
+        const topics = new Set();
+        for (const wf of workflows) {
+            for (const trigger of wf.definition.triggers) {
+                topics.add(trigger.event);
+            }
+        }
+        return Array.from(topics);
+    }
+    async connectWebSocket(topics) {
+        if (!topics.length) {
+            console.warn('[workflow] No trigger events configured, nothing to subscribe');
+            return;
+        }
+        const wsUrl = this.options.wsUrl || 'ws://127.0.0.1:7701/ws';
+        console.log(`[workflow] connecting to ${wsUrl}`);
+        this.ws = new WebSocket(wsUrl);
+        this.ws.on('open', () => {
+            console.log('[workflow] websocket connected');
+            topics.forEach((topic) => {
+                const payload = { type: 'subscribe', topic };
+                this.ws?.send(JSON.stringify(payload));
+                console.log(`[workflow] subscribed ${topic}`);
+            });
+        });
+        this.ws.on('message', (raw) => {
+            this.handleWsMessage(raw.toString()).catch((err) => {
+                console.error('[workflow] ws message error', err?.message || err);
+            });
+        });
+        this.ws.on('close', () => {
+            console.warn('[workflow] websocket closed');
+        });
+        this.ws.on('error', (err) => {
+            console.error('[workflow] websocket error', err?.message || err);
+        });
+    }
+    async handleWsMessage(raw) {
+        if (!this.runtime)
+            return;
+        let message;
+        try {
+            message = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (message?.type !== 'event') {
+            return;
+        }
+        const topic = message.topic || 'unknown';
+        console.log(`[workflow] ws event ${topic}`);
+        await this.runtime.dispatchEvent(topic, message.payload || {});
+    }
+    loadDefinitions() {
+        const outputs = [];
+        for (const defPath of this.options.definitionPaths) {
+            const abs = path.resolve(defPath);
+            if (!fs.existsSync(abs)) {
+                throw new Error(`Workflow definition not found: ${abs}`);
+            }
+            const raw = fs.readFileSync(abs, 'utf-8');
+            let data;
+            try {
+                data = JSON.parse(raw);
+            }
+            catch (err) {
+                throw new Error(`Invalid JSON in ${abs}: ${err?.message || err}`);
+            }
+            const entries = Array.isArray(data) ? data : [data];
+            entries.forEach((entry, idx) => {
+                const workflow = this.transformDefinition(entry, abs, idx);
+                outputs.push({ definition: workflow, sourcePath: abs });
+            });
+        }
+        return outputs;
+    }
+    transformDefinition(entry, sourcePath, index) {
+        if (!entry || typeof entry !== 'object') {
+            throw new Error(`Workflow definition at ${sourcePath}#${index} is not an object`);
+        }
+        if (!entry.id) {
+            throw new Error(`Workflow definition missing id (${sourcePath}#${index})`);
+        }
+        if (!entry.containerId) {
+            throw new Error(`Workflow ${entry.id} missing containerId`);
+        }
+        if (!Array.isArray(entry.triggers) || !entry.triggers.length) {
+            throw new Error(`Workflow ${entry.id} requires at least one trigger`);
+        }
+        const container = this.resolveContainer(entry);
+        const triggers = entry.triggers.map((trigger) => {
+            if (!trigger?.event) {
+                throw new Error(`Workflow ${entry.id} trigger missing event`);
+            }
+            const operations = this.resolveOperations(trigger, container);
+            return {
+                event: trigger.event,
+                operations,
+            };
+        });
+        return {
+            id: entry.id,
+            name: entry.name,
+            container,
+            triggers,
+        };
+    }
+    resolveContainer(entry) {
+        const url = entry.url || this.options.url;
+        let containers = {};
+        if (entry.site || this.options.containerSite) {
+            const site = entry.site || this.options.containerSite;
+            containers = this.registry.getContainersForSite(site);
+        }
+        else if (url) {
+            containers = this.registry.getContainersForUrl(url);
+        }
+        else {
+            throw new Error(`Workflow ${entry.id} requires site or url to resolve containers`);
+        }
+        const container = containers[entry.containerId];
+        if (!container) {
+            throw new Error(`Container ${entry.containerId} not found for workflow ${entry.id}`);
+        }
+        return container;
+    }
+    resolveOperations(trigger, container) {
+        if (trigger.operations && trigger.operations.length) {
+            return trigger.operations.map((op) => ({
+                id: op.id,
+                config: op.config,
+                priority: op.priority,
+            }));
+        }
+        if (trigger.useContainerOperations) {
+            const operations = container.operations || [];
+            return operations.map((op, index) => ({
+                id: op.type || op.id,
+                config: op.config || op.params || {},
+                priority: operations.length - index,
+            }));
+        }
+        throw new Error(`Trigger ${trigger.event} missing operations configuration`);
+    }
+}
+//# sourceMappingURL=orchestrator.js.map

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

@@ -0,0 +1,55 @@
+import { WorkflowExecutor } from '../blocks/WorkflowExecutor.js';
+import { getWorkflowDefinition } from '../config/workflowRegistry.js';
+import * as EnsureSession from '../blocks/EnsureSession.js';
+import * as EnsureLoginBlock from '../blocks/EnsureLoginBlock.js';
+import * as WaitSearchPermitBlock from '../blocks/WaitSearchPermitBlock.js';
+import * as GoToSearchBlock from '../blocks/GoToSearchBlock.js';
+import * as CollectSearchListBlock from '../blocks/CollectSearchListBlock.js';
+import * as OpenDetailBlock from '../blocks/OpenDetailBlock.js';
+import * as ExtractDetailBlock from '../blocks/ExtractDetailBlock.js';
+import * as WarmupCommentsBlock from '../blocks/WarmupCommentsBlock.js';
+import * as ExpandCommentsBlock from '../blocks/ExpandCommentsBlock.js';
+import * as CollectCommentsBlock from '../blocks/CollectCommentsBlock.js';
+import * as PersistXhsNoteBlock from '../blocks/PersistXhsNoteBlock.js';
+import * as CloseDetailBlock from '../blocks/CloseDetailBlock.js';
+import * as XiaohongshuFullCollectBlock from '../blocks/XiaohongshuFullCollectBlock.js';
+import * as XiaohongshuCollectLinksBlock from '../blocks/XiaohongshuCollectLinksBlock.js';
+import * as XiaohongshuCollectFromLinksBlock from '../blocks/XiaohongshuCollectFromLinksBlock.js';
+import * as ErrorRecoveryBlock from '../blocks/ErrorRecoveryBlock.js';
+import * as AnchorVerificationBlock from '../blocks/AnchorVerificationBlock.js';
+import * as CallWorkflowBlock from '../blocks/CallWorkflowBlock.js';
+import * as RecordFixtureBlock from '../blocks/RecordFixtureBlock.js';
+import * as OrganizeXhsNotesBlock from '../blocks/OrganizeXhsNotesBlock.js';
+export function createDefaultWorkflowExecutor() {
+    const executor = new WorkflowExecutor();
+    executor.registerBlock('EnsureSession', { execute: EnsureSession.execute });
+    executor.registerBlock('EnsureLoginBlock', { execute: EnsureLoginBlock.execute });
+    executor.registerBlock('WaitSearchPermitBlock', { execute: WaitSearchPermitBlock.execute });
+    executor.registerBlock('GoToSearchBlock', { execute: GoToSearchBlock.execute });
+    executor.registerBlock('CollectSearchListBlock', { execute: CollectSearchListBlock.execute });
+    executor.registerBlock('OpenDetailBlock', { execute: OpenDetailBlock.execute });
+    executor.registerBlock('ExtractDetailBlock', { execute: ExtractDetailBlock.execute });
+    executor.registerBlock('WarmupCommentsBlock', { execute: WarmupCommentsBlock.execute });
+    executor.registerBlock('ExpandCommentsBlock', { execute: ExpandCommentsBlock.execute });
+    executor.registerBlock('CollectCommentsBlock', { execute: CollectCommentsBlock.execute });
+    executor.registerBlock('CloseDetailBlock', { execute: CloseDetailBlock.execute });
+    executor.registerBlock('ErrorRecoveryBlock', { execute: ErrorRecoveryBlock.execute });
+    executor.registerBlock('AnchorVerificationBlock', { execute: AnchorVerificationBlock.execute });
+    executor.registerBlock('CallWorkflowBlock', { execute: CallWorkflowBlock.execute });
+    executor.registerBlock('PersistXhsNoteBlock', { execute: PersistXhsNoteBlock.execute });
+    executor.registerBlock('RecordFixtureBlock', { execute: RecordFixtureBlock.execute });
+    executor.registerBlock('XiaohongshuFullCollectBlock', { execute: XiaohongshuFullCollectBlock.execute });
+    executor.registerBlock('XiaohongshuCollectLinksBlock', { execute: XiaohongshuCollectLinksBlock.execute });
+    executor.registerBlock('XiaohongshuCollectFromLinksBlock', { execute: XiaohongshuCollectFromLinksBlock.execute });
+    executor.registerBlock('OrganizeXhsNotesBlock', { execute: OrganizeXhsNotesBlock.execute });
+    return executor;
+}
+export async function runWorkflowById(workflowId, initialContext) {
+    const def = getWorkflowDefinition(workflowId);
+    if (!def) {
+        throw new Error(`Workflow not found: ${workflowId}`);
+    }
+    const executor = createDefaultWorkflowExecutor();
+    return executor.execute(def, initialContext);
+}
+//# sourceMappingURL=runner.js.map

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

@@ -0,0 +1,70 @@
+import { EventEmitter } from 'node:events';
+import { ContainerOperationQueue } from '../../operations/src/queue.js';
+import { ensureBuiltinOperations } from '../../operations/src/builtin.js';
+import { assertContainerOperations, containerAllowsOperation } from '../../operations/src/container-binding.js';
+function matches(pattern, topic) {
+    if (!pattern || pattern === topic)
+        return true;
+    const regexPattern = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(topic);
+}
+export class WorkflowRuntime extends EventEmitter {
+    queue;
+    workflows = new Map();
+    constructor(options = {}) {
+        super();
+        ensureBuiltinOperations();
+        this.queue = new ContainerOperationQueue({
+            contextProvider: options.contextProvider,
+            autoStart: true,
+        });
+        this.queue.on('task:queued', (payload) => this.emit('task:queued', payload));
+        this.queue.on('task:started', (payload) => this.emit('task:started', payload));
+        this.queue.on('task:completed', (payload) => this.emit('task:completed', payload));
+        this.queue.on('task:failed', (payload) => this.emit('task:failed', payload));
+    }
+    registerWorkflow(definition) {
+        if (!definition?.container) {
+            throw new Error('workflow definition missing container');
+        }
+        assertContainerOperations(definition.container);
+        this.workflows.set(definition.id, definition);
+        this.emit('workflow:registered', { workflow: definition });
+    }
+    unregisterWorkflow(id) {
+        if (this.workflows.delete(id)) {
+            this.emit('workflow:unregistered', { id });
+        }
+    }
+    async dispatchEvent(event, payload) {
+        for (const workflow of this.workflows.values()) {
+            for (const trigger of workflow.triggers) {
+                if (!matches(trigger.event, event)) {
+                    continue;
+                }
+                if (trigger.condition) {
+                    const shouldRun = await trigger.condition({ event, payload, workflow });
+                    if (!shouldRun) {
+                        continue;
+                    }
+                }
+                await this.enqueueOperations(workflow, trigger.operations, { event: { name: event, data: payload } });
+            }
+        }
+    }
+    async enqueueOperations(workflow, operations, metadata) {
+        for (const operation of operations) {
+            containerAllowsOperation(workflow.container, operation.id);
+            this.queue.enqueue(workflow.container, operation.id, {
+                priority: operation.priority,
+                config: operation.config,
+                event: metadata.event,
+            });
+        }
+    }
+}
+//# sourceMappingURL=runtime.js.map