xiumiagent 0.1.0__py3-none-any.whl

cdp/browser.py

@@ -0,0 +1,98 @@
+"""Edge 启动与标签页管理（独立自动化 profile）。"""
+from __future__ import annotations
+
+import subprocess
+from typing import Any
+
+from core.config import Config
+
+from .connection import CDPConnection
+from .helpers import Tab
+
+
+class BrowserNotReady(RuntimeError):
+    pass
+
+
+class EdgeBrowser:
+    def __init__(self, config: Config):
+        self.config = config
+        self.cdp: CDPConnection | None = None
+        self._proc: subprocess.Popen | None = None
+
+    # ---- 启动 ----
+    async def ensure_started(self) -> None:
+        """端口活着就复用已有 Edge；否则用独立 profile 启动一个。"""
+        if await self._port_alive():
+            return
+        if not self.config.edge_path:
+            raise BrowserNotReady(
+                "未找到 Edge，请在 .env 的 EDGE_PATH 指定 msedge.exe 路径"
+            )
+        args = [
+            self.config.edge_path,
+            f"--remote-debugging-port={self.config.cdp_port}",
+            f"--user-data-dir={self.config.profile_dir}",
+            "--remote-allow-origins=*",
+            "--no-first-run",
+            "--no-default-browser-check",
+            "--disable-session-crashed-bubble",
+            "--hide-crash-restore-bubble",
+            "--restore-last-session=false",
+            "about:blank",
+        ]
+        self._proc = subprocess.Popen(args, creationflags=subprocess.DETACHED_PROCESS | subprocess.CREATE_NEW_PROCESS_GROUP)
+        for _ in range(80):  # 最多等 20 秒
+            if await self._port_alive():
+                return
+            import asyncio
+
+            await asyncio.sleep(0.25)
+        raise BrowserNotReady(f"Edge 调试端口 {self.config.cdp_port} 未就绪")
+
+    async def _port_alive(self) -> bool:
+        probe: CDPConnection | None = None
+        try:
+            probe = await CDPConnection.connect(self.config.cdp_port, timeout=1.5)
+            return True
+        except Exception:
+            return False
+        finally:
+            if probe:
+                try:
+                    await probe.close()
+                except Exception:
+                    pass
+
+    async def connect(self) -> None:
+        self.cdp = await CDPConnection.connect(self.config.cdp_port)
+
+    # ---- 标签页 ----
+    async def get_or_create_tab(self, url_contains: str = "xiumi.us", default_url: str = "https://xiumi.us/") -> Tab:
+        """找 url 含 url_contains 的标签页；找不到就新建并导航到 default_url。"""
+        if not self.cdp:
+            raise BrowserNotReady("CDP 未连接")
+        pages = await self.cdp.list_pages()
+        for p in pages:
+            url = p.get("url", "")
+            if url_contains in url and "devtools" not in url:
+                return await self.attach_tab(p)
+        page = await self.cdp.new_tab(default_url)
+        return await self.attach_tab(page)
+
+    async def open_tab(self, url: str) -> Tab:
+        if not self.cdp:
+            raise BrowserNotReady("CDP 未连接")
+        page = await self.cdp.new_tab(url)
+        return await self.attach_tab(page)
+
+    async def attach_tab(self, target_info: dict[str, Any]) -> Tab:
+        session_id = await self.cdp.attach(target_info["targetId"])
+        tab = Tab(self.cdp, session_id, target_info)
+        await tab.enable()
+        return tab
+
+    async def shutdown(self) -> None:
+        if self.cdp:
+            await self.cdp.close()
+            self.cdp = None

cdp/connection.py

