@tocha688/browser 1.0.2 → 1.0.4

package/src/core/launcher.ts

@@ -1,45 +0,0 @@
-import path from "path";
-import { chromium } from "patchright-core";
-import { AutoHelper } from "../actions/auto";
-import type { BrowserStartOptions, ProxyServerResult, StartBrowserFn } from "../types";
-
-export function makeUniqueBrowserConfig() {
-  const sessionId = `${Date.now()}-${Math.random().toString(36).slice(2)}`;
-  const userDataDir = path.join(process.cwd(), "tmps", `brw-session-${sessionId}`);
-  return { sessionId, userDataDir };
-}
-
-
-export async function getBrowserWebSocketUrl(port: number): Promise<string> {
-  const res = await fetch(`http://127.0.0.1:${port}/json/version`).then(x => x.json()) as any
-  return res?.webSocketDebuggerUrl || "";
-}
-
-
-export async function createBrowser(startBrowserMain: StartBrowserFn, opts: BrowserStartOptions) {
-  const brwMain = await startBrowserMain({ ...opts });
-  const wsUrl = await getBrowserWebSocketUrl(brwMain.port);
-  if (!wsUrl) {
-    brwMain.close();
-    throw new Error("无法获取浏览器WebSocket URL");
-  }
-  try {
-    // console.log(wsUrl)
-    const brw = await chromium.connectOverCDP(wsUrl);
-    const page = brw.contexts()[0]?.pages()?.[0] ?? (await brw.newPage());
-    page.setDefaultNavigationTimeout(60000);
-    page.setDefaultTimeout(60000);
-    const auto = new AutoHelper(page);
-    (brw as any)._hk_close = brw.close;
-    brw.close = async function () {
-      await (brw as any)._hk_close();
-      await brwMain.close();
-    }
-    return { page, auto, brw }
-  } catch (e) {
-    console.log(e)
-    await brwMain.close();
-    return await createBrowser(startBrowserMain, opts);
-  }
-}
-

package/src/core/pool.ts

@@ -1,70 +0,0 @@
-import { createPool, Pool } from 'generic-pool';
-import type { BrowserStartOptions, StartBrowserFn } from '../types';
-import { createBrowser } from './launcher';
-import type { Browser, Page } from 'patchright-core';
-import type { AutoHelper } from '../actions/auto';
-
-export interface PoolOptions {
-    min?: number;
-    max?: number;
-    testOnBorrow?: boolean;
-    idleTimeoutMillis?: number;
-}
-
-export interface PooledBrowser {
-    page: Page;
-    auto: AutoHelper;
-    brw: Browser;
-    release: () => Promise<void>;
-}
-
-export class BrowserPool {
-    private pool: Pool<Awaited<ReturnType<typeof createBrowser>>>;
-
-    constructor(
-        private startFn: StartBrowserFn,
-        private opts: BrowserStartOptions,
-        poolOpts: PoolOptions = {}
-    ) {
-        this.pool = createPool({
-            create: async () => {
-                return await createBrowser(this.startFn, this.opts);
-            },
-            destroy: async (client) => {
-                await client.brw.close();
-            },
-            validate: async (client) => {
-                return client.brw.isConnected();
-            }
-        }, {
-            min: poolOpts.min ?? 1,
-            max: poolOpts.max ?? 5,
-            testOnBorrow: poolOpts.testOnBorrow ?? true,
-            idleTimeoutMillis: poolOpts.idleTimeoutMillis ?? 30000,
-        });
-    }
-
-    async acquire(): Promise<PooledBrowser> {
-        const client = await this.pool.acquire();
-        return {
-            ...client,
-            release: async () => {
-                await this.pool.release(client);
-            }
-        };
-    }
-
-    async drain() {
-        await this.pool.drain();
-        await this.pool.clear();
-    }
-    
-    async use<T>(fn: (browser: PooledBrowser) => Promise<T>): Promise<T> {
-        const resource = await this.acquire();
-        try {
-            return await fn(resource);
-        } finally {
-            await resource.release();
-        }
-    }
-}

