android-midscene-automation 0.2.4 → 1.1.0

package/artemis-main/apps/__init__.py

@@ -0,0 +1,15 @@
+# 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 Applications Package."""

package/artemis-main/apps/admin_console/__init__.py

@@ -0,0 +1,19 @@
+# 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 Admin & Trace Console Package."""
+
+from apps.admin_console.server import app
+
+__all__ = ["app"]

package/artemis-main/apps/admin_console/core/__init__.py

@@ -0,0 +1,13 @@
+# 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.

package/artemis-main/apps/admin_console/core/config.py

@@ -0,0 +1,43 @@
+# 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.
+
+"""Admin Console configuration facade.
+
+All configuration and path management is centralized in `artemis.config`.
+This module re-exports common constants for full backward compatibility.
+"""
+
+from artemis.config import (
+    DB_PATH,
+    IMAGES_DIR,
+    PAUSE_FILE,
+    REPLAY_BASE_DIR,
+    TEST_DATA_DIR,
+    TEST_OUTPUTS_DIR,
+    TRACES_PATH,
+    WORKSPACE_ROOT,
+    init_ls_address,
+)
+
+__all__ = [
+    "DB_PATH",
+    "IMAGES_DIR",
+    "PAUSE_FILE",
+    "REPLAY_BASE_DIR",
+    "TEST_DATA_DIR",
+    "TEST_OUTPUTS_DIR",
+    "TRACES_PATH",
+    "WORKSPACE_ROOT",
+    "init_ls_address",
+]

package/artemis-main/apps/admin_console/core/security.py

