machinaos 0.0.78 → 0.0.80

package/server/services/credentials/handlers.py

@@ -0,0 +1,196 @@
+"""Credential CRUD WS handlers extracted from ``routers/websocket.py`` (Wave 13.5).
+
+4 handlers:
+  - ``validate_api_key`` — dispatch to plugin's ``Credential.validate``.
+  - ``get_stored_api_key`` — return stored key + catalogue default fallback.
+  - ``save_api_key`` — idempotent store + symmetric broadcast.
+  - ``delete_api_key`` — idempotent delete + symmetric broadcast.
+
+Per-provider validation logic lives in ``services/plugin/credential.py``'s
+``CREDENTIAL_REGISTRY``. Adding a new provider with a special validator
+is a single ``_probe`` override on the plugin's ``Credential`` subclass —
+this module stays untouched.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, Optional
+
+from fastapi import WebSocket
+
+from core.container import container
+from core.logging import get_logger
+from services.status_broadcaster import get_status_broadcaster
+from services.ws_handler_registry import ws_handler
+
+# ``container`` + ``get_status_broadcaster`` re-imported at module scope
+# so existing tests that patch ``services.credentials.handlers.container``
+# / ``...get_status_broadcaster`` (formerly patched on ``routers.websocket``)
+# keep working without rewriting fixtures. ``services.credentials`` is
+# imported lazily from ``main.py`` at lifespan startup, AFTER the
+# container is fully initialised — no circular-import risk like Wave
+# 13.2's deployment handlers.
+
+logger = get_logger(__name__)
+
+
+@ws_handler("provider", "api_key")
+async def handle_validate_api_key(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Validate and store an API key.
+
+    Pure dispatch — looks up the plugin's ``Credential`` subclass in
+    ``CREDENTIAL_REGISTRY`` and calls its ``validate`` classmethod. The
+    base ``Credential.validate`` (defined in
+    ``services/plugin/credential.py``) wires the shared scaffold
+    (storage + status broadcast + error classification + response
+    envelope) and dispatches the per-provider probe via the
+    subclass-supplied ``_probe`` hook.
+    """
+    from services.plugin.credential import CREDENTIAL_REGISTRY
+
+    provider = data["provider"].lower()
+    normalized = dict(data, provider=provider)
+
+    cred_cls = CREDENTIAL_REGISTRY.get(provider)
+    if cred_cls is None:
+        return {
+            "success": False,
+            "valid": False,
+            "error": f"Unknown provider '{provider}' — no Credential class registered.",
+        }
+    return await cred_cls.validate(normalized)
+
+
+def _lookup_credential_default(storage_key: str) -> Optional[str]:
+    """Look up a field's catalogue ``default`` for the given storage key.
+
+    Storage keys are either the provider id (``"openai"`` for cloud
+    providers whose field key is ``apiKey``) or the field key itself
+    (``"lmstudio_proxy"`` etc. for local-LLM providers). Both shapes
+    map back to a credential_providers.json field; this helper finds
+    the one and returns its ``default`` value if declared.
+    """
+    from services.credential_registry import get_credential_registry
+
+    registry = get_credential_registry()
+    for provider in registry.get_all_providers():
+        provider_id = provider.get("id") or provider.get("name", "").lower()
+        for field in provider.get("fields") or []:
+            field_key = field.get("key")
+            if not field_key:
+                continue
+            field_storage_key = provider_id if field_key == "apiKey" else field_key
+            if field_storage_key == storage_key:
+                default = field.get("default")
+                return default if default else None
+    return None
+
+
+@ws_handler("provider")
+async def handle_get_stored_api_key(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Get stored API key for a provider.
+
+    Response uses camelCase (``hasKey`` / ``apiKey``) to match the
+    ``update_api_key_status`` broadcast shape — every WS payload the
+    frontend receives for API key state uses the same convention.
+
+    When nothing is stored AND the catalogue declares a ``default`` for
+    this field (e.g. local-LLM canonical Base URL), the default is
+    returned in ``apiKey`` with ``hasKey: false``. The frontend renders
+    the value but tracks ``stored`` separately via ``hasKey`` so the
+    validated/connected badge stays honest.
+    """
+
+    auth_service = container.auth_service()
+    provider = data["provider"].lower()
+    api_key = await auth_service.get_api_key(provider, data.get("session_id", "default"))
+    if not api_key:
+        default = _lookup_credential_default(provider)
+        if default is not None:
+            return {"provider": provider, "hasKey": False, "apiKey": default}
+        return {"provider": provider, "hasKey": False}
+    models = await auth_service.get_stored_models(provider, data.get("session_id", "default"))
+    return {
+        "provider": provider,
+        "hasKey": True,
+        "apiKey": api_key,
+        "models": models,
+        "timestamp": time.time(),
+    }
+
+
+@ws_handler("provider", "api_key")
+async def handle_save_api_key(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Save an API key (without validation).
+
+    Supports client-side idempotency: if the client supplies a
+    ``request_id`` (opaque UUID), duplicate calls within 60 s return the
+    cached result instead of re-running the mutation.
+    """
+    from services.idempotency import get_idempotency_store
+
+    store = get_idempotency_store("credentials")
+    provider = data["provider"].lower()
+
+    async def _do_save() -> Dict[str, Any]:
+        auth_service = container.auth_service()
+        broadcaster = get_status_broadcaster()
+        await auth_service.store_api_key(
+            provider=provider,
+            api_key=data["api_key"].strip(),
+            models=data.get("models", []),
+            session_id=data.get("session_id", "default"),
+        )
+        await broadcaster.broadcast_credential_event(
+            "credential.api_key.saved",
+            provider=provider,
+        )
+        return {"provider": data["provider"]}
+
+    return await store.run(data.get("request_id"), _do_save)
+
+
+@ws_handler("provider")
+async def handle_delete_api_key(data: Dict[str, Any], websocket: WebSocket) -> Dict[str, Any]:
+    """Delete stored API key. Idempotent on ``request_id``."""
+    from services.idempotency import get_idempotency_store
+
+    store = get_idempotency_store("credentials")
+    provider = data["provider"].lower()
+
+    async def _do_delete() -> Dict[str, Any]:
+        auth_service = container.auth_service()
+        broadcaster = get_status_broadcaster()
+        await auth_service.remove_api_key(provider, data.get("session_id", "default"))
+        await broadcaster.update_api_key_status(
+            provider,
+            valid=False,
+            has_key=False,
+            message="deleted",
+            models=[],
+        )
+        await broadcaster.broadcast_credential_event(
+            "credential.api_key.deleted",
+            provider=provider,
+        )
+        return {"provider": data["provider"]}
+
+    return await store.run(data.get("request_id"), _do_delete)
+
+
+WS_HANDLERS: Dict[str, Any] = {
+    "validate_api_key": handle_validate_api_key,
+    "get_stored_api_key": handle_get_stored_api_key,
+    "save_api_key": handle_save_api_key,
+    "delete_api_key": handle_delete_api_key,
+}
+
+
+__all__ = [
+    "WS_HANDLERS",
+    "handle_delete_api_key",
+    "handle_get_stored_api_key",
+    "handle_save_api_key",
+    "handle_validate_api_key",
+]

package/server/services/deployment/__init__.py

@@ -1,8 +1,19 @@
-"""Deployment module - Event-driven workflow deployment."""
+"""Deployment module - Event-driven workflow deployment.
+
+Wave 13.2: side-effect import publishes the 5 deployment WS handlers
+(deploy_workflow / cancel_deployment / get_deployment_status /
+get_workflow_lock / update_deployment_settings) into the central
+``ws_handler_registry``.
+"""
+
+from services.ws_handler_registry import register_ws_handlers as _register_ws_handlers
 
 from .state import DeploymentState, TriggerInfo
 from .triggers import TriggerManager
 from .manager import DeploymentManager
+from .handlers import WS_HANDLERS as _DEPLOYMENT_WS_HANDLERS
+
+_register_ws_handlers(_DEPLOYMENT_WS_HANDLERS)
 
 __all__ = [
     "DeploymentState",

package/server/services/deployment/canary_registry.py

@@ -0,0 +1,137 @@
+"""Wave 12 C1 canary registry — plugin-owned opt-in for Temporal-durable triggers.
+
+Plugin packages call :func:`register_canary_trigger_type` from their
+``__init__.py`` to opt their trigger node type into the
+:class:`TriggerListenerWorkflow` consumer path inside
+:class:`DeploymentManager`. The deployment manager queries via
+:func:`is_canary_trigger_type` instead of hardcoding a per-plugin list.
+
+This mirrors the established Wave-11.I plugin-self-registration pattern
+(``register_filter_builder``, ``register_poll_coroutine_factory``,
+``register_router``, ``register_ws_handlers``, etc.) — DeploymentManager
+stays plugin-agnostic and never edits when a new canary trigger lands.
+
+The producer side (each plugin's ``_events.py`` calling
+``services.events.dispatch.emit``) is a separate, mechanical change
+that doesn't touch this registry. The two together activate the
+canary for one trigger type: the registry tells DeploymentManager to
+start a ``TriggerListenerWorkflow`` for it; the dispatch.emit call
+ensures events reach that listener.
+
+Membership semantics (set-shaped):
+
+    register_canary_trigger_type("webhookTrigger", "com.machinaos.webhook.received")
+    register_canary_trigger_type("chatTrigger", "com.machinaos.chat.message.received")
+    is_canary_trigger_type("webhookTrigger")  # True
+    is_canary_trigger_type("whatsappReceive") # False (not yet opted in)
+    cloudevent_type_for("webhookTrigger")     # "com.machinaos.webhook.received"
+
+Idempotent on re-import (multiple registrations of the same type with
+the same cloudevent_type are a no-op; a conflicting cloudevent_type
+raises so plugin upgrades surface drift loudly).
+
+**Why cloudevent_type is required (Wave 12 bug fix, 2026-05-15).** The
+``TriggerListenerWorkflow`` is tagged at start with an ``EventType``
+Search Attribute. :func:`services.events.dispatch.emit` runs a
+Visibility query ``EventType='<value>' AND ExecutionStatus='Running'``
+to find listeners and signal them. The query uses ``event.type`` from
+the CloudEvents envelope (reverse-DNS, e.g.
+``com.machinaos.chat.message.received``). The Search Attribute MUST
+carry the same value or the query never matches and no signal is
+delivered — symptom was "TriggerListener started ok but never reacts
+to incoming events". Pre-fix the deployment manager registered the
+legacy snake_case ``event_type`` from ``TriggerConfig`` (e.g.
+``chat_message_received``), which silently broke every C1 canary.
+"""
+
+from __future__ import annotations
+
+from typing import Dict, FrozenSet, Iterator, Optional
+
+
+_REGISTERED: Dict[str, str] = {}
+
+
+def register_canary_trigger_type(node_type: str, cloudevent_type: str) -> None:
+    """Opt this trigger node type into the Wave 12 C1 canary path.
+
+    Called from a plugin's ``__init__.py``. Idempotent on re-import when
+    the same ``cloudevent_type`` is supplied; a conflicting
+    ``cloudevent_type`` raises :class:`ValueError` so an accidentally
+    diverging plugin upgrade can't silently produce events that the
+    listener can't see.
+
+    Args:
+        node_type: The trigger node's ``BaseNode.type`` string. The
+            string MUST match what the workflow JSON carries for nodes
+            of this type — that's the key DeploymentManager looks up
+            when deciding which trigger goes to the canary listener.
+        cloudevent_type: The CloudEvents ``type`` field the plugin's
+            ``_events.py`` factory will populate on outgoing envelopes
+            (reverse-DNS, e.g. ``"com.machinaos.chat.message.received"``).
+            Used as the ``EventType`` Search Attribute value when the
+            listener workflow is started so
+            :func:`services.events.dispatch.emit`'s Visibility query
+            matches it.
+
+    Raises:
+        TypeError: if ``node_type`` or ``cloudevent_type`` is not a
+            non-empty string.
+        ValueError: if ``node_type`` was already registered with a
+            different ``cloudevent_type``.
+    """
+    if not isinstance(node_type, str) or not node_type:
+        raise TypeError(
+            f"register_canary_trigger_type expected a non-empty str for " f"node_type, got {type(node_type).__name__}: {node_type!r}"
+        )
+    if not isinstance(cloudevent_type, str) or not cloudevent_type:
+        raise TypeError(
+            f"register_canary_trigger_type expected a non-empty str for "
+            f"cloudevent_type, got {type(cloudevent_type).__name__}: "
+            f"{cloudevent_type!r}"
+        )
+    existing = _REGISTERED.get(node_type)
+    if existing is not None and existing != cloudevent_type:
+        raise ValueError(
+            f"register_canary_trigger_type: node_type={node_type!r} already "
+            f"registered with cloudevent_type={existing!r}; refusing to "
+            f"overwrite with {cloudevent_type!r}. A diverging registration "
+            f"would silently break the Visibility-query → Signal fan-out."
+        )
+    _REGISTERED[node_type] = cloudevent_type
+
+
+def is_canary_trigger_type(node_type: str) -> bool:
+    """True iff ``node_type`` has been opted into the canary."""
+    return node_type in _REGISTERED
+
+
+def cloudevent_type_for(node_type: str) -> Optional[str]:
+    """Return the CloudEvents ``type`` registered for ``node_type``.
+
+    ``None`` when the trigger isn't canary-registered — caller decides
+    whether to fall back to a legacy event_type or error.
+    """
+    return _REGISTERED.get(node_type)
+
+
+def canary_trigger_types() -> FrozenSet[str]:
+    """Return an immutable snapshot of registered canary trigger types.
+
+    Useful for diagnostics / ops dashboards. Don't iterate during a
+    deploy — call :func:`is_canary_trigger_type` instead so a future
+    plugin reload sees fresh registrations.
+    """
+    return frozenset(_REGISTERED)
+
+
+def __iter__() -> Iterator[str]:  # pragma: no cover — module dunders only
+    return iter(_REGISTERED)
+
+
+__all__ = [
+    "register_canary_trigger_type",
+    "is_canary_trigger_type",
+    "cloudevent_type_for",
+    "canary_trigger_types",
+]