package/src/human/mouse.ts

@@ -1,308 +0,0 @@
-// const { Bezier } = require('bezier-js');
-// const { sleep } = require('timers/promises');
-import { sleep } from '@tocha688/utils';
-import { rInt } from '@tocha688/utils/random';
-import { Bezier } from 'bezier-js';
-import type { Locator, Page } from 'patchright-core';
-
-/** 坐标点定义 */
-type Point = {
-    /** X坐标 */
-    x: number;
-    /** Y坐标 */
-    y: number;
-};
-
-/** 范围定义，用于指定元素内的随机点范围 */
-type Range = {
-    /** 最小边界比例 (0-1) */
-    min?: number;
-    /** 最大边界比例 (0-1) */
-    max?: number;
-};
-
-/** 鼠标移动配置 */
-type Config = {
-    /** 最小移动步数 */
-    minSteps: number;
-    /** 最大移动步数 */
-    maxSteps: number;
-};
-
-/** 延迟和移动选项 */
-type DelayOptions = {
-    /** 移动步数，覆盖默认配置 */
-    steps?: number;
-    /** 移动速度 (0-1)，越大越快 */
-    speed?: number;
-    /** 随机性 (0-1)，越大路径越随机 */
-    randomness?: number;
-};
-
-/** 移动到元素的选项，结合了延迟选项和范围选项 */
-type MoveOptions = DelayOptions & Range;
-
-/** 鼠标按键类型 */
-type MouseButton = 'left' | 'right' | 'middle';
-
-/** 点击选项 */
-export type ClickOptions = DelayOptions & {
-    /** 是否执行双击 */
-    doubleClick?: boolean;
-    /** 鼠标按键 */
-    button?: MouseButton;
-};
-
-/** 点击元素的选项，结合了点击选项和范围选项 */
-type ClickElementOptions = ClickOptions & Range;
-
-/**
- * 模拟真人鼠标移动和点击的类
- * 使用贝塞尔曲线生成自然的鼠标轨迹，避免被检测为机器人
- */
-export class HumanMouse {
-    /** Playwright页面实例 */
-    page: Page;
-    /** 当前鼠标位置 */
-    currentPosition: Point = { x: 0, y: 0 };
-    /** 移动配置 */
-    config: Config = { minSteps: 15, maxSteps: 50 };
-
-    /**
-     * 构造函数
-     * @param page Playwright页面实例
-     * @param config 可选的配置参数
-     */
-    constructor(page: Page, config: Partial<Config> = {}) {
-        this.page = page;
-        this.currentPosition = { x: 0, y: 0 };
-        this.config = {
-            minSteps: 15,
-            maxSteps: 50,
-            ...config
-        };
-    }
-
-    /**
-     * 生成随机步数
-     * @returns 在配置范围内的随机步数
-     */
-    private _randomSteps(): number {
-        return Math.floor(Math.random() *
-            (this.config.maxSteps - this.config.minSteps)) + this.config.minSteps;
-    }
-
-    /**
-     * 计算元素内的随机点
-     * @param el 目标元素
-     * @param options 范围选项
-     * @returns 元素内的随机坐标点
-     */
-    private async _toPoint(el: Locator, options?: Range): Promise<Point> {
-        const { min = 0.2, max = 0.8 } = options || {};
-        const box = await el.boundingBox();
-        if (!box) {
-            throw new Error('Element has no bounding box');
-        }
-        return {
-            x: box.x + box.width * (min + (Math.random() * (max - min))),
-            y: box.y + box.height * (min + (Math.random() * (max - min)))
-        };
-    }
-
-    /**
-     * 模拟真人鼠标绝对移动
-     * @param x 目标X坐标
-     * @param y 目标Y坐标
-     * @param options 移动选项
-     */
-    async moveTo(x: number, y: number, options: DelayOptions = {}): Promise<void> {
-        const { speed = 0.5, randomness = 0.3 } = options;
-        const start = this.currentPosition;
-        const end = { x, y };
-        // 生成贝塞尔曲线控制点
-        const controlPoints = this.generateControlPoints(start, end, randomness);
-        //@ts-ignore
-        const curve = new Bezier(...controlPoints);
-        const steps = options.steps || this._randomSteps();
-        const points = curve.getLUT(steps);
-
-        for (let i = 0; i < points.length; i++) {
-            const point = points[i] as Point;
-            const delay = this.getDynamicDelay(i, points.length, speed);
-
-            await this.page.mouse.move(point.x, point.y);
-            await sleep(delay);
-        }
-        this.currentPosition = end;
-    }
-
-    /**
-     * 模拟真人鼠标移动到指定元素
-     * @param el 目标元素
-     * @param options 移动和范围选项
-     */
-    async moveToEl(el: Locator, options: MoveOptions = {}): Promise<void> {
-        const point = await this._toPoint(el, options);
-        await this.moveTo(point.x, point.y, options);
-    }
-
-    /**
-     * 模拟真人鼠标相对移动
-     * @param deltaX X轴偏移量
-     * @param deltaY Y轴偏移量
-     * @param options 移动和范围选项
-     */
-    async moveBy(deltaX: number, deltaY: number, options: MoveOptions = {}): Promise<void> {
-        const targetX = this.currentPosition.x + deltaX;
-        const targetY = this.currentPosition.y + deltaY;
-        return this.moveTo(targetX, targetY, options);
-    }
-
-    async scrollBy(deltaY: number, options: DelayOptions = {}): Promise<void> {
-        const { speed = 0.5, randomness = 0.3 } = options;
-        const steps = options.steps || this._randomSteps();
-        const baseStep = deltaY / steps;
-        for (let i = 0; i < steps; i++) {
-            const jitter = baseStep * (Math.random() - 0.5) * randomness;
-            const stepY = baseStep + jitter;
-            //@ts-ignore
-            await this.page.evaluate(`(y) => { window.scrollBy(0, y); }`, stepY);
-            const delay = this.getDynamicDelay(i, steps, speed);
-            await sleep(delay);
-        }
-    }
-
-    async scrollTo(y: number, options: DelayOptions = {}): Promise<void> {
-        const current = await this.page.evaluate(`() => window.scrollY || document.documentElement.scrollTop || 0`) as number;
-        const delta = y - current;
-        if (Math.abs(delta) < 1) return;
-        await this.scrollBy(delta, options);
-    }
-
-    async scrollToEl(el: Locator, options: DelayOptions = {}): Promise<void> {
-        const viewport = this.page.viewportSize();
-        //@ts-ignore
-        const viewportHeight = viewport?.height ?? await this.page.evaluate(`() => window.innerHeight`) as any;
-        const metrics = await el.evaluate(`(node) => {
-            const rect = node.getBoundingClientRect();
-            return { top: rect.top + window.scrollY, height: rect.height };
-        }`) as any;
-        const target = Math.max(0, metrics.top - viewportHeight * 0.3);
-        await this.scrollTo(target, options);
-    }
-
-    /**
-     * 模拟真人鼠标单击
-     * @param x 目标X坐标
-     * @param y 目标Y坐标
-     * @param options 点击选项
-     */
-    async click(x: number, y: number, options: ClickOptions = {}): Promise<void> {
-        const { doubleClick = false, button = 'left' } = options;
-        await this.moveTo(x, y, {
-            steps: options.steps,
-            speed: options.speed,
-            randomness: options.randomness
-        });
-        await this.page.mouse.down({ button });
-        await sleep(rInt(50, 150));
-        await this.page.mouse.up({ button });
-
-        if (doubleClick) {
-            await sleep(rInt(100, 300));
-            await this.page.mouse.down({ button });
-            await sleep(rInt(50, 150));
-            await this.page.mouse.up({ button });
-        }
-    }
-
-    /**
-     * 模拟真人鼠标单击指定元素
-     * @param el 目标元素
-     * @param options 点击和范围选项
-     */
-    async clickEl(el: Locator, options: ClickElementOptions = {}): Promise<void> {
-        try {
-            const point = await this._toPoint(el, options);
-            await this.click(point.x, point.y, options);
-        } catch (err) {
-            console.log('clickEl err: ', err, 'el: ', el);
-        }
-    }
-
-    /**
-     * 生成贝塞尔曲线控制点
-     * @param start 起始点
-     * @param end 终点
-     * @param randomness 随机性程度
-     * @returns 四个控制点组成的数组
-     */
-    generateControlPoints(start: Point, end: Point, randomness: number): Point[] {
-        const distance = Math.hypot(end.x - start.x, end.y - start.y);
-        const cp1 = {
-            x: start.x + (end.x - start.x) * 0.3 + (Math.random() - 0.5) * distance * randomness,
-            y: start.y + (end.y - start.y) * 0.3 + (Math.random() - 0.5) * distance * randomness
-        };
-        const cp2 = {
-            x: end.x - (end.x - start.x) * 0.3 + (Math.random() - 0.5) * distance * randomness,
-            y: end.y - (end.y - start.y) * 0.3 + (Math.random() - 0.5) * distance * randomness
-        };
-        return [start, cp1, cp2, end];
-    }
-
-    /**
-     * 计算动态延迟，模拟加速减速效果
-     * @param index 当前步骤索引
-     * @param totalPoints 总步数
-     * @param speed 速度参数
-     * @returns 延迟时间（毫秒）
-     */
-    getDynamicDelay(index: number, totalPoints: number, speed: number): number {
-        // 模拟加速减速效果
-        const progress = index / totalPoints;
-        const baseDelay = 10 + (1 - speed) * 50;
-        return Math.max(10, baseDelay * (1 - Math.sin(progress * Math.PI)) * 0.5);
-    }
-
-    /**
-     * 生成指定范围内的随机延迟
-     * @param min 最小延迟（毫秒）
-     * @param max 最大延迟（毫秒）
-     * @returns 随机延迟时间（毫秒）
-     */
-    getRandomDelay(min = 20, max = 100): number {
-        return Math.floor(Math.random() * (max - min + 1)) + min;
-    }
-
-    /**
-     * 在页面上显示鼠标轨迹，用于调试
-     * 会在页面上添加一个红色小点跟随鼠标移动
-     */
-    async showCursor(): Promise<void> {
-        await this.page.addInitScript({
-            content: `
-                let dot;
-                document.addEventListener('mousemove', (e) => {
-                    if (!dot) {
-                        dot = document.createElement('div');
-                        Object.assign(dot.style, {
-                            position: 'fixed',
-                            width: '5px',
-                            height: '5px',
-                            borderRadius: '50%',
-                            backgroundColor: 'red',
-                            pointerEvents: 'none',
-                            zIndex: 999999
-                        });
-                        document.body.appendChild(dot);
-                    }
-                    dot.style.left = e.clientX + 'px';
-                    dot.style.top = e.clientY + 'px';
-                });
-            `
-        });
-    }
-}
-
-export default HumanMouse;

