android-midscene-automation 0.2.4 → 1.1.1

package/artemis-main/artemis/platform/windows.py

@@ -0,0 +1,193 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Windows Platform Implementation (KnownFolders/AppData, Win32 Process Tree & UTF-8 Injection)."""
+
+import os
+from pathlib import Path
+import shutil
+import subprocess
+import sys
+import tempfile
+
+from artemis.platform.base import IPlatform, IPlatformPaths, IPlatformProcess, OSType
+
+
+class WindowsPlatformPaths(IPlatformPaths):
+    """Windows paths adhering to KnownFolders (%APPDATA% / %LOCALAPPDATA%)."""
+
+    def __init__(self):
+        self._home = Path.home()
+
+    @property
+    def config_dir(self) -> Path:
+        appdata = os.getenv("APPDATA")
+        if appdata:
+            p = Path(appdata) / "Artemis"
+        else:
+            p = self._home / "AppData" / "Roaming" / "Artemis"
+        p.mkdir(parents=True, exist_ok=True)
+        return p
+
+    @property
+    def data_dir(self) -> Path:
+        env_dir = os.getenv("ARTEMIS_APP_DIR") or os.getenv("ANTIGRAVITY_APP_DIR")
+        if env_dir:
+            p = Path(env_dir)
+            p.mkdir(parents=True, exist_ok=True)
+            return p
+
+        local_appdata = os.getenv("LOCALAPPDATA")
+        if local_appdata:
+            p = Path(local_appdata) / "Artemis"
+            p.mkdir(parents=True, exist_ok=True)
+            return p
+
+        legacy_jetski = self._home / ".gemini" / "jetski"
+        if legacy_jetski.exists():
+            return legacy_jetski
+
+        legacy_artemis = self._home / ".artemis"
+        if legacy_artemis.exists():
+            return legacy_artemis
+
+        p = self._home / "AppData" / "Local" / "Artemis"
+        p.mkdir(parents=True, exist_ok=True)
+        return p
+
+    @property
+    def cache_dir(self) -> Path:
+        p = self.data_dir / "cache"
+        p.mkdir(parents=True, exist_ok=True)
+        return p
+
+    @property
+    def logs_dir(self) -> Path:
+        p = self.data_dir / "logs"
+        p.mkdir(parents=True, exist_ok=True)
+        return p
+
+    def temp_dir(self, subfolder: str | None = None) -> Path:
+        base = Path(tempfile.gettempdir()) / "artemis"
+        target = base / subfolder if subfolder else base
+        target.mkdir(parents=True, exist_ok=True)
+        return target
+
+    def resolve_app_dir(self) -> Path:
+        return self.data_dir
+
+
+class WindowsPlatformProcess(IPlatformProcess):
+    """Windows process management with tree termination and UTF-8 console streams."""
+
+    @property
+    def path_separator(self) -> str:
+        return ";"
+
+    def terminate_process_tree(self, pid: int, timeout_seconds: float = 3.0) -> bool:
+        # 1. Try taskkill /F /T /PID on Windows (fastest and cleanest for process trees)
+        try:
+            res = subprocess.run(
+                ["taskkill", "/F", "/T", "/PID", str(pid)],
+                stdout=subprocess.DEVNULL,
+                stderr=subprocess.DEVNULL,
+                check=False,
+                timeout=timeout_seconds,
+            )
+            if res.returncode == 0:
+                return True
+        except (OSError, subprocess.SubprocessError):
+            # taskkill missing, not runnable, or timed out; try psutil below.
+            pass
+
+        # 2. Fallback to psutil
+        try:
+            import psutil
+
+            parent = psutil.Process(pid)
+            children = parent.children(recursive=True)
+            for child in children:
+                try:
+                    child.kill()
+                except (psutil.NoSuchProcess, psutil.AccessDenied):
+                    pass
+            parent.kill()
+            return True
+        except Exception:
+            return False
+
+    def setup_utf8_io(self) -> None:
+        """Configures Windows stdout/stderr to UTF-8 mode to prevent encoding crashes."""
+        if hasattr(sys.stdout, "reconfigure"):
+            try:
+                sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+            except (OSError, ValueError):
+                # Stream is detached/closed or does not support reconfigure.
+                pass
+        if hasattr(sys.stderr, "reconfigure"):
+            try:
+                sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+            except (OSError, ValueError):
+                # Stream is detached/closed or does not support reconfigure.
+                pass
+        os.environ["PYTHONUTF8"] = "1"
+
+
+class WindowsPlatform(IPlatform):
+    """Windows Platform Adapter."""
+
+    def __init__(self):
+        self._paths = WindowsPlatformPaths()
+        self._process = WindowsPlatformProcess()
+
+    @property
+    def os_type(self) -> OSType:
+        return OSType.WINDOWS
+
+    @property
+    def paths(self) -> IPlatformPaths:
+        return self._paths
+
+    @property
+    def process(self) -> IPlatformProcess:
+        return self._process
+
+    def get_package_manager_name(self) -> str | None:
+        for pm in ("winget", "choco", "scoop"):
+            if shutil.which(pm):
+                return pm
+        return None
+
+    def get_install_command(self, tool_name: str) -> str:
+        pm = self.get_package_manager_name() or "winget"
+        pkg_map = {
+            "adb": {
+                "winget": "winget install Google.PlatformTools",
+                "choco": "choco install adb",
+                "scoop": "scoop install adb",
+            },
+            "ffmpeg": {
+                "winget": "winget install Gyan.FFmpeg",
+                "choco": "choco install ffmpeg",
+                "scoop": "scoop install ffmpeg",
+            },
+            "scrcpy": {
+                "winget": "winget install Genymobile.scrcpy",
+                "choco": "choco install scrcpy",
+                "scoop": "scoop install scrcpy",
+            },
+        }
+        if tool_name in pkg_map and pm in pkg_map[tool_name]:
+            return pkg_map[tool_name][pm]
+        return f"winget install {tool_name} (or download official installer)"

package/artemis-main/artemis/resources/__init__.py

@@ -0,0 +1,46 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Access to immutable defaults and web assets shipped with Artemis.
+
+Python wheels are installed as ordinary directories by pip, so callers that
+need to hand a path to another library (for example FastAPI's ``FileResponse``)
+can safely use the paths returned here. Source checkouts continue to prefer
+their editable ``config`` and ``apps/showcase_ui/dist`` trees; these resources
+are the installation fallback.
+"""
+
+from importlib.resources import files
+from pathlib import Path
+
+
+def _resource_path(*parts: str) -> Path:
+    """Return a filesystem path inside the installed resource package."""
+    resource = files(__name__).joinpath(*parts)
+    return Path(str(resource))
+
+
+def get_bundled_config_path(filename: str) -> Path | None:
+    """Return a bundled configuration template when it exists."""
+    candidate = _resource_path("config", filename)
+    return candidate if candidate.is_file() else None
+
+
+def get_bundled_showcase_dist() -> Path | None:
+    """Return the bundled Angular browser build when it is complete."""
+    candidate = _resource_path("showcase_ui")
+    return candidate if (candidate / "index.html").is_file() else None
+
+
+__all__ = ["get_bundled_config_path", "get_bundled_showcase_dist"]

