machinaos 0.0.78 → 0.0.80

package/server/services/plugin/shutdown_hooks.py

@@ -0,0 +1,103 @@
+"""Plugin-owned shutdown-hook registry for FastAPI lifespan teardown.
+
+Closes the cross-plugin reaches in ``main.py``:
+
+  - ``from nodes.android._relay.manager import close_relay_client``
+  - ``from nodes.browser._service import shutdown_browser_service``
+
+Both made the framework's lifespan code know about specific plugins'
+internals. Plugins with cleanup logic now self-register a hook; the
+lifespan awaits all registered hooks via :func:`run_shutdown_hooks`.
+
+Distinct from :mod:`services._supervisor`: that registry is for
+managed-subprocess supervisors (Go binaries, etc.) with a well-defined
+``shutdown()`` contract. This registry is the general async-cleanup
+hatch — any coroutine-shaped teardown (close a connection, drain a
+queue, flush a cache, ...) goes here.
+
+Hook signature
+--------------
+
+::
+
+    hook() -> Awaitable[None]
+
+The hook is named (label) so failures during shutdown surface with a
+plugin identifier instead of just a traceback. Failures DO NOT block
+sibling hooks — every hook runs even if one raises, mirroring the
+``shutdown_all_supervisors`` semantics.
+"""
+
+from __future__ import annotations
+
+from typing import Awaitable, Callable, List, Tuple
+
+from core.logging import get_logger
+from services.plugin.registry import IdempotentRegistry
+
+logger = get_logger(__name__)
+
+
+ShutdownHook = Callable[[], Awaitable[None]]
+
+
+# Registry is keyed by label so each plugin can register exactly one
+# hook under a stable name. The `items` view preserves insertion order
+# (CPython 3.7+ dict ordering guarantee) which gives deterministic
+# shutdown ordering. Plugins that need ordering invariants should
+# document them via their label naming.
+_REGISTRY: IdempotentRegistry[str, ShutdownHook] = IdempotentRegistry("plugin_shutdown_hook")
+
+
+def register_shutdown_hook(label: str, hook: ShutdownHook) -> None:
+    """Publish a shutdown hook for FastAPI lifespan teardown.
+
+    Idempotent on re-import (same callable for the same label is a
+    no-op). A different callable for an existing label raises
+    ``ValueError`` to surface plugin namespace collisions at import time.
+
+    Args:
+        label: Stable plugin identifier (``"android_relay"``,
+            ``"browser_service"``, ...). Surfaces in shutdown logs +
+            in the error message if the hook raises.
+        hook: Async function taking no arguments. Should be
+            idempotent (lifespan may run it multiple times during
+            test harness teardown).
+    """
+    _REGISTRY.register(label, hook)
+
+
+def registered_labels() -> Tuple[str, ...]:
+    """Return registered hook labels in insertion order (snapshot)."""
+    return tuple(_REGISTRY.keys())
+
+
+async def run_shutdown_hooks() -> None:
+    """Run every registered shutdown hook in registration order.
+
+    Per-hook failures are caught + logged with the hook's label so
+    one slow / broken plugin doesn't strand the rest of the lifespan
+    teardown. Mirrors ``services._supervisor.shutdown_all_supervisors``
+    semantics.
+    """
+    hooks: List[Tuple[str, ShutdownHook]] = list(_REGISTRY.items().items())
+    if not hooks:
+        return
+
+    logger.info(f"Running {len(hooks)} plugin shutdown hook(s): " f"{[label for label, _ in hooks]}")
+    for label, hook in hooks:
+        try:
+            await hook()
+        except Exception as exc:  # noqa: BLE001 — log and continue
+            logger.error(
+                f"Plugin shutdown hook {label!r} raised; continuing: {exc}",
+                exc_info=True,
+            )
+
+
+__all__ = [
+    "register_shutdown_hook",
+    "registered_labels",
+    "run_shutdown_hooks",
+    "ShutdownHook",
+]

package/server/services/plugin/social_provider_registry.py