@@ -0,0 +1,158 @@
+"""CDP 浏览器级 WebSocket 连接（flat session 模式）。
+
+一条浏览器级连接即可操作所有标签页：Target.attachToTarget(flatten=True)
+拿到 sessionId 后，send() 携带 sessionId 即面向该标签页。
+"""
+from __future__ import annotations
+
+import asyncio
+import itertools
+import json
+import urllib.request
+from typing import Any, Callable
+
+import websockets
+
+DEFAULT_TIMEOUT = 60.0
+
+
+class CDPError(RuntimeError):
+    pass
+
+
+class CDPProtocolError(CDPError):
+    """CDP 返回了 error 结果。"""
+
+    def __init__(self, method: str, code: int, message: str):
+        super().__init__(f"CDP {method} 失败 [{code}]: {message}")
+        self.method, self.code, self.message = method, code, message
+
+
+class CDPEvalError(CDPError):
+    """页面内 JS 抛出异常。"""
+
+    def __init__(self, expression: str, detail: str):
+        super().__init__(f"JS 执行出错: {detail}\n--- 表达式 ---\n{expression[:500]}")
+        self.detail = detail
+
+
+EventCallback = Callable[[str | None, str, dict], None]
+
+
+class CDPConnection:
+    def __init__(self, ws_url: str, port: int):
+        self._ws_url = ws_url
+        self.port = port
+        self._ws: websockets.WebSocketCommonProtocol | None = None
+        self._ids = itertools.count(1)
+        self._pending: dict[int, asyncio.Future] = {}
+        self._event_cbs: list[EventCallback] = []
+        self._recv_task: asyncio.Task | None = None
+        self._closed = False
+
+    # ---- 生命周期 ----
+    @classmethod
+    async def connect(cls, port: int, timeout: float = 15.0) -> "CDPConnection":
+        version = await asyncio.wait_for(
+            asyncio.to_thread(cls._http_get, port, "/json/version"), timeout=timeout
+        )
+        ws_url = version.get("webSocketDebuggerUrl")
+        if not ws_url:
+            raise CDPError("未能从 /json/version 获取 webSocketDebuggerUrl")
+        self = cls(ws_url, port)
+        await self._open()
+        return self
+
+    @staticmethod
+    def _http_get(port: int, path: str) -> dict:
+        with urllib.request.urlopen(f"http://127.0.0.1:{port}{path}", timeout=3) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+
+    async def _open(self) -> None:
+        self._ws = await websockets.connect(self._ws_url, max_size=64 * 1024 * 1024, ping_interval=20)
+        self._recv_task = asyncio.create_task(self._recv_loop())
+
+    async def close(self) -> None:
+        self._closed = True
+        if self._recv_task:
+            self._recv_task.cancel()
+        if self._ws:
+            await self._ws.close()
+
+    def http_get(self, path: str) -> dict:
+        return self._http_get(self.port, path)
+
+    # ---- 消息收发 ----
+    async def send(
+        self,
+        method: str,
+        params: dict | None = None,
+        *,
+        session_id: str | None = None,
+        timeout: float = DEFAULT_TIMEOUT,
+    ) -> Any:
+        if not self._ws:
+            raise CDPError("CDP 连接未打开")
+        mid = next(self._ids)
+        msg: dict[str, Any] = {"id": mid, "method": method, "params": params or {}}
+        if session_id:
+            msg["sessionId"] = session_id
+        fut: asyncio.Future = asyncio.get_running_loop().create_future()
+        self._pending[mid] = fut
+        try:
+            await self._ws.send(json.dumps(msg))
+            result = await asyncio.wait_for(fut, timeout=timeout)
+        finally:
+            self._pending.pop(mid, None)
+        return result
+
+    def on_event(self, callback: EventCallback) -> None:
+        """callback(session_id, method, params) —— 同步回调。"""
+        self._event_cbs.append(callback)
+
+    async def _recv_loop(self) -> None:
+        try:
+            async for raw in self._ws:
+                msg = json.loads(raw)
+                if "id" in msg:
+                    fut = self._pending.get(msg["id"])
+                    if fut and not fut.done():
+                        if "error" in msg:
+                            fut.set_exception(
+                                CDPProtocolError(msg.get("method", "?"), msg["error"].get("code", -1), msg["error"].get("message", ""))
+                            )
+                        else:
+                            fut.set_result(msg.get("result"))
+                else:
+                    sid = msg.get("sessionId")
+                    method = msg.get("method", "")
+                    params = msg.get("params") or {}
+                    for cb in list(self._event_cbs):
+                        try:
+                            cb(sid, method, params)
+                        except Exception:
+                            pass
+        except asyncio.CancelledError:
+            pass
+        except Exception:
+            if not self._closed:
+                for fut in self._pending.values():
+                    if not fut.done():
+                        fut.set_exception(CDPError("CDP 连接断开"))
+
+    # ---- Target 管理 ----
+    async def list_pages(self) -> list[dict]:
+        res = await self.send("Target.getTargets")
+        return [t for t in res.get("targetInfos", []) if t.get("type") == "page"]
+
+    async def new_tab(self, url: str = "about:blank") -> dict:
+        res = await self.send("Target.createTarget", {"url": url})
+        tid = res["targetId"]
+        for t in await self.list_pages():
+            if t["targetId"] == tid:
+                return t
+        return {"targetId": tid, "url": url}
+
+    async def attach(self, target_id: str) -> str:
+        res = await self.send("Target.attachToTarget", {"targetId": target_id, "flatten": True})
+        return res["sessionId"]

