mooncat-browser 0.1.0

package/browser-op/py/scroll.py

@@ -0,0 +1,180 @@
+"""web/scroll — 唯一滚动入口 ScrollController (路由无关).
+
+忠实复刻 lib/web/scroll.js。
+原则: 所有改变 viewport 的动作必须经过这里。
+  - scroll_to_y: 启动读一次 startY, clamp target, 单次定方向, 单调 easing, 不越过, 不反向
+  - scroll_by: = scroll_to_y(currentY + delta)
+  - scroll_to_element: 算目标→scroll_to_y→重测→最多一次同向修正, 禁 scrollIntoView
+  - scroll_to_end: 读 maxScrollY→scroll_to_y, 只单调
+
+依赖: browser (operate)
+"""
+from __future__ import annotations
+import time
+import math
+import random
+from typing import Any
+
+import sys
+sys.path.insert(0, __file__.rsplit("\\", 1)[0] if "\\" in __file__ else __file__.rsplit("/", 1)[0])
+from browser import operate  # noqa: E402
+
+
+def _ease(t: float) -> float:
+    """单调缓动 (easeInOutCubic): t∈[0,1] → [0,1], 单调递增."""
+    if t < 0.5:
+        return 4 * t * t * t
+    return 1 - math.pow(-2 * t + 2, 3) / 2
+
+
+def read_scroll_y(ph: dict) -> int:
+    """读当前 scrollY."""
+    y = operate(ph, {"action": "evaluate", "source": "() => window.scrollY || window.pageYOffset || 0", "_skipVisualize": True})
+    if y is None:
+        return 0
+    return int(y) if not isinstance(y, (int, float)) else int(y)
+
+
+def read_max_scroll_y(ph: dict) -> int:
+    """读最大可滚距离."""
+    m = operate(ph, {"action": "evaluate", "source": "() => Math.max(0, (document.body.scrollHeight || 0) - (window.innerHeight || 0))", "_skipVisualize": True})
+    if m is None:
+        return 0
+    return int(m) if not isinstance(m, (int, float)) else int(m)
+
+
+def _set_scroll_y(ph: dict, y: int) -> None:
+    """设置绝对 scrollY (用 scrollTo 设精确位置)."""
+    operate(ph, {"action": "evaluate", "source": "(y) => { window.scrollTo(0, y); return window.scrollY || 0 }", "args": y, "_skipVisualize": True})
+
+
+def scroll_to_y(page_handle: dict, target_y: int, opts: dict | None = None) -> dict:
+    """滚动到指定 scrollY (绝对坐标)。
+
+    规则:
+      - 启动读一次 startY, 之后不靠实时 scrollY 反向修正
+      - clamp targetY 到 [0, maxScrollY]
+      - 方向一次确定, 单调 easing, 每步 clamp 到目标内, 不越过不反向
+
+    返回: {ok, startY, targetY, positions, maxDelta, reversed}
+      reversed=true 表示页面外部干扰导致实际滚动反向 (异常)
+    """
+    opts = opts or {}
+    step_px = opts.get("stepPx", 40)
+    step_ms = opts.get("stepMs", 16)
+
+    start_y = read_scroll_y(page_handle)
+    max_y = read_max_scroll_y(page_handle)
+    target = max(0, min(target_y, max_y))
+    distance = abs(target - start_y)
+    dir_flag = 1 if target >= start_y else -1
+
+    steps = max(1, math.ceil(distance / step_px))
+    positions = [start_y]
+    max_delta = 0
+    reversed_flag = False
+
+    for i in range(1, steps + 1):
+        t = i / steps
+        eased = _ease(t)
+        pos = start_y + dir_flag * distance * eased
+        if dir_flag > 0:
+            pos = min(pos, target)
+        else:
+            pos = max(pos, target)
+        _set_scroll_y(page_handle, int(pos))
+
+        real = read_scroll_y(page_handle)
+        positions.append(real)
+        delta = abs(real - positions[-2])
+        if delta > max_delta:
+            max_delta = delta
+        if len(positions) >= 2:
+            prev = positions[-2]
+            if dir_flag > 0 and real < prev - 1:
+                reversed_flag = True
+            if dir_flag < 0 and real > prev + 1:
+                reversed_flag = True
+        time.sleep(step_ms / 1000)
+
+    _set_scroll_y(page_handle, target)
+    final = read_scroll_y(page_handle)
+    positions.append(final)
+
+    return {"ok": True, "startY": start_y, "targetY": target, "positions": positions, "maxDelta": max_delta, "reversed": reversed_flag}
+
+
+def scroll_by(page_handle: dict, delta_px: int, opts: dict | None = None) -> dict:
+    """增量滚动 = 读当前 Y + scroll_to_y."""
+    cur = read_scroll_y(page_handle)
+    return scroll_to_y(page_handle, cur + delta_px, opts)
+
+
+def scroll_to_element(page_handle: dict, selector: str, opts: dict | None = None) -> dict:
+    """滚到元素 (禁 scrollIntoView).
+
+    算目标 → scroll_to_y → 重测 → 容差内即停, 否则最多一次同向单调修正.
+    opts.block='center'|'start'|'end', opts.tolerance=20
+    """
+    opts = opts or {}
+    block = opts.get("block", "center")
+    tolerance = opts.get("tolerance", 20)
+    import json
+
+    def compute_target():
+        r = operate(page_handle, {
+            "action": "evaluate",
+            "source": """(() => { const el = document.querySelector(""" + json.dumps(selector) + """);
+              if (!el) return null;
+              const r = el.getBoundingClientRect();
+              const vh = window.innerHeight;
+              let off = vh/2;
+              if (""" + json.dumps(block) + """==='start') off=50;
+              else if (""" + json.dumps(block) + """==='end') off=vh-50;
+              return { targetY: Math.max(0, r.top + (window.scrollY||0) - off), top: Math.round(r.top), vh };
+            })()""",
+            "_skipVisualize": True
+        })
+        return r
+
+    first = compute_target()
+    if not first:
+        return {"ok": False, "error": "ELEMENT_NOT_FOUND", "selector": selector}
+    trace = scroll_to_y(page_handle, first.get("targetY", 0), opts)
+
+    remeasure = compute_target()
+    if not remeasure:
+        return {"ok": False, "error": "ELEMENT_NOT_FOUND_AFTER_SCROLL", "selector": selector}
+    vh = first.get("vh", 800)
+    center = 0 if block == "start" else (vh if block == "end" else vh / 2)
+    in_view = abs(remeasure.get("top", 0) - center) < tolerance + 50
+    if in_view:
+        return {"ok": True, "targetY": first.get("targetY"), "inViewport": True, **trace}
+
+    fix = compute_target()
+    if not fix:
+        return {"ok": False, "error": "ELEMENT_NOT_FOUND", "selector": selector, "inViewport": False, **trace}
+    trace2 = scroll_to_y(page_handle, fix.get("targetY", 0), opts)
+    remeasure2 = compute_target()
+    in_view2 = False
+    if remeasure2:
+        in_view2 = abs(remeasure2.get("top", 0) - center) < tolerance + 50
+    return {"ok": in_view2, "targetY": fix.get("targetY"), "inViewport": in_view2, **trace, "fixTrace": trace2}
+
+
+def scroll_to_end(page_handle: dict, to: str = "top", opts: dict | None = None) -> dict:
+    """滚到页顶/页底 (只单调).
+
+    bottom: 读 maxScrollY → scroll_to_y → 若 scrollHeight 变化则重复 (最多 5 轮).
+    """
+    if to == "top":
+        return scroll_to_y(page_handle, 0, opts)
+    last_max = -1
+    trace = None
+    for _ in range(5):
+        max_y = read_max_scroll_y(page_handle)
+        if max_y == last_max:
+            break
+        last_max = max_y
+        trace = scroll_to_y(page_handle, max_y, opts)
+    return trace or {"ok": True, "startY": 0, "targetY": 0, "positions": [], "maxDelta": 0, "reversed": False}