@@ -0,0 +1,80 @@
+"""Plugin-owned dispatch registry for the social-messaging facade.
+
+Closes the cross-plugin reach from ``nodes/social/_base.py:478`` —
+``from nodes.whatsapp._service import handle_whatsapp_send`` — which
+made the ``social`` plugin depend on the ``whatsapp`` plugin's
+internals and violated the "framework knows no plugin names" rule.
+
+Each social platform plugin (whatsapp, telegram, slack, discord, …)
+registers a send handler keyed by the platform identifier from its
+own ``__init__.py``. The social node queries the registry instead of
+importing platform internals — same Wave-11.I plugin-self-registration
+pattern as ``register_filter_builder`` / ``register_poll_coroutine_factory``
+/ ``register_ws_handlers`` / ``register_canary_trigger_type``.
+
+Handler signature
+-----------------
+
+::
+
+    handler(params: Dict[str, Any]) -> Awaitable[Dict[str, Any]]
+
+The social node maps its own parameter shape onto the platform's
+expected shape and calls the handler. The handler returns the
+platform's native result dict; the social node passes that through.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Awaitable, Callable, Dict, Optional
+
+from services.plugin.registry import IdempotentRegistry
+
+
+# (params: Dict) -> Awaitable[Dict]
+SocialSendHandler = Callable[[Dict[str, Any]], Awaitable[Dict[str, Any]]]
+
+
+_REGISTRY: IdempotentRegistry[str, SocialSendHandler] = IdempotentRegistry("social_send_handler")
+
+
+def register_social_send_handler(platform: str, handler: SocialSendHandler) -> None:
+    """Publish a send handler for one social platform.
+
+    Idempotent on re-import (same callable for the same platform key
+    is a no-op). A different callable for an existing platform raises
+    ``ValueError`` to surface plugin namespace collisions at import time.
+
+    Args:
+        platform: Lower-case platform identifier (``"whatsapp"``,
+            ``"telegram"``, …). Matches the value the social node's
+            ``platform`` parameter holds at runtime.
+        handler: Async function accepting platform-specific
+            ``params: Dict`` and returning the platform's native
+            result dict. The social node builds the params dict by
+            mapping its generic shape onto the platform's keys.
+    """
+    _REGISTRY.register(platform, handler)
+
+
+def get_social_send_handler(platform: str) -> Optional[SocialSendHandler]:
+    """Return the handler for ``platform``, or ``None`` if unregistered.
+
+    A ``None`` return surfaces as a clear "unsupported platform" error
+    at the social node call site instead of an ``ImportError`` deep
+    inside the platform's ``_service.py``.
+    """
+    return _REGISTRY.get(platform)
+
+
+def registered_platforms() -> frozenset[str]:
+    """Return an immutable snapshot of registered platform identifiers."""
+    return frozenset(_REGISTRY.keys())
+
+
+__all__ = [
+    "register_social_send_handler",
+    "get_social_send_handler",
+    "registered_platforms",
+    "SocialSendHandler",
+]

package/server/services/plugin/ws.py

@@ -64,7 +64,8 @@ def ws_response(handler: WSHandlerFn) -> WSHandlerFn:
 
     @wraps(handler)
     async def wrapper(
-        data: Dict[str, Any], websocket: WebSocket,
+        data: Dict[str, Any],
+        websocket: WebSocket,
     ) -> Dict[str, Any]:
         try:
             return await handler(data, websocket)

package/server/services/pricing.py

@@ -26,10 +26,11 @@ CONFIG_PATH = Path(__file__).parent.parent / "config" / "pricing.json"
 @dataclass
 class ModelPricing:
     """Pricing for a specific LLM model."""
-    input_per_mtok: float   # USD per 1M input tokens
+
+    input_per_mtok: float  # USD per 1M input tokens
     output_per_mtok: float  # USD per 1M output tokens
     cache_read_per_mtok: Optional[float] = None  # USD per 1M cache read tokens (Anthropic)
-    reasoning_per_mtok: Optional[float] = None   # USD per 1M reasoning tokens (OpenAI o-series)
+    reasoning_per_mtok: Optional[float] = None  # USD per 1M reasoning tokens (OpenAI o-series)
 
 
 class PricingService:
@@ -44,7 +45,7 @@ class PricingService:
         """Load pricing config from JSON file."""
         if CONFIG_PATH.exists():
             try:
-                with open(CONFIG_PATH, 'r', encoding='utf-8') as f:
+                with open(CONFIG_PATH, "r", encoding="utf-8") as f:
                     self._config = json.load(f)
                 self._build_llm_registry()
                 logger.info(f"[Pricing] Loaded pricing config v{self._config.get('version', 'unknown')}")
@@ -97,7 +98,7 @@ class PricingService:
             # Ensure config directory exists
             CONFIG_PATH.parent.mkdir(parents=True, exist_ok=True)
 
-            with open(CONFIG_PATH, 'w', encoding='utf-8') as f:
+            with open(CONFIG_PATH, "w", encoding="utf-8") as f:
                 json.dump(config, f, indent=2)
 
             # Reload the config into memory
@@ -128,7 +129,7 @@ class PricingService:
             ModelPricing with rates per million tokens
         """
         provider_lower = provider.lower()
