@poolzin/pool-bot 2026.3.22 → 2026.3.23

package/dist/browser/browser-profile-manager.js

@@ -0,0 +1,319 @@
+/**
+ * Browser Profile Manager
+ *
+ * Manages multiple Chrome profiles with isolated user data directories.
+ * Enables parallel browser sessions with separate cookies, storage, and preferences.
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import playwright from "playwright-core";
+export class BrowserProfileManager {
+    profiles = new Map();
+    activeSessions = new Map();
+    baseDir;
+    IDLE_TIMEOUT_MS;
+    MAX_SESSIONS;
+    cleanupInterval = null;
+    constructor(options) {
+        this.baseDir = options?.baseDir ?? path.join(os.tmpdir(), "poolbot-browser-profiles");
+        this.IDLE_TIMEOUT_MS = options?.idleTimeoutMs ?? 300000; // 5 minutes
+        this.MAX_SESSIONS = options?.maxSessions ?? 10;
+        if (options?.autoCleanup !== false) {
+            this.startCleanupInterval();
+        }
+    }
+    /**
+     * Initialize manager - create base directory
+     */
+    async initialize() {
+        await fs.mkdir(this.baseDir, { recursive: true });
+    }
+    /**
+     * Create a new browser profile
+     */
+    async createProfile(config) {
+        if (this.profiles.has(config.name)) {
+            throw new Error(`Profile ${config.name} already exists`);
+        }
+        const userDataDir = config.userDataDir ?? path.join(this.baseDir, config.name);
+        await fs.mkdir(userDataDir, { recursive: true });
+        const profile = {
+            ...config,
+            userDataDir,
+            preferences: {
+                // Default preferences
+                "download.default_directory": path.join(userDataDir, "Downloads"),
+                "plugins.always_open_pdf_externally": true,
+                credentials_enable_service: false,
+                "profile.password_manager_enabled": false,
+                "safebrowsing.enabled": true,
+                ...config.preferences,
+            },
+        };
+        this.profiles.set(config.name, profile);
+        await this.writePreferences(profile);
+        return profile;
+    }
+    /**
+     * Get profile by name
+     */
+    getProfile(name) {
+        return this.profiles.get(name);
+    }
+    /**
+     * Launch browser with specified profile
+     */
+    async launchProfile(profileName) {
+        const profile = this.profiles.get(profileName);
+        if (!profile) {
+            throw new Error(`Profile ${profileName} not found`);
+        }
+        // Check if session already exists
+        const existing = this.activeSessions.get(profileName);
+        if (existing) {
+            existing.lastActivity = Date.now();
+            return existing;
+        }
+        // Evict oldest session if at capacity
+        if (this.activeSessions.size >= this.MAX_SESSIONS) {
+            await this.evictOldestSession();
+        }
+        // Launch browser
+        const context = await playwright.chromium.launchPersistentContext(profile.userDataDir, {
+            headless: profile.headless ?? false,
+            viewport: profile.viewport ?? { width: 1280, height: 720 },
+            args: [
+                "--disable-web-security",
+                "--disable-features=IsolateOrigins,site-per-process",
+                "--disable-site-isolation-trials",
+                "--disable-blink-features=AutomationControlled",
+                "--no-first-run",
+                "--no-default-browser-check",
+                "--disable-dev-shm-usage",
+                "--disable-accelerated-2d-canvas",
+                "--disable-gpu",
+            ],
+            proxy: profile.proxy
+                ? {
+                    server: `${profile.proxy.host}:${profile.proxy.port}`,
+                    username: profile.proxy.username,
+                    password: profile.proxy.password,
+                }
+                : undefined,
+            ...profile.preferences,
+        });
+        const session = {
+            profile,
+            context,
+            browser: context.pages()[0]?.context().browser(),
+            startTime: Date.now(),
+            lastActivity: Date.now(),
+        };
+        this.activeSessions.set(profileName, session);
+        return session;
+    }
+    /**
+     * Close a profile session
+     */
+    async closeProfile(profileName) {
+        const session = this.activeSessions.get(profileName);
+        if (session) {
+            await session.context.close();
+            this.activeSessions.delete(profileName);
+        }
+    }
+    /**
+     * Get active session
+     */
+    getSession(profileName) {
+        return this.activeSessions.get(profileName);
+    }
+    /**
+     * Get all active sessions
+     */
+    getActiveSessions() {
+        return Array.from(this.activeSessions.values());
+    }
+    /**
+     * Update session activity timestamp
+     */
+    touchSession(profileName) {
+        const session = this.activeSessions.get(profileName);
+        if (session) {
+            session.lastActivity = Date.now();
+        }
+    }
+    /**
+     * Get statistics
+     */
+    getStats() {
+        const sessions = Array.from(this.activeSessions.values());
+        const oldest = sessions.length > 0 ? Math.min(...sessions.map((s) => s.startTime)) : null;
+        return {
+            totalProfiles: this.profiles.size,
+            activeSessions: sessions.length,
+            oldestSession: oldest,
+        };
+    }
+    /**
+     * Cleanup idle sessions
+     */
+    async cleanupIdleSessions() {
+        const now = Date.now();
+        let removed = 0;
+        for (const [name, session] of this.activeSessions.entries()) {
+            if (now - session.lastActivity > this.IDLE_TIMEOUT_MS) {
+                await this.closeProfile(name);
+                removed++;
+            }
+        }
+        return removed;
+    }
+    /**
+     * Destroy manager and close all sessions
+     */
+    async destroy() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        const closePromises = Array.from(this.activeSessions.keys()).map((name) => this.closeProfile(name).catch(console.error));
+        await Promise.all(closePromises);
+        this.profiles.clear();
+    }
+    async writePreferences(profile) {
+        if (!profile.userDataDir)
+            return;
+        const preferencesPath = path.join(profile.userDataDir, "Default", "Preferences");
+        await fs.mkdir(path.dirname(preferencesPath), { recursive: true });
+        const preferences = {
+            profile: {
+                default_content_setting_values: {
+                    notifications: 2, // Block notifications
+                    geolocation: 2, // Block geolocation
+                },
+            },
+            ...profile.preferences,
+        };
+        await fs.writeFile(preferencesPath, JSON.stringify(preferences, null, 2));
+    }
+    async evictOldestSession() {
+        let oldestName = null;
+        let oldestTime = Infinity;
+        for (const [name, session] of this.activeSessions.entries()) {
+            if (session.startTime < oldestTime) {
+                oldestTime = session.startTime;
+                oldestName = name;
+            }
+        }
+        if (oldestName) {
+            await this.closeProfile(oldestName);
+        }
+    }
+    startCleanupInterval() {
+        const cleanupIntervalMs = Math.max(30000, this.IDLE_TIMEOUT_MS / 10);
+        this.cleanupInterval = setInterval(() => {
+            this.cleanupIdleSessions().catch(console.error);
+        }, cleanupIntervalMs);
+        this.cleanupInterval.unref();
+    }
+}
+/**
+ * Navigation Guards for safe browsing
+ */
+export class GuardedNavigator {
+    blockedUrls;
+    allowedDomains;
+    maxRedirects;
+    timeout;
+    constructor(options) {
+        this.blockedUrls = options?.blockedUrls ?? [
+            /file:\/\/\//,
+            /chrome:\/\//,
+            /chrome-extension:\/\//,
+            /about:/,
+        ];
+        this.allowedDomains = new Set(options?.allowedDomains ?? []);
+        this.maxRedirects = options?.maxRedirects ?? 5;
+        this.timeout = options?.timeout ?? 30000;
+    }
+    /**
+     * Navigate with security guards
+     */
+    async navigate(context, url) {
+        try {
+            // Validate URL
+            const parsed = new URL(url);
+            if (!this.isAllowedDomain(parsed.hostname)) {
+                return {
+                    success: false,
+                    finalUrl: url,
+                    status: 0,
+                    redirects: 0,
+                    error: `Domain ${parsed.hostname} not in allowlist`,
+                };
+            }
+            if (this.isBlockedUrl(url)) {
+                return {
+                    success: false,
+                    finalUrl: url,
+                    status: 0,
+                    redirects: 0,
+                    error: `URL matches blocked pattern`,
+                };
+            }
+            // Navigate with timeout
+            const page = await context.newPage();
+            let redirects = 0;
+            let currentUrl = url;
+            const response = await page.goto(url, {
+                waitUntil: "networkidle",
+                timeout: this.timeout,
+            });
+            // Track redirects
+            while (currentUrl !== url && redirects < this.maxRedirects) {
+                redirects++;
+                currentUrl = page.url();
+                await page.waitForTimeout(100);
+            }
+            if (redirects >= this.maxRedirects) {
+                await page.close();
+                return {
+                    success: false,
+                    finalUrl: page.url(),
+                    status: 0,
+                    redirects,
+                    error: `Too many redirects (${redirects})`,
+                };
+            }
+            const status = response?.status() ?? 0;
+            const finalUrl = page.url();
+            // Don't close page - let caller manage it
+            return {
+                success: status >= 200 && status < 400,
+                finalUrl,
+                status,
+                redirects,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                finalUrl: url,
+                status: 0,
+                redirects: 0,
+                error: error.message,
+            };
+        }
+    }
+    isAllowedDomain(hostname) {
+        if (this.allowedDomains.size === 0) {
+            return true; // No restrictions
+        }
+        return this.allowedDomains.has(hostname);
+    }
+    isBlockedUrl(url) {
+        return this.blockedUrls.some((re) => re.test(url));
+    }
+}

