@jshookmcp/jshook 0.2.5 → 0.2.7

package/dist/src/modules/collector/DOMInspector.js

@@ -1,554 +0,0 @@
-import { logger } from '../../utils/logger.js';
-export class DOMInspector {
-    collector;
-    cdpSession = null;
-    constructor(collector) {
-        this.collector = collector;
-    }
-    async waitForReadyState(page, timeoutMs = 3000) {
-        const deadline = Date.now() + timeoutMs;
-        let waitedForReadyState = false;
-        let readyState = 'unknown';
-        while (Date.now() <= deadline) {
-            readyState = await page.evaluate(() => document.readyState).catch(() => 'unknown');
-            if (readyState === 'complete') {
-                break;
-            }
-            waitedForReadyState = true;
-            await new Promise((resolve) => setTimeout(resolve, 100));
-        }
-        const frameCount = typeof page.frames === 'function' ? page.frames().length : 1;
-        return { readyState, waitedForReadyState, frameCount };
-    }
-    async querySelector(selector, _getAttributes = true) {
-        try {
-            const page = await this.collector.getActivePage();
-            const elementInfo = await page.evaluate((sel) => {
-                const element = document.querySelector(sel);
-                if (!element) {
-                    return { found: false };
-                }
-                const attributes = {};
-                const attrs = element.attributes;
-                for (let i = 0; i < attrs.length; i++) {
-                    const attr = attrs[i];
-                    if (attr) {
-                        attributes[attr.name] = attr.value;
-                    }
-                }
-                const rect = element.getBoundingClientRect();
-                const boundingBox = {
-                    x: rect.x,
-                    y: rect.y,
-                    width: rect.width,
-                    height: rect.height,
-                };
-                const style = window.getComputedStyle(element);
-                const visible = style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0';
-                return {
-                    found: true,
-                    nodeName: element.nodeName,
-                    attributes,
-                    textContent: element.textContent?.trim() || '',
-                    boundingBox,
-                    visible,
-                };
-            }, selector);
-            logger.info(`querySelector: ${selector} - ${elementInfo.found ? 'found' : 'not found'}`);
-            return elementInfo;
-        }
-        catch (error) {
-            logger.error(`querySelector failed for ${selector}:`, error);
-            return { found: false };
-        }
-    }
-    async querySelectorAll(selector, limit = 50) {
-        try {
-            const page = await this.collector.getActivePage();
-            const readyStateStatus = await this.waitForReadyState(page);
-            const runQuery = async () => page.evaluate((sel, maxLimit) => {
-                const roots = [document];
-                const queue = [document];
-                let shadowRootCount = 0;
-                while (queue.length > 0) {
-                    const root = queue.shift();
-                    if (!root)
-                        continue;
-                    const elements = Array.from(root.querySelectorAll('*'));
-                    for (const element of elements) {
-                        const shadowRoot = element
-                            .shadowRoot;
-                        if (shadowRoot) {
-                            roots.push(shadowRoot);
-                            queue.push(shadowRoot);
-                            shadowRootCount += 1;
-                        }
-                    }
-                }
-                const seen = new Set();
-                const results = [];
-                let totalMatches = 0;
-                for (const root of roots) {
-                    const nodeList = Array.from(root.querySelectorAll(sel));
-                    totalMatches += nodeList.length;
-                    for (const element of nodeList) {
-                        if (seen.has(element)) {
-                            continue;
-                        }
-                        seen.add(element);
-                        const attributes = {};
-                        const attrs = element.attributes;
-                        for (let j = 0; j < attrs.length; j++) {
-                            const attr = attrs[j];
-                            if (attr) {
-                                attributes[attr.name] = attr.value;
-                            }
-                        }
-                        const rect = element.getBoundingClientRect();
-                        const style = window.getComputedStyle(element);
-                        const textContent = element.textContent?.trim() || '';
-                        const truncatedText = textContent.length > 500
-                            ? textContent.substring(0, 500) + '...[truncated]'
-                            : textContent;
-                        results.push({
-                            found: true,
-                            nodeName: element.nodeName,
-                            attributes,
-                            textContent: truncatedText,
-                            boundingBox: {
-                                x: rect.x,
-                                y: rect.y,
-                                width: rect.width,
-                                height: rect.height,
-                            },
-                            visible: style.display !== 'none' &&
-                                style.visibility !== 'hidden' &&
-                                style.opacity !== '0',
-                        });
-                        if (results.length >= maxLimit) {
-                            break;
-                        }
-                    }
-                    if (results.length >= maxLimit) {
-                        break;
-                    }
-                }
-                if (totalMatches > maxLimit) {
-                    console.warn(`[DOMInspector] Found ${totalMatches} elements for "${sel}", limiting to ${maxLimit}`);
-                }
-                return {
-                    elements: results,
-                    diagnostics: {
-                        readyState: document.readyState,
-                        shadowRootCount,
-                    },
-                };
-            }, selector, limit);
-            let result = await runQuery();
-            let retried = false;
-            if (result.elements.length === 0 && result.diagnostics.readyState === 'complete') {
-                retried = true;
-                await new Promise((resolve) => setTimeout(resolve, 500));
-                result = await runQuery();
-            }
-            const diagnostics = {
-                readyState: result.diagnostics.readyState ?? readyStateStatus.readyState,
-                frameCount: readyStateStatus.frameCount,
-                shadowRootCount: result.diagnostics.shadowRootCount ?? 0,
-                retried,
-                waitedForReadyState: readyStateStatus.waitedForReadyState,
-            };
-            logger.info(`querySelectorAll: ${selector} - found ${result.elements.length} elements (limit: ${limit}, readyState: ${diagnostics.readyState}, shadowRoots: ${diagnostics.shadowRootCount}, retried: ${retried})`);
-            return {
-                elements: result.elements,
-                diagnostics,
-            };
-        }
-        catch (error) {
-            logger.error(`querySelectorAll failed for ${selector}:`, error);
-            return {
-                elements: [],
-                diagnostics: {
-                    readyState: 'error',
-                    frameCount: 0,
-                    shadowRootCount: 0,
-                    retried: false,
-                    waitedForReadyState: false,
-                },
-            };
-        }
-    }
-    async getStructure(maxDepth = 3, includeText = true) {
-        try {
-            const page = await this.collector.getActivePage();
-            const structure = await page.evaluate((depth, withText) => {
-                function buildTree(node, currentDepth) {
-                    if (currentDepth > depth) {
-                        return null;
-                    }
-                    const result = {
-                        tag: node.tagName,
-                        id: node.id || undefined,
-                        class: node.className || undefined,
-                    };
-                    if (withText && node.childNodes.length === 1) {
-                        const firstChild = node.childNodes[0];
-                        if (firstChild?.nodeType === 3) {
-                            result.text = node.textContent?.trim();
-                        }
-                    }
-                    const children = [];
-                    const childElements = node.children;
-                    for (let i = 0; i < childElements.length; i++) {
-                        const child = childElements[i];
-                        if (child) {
-                            const childTree = buildTree(child, currentDepth + 1);
-                            if (childTree) {
-                                children.push(childTree);
-                            }
-                        }
-                    }
-                    if (children.length > 0) {
-                        result.children = children;
-                    }
-                    return result;
-                }
-                return buildTree(document.body, 0);
-            }, maxDepth, includeText);
-            logger.info('DOM structure retrieved');
-            return structure;
-        }
-        catch (error) {
-            logger.error('getStructure failed:', error);
-            return null;
-        }
-    }
-    async findClickable(filterText) {
-        try {
-            const page = await this.collector.getActivePage();
-            const readyStateStatus = await this.waitForReadyState(page);
-            const runQuery = async () => page.evaluate((filter) => {
-                const roots = [document];
-                const queue = [document];
-                let shadowRootCount = 0;
-                while (queue.length > 0) {
-                    const root = queue.shift();
-                    if (!root)
-                        continue;
-                    const elements = Array.from(root.querySelectorAll('*'));
-                    for (const element of elements) {
-                        const shadowRoot = element
-                            .shadowRoot;
-                        if (shadowRoot) {
-                            roots.push(shadowRoot);
-                            queue.push(shadowRoot);
-                            shadowRootCount += 1;
-                        }
-                    }
-                }
-                const results = [];
-                const seen = new Set();
-                const normalizedFilter = filter?.toLowerCase();
-                const appendClickable = (element, type, fallbackSelector) => {
-                    if (seen.has(element)) {
-                        return;
-                    }
-                    seen.add(element);
-                    const text = element.textContent?.trim() ||
-                        (element.value ?? '').trim() ||
-                        '';
-                    if (normalizedFilter && !text.toLowerCase().includes(normalizedFilter)) {
-                        return;
-                    }
-                    const rect = element.getBoundingClientRect();
-                    const style = window.getComputedStyle(element);
-                    const visible = style.display !== 'none' &&
-                        style.visibility !== 'hidden' &&
-                        style.opacity !== '0' &&
-                        rect.width > 0 &&
-                        rect.height > 0;
-                    let selector = fallbackSelector;
-                    if (element.id) {
-                        selector = `#${element.id}`;
-                    }
-                    else if (element.className) {
-                        selector = `${fallbackSelector}.${element.className.split(' ')[0]}`;
-                    }
-                    results.push({
-                        selector,
-                        text,
-                        type,
-                        visible,
-                        boundingBox: {
-                            x: rect.x,
-                            y: rect.y,
-                            width: rect.width,
-                            height: rect.height,
-                        },
-                    });
-                };
-                for (const root of roots) {
-                    const buttons = root.querySelectorAll('button, input[type="button"], input[type="submit"], input[type="reset"]');
-                    buttons.forEach((btn) => appendClickable(btn, 'button', btn.tagName.toLowerCase()));
-                    const links = root.querySelectorAll('a[href]');
-                    links.forEach((link) => appendClickable(link, 'link', 'a'));
-                }
-                return {
-                    elements: results,
-                    diagnostics: {
-                        readyState: document.readyState,
-                        shadowRootCount,
-                    },
-                };
-            }, filterText);
-            let result = await runQuery();
-            let retried = false;
-            if (result.elements.length === 0 && result.diagnostics.readyState === 'complete') {
-                retried = true;
-                await new Promise((resolve) => setTimeout(resolve, 500));
-                result = await runQuery();
-            }
-            const diagnostics = {
-                readyState: result.diagnostics.readyState ?? readyStateStatus.readyState,
-                frameCount: readyStateStatus.frameCount,
-                shadowRootCount: result.diagnostics.shadowRootCount ?? 0,
-                retried,
-                waitedForReadyState: readyStateStatus.waitedForReadyState,
-            };
-            logger.info(`findClickable: found ${result.elements.length} elements${filterText ? ` (filtered by: ${filterText})` : ''} (readyState: ${diagnostics.readyState}, shadowRoots: ${diagnostics.shadowRootCount}, retried: ${retried})`);
-            return {
-                elements: result.elements,
-                diagnostics,
-            };
-        }
-        catch (error) {
-            logger.error('findClickable failed:', error);
-            return {
-                elements: [],
-                diagnostics: {
-                    readyState: 'error',
-                    frameCount: 0,
-                    shadowRootCount: 0,
-                    retried: false,
-                    waitedForReadyState: false,
-                },
-            };
-        }
-    }
-    async getComputedStyle(selector) {
-        try {
-            const page = await this.collector.getActivePage();
-            const styles = await page.evaluate((sel) => {
-                const element = document.querySelector(sel);
-                if (!element) {
-                    return null;
-                }
-                const computed = window.getComputedStyle(element);
-                const result = {};
-                const importantProps = [
-                    'display',
-                    'visibility',
-                    'opacity',
-                    'position',
-                    'zIndex',
-                    'width',
-                    'height',
-                    'top',
-                    'left',
-                    'right',
-                    'bottom',
-                    'color',
-                    'backgroundColor',
-                    'fontSize',
-                    'fontFamily',
-                    'border',
-                    'padding',
-                    'margin',
-                    'overflow',
-                ];
-                for (const prop of importantProps) {
-                    result[prop] = computed.getPropertyValue(prop);
-                }
-                return result;
-            }, selector);
-            logger.info(`getComputedStyle: ${selector} - ${styles ? 'found' : 'not found'}`);
-            return styles;
-        }
-        catch (error) {
-            logger.error(`getComputedStyle failed for ${selector}:`, error);
-            return null;
-        }
-    }
-    async waitForElement(selector, timeout = 30000) {
-        try {
-            const page = await this.collector.getActivePage();
-            await page.waitForSelector(selector, { timeout });
-            return await this.querySelector(selector);
-        }
-        catch (error) {
-            logger.error(`waitForElement timeout for ${selector}:`, error);
-            return null;
-        }
-    }
-    async observeDOMChanges(options = {}) {
-        const page = await this.collector.getActivePage();
-        await page.evaluate((opts) => {
-            const targetNode = opts.selector ? document.querySelector(opts.selector) : document.body;
-            if (!targetNode) {
-                console.error('Target node not found for MutationObserver');
-                return;
-            }
-            const observer = new MutationObserver((mutations) => {
-                mutations.forEach((mutation) => {
-                    console.warn('[DOM Change]', {
-                        type: mutation.type,
-                        target: mutation.target,
-                        addedNodes: mutation.addedNodes.length,
-                        removedNodes: mutation.removedNodes.length,
-                        attributeName: mutation.attributeName,
-                    });
-                });
-            });
-            observer.observe(targetNode, {
-                childList: opts.childList !== false,
-                attributes: opts.attributes !== false,
-                characterData: opts.characterData !== false,
-                subtree: opts.subtree !== false,
-            });
-            const typedWindow = window;
-            typedWindow.__domObserver = observer;
-        }, options);
-        logger.info('DOM change observer started');
-    }
-    async stopObservingDOM() {
-        const page = await this.collector.getActivePage();
-        await page.evaluate(() => {
-            const typedWindow = window;
-            const observer = typedWindow.__domObserver;
-            if (observer) {
-                observer.disconnect();
-                delete typedWindow.__domObserver;
-            }
-        });
-        logger.info('DOM change observer stopped');
-    }
-    async findByText(text, tag) {
-        try {
-            const page = await this.collector.getActivePage();
-            const elements = await page.evaluate((searchText, tagName) => {
-                const xpath = tagName
-                    ? `//${tagName}[contains(text(), "${searchText}")]`
-                    : `//*[contains(text(), "${searchText}")]`;
-                const result = document.evaluate(xpath, document, null, XPathResult.ORDERED_NODE_SNAPSHOT_TYPE, null);
-                const matchedElements = [];
-                for (let i = 0; i < Math.min(result.snapshotLength, 100); i++) {
-                    const element = result.snapshotItem(i);
-                    if (!element)
-                        continue;
-                    const rect = element.getBoundingClientRect();
-                    const style = window.getComputedStyle(element);
-                    let selector = element.tagName.toLowerCase();
-                    if (element.id) {
-                        selector = `#${element.id}`;
-                    }
-                    else if (element.className) {
-                        const classes = element.className.split(' ').filter((c) => c);
-                        if (classes.length > 0) {
-                            selector = `${element.tagName.toLowerCase()}.${classes[0]}`;
-                        }
-                    }
-                    matchedElements.push({
-                        found: true,
-                        nodeName: element.tagName,
-                        textContent: element.textContent?.trim(),
-                        selector,
-                        boundingBox: {
-                            x: rect.x,
-                            y: rect.y,
-                            width: rect.width,
-                            height: rect.height,
-                        },
-                        visible: style.display !== 'none' && style.visibility !== 'hidden' && style.opacity !== '0',
-                    });
-                }
-                return matchedElements;
-            }, text, tag);
-            logger.info(`findByText: "${text}" - found ${elements.length} elements`);
-            return elements;
-        }
-        catch (error) {
-            logger.error(`findByText failed for "${text}":`, error);
-            return [];
-        }
-    }
-    async getXPath(selector) {
-        try {
-            const page = await this.collector.getActivePage();
-            const xpath = await page.evaluate((sel) => {
-                const element = document.querySelector(sel);
-                if (!element) {
-                    return null;
-                }
-                const parts = [];
-                let current = element;
-                while (current && current !== document.body && current !== document.documentElement) {
-                    if (current.id) {
-                        parts.unshift(`//*[@id="${current.id}"]`);
-                        return parts.join('');
-                    }
-                    let ix = 0;
-                    const siblings = current.parentElement?.children;
-                    if (siblings) {
-                        for (let i = 0; i < siblings.length; i++) {
-                            const sibling = siblings[i];
-                            if (!sibling)
-                                continue;
-                            if (sibling === current)
-                                break;
-                            if (sibling.tagName === current.tagName)
-                                ix++;
-                        }
-                    }
-                    parts.unshift(`/${current.tagName.toLowerCase()}[${ix + 1}]`);
-                    current = current.parentElement;
-                }
-                return '/html/body' + parts.join('');
-            }, selector);
-            logger.info(`getXPath: ${selector} -> ${xpath}`);
-            return xpath;
-        }
-        catch (error) {
-            logger.error(`getXPath failed for ${selector}:`, error);
-            return null;
-        }
-    }
-    async isInViewport(selector) {
-        try {
-            const page = await this.collector.getActivePage();
-            const inViewport = await page.evaluate((sel) => {
-                const element = document.querySelector(sel);
-                if (!element) {
-                    return false;
-                }
-                const rect = element.getBoundingClientRect();
-                return (rect.top >= 0 &&
-                    rect.left >= 0 &&
-                    rect.bottom <= (window.innerHeight || document.documentElement.clientHeight) &&
-                    rect.right <= (window.innerWidth || document.documentElement.clientWidth));
-            }, selector);
-            logger.info(`isInViewport: ${selector} - ${inViewport}`);
-            return inViewport;
-        }
-        catch (error) {
-            logger.error(`isInViewport failed for ${selector}:`, error);
-            return false;
-        }
-    }
-    async close() {
-        if (this.cdpSession) {
-            await this.cdpSession.detach();
-            this.cdpSession = null;
-            logger.info('DOM Inspector CDP session closed');
-        }
-    }
-}