-        model_lower = model.lower() if model else ''
+        model_lower = model.lower() if model else ""
 
         provider_pricing = self._llm_registry.get(provider_lower, {})
 
@@ -138,16 +139,16 @@ class PricingService:
 
         # Try partial match (model name starts with a known key)
         for model_key, pricing in provider_pricing.items():
-            if model_key != '_default' and model_lower.startswith(model_key):
+            if model_key != "_default" and model_lower.startswith(model_key):
                 return pricing
 
         # Try if any key is contained in the model name
         for model_key, pricing in provider_pricing.items():
-            if model_key != '_default' and model_key in model_lower:
+            if model_key != "_default" and model_key in model_lower:
                 return pricing
 
         # Fall back to provider default
-        default_pricing = provider_pricing.get('_default')
+        default_pricing = provider_pricing.get("_default")
         if default_pricing:
             return default_pricing
 
@@ -163,7 +164,7 @@ class PricingService:
         output_tokens: int,
         cache_read_tokens: int = 0,
         cache_creation_tokens: int = 0,
-        reasoning_tokens: int = 0
+        reasoning_tokens: int = 0,
     ) -> Dict[str, float]:
         """Calculate cost for LLM token usage.
 
@@ -206,11 +207,11 @@ class PricingService:
         total_cost = input_cost + output_cost + cache_cost + reasoning_cost
 
         return {
-            'input_cost': round(input_cost, 6),
-            'output_cost': round(output_cost, 6),
-            'cache_cost': round(cache_cost, 6),
-            'reasoning_cost': round(reasoning_cost, 6),
-            'total_cost': round(total_cost, 6),
+            "input_cost": round(input_cost, 6),
+            "output_cost": round(output_cost, 6),
+            "cache_cost": round(cache_cost, 6),
+            "reasoning_cost": round(reasoning_cost, 6),
+            "total_cost": round(total_cost, 6),
         }
 
     def get_all_pricing(self) -> Dict[str, Dict[str, Dict[str, float]]]:
@@ -224,10 +225,10 @@ class PricingService:
             result[provider] = {}
             for model, pricing in models.items():
                 result[provider][model] = {
-                    'input': pricing.input_per_mtok,
-                    'output': pricing.output_per_mtok,
-                    'cache_read': pricing.cache_read_per_mtok,
-                    'reasoning': pricing.reasoning_per_mtok,
+                    "input": pricing.input_per_mtok,
+                    "output": pricing.output_per_mtok,
+                    "cache_read": pricing.cache_read_per_mtok,
+                    "reasoning": pricing.reasoning_per_mtok,
                 }
         return result
 
@@ -245,7 +246,7 @@ class PricingService:
         Returns:
             USD cost per resource/request
         """
-        api_config = self._config.get('api', {})
+        api_config = self._config.get("api", {})
         service_config = api_config.get(service, {})
         return service_config.get(operation, 0.0)
 
@@ -258,10 +259,10 @@ class PricingService:
         Returns:
             Dict of {operation: price} for the service
         """
-        api_config = self._config.get('api', {})
+        api_config = self._config.get("api", {})
         service_config = api_config.get(service, {})
         # Filter out metadata keys starting with _
-        return {k: v for k, v in service_config.items() if not k.startswith('_') and isinstance(v, (int, float))}
+        return {k: v for k, v in service_config.items() if not k.startswith("_") and isinstance(v, (int, float))}
 
     def map_action_to_operation(self, service: str, action: str) -> Optional[str]:
         """Map handler action to pricing operation.
