android-midscene-automation 0.2.4 → 1.1.1

package/artemis-main/scripts/run_edge_case_part.py

@@ -0,0 +1,327 @@
+"""Interactive Edge-Case Test Suite with Clear Step-by-Step Guidance.
+
+Supports running each edge-case part independently or all together.
+Usage:
+    python scripts/run_edge_case_part.py --part 1
+    python scripts/run_edge_case_part.py --part 2
+    python scripts/run_edge_case_part.py --part 3
+    python scripts/run_edge_case_part.py --part 4
+    python scripts/run_edge_case_part.py --part all
+"""
+
+import argparse
+import asyncio
+import os
+import sys
+import time
+import requests
+
+WORKSPACE_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+if WORKSPACE_ROOT not in sys.path:
+    sys.path.insert(0, WORKSPACE_ROOT)
+
+from artemis.interfaces.sdk.client import ArtemisClient
+from artemis.runtime.device_lock import DeviceExecutionLock
+from artemis.toolchain import ensure_toolchain_in_path
+
+ensure_toolchain_in_path()
+
+from artemis.runtime import device_pool
+
+
+def _resolve_devices() -> tuple[str, str]:
+    all_devs = device_pool.list_devices()
+    real_dev = next((d for d in all_devs if not d.is_emulator and d.state == "device"), None)
+    emu_dev = next((d for d in all_devs if d.is_emulator and d.state == "device"), None)
+    phone = os.environ.get("ARTEMIS_PHONE_SERIAL") or (
+        real_dev.serial if real_dev else "63191FDKX00062"
+    )
+    emu = os.environ.get("ARTEMIS_EMULATOR_SERIAL") or (
+        emu_dev.serial if emu_dev else "emulator-5554"
+    )
+    return phone, emu
+
+
+PHONE_SERIAL, EMULATOR_SERIAL = _resolve_devices()
+API_STATUS_URL = "http://127.0.0.1:8000/api/status"
+
+
+def query_api():
+    try:
+        r = requests.get(API_STATUS_URL, timeout=3).json()
+        return r.get("active_tasks", []), r.get("queue", [])
+    except Exception:
+        return [], []
+
+
+def print_status_snapshot(label: str):
+    active, queue = query_api()
+    print(f"\n[{label}] Web Console Live Snapshot (/api/status):")
+    print(f"  ⚡ Running Tasks ({len(active)}):")
+    for a in active:
+        dev = a.get("device_id") or a.get("device_serial")
+        print(f"     - [Device: {dev}] {a.get('goal')} (PID: {a.get('pid')})")
+    print(f"  ⏳ Pending Tasks ({len(queue)}):")
+    for q in queue:
+        dev = q.get("device_serial") or q.get("device_id")
+        print(f"     - [Device: {dev}] {q.get('goal')} [status={q.get('status')}]")
+    print(f"  📊 Total Active Queue (Running + Pending) = {len(active) + len(queue)}\n")
+
+
+async def run_part_1():
+    print("=" * 80)
+    print("[Part 1: Single Device Serial Queueing & Automatic Relay]")
+    print("=" * 80)
+    print(
+        "🎯 Goal: Launch 2 tasks on the same physical device; verify FIFO queueing, Web Active Queue count, and relay."
+    )
+    print("📱 Target Device: Physical Pixel 11 Pro (63191FDKX00062)")
+    print("👀 Please observe:")
+    print(
+        "   1. Web Console (http://127.0.0.1:8000): Active Queue becomes 2 (1 Running blue badge, 1 Pending yellow badge)"
+    )
+    print(
+        "   2. Device Screen: Task 1A opens Settings first; upon completion, Task 1B automatically takes over to open Clock"
+    )
+    print(
+        "   3. Web Console: After 1A finishes, 1B switches to Running, and queue eventually clears to zero"
+    )
+    print("-" * 80)
+
+    DeviceExecutionLock.cleanup_stale_locks()
+    client = ArtemisClient(device_serial=PHONE_SERIAL, concurrency_mode="per_device")
+
+    async def task_1a():
+        print("🚀 [Task 1A] Launching: Open Settings on physical device...")
+        res = await client.run(
+            "Use manage_app to launch Settings app and report task status completed",
+            profile="flash",
+        )
+        print(f"✅ [Task 1A] Completed: status={res.status}")
+        return res
+
+    async def task_1b():
+        await asyncio.sleep(0.4)
+        print(
+            "🚀 [Task 1B] Launching: Open Clock on physical device -> should immediately enter queue..."
+        )
+        res = await client.run(
+            "Use manage_app to launch Clock app and report task status completed", profile="flash"
+        )
+        print(f"✅ [Task 1B] Completed: status={res.status}")
+        return res
+
+    t1 = asyncio.create_task(task_1a())
+    t2 = asyncio.create_task(task_1b())
+
+    await asyncio.sleep(1.2)
+    print_status_snapshot("Part 1 Running")
+
+    await asyncio.gather(t1, t2)
+    print(
+        "🎉 Part 1 Success: Task 1B automatically relayed and completed after Task 1A finished!\n"
+    )
+
+
+async def run_part_2():
+    print("=" * 80)
+    print("[Part 2: Multi-Device True Parallel Execution]")
+    print("=" * 80)
+    print(
+        "🎯 Goal: Cross-device true concurrency; both devices run independently at the same time without blocking."
+    )
+    print(f"📱 Target Device 1: Physical Pixel 11 Pro ({PHONE_SERIAL})")
+    print(f"💻 Target Device 2: Android Emulator ({EMULATOR_SERIAL})")
+    print("👀 Please observe:")
+    print(
+        "   1. Dual screens: Physical device and emulator operate simultaneously without sequential waiting!"
+    )
+    print(
+        "   2. Web Console (http://127.0.0.1:8000): Active Tasks shows 2 (both with blue Running badges)"
+    )
+    print("   3. Queue count: Queue is 0, each device displays its own Device Serial")
+    print("-" * 80)
+
+    DeviceExecutionLock.cleanup_stale_locks()
+    client_phone = ArtemisClient(device_serial=PHONE_SERIAL, concurrency_mode="per_device")
+    client_emu = ArtemisClient(device_serial=EMULATOR_SERIAL, concurrency_mode="per_device")
+
+    start_t = time.time()
+
+    async def p_task():
+        print(f"🚀 [Phone Task] Launching: Open Settings on {PHONE_SERIAL}...")
+        res = await client_phone.run(
+            "Use manage_app to launch Settings app and report task status completed",
+            profile="flash",
+        )
+        print(f"✅ [Phone Task] Finished in {time.time() - start_t:.2f}s")
+        return res
+
+    async def e_task():
+        print(f"🚀 [Emulator Task] Launching: Open Settings on {EMULATOR_SERIAL}...")
+        res = await client_emu.run(
+            "Use manage_app to launch Settings app and report task status completed",
+            profile="flash",
+        )
+        print(f"✅ [Emulator Task] Finished in {time.time() - start_t:.2f}s")
+        return res
+
+    tp = asyncio.create_task(p_task())
+    te = asyncio.create_task(e_task())
+
+    await asyncio.sleep(1.2)
+    print_status_snapshot("Part 2 Running (Multi-Device Concurrency)")
+
+    await asyncio.gather(tp, te)
+    print(
+        f"🎉 Part 2 Success: Both devices completed tasks concurrently in {time.time() - start_t:.2f}s!\n"
+    )
+
+
+async def run_part_3():
+    print("=" * 80)
+    print("[Part 3: Global Concurrency Limit Across Devices]")
+    print("=" * 80)
+    print(
+        "🎯 Goal: Configure global concurrency mode (global, limit 1); even targeting different devices, tasks must queue globally."
+    )
+    print(f"📱 Device 1: Physical Pixel 11 Pro ({PHONE_SERIAL})")
+    print(f"💻 Device 2: Android Emulator ({EMULATOR_SERIAL})")
+    print("👀 Please observe:")
+    print(
+        "   1. Emulator screen: Even though emulator is completely idle, it waits until the phone task completes!"
+    )
+    print(
+        "   2. Web Console: Phone task is Running (blue badge), emulator task is Pending (yellow badge)!"
+    )
+    print("   3. Once phone finishes, emulator instantly activates and begins execution!")
+    print("-" * 80)
+
+    DeviceExecutionLock.cleanup_stale_locks()
+    client_phone_g = ArtemisClient(device_serial=PHONE_SERIAL, concurrency_mode="global")
+    client_emu_g = ArtemisClient(device_serial=EMULATOR_SERIAL, concurrency_mode="global")
+
+    async def task_3a():
+        print(f"🚀 [Task 3A - Phone] Global mode starting: Executing on {PHONE_SERIAL}...")
+        res = await client_phone_g.run(
+            "Use manage_app to launch Settings app and report task status completed",
+            profile="flash",
+        )
+        print("✅ [Task 3A - Phone] Finished")
+        return res
+
+    async def task_3b():
+        await asyncio.sleep(0.4)
+        print(
+            f"🚀 [Task 3B - Emulator] Global mode starting: Targeting {EMULATOR_SERIAL} (should queue due to global limit)..."
+        )
+        res = await client_emu_g.run(
+            "Use manage_app to launch Settings app and report task status completed",
+            profile="flash",
+        )
+        print("✅ [Task 3B - Emulator] Finished")
+        return res
+
+    t3a = asyncio.create_task(task_3a())
+    t3b = asyncio.create_task(task_3b())
+
+    await asyncio.sleep(1.2)
+    print_status_snapshot("Part 3 Running (Global Limit Cross-Device Queueing)")
+
+    await asyncio.gather(t3a, t3b)
+    print(
+        "🎉 Part 3 Success: Global mutex accurately queued and relayed tasks across physical phone and emulator!\n"
+    )
+
+
+async def run_part_4():
+    print("=" * 80)
+    print("[Part 4: Multi-Device Asymmetric Mixed Queueing]")
+    print("=" * 80)
+    print("🎯 Goal: Assign 2 tasks to physical phone, 1 task to emulator.")
+    print(
+        "   Expected: Phone 4A and Emulator 4C run concurrently; Phone 4B queues in dedicated phone queue; 4B relays immediately on phone after 4A."
+    )
+    print("👀 Please observe:")
+    print(
+        "   1. Web Console: Active Tasks = 2 (Phone 4A + Emulator 4C), Queue = 1 (Phone 4B), Total = 3!"
+    )
+    print(
+        "   2. Screens: Phone and emulator operate concurrently first; Phone 4B executes on phone immediately after 4A finishes!"
+    )
+    print("-" * 80)
+
+    DeviceExecutionLock.cleanup_stale_locks()
+    client_phone = ArtemisClient(device_serial=PHONE_SERIAL, concurrency_mode="per_device")
+    client_emu = ArtemisClient(device_serial=EMULATOR_SERIAL, concurrency_mode="per_device")
+
+    async def task_4a():
+        print("🚀 [Task 4A - Phone] Started...")
+        return await client_phone.run(
+            "Use manage_app to launch Settings app and report task status completed",
+            profile="flash",
+        )
+
+    async def task_4b():
+        await asyncio.sleep(0.4)
+        print("🚀 [Task 4B - Phone] Started (Queued behind 4A)...")
+        return await client_phone.run(
+            "Use manage_app to launch Clock app and report task status completed", profile="flash"
+        )
+
+    async def task_4c():
+        print("🚀 [Task 4C - Emulator] Started concurrently with 4A...")
+        return await client_emu.run(
+            "Use manage_app to launch Settings app and report task status completed",
+            profile="flash",
+        )
+
+    t4a = asyncio.create_task(task_4a())
+    t4b = asyncio.create_task(task_4b())
+    t4c = asyncio.create_task(task_4c())
+
+    await asyncio.sleep(1.2)
+    print_status_snapshot("Part 4 Running (Mixed Queueing)")
+
+    await asyncio.gather(t4a, t4b, t4c)
+    print("Part 4 passed: cross-device concurrency and single-device queueing.\n")
+
+
+async def main():
+    global PHONE_SERIAL, EMULATOR_SERIAL
+    parser = argparse.ArgumentParser(description="Artemis Concurrency & Queue Edge-Cases Runner")
+    parser.add_argument(
+        "--part",
+        choices=["1", "2", "3", "4", "all"],
+        default="1",
+        help="Which part to run (1, 2, 3, 4, or all)",
+    )
+    parser.add_argument("--phone", default=None, help="Target physical phone serial number")
+    parser.add_argument("--emulator", default=None, help="Target Android emulator serial number")
+    args = parser.parse_args()
+
+    if args.phone:
+        PHONE_SERIAL = args.phone
+    if args.emulator:
+        EMULATOR_SERIAL = args.emulator
+
+    if args.part == "1":
+        await run_part_1()
+    elif args.part == "2":
+        await run_part_2()
+    elif args.part == "3":
+        await run_part_3()
+    elif args.part == "4":
+        await run_part_4()
+    elif args.part == "all":
+        await run_part_1()
+        await asyncio.sleep(1)
+        await run_part_2()
+        await asyncio.sleep(1)
+        await run_part_3()
+        await asyncio.sleep(1)
+        await run_part_4()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/artemis-main/scripts/run_ui.py

