@poolzin/pool-bot 2026.3.22 → 2026.3.23

package/dist/browser/chrome-extension-validator.js

@@ -0,0 +1,406 @@
+/**
+ * Chrome Extension Validator
+ * Validates Chrome extension manifest, options, and background service worker
+ */
+import * as fs from "fs";
+import * as path from "path";
+/**
+ * Validate Chrome extension manifest.json
+ */
+export function validateManifest(manifest) {
+    const errors = [];
+    const warnings = [];
+    // Check manifest_version
+    if (!manifest.manifest_version) {
+        errors.push({
+            severity: "error",
+            field: "manifest_version",
+            message: "manifest_version is required",
+            suggestion: "Use manifest_version: 3 for Chrome extensions",
+        });
+    }
+    else if (manifest.manifest_version !== 3) {
+        warnings.push({
+            severity: "warning",
+            field: "manifest_version",
+            message: `Manifest version ${manifest.manifest_version} detected`,
+            suggestion: "Consider upgrading to manifest_version: 3",
+        });
+    }
+    // Check required fields
+    if (!manifest.name) {
+        errors.push({
+            severity: "error",
+            field: "name",
+            message: "Extension name is required",
+        });
+    }
+    else if (manifest.name.length > 45) {
+        warnings.push({
+            severity: "warning",
+            field: "name",
+            message: "Extension name is too long (max 45 characters)",
+        });
+    }
+    if (!manifest.version) {
+        errors.push({
+            severity: "error",
+            field: "version",
+            message: "Extension version is required",
+            suggestion: "Use semantic versioning (e.g., 1.0.0)",
+        });
+    }
+    else if (!/^\d+\.\d+\.\d+$/.test(manifest.version)) {
+        warnings.push({
+            severity: "warning",
+            field: "version",
+            message: "Version should follow semantic versioning",
+            suggestion: "Use format: major.minor.patch (e.g., 1.0.0)",
+        });
+    }
+    // Check background service worker (Manifest V3)
+    if (manifest.manifest_version === 3) {
+        if (!manifest.background?.service_worker) {
+            errors.push({
+                severity: "error",
+                field: "background.service_worker",
+                message: "Background service worker is required for Manifest V3",
+                suggestion: 'Add background: { service_worker: "background.js" }',
+            });
+        }
+    }
+    // Check action (Manifest V3)
+    if (manifest.manifest_version === 3 && !manifest.action) {
+        warnings.push({
+            severity: "warning",
+            field: "action",
+            message: "No action defined (popup or browser action)",
+            suggestion: 'Add action: { default_popup: "popup.html" }',
+        });
+    }
+    // Check icons
+    if (!manifest.icons) {
+        warnings.push({
+            severity: "warning",
+            field: "icons",
+            message: "No icons defined",
+            suggestion: "Add icons in sizes: 16, 32, 48, 128",
+        });
+    }
+    else {
+        const requiredSizes = ["16", "32", "48", "128"];
+        const availableSizes = Object.keys(manifest.icons);
+        const missingSizes = requiredSizes.filter((size) => !availableSizes.includes(size));
+        if (missingSizes.length > 0) {
+            warnings.push({
+                severity: "warning",
+                field: "icons",
+                message: `Missing icon sizes: ${missingSizes.join(", ")}`,
+            });
+        }
+    }
+    // Check permissions
+    if (manifest.permissions && manifest.permissions.length > 0) {
+        const dangerousPermissions = ["tabs", "history", "bookmarks", "downloads", "management"];
+        const usedDangerous = manifest.permissions.filter((p) => dangerousPermissions.includes(p));
+        if (usedDangerous.length > 0) {
+            warnings.push({
+                severity: "warning",
+                field: "permissions",
+                message: `Using sensitive permissions: ${usedDangerous.join(", ")}`,
+                suggestion: "Ensure these permissions are necessary and justify them in the store listing",
+            });
+        }
+    }
+    // Check host_permissions (Manifest V3)
+    if (manifest.manifest_version === 3 && manifest.host_permissions) {
+        if (manifest.host_permissions.includes("<all_urls>")) {
+            warnings.push({
+                severity: "warning",
+                field: "host_permissions",
+                message: "Using <all_urls> permission",
+                suggestion: "Consider restricting to specific domains",
+            });
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Validate extension file structure
+ */
+export function validateExtensionFiles(extensionDir) {
+    const errors = [];
+    const warnings = [];
+    // Check if directory exists
+    if (!fs.existsSync(extensionDir)) {
+        errors.push({
+            severity: "error",
+            field: "extensionDir",
+            message: `Extension directory does not exist: ${extensionDir}`,
+        });
+        return { valid: false, errors, warnings };
+    }
+    // Check manifest.json
+    const manifestPath = path.join(extensionDir, "manifest.json");
+    if (!fs.existsSync(manifestPath)) {
+        errors.push({
+            severity: "error",
+            field: "manifest.json",
+            message: "manifest.json not found",
+        });
+    }
+    else {
+        try {
+            const manifestContent = fs.readFileSync(manifestPath, "utf-8");
+            const manifest = JSON.parse(manifestContent);
+            const manifestResult = validateManifest(manifest);
+            errors.push(...manifestResult.errors);
+            warnings.push(...manifestResult.warnings);
+            // Check referenced files
+            if (manifest.background?.service_worker) {
+                const bgPath = path.join(extensionDir, manifest.background.service_worker);
+                if (!fs.existsSync(bgPath)) {
+                    errors.push({
+                        severity: "error",
+                        field: "background.service_worker",
+                        message: `Background service worker not found: ${manifest.background.service_worker}`,
+                    });
+                }
+            }
+            if (manifest.action?.default_popup) {
+                const popupPath = path.join(extensionDir, manifest.action.default_popup);
+                if (!fs.existsSync(popupPath)) {
+                    errors.push({
+                        severity: "error",
+                        field: "action.default_popup",
+                        message: `Popup HTML not found: ${manifest.action.default_popup}`,
+                    });
+                }
+            }
+            if (manifest.options_page) {
+                const optionsPath = path.join(extensionDir, manifest.options_page);
+                if (!fs.existsSync(optionsPath)) {
+                    errors.push({
+                        severity: "error",
+                        field: "options_page",
+                        message: `Options page not found: ${manifest.options_page}`,
+                    });
+                }
+            }
+            if (manifest.options_ui?.page) {
+                const optionsPath = path.join(extensionDir, manifest.options_ui.page);
+                if (!fs.existsSync(optionsPath)) {
+                    errors.push({
+                        severity: "error",
+                        field: "options_ui.page",
+                        message: `Options UI page not found: ${manifest.options_ui.page}`,
+                    });
+                }
+            }
+            // Check icons
+            if (manifest.icons) {
+                for (const [size, iconPath] of Object.entries(manifest.icons)) {
+                    const fullPath = path.join(extensionDir, iconPath);
+                    if (!fs.existsSync(fullPath)) {
+                        warnings.push({
+                            severity: "warning",
+                            field: `icons[${size}]`,
+                            message: `Icon not found: ${iconPath}`,
+                        });
+                    }
+                }
+            }
+        }
+        catch (e) {
+            errors.push({
+                severity: "error",
+                field: "manifest.json",
+                message: `Failed to parse manifest.json: ${e.message}`,
+            });
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Validate background service worker syntax
+ */
+export function validateBackgroundWorker(extensionDir, workerFile) {
+    const errors = [];
+    const warnings = [];
+    const workerPath = path.join(extensionDir, workerFile);
+    if (!fs.existsSync(workerPath)) {
+        errors.push({
+            severity: "error",
+            field: "background.service_worker",
+            message: `Service worker file not found: ${workerFile}`,
+        });
+        return { valid: false, errors, warnings };
+    }
+    try {
+        const content = fs.readFileSync(workerPath, "utf-8");
+        // Check for common Manifest V3 patterns
+        if (!content.includes("chrome.runtime.onInstalled")) {
+            warnings.push({
+                severity: "warning",
+                field: "background.service_worker",
+                message: "No onInstalled listener found",
+                suggestion: "Add chrome.runtime.onInstalled listener for initialization",
+            });
+        }
+        if (!content.includes("chrome.runtime.onMessage")) {
+            warnings.push({
+                severity: "warning",
+                field: "background.service_worker",
+                message: "No onMessage listener found",
+                suggestion: "Add chrome.runtime.onMessage listener for communication",
+            });
+        }
+        // Check for Manifest V2 deprecated APIs
+        const deprecatedAPIs = ["chrome.webRequest.onBeforeRequest"];
+        for (const api of deprecatedAPIs) {
+            if (content.includes(api)) {
+                warnings.push({
+                    severity: "warning",
+                    field: "background.service_worker",
+                    message: `Using Manifest V2 API: ${api}`,
+                    suggestion: "Migrate to declarativeNetRequest API",
+                });
+            }
+        }
+        // Check for syntax errors (basic check)
+        try {
+            new Function(content);
+        }
+        catch (e) {
+            // This is expected for service workers with top-level await
+            // Just warn about potential syntax issues
+            if (e.message.includes("await")) {
+                // Top-level await is OK in service workers
+            }
+            else {
+                warnings.push({
+                    severity: "warning",
+                    field: "background.service_worker",
+                    message: `Potential syntax error: ${e.message}`,
+                    suggestion: "Verify JavaScript syntax",
+                });
+            }
+        }
+    }
+    catch (e) {
+        errors.push({
+            severity: "error",
+            field: "background.service_worker",
+            message: `Failed to read service worker: ${e.message}`,
+        });
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Validate options page
+ */
+export function validateOptionsPage(extensionDir, optionsFile) {
+    const errors = [];
+    const warnings = [];
+    const optionsPath = path.join(extensionDir, optionsFile);
+    if (!fs.existsSync(optionsPath)) {
+        errors.push({
+            severity: "error",
+            field: "options_page",
+            message: `Options page not found: ${optionsFile}`,
+        });
+        return { valid: false, errors, warnings };
+    }
+    try {
+        const content = fs.readFileSync(optionsPath, "utf-8");
+        // Check for basic HTML structure
+        if (!content.includes("<!DOCTYPE html>") && !content.includes("<html")) {
+            warnings.push({
+                severity: "warning",
+                field: "options_page",
+                message: "Options page may not be valid HTML",
+                suggestion: "Ensure proper HTML structure",
+            });
+        }
+        // Check for script tag
+        if (!content.includes("<script")) {
+            warnings.push({
+                severity: "warning",
+                field: "options_page",
+                message: "No script tag found in options page",
+                suggestion: "Add JavaScript for options functionality",
+            });
+        }
+        // Check for form elements
+        if (!content.includes("<form") && !content.includes("<input") && !content.includes("<button")) {
+            warnings.push({
+                severity: "warning",
+                field: "options_page",
+                message: "No form elements found in options page",
+                suggestion: "Add form elements for user configuration",
+            });
+        }
+    }
+    catch (e) {
+        errors.push({
+            severity: "error",
+            field: "options_page",
+            message: `Failed to read options page: ${e.message}`,
+        });
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Run all validations
+ */
+export function validateExtension(extensionDir) {
+    const allErrors = [];
+    const allWarnings = [];
+    // Validate file structure
+    const fileResult = validateExtensionFiles(extensionDir);
+    allErrors.push(...fileResult.errors);
+    allWarnings.push(...fileResult.warnings);
+    // If manifest is valid, validate referenced files
+    if (fileResult.valid) {
+        const manifestPath = path.join(extensionDir, "manifest.json");
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+        // Validate background worker
+        if (manifest.background?.service_worker) {
+            const bgResult = validateBackgroundWorker(extensionDir, manifest.background.service_worker);
+            allErrors.push(...bgResult.errors);
+            allWarnings.push(...bgResult.warnings);
+        }
+        // Validate options page
+        if (manifest.options_page) {
+            const optionsResult = validateOptionsPage(extensionDir, manifest.options_page);
+            allErrors.push(...optionsResult.errors);
+            allWarnings.push(...optionsResult.warnings);
+        }
+        if (manifest.options_ui?.page) {
+            const optionsResult = validateOptionsPage(extensionDir, manifest.options_ui.page);
+            allErrors.push(...optionsResult.errors);
+            allWarnings.push(...optionsResult.warnings);
+        }
+    }
+    return {
+        valid: allErrors.length === 0,
+        errors: allErrors,
+        warnings: allWarnings,
+    };
+}

package/dist/browser/chrome-mcp-snapshot.js

@@ -0,0 +1,222 @@
+/**
+ * Chrome MCP Snapshot
+ * Captures comprehensive page state including DOM, network, and console state
+ */
+/**
+ * Capture a comprehensive snapshot of the current page state
+ */
+export async function captureSnapshot(cdp) {
+    const timestamp = Date.now();
+    // Enable required CDP domains
+    await Promise.all([
+        cdp.send("Page.enable"),
+        cdp.send("DOM.enable"),
+        cdp.send("Network.enable"),
+        cdp.send("Console.enable"),
+        cdp.send("Runtime.enable"),
+    ]);
+    // Capture page info
+    const { result: pageInfo } = await cdp.send("Runtime.evaluate", {
+        expression: `({
+      url: window.location.href,
+      title: document.title,
+      loadTime: performance.timing.loadEventEnd - performance.timing.navigationStart,
+      domContentLoaded: performance.timing.domContentLoadedEventEnd - performance.timing.navigationStart
+    })`,
+        returnByValue: true,
+    });
+    // Capture DOM
+    const { root } = await cdp.send("DOM.getDocument", { depth: -1 });
+    const domSnapshot = await captureDOM(cdp, root.nodeId);
+    // Capture network requests
+    const networkRequests = await captureNetwork(cdp);
+    // Capture console messages
+    const consoleMessages = await captureConsole(cdp);
+    // Capture viewport
+    const { visualViewport } = await cdp.send("Page.getLayoutMetrics");
+    return {
+        timestamp,
+        url: pageInfo?.value?.url || "unknown",
+        title: pageInfo?.value?.title || "unknown",
+        dom: domSnapshot,
+        network: networkRequests,
+        console: consoleMessages,
+        viewport: {
+            width: visualViewport.clientWidth,
+            height: visualViewport.clientHeight,
+            deviceScaleFactor: visualViewport.scale,
+        },
+        metadata: {
+            loadTime: pageInfo?.value?.loadTime,
+            domContentLoaded: pageInfo?.value?.domContentLoaded,
+        },
+    };
+}
+/**
+ * Capture DOM structure and interactive elements
+ */
+async function captureDOM(cdp, rootNodeId) {
+    // Get outer HTML
+    const { outerHTML } = await cdp.send("DOM.getOuterHTML", { nodeId: rootNodeId });
+    // Query interactive elements
+    const selectors = [
+        "a",
+        "button",
+        "input",
+        "select",
+        "textarea",
+        '[role="button"]',
+        '[role="link"]',
+        '[role="menuitem"]',
+        "[tabindex]",
+    ];
+    const interactiveElements = [];
+    for (const selector of selectors) {
+        try {
+            const { nodes } = await cdp.send("DOM.querySelectorAll", {
+                nodeId: rootNodeId,
+                selector,
+            });
+            for (const nodeId of nodes || []) {
+                const element = await captureElement(cdp, nodeId);
+                if (element) {
+                    interactiveElements.push(element);
+                }
+            }
+        }
+        catch {
+            // Ignore selector errors
+        }
+    }
+    return {
+        html: outerHTML,
+        nodeCount: interactiveElements.length,
+        interactiveElements,
+    };
+}
+/**
+ * Capture element details
+ */
+async function captureElement(cdp, nodeId) {
+    try {
+        const [attributes, boxModel] = await Promise.all([
+            cdp.send("DOM.getAttributes", { nodeId }),
+            cdp.send("DOM.getBoxModel", { nodeId }).catch(() => null),
+        ]);
+        const attrArray = attributes?.attributes || [];
+        const attrMap = {};
+        for (let i = 0; i < attrArray.length; i += 2) {
+            attrMap[attrArray[i]] = attrArray[i + 1];
+        }
+        const { nodeName } = await cdp.send("DOM.getNodeName", { nodeId });
+        return {
+            tag: nodeName.toLowerCase(),
+            type: attrMap.type,
+            id: attrMap.id,
+            class: attrMap.class,
+            text: attrMap.textContent?.slice(0, 100),
+            href: attrMap.href,
+            role: attrMap.role,
+            bounds: boxModel
+                ? {
+                    x: boxModel.content[0],
+                    y: boxModel.content[1],
+                    width: boxModel.width,
+                    height: boxModel.height,
+                }
+                : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Capture network requests
+ */
+async function captureNetwork(cdp) {
+    const requests = [];
+    const requestFinished = (params) => {
+        const { response, type, timings } = params;
+        if (response) {
+            requests.push({
+                url: response.url,
+                method: params.request?.method || "GET",
+                status: response.status,
+                type: type || "Other",
+                size: response.encodedDataLength || 0,
+                time: timings?.receiveHeadersEnd || 0,
+            });
+        }
+    };
+    cdp.on("Network.requestFinished", requestFinished);
+    // Wait a bit for requests to complete
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    cdp.off("Network.requestFinished", requestFinished);
+    const totalBytes = requests.reduce((sum, r) => sum + r.size, 0);
+    return {
+        requests,
+        totalBytes,
+    };
+}
+/**
+ * Capture console messages
+ */
+async function captureConsole(cdp) {
+    const messages = [];
+    const messageAdded = (params) => {
+        const { message } = params;
+        messages.push({
+            level: message.level || "log",
+            text: message.text || "",
+            timestamp: message.timestamp || Date.now(),
+            source: message.source,
+            line: message.line,
+        });
+    };
+    cdp.on("Console.messageAdded", messageAdded);
+    // Get existing messages
+    try {
+        const { messages: existingMessages } = await cdp.send("Console.getRecentMessages");
+        for (const msg of existingMessages || []) {
+            messages.push({
+                level: msg.level || "log",
+                text: msg.text || "",
+                timestamp: msg.timestamp || Date.now(),
+                source: msg.source,
+                line: msg.line,
+            });
+        }
+    }
+    catch {
+        // Ignore if not available
+    }
+    // Wait a bit for new messages
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    cdp.off("Console.messageAdded", messageAdded);
+    const errors = messages.filter((m) => m.level === "error").length;
+    const warnings = messages.filter((m) => m.level === "warning").length;
+    return {
+        messages,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Serialize snapshot to JSON (safe for storage)
+ */
+export function serializeSnapshot(snapshot) {
+    return JSON.stringify(snapshot, (key, value) => {
+        // Truncate large strings
+        if (typeof value === "string" && value.length > 10000) {
+            return value.slice(0, 10000) + "... [truncated]";
+        }
+        return value;
+    }, 2);
+}
+/**
+ * Deserialize snapshot from JSON
+ */
+export function deserializeSnapshot(json) {
+    return JSON.parse(json);
+}