machinaos 0.0.76 → 0.0.78

package/server/nodes/agent/codex_agent.py

@@ -0,0 +1,239 @@
+"""OpenAI Codex CLI agent — multi-instance via `AICliService`.
+
+Sandbox-first companion to `claude_code_agent`. Each task gets its own
+git worktree; sandbox is enforced by Codex itself, not by us.
+
+Codex has no session/resume/budget/turns surface — `CodexTaskSpec`
+exposes only `sandbox` + `ask_for_approval` as task-level overrides.
+"""
+
+from __future__ import annotations
+
+import time
+from datetime import datetime
+from pathlib import Path
+from typing import Any, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from core.logging import get_logger
+from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+from services.plugin.edge_walker import collect_agent_connections
+
+from ._handles import STD_AGENT_HINTS, std_agent_handles
+
+logger = get_logger(__name__)
+
+
+from services.cli_agent import CodexTaskSpec  # noqa: E402
+
+
+class CodexAgentParams(BaseModel):
+    """Multi-task batch parameters for Codex."""
+
+    tasks: List[CodexTaskSpec] = Field(
+        default_factory=list,
+        description="List of Codex tasks to run in parallel (max 5 concurrent).",
+        json_schema_extra={"rows": 1},
+    )
+    prompt: str = Field(
+        default="",
+        description="Legacy: single-prompt fallback used only when "
+                    "`tasks` is empty.",
+        json_schema_extra={"rows": 4, "placeholder": "Or use the tasks array..."},
+    )
+    model: str = Field(
+        default="gpt-5.2-codex",
+        description="Default model for tasks that don't override it.",
+    )
+    sandbox: str = Field(
+        default="workspace-write",
+        description="Default sandbox for tasks that don't override it. "
+                    "One of: read-only | workspace-write | danger-full-access.",
+    )
+    ask_for_approval: str = Field(
+        default="never",
+        description="Default approval mode: untrusted | on-request | never.",
+    )
+    system_prompt: Optional[str] = Field(default=None, json_schema_extra={"rows": 3})
+    working_directory: Optional[str] = None
+    max_parallel: int = Field(default=5, ge=1, le=20)
+    allowed_credentials: List[str] = Field(default_factory=list)
+
+    model_config = ConfigDict(extra="ignore")
+
+
+class CodexAgentOutput(BaseModel):
+    success: bool = True
+    n_tasks: int = 0
+    n_succeeded: int = 0
+    n_failed: int = 0
+    wall_clock_ms: int = 0
+    tasks: List[Any] = Field(default_factory=list)
+    provider: str = "codex"
+    timestamp: Optional[str] = None
+    # Legacy single-task convenience
+    response: Optional[str] = None
+    model_config = ConfigDict(extra="allow")
+
+
+class CodexAgentNode(ActionNode):
+    type = "codex_agent"
+    display_name = "Codex"
+    subtitle = "Sandboxed Coding"
+    group = ("agent",)
+    description = (
+        "Run N parallel OpenAI Codex CLI sessions. Sandbox enforced "
+        "by Codex itself; per-task git worktree isolation."
+    )
+    component_kind = "agent"
+    handles = std_agent_handles()
+    ui_hints = STD_AGENT_HINTS
+    annotations = {"destructive": True, "readonly": False, "open_world": True}
+    task_queue = TaskQueue.AI_HEAVY
+
+    Params = CodexAgentParams
+    Output = CodexAgentOutput
+
+    @Operation(
+        "execute",
+        cost={"service": "codex_agent", "action": "run", "count": 1},
+    )
+    async def execute_op(
+        self, ctx: NodeContext, params: CodexAgentParams,
+    ) -> Any:
+        from services.cli_agent.service import get_ai_cli_service
+        from services.cli_agent.types import session_result_to_model
+        from services.plugin.deps import get_database
+        from services.status_broadcaster import get_status_broadcaster
+
+        start_time = time.time()
+        broadcaster = get_status_broadcaster()
+        workflow_id = ctx.workflow_id
+        node_id = ctx.node_id
+
+        await broadcaster.update_node_status(
+            node_id, "executing",
+            {"message": "Starting Codex batch..."},
+            workflow_id=workflow_id,
+        )
+
+        tasks = list(params.tasks)
+        if not tasks:
+            prompt = params.prompt or self._infer_prompt_from_inputs(ctx, node_id)
+            if not prompt:
+                raise RuntimeError(
+                    "codex_agent: provide either `tasks` or `prompt`"
+                )
+            tasks = [
+                CodexTaskSpec(
+                    prompt=prompt,
+                    model=params.model,
+                    sandbox=params.sandbox,  # type: ignore[arg-type]
+                    ask_for_approval=params.ask_for_approval,  # type: ignore[arg-type]
+                    system_prompt=params.system_prompt,
+                ),
+            ]
+        else:
+            for i, t in enumerate(tasks):
+                changed: dict = {}
+                if not t.model and params.model:
+                    changed["model"] = params.model
+                if not t.system_prompt and params.system_prompt:
+                    changed["system_prompt"] = params.system_prompt
+                if changed:
+                    tasks[i] = t.model_copy(update=changed)
+
+        database = get_database()
+        _, skill_data, _, _, _ = await collect_agent_connections(
+            node_id, ctx.raw, database,
+        )
+        connected_skills = [
+            s.get("skill_name") or s.get("label")
+            for s in skill_data
+            if s.get("skill_name") or s.get("label")
+        ]
+
+        workspace_dir = ctx.raw.get("workspace_dir") or params.working_directory
+        if workspace_dir is None:
+            from core.config import Settings
+            workspace_dir = Path(Settings().workspace_base_resolved) / (
+                workflow_id or "default"
+            )
+        workspace_dir = Path(workspace_dir)
+
+        repo_root = (
+            Path(params.working_directory) if params.working_directory else None
+        )
+
+        svc = get_ai_cli_service()
+        result = await svc.run_batch(
+            "codex",
+            tasks=tasks,
+            node_id=node_id,
+            workflow_id=workflow_id or "",
+            workspace_dir=workspace_dir,
+            broadcaster=broadcaster,
+            repo_root=repo_root,
+            connected_skill_names=connected_skills,
+            allowed_credentials=params.allowed_credentials,
+            max_parallel=params.max_parallel,
+        )
+
+        elapsed = time.time() - start_time
+        logger.debug(
+            "[codex_agent] node=%s tasks=%d ok=%d fail=%d elapsed=%.2fs",
+            node_id, result.n_tasks, result.n_succeeded, result.n_failed, elapsed,
+        )
+
+        await broadcaster.update_node_status(
+            node_id, "success" if result.n_failed == 0 else "warning",
+            {
+                "message": (
+                    f"Batch complete: {result.n_succeeded}/{result.n_tasks} "
+                    f"succeeded"
+                ),
+                "n_tasks": result.n_tasks,
+                "n_succeeded": result.n_succeeded,
+                "n_failed": result.n_failed,
+            },
+            workflow_id=workflow_id,
+        )
+
+        task_models = [session_result_to_model(t).model_dump() for t in result.tasks]
+
+        legacy_response = (
+            result.tasks[0].response if len(result.tasks) == 1 else None
+        )
+
+        return {
+            "success": result.n_failed == 0,
+            "n_tasks": result.n_tasks,
+            "n_succeeded": result.n_succeeded,
+            "n_failed": result.n_failed,
+            "total_cost_usd": result.total_cost_usd,  # always None for Codex
+            "wall_clock_ms": result.wall_clock_ms,
+            "tasks": task_models,
+            "provider": result.provider,
+            "timestamp": result.timestamp or datetime.now().isoformat(),
+            "response": legacy_response,
+        }
+
+    @staticmethod
+    def _infer_prompt_from_inputs(ctx: NodeContext, node_id: str) -> str:
+        for edge in ctx.raw.get("edges", []):
+            if edge.get("target") != node_id:
+                continue
+            handle = edge.get("targetHandle")
+            if handle not in ("input-main", None):
+                continue
+            src = ctx.raw.get("outputs", {}).get(edge.get("source"), {})
+            if isinstance(src, dict):
+                for k in ("message", "text", "content", "prompt"):
+                    val = src.get(k)
+                    if val:
+                        return str(val)
+                return str(src)
+            elif src:
+                return str(src)
+        return ""