package/dist/src/modules/collector/PageController.d.ts

@@ -1,128 +0,0 @@
-import type { CodeCollector } from '../collector/CodeCollector.js';
-import type { Page } from 'rebrowser-puppeteer-core';
-export interface NavigationOptions {
-    waitUntil?: 'load' | 'domcontentloaded' | 'networkidle0' | 'networkidle2';
-    timeout?: number;
-}
-export interface ClickOptions {
-    button?: 'left' | 'right' | 'middle';
-    clickCount?: number;
-    delay?: number;
-}
-export interface TypeOptions {
-    delay?: number;
-}
-export interface ScrollOptions {
-    x?: number;
-    y?: number;
-}
-export interface ScreenshotClip {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
-export interface ScreenshotOptions {
-    path?: string;
-    type?: 'png' | 'jpeg';
-    quality?: number;
-    fullPage?: boolean;
-    clip?: ScreenshotClip;
-}
-interface WaitForSelectorElement {
-    tagName: string;
-    id?: string;
-    className?: string;
-    textContent?: string;
-    attributes: Record<string, string>;
-}
-export declare class PageController {
-    private collector;
-    constructor(collector: CodeCollector);
-    navigate(url: string, options?: NavigationOptions): Promise<{
-        url: string;
-        title: string;
-        loadTime: number;
-    }>;
-    reload(options?: NavigationOptions): Promise<void>;
-    goBack(): Promise<void>;
-    goForward(): Promise<void>;
-    click(selector: string, options?: ClickOptions): Promise<void>;
-    type(selector: string, text: string, options?: TypeOptions): Promise<void>;
-    select(selector: string, ...values: string[]): Promise<void>;
-    hover(selector: string): Promise<void>;
-    scroll(options: ScrollOptions): Promise<void>;
-    waitForSelector(selector: string, timeout?: number): Promise<{
-        success: boolean;
-        element?: WaitForSelectorElement | null;
-        message: string;
-    }>;
-    waitForNavigation(timeout?: number): Promise<void>;
-    evaluate<T>(code: string): Promise<T>;
-    getURL(): Promise<string>;
-    getTitle(): Promise<string>;
-    getContent(): Promise<string>;
-    screenshot(options?: ScreenshotOptions): Promise<Buffer>;
-    getPerformanceMetrics(): Promise<{
-        domContentLoaded: number;
-        loadComplete: number;
-        dns: number;
-        tcp: number;
-        request: number;
-        response: number;
-        total: number;
-        resources: number;
-    }>;
-    injectScript(scriptContent: string): Promise<void>;
-    setCookies(cookies: Array<{
-        name: string;
-        value: string;
-        domain?: string;
-        path?: string;
-        expires?: number;
-        httpOnly?: boolean;
-        secure?: boolean;
-        sameSite?: 'Strict' | 'Lax' | 'None';
-    }>): Promise<void>;
-    getCookies(): Promise<import("rebrowser-puppeteer-core").Cookie[]>;
-    clearCookies(): Promise<void>;
-    setViewport(width: number, height: number): Promise<void>;
-    emulateDevice(deviceName: string): Promise<'iPhone' | 'iPad' | 'Android'>;
-    waitForNetworkIdle(timeout?: number): Promise<void>;
-    getLocalStorage(): Promise<Record<string, string>>;
-    setLocalStorage(key: string, value: string): Promise<void>;
-    clearLocalStorage(): Promise<void>;
-    pressKey(key: string): Promise<void>;
-    uploadFile(selector: string, filePath: string): Promise<void>;
-    getAllLinks(): Promise<Array<{
-        text: string;
-        href: string;
-    }>>;
-    getPage(): Promise<Page>;
-}
-export declare function evaluateWithTimeout<Args extends readonly unknown[], Result>(page: Page, pageFunction: (...args: Args) => Result, ...args: Args): Promise<Awaited<Result>>;
-export declare function evaluateWithTimeout(page: Page, pageFunction: string, ...args: readonly unknown[]): Promise<unknown>;
-export declare function evaluateOnNewDocumentWithTimeout<Args extends readonly unknown[], Result>(page: Page, pageFunction: string | ((...args: never[]) => Result), ...args: Args): Promise<unknown>;
-interface CoveragePage {
-    coverage: {
-        startJSCoverage(options?: {
-            resetOnNavigation?: boolean;
-            reportAnonymousScripts?: boolean;
-        }): Promise<void>;
-        stopJSCoverage(): Promise<unknown>;
-        startCSSCoverage(options?: {
-            resetOnNavigation?: boolean;
-        }): Promise<void>;
-        stopCSSCoverage(): Promise<unknown>;
-    };
-}
-export declare function coverageStartJSWithTimeout(page: CoveragePage, options?: {
-    resetOnNavigation?: boolean;
-    reportAnonymousScripts?: boolean;
-}): Promise<void>;
-export declare function coverageStartCSSWithTimeout(page: CoveragePage, options?: {
-    resetOnNavigation?: boolean;
-}): Promise<void>;
-export declare function coverageStopJSWithTimeout(page: CoveragePage): Promise<unknown>;
-export declare function coverageStopCSSWithTimeout(page: CoveragePage): Promise<unknown>;
-export {};