rpa-skill-runtime 0.1.1__tar.gz

rpa_skill_runtime-0.1.1/PKG-INFO

@@ -0,0 +1,33 @@
+Metadata-Version: 2.4
+Name: rpa-skill-runtime
+Version: 0.1.1
+Summary: 面向独立 RPA Skill 的轻量 Playwright 运行时
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: playwright>=1.61.0
+
+# rpa-skill-runtime
+
+独立 RPA Skill 共用的轻量 Playwright 运行时，提供任务进程、浏览器会话、JSON 动作协议和 DOM UI 工具。登录和业务动作仍由各系统 Skill 自己实现。
+
+## 安装
+
+Python 最低版本为 3.10：
+
+```bash
+python3.12 -m pip install "rpa-skill-runtime>=0.1.1"
+python3.12 -m playwright install chromium
+```
+
+安装后，Skill 脚本直接导入 `rpa_skill_runtime`，不需要携带 `runtime/` 源码目录。
+
+## 发布
+
+```bash
+./publish.sh --dry-run
+./publish.sh
+./publish.sh --repository internal
+TWINE_REPOSITORY_URL=https://pypi.example.com/legacy/ ./publish.sh
+```
+
+默认发布到公开 PyPI。认证信息只从 `~/.pypirc` 或 Twine 标准环境变量读取。

rpa_skill_runtime-0.1.1/README.md

@@ -0,0 +1,25 @@
+# rpa-skill-runtime
+
+独立 RPA Skill 共用的轻量 Playwright 运行时，提供任务进程、浏览器会话、JSON 动作协议和 DOM UI 工具。登录和业务动作仍由各系统 Skill 自己实现。
+
+## 安装
+
+Python 最低版本为 3.10：
+
+```bash
+python3.12 -m pip install "rpa-skill-runtime>=0.1.1"
+python3.12 -m playwright install chromium
+```
+
+安装后，Skill 脚本直接导入 `rpa_skill_runtime`，不需要携带 `runtime/` 源码目录。
+
+## 发布
+
+```bash
+./publish.sh --dry-run
+./publish.sh
+./publish.sh --repository internal
+TWINE_REPOSITORY_URL=https://pypi.example.com/legacy/ ./publish.sh
+```
+
+默认发布到公开 PyPI。认证信息只从 `~/.pypirc` 或 Twine 标准环境变量读取。

rpa_skill_runtime-0.1.1/pyproject.toml