package/src/index.ts

@@ -1,13 +0,0 @@
-export * from "./actions";
-export * from "./core/config";
-export * from "./core/launcher";
-export * from "./core/pool";
-export * from "./human/mouse";
-export * from "./network/cache";
-export * from "./network/resource";
-export * from "./providers/local";
-export * from "./providers/adspower";
-export * from "./providers/ok";
-export * from "./providers/base";
-export * from "./types";
-export * from "./const/browser";

package/src/network/cache.ts

@@ -1,130 +0,0 @@
-/**
- * 用于浏览器缓存
- */
-
-import { type Page } from "patchright-core";
-import fs from "fs";
-import path from "path";
-import { createHash } from "crypto";
-import { BrowserCachePath } from "../core/config";
-
-function getCachePath(url: string, cachePath: string) {
-    const hash = createHash("md5").update(url).digest("hex");
-    const cacheFile = path.join(cachePath, hash);
-    const metaFile = cacheFile + ".meta.json";
-    return { cacheFile, metaFile }
-}
-
-/** 缓存浏览器到目录 ./tmp/browser_cache */
-export async function routeAssetsCache(page: Page, cachePath: string) {
-    // 确保缓存目录存在
-    if (!fs.existsSync(cachePath)) {
-        fs.mkdirSync(cachePath, { recursive: true });
-    }
-
-    console.log("启用浏览器缓存")
-
-    await page.route("**/*", async (route) => {
-        const req = route.request();
-        //如果不是get直接放行
-        if (req.method() !== "GET") {
-            return route.continue();
-        }
-        const type = req.resourceType()
-        if (["xhr", "fetch", "websocket", "document"].includes(type)) {
-            return route.continue();
-        }
-
-        // 尝试从缓存读取 (使用 URL hash 作为文件名)
-        const url = req.url();
-        const { cacheFile, metaFile } = getCachePath(url, cachePath);
-
-        try {
-            if (fs.existsSync(cacheFile) && fs.existsSync(metaFile)) {
-                const meta = JSON.parse(fs.readFileSync(metaFile, "utf-8"));
-                const body = fs.readFileSync(cacheFile);
-                // 检查缓存是否过期
-                if (Date.now() - meta.timestamp > meta.timeout) {
-                    fs.unlinkSync(cacheFile);
-                    fs.unlinkSync(metaFile);
-                    return route.continue();
-                }
-                // console.log(`命中缓存 ${url}`, metaFile);
-                return route.fulfill({
-                    status: 200,
-                    headers: meta.headers,
-                    body: body,
-                    contentType: meta.contentType
-                });
-            }
-        } catch (e) {
-            // 缓存读取失败，继续请求
-            // console.log(`缓存 ${url} 读取失败`, e);
-        }
-        return route.continue();
-    });
-
-    // 监听响应事件，检查是否缓存到本地
-    await page.on("response", async (response) => {
-        const req = response.request();
-        if (req.method() !== "GET") {
-            return;
-        }
-        const status = response.status()
-        if (![200, 201].includes(status)) {
-            return;
-        }
-        const url = response.url();
-        const { cacheFile, metaFile } = getCachePath(url, cachePath);
-        if (fs.existsSync(cacheFile) && fs.existsSync(metaFile)) {
-            return;
-        }
-        // 检查响应头是否允许缓存
-        const headers = response.headers();
-        const resType = headers["content-type"] || "";
-        if (resType.includes("text/plain") || url.includes(";")) {
-            return;
-        }
-        const cacheControl = headers["cache-control"] || "";
-        const pragma = headers["pragma"] || "";
-        // 如果明确禁止缓存，则不缓存
-        if (cacheControl.includes("no-store") || pragma.includes("no-cache")) {
-            return;
-        }
-        const type = req.resourceType()
-        if (!(pragma || cacheControl)) {
-            // 如果没有cache-control和pragma头，只缓存document类型的资源
-            if (["xhr", "fetch", "websocket", "document"].includes(type)) {
-                return;
-            }
-            // 如果有参数也不缓存
-            const params = new URL(url).searchParams
-            if (params.toString().length > 0) {
-                return;
-            }
-            // if (["document", "script"].includes(type) && params.size > 0) {
-            //     return;
-            // }
-            // if (["script"].includes(type) && params.size > 38) {
-            //     return;
-            // }
-        }
-
-        try {
-            // 保存到缓存
-            const buffer = await response.body();
-            fs.writeFileSync(cacheFile, buffer);
-            fs.writeFileSync(metaFile, JSON.stringify({
-                url: url,
-                headers: headers,
-                contentType: headers["content-type"],
-                timestamp: Date.now(),
-                // 从header中获取缓存时间，默认1分钟
-                timeout: parseInt(headers["cache-control"]?.match(/max-age=(\d+)/)?.[1] || "99999999") * 1000,
-            }));
-            // console.log(`缓存 ${url}`, resType);
-        } catch (e) {
-            // console.log(`缓存 ${url} 写入失败`, e);
-        }
-    });
-}