package/dist/browser/cdp-proxy-bypass.js

@@ -0,0 +1,129 @@
+/**
+ * Proxy bypass for CDP (Chrome DevTools Protocol) localhost connections.
+ *
+ * When HTTP_PROXY / HTTPS_PROXY / ALL_PROXY environment variables are set,
+ * CDP connections to localhost/127.0.0.1 can be incorrectly routed through
+ * the proxy, causing browser control to fail.
+ */
+import http from "node:http";
+import https from "node:https";
+import { isLoopbackHost } from "../gateway/net.js";
+import { hasProxyEnvConfigured } from "../infra/net/proxy-env.js";
+/** HTTP agent that never uses a proxy — for localhost CDP connections. */
+const directHttpAgent = new http.Agent();
+const directHttpsAgent = new https.Agent();
+/**
+ * Returns a plain (non-proxy) agent for WebSocket or HTTP connections
+ * when the target is a loopback address. Returns `undefined` otherwise
+ * so callers fall through to their default behaviour.
+ */
+export function getDirectAgentForCdp(url) {
+    try {
+        const parsed = new URL(url);
+        if (isLoopbackHost(parsed.hostname)) {
+            return parsed.protocol === "https:" || parsed.protocol === "wss:"
+                ? directHttpsAgent
+                : directHttpAgent;
+        }
+    }
+    catch {
+        // not a valid URL — let caller handle it
+    }
+    return undefined;
+}
+/**
+ * Returns `true` when any proxy-related env var is set that could
+ * interfere with loopback connections.
+ */
+export function hasProxyEnv() {
+    return hasProxyEnvConfigured();
+}
+const LOOPBACK_ENTRIES = "localhost,127.0.0.1,[::1]";
+function noProxyAlreadyCoversLocalhost() {
+    const current = process.env.NO_PROXY || process.env.no_proxy || "";
+    return (current.includes("localhost") && current.includes("127.0.0.1") && current.includes("[::1]"));
+}
+export async function withNoProxyForLocalhost(fn) {
+    return await withNoProxyForCdpUrl("http://127.0.0.1", fn);
+}
+function isLoopbackCdpUrl(url) {
+    try {
+        return isLoopbackHost(new URL(url).hostname);
+    }
+    catch {
+        return false;
+    }
+}
+class NoProxyLeaseManager {
+    leaseCount = 0;
+    snapshot = null;
+    acquire(url) {
+        if (!isLoopbackCdpUrl(url) || !hasProxyEnv()) {
+            return null;
+        }
+        if (this.leaseCount === 0 && !noProxyAlreadyCoversLocalhost()) {
+            const noProxy = process.env.NO_PROXY;
+            const noProxyLower = process.env.no_proxy;
+            const current = noProxy || noProxyLower || "";
+            const applied = current ? `${current},${LOOPBACK_ENTRIES}` : LOOPBACK_ENTRIES;
+            process.env.NO_PROXY = applied;
+            process.env.no_proxy = applied;
+            this.snapshot = { noProxy, noProxyLower, applied };
+        }
+        this.leaseCount += 1;
+        let released = false;
+        return () => {
+            if (released) {
+                return;
+            }
+            released = true;
+            this.release();
+        };
+    }
+    release() {
+        if (this.leaseCount <= 0) {
+            return;
+        }
+        this.leaseCount -= 1;
+        if (this.leaseCount > 0 || !this.snapshot) {
+            return;
+        }
+        const { noProxy, noProxyLower, applied } = this.snapshot;
+        const currentNoProxy = process.env.NO_PROXY;
+        const currentNoProxyLower = process.env.no_proxy;
+        const untouched = currentNoProxy === applied &&
+            (currentNoProxyLower === applied || currentNoProxyLower === undefined);
+        if (untouched) {
+            if (noProxy !== undefined) {
+                process.env.NO_PROXY = noProxy;
+            }
+            else {
+                delete process.env.NO_PROXY;
+            }
+            if (noProxyLower !== undefined) {
+                process.env.no_proxy = noProxyLower;
+            }
+            else {
+                delete process.env.no_proxy;
+            }
+        }
+        this.snapshot = null;
+    }
+}
+const noProxyLeaseManager = new NoProxyLeaseManager();
+/**
+ * Scoped NO_PROXY bypass for loopback CDP URLs.
+ *
+ * This wrapper only mutates env vars for loopback destinations. On restore,
+ * it avoids clobbering external NO_PROXY changes that happened while calls
+ * were in-flight.
+ */
+export async function withNoProxyForCdpUrl(url, fn) {
+    const release = noProxyLeaseManager.acquire(url);
+    try {
+        return await fn();
+    }
+    finally {
+        release?.();
+    }
+}

