machinaos 0.0.76 → 0.0.78

package/server/nodes/tool/task_manager.py

@@ -1,4 +1,13 @@
-"""Task Manager Tool — Wave 11.C migration."""
+"""Task Manager Tool — Wave 11.C migration; body inlined Wave 11.I (M.O).
+
+Inspects the in-memory delegation registry that lives on
+``services.handlers.tools`` (``_delegated_tasks`` for in-flight asyncio
+tasks, ``_delegation_results`` for completed-but-still-cached results,
+plus ``get_delegated_task_status`` which adds a DB-fallback layer for
+older runs). The plugin doesn't own that state — the delegation
+lifecycle in ``tools.py`` does — so we read through to it rather than
+duplicating registry plumbing here.
+"""
 
 from __future__ import annotations
 
@@ -6,8 +15,11 @@ from typing import Any, Dict, Literal, Optional
 
 from pydantic import BaseModel, ConfigDict, Field
 
+from core.logging import get_logger
 from services.plugin import NodeContext, Operation, TaskQueue, ToolNode
 
+logger = get_logger(__name__)
+
 
 class TaskManagerParams(BaseModel):
     action: Literal["create", "list", "complete", "delete", "update"] = "create"
@@ -49,7 +61,137 @@ class TaskManagerNode(ToolNode):
 
     @Operation("manage")
     async def manage(self, ctx: NodeContext, params: TaskManagerParams) -> Any:
-        from services.handlers.tools import _execute_task_manager
         return await _execute_task_manager(
             params.model_dump(), {"node_id": ctx.node_id, "workspace_dir": ctx.workspace_dir or ""},
         )
+
+
+async def _execute_task_manager(
+    tool_args: Dict[str, Any],
+    config: Dict[str, Any],
+) -> Dict[str, Any]:
+    """Execute task manager operations.
+
+    Dual-purpose: works as AI tool (LLM fills args) or workflow node
+    (uses params).
+
+    Operations:
+    - ``list_tasks``: list all active and completed delegated tasks
+    - ``get_task``: detailed status for one task
+    - ``mark_done``: drop a task from active tracking
+    """
+    # Read-through to the delegation registry owned by tools.py. Keeping
+    # the singletons there is intentional -- the entire delegation
+    # lifecycle (spawn / cleanup / refcount / DB persistence) lives in
+    # tools.py and is genuine cross-cutting framework state.
+    from services.handlers.tools import (
+        _delegated_tasks,
+        _delegation_results,
+        get_delegated_task_status,
+    )
+
+    params = config.get("parameters", {})
+    operation = tool_args.get("operation") or params.get("operation", "list_tasks")
+    task_id = tool_args.get("task_id") or params.get("task_id")
+    status_filter = tool_args.get("status_filter") or params.get("status_filter")
+    database = config.get("database")
+
+    logger.debug(
+        f"[TaskManager] Operation: {operation}, task_id: {task_id}, filter: {status_filter}"
+    )
+
+    if operation == "list_tasks":
+        tasks = []
+
+        # Active tasks from asyncio.Task tracking.
+        for tid, task in _delegated_tasks.items():
+            if task.done():
+                try:
+                    if task.cancelled():
+                        status = "cancelled"
+                    elif task.exception():
+                        status = "error"
+                    else:
+                        status = "completed"
+                except Exception:
+                    status = "completed"
+            else:
+                status = "running"
+
+            tasks.append({"task_id": tid, "status": status, "active": True})
+
+        # Completed tasks from in-memory cache.
+        for tid, result in _delegation_results.items():
+            if tid not in [t["task_id"] for t in tasks]:
+                tasks.append({
+                    "task_id": tid,
+                    "status": result.get("status", "completed"),
+                    "agent_name": result.get("agent_name"),
+                    "result_summary": str(result.get("result", ""))[:200],
+                    "active": False,
+                })
+
+        if status_filter:
+            tasks = [t for t in tasks if t.get("status") == status_filter]
+
+        return {
+            "success": True,
+            "operation": "list_tasks",
+            "tasks": tasks,
+            "count": len(tasks),
+            "running": sum(1 for t in tasks if t.get("status") == "running"),
+            "completed": sum(1 for t in tasks if t.get("status") == "completed"),
+            "errors": sum(1 for t in tasks if t.get("status") == "error"),
+        }
+
+    if operation == "get_task":
+        if not task_id:
+            return {"success": False, "error": "task_id is required for get_task operation"}
+
+        # 3-layer lookup (live tasks -> memory cache -> DB).
+        result = await get_delegated_task_status(task_ids=[task_id], database=database)
+        tasks = result.get("tasks", [])
+
+        if not tasks:
+            return {
+                "success": False,
+                "error": f"Task {task_id} not found",
+                "task_id": task_id,
+            }
+
+        task_info = tasks[0]
+        return {
+            "success": True,
+            "operation": "get_task",
+            "task_id": task_id,
+            "status": task_info.get("status"),
+            "agent_name": task_info.get("agent_name"),
+            "result": task_info.get("result"),
+            "error": task_info.get("error"),
+        }
+
+    if operation == "mark_done":
+        if not task_id:
+            return {"success": False, "error": "task_id is required for mark_done operation"}
+
+        removed = False
+        if task_id in _delegated_tasks:
+            del _delegated_tasks[task_id]
+            removed = True
+        if task_id in _delegation_results:
+            del _delegation_results[task_id]
+            removed = True
+
+        return {
+            "success": True,
+            "operation": "mark_done",
+            "task_id": task_id,
+            "removed": removed,
+            "message": (
+                f"Task {task_id} marked as done and removed from tracking"
+                if removed
+                else f"Task {task_id} was not in active tracking"
+            ),
+        }
+
+    return {"success": False, "error": f"Unknown operation: {operation}"}