package/src/network/resource.ts

@@ -1,62 +0,0 @@
-import type { Page, Route, Request } from "patchright-core";
-
-export async function fetchResource(route: Route, req: Request, page: Page) {
-    // 使用 Node.js 原生 fetch，不继承浏览器代理设置
-    return await fetch(req.url(), {
-        method: req.method(),
-        body: req.postData(),
-        headers: req.headers(),
-    })
-        .then(async (res) => {
-            return route.fulfill({
-                status: res.status,
-                headers: Object.fromEntries(res.headers.entries()),
-                body: Buffer.from(await res.arrayBuffer()),
-            });
-        }).catch(() => {
-            return route.abort();
-        })
-}
-
-export async function routeAssetsLocal(page: Page) {
-    await page.route("**/*", async (route) => {
-        const req = route.request();
-        const url = req.url();
-        const type = req.resourceType();
-        //如果不是get直接放行
-        if (!["GET"].includes(req.method())) {
-            return await route.continue();
-        }
-        if (
-            ["xhr", "fetch", "websocket", "document"].includes(type)
-            || (["script"].includes(type) && url.includes("?"))
-        ) {
-            //使用浏览器代理进行请求
-            return await route.continue();
-        }
-        //使用本地网络进行请求
-        return await fetchResource(route, req, page);
-    });
-}
-
-export async function routeAssetsAbort(page: Page) {
-    await page.route("**/*", async (route) => {
-        const req = route.request();
-        //如果不是get直接放行
-        if (req.method() !== "GET") {
-            return route.continue();
-        }
-        const type = req.resourceType()
-        // if (["script"].includes(type)) {
-        //     return await curlResource(route, req, page);
-        // }
-        if (
-            !["xhr", "fetch", "websocket", "document", "script"].includes(type)
-        ) {
-            //使用fetch进行请求
-            return route.abort();
-        }
-        //其他请求继续
-        return route.continue();
-    });
-}