@@ -273,16 +274,11 @@ class PricingService:
         Returns:
             Pricing operation key or None if no mapping
         """
-        operation_map = self._config.get('operation_map', {})
+        operation_map = self._config.get("operation_map", {})
         service_map = operation_map.get(service, {})
         return service_map.get(action)
 
-    def calculate_api_cost(
-        self,
-        service: str,
-        action: str,
-        resource_count: int = 1
-    ) -> Dict[str, Any]:
+    def calculate_api_cost(self, service: str, action: str, resource_count: int = 1) -> Dict[str, Any]:
         """Calculate cost for API usage.
 
         Args:
@@ -299,22 +295,12 @@ class PricingService:
         """
         operation = self.map_action_to_operation(service, action)
         if not operation:
-            return {
-                'operation': action,
-                'unit_cost': 0.0,
-                'resource_count': resource_count,
-                'total_cost': 0.0
-            }
+            return {"operation": action, "unit_cost": 0.0, "resource_count": resource_count, "total_cost": 0.0}
 
         unit_cost = self.get_api_price(service, operation)
         total_cost = unit_cost * resource_count
 
-        return {
-            'operation': operation,
-            'unit_cost': unit_cost,
-            'resource_count': resource_count,
-            'total_cost': round(total_cost, 6)
-        }
+        return {"operation": operation, "unit_cost": unit_cost, "resource_count": resource_count, "total_cost": round(total_cost, 6)}
 
 
 # Singleton instance

package/server/services/pricing_handlers.py

@@ -0,0 +1,90 @@
+"""Pricing-domain WS handlers — Wave 13.8 extraction.
+
+Sibling module to ``services/pricing.py`` (the PricingService singleton);
+kept flat instead of a subpackage to avoid renaming the existing
+``services.pricing`` import path used across handlers.
+
+Side-effect import (from ``main.py``) registers the 3 handlers below
+into ``ws_handler_registry``:
+  - ``get_pricing_config`` — return full pricing config for the
+    Settings panel.
+  - ``save_pricing_config`` — persist edits.
+  - ``get_api_usage_summary`` — aggregated API usage / cost by service.
+
+Note: ``get_provider_usage_summary`` (token-pricing summary, per
+provider) moved into ``services/settings/handlers.py`` (Wave 13.3) —
+kept there because it's surfaced in the Credentials Modal alongside
+the provider-defaults panel.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from fastapi import WebSocket
+
+from core.container import container
+from core.logging import get_logger
+from services.ws_handler_registry import register_ws_handlers, ws_handler
+
+logger = get_logger(__name__)
+
+
+@ws_handler()
+async def handle_get_pricing_config(
+    data: Dict[str, Any],
+    websocket: WebSocket,
+) -> Dict[str, Any]:
+    """Get full pricing configuration for display/editing."""
+    from services.pricing import get_pricing_service
+
+    pricing = get_pricing_service()
+    return {"success": True, "config": pricing.get_config()}
+
+
+@ws_handler()
+async def handle_save_pricing_config(
+    data: Dict[str, Any],
+    websocket: WebSocket,
+) -> Dict[str, Any]:
+    """Save updated pricing configuration."""
+    from services.pricing import get_pricing_service
+
+    config = data.get("config")
+    if not config:
+        return {"success": False, "error": "No config provided"}
+
+    pricing = get_pricing_service()
+    success = pricing.save_config(config)
+    return {"success": success}
+
+
+@ws_handler()
+async def handle_get_api_usage_summary(
+    data: Dict[str, Any],
+    websocket: WebSocket,
+) -> Dict[str, Any]:
+    """Get aggregated API usage and cost by service (Twitter, Maps, etc.)."""
+    database = container.database()
+    service = data.get("service")  # Optional filter by service
+    services = await database.get_api_usage_summary(service)
+    return {"success": True, "services": services}
+
+
+WS_HANDLERS: Dict[str, Any] = {
+    "get_pricing_config": handle_get_pricing_config,
+    "save_pricing_config": handle_save_pricing_config,
+    "get_api_usage_summary": handle_get_api_usage_summary,
+}
+
+# Self-register on import — ``main.py`` triggers via
+# ``import services.pricing_handlers``.
+register_ws_handlers(WS_HANDLERS)
+
+
+__all__ = [
+    "WS_HANDLERS",
+    "handle_get_api_usage_summary",
+    "handle_get_pricing_config",
+    "handle_save_pricing_config",
+]

