@web-auto/webauto 0.1.1 → 0.1.3

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

@@ -0,0 +1,204 @@
+async function runExtract(ctx, config) {
+    if (!config.selector) {
+        throw new Error('extract operation requires selector');
+    }
+    const maxItems = config.max_items ?? 32;
+    const includeText = config.include_text ?? false;
+    const index = Number.isFinite(config.index) ? Math.max(0, Math.floor(config.index)) : null;
+    const visibleOnly = config.visibleOnly === true;
+    return ctx.page.evaluate((data) => {
+        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 allNodes = Array.from(document.querySelectorAll(data.selector || ''));
+        if (!allNodes.length) {
+            return { success: false, error: 'no elements found', count: 0, extracted: [] };
+        }
+        const nodes = data.visibleOnly ? allNodes.filter((n) => isVisible(n)) : allNodes;
+        if (!nodes.length) {
+            return { success: false, error: data.visibleOnly ? 'no visible elements found' : 'no elements found', count: 0, extracted: [] };
+        }
+        const roots = typeof data.index === 'number'
+            ? (() => {
+                const el = nodes[data.index];
+                return el ? [el] : [];
+            })()
+            : nodes;
+        if (!roots.length) {
+            return { success: false, error: 'no elements found', count: 0, extracted: [] };
+        }
+        const extracted = [];
+        const limit = Math.min(roots.length, data.maxItems);
+        const getAttrValue = (node, attr) => {
+            if (!node)
+                return '';
+            if (!attr || attr === 'textContent')
+                return (node.textContent || '').trim();
+            if (attr === 'href') {
+                const href = node.href || (typeof node.getAttribute === 'function' ? node.getAttribute('href') : '') || '';
+                return String(href || '').trim();
+            }
+            if (attr === 'src') {
+                const src = node.currentSrc || node.src || (typeof node.getAttribute === 'function' ? node.getAttribute('src') : '') || '';
+                return String(src || '').trim();
+            }
+            if (typeof node.getAttribute === 'function') {
+                const v = node.getAttribute(attr);
+                return v ? String(v).trim() : '';
+            }
+            return '';
+        };
+        const containerExtractorMode = Array.isArray(data.fields) && data.fields.length > 0 && data.extractors && typeof data.extractors === 'object';
+        for (let i = 0; i < limit; i++) {
+            const el = roots[i];
+            const item = {};
+            if (containerExtractorMode) {
+                const extractorKeys = data.fields;
+                const extractors = data.extractors || {};
+                for (const key of extractorKeys) {
+                    const def = extractors[key] || {};
+                    const selectors = Array.isArray(def.selectors) ? def.selectors : [];
+                    const attr = def.attr || 'textContent';
+                    const multiple = !!def.multiple;
+                    if (!selectors.length) {
+                        item[key] = multiple ? [] : '';
+                        continue;
+                    }
+                    if (multiple) {
+                        const values = [];
+                        for (const sel of selectors) {
+                            try {
+                                const nodes = Array.from(el.querySelectorAll(sel));
+                                for (const n of nodes) {
+                                    const v = getAttrValue(n, attr);
+                                    if (v)
+                                        values.push(v);
+                                }
+                            }
+                            catch {
+                                // ignore selector errors
+                            }
+                            if (values.length)
+                                break;
+                        }
+                        item[key] = values;
+                    }
+                    else {
+                        let value = '';
+                        for (const sel of selectors) {
+                            try {
+                                const n = el.querySelector(sel);
+                                if (!n)
+                                    continue;
+                                value = getAttrValue(n, attr);
+                                if (value)
+                                    break;
+                            }
+                            catch {
+                                // ignore selector errors
+                            }
+                        }
+                        item[key] = value;
+                    }
+                }
+                // Back-compat: common link field names
+                if (!item.href) {
+                    const linkCandidate = item.link ||
+                        item.detail_url ||
+                        item.detailUrl ||
+                        item.author_link ||
+                        item.user_link ||
+                        '';
+                    if (typeof linkCandidate === 'string' && linkCandidate) {
+                        item.href = linkCandidate;
+                    }
+                }
+            }
+            else {
+                // Generic selector-based extraction (legacy)
+                if (el.tagName === 'A' && el instanceof HTMLAnchorElement) {
+                    item.href = el.href;
+                }
+                else if (data.fields && typeof data.fields === 'object' && data.fields.href) {
+                    const hrefSel = data.fields.href;
+                    const linkEl = hrefSel ? el.querySelector(hrefSel) : null;
+                    if (linkEl instanceof HTMLAnchorElement) {
+                        item.href = linkEl.href;
+                    }
+                }
+                if (data.includeText) {
+                    item.text = (el.textContent || '').trim().substring(0, 200);
+                }
+                if (data.fields && typeof data.fields === 'object' && !Array.isArray(data.fields)) {
+                    for (const [field, selector] of Object.entries(data.fields)) {
+                        if (field === 'href')
+                            continue;
+                        try {
+                            const fieldEl = selector ? el.querySelector(selector) : null;
+                            if (!fieldEl)
+                                continue;
+                            if (fieldEl instanceof HTMLImageElement) {
+                                item[field] = fieldEl.currentSrc || fieldEl.src;
+                            }
+                            else if (fieldEl instanceof HTMLAnchorElement) {
+                                item[field] = fieldEl.href;
+                            }
+                            else {
+                                item[field] = (fieldEl.textContent || '').trim().substring(0, 200);
+                            }
+                        }
+                        catch {
+                            // ignore selector errors
+                        }
+                    }
+                }
+            }
+            // Apply whitelist/blacklist filters
+            if (item.href) {
+                let skip = false;
+                // Check blacklist
+                if (data.blacklist?.contains) {
+                    for (const term of data.blacklist.contains) {
+                        if (item.href.includes(term)) {
+                            skip = true;
+                            break;
+                        }
+                    }
+                }
+                if (data.blacklist?.suffix) {
+                    for (const suffix of data.blacklist.suffix) {
+                        if (item.href.endsWith(suffix)) {
+                            skip = true;
+                            break;
+                        }
+                    }
+                }
+                // Check whitelist
+                if (!skip && data.whitelist?.prefix) {
+                    skip = !data.whitelist.prefix.some((prefix) => item.href.startsWith(prefix));
+                }
+                if (!skip) {
+                    extracted.push(item);
+                }
+            }
+            else {
+                // If no href filtering, just add the item
+                extracted.push(item);
+            }
+        }
+        return { success: true, count: extracted.length, extracted };
+    }, { ...config, maxItems, includeText, index, visibleOnly });
+}
+export const extractOperation = {
+    id: 'extract',
+    description: 'Extract structured data from elements',
+    requiredCapabilities: ['extract'],
+    run: runExtract,
+};
+//# sourceMappingURL=extract.js.map