package/src/providers/ads_tool.ts

@@ -1,38 +0,0 @@
-
-/** ads专用参数加密 */
-export function adsEncodeBase64(e: string) {
-    let t, r
-    void 0 === t && (t = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"),
-        void 0 === r && (r = "hTy1bfRJz4nLPcBCO7WtmNIaGvVeul5Zo8kq32UxrYw_-0gsjp96SDFXQiEMKdHA");
-    var n = t
-        , a = r
-        , i = Buffer.from(e).toString('base64').split("")
-        , s = "";
-    return i.map((function (e) {
-        var t = n.indexOf(e);
-        return s += t < 0 ? e : a.substr(t, 1),
-            e
-    }
-    )),
-        s
-}
-
-
-/** ads专用参数解密 */
-export function adsDecodeBase64(e: string) {
-    let t, r;
-    if (void 0 === t && (t = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"),
-        void 0 === r && (r = "hTy1bfRJz4nLPcBCO7WtmNIaGvVeul5Zo8kq32UxrYw_-0gsjp96SDFXQiEMKdHA"),
-        !e)
-        return "";
-    var n = t
-        , a = r
-        , i = e.split("")
-        , s = "";
-    return i.map((function (e) {
-        var t = a.indexOf(e);
-        return s += t < 0 ? e : n.substr(t, 1),
-            e
-    }
-    )), Buffer.from(s, 'base64').toString()
-}