package/artemis-main/artemis/runtime/__init__.py

@@ -0,0 +1,108 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Artemis cross-platform runtime and process supervisor subsystem."""
+
+from artemis.runtime.device_lock import (
+    ConcurrencyMode,
+    DeviceBusyError,
+    DeviceExecutionLock,
+)
+from artemis.runtime.adb_endpoint import (
+    ADB_ENDPOINT_ID_ENV,
+    AdbEndpoint,
+    AdbSession,
+    AdbTarget,
+    InvalidAdbEndpoint,
+    current_adb_endpoint,
+)
+from artemis.runtime.device_pool import DevicePool, DeviceStatus, device_pool
+from artemis.runtime.process_probe import pid_is_alive
+from artemis.runtime.daemon_client import (
+    ensure_daemon_running,
+    get_daemon_session,
+    get_daemon_status,
+    is_artemis_daemon,
+    is_daemon_running,
+    stop_task_on_daemon,
+    submit_batch_to_daemon,
+    submit_task_to_daemon,
+    wait_for_daemon_task,
+)
+from artemis.runtime.awake_service import (
+    ensure_device_awake,
+    sanitize_device_state,
+    screen_awake_service,
+    shutdown_awake_service,
+    start_awake_service,
+)
+from artemis.runtime.server_lifecycle import (
+    clear_server_info,
+    find_server_pids,
+    get_server_status,
+    is_port_in_use,
+    read_server_info,
+    stop_server,
+    write_server_info,
+)
+from artemis.runtime.supervisor import ProcessSupervisor, process_supervisor
+from artemis.runtime.cancel_requests import (
+    clear_cancel_request,
+    is_cancel_requested,
+    request_cancel,
+    watch_for_cancel_request,
+)
+
+__all__ = [
+    "ADB_ENDPOINT_ID_ENV",
+    "AdbEndpoint",
+    "AdbSession",
+    "AdbTarget",
+    "ConcurrencyMode",
+    "DeviceBusyError",
+    "DeviceExecutionLock",
+    "DevicePool",
+    "DeviceStatus",
+    "InvalidAdbEndpoint",
+    "clear_cancel_request",
+    "clear_server_info",
+    "current_adb_endpoint",
+    "device_pool",
+    "ensure_daemon_running",
+    "ensure_device_awake",
+    "find_server_pids",
+    "get_daemon_session",
+    "get_daemon_status",
+    "get_server_status",
+    "is_artemis_daemon",
+    "is_daemon_running",
+    "is_cancel_requested",
+    "is_port_in_use",
+    "pid_is_alive",
+    "ProcessSupervisor",
+    "process_supervisor",
+    "read_server_info",
+    "request_cancel",
+    "sanitize_device_state",
+    "screen_awake_service",
+    "shutdown_awake_service",
+    "start_awake_service",
+    "stop_server",
+    "stop_task_on_daemon",
+    "submit_batch_to_daemon",
+    "submit_task_to_daemon",
+    "wait_for_daemon_task",
+    "watch_for_cancel_request",
+    "write_server_info",
+]

package/artemis-main/artemis/runtime/adb_endpoint.py

@@ -0,0 +1,173 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Immutable ADB endpoint and task target primitives.
+
+The selected endpoint is a user preference. An :class:`AdbTarget` is an
+execution snapshot. Keeping those concepts separate prevents a queued or
+running task from silently moving to another ADB server when the preference
+changes in the Admin Console.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+import os
+import re
+import subprocess
+from typing import Any, Mapping, MutableMapping, Sequence
+
+from artemis.config import settings
+from artemis.config.constants import DEFAULT_ADB_HOST, DEFAULT_ADB_PORT
+from artemis.toolchain import toolchain
+
+
+ADB_ENDPOINT_ID_ENV = "ARTEMIS_ADB_ENDPOINT_ID"
+_LOCAL_HOSTS = frozenset({"127.0.0.1", "localhost", "::1"})
+_SAFE_HOST_PATTERN = re.compile(r"^[A-Za-z0-9._:\-\[\]]+$")
+
+
+class InvalidAdbEndpoint(ValueError):
+    """Raised when an ADB server endpoint is malformed."""
+
+
+@dataclass(frozen=True, slots=True)
+class AdbEndpoint:
+    """Network address of one ADB server."""
+
+    host: str
+    port: int
+
+    @classmethod
+    def create(cls, host: str, port: int) -> AdbEndpoint:
+        clean_host = str(host).strip()
+        if clean_host.startswith("[") and clean_host.endswith("]"):
+            clean_host = clean_host[1:-1]
+        if not clean_host:
+            raise InvalidAdbEndpoint("ADB server host cannot be empty.")
+        if len(clean_host) > 253 or not _SAFE_HOST_PATTERN.fullmatch(clean_host):
+            raise InvalidAdbEndpoint(
+                "Enter a valid IP address or host name without a URL scheme or path."
+            )
+        if not 1 <= int(port) <= 65535:
+            raise InvalidAdbEndpoint("ADB server port must be between 1 and 65535.")
+        return cls(host=clean_host, port=int(port))
+
+    @classmethod
+    def from_mapping(cls, value: Mapping[str, Any]) -> AdbEndpoint:
+        return cls.create(str(value.get("host", "")), int(value.get("port", 0)))
+
+    @classmethod
+    def local(cls) -> AdbEndpoint:
+        return cls(DEFAULT_ADB_HOST, DEFAULT_ADB_PORT)
+
+    @property
+    def socket(self) -> str:
+        host = self.host
+        if ":" in host and not host.startswith("["):
+            host = f"[{host}]"
+        return f"tcp:{host}:{self.port}"
+
+    @property
+    def identity(self) -> str:
+        """Stable identity used for task snapshots and device-lock scoping."""
+        return self.socket.lower()
+
+    @property
+    def is_local_default(self) -> bool:
+        return self.host.lower() in _LOCAL_HOSTS and self.port == DEFAULT_ADB_PORT
+
+    @property
+    def mode(self) -> str:
+        return "local" if self.is_local_default else "remote"
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            **asdict(self),
+            "socket": self.socket,
+            "identity": self.identity,
+            "mode": self.mode,
+            "is_local_default": self.is_local_default,
+        }
+
+    def apply_to_environment(
+        self,
+        environment: MutableMapping[str, str] | None = None,
+    ) -> MutableMapping[str, str]:
+        target = environment if environment is not None else os.environ
+        target["ADB_HOST"] = self.host
+        target["ADB_PORT"] = str(self.port)
+        target["ADB_SERVER_SOCKET"] = self.socket
+        target[ADB_ENDPOINT_ID_ENV] = self.identity
+        return target
+
+
+@dataclass(frozen=True, slots=True)
+class AdbTarget:
+    """A device serial bound to the ADB endpoint that discovered it."""
+
+    endpoint: AdbEndpoint
+    serial: str | None = None
+
+    @property
+    def lock_scope(self) -> str:
+        return self.endpoint.identity
+
+    @property
+    def lock_key(self) -> str:
+        return f"{self.lock_scope}/{self.serial or 'pending'}"
+
+    def to_dict(self) -> dict[str, Any]:
+        return {"endpoint": self.endpoint.to_dict(), "serial": self.serial}
+
+
+class AdbSession:
+    """Execute ADB commands against one explicit, immutable endpoint."""
+
+    def __init__(self, endpoint: AdbEndpoint, adb_path: str | None = None) -> None:
+        self.endpoint = endpoint
+        self.adb_path = adb_path or toolchain.resolve("adb")
+
+    def command(self, arguments: Sequence[str]) -> list[str]:
+        if not self.adb_path:
+            raise FileNotFoundError("Android Platform Tools (adb) could not be found.")
+        return [
+            self.adb_path,
+            "-H",
+            self.endpoint.host,
+            "-P",
+            str(self.endpoint.port),
+            *arguments,
+        ]
+
+    def environment(self, base: Mapping[str, str] | None = None) -> dict[str, str]:
+        environment = dict(base if base is not None else os.environ)
+        self.endpoint.apply_to_environment(environment)
+        return environment
+
+    def run(self, arguments: Sequence[str], **kwargs: Any) -> subprocess.CompletedProcess:
+        kwargs.setdefault("env", self.environment())
+        return subprocess.run(self.command(arguments), **kwargs)
+
+
+def current_adb_endpoint() -> AdbEndpoint:
+    """Return the process preference as an immutable endpoint snapshot."""
+    host = settings.ADB_HOST or os.environ.get("ADB_HOST") or DEFAULT_ADB_HOST
+    port = settings.ADB_PORT or os.environ.get("ADB_PORT") or DEFAULT_ADB_PORT
+    return AdbEndpoint.create(str(host), int(port))
+
+
+def adb_command(arguments: Sequence[str]) -> list[str]:
+    """Resolve the ADB binary and add the configured server's host and port."""
+    return AdbSession(current_adb_endpoint()).command(arguments)