package/server/nodes/agent/deep_agent.py

@@ -39,11 +39,11 @@ class DeepAgentNode(ActionNode):
 
     @Operation("execute", cost={"service": "deep_agent", "action": "run", "count": 1})
     async def execute_op(self, ctx: NodeContext, params: SpecializedAgentParams) -> Any:
-        from core.container import container
+        from services.plugin.deps import get_ai_service, get_database
         from services.status_broadcaster import get_status_broadcaster
 
-        ai_service = container.ai_service()
-        database = container.database()
+        ai_service = get_ai_service()
+        database = get_database()
         node_id = ctx.node_id
         workflow_id = ctx.workflow_id
         payload = params.model_dump()

package/server/nodes/agent/rlm_agent.py

@@ -38,11 +38,11 @@ class RLMAgentNode(ActionNode):
 
     @Operation("execute", cost={"service": "rlm_agent", "action": "run", "count": 1})
     async def execute_op(self, ctx: NodeContext, params: SpecializedAgentParams) -> Any:
-        from core.container import container
+        from services.plugin.deps import get_ai_service, get_database
         from services.status_broadcaster import get_status_broadcaster
 
-        ai_service = container.ai_service()
-        database = container.database()
+        ai_service = get_ai_service()
+        database = get_database()
         node_id = ctx.node_id
         workflow_id = ctx.workflow_id
         payload = params.model_dump()

