machinaos 0.0.76 → 0.0.78

package/server/nodes/google/_refresh.py

@@ -0,0 +1,66 @@
+"""Google Workspace service-status refresh callback (Wave 11.I, milestone J).
+
+Moved from ``services/status_broadcaster._refresh_google_status``.
+Plugin packages register their own callback via
+``status_broadcaster.register_service_refresh``; the broadcaster no
+longer hardcodes a per-service refresh.
+
+Reads OAuth tokens via ``auth_service.get_oauth_tokens("google")`` and
+mirrors the result into the broadcaster cache.
+"""
+
+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_google_status(broadcaster: "StatusBroadcaster") -> None:
+    """Refresh Google cache + broadcast. One pass per
+    ``_refresh_all_services`` cycle.
+    """
+    with tracer.start_as_current_span("broadcaster.refresh_google") as span:
+        try:
+            from services.plugin.deps import get_auth_service
+
+            auth_service = get_auth_service()
+            tokens = await auth_service.get_oauth_tokens(
+                "google", customer_id="owner"
+            )
+            if not tokens or not tokens.get("access_token"):
+                broadcaster._status["google"] = {
+                    "connected": False,
+                    "email": None,
+                    "name": None,
+                }
+            else:
+                broadcaster._status["google"] = {
+                    "connected": True,
+                    "email": tokens.get("email"),
+                    "name": tokens.get("name"),
+                }
+                logger.debug(
+                    "[StatusBroadcaster] Google status: connected as %s",
+                    tokens.get("email"),
+                )
+
+            await broadcaster.broadcast({
+                "type": "google_status",
+                "data": broadcaster._status["google"],
+            })
+            span.set_attribute(
+                "connected", bool(broadcaster._status["google"]["connected"])
+            )
+        except Exception as exc:  # noqa: BLE001
+            span.record_exception(exc)
+            logger.debug(
+                "[StatusBroadcaster] Could not refresh Google status: %s", exc
+            )

package/server/nodes/google/_router.py

