Skip to content

Self-improving AI Employees for everyone

refactor(android): self-contained plugin folder

trohitgc394261b55f4
diff --git a/server/core/container.py b/server/core/container.py
index a957df95..c30ee424 100644
--- a/server/core/container.py
+++ b/server/core/container.py
@@ -25,7 +25,7 @@ from services.workflow import WorkflowService
_clog("WorkflowService imported")
from services.auth import AuthService
from services.text import TextService
-from services.android_service import AndroidService
+from nodes.android._dispatcher import AndroidService
from services.user_auth import UserAuthService
from services.compaction import init_compaction_service
_clog("all service imports done")
diff --git a/server/core/logging.py b/server/core/logging.py
index 2ce3d4e1..7db60515 100644
--- a/server/core/logging.py
+++ b/server/core/logging.py
@@ -32,9 +32,10 @@ class WebSocketLogHandler(logging.Handler):
self._source_map = {
'services.workflow': 'workflow',
'services.ai': 'ai',
- 'services.android': 'android',
+ 'nodes.android._relay': 'android',
+ 'nodes.android._dispatcher': 'android',
+ 'nodes.android._router': 'android',
'nodes.whatsapp._service': 'whatsapp',
- 'routers.android': 'android',
'routers.websocket': 'websocket',
'routers.workflow': 'workflow',
'services.execution': 'execution',
diff --git a/server/main.py b/server/main.py
index 434bdc96..b3e50f53 100644
--- a/server/main.py
+++ b/server/main.py
@@ -40,7 +40,7 @@ from core.config import Settings
from core.logging import configure_logging, get_logger, setup_websocket_logging, shutdown_websocket_logging
from core.tracing import init_tracing
_startup_log("Importing routers...")
-from routers import workflow, database, maps, nodejs_compat, android, websocket, webhook, auth, credentials, schemas
+from routers import workflow, database, maps, nodejs_compat, websocket, webhook, auth, credentials, schemas
_startup_log("All imports complete")
# Initialize settings, logging, and tracing.
@@ -85,12 +85,9 @@ async def lifespan(app: FastAPI):
"routers.database",
"routers.maps",
"routers.nodejs_compat",
- "routers.android",
"routers.websocket",
"routers.webhook",
"routers.auth",
- "routers.twitter",
- "routers.google",
"middleware.auth"
])
@@ -353,7 +350,7 @@ async def lifespan(app: FastAPI):
await _proxy_svc.shutdown()
# Close Android relay client (prevents "Unclosed client session" warning)
- from services.android.manager import close_relay_client
+ from nodes.android._relay.manager import close_relay_client
await close_relay_client(clear_stored_session=False)
# Shut down agent-browser daemon (prevents orphaned processes and EBUSY file locks)
@@ -461,11 +458,9 @@ app.include_router(schemas.router) # Per-node output schema endpoint (GET /api/
# register_router from __init__.py), the corresponding line below is
# removed. Tracked in the plugin-extraction plan.
app.include_router(maps.router)
-app.include_router(android.router)
app.include_router(webhook.router)
-# Twitter + Google OAuth callback routers moved to
-# nodes/twitter/_router.py and nodes/google/_router.py and are mounted
-# via the plugin-registered loop below.
+# Twitter, Google, and Android routers moved to nodes/<plugin>/_router.py
+# and are mounted via the plugin-registered loop below.
# Plugin-registered routers — populated by `nodes/<plugin>/__init__.py`
# at import time via `register_router(...)`. Plugins are imported during
diff --git a/server/nodes/android/__init__.py b/server/nodes/android/__init__.py
index 280b448d..5b6793ae 100644
--- a/server/nodes/android/__init__.py
+++ b/server/nodes/android/__init__.py
@@ -1 +1,18 @@
-"""Plugins for the 'android' palette group. See ../__init__.py for the package layout."""
+"""Plugins for the 'android' palette group.
+
+Self-contained plugin folder (Wave 11.H pattern) — owns its
+WebSocket handlers (`_handlers.py`), HTTP router (`_router.py`),
+action-dispatch service (`_dispatcher.py`), and the relay-pairing
+sub-package (`_relay/`). The 16 service plugins (battery_monitor,
+wifi_automation, ...) live alongside as siblings.
+
+Wiring is body-free; both registrations are idempotent.
+"""
+
+from services.ws_handler_registry import register_router, register_ws_handlers
+
+from . import _router
+from ._handlers import WS_HANDLERS
+
+register_ws_handlers(WS_HANDLERS)
+register_router(_router.router, name="android")
diff --git a/server/nodes/android/_base.py b/server/nodes/android/_base.py
index fc32ecb0..81ede6a6 100644
--- a/server/nodes/android/_base.py
+++ b/server/nodes/android/_base.py
@@ -174,7 +174,7 @@ async def _execute_with_broadcast(
host: str, port: int, log_label: str,
) -> Dict[str, Any]:
"""Run an Android service call with broadcast status for the UI node."""
- from services.android_service import AndroidService
+ from ._dispatcher import AndroidService
from services.status_broadcaster import get_status_broadcaster
broadcaster = get_status_broadcaster()
diff --git a/server/services/android_service.py b/server/nodes/android/_dispatcher.py
similarity index 99%
rename from server/services/android_service.py
rename to server/nodes/android/_dispatcher.py
index 9de88d04..7110b56c 100644
--- a/server/services/android_service.py
+++ b/server/nodes/android/_dispatcher.py
@@ -218,7 +218,7 @@ class AndroidService:
Execution result with service response data
"""
try:
- from services.android import get_current_relay_client
+ from ._relay import get_current_relay_client
relay_client = get_current_relay_client()
if not relay_client:
@@ -373,7 +373,7 @@ class AndroidService:
try:
# Check if relay connection is available (remote device)
- from services.android import get_current_relay_client
+ from ._relay import get_current_relay_client
relay_client = get_current_relay_client()
if relay_client and relay_client.is_paired():
diff --git a/server/nodes/android/_handlers.py b/server/nodes/android/_handlers.py
new file mode 100644
index 00000000..338b3c57
--- /dev/null
+++ b/server/nodes/android/_handlers.py
@@ -0,0 +1,163 @@
+"""WebSocket handlers for the Android plugin.
+
+Five handlers split into two concerns:
+
+- ADB / device-action commands (`get_android_devices`,
+ `execute_android_action`) talk to the local `AndroidService`
+ dispatcher to enumerate devices and run service actions.
+
+- Relay-pairing commands (`android_relay_connect` / `_disconnect` /
+ `_reconnect`) drive the WebSocket relay client lifecycle for
+ remote devices.
+
+Self-registers via ``services.ws_handler_registry.register_ws_handlers``
+from ``__init__.py`` (Wave 11.H plugin pattern).
+"""
+
+from __future__ import annotations
+
+import asyncio
+import time
+from typing import Any, Dict
+
+from starlette.websockets import WebSocket
+
+from core.logging import get_logger
+from services.status_broadcaster import get_status_broadcaster
+
+logger = get_logger(__name__)
+
+
+async def handle_get_android_devices(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+ """Get list of connected Android devices."""
+ from core.container import container
+
+ android_service = container.android_service()
+ devices = await android_service.list_devices()
+ return {"devices": devices, "timestamp": time.time()}
+
+
+async def handle_execute_android_action(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+ """Execute an Android service action."""
+ from core.container import container
+
+ android_service = container.android_service()
+ broadcaster = get_status_broadcaster()
+ service_id, action = data["service_id"], data["action"]
+ node_id = data.get("node_id", f"android_{service_id}_{action}")
+
+ await broadcaster.update_node_status(node_id, "executing")
+ result = await android_service.execute_service(
+ node_id=node_id, service_id=service_id, action=action,
+ parameters=data.get("parameters", {}),
+ android_host=data.get("android_host", "localhost"),
+ android_port=data.get("android_port", 8888)
+ )
+
+ status = "success" if result.get("success") else "error"
+ await broadcaster.update_node_status(
+ node_id, status, result.get("result") or {"error": result.get("error")}
+ )
+ return result
+
+
+async def handle_android_relay_connect(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+ """Connect to the Android relay server.
+
+ Establishes the WebSocket connection and broadcasts QR pairing data.
+ Status updates are emitted from the relay client itself.
+ """
+ from ._relay import get_relay_client
+
+ url = data.get("url", "")
+ api_key = data.get("api_key")
+
+ if not url:
+ return {"success": False, "connected": False, "error": "Relay URL is required"}
+ if not api_key:
+ return {"success": False, "connected": False, "error": "API key is required"}
+
+ logger.info(f"[WebSocket] Android relay connect: {url}")
+
+ try:
+ client, error = await get_relay_client(url, api_key)
+ if client:
+ logger.info(
+ f"[WebSocket] Android relay connect success, qr_data present: "
+ f"{bool(client.qr_data)}, session_token: {client.session_token}"
+ )
+ return {
+ "success": True,
+ "connected": True,
+ "session_token": client.session_token,
+ "qr_data": client.qr_data,
+ "message": "Connected to relay server",
+ }
+ return {
+ "success": False,
+ "connected": False,
+ "error": error or "Failed to connect to relay server",
+ }
+ except Exception as e:
+ logger.error(f"[WebSocket] Android relay connect error: {e}")
+ return {"success": False, "error": str(e)}
+
+
+async def handle_android_relay_disconnect(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+ """Disconnect from the Android relay server."""
+ from ._relay import close_relay_client
+
+ logger.info("[WebSocket] Android relay disconnect requested")
+
+ try:
+ await close_relay_client()
+ return {"success": True, "connected": False, "message": "Disconnected from relay server"}
+ except Exception as e:
+ logger.error(f"[WebSocket] Android relay disconnect error: {e}")
+ return {"success": False, "error": str(e)}
+
+
+async def handle_android_relay_reconnect(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+ """Reconnect to the relay with a fresh session token + QR code."""
+ from ._relay import close_relay_client, get_relay_client
+
+ url = data.get("url", "")
+ api_key = data.get("api_key")
+
+ if not url:
+ return {"success": False, "connected": False, "error": "Relay URL is required"}
+ if not api_key:
+ return {"success": False, "connected": False, "error": "API key is required"}
+
+ logger.info("[WebSocket] Android relay reconnect: forcing new session")
+
+ try:
+ await close_relay_client()
+ await asyncio.sleep(0.5) # ensure clean disconnect
+
+ client, error = await get_relay_client(url, api_key)
+ if client:
+ return {
+ "success": True,
+ "connected": True,
+ "session_token": client.session_token,
+ "qr_data": client.qr_data,
+ "message": "Reconnected with new session token",
+ }
+ return {
+ "success": False,
+ "connected": False,
+ "error": error or "Failed to reconnect to relay server",
+ }
+ except Exception as e:
+ logger.error(f"[WebSocket] Android relay reconnect error: {e}")
+ return {"success": False, "error": str(e)}
+
+
+WS_HANDLERS = {
+ "get_android_devices": handle_get_android_devices,
+ "execute_android_action": handle_execute_android_action,
+ "android_relay_connect": handle_android_relay_connect,
+ "android_relay_disconnect": handle_android_relay_disconnect,
+ "android_relay_reconnect": handle_android_relay_reconnect,
+}
diff --git a/server/services/android/__init__.py b/server/nodes/android/_relay/__init__.py
similarity index 100%
rename from server/services/android/__init__.py
rename to server/nodes/android/_relay/__init__.py
diff --git a/server/services/android/broadcaster.py b/server/nodes/android/_relay/broadcaster.py
similarity index 100%
rename from server/services/android/broadcaster.py
rename to server/nodes/android/_relay/broadcaster.py
diff --git a/server/services/android/client.py b/server/nodes/android/_relay/client.py
similarity index 100%
rename from server/services/android/client.py
rename to server/nodes/android/_relay/client.py
diff --git a/server/services/android/manager.py b/server/nodes/android/_relay/manager.py
similarity index 100%
rename from server/services/android/manager.py
rename to server/nodes/android/_relay/manager.py
diff --git a/server/services/android/protocol.py b/server/nodes/android/_relay/protocol.py
similarity index 100%
rename from server/services/android/protocol.py
rename to server/nodes/android/_relay/protocol.py
diff --git a/server/routers/android.py b/server/nodes/android/_router.py
similarity index 98%
rename from server/routers/android.py
rename to server/nodes/android/_router.py
index c4434684..0452f327 100644
--- a/server/routers/android.py
+++ b/server/nodes/android/_router.py
@@ -5,7 +5,7 @@ from pydantic import BaseModel, Field
from typing import Dict, Any
from core.container import container
-from services.android_service import AndroidService
+from ._dispatcher import AndroidService
from core.logging import get_logger
logger = get_logger(__name__)
@@ -258,7 +258,7 @@ async def get_relay_connection_status():
and the paired Android device.
"""
try:
- from services.android import get_current_relay_client
+ from ._relay import get_current_relay_client
relay_client = get_current_relay_client()
diff --git a/server/routers/websocket.py b/server/routers/websocket.py
index 12d61f91..9cf7c1da 100644
--- a/server/routers/websocket.py
+++ b/server/routers/websocket.py
@@ -1410,166 +1410,13 @@ async def handle_test_ai_proxy(data: Dict[str, Any], websocket: WebSocket) -> Di
# ============================================================================
-# Android Handlers
+# Android handlers (5 of them: get_android_devices, execute_android_action,
+# android_relay_{connect,disconnect,reconnect}) live in
+# ``nodes/android/_handlers.py`` and self-register via
+# ``register_ws_handlers``. The plugin's HTTP router lives in
+# ``nodes/android/_router.py`` and mounts via the plugin-router loop.
# ============================================================================
-@ws_handler()
-async def handle_get_android_devices(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Get list of connected Android devices."""
- android_service = container.android_service()
- devices = await android_service.list_devices()
- return {"devices": devices, "timestamp": time.time()}
-
-
-@ws_handler("service_id", "action")
-async def handle_execute_android_action(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Execute an Android service action."""
- android_service = container.android_service()
- broadcaster = get_status_broadcaster()
- service_id, action = data["service_id"], data["action"]
- node_id = data.get("node_id", f"android_{service_id}_{action}")
-
- await broadcaster.update_node_status(node_id, "executing")
- result = await android_service.execute_service(
- node_id=node_id, service_id=service_id, action=action,
- parameters=data.get("parameters", {}),
- android_host=data.get("android_host", "localhost"),
- android_port=data.get("android_port", 8888)
- )
-
- status = "success" if result.get("success") else "error"
- await broadcaster.update_node_status(node_id, status, result.get("result") or {"error": result.get("error")})
- return result
-
-
-@ws_handler()
-async def handle_android_relay_connect(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Connect to Android relay server.
-
- Establishes WebSocket connection to relay server and broadcasts QR code for pairing.
- Status updates are automatically broadcast via the relay client's broadcaster integration.
- """
- from services.android import get_relay_client
-
- url = data.get("url", "")
- api_key = data.get("api_key")
-
- if not url:
- return {
- "success": False,
- "connected": False,
- "error": "Relay URL is required"
- }
-
- if not api_key:
- return {
- "success": False,
- "connected": False,
- "error": "API key is required"
- }
-
- logger.info(f"[WebSocket] Android relay connect: {url}")
-
- try:
- client, error = await get_relay_client(url, api_key)
- if client:
- logger.info(f"[WebSocket] Android relay connect success, qr_data present: {bool(client.qr_data)}, session_token: {client.session_token}")
- return {
- "success": True,
- "connected": True,
- "session_token": client.session_token,
- "qr_data": client.qr_data,
- "message": "Connected to relay server"
- }
- else:
- return {
- "success": False,
- "connected": False,
- "error": error or "Failed to connect to relay server"
- }
- except Exception as e:
- logger.error(f"[WebSocket] Android relay connect error: {e}")
- return {"success": False, "error": str(e)}
-
-
-@ws_handler()
-async def handle_android_relay_disconnect(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Disconnect from Android relay server.
-
- Closes the relay WebSocket connection and broadcasts disconnected status.
- """
- from services.android import close_relay_client
-
- logger.info("[WebSocket] Android relay disconnect requested")
-
- try:
- await close_relay_client()
- return {
- "success": True,
- "connected": False,
- "message": "Disconnected from relay server"
- }
- except Exception as e:
- logger.error(f"[WebSocket] Android relay disconnect error: {e}")
- return {"success": False, "error": str(e)}
-
-
-@ws_handler()
-async def handle_android_relay_reconnect(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
- """Reconnect to Android relay server with a new session token.
-
- Forces disconnect and reconnect to get fresh session_token and QR code.
- Useful when pairing fails or Android device needs to re-pair.
- """
- from services.android import close_relay_client, get_relay_client
-
- url = data.get("url", "")
- api_key = data.get("api_key")
-
- if not url:
- return {
- "success": False,
- "connected": False,
- "error": "Relay URL is required"
- }
-
- if not api_key:
- return {
- "success": False,
- "connected": False,
- "error": "API key is required"
- }
-
- logger.info("[WebSocket] Android relay reconnect: forcing new session")
-
- try:
- # Force disconnect existing connection
- await close_relay_client()
-
- # Small delay to ensure clean disconnect
- await asyncio.sleep(0.5)
-
- # Reconnect with fresh session
- client, error = await get_relay_client(url, api_key)
- if client:
- return {
- "success": True,
- "connected": True,
- "session_token": client.session_token,
- "qr_data": client.qr_data,
- "message": "Reconnected with new session token"
- }
- else:
- return {
- "success": False,
- "connected": False,
- "error": error or "Failed to reconnect to relay server"
- }
- except Exception as e:
- logger.error(f"[WebSocket] Android relay reconnect error: {e}")
- return {"success": False, "error": str(e)}
-
-
# ----------------------------------------------------------------------------
# Per-provider credential validators (Maps geocode probe, Apify /users/me,
@@ -2791,11 +2638,6 @@ MESSAGE_HANDLERS: Dict[str, MessageHandler] = {
# Google Workspace OAuth operations
# Android operations
- "get_android_devices": handle_get_android_devices,
- "execute_android_action": handle_execute_android_action,
- "android_relay_connect": handle_android_relay_connect,
- "android_relay_disconnect": handle_android_relay_disconnect,
- "android_relay_reconnect": handle_android_relay_reconnect,
# Maps + Apify validation now flow through ``handle_validate_api_key``
# (which dispatches via ``CREDENTIAL_REGISTRY`` to
diff --git a/server/services/ai.py b/server/services/ai.py
index 81651783..9444c07e 100644
--- a/server/services/ai.py
+++ b/server/services/ai.py
@@ -2955,7 +2955,7 @@ class AIService:
)
return EmptyAndroidSchema
- from services.android_service import SERVICE_ACTIONS
+ from nodes.android._dispatcher import SERVICE_ACTIONS
service_info = []
for svc in connected_services:
diff --git a/server/services/node_executor.py b/server/services/node_executor.py
index 5f4fbed3..8c484392 100644
--- a/server/services/node_executor.py
+++ b/server/services/node_executor.py
@@ -35,7 +35,7 @@ if TYPE_CHECKING:
from services.ai import AIService
from services.maps import MapsService
from services.text import TextService
- from services.android_service import AndroidService
+ from nodes.android._dispatcher import AndroidService
logger = get_logger(__name__)
diff --git a/server/services/status_broadcaster.py b/server/services/status_broadcaster.py
index 5b76f570..3d09d998 100644
--- a/server/services/status_broadcaster.py
+++ b/server/services/status_broadcaster.py
@@ -443,7 +443,7 @@ class StatusBroadcaster:
async def _auto_reconnect_android_relay_body(self, span):
try:
# Check if already connected
- from services.android.manager import get_current_relay_client
+ from nodes.android._relay.manager import get_current_relay_client
existing = get_current_relay_client()
if existing and existing.is_connected():
# Already connected, just refresh status
@@ -490,7 +490,7 @@ class StatusBroadcaster:
relay_url=relay_url, device_id=device_id)
# Attempt to reconnect
- from services.android.manager import get_relay_client
+ from nodes.android._relay.manager import get_relay_client
client, error = await get_relay_client(relay_url, api_key)
if client and client.is_connected():
diff --git a/server/services/websocket_client.py b/server/services/websocket_client.py
deleted file mode 100644
index 7fb1cefd..00000000
--- a/server/services/websocket_client.py
+++ /dev/null
@@ -1,29 +0,0 @@
-"""
-Android WebSocket Client - DEPRECATED
-
-This module is deprecated. Use services.android instead:
-
- from services.android import (
- RelayWebSocketClient,
- get_relay_client,
- close_relay_client,
- get_current_relay_client,
- )
-
-This file re-exports from the new module for backwards compatibility.
-"""
-
-from services.android import (
- RelayWebSocketClient,
- get_relay_client,
- close_relay_client,
- get_current_relay_client,
-)
-
-# Re-export for backwards compatibility
-__all__ = [
- "RelayWebSocketClient",
- "get_relay_client",
- "close_relay_client",
- "get_current_relay_client",
-]
diff --git a/server/services/workflow.py b/server/services/workflow.py
index fecd6a22..f5185af6 100644
--- a/server/services/workflow.py
+++ b/server/services/workflow.py
@@ -29,7 +29,7 @@ if TYPE_CHECKING:
from services.ai import AIService
from services.maps import MapsService
from services.text import TextService
- from services.android_service import AndroidService
+ from nodes.android._dispatcher import AndroidService
from services.temporal import TemporalExecutor
logger = get_logger(__name__)