@web-auto/webauto 0.1.1 → 0.1.2

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

@@ -0,0 +1,92 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+const HOME_LOG_ROOT = path.join(os.homedir(), '.webauto', 'logs');
+export const DEBUG_LOG_FILE = path.join(HOME_LOG_ROOT, 'debug.jsonl');
+const DEFAULT_SOURCES = {
+    browser: path.join(HOME_LOG_ROOT, 'browser.log'),
+    service: path.join(HOME_LOG_ROOT, 'service.log'),
+    orchestrator: path.join(HOME_LOG_ROOT, 'orchestrator.log'),
+    debug: DEBUG_LOG_FILE,
+};
+let debugReady = false;
+function isDebugEnabled() {
+    return process.env.DEBUG === '1' || process.env.debug === '1';
+}
+function ensureDebugLogDir() {
+    if (debugReady)
+        return;
+    try {
+        fs.mkdirSync(path.dirname(DEBUG_LOG_FILE), { recursive: true });
+        debugReady = true;
+    }
+    catch {
+        // ignore
+    }
+}
+export function logDebug(module, event, data = {}) {
+    if (!isDebugEnabled())
+        return;
+    ensureDebugLogDir();
+    const entry = {
+        ts: Date.now(),
+        level: 'debug',
+        module,
+        event,
+        data,
+    };
+    try {
+        fs.appendFileSync(DEBUG_LOG_FILE, `${JSON.stringify(entry)}\n`);
+    }
+    catch {
+        // ignore
+    }
+}
+export function logWorkflowEvent(event) {
+    logDebug('workflow', event.status, event);
+}
+export function resolveLogFile(options) {
+    if (options.file) {
+        return path.resolve(options.file);
+    }
+    if (options.session) {
+        return path.join(HOME_LOG_ROOT, `session-${options.session}.log`);
+    }
+    if (options.source && DEFAULT_SOURCES[options.source]) {
+        return DEFAULT_SOURCES[options.source];
+    }
+    return DEFAULT_SOURCES.browser;
+}
+export async function streamLog(options = {}) {
+    const file = resolveLogFile(options);
+    const maxLines = options.maxLines ?? 200;
+    const lines = await readTailLines(file, maxLines);
+    return { file, lines };
+}
+export async function flushLog(options = {}, truncate = false) {
+    const file = resolveLogFile(options);
+    const lines = await readTailLines(file, Number.MAX_SAFE_INTEGER);
+    if (truncate) {
+        await fs.promises
+            .truncate(file, 0)
+            .catch(() => Promise.resolve());
+    }
+    return { file, lines };
+}
+async function readTailLines(file, maxLines) {
+    try {
+        const content = await fs.promises.readFile(file, 'utf-8');
+        const lines = content.split(/\r?\n/).filter((line) => line.length > 0);
+        if (lines.length <= maxLines) {
+            return lines;
+        }
+        return lines.slice(-maxLines);
+    }
+    catch (err) {
+        if (err && (err.code === 'ENOENT' || err.code === 'ENOTDIR')) {
+            return [];
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/modules/operations/src/builtin.js

@@ -0,0 +1,27 @@
+import { registerOperation } from './registry.js';
+import { highlightOperation } from './operations/highlight.js';
+import { scrollOperation } from './operations/scroll.js';
+import { mouseMoveOperation, mouseClickOperation } from './system/mouse.js';
+import { extractOperation } from './operations/extract.js';
+import { clickOperation } from './operations/click.js';
+import { typeOperation } from './operations/type.js';
+import { findChildOperation } from './operations/find-child.js';
+import { navigateOperation } from './operations/navigate.js';
+import { keyOperation } from './operations/key.js';
+let initialized = false;
+export function ensureBuiltinOperations() {
+    if (initialized)
+        return;
+    registerOperation(highlightOperation);
+    registerOperation(scrollOperation);
+    registerOperation(mouseMoveOperation);
+    registerOperation(mouseClickOperation);
+    registerOperation(extractOperation);
+    registerOperation(clickOperation);
+    registerOperation(typeOperation);
+    registerOperation(keyOperation);
+    registerOperation(findChildOperation);
+    registerOperation(navigateOperation);
+    initialized = true;
+}
+//# sourceMappingURL=builtin.js.map

package/dist/modules/operations/src/container-binding.js

@@ -0,0 +1,75 @@
+import { getOperation } from './registry.js';
+function hasCapability(container, required) {
+    if (!required || !required.length) {
+        return true;
+    }
+    const capabilitySet = new Set((container.capabilities || []).map((c) => c.toLowerCase()));
+    return required.every((cap) => capabilitySet.has(cap.toLowerCase()));
+}
+function isOperationListed(container, operationId) {
+    const declared = container.operations || [];
+    return declared.some((item) => (item?.type || item?.id) === operationId);
+}
+export function validateContainerOperations(container) {
+    const issues = [];
+    const operations = container.operations || [];
+    if (!operations.length) {
+        return issues;
+    }
+    for (const entry of operations) {
+        const operationId = entry?.type || entry?.id;
+        if (!operationId) {
+            issues.push({
+                containerId: container.id,
+                operationId: 'unknown',
+                level: 'error',
+                reason: 'operation entry missing type/id',
+            });
+            continue;
+        }
+        const operation = getOperation(operationId);
+        if (!operation) {
+            issues.push({
+                containerId: container.id,
+                operationId,
+                level: 'error',
+                reason: 'operation is not registered in OperationRegistry',
+            });
+            continue;
+        }
+        const required = operation.requiredCapabilities;
+        if (!hasCapability(container, required)) {
+            issues.push({
+                containerId: container.id,
+                operationId,
+                level: 'error',
+                reason: `missing capabilities: ${required?.join(', ') || ''}`,
+            });
+        }
+    }
+    return issues;
+}
+export function assertContainerOperations(container) {
+    const issues = validateContainerOperations(container);
+    if (issues.length) {
+        const summary = issues
+            .map((issue) => `${issue.containerId}:${issue.operationId} -> ${issue.reason}`)
+            .join('\n');
+        const error = new Error(`Container operation validation failed:\n${summary}`);
+        error.issues = issues;
+        throw error;
+    }
+}
+export function containerAllowsOperation(container, operationId) {
+    const operation = getOperation(operationId);
+    if (!operation) {
+        throw new Error(`Unknown operation: ${operationId}`);
+    }
+    if (!hasCapability(container, operation.requiredCapabilities)) {
+        throw new Error(`Operation ${operationId} requires capabilities ${operation.requiredCapabilities?.join(', ') || ''}`);
+    }
+    if (container.operations && container.operations.length && !isOperationListed(container, operationId)) {
+        throw new Error(`Operation ${operationId} is not declared in container ${container.id}`);
+    }
+}
+//# sourceMappingURL=container-binding.js.map

package/dist/modules/operations/src/executor.js

@@ -0,0 +1,146 @@
+import { highlightOperation } from './operations/highlight.js';
+import { scrollOperation } from './operations/scroll.js';
+import { mouseMoveOperation, mouseClickOperation } from './system/mouse.js';
+import { extractOperation } from './operations/extract.js';
+import { clickOperation } from './operations/click.js';
+import { findChildOperation } from './operations/find-child.js';
+import { typeOperation } from './operations/type.js';
+import { navigateOperation } from './operations/navigate.js';
+import { keyOperation } from './operations/key.js';
+import { ContainerRegistry } from '../../container-registry/src/index.js';
+function resolveInputMode() {
+    const raw = String(process.env.WEBAUTO_INPUT_MODE || 'system').trim().toLowerCase();
+    return raw === 'protocol' ? 'protocol' : 'system';
+}
+export class ContainerExecutor {
+    operations = new Map();
+    registry = new ContainerRegistry();
+    constructor() {
+        this.initializeBuiltinOperations();
+    }
+    initializeBuiltinOperations() {
+        this.registerOperation(highlightOperation);
+        this.registerOperation(scrollOperation);
+        this.registerOperation(mouseMoveOperation);
+        this.registerOperation(mouseClickOperation);
+        this.registerOperation(extractOperation);
+        this.registerOperation(clickOperation);
+        this.registerOperation(findChildOperation);
+        this.registerOperation(typeOperation);
+        this.registerOperation(keyOperation);
+        this.registerOperation(navigateOperation);
+    }
+    registerOperation(config) {
+        this.operations.set(config.id, config);
+    }
+    async execute(containerId, operationId, config, context) {
+        const operation = this.operations.get(operationId);
+        if (!operation) {
+            return {
+                success: false,
+                error: `Unknown operation: ${operationId}`
+            };
+        }
+        // 合并容器定义中的默认 operation config（调用方 config 优先）
+        config = await this.mergeContainerOperationConfig(containerId, operationId, config, context);
+        const inputMode = resolveInputMode();
+        const modeControlledOps = new Set(['click', 'type', 'key', 'scroll']);
+        if (modeControlledOps.has(operationId)) {
+            if (inputMode === 'protocol') {
+                // Protocol mode bypasses OS-level input so actions can run without window focus.
+                config = { ...config, useSystemMouse: false };
+            }
+            else if (typeof config.useSystemMouse !== 'boolean') {
+                config = { ...config, useSystemMouse: true };
+            }
+        }
+        // click：如果调用方明确给了坐标/bbox，则优先走坐标点击，避免被容器默认 selector 覆盖
+        if (operationId === 'click' &&
+            config &&
+            typeof config === 'object' &&
+            (Boolean(config.bbox) ||
+                (typeof config.x === 'number' && typeof config.y === 'number'))) {
+            const next = { ...config };
+            delete next.selector;
+            config = next;
+        }
+        // extract：注入容器 extractors（兼容 container-library 的 extract operation fields: string[]）
+        if (operationId === 'extract' && config && typeof config === 'object' && !('extractors' in config)) {
+            try {
+                const { container } = await this.getContainerForContext(containerId, context);
+                const extractors = container?.extractors;
+                if (extractors && typeof extractors === 'object' && !Array.isArray(extractors)) {
+                    config = { ...config, extractors };
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
+        // 如果操作需要 selector，则从容器定义中补齐
+        const isClickWithCoordinates = operationId === 'click' &&
+            config &&
+            typeof config === 'object' &&
+            (Boolean(config.bbox) ||
+                (typeof config.x === 'number' && typeof config.y === 'number'));
+        if (this.requiresSelector(operation) && !config.selector && !isClickWithCoordinates) {
+            const selector = await this.getSelectorForContainer(containerId, context);
+            if (!selector) {
+                return {
+                    success: false,
+                    error: `Cannot find selector for container: ${containerId}`
+                };
+            }
+            config = { ...config, selector };
+        }
+        try {
+            return await operation.run(context, config);
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || String(error)
+            };
+        }
+    }
+    requiresSelector(operation) {
+        return ['highlight', 'click', 'extract', 'type', 'input', 'scroll', 'key'].includes(operation.id);
+    }
+    async mergeContainerOperationConfig(containerId, operationId, config, context) {
+        const { url, container } = await this.getContainerForContext(containerId, context);
+        if (!url || !container)
+            return config;
+        const ops = Array.isArray(container.operations) ? container.operations : [];
+        const defaultOp = ops.find((op) => (op?.type || op?.id) === operationId);
+        const baseConfig = defaultOp?.config && typeof defaultOp.config === 'object' ? defaultOp.config : null;
+        if (!baseConfig)
+            return config;
+        return { ...baseConfig, ...config };
+    }
+    async getSelectorForContainer(containerId, context) {
+        const { container } = await this.getContainerForContext(containerId, context);
+        if (!container || !container.selectors || !container.selectors.length) {
+            return null;
+        }
+        const primary = container.selectors.find((s) => s.variant === 'primary') || container.selectors[0];
+        return primary?.css || null;
+    }
+    async getContainerForContext(containerId, context) {
+        const url = await context.page.evaluate(() => window.location.href);
+        if (!url) {
+            return { url: null, container: null };
+        }
+        await this.registry.load();
+        const containers = this.registry.getContainersForUrl(url);
+        return { url, container: containers[containerId] || null };
+    }
+}
+// Singleton instance
+let executorInstance = null;
+export function getContainerExecutor() {
+    if (!executorInstance) {
+        executorInstance = new ContainerExecutor();
+    }
+    return executorInstance;
+}
+//# sourceMappingURL=executor.js.map

package/dist/modules/operations/src/operations/click.js

@@ -0,0 +1,167 @@
+async function runClick(ctx, config) {
+    const waitFor = config.waitFor || 0;
+    if (waitFor > 0) {
+        await new Promise((r) => setTimeout(r, waitFor));
+    }
+    if (config.selector) {
+        // 方案 A: 通过 selector + index 点击（强制系统级点击，避免 DOM click）
+        const index = Number.isFinite(config.index) ? Math.max(0, Math.floor(config.index)) : 0;
+        const useSystemMouse = config.useSystemMouse !== false;
+        const visibleOnly = config.visibleOnly === true;
+        const fullyVisible = config.fullyVisible === true;
+        const anchor = config.anchor ?? null;
+        const protocolMouse = ctx.page?.mouse;
+        if (!useSystemMouse && (!protocolMouse || typeof protocolMouse.click !== 'function')) {
+            return { success: false, error: 'protocol mouse not available' };
+        }
+        const target = typeof config.target === 'string' ? config.target.trim() : '';
+        const info = await ctx.page.evaluate(({ sel, idx, tgt, visibleOnly: vOnly, fullyVisible: fOnly, anchor: anchorPoint }) => {
+            const isVisible = (el) => {
+                const r = el.getBoundingClientRect();
+                return (r.width > 0 &&
+                    r.height > 0 &&
+                    r.bottom > 0 &&
+                    r.top < window.innerHeight &&
+                    r.right > 0 &&
+                    r.left < window.innerWidth);
+            };
+            const isFullyVisible = (el) => {
+                const r = el.getBoundingClientRect();
+                return (r.width > 0 &&
+                    r.height > 0 &&
+                    r.top >= 0 &&
+                    r.left >= 0 &&
+                    r.bottom <= window.innerHeight &&
+                    r.right <= window.innerWidth);
+            };
+            const allNodes = Array.from(document.querySelectorAll(sel));
+            const nodes = vOnly || fOnly ? allNodes.filter((n) => isVisible(n)) : allNodes;
+            const root = nodes[idx];
+            if (!root)
+                return null;
+            let el = root;
+            if (tgt) {
+                if (tgt === 'self') {
+                    el = root;
+                }
+                else if (tgt === 'img') {
+                    el = root.querySelector('img') || root;
+                }
+                else {
+                    el = root.querySelector(tgt) || root;
+                }
+            }
+            const r = el.getBoundingClientRect();
+            const visible = r.width > 0 && r.height > 0 && r.y < window.innerHeight && r.y + r.height > 0;
+            if (!visible)
+                return { visible: false, clickPoints: [], anchorMatch: false };
+            if (fOnly && !isFullyVisible(el)) {
+                return { visible: false, clickPoints: [], anchorMatch: false };
+            }
+            if (anchorPoint) {
+                const hit = document.elementFromPoint(anchorPoint.x, anchorPoint.y);
+                if (!hit || (hit !== el && !el.contains(hit))) {
+                    return { visible: false, clickPoints: [], anchorMatch: false };
+                }
+            }
+            const x1 = Math.max(0, r.left);
+            const y1 = Math.max(0, r.top);
+            const x2 = Math.min(window.innerWidth, r.right);
+            const y2 = Math.min(window.innerHeight, r.bottom);
+            const mx = Math.round((x1 + x2) / 2);
+            const my = Math.round((y1 + y2) / 2);
+            const pad = 10;
+            const points = [
+                { x: mx, y: my },
+                { x: Math.round(x1 + pad), y: my },
+                { x: Math.round(x2 - pad), y: my },
+                { x: mx, y: Math.round(y1 + pad) },
+                { x: mx, y: Math.round(y2 - pad) },
+            ];
+            const clickPoints = [];
+            for (const p of points) {
+                if (!Number.isFinite(p.x) || !Number.isFinite(p.y))
+                    continue;
+                if (p.x < 0 || p.y < 0 || p.x > window.innerWidth || p.y > window.innerHeight)
+                    continue;
+                const hit = document.elementFromPoint(p.x, p.y);
+                if (hit && (hit === el || el.contains(hit))) {
+                    clickPoints.push(p);
+                }
+            }
+            if (!clickPoints.length) {
+                // 兜底：至少点一次可见交集的中心
+                clickPoints.push({ x: mx, y: my });
+            }
+            return { visible: true, clickPoints, anchorMatch: Boolean(anchorPoint) };
+        }, { sel: config.selector, idx: index, tgt: target, visibleOnly, fullyVisible, anchor });
+        if (!info || !info.visible || !Array.isArray(info.clickPoints) || info.clickPoints.length === 0) {
+            return { success: false, error: 'element not visible' };
+        }
+        if (useSystemMouse && !ctx.systemInput?.mouseClick) {
+            return { success: false, error: 'system mouse not available' };
+        }
+        const clickPoints = info.clickPoints;
+        // 优先点击视口内且命中目标元素的点，避免“元素部分可见但中心离屏”导致点错
+        for (const p of clickPoints) {
+            const x = Math.round(p.x);
+            const y = Math.round(p.y);
+            if (useSystemMouse) {
+                await ctx.systemInput.mouseClick(x, y);
+            }
+            else {
+                await protocolMouse.click(x, y);
+            }
+            break;
+        }
+        return { success: true, inputMode: useSystemMouse ? 'system' : 'protocol' };
+    }
+    else if (config.bbox) {
+        // 方案 B: 通过 bbox 点击（使用系统鼠标）
+        const cx = Math.round((config.bbox.x1 + config.bbox.x2) / 2);
+        const cy = Math.round((config.bbox.y1 + config.bbox.y2) / 2);
+        const useSystemMouse = config.useSystemMouse !== false;
+        const protocolMouse = ctx.page?.mouse;
+        if (useSystemMouse) {
+            if (!ctx.systemInput?.mouseClick) {
+                return { success: false, error: 'system mouse not available' };
+            }
+            await ctx.systemInput.mouseClick(cx, cy);
+        }
+        else {
+            if (!protocolMouse || typeof protocolMouse.click !== 'function') {
+                return { success: false, error: 'protocol mouse not available' };
+            }
+            await protocolMouse.click(cx, cy);
+        }
+        return { success: true, inputMode: useSystemMouse ? 'system' : 'protocol' };
+    }
+    else if (typeof config.x === 'number' && typeof config.y === 'number') {
+        // 方案 C: 直接通过坐标点击
+        const useSystemMouse = config.useSystemMouse !== false;
+        const protocolMouse = ctx.page?.mouse;
+        if (useSystemMouse) {
+            if (!ctx.systemInput?.mouseClick) {
+                return { success: false, error: 'system mouse not available' };
+            }
+            await ctx.systemInput.mouseClick(config.x, config.y);
+        }
+        else {
+            if (!protocolMouse || typeof protocolMouse.click !== 'function') {
+                return { success: false, error: 'protocol mouse not available' };
+            }
+            await protocolMouse.click(config.x, config.y);
+        }
+        return { success: true, inputMode: useSystemMouse ? 'system' : 'protocol' };
+    }
+    else {
+        return { success: false, error: 'selector or bbox required' };
+    }
+}
+export const clickOperation = {
+    id: 'click',
+    description: 'Click element by selector or bbox',
+    requiredCapabilities: ['click'],
+    run: runClick,
+};
+//# sourceMappingURL=click.js.map