package/dist/modules/operations/src/operations/find-child.js

@@ -0,0 +1,17 @@
+export const findChildOperation = {
+    id: 'find-child',
+    description: 'Find child containers',
+    run: async (ctx, config) => {
+        // This is a placeholder operation.
+        // The actual find-child logic is handled by RuntimeController directly.
+        // However, to satisfy OperationExecutor, we provide this definition.
+        // In a full implementation, this could call discovery logic.
+        // Returning success to indicate the operation request was valid.
+        // The side effects (discovery events) are handled by the caller or container system.
+        return {
+            success: true,
+            message: 'find-child operation triggered'
+        };
+    }
+};
+//# sourceMappingURL=find-child.js.map

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

@@ -0,0 +1,138 @@
+async function runHighlight(ctx, config) {
+    if (!config.selector) {
+        throw new Error('highlight operation requires selector');
+    }
+    const style = config.style || '2px solid #fbbc05';
+    const duration = config.duration ?? 1500;
+    const index = Number.isFinite(config.index) ? Math.max(0, Math.floor(config.index)) : null;
+    const target = typeof config.target === 'string' ? config.target.trim() : '';
+    const channel = typeof config.channel === 'string' && config.channel.trim() ? config.channel.trim() : 'container-op';
+    const sticky = config.sticky === true;
+    const visibleOnly = config.visibleOnly === true;
+    return ctx.page.evaluate((data) => {
+        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 allNodes = Array.from(document.querySelectorAll(data.selector));
+        if (!allNodes.length) {
+            return { success: false, error: 'element not found', count: 0 };
+        }
+        const nodes = data.visibleOnly ? allNodes.filter((n) => isVisible(n)) : allNodes;
+        if (!nodes.length) {
+            return { success: false, error: data.visibleOnly ? 'no visible elements found' : 'element not found', count: 0 };
+        }
+        const selected = typeof data.index === 'number'
+            ? (() => {
+                const root = nodes[data.index];
+                if (!root)
+                    return [];
+                let el = root;
+                if (data.target) {
+                    if (data.target === 'self') {
+                        el = root;
+                    }
+                    else if (data.target === 'img') {
+                        el = root.querySelector('img') || root;
+                    }
+                    else {
+                        el = root.querySelector(data.target) || root;
+                    }
+                }
+                return [el];
+            })()
+            : nodes;
+        if (!selected.length) {
+            return { success: false, error: 'element not found', count: 0 };
+        }
+        const first = selected[0];
+        const r = first.getBoundingClientRect();
+        const viewport = { w: window.innerWidth, h: window.innerHeight };
+        const inViewport = r.width > 0 &&
+            r.height > 0 &&
+            r.bottom > 0 &&
+            r.top < viewport.h &&
+            r.right > 0 &&
+            r.left < viewport.w;
+        // 优先使用 runtime overlay（截图可见，且不污染元素 style）
+        try {
+            // @ts-ignore
+            const rt = window.__webautoRuntime;
+            const api = rt?.highlight;
+            if (api && typeof api.highlightElements === 'function') {
+                api.highlightElements(selected, {
+                    channel: data.channel,
+                    style: data.style,
+                    duration: data.duration,
+                    sticky: Boolean(data.sticky),
+                });
+                return {
+                    success: true,
+                    count: selected.length,
+                    rect: { x1: r.left, y1: r.top, x2: r.right, y2: r.bottom },
+                    viewport,
+                    inViewport,
+                    mode: 'overlay',
+                    channel: data.channel,
+                };
+            }
+        }
+        catch {
+            // fallback below
+        }
+        // fallback: element outline (not guaranteed in screenshots on some pages)
+        const cleanups = selected.map((el) => {
+            const originalOutline = el.style?.outline;
+            const originalOutlineOffset = el.style?.outlineOffset;
+            try {
+                el.style.outline = data.style;
+                el.style.outlineOffset = '2px';
+            }
+            catch {
+                // ignore
+            }
+            return () => {
+                try {
+                    el.style.outline = originalOutline;
+                    el.style.outlineOffset = originalOutlineOffset;
+                }
+                catch {
+                    // ignore cleanup errors
+                }
+            };
+        });
+        const cleanup = () => {
+            cleanups.forEach((fn) => {
+                try {
+                    fn();
+                }
+                catch {
+                    // ignore cleanup errors
+                }
+            });
+        };
+        if (data.duration > 0 && !data.sticky) {
+            setTimeout(cleanup, data.duration);
+        }
+        return {
+            success: true,
+            count: selected.length,
+            rect: { x1: r.left, y1: r.top, x2: r.right, y2: r.bottom },
+            viewport,
+            inViewport,
+            mode: 'outline',
+        };
+    }, { selector: config.selector, style, duration, index, target, channel, sticky, visibleOnly });
+}
+export const highlightOperation = {
+    id: 'highlight',
+    description: 'Highlight element using outline',
+    requiredCapabilities: ['highlight'],
+    run: runHighlight,
+};
+//# sourceMappingURL=highlight.js.map

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