package/server/nodes/android/__init__.py

@@ -1 +1,31 @@
-"""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.status_broadcaster import register_service_refresh
+from services.ws_handler_registry import (
+    register_option_loader,
+    register_router,
+    register_ws_handlers,
+)
+
+from . import _router
+from ._handlers import WS_HANDLERS
+from ._option_loaders import load_service_actions
+from ._refresh import refresh_android_status
+
+register_ws_handlers(WS_HANDLERS)
+register_router(_router.router, name="android")
+register_service_refresh(refresh_android_status)
+
+# loadOptionsMethod loader (Wave 11.I, milestone M.3) -- last entry to
+# leave services/node_option_loaders/, which is deleted at the same
+# commit.
+register_option_loader("getAndroidServiceActions", load_service_actions)

package/server/nodes/android/_base.py

@@ -90,9 +90,13 @@ class AndroidServiceOutput(BaseModel):
 
 
 class AndroidServiceBase(ActionNode, abstract=True):
-    """Subclass and set type/display_name/icon/description."""
+    """Subclass and set type/display_name/icon/description.
+
+    Visual metadata (icon + color) lives in ``server/nodes/visuals.json``
+    keyed by individual plugin type. The ``_visuals.py`` resolver picks
+    each entry up at NodeSpec emit time; no class-level ClassVars needed.
+    """
 
-    color = "#50fa7b"
     group = ("android", "service")
     component_kind = "square"
     handles = (
@@ -110,9 +114,9 @@ class AndroidServiceBase(ActionNode, abstract=True):
 
     @Operation("invoke", cost={"service": "android", "action": "service_call", "count": 1})
     async def invoke(self, ctx: NodeContext, params: AndroidServiceParams) -> Any:
-        from core.container import container
+        from services.plugin.deps import get_android_service
 
-        android_service = container.android_service()
+        android_service = get_android_service()
         payload = params.model_dump()
 
         # Derive service_id from the registered node type (battery etc.) —
@@ -174,7 +178,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()

package/server/{services/android_service.py → 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():

package/server/nodes/android/_handlers.py

@@ -0,0 +1,154 @@
+"""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.plugin.ws import ws_response
+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 services.plugin.deps import get_android_service
+
+    android_service = get_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 services.plugin.deps import get_android_service
+
+    android_service = get_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_response
+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}")
+
+    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",
+    }
+
+
+@ws_response
+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")
+    await close_relay_client()
+    return {"success": True, "connected": False, "message": "Disconnected from relay server"}
+
+
+@ws_response
+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")
+
+    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",
+    }
+
+
+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,
+}

package/server/nodes/android/_option_loaders.py

