cortexflow-ai 2.0.0__py3-none-any.whl

cortexflow_ai/channels/mattermost.py

@@ -0,0 +1,235 @@
+"""Mattermost channel adapter — WebSocket real-time events + REST API.
+
+Connects to a Mattermost server using a personal access token or bot token.
+Inbound messages arrive via the Mattermost WebSocket API (``ws(s)://host/api/v4/websocket``).
+Outbound messages use the ``POST /api/v4/posts`` REST endpoint.
+
+Config keys:
+    url         Base URL of the Mattermost server (default: http://localhost:8065)
+    token       Personal access token or bot token (ENV:MATTERMOST_TOKEN)
+    team        Team name or ID to filter messages (optional)
+    channel     Channel name to listen on (default: town-square)
+
+The adapter filters out its own bot messages to prevent echo loops.
+
+WebSocket event format (Mattermost ≥ 5.x):
+    {
+        "event": "posted",
+        "data": {
+            "post": "{\"id\":\"...\",\"user_id\":\"...\",\"channel_id\":\"...\",\"message\":\"Hello\"}",
+            "sender_name": "@alice",
+            "team_id": "..."
+        }
+    }
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import os
+import time
+from typing import Any
+
+from cortexflow_ai.channels.base import ChannelAdapter, InboundMessage
+
+logger = logging.getLogger(__name__)
+
+
+class MattermostAdapter(ChannelAdapter):
+    """Mattermost adapter using the native WebSocket + REST v4 API."""
+
+    channel_id = "mattermost"
+
+    def __init__(self, config: dict[str, Any]) -> None:
+        super().__init__(config)
+        self._url: str = config.get("url", "http://localhost:8065").rstrip("/")
+        self._token: str = self._resolve(config.get("token", ""))
+        self._team: str = config.get("team", "")
+        self._channel_name: str = config.get("channel", "town-square")
+        self._bot_user_id: str | None = None
+        self._ws_task: asyncio.Task | None = None
+        self._ws: Any = None
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    async def connect(self) -> None:
+        """Resolve bot identity, then start the WebSocket listener."""
+        self._bot_user_id = await self._fetch_bot_user_id()
+        self._ws_task = asyncio.create_task(self._ws_loop())
+        logger.info("mattermost.connected url=%s", self._url)
+
+    async def disconnect(self) -> None:
+        if self._ws_task:
+            self._ws_task.cancel()
+            try:
+                await self._ws_task
+            except asyncio.CancelledError:
+                pass
+            self._ws_task = None
+        if self._ws is not None:
+            try:
+                await self._ws.close()
+            except Exception:
+                pass
+            self._ws = None
+
+    # ------------------------------------------------------------------
+    # Outbound
+    # ------------------------------------------------------------------
+
+    async def send(
+        self,
+        target: str,
+        text: str,
+        *,
+        reply_to: str | None = None,
+        attachments=None,
+    ) -> str | None:
+        """Post a message to Mattermost channel *target* (channel_id).
+
+        Returns the new post ID on success, None on error.
+        """
+        if not self._token:
+            return None
+        try:
+            import httpx
+
+            payload: dict[str, Any] = {"channel_id": target, "message": text}
+            if reply_to:
+                payload["root_id"] = reply_to
+
+            async with httpx.AsyncClient() as client:
+                resp = await client.post(
+                    f"{self._url}/api/v4/posts",
+                    headers={
+                        "Authorization": f"Bearer {self._token}",
+                        "Content-Type": "application/json",
+                    },
+                    json=payload,
+                    timeout=15.0,
+                )
+                resp.raise_for_status()
+                return resp.json().get("id")
+        except Exception as exc:
+            logger.error("mattermost.send failed: %s", exc)
+            return None
+
+    # ------------------------------------------------------------------
+    # WebSocket event loop
+    # ------------------------------------------------------------------
+
+    async def _ws_loop(self) -> None:
+        """Connect to the Mattermost WebSocket and dispatch posted events."""
+        ws_url = self._url.replace("http://", "ws://").replace("https://", "wss://")
+        ws_url += "/api/v4/websocket"
+
+        while True:
+            try:
+                await self._ws_connect_and_listen(ws_url)
+            except asyncio.CancelledError:
+                return
+            except Exception as exc:
+                logger.warning("mattermost.ws_error: %s — reconnecting in 5s", exc)
+                await asyncio.sleep(5)
+
+    async def _ws_connect_and_listen(self, ws_url: str) -> None:
+        try:
+            import websockets  # type: ignore[import]
+        except ImportError:
+            raise RuntimeError("websockets package required: pip install websockets")
+
+        async with websockets.connect(
+            ws_url,
+            extra_headers={"Authorization": f"Bearer {self._token}"},
+        ) as ws:
+            self._ws = ws
+            # Authenticate via challenge message
+            await ws.send(json.dumps({
+                "seq": 1,
+                "action": "authentication_challenge",
+                "data": {"token": self._token},
+            }))
+            async for raw in ws:
+                event = json.loads(raw)
+                await self._process_event(event)
+
+    async def _process_event(self, event: dict[str, Any]) -> None:
+        if event.get("event") != "posted":
+            return
+
+        data = event.get("data", {})
+        post_raw = data.get("post", "{}")
+        try:
+            post = json.loads(post_raw) if isinstance(post_raw, str) else post_raw
+        except json.JSONDecodeError:
+            return
+
+        user_id = post.get("user_id", "")
+        if self._bot_user_id and user_id == self._bot_user_id:
+            return  # skip own messages
+
+        text = (post.get("message") or "").strip()
+        if not text:
+            return
+
+        sender_name = data.get("sender_name", "")
+        msg = InboundMessage(
+            channel=self.channel_id,
+            sender_id=user_id,
+            sender_name=sender_name.lstrip("@"),
+            text=text,
+            thread_id=post.get("channel_id"),
+            timestamp=time.time(),
+            raw=post,
+        )
+        asyncio.create_task(self._dispatch(msg))
+
+    # ------------------------------------------------------------------
+    # REST helpers
+    # ------------------------------------------------------------------
+
+    async def _fetch_bot_user_id(self) -> str | None:
+        if not self._token:
+            return None
+        try:
+            import httpx
+
+            async with httpx.AsyncClient() as client:
+                resp = await client.get(
+                    f"{self._url}/api/v4/users/me",
+                    headers={"Authorization": f"Bearer {self._token}"},
+                    timeout=10.0,
+                )
+                resp.raise_for_status()
+                return resp.json().get("id")
+        except Exception as exc:
+            logger.warning("mattermost.fetch_user_id failed: %s", exc)
+            return None
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    def _resolve(self, value: str) -> str:
+        if isinstance(value, str) and value.startswith("ENV:"):
+            return os.getenv(value[4:], "")
+        return value
+
+    def get_config_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "required": ["token"],
+            "properties": {
+                "url": {"type": "string", "default": "http://localhost:8065"},
+                "token": {
+                    "type": "string",
+                    "description": "Personal access token (ENV:MATTERMOST_TOKEN)",
+                },
+                "team": {"type": "string", "description": "Team name or ID"},
+                "channel": {"type": "string", "default": "town-square"},
+            },
+        }

cortexflow_ai/channels/nextcloud.py

@@ -0,0 +1,297 @@
+"""Nextcloud Talk channel adapter — OCS REST API polling.
+
+CortexFlow connects to Nextcloud Talk rooms by long-polling the chat endpoint.
+There is no persistent WebSocket in the Nextcloud Talk OCS API; the adapter
+uses ``lastKnownMessageId`` to fetch only new messages on each poll cycle.
+
+Config keys:
+    url           Nextcloud base URL (e.g. https://cloud.example.com)
+    username      Nextcloud username (ENV:NEXTCLOUD_USERNAME)
+    password      App password or user password (ENV:NEXTCLOUD_PASSWORD)
+    room_token    Talk room token to poll (e.g. "abc123de")
+    poll_interval Seconds between poll requests (default: 5)
+
+OCS API endpoints used:
+    GET /ocs/v2.php/apps/spreed/api/v1/chat/{token}
+        Query params: lookIntoFuture=1, limit=100, lastKnownMessageId=<id>
+    POST /ocs/v2.php/apps/spreed/api/v1/chat/{token}
+        Body: {"message": "<text>"}
+
+Authentication: HTTP Basic Auth (username + app password).
+All requests include ``OCS-APIRequest: true`` and ``Accept: application/json``.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import time
+from typing import Any
+
+from cortexflow_ai.channels.base import ChannelAdapter, InboundMessage
+
+logger = logging.getLogger(__name__)
+
+_OCS_HEADERS = {
+    "OCS-APIRequest": "true",
+    "Accept": "application/json",
+}
+
+
+class NextcloudAdapter(ChannelAdapter):
+    """Nextcloud Talk adapter using the OCS v2 REST API with long-polling."""
+
+    channel_id = "nextcloud"
+
+    def __init__(self, config: dict[str, Any]) -> None:
+        super().__init__(config)
+        self._url: str = config.get("url", "https://localhost").rstrip("/")
+        self._username: str = self._resolve(config.get("username", ""))
+        self._password: str = self._resolve(config.get("password", ""))
+        self._room_token: str = config.get("room_token", "")
+        self._poll_interval: float = float(config.get("poll_interval", 5))
+        self._last_message_id: int = 0
+        self._own_user_id: str | None = None
+        self._poll_task: asyncio.Task | None = None
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    async def connect(self) -> None:
+        """Resolve own user identity, then start the polling loop."""
+        self._own_user_id = await self._fetch_own_user_id()
+        self._last_message_id = await self._fetch_last_message_id()
+        self._poll_task = asyncio.create_task(self._poll_loop())
+        logger.info(
+            "nextcloud.connected url=%s room=%s", self._url, self._room_token
+        )
+
+    async def disconnect(self) -> None:
+        if self._poll_task:
+            self._poll_task.cancel()
+            try:
+                await self._poll_task
+            except asyncio.CancelledError:
+                pass
+            self._poll_task = None
+
+    # ------------------------------------------------------------------
+    # Outbound
+    # ------------------------------------------------------------------
+
+    async def send(
+        self,
+        target: str,
+        text: str,
+        *,
+        reply_to: str | None = None,
+        attachments=None,
+    ) -> str | None:
+        """Post *text* to the room given by *target* (room token).
+
+        Returns the new message ID on success, None on error.
+        """
+        if not target:
+            target = self._room_token
+        if not target or not self._username or not self._password:
+            return None
+        try:
+            import httpx
+
+            endpoint = (
+                f"{self._url}/ocs/v2.php/apps/spreed/api/v1/chat/{target}"
+            )
+            payload: dict[str, Any] = {"message": text}
+            if reply_to:
+                payload["replyTo"] = int(reply_to)
+
+            async with httpx.AsyncClient() as client:
+                resp = await client.post(
+                    endpoint,
+                    headers=_OCS_HEADERS,
+                    json=payload,
+                    auth=(self._username, self._password),
+                    timeout=15.0,
+                )
+                resp.raise_for_status()
+                data = resp.json()
+                msg_id = (
+                    data.get("ocs", {})
+                    .get("data", {})
+                    .get("id")
+                )
+                return str(msg_id) if msg_id is not None else None
+        except Exception as exc:
+            logger.error("nextcloud.send failed: %s", exc)
+            return None
+
+    # ------------------------------------------------------------------
+    # Polling loop
+    # ------------------------------------------------------------------
+
+    async def _poll_loop(self) -> None:
+        while True:
+            try:
+                await self._poll_once()
+            except asyncio.CancelledError:
+                return
+            except Exception as exc:
+                logger.warning("nextcloud.poll_error: %s", exc)
+            await asyncio.sleep(self._poll_interval)
+
+    async def _poll_once(self) -> None:
+        if not self._room_token or not self._username or not self._password:
+            return
+        try:
+            import httpx
+
+            endpoint = (
+                f"{self._url}/ocs/v2.php/apps/spreed/api/v1/chat"
+                f"/{self._room_token}"
+            )
+            params: dict[str, Any] = {
+                "lookIntoFuture": 1,
+                "limit": 100,
+                "lastKnownMessageId": self._last_message_id,
+            }
+            async with httpx.AsyncClient() as client:
+                resp = await client.get(
+                    endpoint,
+                    headers=_OCS_HEADERS,
+                    params=params,
+                    auth=(self._username, self._password),
+                    timeout=30.0,
+                )
+                if resp.status_code == 304:
+                    return  # no new messages
+                resp.raise_for_status()
+                messages = (
+                    resp.json().get("ocs", {}).get("data", [])
+                )
+                for msg in messages:
+                    await self._process_message(msg)
+        except Exception as exc:
+            logger.debug("nextcloud._poll_once error: %s", exc)
+            raise
+
+    async def _process_message(self, msg: dict[str, Any]) -> None:
+        msg_id = int(msg.get("id", 0))
+        if msg_id > self._last_message_id:
+            self._last_message_id = msg_id
+
+        # Only handle regular chat messages from other users
+        if msg.get("systemMessage") or msg.get("messageType") == "system":
+            return
+
+        actor_id = msg.get("actorId", "")
+        if self._own_user_id and actor_id == self._own_user_id:
+            return  # skip own messages
+
+        text = (msg.get("message") or "").strip()
+        if not text:
+            return
+
+        inbound = InboundMessage(
+            channel=self.channel_id,
+            sender_id=actor_id,
+            sender_name=msg.get("actorDisplayName", ""),
+            text=text,
+            thread_id=self._room_token,
+            timestamp=float(msg.get("timestamp", time.time())),
+            raw=msg,
+        )
+        asyncio.create_task(self._dispatch(inbound))
+
+    # ------------------------------------------------------------------
+    # REST helpers
+    # ------------------------------------------------------------------
+
+    async def _fetch_own_user_id(self) -> str | None:
+        if not self._username or not self._password:
+            return None
+        try:
+            import httpx
+
+            async with httpx.AsyncClient() as client:
+                resp = await client.get(
+                    f"{self._url}/ocs/v2.php/cloud/user",
+                    headers=_OCS_HEADERS,
+                    auth=(self._username, self._password),
+                    timeout=10.0,
+                )
+                resp.raise_for_status()
+                return (
+                    resp.json().get("ocs", {}).get("data", {}).get("id")
+                )
+        except Exception as exc:
+            logger.warning("nextcloud.fetch_user_id failed: %s", exc)
+            return None
+
+    async def _fetch_last_message_id(self) -> int:
+        """Fetch the most recent message ID to avoid replaying history on start."""
+        if not self._room_token or not self._username or not self._password:
+            return 0
+        try:
+            import httpx
+
+            endpoint = (
+                f"{self._url}/ocs/v2.php/apps/spreed/api/v1/chat"
+                f"/{self._room_token}"
+            )
+            async with httpx.AsyncClient() as client:
+                resp = await client.get(
+                    endpoint,
+                    headers=_OCS_HEADERS,
+                    params={"limit": 1, "lookIntoFuture": 0},
+                    auth=(self._username, self._password),
+                    timeout=10.0,
+                )
+                resp.raise_for_status()
+                messages = (
+                    resp.json().get("ocs", {}).get("data", [])
+                )
+                if messages:
+                    return int(messages[-1].get("id", 0))
+        except Exception as exc:
+            logger.warning("nextcloud.fetch_last_id failed: %s", exc)
+        return 0
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    def _resolve(self, value: str) -> str:
+        if isinstance(value, str) and value.startswith("ENV:"):
+            return os.getenv(value[4:], "")
+        return value
+
+    def get_config_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "required": ["url", "username", "password", "room_token"],
+            "properties": {
+                "url": {
+                    "type": "string",
+                    "description": "Nextcloud base URL",
+                },
+                "username": {
+                    "type": "string",
+                    "description": "Nextcloud username (ENV:NEXTCLOUD_USERNAME)",
+                },
+                "password": {
+                    "type": "string",
+                    "description": "App password (ENV:NEXTCLOUD_PASSWORD)",
+                },
+                "room_token": {
+                    "type": "string",
+                    "description": "Talk room token",
+                },
+                "poll_interval": {
+                    "type": "number",
+                    "default": 5,
+                    "description": "Seconds between polls",
+                },
+            },
+        }