@@ -0,0 +1,61 @@
+function delay(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+async function runKey(ctx, config) {
+    const key = String(config.key || '').trim();
+    if (!key) {
+        throw new Error('key operation requires key');
+    }
+    const selector = typeof config.selector === 'string' ? config.selector.trim() : '';
+    const waitAfter = typeof config.wait_after === 'number'
+        ? config.wait_after
+        : typeof config.waitAfter === 'number'
+            ? config.waitAfter
+            : 0;
+    const useSystemMouse = config.useSystemMouse !== false;
+    const protocolMouse = ctx.page?.mouse;
+    if (selector) {
+        const rect = await ctx.page.evaluate((sel) => {
+            const el = document.querySelector(sel);
+            if (!el)
+                return null;
+            const r = el.getBoundingClientRect();
+            const visible = r.width > 0 && r.height > 0 && r.y < window.innerHeight && r.y + r.height > 0;
+            return { x1: r.left, y1: r.top, x2: r.right, y2: r.bottom, visible };
+        }, selector);
+        if (!rect || !rect.visible) {
+            return { success: false, error: 'element not visible' };
+        }
+        const cx = Math.round((rect.x1 + rect.x2) / 2);
+        const cy = Math.round((rect.y1 + rect.y2) / 2);
+        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);
+        }
+        await delay(150);
+    }
+    const keyboard = ctx.page.keyboard;
+    if (!keyboard || typeof keyboard.press !== 'function') {
+        return { success: false, error: 'keyboard press not available' };
+    }
+    await keyboard.press(key);
+    if (waitAfter > 0) {
+        await delay(waitAfter);
+    }
+    return { success: true, inputMode: useSystemMouse ? 'system' : 'protocol' };
+}
+export const keyOperation = {
+    id: 'key',
+    description: 'Press a key using system-level keyboard',
+    requiredCapabilities: [],
+    run: runKey,
+};
+//# sourceMappingURL=key.js.map

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