package/server/nodes/twitter/__init__.py

@@ -1 +1,38 @@
-"""Plugins for the 'twitter' palette group. See ../__init__.py for the package layout."""
+"""Plugins for the 'twitter' palette group.
+
+Self-contained plugin folder (Wave 11.H pattern). Owns:
+
+- Action / trigger nodes — ``twitter_send.py``, ``twitter_search.py``,
+  ``twitter_user.py``, ``twitter_receive.py`` (auto-registered via
+  ``BaseNode.__init_subclass__``).
+- ``_credentials.py`` — :class:`TwitterCredential` (OAuth2).
+- ``_oauth.py`` — OAuth 2.0 PKCE flow client (formerly
+  ``services/twitter_oauth.py``).
+- ``_handlers.py`` — 3 WebSocket handlers
+  (``twitter_oauth_login`` / ``twitter_oauth_status`` /
+  ``twitter_logout``).
+- ``_router.py`` — HTTP OAuth callback (``/api/twitter/callback``).
+
+Two self-registration calls below — the central WS dispatcher and the
+FastAPI app pick up the plugin's surface without ever importing this
+module by name.
+"""
+
+from services.event_waiter import register_filter_builder
+from services.status_broadcaster import register_service_refresh
+from services.ws_handler_registry import register_router, register_ws_handlers
+
+from . import _router
+from ._filters import build_filter as build_twitter_filter
+from ._handlers import WS_HANDLERS
+from ._refresh import refresh_twitter_status
+
+# WebSocket handlers (3 message types) and the OAuth-callback HTTP
+# router self-register so ``routers/websocket.py`` and ``main.py``
+# stay free of per-plugin imports. Plus the service-status refresh
+# callback (Wave 11.I, milestone J) and the trigger filter builder
+# (milestone K).
+register_ws_handlers(WS_HANDLERS)
+register_router(_router.router, name="twitter")
+register_service_refresh(refresh_twitter_status)
+register_filter_builder("twitterReceive", build_twitter_filter)

