agentremote-cli 1.0.0__py3-none-any.whl

remotecli/client.py

@@ -0,0 +1,120 @@
+"""
+AgentRemote HTTP Client — 与 Middleware 通信.
+
+供 remotecli CLI 和 AI Agent 使用。
+"""
+
+from __future__ import annotations
+
+import sys
+import time
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import httpx
+
+_RUNTIME_ROOT = Path(__file__).resolve().parents[1]
+_SHARED_ROOT = _RUNTIME_ROOT / "shared"
+if str(_SHARED_ROOT) not in sys.path:
+    sys.path.insert(0, str(_SHARED_ROOT))
+
+from agentremote_common.config import load_cli_defaults
+
+
+class RemoteCliClient:
+    """Middleware HTTP API 客户端。
+
+    handle 由 CLI --handle 传入，每次 HTTP 请求自动带 Authorization: Bearer <handle>。
+    """
+
+    def __init__(self, middleware_url: str = "",
+                 tenant_id: str = "", node_id: str = "",
+                 agent_id: str = "", handle: str = "") -> None:
+        defaults = load_cli_defaults()
+        self.middleware_url = (middleware_url or defaults.middleware_url).rstrip("/")
+        self.tenant_id = tenant_id or defaults.tenant
+        self.node_id = node_id or defaults.node
+        self.agent_id = agent_id or defaults.agent
+        self.handle = handle or defaults.handle
+        self._http = httpx.Client(timeout=httpx.Timeout(10.0))
+
+    def _auth_headers(self) -> Dict[str, str]:
+        """构建 Authorization header (handle 为空时不发)。"""
+        if self.handle:
+            return {"Authorization": f"Bearer {self.handle}"}
+        return {}
+
+    # ── Capabilities ──────────────────────
+
+    def list_capabilities(self) -> Dict[str, Any]:
+        r = self._http.get(
+            f"{self.middleware_url}/api/v1/capabilities",
+            params={"tenant_id": self.tenant_id, "node_id": self.node_id},
+            headers=self._auth_headers(),
+        )
+        r.raise_for_status()
+        return r.json()
+
+    def get_guide(self, capability_id: str) -> Dict[str, Any]:
+        r = self._http.get(
+            f"{self.middleware_url}/api/v1/capabilities/{capability_id}/guide",
+            params={"tenant_id": self.tenant_id, "node_id": self.node_id},
+            headers=self._auth_headers(),
+        )
+        r.raise_for_status()
+        return r.json()
+
+    # ── Tasks ─────────────────────────────
+
+    def submit(self, capability_id: str, tool: str, args: Dict[str, Any] = None,
+               timeout_sec: int = 300) -> Dict[str, Any]:
+        body = {
+            "tenant_id": self.tenant_id,
+            "node_id": self.node_id,
+            "agent_id": self.agent_id,
+            "capability_id": capability_id,
+            "tool": tool,
+            "args": args or {},
+            "timeout_sec": timeout_sec,
+        }
+        try:
+            r = self._http.post(
+                f"{self.middleware_url}/api/v1/tasks",
+                json=body,
+                headers=self._auth_headers(),
+            )
+            r.raise_for_status()
+        except httpx.HTTPStatusError as e:
+            # 把服务端返回的 JSON 错误详情带出来
+            detail = ""
+            try:
+                detail = e.response.json()
+            except Exception:
+                detail = e.response.text
+            return {
+                "status": "rejected",
+                "http_status": e.response.status_code,
+                "detail": detail,
+            }
+        except httpx.RequestError as e:
+            return {
+                "status": "rejected",
+                "reason": "connection_error",
+                "error": str(e),
+            }
+        return r.json()
+
+    def poll_result(self, trace_id: str, timeout_sec: float = 30.0,
+                    interval: float = 0.1) -> Dict[str, Any]:
+        deadline = time.time() + timeout_sec
+        while time.time() < deadline:
+            r = self._http.get(
+                f"{self.middleware_url}/api/v1/tasks/{trace_id}/result",
+                headers=self._auth_headers(),
+            )
+            if r.status_code == 200:
+                data = r.json()
+                if data.get("status") != "pending" and data.get("result") is not None:
+                    return data
+            time.sleep(interval)
+        return {"trace_id": trace_id, "status": "timeout", "result": None}