@@ -0,0 +1,131 @@
+"""Google Workspace OAuth callback router — factory-built (Wave 11.I, S.2).
+
+Two endpoints:
+
+* ``GET /api/google/callback`` -- built by
+  :func:`services.events.oauth_lifecycle.make_oauth_callback_router`.
+  ``extra_state_handler`` routes customer-mode logins (where
+  ``state_data["mode"] == "customer"`` and a ``customer_id`` is set)
+  to the ``google_connections`` table by overriding ``customer_id``
+  on ``store_oauth_tokens``. ``redirect_after`` from the same state
+  data triggers a 302 to the customer-portal URL.
+* ``POST /api/google/customer-auth-url`` -- generates an OAuth URL for
+  a specific customer (Google-only multi-tenant feature; Twitter
+  ships owner-mode only).
+
+The pre-S file also exposed ``GET /status`` and ``POST /logout`` REST
+routes; both duplicated the WS handlers in ``_handlers.py`` and have
+been retired in line with the Twitter migration.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from fastapi import APIRouter, Request
+
+from services.events.oauth_lifecycle import make_oauth_callback_router
+
+from ._handlers import _google_oauth_factory
+
+
+def _user_info_to_email(info: Dict[str, Any]) -> str:
+    return info.get("email", "Unknown") or "Unknown"
+
+
+def _user_info_to_name(info: Dict[str, Any]) -> str:
+    return info.get("name", "") or ""
+
+
+async def _customer_mode_handler(
+    payload: Dict[str, Any],
+) -> Optional[Dict[str, Any]]:
+    """If the auth flow was launched in customer mode, route the
+    token storage to the customer's slot + return a 302 target.
+
+    Owner mode -> returns ``None`` (lifecycle factory keeps its
+    defaults).
+    """
+    state_data = payload.get("state_data") or {}
+    if state_data.get("mode") != "customer":
+        return None
+
+    customer_id = state_data.get("customer_id")
+    if not customer_id:
+        return None
+
+    user_info = payload.get("user_info") or {}
+    email = user_info.get("email", "Unknown")
+    redirect_after = state_data.get("redirect_after")
+
+    overrides: Dict[str, Any] = {"customer_id": customer_id}
+    if redirect_after:
+        overrides["redirect_after"] = (
+            f"{redirect_after}?google_connected=true"
+            f"&customer={customer_id}&email={email}"
+        )
+    return overrides
+
+
+# The factory mounts ``GET /api/google/callback``. Google-specific
+# extras (the customer-auth-url route + the customer-mode hook) layer
+# on top of the same router instance.
+router: APIRouter = make_oauth_callback_router(
+    provider="google",
+    oauth_factory=_google_oauth_factory,
+    user_info_to_email=_user_info_to_email,
+    user_info_to_name=_user_info_to_name,
+    extra_state_handler=_customer_mode_handler,
+    color_hex="#34a853",
+)
+
+
+@router.post("/customer-auth-url")
+async def generate_customer_auth_url(
+    request: Request, customer_id: str, redirect_after: Optional[str] = None,
+):
+    """Generate OAuth URL for a customer to connect their Google account."""
+    from services.oauth_utils import get_redirect_uri
+
+    redirect_uri = get_redirect_uri(request, "google")
+    oauth = await _google_oauth_factory(redirect_uri=redirect_uri)
+    if not oauth.client_id or not oauth.client_secret:
+        return {
+            "success": False,
+            "error": "Google not configured. Add Client ID and Secret.",
+        }
+    result = oauth.generate_authorization_url(
+        state_data={
+            "customer_id": customer_id,
+            "redirect_after": redirect_after,
+            "mode": "customer",
+        },
+    )
+    return {"success": True, "url": result["url"], "state": result["state"]}
+
+
+@router.get("/customer/{customer_id}/status")
+async def get_customer_google_status(customer_id: str):
+    """Get Google connection status for a customer."""
+    from services.plugin.deps import get_auth_service
+
+    auth_service = get_auth_service()
+    tokens = await auth_service.get_oauth_tokens("google", customer_id=customer_id)
+    if not tokens:
+        return {"connected": False, "customer_id": customer_id}
+    return {
+        "connected": True,
+        "customer_id": customer_id,
+        "email": tokens.get("email"),
+        "name": tokens.get("name"),
+    }
+
+
+@router.post("/customer/{customer_id}/disconnect")
+async def disconnect_customer_google(customer_id: str):
+    """Disconnect a customer's Google account."""
+    from services.plugin.deps import get_auth_service
+
+    auth_service = get_auth_service()
+    await auth_service.remove_oauth_tokens("google", customer_id=customer_id)
+    return {"success": True, "customer_id": customer_id}

package/server/nodes/google/gmail_receive.py

@@ -10,7 +10,9 @@ from typing import Any, Dict, Literal, Optional, Set
 from pydantic import BaseModel, ConfigDict, Field
 
 from core.logging import get_logger
-from services.plugin import NodeContext, Operation, TaskQueue, TriggerNode
+from services.plugin import (
+    NodeContext, Operation, PollingTriggerNode, TaskQueue,
+)
 
 from ._credentials import GoogleCredential
 
@@ -52,8 +54,16 @@ class GmailReceiveOutput(BaseModel):
     model_config = ConfigDict(extra="allow")
 
 
-class GmailReceiveNode(TriggerNode):
+class GmailReceiveNode(PollingTriggerNode):
     type = "googleGmailReceive"
+    # Wave 11.I, milestone P: ``event_type`` ClassVar lets
+    # ``event_waiter._auto_populate_from_plugins`` backfill
+    # TRIGGER_REGISTRY without a hardcoded entry in event_waiter. The
+    # legacy ``type_alias = "gmailReceive"`` shim was retired -- the
+    # downstream callers (POLLING_TRIGGER_TYPES, deployment manager,
+    # frontend trigger list, _filters registration) all rename to the
+    # canonical class type in the same commit.
+    event_type = "gmail_email_received"
     display_name = "Gmail Receive"
     subtitle = "Inbound Email"
     group = ("google", "trigger")