package/browser-op/py/upload.py

@@ -0,0 +1,103 @@
+"""web/upload — 通用文件 / 文件夹上传 (路由无关, 全走 operate).
+
+忠实复刻 lib/web/upload.js。
+统一 operate(pageHandle, {action:'setInputFiles'}), operate 内部按路由分流:
+  cdp 吃本地 paths (playwright 自动展开目录), extension 吃 base64 files。
+upload 只负责把调用方意图整理成 operate 能懂的参数:
+  总是同时提供 paths (给 cdp) + files (给 extension, base64 展开后)。
+
+依赖: browser (operate), os + pathlib
+"""
+from __future__ import annotations
+import base64
+import mimetypes
+import os
+from pathlib import Path
+from typing import Any
+
+import sys
+sys.path.insert(0, __file__.rsplit("\\", 1)[0] if "\\" in __file__ else __file__.rsplit("/", 1)[0])
+from browser import operate  # noqa: E402
+
+MIME_MAP = {
+    "png": "image/png", "jpg": "image/jpeg", "jpeg": "image/jpeg", "gif": "image/gif",
+    "webp": "image/webp", "svg": "image/svg+xml", "ico": "image/x-icon", "bmp": "image/bmp",
+    "pdf": "application/pdf", "txt": "text/plain", "json": "application/json", "csv": "text/csv",
+    "html": "text/html", "htm": "text/html", "xml": "application/xml", "zip": "application/zip",
+    "gz": "application/gzip", "tar": "application/x-tar",
+    "xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    "xls": "application/vnd.ms-excel",
+    "docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+    "doc": "application/msword", "mp4": "video/mp4", "mp3": "audio/mpeg",
+    "js": "text/javascript", "ts": "text/plain", "css": "text/css", "md": "text/markdown",
+}
+
+
+def _guess_mime(name: str) -> str:
+    ext = name.lower().split(".")[-1] if "." in name else ""
+    return MIME_MAP.get(ext, "application/octet-stream")
+
+
+def _read_file_entry(full_path: str, webkit_relative_path: str | None = None) -> dict:
+    p = Path(full_path)
+    data = base64.b64encode(p.read_bytes()).decode("ascii")
+    return {
+        "name": p.name,
+        "mime": _guess_mime(p.name),
+        "data": data,
+        "webkitRelativePath": webkit_relative_path or p.name,
+    }
+
+
+def expand_paths(paths: list[str]) -> list[dict]:
+    """展开本地路径数组 (文件/目录混合) → base64 文件 entry 数组.
+
+    插件分支用 (content 读不到本地文件, 必须转 base64).
+    CDP 分支不需要 (直传路径给 playwright).
+    """
+    out = []
+    for root in paths:
+        p = Path(root)
+        if not p.exists():
+            raise RuntimeError(f"upload: path not found: {root}")
+        if p.is_file():
+            out.append(_read_file_entry(str(p), p.name))
+        elif p.is_dir():
+            for f in sorted(p.rglob("*")):
+                if f.is_file():
+                    rel = str(f.relative_to(p.parent))
+                    out.append(_read_file_entry(str(f), rel))
+        else:
+            raise RuntimeError(f"upload: not a file or directory: {root}")
+    return out
+
+
+def upload_files(page_handle: dict, options: dict | None = None) -> dict:
+    """上传文件 / 文件夹到 <input type=file>.
+
+    options:
+      selector: 文件输入框 selector (必需)
+      paths: 本地路径数组, 文件或目录, 可混合 (必需)
+    返回: {ok, selector, requested, built, totalBytes}
+    """
+    if not page_handle:
+        raise ValueError("upload_files: page_handle required")
+    opts = options or {}
+    selector = opts.get("selector")
+    if not selector:
+        raise ValueError("upload_files: selector required")
+    paths = opts.get("paths", [])
+    if not paths:
+        raise ValueError("upload_files: paths required")
+
+    files = expand_paths(paths)
+    total_bytes = sum(len(f["data"]) * 3 // 4 for f in files)
+
+    r = operate(page_handle, {"action": "setInputFiles", "selector": selector, "paths": paths, "files": files})
+    return {
+        "ok": r.get("ok") is not False if isinstance(r, dict) else False,
+        "selector": selector,
+        "requested": len(paths),
+        "built": len(files),
+        "totalBytes": total_bytes,
+    }

package/browser-op/py/visual_target.py

@@ -0,0 +1,47 @@
+"""web/visual-target — 从 action 参数生成可视化目标声明.
+
+忠实复刻 lib/web/visual-target.js。
+唯一职责: 根据 operate 的 action 类型, 推断出"这一步在操作什么目标"。
+返回 { kind, ... } 声明, 供 interact.highlight 解析画框。
+
+依赖: 无 (纯函数, 不调 operate).
+"""
+from __future__ import annotations
+from typing import Any
+
+
+def visual_target_from_action(action: str, rest: dict | None = None) -> dict | None:
+    """从 action + rest 参数推断可视化目标.
+
+    kind 类型:
+      selector -> { kind:'selector', selector, required }
+      text     -> { kind:'text', text, required }
+      point    -> { kind:'point', x, y, required }
+      rect     -> { kind:'rect', x, y, w, h, required }
+      pair     -> { kind:'pair', source, target, required }
+    """
+    rest = rest or {}
+
+    # 交互类: 有 selector 目标
+    if action in ("click", "fill", "type", "hover", "focus", "check", "uncheck",
+                   "selectOption", "dblclick", "boundingBox", "waitForSelector", "setInputFiles"):
+        if rest.get("selector"):
+            return {"kind": "selector", "selector": rest["selector"], "required": True}
+        return None
+
+    # 拖拽: 双目标
+    if action == "dragTo":
+        return {"kind": "pair", "source": rest.get("source"), "target": rest.get("target"), "required": True}
+
+    # evaluate: 看 rest 是否传了 visualTarget
+    if action == "evaluate":
+        return rest.get("visualTarget") or None
+
+    # 鼠标坐标: 有坐标但无元素
+    if action == "mouseMove":
+        if rest.get("x") is not None and rest.get("y") is not None:
+            return {"kind": "point", "x": rest["x"], "y": rest["y"], "required": False}
+        return None
+
+    # 无目标类
+    return None

package/browser-op/py/visualize.py

@@ -0,0 +1,91 @@
+"""web/visualize — operate 可视化注入层 (路由无关).
+
+忠实复刻 lib/web/visualize.js。
+通过 open({visualize:True}) 开启。标记挂到 browserHandle→pageHandle，
+operate 自动在执行前/后注入高亮 + toast，调用方零改动。
+
+原则：高亮目标 + 知道在干什么，不显示提取到的内容。
+高亮失败不静默: required 目标高亮失败 → 抛错, 不执行主 action。
+
+依赖: browser (operate), interact (highlight/toast), visual_target
+"""
+from __future__ import annotations
+from typing import Any
+
+import sys
+sys.path.insert(0, __file__.rsplit("\\", 1)[0] if "\\" in __file__ else __file__.rsplit("/", 1)[0])
+from interact import toast, highlight  # noqa: E402
+from visual_target import visual_target_from_action  # noqa: E402
+
+
+def _desc(sel: Any) -> str:
+    if sel is None:
+        return "?"
+    s = str(sel)
+    if len(s) > 24:
+        return s[:24] + chr(0x2026)
+    return s
+
+
+def _before_text(action: str, rest: dict) -> str | None:
+    texts = {
+        "click": "点击 ",
+        "fill": "填写 ",
+        "type": "输入 ",
+        "press": "按键 " + str(rest.get("key", "")),
+        "hover": "悬停 ",
+        "focus": "聚焦 ",
+        "check": "勾选 ",
+        "uncheck": "取消勾选 ",
+        "selectOption": "选择 ",
+        "dblclick": "双击 ",
+        "goto": "导航到 ",
+        "reload": "刷新页面",
+        "goBack": "后退",
+        "goForward": "前进",
+        "evaluate": rest.get("label") or "执行 evaluate",
+        "waitForSelector": "等待 ",
+        "setInputFiles": "上传文件 ",
+    }
+    if action in ("click", "fill", "type", "hover", "focus", "check", "uncheck", "selectOption", "dblclick", "waitForSelector", "setInputFiles"):
+        return (texts.get(action, "") + _desc(rest.get("selector"))).strip()
+    if action == "press":
+        return "按键 " + str(rest.get("key", ""))
+    if action == "goto":
+        return "导航到 " + str(rest.get("url", ""))[:40]
+    if action == "dragTo":
+        return "拖拽 " + _desc(rest.get("source")) + " \u2192 " + _desc(rest.get("target"))
+    if action in ("waitForURL", "waitForLoadState"):
+        return None
+    return texts.get(action)
+
+
+def create_visualizer(opts: dict | None = None) -> dict:
+    """创建可视化器。
+
+    opts:
+      toastMs: toast 显示时间 (默认 2000)
+    返回: {beforeAction, afterAction, toastMs}
+    """
+    opts = opts or {}
+    toast_ms = opts.get("toastMs", 2000)
+
+    async def do_before_action(page_handle: dict, action: str, rest: dict) -> None:
+        text = _before_text(action, rest)
+        if text:
+            try:
+                await toast(page_handle, text, {"level": "info", "ms": toast_ms})
+            except Exception:
+                pass
+        target = visual_target_from_action(action, rest)
+        if target:
+            r = await highlight(page_handle, target)
+            if not r.get("ok") and target.get("required", False):
+                reason = r.get("reason", "unknown")
+                raise RuntimeError(f"highlight failed (required): {reason} - action \"{action}\" aborted")
+
+    return {
+        "toastMs": toast_ms,
+        "beforeAction": do_before_action,
+        "afterAction": None,
+    }

package/browser-op/state.cjs

@@ -0,0 +1,63 @@
+// -*- coding: utf-8 -*-
+//
+// state.cjs — 全局运行时状态文件 (跨路由公共数据)。
+//
+// 分两层:
+//   - 本文件 (lib/state.cjs): 跨路由公共运行时数据, 不属于任何单条路由。
+//     如: 当前活跃 profile、主控进程 pid、启动时间。
+//   - 分路由 state: lib/cdp/state.cjs (wsEndpoint/port)、
+//     lib/extension/state.cjs (WS 端口/心跳)。各管各的复用判据。
+//
+// 文件位置: <userDataDir>/.browser-op-state.json
+
+'use strict'
+
+const fs = require('node:fs')
+const path = require('node:path')
+
+const STATE_FILENAME = '.browser-op-state.json'
+
+function statePath (userDataDir) {
+  return path.join(userDataDir, STATE_FILENAME)
+}
+
+/** 读全局状态。返回 { profile, mainPid, startedAt, ... } 或 null。 */
+function readGlobal (userDataDir) {
+  try {
+    const p = statePath(userDataDir)
+    if (!fs.existsSync(p)) return null
+    return JSON.parse(fs.readFileSync(p, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
+/** 写全局状态 (主进程 open 成功后调)。 */
+function writeGlobal (userDataDir, info) {
+  try {
+    const p = statePath(userDataDir)
+    fs.mkdirSync(path.dirname(p), { recursive: true })
+    fs.writeFileSync(p, JSON.stringify({
+      profile: info.profile || null,
+      mainPid: info.mainPid || process.pid,
+      startedAt: info.startedAt || Date.now(),
+      updatedAt: Date.now()
+    }, null, 2))
+  } catch { /* 写失败不阻塞主流程 */ }
+}
+
+/** 清全局状态 (close 后调)。 */
+function clearGlobal (userDataDir) {
+  try {
+    const p = statePath(userDataDir)
+    if (fs.existsSync(p)) fs.unlinkSync(p)
+  } catch { /* ignore */ }
+}
+
+module.exports = {
+  STATE_FILENAME,
+  statePath,
+  readGlobal,
+  writeGlobal,
+  clearGlobal
+}

package/browser-op/web/behavior.js

@@ -0,0 +1,153 @@
+// -*- coding: utf-8 -*-
+//
+// web/behavior — 人类行为模拟（路由无关，全走 operate）
+//
+// 完整复刻自 bee/resources/sandbox/builtin-libs/web/behavior.js。
+// 贝塞尔鼠标轨迹 / 随机点击偏移 / 打字节奏 / 平滑滚动。
+//   所有页面动作统一走 operate(pageHandle, {action})，本模块只编排动作序列。
+//
+// 依赖：./browser（operate）
+
+'use strict'
+
+const { operate } = require('./browser')
+
+// ─── 数学工具 ───
+function bezier (p0, p1, p2, p3, t) {
+  const u = 1 - t
+  return u * u * u * p0 + 3 * u * u * t * p1 + 3 * u * t * t * p2 + t * t * t * p3
+}
+
+// 生成贝塞尔轨迹点（含随机抖动）
+function trajectory (from, to, steps) {
+  const pts = []
+  const mx = (from.x + to.x) / 2 + (Math.random() - 0.5) * Math.abs(to.x - from.x) * 0.6
+  const my = (from.y + to.y) / 2 + (Math.random() - 0.5) * Math.abs(to.y - from.y) * 0.6
+  const c1 = { x: from.x + (mx - from.x) * 0.3, y: from.y + (my - from.y) * 0.3 }
+  const c2 = { x: to.x + (mx - to.x) * 0.3, y: to.y + (my - to.y) * 0.3 }
+  for (let i = 0; i <= steps; i++) {
+    const t = i / steps
+    pts.push({
+      x: bezier(from.x, c1.x, c2.x, to.x, t) + (Math.random() - 0.5) * 2,
+      y: bezier(from.y, c1.y, c2.y, to.y, t) + (Math.random() - 0.5) * 2
+    })
+  }
+  return pts
+}
+
+function randomPointInRect (rect) {
+  return {
+    x: rect.x + rect.width * (0.3 + Math.random() * 0.4),
+    y: rect.y + rect.height * (0.3 + Math.random() * 0.4)
+  }
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+
+// 沿贝塞尔轨迹多点 mouseMove 注入（两条路由都支持 operate mouseMove）
+async function moveTrajectory (pageHandle, from, to) {
+  const pts = trajectory(from, to, 10 + Math.floor(Math.random() * 6))
+  for (const pt of pts) {
+    await operate(pageHandle, { action: 'mouseMove', x: pt.x, y: pt.y })
+    await sleep(8 + Math.random() * 16)
+  }
+}
+
+/**
+ * 创建绑定到 pageHandle 的行为模拟器。
+ * @param {object} pageHandle - 单个 page 句柄
+ * @returns {object} moveTo/click/clickElement/typeText/typeInElement/scrollDown/scrollToBottom/scrollToElement
+ */
+function createBehavior (pageHandle) {
+  if (!pageHandle) throw new Error('createBehavior: pageHandle required')
+  let lastPos = { x: 100, y: 100 }
+
+  async function moveTo (x, y) {
+    await moveTrajectory(pageHandle, lastPos, { x, y })
+    lastPos = { x, y }
+  }
+
+  async function click (x, y, options = {}) {
+    await moveTo(x, y)
+    await sleep(50 + Math.random() * 100)
+    await operate(pageHandle, { action: 'click', x, y })
+    await sleep(options.delay || (50 + Math.random() * 100))
+  }
+
+  async function clickElement (selector, timeout = 10000) {
+    await operate(pageHandle, { action: 'waitForSelector', selector, timeout })
+    const boxR = await operate(pageHandle, { action: 'boundingBox', selector })
+    const box = (boxR && (boxR.value || boxR)) || null
+    if (!box || box.width == null) {
+      // 拿不到 bbox（某些元素/路由回退）：直接 selector 点击
+      await operate(pageHandle, { action: 'click', selector })
+      await sleep(50 + Math.random() * 100)
+      return
+    }
+    const pt = randomPointInRect({ x: box.x, y: box.y, width: box.width, height: box.height })
+    await click(pt.x, pt.y)
+  }
+
+  async function typeText (text, delay = 100) {
+    for (const ch of text) {
+      await operate(pageHandle, { action: 'press', selector: 'body', key: ch })
+      let d = delay * (0.5 + Math.random())
+      if (Math.random() < 0.1) d += 200 + Math.random() * 400
+      await sleep(d)
+    }
+  }
+
+  async function typeInElement (selector, text, options = {}) {
+    const delay = options.delay != null ? options.delay : 100
+    const timeout = options.timeout != null ? options.timeout : 10000
+    await operate(pageHandle, { action: 'waitForSelector', selector, timeout })
+    await operate(pageHandle, { action: 'click', selector })
+    await operate(pageHandle, { action: 'type', selector, value: text, delay })
+  }
+
+  async function scrollDown (pixels = 400) {
+    const step = 30 + Math.floor(Math.random() * 30)
+    await operate(pageHandle, {
+      action: 'evaluate',
+      source: '(p) => new Promise((r) => {\n' +
+              '  let done = 0\n' +
+              '  const t = setInterval(() => {\n' +
+              '    window.scrollBy(0, ' + step + ')\n' +
+              '    done += ' + step + '\n' +
+              '    if (done >= p) { clearInterval(t); r() }\n' +
+              '  }, 30 + Math.random() * 30)\n' +
+              '})',
+      args: pixels
+    })
+  }
+
+  async function scrollToBottom () {
+    await operate(pageHandle, {
+      action: 'evaluate',
+      source: '() => new Promise((resolve) => {\n' +
+              '  let last = -1\n' +
+              '  const t = setInterval(() => {\n' +
+              '    window.scrollBy(0, 100 + Math.random() * 100)\n' +
+              '    const h = document.body.scrollHeight\n' +
+              '    if (h === last) { clearInterval(t); resolve() }\n' +
+              '    last = h\n' +
+              '  }, 150)\n' +
+              '})'
+    })
+  }
+
+  async function scrollToElement (selector, timeout = 10000) {
+    await operate(pageHandle, {
+      action: 'evaluate',
+      source: '(s) => { const el = document.querySelector(s); if (el) el.scrollIntoView({ behavior: "smooth", block: "center" }) }',
+      args: selector
+    })
+  }
+
+  return {
+    moveTo, click, clickElement, typeText, typeInElement,
+    scrollDown, scrollToBottom, scrollToElement
+  }
+}
+
+module.exports = { createBehavior }