@@ -0,0 +1,178 @@
+# 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.
+
+"""Same-origin security boundary for the Artemis console.
+
+Artemis runs without user accounts: whoever can reach the TCP port is the
+operator. For that model to hold for a server that browsers also talk to,
+two browser-borne attack vectors must be closed even on a loopback bind:
+
+- DNS rebinding: a page at ``attacker.example`` re-points its DNS record at
+  127.0.0.1 so the victim's browser reads API responses under the attacker's
+  origin. Blocked by validating the ``Host`` header.
+- Cross-site request forgery: any web page can fire side-effectful requests
+  at ``http://127.0.0.1:8000`` from a visitor's browser. Blocked by requiring
+  the ``Origin`` header, when a browser sends one, to match the request host.
+
+Non-browser clients (the SDK, curl, the CLI, MCP) send no ``Origin`` header
+and pass through untouched. Remote access is expected to arrive over a
+network-level tunnel (Tailscale, SSH port forward); a tunnel hostname that is
+not an IP literal can be admitted via ``ARTEMIS_ALLOWED_HOSTS``.
+"""
+
+from __future__ import annotations
+
+import ipaddress
+import json
+import os
+from urllib.parse import urlsplit
+
+_SECURITY_HEADERS: tuple[tuple[bytes, bytes], ...] = (
+    (b"x-content-type-options", b"nosniff"),
+    (b"referrer-policy", b"no-referrer"),
+    (b"x-frame-options", b"DENY"),
+    (b"cross-origin-opener-policy", b"same-origin"),
+)
+
+# Paths whose responses may hold task data, media, or diagnostics and must not
+# land in shared caches or survive on disk after the session.
+_NO_STORE_PREFIXES = ("/api/",)
+
+
+def _hostname(netloc: str) -> str:
+    """Extract the lowercase hostname from a ``host[:port]`` netloc."""
+    netloc = netloc.strip().lower()
+    if netloc.startswith("["):  # IPv6 literal, e.g. [::1]:8000
+        return netloc.partition("]")[0].lstrip("[")
+    return netloc.rpartition(":")[0] if netloc.count(":") == 1 else netloc
+
+
+def _is_ip_literal(host: str) -> bool:
+    """An IP-literal Host cannot be forged through DNS rebinding: a browser
+    only sends ``Host: 192.168.1.5`` when it actually connected to that IP."""
+    try:
+        ipaddress.ip_address(host)
+        return True
+    except ValueError:
+        return False
+
+
+def allowed_hostnames() -> frozenset[str]:
+    """Hostnames (not IP literals) accepted in Host and Origin headers."""
+    names = {"localhost"}
+    extra = os.environ.get("ARTEMIS_ALLOWED_HOSTS", "")
+    names.update(part.strip().lower() for part in extra.split(",") if part.strip())
+    return frozenset(names)
+
+
+def host_is_allowed(host_header: str) -> bool:
+    host = _hostname(host_header)
+    if not host:
+        return False
+    return _is_ip_literal(host) or host in allowed_hostnames()
+
+
+def origin_is_allowed(origin_header: str, host_header: str) -> bool:
+    """A browser request is acceptable when its page is same-origin with this
+    server, or was served from an explicitly allowed tunnel hostname."""
+    origin = origin_header.strip().lower()
+    if not origin or origin == "null":
+        return False
+    origin_netloc = urlsplit(origin).netloc
+    if not origin_netloc:
+        return False
+    if origin_netloc == host_header.strip().lower():
+        return True
+    return _hostname(origin_netloc) in allowed_hostnames()
+
+
+class SameOriginBoundaryMiddleware:
+    """Pure ASGI middleware enforcing the Host/Origin boundary and appending
+    baseline security headers. Pure ASGI (not BaseHTTPMiddleware) so future
+    WebSocket endpoints cannot slip past the Origin check."""
+
+    def __init__(self, app):
+        self.app = app
+
+    async def __call__(self, scope, receive, send):
+        if scope["type"] not in ("http", "websocket"):
+            await self.app(scope, receive, send)
+            return
+
+        if os.environ.get("ARTEMIS_DISABLE_ORIGIN_GUARD", "").lower() in {"1", "true", "yes"}:
+            await self._forward(scope, receive, send)
+            return
+
+        headers = {k.decode("latin-1").lower(): v.decode("latin-1") for k, v in scope["headers"]}
+        host_header = headers.get("host", "")
+        origin_header = headers.get("origin")
+
+        if not host_is_allowed(host_header):
+            await self._reject(
+                scope,
+                send,
+                "Unrecognized Host header. Access Artemis via localhost or an IP address, "
+                "or add your tunnel hostname to ARTEMIS_ALLOWED_HOSTS.",
+            )
+            return
+
+        if origin_header is not None and not origin_is_allowed(origin_header, host_header):
+            await self._reject(
+                scope,
+                send,
+                "Cross-origin browser requests are not accepted by the Artemis console.",
+            )
+            return
+
+        await self._forward(scope, receive, send)
+
+    async def _forward(self, scope, receive, send):
+        if scope["type"] != "http":
+            await self.app(scope, receive, send)
+            return
+
+        path = scope.get("path", "")
+
+        async def send_with_headers(message):
+            if message["type"] == "http.response.start":
+                raw = list(message.get("headers", []))
+                existing = {name.lower() for name, _ in raw}
+                for name, value in _SECURITY_HEADERS:
+                    if name not in existing:
+                        raw.append((name, value))
+                if b"cache-control" not in existing and path.startswith(_NO_STORE_PREFIXES):
+                    raw.append((b"cache-control", b"no-store"))
+                message = {**message, "headers": raw}
+            await send(message)
+
+        await self.app(scope, receive, send_with_headers)
+
+    @staticmethod
+    async def _reject(scope, send, detail: str):
+        if scope["type"] == "websocket":
+            await send({"type": "websocket.close", "code": 1008})
+            return
+        body = json.dumps({"detail": detail}).encode("utf-8")
+        await send(
+            {
+                "type": "http.response.start",
+                "status": 403,
+                "headers": [
+                    (b"content-type", b"application/json"),
+                    (b"content-length", str(len(body)).encode("latin-1")),
+                    *_SECURITY_HEADERS,
+                ],
+            }
+        )
+        await send({"type": "http.response.body", "body": body})

package/artemis-main/apps/admin_console/core/state.py