cdp/helpers.py

@@ -0,0 +1,175 @@
+"""Tab：面向单个标签页的高级封装（evaluate / 注入 JS 库 / 截图 / 文件注入 / 真实按键）。"""
+from __future__ import annotations
+
+import base64
+import json
+from pathlib import Path
+from typing import Any
+
+from .connection import CDPConnection, CDPError, CDPEvalError
+from .jslib import AGENT_JS, call_expr
+
+_KEY_MAP = {
+    "Enter": ("\r", "Enter", 13),
+    "Tab": ("\t", "Tab", 9),
+    "Escape": ("", "Escape", 27),
+    "Backspace": ("\b", "Backspace", 8),
+    "Delete": ("", "Delete", 46),
+    "ArrowLeft": ("", "Left", 37),
+    "ArrowRight": ("", "Right", 39),
+    "ArrowUp": ("", "Up", 38),
+    "ArrowDown": ("", "Down", 40),
+}
+
+
+class Tab:
+    def __init__(self, conn: CDPConnection, session_id: str, target_info: dict):
+        self.conn = conn
+        self.session_id = session_id
+        self.target_info = target_info
+        self._lib_injected = False
+
+    # ---- 基础 ----
+    async def send(self, method: str, params: dict | None = None, timeout: float = 60.0) -> Any:
+        return await self.conn.send(method, params, session_id=self.session_id, timeout=timeout)
+
+    async def enable(self) -> None:
+        for m in ("Runtime.enable", "Page.enable", "DOM.enable"):
+            try:
+                await self.send(m)
+            except CDPError:
+                pass
+        self._lib_injected = False
+
+    @property
+    def url(self) -> str:
+        return self.target_info.get("url", "")
+
+    async def current_url(self) -> str:
+        try:
+            return await self.evaluate("location.href")
+        except Exception:
+            return self.url
+
+    # ---- JS ----
+    async def evaluate(self, expression: str, await_promise: bool = False, timeout: float = 60.0) -> Any:
+        res = await self.send(
+            "Runtime.evaluate",
+            {
+                "expression": expression,
+                "awaitPromise": await_promise,
+                "returnByValue": True,
+                "userGesture": True,
+            },
+            timeout=timeout,
+        )
+        if res.get("exceptionDetails"):
+            d = res["exceptionDetails"]
+            detail = d.get("exception", {}).get("description") or d.get("text", "unknown")
+            raise CDPEvalError(expression, detail)
+        result = res.get("result", {})
+        return result.get("value")
+
+    async def ensure_lib(self) -> None:
+        if self._lib_injected:
+            return
+        state = await self.evaluate(AGENT_JS)
+        self._lib_injected = state in ("ok", "already")
+        if not self._lib_injected:
+            raise CDPError("agent JS 库注入失败")
+
+    async def agent(self, fn: str, *args: Any) -> Any:
+        """调用 window.__agent.fn(...)，返回 JSON 可序列化结果。"""
+        await self.ensure_lib()
+        return await self.evaluate(call_expr(fn, *args))
+
+    # ---- 导航 ----
+    async def navigate(self, url: str, settle: float = 1.5, timeout: float = 30.0) -> dict:
+        self._lib_injected = False
+        res = await self.send("Page.navigate", {"url": url}, timeout=timeout)
+        import asyncio
+
+        await asyncio.sleep(0.3)
+        deadline = asyncio.get_event_loop().time() + timeout
+        while asyncio.get_event_loop().time() < deadline:
+            state = await self.evaluate("document.readyState")
+            if state == "complete":
+                break
+            await asyncio.sleep(0.3)
+        await asyncio.sleep(settle)  # SPA 渲染缓冲
+        self.target_info["url"] = url
+        return res
+
+    async def wait_selector(self, selector: str, timeout: float = 10.0) -> bool:
+        import asyncio
+
+        deadline = asyncio.get_event_loop().time() + timeout
+        while asyncio.get_event_loop().time() < deadline:
+            found = await self.evaluate(f"!!document.querySelector({json.dumps(selector)})")
+            if found:
+                return True
+            await asyncio.sleep(0.4)
+        return False
+
+    # ---- 截图 ----
+    async def screenshot(self, path: Path | None = None, selector: str | None = None) -> Path:
+        params: dict[str, Any] = {"format": "png"}
+        if selector:
+            rect = await self.evaluate(
+                f"(() => {{ const el = document.querySelector({json.dumps(selector)});"
+                f" if (!el) return null; const r = el.getBoundingClientRect();"
+                f" return {{x: r.x, y: r.y + window.scrollY, width: r.width, height: r.height}}; }})()"
+            )
+            if not rect or rect["width"] < 2:
+                raise CDPError(f"截图失败：找不到可见元素 {selector}")
+            params["clip"] = {**rect, "scale": 1}
+            params["captureBeyondViewport"] = True
+        res = await self.send("Page.captureScreenshot", params, timeout=60)
+        data = base64.b64decode(res["data"])
+        if path is None:
+            from core.config import PROJECT_ROOT
+
+            path = PROJECT_ROOT / "screenshots" / "shot.png"
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(data)
+        return path
+
+    # ---- 文件上传（纯 JS 做不到，必须走 CDP）----
+    async def set_files(self, selector: str, file_paths: list[str | Path]) -> None:
+        """把本地文件塞进页面 file input（如秀米图库上传）。"""
+        # 先确保 input 存在
+        exists = await self.evaluate(f"!!document.querySelector({json.dumps(selector)})")
+        if not exists:
+            raise CDPError(f"file input 不存在: {selector}")
+        res = await self.send(
+            "Runtime.evaluate",
+            {
+                "expression": f"document.querySelector({json.dumps(selector)})",
+                "returnByValue": False,
+            },
+        )
+        object_id = res.get("result", {}).get("objectId")
+        if not object_id:
+            raise CDPError("无法获取 file input 的 objectId")
+        node = await self.send("DOM.requestNode", {"objectId": object_id})
+        abs_paths = [str(Path(p).resolve()) for p in file_paths]
+        for p in abs_paths:
+            if not Path(p).exists():
+                raise CDPError(f"文件不存在: {p}")
+        await self.send("DOM.setFileInputFiles", {"files": abs_paths, "nodeId": node["nodeId"]})
+        # 通知框架文件已选择
+        await self.agent("triggerChange", selector)
+
+    # ---- 真实按键兜底（isTrusted，合成事件不生效时用）----
+    async def real_press(self, key: str) -> None:
+        text, key_name, vk = _KEY_MAP.get(key, ("", key, 0))
+        for type_ in ("keyDown", "keyUp") if not text else (("keyDown", "char", "keyUp")):
+            params: dict[str, Any] = {"type": type_, "key": key_name, "windowsVirtualKeyCode": vk}
+            if type_ == "char":
+                params["text"] = text
+            await self.send("Input.dispatchKeyEvent", params)
+
+    async def real_type(self, text: str) -> None:
+        """逐字符发送真实键盘输入（焦点必须在目标输入框上）。"""
+        for ch in text:
+            await self.send("Input.dispatchKeyEvent", {"type": "char", "text": ch})