package/server/services/process_service.py

@@ -13,7 +13,7 @@ import asyncio
 import os
 import shlex
 import shutil
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Awaitable, Callable, Dict, List, Optional
@@ -96,15 +96,24 @@ class ProcessService:
         # Block destructive commands -- file ops should use the sandboxed shell node
         cmd_lower = command.lower().strip()
         blocked = (
-            "rm ", "rm\t", "rmdir", "del ", "rd ", "remove-item",
-            "format ", "mkfs", "dd if=", "shred",
-            "> /dev/", "chmod 777", "chmod -r",
+            "rm ",
+            "rm\t",
+            "rmdir",
+            "del ",
+            "rd ",
+            "remove-item",
+            "format ",
+            "mkfs",
+            "dd if=",
+            "shred",
+            "> /dev/",
+            "chmod 777",
+            "chmod -r",
         )
         if any(cmd_lower.startswith(b) or f" {b}" in f" {cmd_lower}" for b in blocked):
             return {
                 "success": False,
-                "error": f"Destructive commands blocked in process_manager. "
-                         f"Use shell_execute for file operations (sandboxed, no PATH).",
+                "error": "Destructive commands blocked in process_manager. " "Use shell_execute for file operations (sandboxed, no PATH).",
             }
 
         name = name or f"proc_{id(command) % 100000}"
@@ -132,18 +141,16 @@ class ProcessService:
         if resolved is None:
             return {
                 "success": False,
-                "error": (
-                    f"Command not found: '{argv[0] if argv else ''}'. "
-                    "Check spelling or ensure the binary is on PATH."
-                ),
+                "error": (f"Command not found: '{argv[0] if argv else ''}'. " "Check spelling or ensure the binary is on PATH."),
             }
         argv[0] = resolved
         env = {**os.environ, "PYTHONUNBUFFERED": "1"}
         from core.config import Settings
+
         workspace_base = Path(Settings().workspace_base_resolved).resolve()
 
         if not working_directory:
-            working_directory = str(workspace_base / 'default')
+            working_directory = str(workspace_base / "default")
             os.makedirs(working_directory, exist_ok=True)
         cwd = working_directory
 
@@ -232,9 +239,7 @@ class ProcessService:
         result = self._info(managed)
 
         # Schedule cleanup after 60s to allow output reading
-        asyncio.get_event_loop().call_later(
-            60, lambda: self._cleanup_completed(workflow_id, name)
-        )
+        asyncio.get_event_loop().call_later(60, lambda: self._cleanup_completed(workflow_id, name))
 
         return {"success": True, "result": result}
 
@@ -272,11 +277,7 @@ class ProcessService:
 
     def list_processes(self, workflow_id: str = "default") -> List[Dict[str, Any]]:
         """List all processes for a workflow."""