@@ -0,0 +1,243 @@
+# 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.
+
+import asyncio
+from collections.abc import Callable
+from typing import Any
+
+from artemis.config import PAUSE_FILE
+from artemis.runtime.process_probe import pid_is_alive
+
+
+class ServerState:
+    """Encapsulates all runtime states of the debug server."""
+
+    def __init__(self):
+        self.ipc_subscribers: list[Callable[[str, Any], None]] = []
+        self.ipc_server: asyncio.Server | None = None
+        self.ipc_serve_task: asyncio.Task | None = None
+        self.ipc_port: int | None = None
+        self.port: int = 8000
+        self.host: str = "127.0.0.1"
+        self.is_shutting_down: bool = False
+
+        self.current_process: asyncio.subprocess.Process | None = None
+        self.current_goal: str | None = None
+        self.current_profile: str | None = None
+        self.active_connections: dict[str, dict[str, Any]] = {}
+        self.active_session_id: str | None = None
+        # Run keys (session id, or the synthetic run key of session-less runs)
+        # that were stopped manually. Tracked per run so a manual stop of one
+        # device's task never pollutes the terminal-status resolution of a
+        # concurrently running task on another device. Entries are discarded by
+        # each run's finalizer.
+        self.manually_stopped_run_ids: set[str] = set()
+        self.cancelled_session_ids: set[str] = set()
+        self.startup_progress: dict[str, list[dict[str, Any]]] = {}
+
+        # Concurrent task executions keyed by session_id. Each value holds
+        # {"process", "device_id", "goal", "profile"}. `current_process` /
+        # `active_session_id` mirror the most recently launched run for
+        # backward compatibility with single-task consumers.
+        self.active_runs: dict[str, dict[str, Any]] = {}
+
+        # Unified single source of truth for task queue
+        self.queue_items: list[dict[str, Any]] = []
+        self._wake_event: asyncio.Event | None = None
+        self._shutdown_event: asyncio.Event | None = None
+        self.worker_task: asyncio.Task | None = None
+
+    @property
+    def wake_event(self) -> asyncio.Event:
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = None
+
+        if self._wake_event is None or (
+            loop
+            and getattr(self._wake_event, "_loop", None) is not None
+            and self._wake_event._loop != loop
+        ):
+            self._wake_event = asyncio.Event()
+        return self._wake_event
+
+    @property
+    def shutdown_event(self) -> asyncio.Event:
+        """Event set as soon as the HTTP server receives a shutdown signal."""
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = None
+
+        if self._shutdown_event is None or (
+            loop
+            and getattr(self._shutdown_event, "_loop", None) is not None
+            and self._shutdown_event._loop != loop
+        ):
+            self._shutdown_event = asyncio.Event()
+        return self._shutdown_event
+
+    @property
+    def task_queue(self) -> list[dict[str, Any]]:
+        """Backward compatibility alias for queue_items."""
+        return self.queue_items
+
+    @property
+    def queue_tasks(self) -> list[dict[str, Any]]:
+        """Returns all currently pending tasks in the queue."""
+        return [t for t in self.queue_items if isinstance(t, dict) and t.get("status") == "pending"]
+
+    @queue_tasks.setter
+    def queue_tasks(self, val: list[dict[str, Any]]):
+        # Compatibility setter
+        self.queue_items = list(val)
+
+    @property
+    def queue_goals(self) -> list[str]:
+        """Backward compatibility helper for queue goals."""
+        return [t.get("goal", "") for t in self.queue_tasks]
+
+    @queue_goals.setter
+    def queue_goals(self, val: list[Any]):
+        pass
+
+    def prune_finished_runs(self) -> None:
+        """Drop finished entries from active_runs.
+
+        Besides reaped processes (returncode set), also drops entries whose pid no
+        longer exists: if a run coroutine dies without reaping its child, the entry
+        must not permanently block the scheduler.
+        """
+        for sid, run in list(self.active_runs.items()):
+            proc = run.get("process")
+            if proc is None or proc.returncode is not None:
+                self.active_runs.pop(sid, None)
+                continue
+            pid = getattr(proc, "pid", None)
+            if pid and not pid_is_alive(pid):
+                self.active_runs.pop(sid, None)
+
+    @property
+    def busy_device_ids(self) -> set[str]:
+        """Device serials currently owned by an in-flight run."""
+        self.prune_finished_runs()
+        return {
+            str(run.get("lock_key") or run["device_id"])
+            for run in self.active_runs.values()
+            if run.get("device_id")
+        }
+
+    @property
+    def is_running(self) -> bool:
+        self.prune_finished_runs()
+        if self.active_runs:
+            return True
+        has_proc = False
+        if self.current_process is not None:
+            if self.current_process.returncode is not None:
+                has_proc = False
+                self.current_process = None
+            else:
+                pid = getattr(self.current_process, "pid", None)
+                if pid and pid_is_alive(pid):
+                    has_proc = True
+                else:
+                    has_proc = False
+                    self.current_process = None
+
+        has_running_item = any(
+            isinstance(t, dict) and t.get("status") == "running" for t in self.queue_items
+        )
+
+        has_live_connection = False
+        for sid, conn in list(self.active_connections.items()):
+            c_pid = conn.get("pid")
+            if c_pid:
+                if pid_is_alive(c_pid):
+                    has_live_connection = True
+                else:
+                    self.active_connections.pop(sid, None)
+
+        if not has_proc and not has_running_item and not has_live_connection:
+            self.active_session_id = None
+            self.current_process = None
+            return False
+
+        return True
+
+    @property
+    def is_paused(self) -> bool:
+        return PAUSE_FILE.exists()
+
+    @property
+    def paused_error(self) -> str | None:
+        """Return the persisted pause reason for clients that missed the SSE event."""
+        if not PAUSE_FILE.exists():
+            return None
+        try:
+            message = PAUSE_FILE.read_text(encoding="utf-8", errors="replace").strip()
+        except OSError:
+            return "AI model request failed. The task is paused."
+        if message.startswith("LLM Error: "):
+            message = message[len("LLM Error: ") :]
+        return message or "AI model request failed. The task is paused."
+
+    def add_subscriber(self, callback: Callable[[str, Any], None]):
+        if callback not in self.ipc_subscribers:
+            self.ipc_subscribers.append(callback)
+
+    def remove_subscriber(self, callback: Callable[[str, Any], None]):
+        if callback in self.ipc_subscribers:
+            self.ipc_subscribers.remove(callback)
+
+    def record_startup_progress(self, data: dict[str, Any]) -> None:
+        """Retain the short pre-trace timeline so late SSE clients can catch up."""
+        session_id = data.get("session_id")
+        stage = data.get("stage")
+        if not session_id or not stage:
+            return
+
+        key = str(session_id)
+        events = self.startup_progress.setdefault(key, [])
+        replacement_index = next(
+            (index for index, item in enumerate(events) if item.get("stage") == stage),
+            None,
+        )
+        snapshot = dict(data)
+        if replacement_index is None:
+            events.append(snapshot)
+        else:
+            events[replacement_index] = snapshot
+        self.startup_progress[key] = events[-16:]
+
+    def get_startup_progress(self, session_id: str) -> list[dict[str, Any]]:
+        return [dict(item) for item in self.startup_progress.get(str(session_id), [])]
+
+    def clear_queue(self):
+        """Clears all pending items from the task queue."""
+        self.queue_items = [t for t in self.queue_items if t.get("status") == "running"]
+        if self._wake_event:
+            self._wake_event.set()
+
+
+# Global shared instance
+state = ServerState()
+
+import sys
+
+if __name__ == "admin_console.core.state":
+    sys.modules["apps.admin_console.core.state"] = sys.modules[__name__]
+elif __name__ == "apps.admin_console.core.state":
+    sys.modules["admin_console.core.state"] = sys.modules[__name__]