@@ -0,0 +1,148 @@
+function resolveWaitAfter(config) {
+    const wait = typeof config.waitAfterMs === 'number' ? config.waitAfterMs : config.wait_after_ms;
+    return Number.isFinite(wait) ? Math.max(0, wait) : 0;
+}
+function ensureAbsoluteUrl(raw, base) {
+    if (!raw)
+        return '';
+    if (/^https?:\/\//i.test(raw))
+        return raw;
+    if (base) {
+        try {
+            return new URL(raw, base).toString();
+        }
+        catch {
+            return raw;
+        }
+    }
+    return raw;
+}
+function normalizedIndex(config, ctxIndex) {
+    if (typeof config.match_index === 'number')
+        return Math.max(0, Math.floor(config.match_index));
+    if (typeof config.matchIndex === 'number')
+        return Math.max(0, Math.floor(config.matchIndex));
+    if (typeof ctxIndex === 'number')
+        return Math.max(0, Math.floor(ctxIndex));
+    return 0;
+}
+function parseNoteInfo(url) {
+    const noteMatch = url?.match(/\/explore\/([0-9a-z]+)/i);
+    const xsecMatch = url?.match(/[?&]xsec_token=([^&]+)/i);
+    return {
+        noteId: noteMatch ? noteMatch[1] : '',
+        xsecToken: xsecMatch ? decodeURIComponent(xsecMatch[1]) : '',
+    };
+}
+async function resolveTargetUrl(ctx, config) {
+    if (config.url) {
+        const absolute = ensureAbsoluteUrl(config.url, config.baseUrl || config.base_url);
+        return { url: absolute, ...parseNoteInfo(absolute) };
+    }
+    const scopeSelector = config.scopeSelector || config.scope_selector || config.selector || '';
+    const anchorSelector = config.anchorSelector || config.anchor_selector || '';
+    if (!scopeSelector && !anchorSelector && !config.selector) {
+        throw new Error('navigate operation requires url or selector');
+    }
+    const attr = config.attribute || 'href';
+    const matchIndex = normalizedIndex(config, ctx.node?.index);
+    const evaluation = await ctx.page.evaluate(({ scopeSelector, anchorSelector, attribute, matchIndex }) => {
+        const resolveFromElement = (el) => {
+            if (!el) {
+                return { url: '', noteId: '', xsecToken: '' };
+            }
+            const target = el;
+            let raw = '';
+            if (attribute === 'textContent') {
+                raw = (target.textContent || '').trim();
+            }
+            else if (attribute) {
+                raw = target.getAttribute(attribute) || '';
+                if (!raw && attribute === 'href' && target instanceof HTMLAnchorElement) {
+                    raw = target.href;
+                }
+            }
+            const href = target instanceof HTMLAnchorElement && attribute === 'href' ? target.href : raw;
+            const url = href || raw || '';
+            const noteMatch = url.match(/\/explore\/([0-9a-z]+)/i);
+            const tokenMatch = url.match(/[?&]xsec_token=([^&]+)/i);
+            return {
+                url,
+                noteId: noteMatch ? noteMatch[1] : '',
+                xsecToken: tokenMatch ? decodeURIComponent(tokenMatch[1]) : '',
+            };
+        };
+        const index = Number.isFinite(matchIndex) ? Math.max(0, Number(matchIndex)) : 0;
+        const scopes = scopeSelector ? Array.from(document.querySelectorAll(scopeSelector)) : [];
+        let scope = scopes[index] || scopes[0] || null;
+        if (!scope && anchorSelector) {
+            scope = document.body;
+        }
+        if (!scope) {
+            return { url: '', noteId: '', xsecToken: '' };
+        }
+        if (anchorSelector) {
+            const anchor = scope.matches(anchorSelector)
+                ? scope
+                : scope.querySelector(anchorSelector);
+            return resolveFromElement(anchor);
+        }
+        return resolveFromElement(scope);
+    }, { scopeSelector, anchorSelector, attribute: attr, matchIndex });
+    const absoluteUrl = ensureAbsoluteUrl(evaluation.url, config.baseUrl || config.base_url);
+    if (!absoluteUrl) {
+        throw new Error('navigate: selector did not resolve to a URL');
+    }
+    const info = parseNoteInfo(absoluteUrl);
+    return { url: absoluteUrl, ...info };
+}
+function isXiaohongshuUrl(url) {
+    return /(^https?:\/\/)?(www\.)?xiaohongshu\.com/i.test(url || '');
+}
+function isAllowedXiaohongshuNavigate(url) {
+    // 小红书强规则：禁止通过代码构造/抽取链接进行导航（尤其是 /explore、/search_result）
+    // 仅允许回到站点主页，其他页面必须通过页面内点击/搜索流转生成带 token 的 URL。
+    try {
+        const u = new URL(url);
+        const p = u.pathname || '/';
+        if (p === '/' || p === '' || p === '/explore')
+            return true; // /explore 作为站点入口页允许
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+export async function runNavigateOperation(ctx, config) {
+    const target = await resolveTargetUrl(ctx, config);
+    if (!target.url) {
+        return { success: false, error: 'navigate: empty url' };
+    }
+    if (isXiaohongshuUrl(target.url) && !isAllowedXiaohongshuNavigate(target.url)) {
+        return { success: false, error: `navigate: disabled for xiaohongshu url=${target.url}` };
+    }
+    try {
+        await ctx.page.goto(target.url, { waitUntil: 'domcontentloaded' });
+    }
+    catch (e) {
+        return { success: false, error: `navigate: page.goto failed: ${e?.message || String(e)}` };
+    }
+    const waitAfter = resolveWaitAfter(config);
+    if (waitAfter > 0) {
+        await new Promise((resolve) => setTimeout(resolve, waitAfter));
+    }
+    return {
+        success: true,
+        url: target.url,
+        noteId: target.noteId,
+        xsecToken: target.xsecToken,
+        navigation: { success: true, href: target.url, via: 'page.goto' },
+    };
+}
+export const navigateOperation = {
+    id: 'navigate',
+    description: 'Navigate current page using selector-derived URL or explicit target',
+    requiredCapabilities: ['navigate'],
+    run: runNavigateOperation,
+};
+//# sourceMappingURL=navigate.js.map