@@ -0,0 +1,44 @@
+"""Android ``loadOptionsMethod`` loaders.
+
+Wave 11.I, milestone M.3. Returns the list of actions supported by each
+Android service node. The frontend passes ``node_type`` in params; the
+loader maps it to the service's ``action`` enum advertised by the
+running Android bridge.
+
+``SERVICE_ID_MAP`` is the single source of truth -- imported from
+``_base.py`` instead of being duplicated here (the pre-Wave-11.I
+``services/node_option_loaders/android_loaders.py`` carried its own
+copy under a different name; that copy is gone now).
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from ._base import SERVICE_ID_MAP
+
+
+async def load_service_actions(params: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """Return ``[{value, label}]`` for the given Android service node.
+
+    Each service's ``execute_action`` endpoint validates the action at
+    call time; the dropdown is convenience UX, not a correctness
+    boundary. The frontend falls back to a free-text input if the
+    loader returns an empty list (service offline / discovery failed).
+    """
+    node_type = params.get("node_type") or ""
+    service_id = SERVICE_ID_MAP.get(node_type)
+    if not service_id:
+        return []
+
+    try:
+        from services.plugin.deps import get_android_service
+
+        android_svc = get_android_service()
+        actions = await android_svc.list_actions(service_id)  # type: ignore[attr-defined]
+        return [
+            {"value": a, "label": a.replace("_", " ").title()}
+            for a in actions or []
+        ]
+    except Exception:
+        return []

package/server/nodes/android/_refresh.py

@@ -0,0 +1,127 @@
+"""Android service-status refresh callback (Wave 11.I, milestone J).
+
+Moved from ``services/status_broadcaster._auto_reconnect_android_relay``
+(plus the ``_auto_reconnect_android_relay_body`` helper). Plugin
+packages register their own callback via
+``status_broadcaster.register_service_refresh``; the broadcaster no
+longer hardcodes a per-service refresh.
+
+Load-bearing: this is the path that auto-reconnects the Android relay
+from a stored pairing session after server restart. Without it the
+relay sits idle until the user manually clicks Connect. Runs once on
+lifespan startup (post-V).
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from opentelemetry import trace
+
+if TYPE_CHECKING:
+    from services.status_broadcaster import StatusBroadcaster
+
+logger = logging.getLogger(__name__)
+tracer = trace.get_tracer(__name__)
+
+
+async def refresh_android_status(broadcaster: "StatusBroadcaster") -> None:
+    """Auto-reconnect to the Android relay if a stored pairing exists.
+
+    Called once per ``_refresh_all_services`` cycle (post-V: at
+    lifespan startup only).
+    """
+    with tracer.start_as_current_span("broadcaster.refresh_android") as span:
+        await _auto_reconnect_body(broadcaster, span)
+
+
+async def _auto_reconnect_body(broadcaster: "StatusBroadcaster", span) -> None:
+    try:
+        # Already connected? Refresh the cached snapshot and stop.
+        from ._relay.manager import get_current_relay_client
+
+        existing = get_current_relay_client()
+        if existing and existing.is_connected():
+            broadcaster._status["android"] = {
+                "connected": True,
+                "paired": existing.is_paired(),
+                "device_id": existing.paired_device_id,
+                "device_name": existing.paired_device_name,
+                "connected_devices": list(existing.get_connected_devices()),
+                "connection_type": "relay",
+                "qr_data": existing.qr_data,
+                "session_token": existing.session_token,
+            }
+            logger.debug("[StatusBroadcaster] Android relay already connected")
+            await broadcaster.broadcast({
+                "type": "android_status",
+                "data": broadcaster._status["android"],
+            })
+            span.set_attribute("path", "already_connected")
+            return
+
+        # Look for a stored pairing session.
+        from services.plugin.deps import get_database
+
+        database = get_database()
+        session = await database.get_android_relay_session()
+        if not session:
+            span.set_attribute("path", "no_session")
+            logger.debug("[StatusBroadcaster] No stored Android relay session")
+            return
+
+        relay_url = session.get("relay_url")
+        api_key = session.get("api_key")
+        device_id = session.get("device_id")
+
+        if not relay_url or not api_key:
+            span.set_attribute("path", "session_missing_creds")
+            logger.debug(
+                "[StatusBroadcaster] Stored session missing relay URL or API key"
+            )
+            return
+
+        span.set_attribute("path", "auto_reconnect")
+        logger.info(
+            "[StatusBroadcaster] Auto-reconnecting to Android relay...",
+            relay_url=relay_url,
+            device_id=device_id,
+        )
+
+        from ._relay.manager import get_relay_client
+
+        client, error = await get_relay_client(relay_url, api_key)
+
+        if client and client.is_connected():
+            logger.info("[StatusBroadcaster] Android relay reconnected successfully")
+            # The relay server creates a new session on each connect, so
+            # pairing may be lost -- mirror whatever the new client
+            # reports.
+            broadcaster._status["android"] = {
+                "connected": True,
+                "paired": client.is_paired(),
+                "device_id": client.paired_device_id,
+                "device_name": client.paired_device_name,
+                "connected_devices": list(client.get_connected_devices()),
+                "connection_type": "relay",
+                "qr_data": client.qr_data,
+                "session_token": client.session_token,
+            }
+            await broadcaster.broadcast({
+                "type": "android_status",
+                "data": broadcaster._status["android"],
+            })
+            span.set_attribute("reconnect_ok", True)
+        else:
+            span.set_attribute("reconnect_ok", False)
+            logger.warning(
+                "[StatusBroadcaster] Failed to reconnect Android relay: %s", error
+            )
+            # Stored session is stale; drop it.
+            await database.clear_android_relay_session()
+    except Exception as exc:  # noqa: BLE001 -- mirror pre-migration behaviour
+        span.record_exception(exc)
+        logger.debug(
+            "[StatusBroadcaster] Could not auto-reconnect Android relay: %s", exc
+        )