package/artemis-main/apps/admin_console/database/__init__.py

@@ -0,0 +1,13 @@
+# 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.

package/artemis-main/apps/admin_console/database/connection.py

@@ -0,0 +1,60 @@
+# 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.
+
+from contextlib import contextmanager
+import logging
+from pathlib import Path
+import sqlite3
+
+from artemis.config import DB_PATH
+
+logger = logging.getLogger(__name__)
+
+_initialized_dbs = set()
+
+
+def get_db(db_path: Path | None = None) -> sqlite3.Connection:
+    """Returns a SQLite connection with timeout and Row row_factory."""
+    path = db_path or DB_PATH
+    path_key = str(path)
+    if path_key not in _initialized_dbs:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            from artemis.data_engine.storage import StorageManager
+
+            StorageManager(db_path=path, base_trace_dir=path.parent)
+            _initialized_dbs.add(path_key)
+        except (ImportError, OSError, sqlite3.Error) as exc:
+            # Schema bootstrap is best-effort here; queries against a missing
+            # schema will surface their own errors, but log the root cause.
+            logger.warning("Schema bootstrap failed for %s: %s", path, exc)
+    conn = sqlite3.connect(path, timeout=10.0)
+    conn.row_factory = sqlite3.Row
+    try:
+        conn.execute("PRAGMA journal_mode=WAL")
+        conn.execute("PRAGMA busy_timeout=10000")
+    except sqlite3.Error:
+        # Optional performance PRAGMAs; the connection works without them.
+        pass
+    return conn
+
+
+@contextmanager
+def db_session(db_path: Path | None = None):
+    """Context manager for SQLite connections ensuring clean closure."""
+    conn = get_db(db_path)
+    try:
+        yield conn
+    finally:
+        conn.close()

package/artemis-main/apps/admin_console/database/repositories/__init__.py

@@ -0,0 +1,13 @@
+# 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.