-        return [
-            self._info(m)
-            for (wid, _), m in self._processes.items()
-            if wid == workflow_id
-        ]
+        return [self._info(m) for (wid, _), m in self._processes.items() if wid == workflow_id]
 
     def get_output(
         self,
@@ -378,9 +379,7 @@ class ProcessService:
                 shutil.rmtree(managed.log_dir, ignore_errors=True)
         self._processes.clear()
 
-    async def _read_stream(
-        self, managed: ManagedProcess, stream: asyncio.StreamReader, stream_name: str
-    ) -> None:
+    async def _read_stream(self, managed: ManagedProcess, stream: asyncio.StreamReader, stream_name: str) -> None:
         """Background task: read lines, write to log file, broadcast to Terminal."""
         level = "info" if stream_name == "stdout" else "error"
         source = f"process:{managed.name}"
@@ -405,12 +404,14 @@ class ProcessService:
 
                     # Broadcast to Terminal tab
                     if self._broadcaster:
-                        await self._broadcaster.broadcast_terminal_log({
-                            "timestamp": datetime.now().isoformat(),
-                            "level": level,
-                            "message": text,
-                            "source": source,
-                        })
+                        await self._broadcaster.broadcast_terminal_log(
+                            {
+                                "timestamp": datetime.now().isoformat(),
+                                "level": level,
+                                "message": text,
+                                "source": source,
+                            }
+                        )
 
                     # Optional framework-level subscriber.
                     if managed.line_handler is not None:
@@ -419,7 +420,9 @@ class ProcessService:
                         except Exception as cb_err:
                             logger.debug(
                                 "[Process] line_handler %s/%s raised: %s",
-                                managed.name, stream_name, cb_err,
+                                managed.name,
+                                stream_name,
+                                cb_err,
                             )
         except asyncio.CancelledError:
             pass
@@ -436,9 +439,7 @@ class ProcessService:
             logger.info("[Process] Exited: %s (exit=%s)", managed.name, managed.exit_code)
 
             # Schedule auto-cleanup of log files and process entry after delay
-            asyncio.get_event_loop().call_later(
-                60, lambda: self._cleanup_completed(managed.workflow_id, managed.name)
-            )
+            asyncio.get_event_loop().call_later(60, lambda: self._cleanup_completed(managed.workflow_id, managed.name))
 
     @staticmethod
     def _info(m: ManagedProcess) -> Dict[str, Any]:

package/server/services/proxy/models.py

@@ -7,12 +7,14 @@ from pydantic import BaseModel, Field
 
 class SessionType(str, Enum):
     """Proxy session type controlling IP rotation behavior."""
-    ROTATING = "rotating"    # New IP per request (default)
-    STICKY = "sticky"        # Same IP for duration
+
+    ROTATING = "rotating"  # New IP per request (default)
+    STICKY = "sticky"  # Same IP for duration
 
 
 class GeoTarget(BaseModel):
     """Geographic targeting for proxy requests."""
+
     country: Optional[str] = Field(default=None, description="ISO 3166-1 alpha-2 country code")
     city: Optional[str] = Field(default=None, description="City name")
     state: Optional[str] = Field(default=None, description="State/region name")
@@ -20,11 +22,12 @@ class GeoTarget(BaseModel):
 
 class ProviderConfig(BaseModel):
     """Configuration for a proxy provider loaded from database."""
+
     name: str
     enabled: bool = True
-    priority: int = 50                # Lower = preferred
-    weight: float = 1.0               # For weighted random selection
-    cost_per_gb: float = 0.0          # USD per GB
+    priority: int = 50  # Lower = preferred
+    weight: float = 1.0  # For weighted random selection
+    cost_per_gb: float = 0.0  # USD per GB
     gateway_host: str = ""
     gateway_port: int = 0
     geo_coverage: List[str] = Field(default_factory=list)  # ISO country codes
@@ -36,9 +39,10 @@ class ProviderConfig(BaseModel):
 
 class ProviderStats(BaseModel):
     """Runtime health statistics for a proxy provider."""
+
     name: str
-    score: float = 1.0                # 0.0 - 1.0 composite score
-    success_rate: float = 1.0         # 0.0 - 1.0
+    score: float = 1.0  # 0.0 - 1.0 composite score
+    success_rate: float = 1.0  # 0.0 - 1.0
     avg_latency_ms: float = 0.0
     total_requests: int = 0
     total_bytes: int = 0
@@ -47,8 +51,9 @@ class ProviderStats(BaseModel):
 
 class RoutingRule(BaseModel):
     """Domain-based routing rule for proxy selection."""
+
     id: Optional[int] = None
-    domain_pattern: str               # fnmatch glob: "*.linkedin.com", "*"
+    domain_pattern: str  # fnmatch glob: "*.linkedin.com", "*"
     preferred_providers: List[str] = Field(default_factory=list)
     required_country: Optional[str] = None
     session_type: SessionType = SessionType.ROTATING
@@ -56,11 +61,12 @@ class RoutingRule(BaseModel):
     max_retries: int = 3
     failover: bool = True
     min_success_rate: float = 0.7
-    priority: int = 0                 # Lower = evaluated first
+    priority: int = 0  # Lower = evaluated first
 
 
 class ProxyResult(BaseModel):
     """Result of a proxied HTTP request, reported back for scoring."""
+
     success: bool
     latency_ms: float = 0.0
     bytes_transferred: int = 0