@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+# 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 UI Quick Launcher (run_ui.py)
+
+Fastest and simplest way to launch the Artemis Web UI across all platforms:
+- Automatically detects if the UI is already running and opens the browser directly.
+- Uses uv or an existing virtualenv.
+- Zero-configuration one-click start.
+"""
+
+import argparse
+import os
+from pathlib import Path
+import socket
+import subprocess
+import sys
+import urllib.request
+import webbrowser
+
+ROOT_DIR = Path(__file__).resolve().parent.parent
+
+
+def is_port_in_use(port: int, host: str = "127.0.0.1") -> bool:
+    """Check whether a TCP port is in use."""
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.settimeout(0.5)
+        return s.connect_ex((host, port)) == 0
+
+
+def is_artemis_ui_responsive(url: str, timeout: float = 1.0) -> bool:
+    """Check if Artemis UI server is responding on given URL."""
+    try:
+        req = urllib.request.Request(url, headers={"User-Agent": "Artemis-QuickLauncher/1.0"})
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return resp.status in (200, 304)
+    except Exception:
+        return False
+
+
+def find_python_executable() -> str:
+    """Find the best Python executable (.venv or system)."""
+    # 1. Check local .venv
+    venv_py = (
+        ROOT_DIR
+        / ".venv"
+        / ("Scripts" if os.name == "nt" else "bin")
+        / ("python.exe" if os.name == "nt" else "python")
+    )
+    if venv_py.is_file() and os.access(venv_py, os.X_OK if os.name != "nt" else os.F_OK):
+        return str(venv_py)
+
+    # 2. Return current sys.executable
+    return sys.executable
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="✨ One-click launcher for Artemis Mobile Agent UI",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+    parser.add_argument("-p", "--port", type=int, default=8000, help="Port to run UI on")
+    parser.add_argument(
+        "-H",
+        "--host",
+        type=str,
+        default="127.0.0.1",
+        help="Host address to bind (loopback by default; use a tunnel for remote access)",
+    )
+    parser.add_argument(
+        "-r",
+        "--restart",
+        action="store_true",
+        help="Restart the server by terminating any existing instance on the port first",
+    )
+    parser.add_argument(
+        "-s",
+        "--stop",
+        action="store_true",
+        help="Stop running Artemis server on the specified port",
+    )
+    parser.add_argument(
+        "--status",
+        action="store_true",
+        help="Display status of running Artemis server on the specified port",
+    )
+    args, unknown = parser.parse_known_args()
+
+    # Ensure project root is on sys.path for lifecycle utility imports
+    if str(ROOT_DIR) not in sys.path:
+        sys.path.insert(0, str(ROOT_DIR))
+
+    from artemis.runtime.server_lifecycle import get_server_status, stop_server
+
+    def _arm_session_reconciler() -> None:
+        # Entry-layer assembly: importing the admin console session repository
+        # registers its orphan-session reconciler with the runtime, so a forced
+        # stop below can mark sessions whose worker processes were killed.
+        try:
+            import apps.admin_console.database.repositories.session_repository  # noqa: F401
+        except Exception:
+            pass
+
+    if args.status:
+        st = get_server_status(args.port)
+        if st["running"]:
+            pid_info = f" (PID: {', '.join(map(str, st['pids']))})" if st["pids"] else ""
+            print(f"\033[1;32m● Artemis Server is RUNNING on port {args.port}{pid_info}\033[0m")
+            print(f"  URL: {st['url']}")
+        else:
+            print(f"\033[1;30m○ Artemis Server is STOPPED (Port {args.port} is free)\033[0m")
+        return
+
+    if args.stop:
+        print(f"\033[1;33m🛑 Stopping Artemis server on port {args.port}...\033[0m")
+        _arm_session_reconciler()
+        ok, msg, pids = stop_server(args.port)
+        print(f"\033[1;32m✓ {msg}\033[0m")
+        return
+
+    ui_url = f"http://localhost:{args.port}"
+    admin_url = f"http://localhost:{args.port}/admin"
+
+    print("\033[1;36m" + "=" * 56 + "\033[0m")
+    print("\033[1;36m      ✨ Artemis Autonomous Mobile Agent UI          \033[0m")
+    print("\033[1;36m" + "=" * 56 + "\033[0m\n")
+
+    # Check if restart requested
+    if args.restart:
+        print(f"\033[1;33m🔄 Restart requested. Recycling port {args.port}...\033[0m")
+        _arm_session_reconciler()
+        ok, msg, pids = stop_server(args.port)
+        if pids:
+            print(f"\033[1;32m✓ {msg}\033[0m\n")
+        else:
+            print(f"Port {args.port} is clear.\n")
+
+    # Check if server is already running
+    elif is_port_in_use(args.port):
+        if is_artemis_ui_responsive(ui_url):
+            print(f"\033[1;32m✓ Artemis UI is already running at:\033[0m \033[1;36m{ui_url}\033[0m")
+            print(f"\033[1;35m🛠️ Admin Console:\033[0m \033[1;36m{admin_url}\033[0m\n")
+
+            # In interactive terminal, allow user to restart or open browser
+            if sys.stdin.isatty():
+                print("Server is active in another session/terminal.")
+                print("  [1] Open browser (default)")
+                print("  [2] Restart server (stop existing and start here)")
+                print("  [3] Stop server")
+                try:
+                    choice = input("Select [1-3, default 1]: ").strip()
+                except (KeyboardInterrupt, EOFError):
+                    choice = "1"
+
+                if choice == "2":
+                    print(f"\n\033[1;33m🔄 Restarting Artemis server on port {args.port}...\033[0m")
+                    _arm_session_reconciler()
+                    stop_server(args.port)
+                elif choice == "3":
+                    print(f"\n\033[1;33m🛑 Stopping Artemis server on port {args.port}...\033[0m")
+                    _arm_session_reconciler()
+                    ok, msg, _ = stop_server(args.port)
+                    print(f"\033[1;32m✓ {msg}\033[0m")
+                    return
+                else:
+                    if not args.no_open:
+                        print("🌐 Opening browser...")
+                        webbrowser.open(ui_url)
+                    return
+            else:
+                if not args.no_open:
+                    print("🌐 Opening browser...")
+                    webbrowser.open(ui_url)
+                return
+        else:
+            print(f"\033[1;33m⚠️ Port {args.port} is in use by another process.\033[0m")
+            print("Attempting to connect or start on specified port...")
+
+    # Choose execution engine: uv run artemis ui > direct python
+    has_uv = (
+        subprocess.run(
+            ["which", "uv"] if os.name != "nt" else ["where", "uv"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        ).returncode
+        == 0
+    )
+
+    cmd = []
+    if has_uv and (ROOT_DIR / "pyproject.toml").exists():
+        # Launch via `python -m artemis` (not the `artemis` console-script shim) so the
+        # long-running server never locks .venv/Scripts/artemis.exe against reinstalls.
+        cmd = [
+            "uv",
+            "run",
+            "python",
+            "-m",
+            "artemis",
+            "ui",
+            "--port",
+            str(args.port),
+            "--host",
+            args.host,
+        ]
+        if args.no_open:
+            cmd.append("--no-open")
+        if args.reload:
+            cmd.append("--reload")
+    else:
+        python_bin = find_python_executable()
+        # Set PYTHONPATH so apps and artemis are importable
+        env = os.environ.copy()
+        env["PYTHONPATH"] = (
+            f"{ROOT_DIR}{os.pathsep}{ROOT_DIR / 'apps'}{os.pathsep}{env.get('PYTHONPATH', '')}"
+        )
+        cmd = [python_bin, "-m", "artemis", "ui", "--port", str(args.port), "--host", args.host]
+        if args.no_open:
+            cmd.append("--no-open")
+        if args.reload:
+            cmd.append("--reload")
+
+    try:
+        # Run the server
+        subprocess.run(cmd, cwd=str(ROOT_DIR))
+    except KeyboardInterrupt:
+        print("\n\033[1;33m🛑 Artemis UI server stopped.\033[0m")
+
+
+if __name__ == "__main__":
+    main()