package/dist/browser/cdp-timeouts.js

@@ -0,0 +1,41 @@
+export const CDP_HTTP_REQUEST_TIMEOUT_MS = 1500;
+export const CDP_WS_HANDSHAKE_TIMEOUT_MS = 5000;
+export const CDP_JSON_NEW_TIMEOUT_MS = 1500;
+export const CHROME_REACHABILITY_TIMEOUT_MS = 500;
+export const CHROME_WS_READY_TIMEOUT_MS = 800;
+export const CHROME_BOOTSTRAP_PREFS_TIMEOUT_MS = 10_000;
+export const CHROME_BOOTSTRAP_EXIT_TIMEOUT_MS = 5000;
+export const CHROME_LAUNCH_READY_WINDOW_MS = 15_000;
+export const CHROME_LAUNCH_READY_POLL_MS = 200;
+export const CHROME_STOP_TIMEOUT_MS = 2500;
+export const CHROME_STOP_PROBE_TIMEOUT_MS = 200;
+export const CHROME_STDERR_HINT_MAX_CHARS = 2000;
+export const PROFILE_HTTP_REACHABILITY_TIMEOUT_MS = 300;
+export const PROFILE_WS_REACHABILITY_MIN_TIMEOUT_MS = 200;
+export const PROFILE_WS_REACHABILITY_MAX_TIMEOUT_MS = 2000;
+export const PROFILE_ATTACH_RETRY_TIMEOUT_MS = 1200;
+export const PROFILE_POST_RESTART_WS_TIMEOUT_MS = 600;
+function normalizeTimeoutMs(value) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return undefined;
+    }
+    return Math.max(1, Math.floor(value));
+}
+export function resolveCdpReachabilityTimeouts(params) {
+    const normalized = normalizeTimeoutMs(params.timeoutMs);
+    if (params.profileIsLoopback) {
+        const httpTimeoutMs = normalized ?? PROFILE_HTTP_REACHABILITY_TIMEOUT_MS;
+        const wsTimeoutMs = Math.max(PROFILE_WS_REACHABILITY_MIN_TIMEOUT_MS, Math.min(PROFILE_WS_REACHABILITY_MAX_TIMEOUT_MS, httpTimeoutMs * 2));
+        return { httpTimeoutMs, wsTimeoutMs };
+    }
+    if (normalized !== undefined) {
+        return {
+            httpTimeoutMs: Math.max(normalized, params.remoteHttpTimeoutMs),
+            wsTimeoutMs: Math.max(normalized * 2, params.remoteHandshakeTimeoutMs),
+        };
+    }
+    return {
+        httpTimeoutMs: params.remoteHttpTimeoutMs,
+        wsTimeoutMs: params.remoteHandshakeTimeoutMs,
+    };
+}