android-midscene-automation 0.2.4 → 1.1.1

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.