@@ -0,0 +1,14 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "rpa-skill-runtime"
+version = "0.1.1"
+description = "面向独立 RPA Skill 的轻量 Playwright 运行时"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = ["playwright>=1.61.0"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

rpa_skill_runtime-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

rpa_skill_runtime-0.1.1/src/rpa_skill_runtime/__init__.py

@@ -0,0 +1,22 @@
+"""独立 RPA Skill 的轻量运行时。"""
+
+from .action import action_main, run_action
+from .context import ActionContext
+from .errors import InvalidPageState, LoginTimeout, RpaSkillError, TaskLost
+from .lifecycle import lifecycle_main
+from .session import TaskSession
+from .ui import UiTools, ui
+
+__all__ = [
+    "ActionContext",
+    "InvalidPageState",
+    "LoginTimeout",
+    "RpaSkillError",
+    "TaskLost",
+    "TaskSession",
+    "UiTools",
+    "action_main",
+    "lifecycle_main",
+    "run_action",
+    "ui",
+]

rpa_skill_runtime-0.1.1/src/rpa_skill_runtime/action.py

@@ -0,0 +1,79 @@
+"""独立动作脚本的 stdin/stdout JSON 入口。"""
+
+from __future__ import annotations
+
+import asyncio
+import importlib.util
+import inspect
+import json
+import sys
+from pathlib import Path
+from types import ModuleType
+from typing import Any
+
+from .errors import InvalidInput, error_payload
+from .task_client import call_action
+
+
+def load_action_module(action_file: Path) -> ModuleType:
+    name = f"rpa_skill_action_{action_file.stem}_{id(action_file)}"
+    spec = importlib.util.spec_from_file_location(name, action_file)
+    if spec is None or spec.loader is None:
+        raise InvalidInput("无法加载动作脚本")
+    module = importlib.util.module_from_spec(spec)
+    scripts_dir = str(action_file.parent)
+    inserted = scripts_dir not in sys.path
+    if inserted:
+        sys.path.insert(0, scripts_dir)
+    sys.modules[name] = module
+    try:
+        spec.loader.exec_module(module)
+    except BaseException:
+        sys.modules.pop(name, None)
+        raise
+    finally:
+        if inserted:
+            sys.path.remove(scripts_dir)
+    return module
+
+
+async def execute_loaded_action(action_file: Path, session: Any, raw: dict[str, Any]) -> dict[str, Any]:
+    module = load_action_module(action_file)
+    explicit = getattr(module, "run", None)
+    if not inspect.iscoroutinefunction(explicit):
+        raise InvalidInput("动作脚本必须实现 async def run(session, params)")
+    result = await explicit(session, raw)
+    if not isinstance(result, dict):
+        raise InvalidInput("动作必须返回 JSON 对象")
+    return result
+
+
+async def run_action(action_file: str | Path, payload: dict[str, Any]) -> dict[str, Any]:
+    action_file = Path(action_file).resolve()
+    task_id = str(payload.get("task_id") or "")
+    if not task_id:
+        raise InvalidInput("请提供 task_id")
+    page_ref = payload.get("page_ref")
+    params = {key: value for key, value in payload.items() if key not in {"task_id", "page_ref"}}
+    return await call_action(action_file, task_id, params, page_ref=page_ref)
+
+
+def _json_main(handler: Any) -> None:
+    payload: dict[str, Any] = {}
+    try:
+        raw = sys.stdin.read()
+        payload = json.loads(raw or "{}")
+        if not isinstance(payload, dict):
+            raise InvalidInput("stdin 必须是一个 JSON 对象")
+        result = asyncio.run(handler(payload))
+    except BaseException as exc:
+        runtime = getattr(exc, "runtime", None)
+        if runtime is None and payload.get("task_id"):
+            runtime = {"task_id": payload["task_id"], "page_ref": payload.get("page_ref")}
+        result = error_payload(exc, runtime)
+    sys.stdout.write(json.dumps(result, ensure_ascii=False, separators=(",", ":")) + "\n")
+
+
+def action_main(action_file: str | Path) -> None:
+    action_file = Path(action_file).resolve()
+    _json_main(lambda payload: run_action(action_file, payload))

rpa_skill_runtime-0.1.1/src/rpa_skill_runtime/browser.py

@@ -0,0 +1,44 @@
+"""任务运行时与工厂工具共用的浏览器默认环境。"""
+
+from __future__ import annotations
+
+from typing import Any, Iterable
+
+
+BROWSER_VIEWPORT = {"width": 1920, "height": 1080}
+BROWSER_SCREEN = {"width": 1920, "height": 1080}
+BROWSER_LOCALE = "zh-CN"
+BROWSER_TIMEZONE = "Asia/Shanghai"
+BROWSER_ARGS = (
+    "--disable-dev-shm-usage",
+    "--disable-gpu",
+    "--window-position=0,0",
+    # 临时绕过本地 IPv6 解析问题，确认网络环境修复前保留。
+    "--host-resolver-rules=MAP img.yeepay.com 221.194.141.203,EXCLUDE localhost",
+    "--proxy-bypass-list=img.yeepay.com;*.yeepay.com;221.194.141.203;<local>",
+)
+
+
+def merge_browser_args(extra: Iterable[str] | None = None) -> list[str]:
+    """合并启动参数；调用方最后提供的同名参数优先。"""
+    merged: list[str] = []
+    seen: set[str] = set()
+    for argument in reversed([*BROWSER_ARGS, *(str(item) for item in extra or ())]):
+        key = argument.partition("=")[0]
+        if key not in seen:
+            seen.add(key)
+            merged.append(argument)
+    return list(reversed(merged))
+
+
+def browser_context_options(storage_state: str | None = None) -> dict[str, Any]:
+    """返回每个 BrowserContext 独立持有的默认参数。"""
+    options: dict[str, Any] = {
+        "viewport": dict(BROWSER_VIEWPORT),
+        "screen": dict(BROWSER_SCREEN),
+        "locale": BROWSER_LOCALE,
+        "timezone_id": BROWSER_TIMEZONE,
+    }
+    if storage_state:
+        options["storage_state"] = storage_state
+    return options

rpa_skill_runtime-0.1.1/src/rpa_skill_runtime/context.py

@@ -0,0 +1,48 @@
+"""迁移后业务动作使用的页面上下文。"""
+
+from __future__ import annotations
+
+from typing import Any, Generic, TypeVar
+
+from .errors import LoginRequired
+from .ui import UiTools
+
+
+ParamsT = TypeVar("ParamsT")
+
+
+class ActionContext(Generic[ParamsT]):
+    def __init__(self, session: Any, params: ParamsT):
+        self.session = session
+        self.page = session.page
+        self.params = params
+        self.tools = UiTools(self.page)
+
+    async def open(
+        self,
+        url: str,
+        *,
+        ready_button: str | None = None,
+        ready_text: str | None = None,
+        wait_until: str = "domcontentloaded",
+        timeout: int = 60000,
+    ) -> None:
+        await self.page.goto(url, wait_until=wait_until, timeout=timeout)
+        await self._raise_if_login_page()
+        if ready_button:
+            await self.page.get_by_role("button", name=ready_button, exact=True).wait_for(state="visible", timeout=timeout)
+        if ready_text:
+            await self.page.get_by_text(ready_text, exact=True).wait_for(state="visible", timeout=timeout)
+
+    def rows(self, rows: list[dict[str, Any]]) -> dict[str, Any]:
+        return {"rows": rows, "count": len(rows)}
+
+    def records(self, records: list[dict[str, Any]]) -> dict[str, Any]:
+        return {"records": records, "count": len(records)}
+
+    async def _raise_if_login_page(self) -> None:
+        url = self.page.url.lower()
+        if any(marker in url for marker in ("login", "signin", "sign-in", "sso")):
+            password = self.page.locator("input[type=password],input[name=password]")
+            if await password.count():
+                raise LoginRequired("登录态已失效，请先执行当前 Skill 的 login.py")

rpa_skill_runtime-0.1.1/src/rpa_skill_runtime/errors.py

@@ -0,0 +1,48 @@
+"""稳定的运行时错误协议。"""
+
+from __future__ import annotations
+
+from typing import Any
+
+
+class RpaSkillError(RuntimeError):
+    code = "RuntimeError"
+
+    def __init__(self, message: str, *, details: dict[str, Any] | None = None):
+        super().__init__(message)
+        self.details = details or {}
+
+
+class InvalidInput(RpaSkillError):
+    code = "InvalidInput"
+
+
+class TaskLost(RpaSkillError):
+    code = "TaskLost"
+
+
+class InvalidPageState(RpaSkillError):
+    code = "InvalidPageState"
+
+
+class LoginRequired(RpaSkillError):
+    code = "LoginRequired"
+
+
+class LoginTimeout(RpaSkillError):
+    code = "LoginTimeout"
+
+
+class ActionNotAllowed(RpaSkillError):
+    code = "ActionNotAllowed"
+
+
+def error_payload(exc: BaseException, runtime: dict[str, Any] | None = None) -> dict[str, Any]:
+    if isinstance(exc, RpaSkillError):
+        code, details = exc.code, exc.details
+    else:
+        code, details = type(exc).__name__, {}
+    payload: dict[str, Any] = {"error": code, "message": str(exc), "details": details}
+    if runtime:
+        payload["_runtime"] = runtime
+    return payload

rpa_skill_runtime-0.1.1/src/rpa_skill_runtime/lifecycle.py

@@ -0,0 +1,36 @@
+"""系统 Skill 的统一任务生命周期入口。"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any
+
+from .action import _json_main
+from .errors import InvalidInput
+from .task_client import close_page, close_task, start_task, task_status
+
+
+async def _run(skill_dir: Path, operation: str, payload: dict[str, Any]) -> dict[str, Any]:
+    if operation == "start":
+        return await start_task(
+            skill_dir,
+            str(payload.get("account") or ""),
+            headless=bool(payload.get("headless", False)),
+            idle_timeout=int(payload.get("idle_timeout", 900)),
+            browser_args=list(payload.get("browser_args") or []),
+        )
+    task_id = str(payload.get("task_id") or "")
+    if operation == "status":
+        return await task_status(skill_dir, task_id)
+    if operation == "page-close":
+        return await close_page(skill_dir, task_id, str(payload.get("page_ref") or ""))
+    if operation == "close":
+        return await close_task(skill_dir, task_id)
+    raise InvalidInput("生命周期操作必须是 start、status、page-close 或 close")
+
+
+def lifecycle_main(script_file: str | Path) -> None:
+    operation = sys.argv[1] if len(sys.argv) == 2 else ""
+    skill_dir = Path(script_file).resolve().parent.parent
+    _json_main(lambda payload: _run(skill_dir, operation, payload))

rpa_skill_runtime-0.1.1/src/rpa_skill_runtime/session.py

@@ -0,0 +1,105 @@
+"""任务进程内的多页面会话。"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from .errors import ActionNotAllowed, InvalidPageState
+from .state import atomic_write_json, new_page_ref
+
+
+class TaskSession:
+    """一个任务独占的 BrowserContext 及其 Page 集合。"""
+
+    def __init__(self, context: Any, auth_file: Path):
+        self.context = context
+        self.auth_file = auth_file
+        self._pages: dict[str, Any] = {}
+        self._refs: dict[int, str] = {}
+        self.active_page_ref: str | None = None
+        self.allow_auth_write = False
+        context.on("page", self._on_page)
+
+    def _on_page(self, page: Any) -> None:
+        ref = self.register_page(page, activate=True)
+
+        def closed() -> None:
+            self._pages.pop(ref, None)
+            self._refs.pop(id(page), None)
+            if self.active_page_ref == ref:
+                self.active_page_ref = next(reversed(self._pages), None)
+
+        page.on("close", closed)
+
+    def register_page(self, page: Any, *, activate: bool = False) -> str:
+        ref = self._refs.get(id(page))
+        if ref is None:
+            ref = new_page_ref()
+            self._refs[id(page)] = ref
+            self._pages[ref] = page
+        if activate or self.active_page_ref is None:
+            self.active_page_ref = ref
+        return ref
+
+    @property
+    def page(self) -> Any:
+        if not self.active_page_ref or self.active_page_ref not in self._pages:
+            raise InvalidPageState("任务中没有可用页面")
+        return self._pages[self.active_page_ref]
+
+    def select_page(self, page_ref: str | None) -> Any:
+        if page_ref:
+            page = self._pages.get(page_ref)
+            if page is None:
+                raise InvalidPageState("page_ref 不存在或页面已关闭", details={"page_ref": page_ref})
+            self.active_page_ref = page_ref
+        return self.page
+
+    async def new_page(self) -> tuple[str, Any]:
+        page = await self.context.new_page()
+        ref = self.register_page(page, activate=True)
+        return ref, page
+
+    async def activate_page(self, page_ref: str) -> None:
+        page = self.select_page(page_ref)
+        await page.bring_to_front()
+
+    async def close_page(self, page_ref: str) -> None:
+        page = self._pages.get(page_ref)
+        if page is None:
+            raise InvalidPageState("page_ref 不存在或页面已关闭", details={"page_ref": page_ref})
+        await page.close()
+
+    async def save_auth(self) -> None:
+        if not self.allow_auth_write:
+            raise ActionNotAllowed("只有 login.py 可以更新 canonical 登录态")
+        state = await self.context.storage_state(indexed_db=True)
+        atomic_write_json(self.auth_file, state)
+
+    async def pages(self) -> list[dict[str, Any]]:
+        result = []
+        for ref, page in list(self._pages.items()):
+            if page.is_closed():
+                continue
+            try:
+                title = await page.title()
+            except Exception:
+                title = ""
+            result.append(
+                {
+                    "page_ref": ref,
+                    "url": page.url,
+                    "title": title,
+                    "active": ref == self.active_page_ref,
+                }
+            )
+        return result
+
+    async def runtime(self, task_id: str) -> dict[str, Any]:
+        return {
+            "task_id": task_id,
+            "page_ref": self.active_page_ref,
+            "active_page_ref": self.active_page_ref,
+            "pages": await self.pages(),
+        }