package/server/nodes/twitter/_base.py

@@ -28,12 +28,12 @@ async def track_twitter_usage(
     node_id: str, action: str, resource_count: int, context: Dict[str, Any],
 ) -> Dict[str, float]:
     """Record a Twitter API call in ``api_usage_metrics``."""
-    from core.container import container
+    from services.plugin.deps import get_database
 
     pricing = get_pricing_service()
     cost_data = pricing.calculate_api_cost('twitter', action, resource_count)
 
-    db = container.database()
+    db = get_database()
     await db.save_api_usage_metric({
         'session_id': context.get('session_id', 'default'),
         'node_id': node_id,
@@ -49,10 +49,10 @@ async def track_twitter_usage(
 
 async def get_twitter_client():
     """Build an XDK Client from the stored OAuth2 access token."""
-    from core.container import container
+    from services.plugin.deps import get_auth_service
     from xdk import Client
 
-    auth_service = container.auth_service()
+    auth_service = get_auth_service()
     tokens = await auth_service.get_oauth_tokens("twitter", customer_id="owner")
     if not tokens or not tokens.get("access_token"):
         raise RuntimeError("Twitter not connected. Please authenticate via Credentials.")
@@ -61,11 +61,11 @@ async def get_twitter_client():
 
 async def refresh_and_get_client():
     """Refresh the OAuth2 token and return a new client."""
-    from core.container import container
-    from services.twitter_oauth import TwitterOAuth
+    from nodes.twitter._oauth import TwitterOAuth
+    from services.plugin.deps import get_auth_service
     from xdk import Client
 
-    auth_service = container.auth_service()
+    auth_service = get_auth_service()
     tokens = await auth_service.get_oauth_tokens("twitter", customer_id="owner")
     refresh_token = tokens.get("refresh_token", "") if tokens else ""
     if not refresh_token:

package/server/nodes/twitter/_credentials.py

@@ -4,7 +4,7 @@ Used by the four twitter plugins in this folder (twitter_send, twitter_search,
 twitter_user, twitter_receive).
 
 OAuth 2.0 with PKCE. The refresh flow is non-trivial (custom code exchange
-in :mod:`services.twitter_oauth`), so :meth:`build_client` returns an
+in :mod:`nodes.twitter._oauth`), so :meth:`build_client` returns an
 authenticated XDK ``Client`` — that's what the four twitter plugins
 actually hand to the XDK API methods. Use :func:`nodes.twitter._base.call_with_retry`
 on top; it transparently refreshes on 401/403 via this class.

package/server/nodes/twitter/_filters.py

@@ -0,0 +1,37 @@
+"""Twitter event-trigger filter builder (Wave 11.I, milestone K).
+
+Moved verbatim from ``services/event_waiter.build_twitter_filter``.
+"""
+
+from __future__ import annotations
+
+from typing import Callable, Dict
+
+
+def build_filter(params: Dict) -> Callable[[Dict], bool]:
+    """Build filter function for Twitter events.
+
+    Filters by:
+
+    - ``trigger_type`` -- ``mentions`` / ``search`` / ``user_timeline``
+    - ``search_query`` -- search query for ``search``
+    - ``user_id`` -- user ID for ``user_timeline``
+    """
+    trigger_type = params.get('trigger_type', 'mentions')
+    search_query = params.get('search_query', '')
+    user_id = params.get('user_id', '')
+
+    def matches(data: Dict) -> bool:
+        event_type = data.get('trigger_type', '')
+        if trigger_type != 'all' and event_type != trigger_type:
+            return False
+        if trigger_type == 'search' and search_query:
+            event_query = data.get('query', '')
+            if search_query.lower() not in event_query.lower():
+                return False
+        if trigger_type == 'user_timeline' and user_id:
+            if data.get('user_id') != user_id:
+                return False
+        return True
+
+    return matches

package/server/nodes/twitter/_handlers.py

@@ -0,0 +1,77 @@
+"""Twitter / X WebSocket handlers — factory-built (Wave 11.I, S).
+
+The 3 handlers (``twitter_oauth_login`` / ``twitter_oauth_status`` /
+``twitter_logout``) come from
+:func:`services.events.oauth_lifecycle.make_oauth_lifecycle_handlers`.
+The factory takes care of credential loading, redirect-URI derivation,
+silent token refresh on status, revoke + remove + broadcast on
+logout. Plugin-specific bits supplied via kwargs:
+
+* ``oauth_factory`` -- async builder that constructs
+  :class:`TwitterOAuth` per call, pulling stored client_id /
+  client_secret from ``auth_service``.
+* ``user_info_to_subject`` -- ``f"@{username}"`` (X has no email).
+* ``extra_logout`` -- drops legacy API-key entries left behind by the
+  pre-OAuth layout.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, Optional
+
+from services.events.oauth_lifecycle import make_oauth_lifecycle_handlers
+
+from ._oauth import TwitterOAuth
+
+
+async def _twitter_oauth_factory(
+    *, redirect_uri: Optional[str] = None, **_kwargs,
+) -> TwitterOAuth:
+    """Build a :class:`TwitterOAuth` from stored client credentials."""
+    from services.plugin.deps import get_auth_service
+
+    auth_service = get_auth_service()
+    client_id = await auth_service.get_api_key("twitter_client_id") or ""
+    client_secret = await auth_service.get_api_key("twitter_client_secret")
+    return TwitterOAuth(
+        client_id=client_id,
+        client_secret=client_secret,
+        redirect_uri=redirect_uri or "",
+    )
+
+
+def _user_info_to_handle(info: Dict[str, Any]) -> str:
+    return f"@{info.get('username', 'unknown')}"
+
+
+async def _drop_legacy_api_key_entries() -> None:
+    """Remove stale API-key entries from the pre-OAuth layout.
+
+    Pre-Wave-11.I some flows mistakenly stored access / refresh tokens
+    as API keys. The OAuth tokens table is the canonical home now;
+    these orphans are cleaned on every logout for safety.
+    """
+    from services.plugin.deps import get_auth_service
+
+    auth_service = get_auth_service()
+    for key in ("twitter_access_token", "twitter_refresh_token", "twitter_user_info"):
+        try:
+            await auth_service.remove_api_key(key)
+        except Exception:
+            pass
+
+
+WS_HANDLERS = make_oauth_lifecycle_handlers(
+    provider="twitter",
+    oauth_factory=_twitter_oauth_factory,
+    user_info_to_subject=_user_info_to_handle,
+    extra_logout=_drop_legacy_api_key_entries,
+)
+
+# Module-level aliases so the contract tests in
+# ``tests/credentials/test_websocket_handlers.py`` can import the
+# handlers by name. The dispatch table itself is what
+# ``register_ws_handlers`` consumes.
+handle_twitter_oauth_login = WS_HANDLERS["twitter_oauth_login"]
+handle_twitter_oauth_status = WS_HANDLERS["twitter_oauth_status"]
+handle_twitter_logout = WS_HANDLERS["twitter_logout"]

package/server/nodes/twitter/_oauth.py

@@ -0,0 +1,124 @@
+"""Twitter / X OAuth 2.0 PKCE client.
+
+Wave 11.I, milestone S: subclasses :class:`OAuth2PKCEClient` from
+:mod:`services.plugin.oauth`. The base class owns the PKCE state
+store, code-verifier generation, code exchange, token refresh, and
+revocation. This file declares X-specific endpoints + scopes +
+``fetch_user_info`` translation.
+
+Pre-S the file hand-rolled all of that (~410 LOC). The only Twitter-
+specific behaviour now lives in this small subclass.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+import httpx
+
+from core.logging import get_logger
+from services.plugin.oauth import OAuth2PKCEClient, OAuthStateStore
+
+logger = get_logger(__name__)
+
+# X API OAuth 2.0 endpoints. Updated URLs per latest docs. Public so
+# the contract tests in tests/credentials/test_twitter_oauth.py can
+# pin them via respx mocks.
+AUTHORIZATION_URL = "https://x.com/i/oauth2/authorize"
+TOKEN_URL = "https://api.x.com/2/oauth2/token"
+REVOKE_URL = "https://api.x.com/2/oauth2/revoke"
+USER_INFO_URL = "https://api.x.com/2/users/me"
+
+# Required scopes for full Twitter integration.
+# See: https://docs.x.com/fundamentals/authentication/oauth-2-0/authorization-code
+_DEFAULT_SCOPES = [
+    "tweet.read",
+    "tweet.write",
+    "users.read",
+    "follows.read",
+    "like.read",
+    "like.write",
+    "offline.access",  # enables refresh tokens
+]
+
+
+class TwitterOAuth(OAuth2PKCEClient):
+    """X (Twitter) OAuth 2.0 PKCE client."""
+
+    provider = "twitter"
+    authorization_endpoint = AUTHORIZATION_URL
+    token_endpoint = TOKEN_URL
+    revocation_endpoint = REVOKE_URL
+
+    # Plugin-scoped state store -- isolated from Google's instance.
+    state_store = OAuthStateStore()
+
+    DEFAULT_SCOPES = _DEFAULT_SCOPES
+
+    def __init__(
+        self,
+        client_id: str,
+        redirect_uri: str,
+        client_secret: Optional[str] = None,
+        scopes: Optional[List[str]] = None,
+    ) -> None:
+        super().__init__(
+            client_id=client_id,
+            redirect_uri=redirect_uri,
+            client_secret=client_secret,
+            scopes=scopes,
+        )
+
+    # Back-compat alias for the contract tests in
+    # tests/credentials/test_twitter_oauth.py -- the unified protocol
+    # method is :meth:`fetch_user_info`.
+    async def get_user_info(self, access_token: str) -> Dict[str, Any]:
+        return await self.fetch_user_info(access_token)
+
+    async def fetch_user_info(self, access_token: str) -> Dict[str, Any]:
+        """Translate X's ``/users/me`` response into the unified shape."""
+        try:
+            async with httpx.AsyncClient(timeout=30.0) as client:
+                response = await client.get(
+                    USER_INFO_URL,
+                    params={
+                        "user.fields": "id,name,username,profile_image_url,verified",
+                    },
+                    headers={"Authorization": f"Bearer {access_token}"},
+                )
+        except httpx.HTTPError as exc:
+            logger.error(f"[twitter] HTTP error getting user info: {exc}")
+            return {"success": False, "error": str(exc)}
+
+        if response.status_code != 200:
+            error_data = response.json() if response.text else {}
+            return {
+                "success": False,
+                "error": error_data.get("detail")
+                or error_data.get("title", "Failed to get user info"),
+            }
+
+        user = response.json().get("data", {})
+        return {
+            "success": True,
+            "id": user.get("id"),
+            "username": user.get("username"),
+            "name": user.get("name"),
+            "profile_image_url": user.get("profile_image_url"),
+            "verified": user.get("verified", False),
+        }
+
+
+# Module-level alias for the contract tests' ``_oauth_states.clear()``
+# pattern -- this is the same dict the class-level state store wraps,
+# so clearing one clears the other.
+_oauth_states = TwitterOAuth.state_store._states
+
+
+__all__ = [
+    "TwitterOAuth",
+    "AUTHORIZATION_URL",
+    "TOKEN_URL",
+    "REVOKE_URL",
+    "USER_INFO_URL",
+]

package/server/nodes/twitter/_refresh.py

@@ -0,0 +1,78 @@
+"""Twitter service-status refresh callback (Wave 11.I, milestone J).
+
+Moved from ``services/status_broadcaster._refresh_twitter_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("twitter")`` and
+mirrors the result into the broadcaster cache. No plugin internals
+are reached -- pure auth-service read + broadcast. The function still
+runs in the broadcaster's TaskGroup so OTel spans aggregate the same
+way they did pre-migration.
+"""
+
+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_twitter_status(broadcaster: "StatusBroadcaster") -> None:
+    """Refresh Twitter cache + broadcast. One pass per
+    ``_refresh_all_services`` cycle.
+    """
+    with tracer.start_as_current_span("broadcaster.refresh_twitter") as span:
+        try:
+            from services.plugin.deps import get_auth_service
+
+            auth_service = get_auth_service()
+            tokens = await auth_service.get_oauth_tokens(
+                "twitter", customer_id="owner"
+            )
+            if not tokens or not tokens.get("access_token"):
+                broadcaster._status["twitter"] = {
+                    "connected": False,
+                    "username": None,
+                    "user_id": None,
+                    "name": None,
+                    "profile_image_url": None,
+                }
+            else:
+                # User info is stored in the OAuth token record.
+                # email field carries the ``@username`` form.
+                email = tokens.get("email", "")
+                name = tokens.get("name", "")
+                username = email.lstrip("@") if email.startswith("@") else email
+                broadcaster._status["twitter"] = {
+                    "connected": True,
+                    "username": username or None,
+                    "user_id": None,
+                    "name": name or None,
+                    "profile_image_url": None,
+                }
+                logger.debug(
+                    "[StatusBroadcaster] Twitter status: connected as @%s",
+                    username,
+                )
+
+            await broadcaster.broadcast({
+                "type": "twitter_status",
+                "data": broadcaster._status["twitter"],
+            })
+            span.set_attribute(
+                "connected", bool(broadcaster._status["twitter"]["connected"])
+            )
+        except Exception as exc:  # noqa: BLE001 -- mirror pre-migration behaviour
+            span.record_exception(exc)
+            logger.debug(
+                "[StatusBroadcaster] Could not refresh Twitter status: %s", exc
+            )

package/server/nodes/twitter/_router.py

@@ -0,0 +1,29 @@
+"""Twitter / X OAuth callback router — factory-built (Wave 11.I, S).
+
+The single ``GET /api/twitter/callback`` route comes from
+:func:`services.events.oauth_lifecycle.make_oauth_callback_router`.
+Pre-S the file hand-rolled the callback + status + logout REST routes
+(~370 LOC). Status + logout were duplicates of the WS handlers in
+``_handlers.py`` and have been retired -- the WS path is canonical.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from services.events.oauth_lifecycle import make_oauth_callback_router
+
+from ._handlers import _twitter_oauth_factory
+
+
+def _user_info_to_email(info: Dict[str, Any]) -> str:
+    """X has no email field -- use ``@username`` as the identifier."""
+    return f"@{info.get('username', 'unknown')}"
+
+
+router = make_oauth_callback_router(
+    provider="twitter",
+    oauth_factory=_twitter_oauth_factory,
+    user_info_to_email=_user_info_to_email,
+    color_hex="#00ba7c",  # X brand green for the success page
+)

package/server/nodes/twitter/twitter_receive.py

@@ -39,6 +39,10 @@ class TwitterReceiveNode(TriggerNode):
     group = ("social", "trigger")
     description = "Trigger workflow on Twitter mentions, search results, or timeline updates (polling-based)"
     component_kind = "trigger"
+    # Wave 11.I, milestone K: ``event_type`` ClassVar lets
+    # ``event_waiter._auto_populate_from_plugins`` backfill
+    # TRIGGER_REGISTRY without a hardcoded entry in event_waiter.
+    event_type = "twitter_event_received"
     handles = (
         {"name": "output-main", "kind": "output", "position": "right",
          "label": "Output", "role": "main"},