remotecli/config/agentremote.cli.toml

@@ -0,0 +1,6 @@
+[cli]
+middleware_url = "http://127.0.0.1:9100"
+tenant = "acme_shanghai"
+node = "sh_win_01"
+agent = "agent_ai_01"
+handle = ""

remotecli/cua.py

@@ -0,0 +1,213 @@
+"""
+remotecli cua — CUA 桌面控制子命令.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any, Dict
+
+from .client import RemoteCliClient
+
+
+class CuaCommands:
+    """CUA 桌面控制命令构建器。"""
+
+    def __init__(self, client: RemoteCliClient) -> None:
+        self._client = client
+        self._capability_id = "desktop.cua"
+
+    def _submit(self, tool: str, args: Dict[str, Any], timeout_sec: int = 30) -> Dict[str, Any]:
+        return self._client.submit(self._capability_id, tool, args, timeout_sec=timeout_sec)
+
+    def click(self, pid: int, window_id: int, target: str = "",
+              x: int = 0, y: int = 0, element_index: int = 0,
+              locate_mode: str = "") -> Dict[str, Any]:
+        args: Dict[str, Any] = {"pid": pid, "window_id": window_id}
+        if target:
+            args["target"] = target
+            if locate_mode:
+                args["locate_mode"] = locate_mode
+        elif element_index:
+            args["element_index"] = element_index
+        elif x or y:
+            args["x"] = x
+            args["y"] = y
+        return self._submit("click", args)
+
+    def double_click(self, pid: int, window_id: int, target: str = "",
+                     x: int = 0, y: int = 0, element_index: int = 0,
+                     locate_mode: str = "") -> Dict[str, Any]:
+        args: Dict[str, Any] = {"pid": pid, "window_id": window_id}
+        if target:
+            args["target"] = target
+            if locate_mode:
+                args["locate_mode"] = locate_mode
+        elif element_index:
+            args["element_index"] = element_index
+        elif x or y:
+            args["x"] = x
+            args["y"] = y
+        return self._submit("double_click", args)
+
+    def right_click(self, pid: int, window_id: int, target: str = "",
+                    x: int = 0, y: int = 0, element_index: int = 0,
+                    locate_mode: str = "") -> Dict[str, Any]:
+        args: Dict[str, Any] = {"pid": pid, "window_id": window_id}
+        if target:
+            args["target"] = target
+            if locate_mode:
+                args["locate_mode"] = locate_mode
+        elif element_index:
+            args["element_index"] = element_index
+        elif x or y:
+            args["x"] = x
+            args["y"] = y
+        return self._submit("right_click", args)
+
+    def type_text(self, pid: int, target: str, text: str, element_index: int = 0,
+                  window_id: int = 0, locate_mode: str = "") -> Dict[str, Any]:
+        args: Dict[str, Any] = {"pid": pid, "text": text}
+        if window_id:
+            args["window_id"] = window_id
+        if target:
+            args["target"] = target
+            if locate_mode:
+                args["locate_mode"] = locate_mode
+        elif element_index:
+            args["element_index"] = element_index
+        return self._submit("type_text", args)
+
+    def hotkey(self, pid: int, keys: str | Sequence[str], window_id: int = 0) -> Dict[str, Any]:
+        args: Dict[str, Any] = {"pid": pid, "keys": self._parse_hotkey_keys(keys)}
+        if window_id:
+            args["window_id"] = window_id
+        return self._submit("hotkey", args)
+
+    def press_key(self, pid: int, key: str, window_id: int = 0) -> Dict[str, Any]:
+        args: Dict[str, Any] = {"pid": pid, "key": key}
+        if window_id:
+            args["window_id"] = window_id
+        return self._submit("press_key", args)
+
+    @staticmethod
+    def _parse_hotkey_keys(keys: str | Sequence[str]) -> list[str]:
+        if isinstance(keys, str):
+            separator = "," if "," in keys else "+"
+            parsed = [part.strip() for part in keys.split(separator)]
+        else:
+            parsed = [str(part).strip() for part in keys]
+
+        parsed = [part for part in parsed if part]
+        if not parsed:
+            raise ValueError("hotkey keys must include at least one key")
+        return parsed
+
+    def launch_app(self, name: str = "", path: str = "", args_str: str = "",
+                   wait: bool = False) -> Dict[str, Any]:
+        app_args: Dict[str, Any] = {}
+        if name:
+            app_args["name"] = name
+        if path:
+            app_args["launch_path"] = path
+        if args_str:
+            app_args["args"] = args_str
+        if wait:
+            app_args["wait"] = True
+        return self._submit("launch_app", app_args)
+
+    def list_apps(self, query: str = "", max_results: int = 0) -> Dict[str, Any]:
+        args: Dict[str, Any] = {}
+        if query:
+            args["query"] = query
+        if max_results:
+            args["max_results"] = max_results
+        return self._submit("list_apps", args)
+
+    def list_windows(self, pid: int = 0) -> Dict[str, Any]:
+        args: Dict[str, Any] = {}
+        if pid:
+            args["pid"] = pid
+        return self._submit("list_windows", args)
+
+    def bring_to_front(self, pid: int, window_id: int) -> Dict[str, Any]:
+        return self._submit("bring_to_front", {"pid": pid, "window_id": window_id})
+
+    def get_window_state(self, pid: int, window_id: int, mode: str = "vision") -> Dict[str, Any]:
+        args = {"pid": pid, "window_id": window_id}
+        if mode and mode != "uia":
+            args["capture_mode"] = mode
+        return self._submit("get_window_state", args)
+
+    def probe_window(
+        self,
+        pid: int,
+        window_id: int,
+        targets: Sequence[str],
+        mode: str = "smart",
+    ) -> Dict[str, Any]:
+        return self._submit(
+            "probe_window",
+            {
+                "pid": pid,
+                "window_id": window_id,
+                "targets": [str(target) for target in targets if str(target).strip()],
+                "mode": mode,
+            },
+        )
+
+    def get_cursor_position(self) -> Dict[str, Any]:
+        return self._submit("get_cursor_position", {})
+
+    def move_mouse(self, x: int, y: int) -> Dict[str, Any]:
+        return self._submit("move_mouse", {"x": x, "y": y})
+
+    def move_mouse_relative(self, dx: int, dy: int) -> Dict[str, Any]:
+        return self._submit("move_mouse_relative", {"dx": dx, "dy": dy})
+
+    def scroll(
+        self,
+        pid: int,
+        window_id: int,
+        dx: int = 0,
+        dy: int = 0,
+        direction: str = "",
+        amount: int = 0,
+        by: str = "",
+        dispatch: str = "",
+    ) -> Dict[str, Any]:
+        args: Dict[str, Any] = {"pid": pid, "window_id": window_id}
+        if direction:
+            args["direction"] = direction
+            if amount:
+                args["amount"] = amount
+            if by:
+                args["by"] = by
+            if dispatch:
+                args["dispatch"] = dispatch
+        else:
+            args["dx"] = dx
+            args["dy"] = dy
+        return self._submit("scroll", args)
+
+    def drag(self, pid: int, window_id: int, from_x: int, from_y: int,
+             to_x: int, to_y: int) -> Dict[str, Any]:
+        return self._submit("drag", {
+            "pid": pid, "window_id": window_id,
+            "from_x": from_x, "from_y": from_y,
+            "to_x": to_x, "to_y": to_y,
+        })
+
+    def set_value(self, pid: int, target: str = "", value: str = "",
+                  element_index: int = 0, window_id: int = 0,
+                  locate_mode: str = "") -> Dict[str, Any]:
+        args: Dict[str, Any] = {"pid": pid, "value": value}
+        if window_id:
+            args["window_id"] = window_id
+        if target:
+            args["target"] = target
+            if locate_mode:
+                args["locate_mode"] = locate_mode
+        elif element_index:
+            args["element_index"] = element_index
+        return self._submit("set_value", args)