@@ -65,12 +75,39 @@ class GmailReceiveNode(TriggerNode):
     )
     credentials = (GoogleCredential,)
     task_queue = TaskQueue.TRIGGERS_POLL
-    mode = "polling"
     default_poll_interval = 60
 
     Params = GmailReceiveParams
     Output = GmailReceiveOutput
 
+    # ---- PollingTriggerNode hooks (deployment-mode loop) -------------
+
+    @staticmethod
+    def _build_query(parameters: Dict[str, Any]) -> str:
+        query = parameters.get("filter_query", "is:unread")
+        label = parameters.get("label_filter", "INBOX")
+        return f"label:{label} {query}" if label and label != "all" else query
+
+    async def setup_service(self, params: Dict[str, Any]) -> Any:
+        return await build_google_service("gmail", "v1", params, {})
+
+    async def fetch_ids(self, service: Any, params: Dict[str, Any]) -> Set[str]:
+        return await poll_gmail_ids(service, self._build_query(params))
+
+    async def fetch_detail(
+        self, service: Any, msg_id: str, params: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        return await fetch_email_details(service, msg_id)
+
+    async def post_emit(
+        self, service: Any, msg_id: str, params: Dict[str, Any]
+    ) -> None:
+        if params.get("mark_as_read"):
+            try:
+                await mark_email_as_read(service, msg_id)
+            except Exception as exc:  # noqa: BLE001
+                logger.warning(f"[GmailReceive] Failed to mark as read: {exc}")
+
     async def execute(
         self,
         node_id: str,
@@ -168,5 +205,5 @@ class GmailReceiveNode(TriggerNode):
     @Operation("wait")
     async def wait(self, ctx: NodeContext, params: GmailReceiveParams) -> GmailReceiveOutput:
         raise NotImplementedError(
-            "gmailReceive uses execute() override (Wave 11.D.5 inlined)."
+            "googleGmailReceive uses execute() override (Wave 11.D.5 inlined)."
         )

package/server/nodes/groups.py

@@ -49,6 +49,7 @@ register_group(key="scheduler",   metadata={"label": "Schedulers",        "icon"
 register_group(key="proxy",       metadata={"label": "Proxy",             "icon": "🛡", "color": "#bd93f9", "visibility": "dev"})
 register_group(key="whatsapp",    metadata={"label": "WhatsApp",          "icon": "💬", "color": "#25D366", "visibility": "dev"})
 register_group(key="email",       metadata={"label": "Email",             "icon": "✉️", "color": "#8be9fd", "visibility": "dev"})
+register_group(key="payments",    metadata={"label": "Payments",          "icon": "asset:stripe", "color": "#635BFF", "visibility": "dev"})
 register_group(key="browser",     metadata={"label": "Browser",           "icon": "🌐", "color": "#ff79c6", "visibility": "dev"})
 register_group(key="scraper",     metadata={"label": "Scrapers",          "icon": "🕸", "color": "#ff79c6", "visibility": "dev"})
 register_group(key="filesystem",  metadata={"label": "Filesystem",        "icon": "📁", "color": "#8be9fd", "visibility": "dev"})

package/server/nodes/location/_credentials.py

@@ -8,7 +8,17 @@ gmaps_locations, gmaps_nearby_places). Separate from
 
 from __future__ import annotations
 
-from services.plugin.credential import ApiKeyCredential
+import httpx
+
+from services.plugin.credential import ApiKeyCredential, ProbeResult
+
+
+# Google's documented sentinel address for connectivity tests on the
+# Geocoding API. Returns ``status=OK`` for any working key with the
+# Geocoding API enabled; ``REQUEST_DENIED`` for a bad key or disabled
+# API. We never store the response — it's just a probe.
+_GEOCODE_SENTINEL = "1600 Amphitheatre Parkway, Mountain View, CA"
+_GEOCODE_URL = "https://maps.googleapis.com/maps/api/geocode/json"
 
 
 class GoogleMapsCredential(ApiKeyCredential):
@@ -19,3 +29,37 @@ class GoogleMapsCredential(ApiKeyCredential):
     key_name = "key"
     key_location = "query"
     docs_url = "https://developers.google.com/maps/documentation"
+
+    @classmethod
+    async def _probe(cls, api_key: str) -> ProbeResult:
+        """Geocode a sentinel address to verify the key is live.
+
+        Replaces ``handle_validate_maps_key`` in
+        ``routers/websocket.py``; the storage + broadcast wiring is
+        handled by the base :meth:`Credential.validate` so this method
+        only needs to translate the geocode response into a
+        :class:`ProbeResult`. ``REQUEST_DENIED`` → invalid; ``OK`` /
+        ``ZERO_RESULTS`` / ``OVER_QUERY_LIMIT`` → valid (the key
+        authenticated, even if the query didn't return rows).
+        """
+        async with httpx.AsyncClient(timeout=10.0) as client:
+            response = await client.get(
+                _GEOCODE_URL,
+                params={"address": _GEOCODE_SENTINEL, "key": api_key},
+            )
+        payload = response.json()
+        status = payload.get("status")
+
+        if status == "REQUEST_DENIED":
+            return ProbeResult(
+                valid=False,
+                message=payload.get("error_message", "Invalid API key"),
+            )
+        return ProbeResult(
+            valid=True,
+            message=(
+                "Google Maps API key is valid"
+                if status == "OK"
+                else f"API key is valid (status: {status})"
+            ),
+        )

package/server/{services/maps.py → nodes/location/_service.py}

@@ -1,4 +1,19 @@
-"""Google Maps service for location operations."""
+"""Google Maps service for location operations.
+
+Wave 11.I, milestone N: relocated from ``services/maps.py`` into the
+location plugin folder. Three nodes consume it through the DI container
+(``container.maps_service()``): ``gmaps_create``, ``gmaps_locations``,
+``gmaps_nearby_places``. The container provider in ``core/container.py``
+imports ``MapsService`` from this module.
+
+API-key validation lives in :mod:`._credentials`'s
+:class:`GoogleMapsCredential._probe` (Wave 11.I scaffold) -- the legacy
+REST endpoint at ``/python/maps/validate-key`` was retired with this
+move. Workflow nodes still call ``MapsService.create_map`` /
+``geocode_location`` / ``find_nearby_places`` directly via the DI
+container; the dead ``/python/<name>/execute`` REST endpoints (also
+retired) duplicated the same paths.
+"""
 
 import time
 import googlemaps
@@ -32,13 +47,13 @@ async def _track_maps_usage(
     Returns:
         Cost breakdown dict with operation, unit_cost, resource_count, total_cost
     """
-    from core.container import container
+    from services.plugin.deps import get_database
 
     pricing = get_pricing_service()
     cost_data = pricing.calculate_api_cost('google_maps', action, resource_count)
 
     # Save to database
-    db = container.database()
+    db = get_database()
     await db.save_api_usage_metric({
         'session_id': session_id,
         'node_id': node_id,

package/server/nodes/location/gmaps_create.py

@@ -6,7 +6,7 @@ from typing import Any, Dict, Literal, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+from services.plugin import ActionNode, NodeContext, NodeUserError, Operation, TaskQueue
 
 from ._credentials import GoogleMapsCredential
 
@@ -61,12 +61,12 @@ class GmapsCreateNode(ActionNode):
 
     @Operation("create")
     async def create(self, ctx: NodeContext, params: GmapsCreateParams) -> Any:
-        from core.container import container
+        from services.plugin.deps import get_maps_service
 
-        maps_service = container.maps_service()
+        maps_service = get_maps_service()
         response = await maps_service.create_map(
             ctx.node_id, params.model_dump(), ctx.raw,
         )
         if response.get("success"):
             return response.get("result") or response
-        raise RuntimeError(response.get("error") or "Map create failed")
+        raise NodeUserError(response.get("error") or "Map create failed")

package/server/nodes/location/gmaps_locations.py

@@ -6,7 +6,7 @@ from typing import Any, Literal, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+from services.plugin import ActionNode, NodeContext, NodeUserError, Operation, TaskQueue
 
 from ._credentials import GoogleMapsCredential
 
@@ -72,12 +72,12 @@ class GmapsLocationsNode(ActionNode):
 
     @Operation("geocode", cost={"service": "google_maps", "action": "geocode", "count": 1})
     async def geocode(self, ctx: NodeContext, params: GmapsLocationsParams) -> Any:
-        from core.container import container
+        from services.plugin.deps import get_maps_service
 
-        maps_service = container.maps_service()
+        maps_service = get_maps_service()
         response = await maps_service.geocode_location(
             ctx.node_id, params.model_dump(), ctx.raw,
         )
         if response.get("success"):
             return response.get("result") or response
-        raise RuntimeError(response.get("error") or "Geocoding failed")
+        raise NodeUserError(response.get("error") or "Geocoding failed")

package/server/nodes/location/gmaps_nearby_places.py

@@ -6,7 +6,7 @@ from typing import Any, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from services.plugin import ActionNode, NodeContext, Operation, TaskQueue
+from services.plugin import ActionNode, NodeContext, NodeUserError, Operation, TaskQueue
 
 from ._credentials import GoogleMapsCredential
 
@@ -51,12 +51,12 @@ class GmapsNearbyPlacesNode(ActionNode):
 
     @Operation("nearby", cost={"service": "google_maps", "action": "places_nearby", "count": 1})
     async def nearby(self, ctx: NodeContext, params: GmapsNearbyPlacesParams) -> Any:
-        from core.container import container
+        from services.plugin.deps import get_maps_service
 
-        maps_service = container.maps_service()
+        maps_service = get_maps_service()
         response = await maps_service.find_nearby_places(
             ctx.node_id, params.model_dump(), ctx.raw,
         )
         if response.get("success"):
             return response.get("result") or response
-        raise RuntimeError(response.get("error") or "Nearby places failed")
+        raise NodeUserError(response.get("error") or "Nearby places failed")

package/server/nodes/model/_base.py

@@ -97,9 +97,14 @@ class ChatModelBase(ActionNode, abstract=True):
 
     @Operation("chat", cost={"service": "chat_model", "action": "chat", "count": 1})
     async def chat(self, ctx: NodeContext, params: ChatModelParams) -> Any:
-        from core.container import container
-
-        ai_service = container.ai_service()
+        from services.plugin.deps import get_ai_service
+
+        ai_service = get_ai_service()
+        # ``execute_chat`` raises ``NodeUserError`` directly for typed
+        # openai SDK failures (context overflow, bad key, server down) —
+        # BaseNode.execute() then logs at WARN with no traceback.
+        # ``RuntimeError`` here only fires for "success=False" responses
+        # that aren't typed SDK errors (real bugs worth a stacktrace).
         response = await ai_service.execute_chat(
             ctx.node_id, self.type, params.model_dump(),
         )

package/server/nodes/model/_credentials.py

@@ -1,26 +1,64 @@
 """LLM provider credentials (Wave 11.E.1 — per-domain).
 
-One :class:`ApiKeyCredential` per provider. Used by the 9 chat-model
+One :class:`ApiKeyCredential` per provider. Used by the chat-model
 plugins in this folder (openai, anthropic, gemini, openrouter, groq,
-cerebras, deepseek, kimi, mistral) plus the xAI credential referenced
-by agent plugins. At execution time the plugin's LangChain / native
-SDK client pulls the key directly from :mod:`services.auth`; this
-class is the Credentials-modal + discovery manifest, not the runtime
-client.
+cerebras, deepseek, kimi, mistral, ollama, lmstudio) plus the xAI
+credential referenced by agent plugins. At execution time the plugin's
+LangChain / native SDK client pulls the key directly from
+:mod:`services.auth`; this class is the Credentials-modal + discovery
+manifest, not the runtime client.
+
+Local servers (Ollama, LM Studio) follow the same shape as the cloud
+credentials but their api_key is optional — many users run them on
+localhost with no auth. The existing ``{provider}_proxy`` mechanism
+in :func:`services.ai.AIService.create_model` already handles the
+"override base_url + use placeholder api_key" path; the credential
+class only needs to return a placeholder when nothing is stored so
+the central "API key is required" check in ``execute_chat`` passes.
 """
 
 from __future__ import annotations
 
-from services.plugin.credential import ApiKeyCredential
+from typing import Any, Dict
+
+from services.plugin.credential import ApiKeyCredential, ProbeResult
 
 
 class _LLMApiKey(ApiKeyCredential):
-    """Shared defaults. Subclasses only set id / display_name / icon."""
+    """Shared defaults. Subclasses only set id / display_name / icon.
+
+    The :meth:`_probe` override calls ``ai_service.fetch_models`` —
+    every cloud LLM provider in this file inherits it, so adding a new
+    OpenAI-compatible provider is purely declarative (id + base_url in
+    JSON; no validator code). The local-server credential override
+    (:class:`_LocalLLM`) supersedes ``validate`` entirely because its
+    side-effect ordering differs (URL stored under ``{id}_proxy``
+    before the probe + per-model context registration after).
+    """
 
     category = "AI"
     key_name = "Authorization"
     key_location = "bearer"
 
+    @classmethod
+    async def _probe(cls, api_key: str) -> ProbeResult:
+        """Default LLM probe: fetch the provider's model list.
+
+        Hits ``GET /v1/models`` (or the provider equivalent) via
+        :meth:`AIService.fetch_models`. Returns a populated
+        :class:`ProbeResult` on success; raises ``httpx``/``openai``
+        exceptions for the base ``Credential.validate`` to classify.
+        """
+        from services.plugin.deps import get_ai_service
+
+        ai_service = get_ai_service()
+        models = await ai_service.fetch_models(cls.id, api_key)
+        return ProbeResult(
+            valid=True,
+            message="API key validated",
+            models=models,
+        )
+
 
 class OpenAICredential(_LLMApiKey):
     id = "openai"
@@ -95,3 +133,53 @@ class XaiCredential(_LLMApiKey):
     display_name = "xAI (Grok)"
     icon = "asset:xai"
     docs_url = "https://console.x.ai"
+
+
+class _LocalLLM(_LLMApiKey):
+    """Base for local-server credentials (Ollama, LM Studio).
+
+    Same shape as :class:`_LLMApiKey`, but ``resolve()`` returns the
+    documented Ollama placeholder when no key is stored instead of
+    raising. The user's custom server address rides on the existing
+    ``{id}_proxy`` credential — :func:`services.ai.AIService.create_model`
+    already reads it and OpenAIProvider already overrides ``base_url``
+    + forces ``api_key="ollama"``. Nothing else to wire.
+    """
+
+    @classmethod
+    async def resolve(cls, *, user_id: str = "owner") -> Dict[str, Any]:
+        from services.plugin.deps import get_auth_service
+
+        api_key = await get_auth_service().get_api_key(cls.id)
+        return {"api_key": api_key or "ollama"}
+
+    @classmethod
+    async def validate(cls, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Probe the user's local server via the official SDK.
+
+        Overrides the base ``Credential.validate`` because local-LLM
+        side-effect ordering genuinely differs from the cloud case:
+        the user's URL is persisted under ``{cls.id}_proxy`` BEFORE
+        the probe runs, the placeholder ``api_key="ollama"`` is
+        stored under ``cls.id`` only on success, and per-model context
+        is registered in the model registry. Delegates to the
+        SDK-typed probe in ``_local_validator.py`` which already owns
+        that full flow.
+        """
+        from ._local_validator import validate_local_llm
+
+        return await validate_local_llm(dict(data, provider=cls.id))
+
+
+class OllamaCredential(_LocalLLM):
+    id = "ollama"
+    display_name = "Ollama"
+    icon = "lobehub:ollama"
+    docs_url = "https://ollama.com/download"
+
+
+class LMStudioCredential(_LocalLLM):
+    id = "lmstudio"
+    display_name = "LM Studio"
+    icon = "lobehub:lmstudio"
+    docs_url = "https://lmstudio.ai/docs/local-server"