cortexflow-ai 2.0.0__py3-none-any.whl

cortexflow_ai/channels/irc.py

@@ -0,0 +1,261 @@
+"""IRC channel adapter using pure asyncio (no external library required).
+
+Implements RFC 1459 / 2812 IRC client over raw TCP with asyncio.
+Supports TLS (ircs://) and SASL PLAIN authentication.
+
+Features:
+- Auto-reconnect with exponential backoff
+- Channel message and private message handling
+- Command parsing (!reset, !memory, !status)
+- CTCP ACTION support (emote messages)
+- TLS support
+
+Setup (no pip install needed — uses stdlib asyncio):
+    config:
+        channels.irc.server   = "irc.libera.chat"
+        channels.irc.port     = 6697            # 6697 for TLS, 6667 plain
+        channels.irc.tls      = true
+        channels.irc.nick     = "cortexflow"
+        channels.irc.channels = ["#cortexflow", "#help"]
+        channels.irc.sasl_user     = "ENV:IRC_SASL_USER"     # optional
+        channels.irc.sasl_password = "ENV:IRC_SASL_PASSWORD"  # optional
+
+Usage::
+
+    adapter = IRCAdapter({
+        "server": "irc.libera.chat",
+        "port": 6697,
+        "tls": True,
+        "nick": "mybot",
+        "channels": ["#mychannel"],
+    })
+    adapter.on_message(my_handler)
+    await adapter.connect()
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import ssl
+from typing import Any
+
+from cortexflow_ai.channels.base import ChannelAdapter, InboundMessage
+
+logger = logging.getLogger(__name__)
+
+_CRLF = "\r\n"
+_MAX_LINE = 512
+_COMMANDS = {"!reset", "!memory", "!status", "!compact", "!voice", "!model"}
+_RECONNECT_BASE = 5   # seconds
+_RECONNECT_MAX = 300  # 5 minutes cap
+
+
+class IRCAdapter(ChannelAdapter):
+    """Pure-asyncio IRC client adapter.
+
+    Handles both public channel messages and private messages (PM).
+    Messages from channels arrive with thread_id=channel_name.
+    Private messages arrive with thread_id=None.
+    """
+
+    channel_id = "irc"
+
+    def __init__(self, config: dict[str, Any]) -> None:
+        super().__init__(config)
+        self._server = str(config.get("server", "irc.libera.chat"))
+        self._port = int(config.get("port", 6697))
+        self._tls = bool(config.get("tls", True))
+        self._nick = str(config.get("nick", "cortexflow"))
+        self._realname = str(config.get("realname", "CortexFlow AI"))
+        self._channels: list[str] = list(config.get("channels", []))
+        self._sasl_user = self._resolve(config.get("sasl_user", ""))
+        self._sasl_password = self._resolve(config.get("sasl_password", ""))
+        self._reader: asyncio.StreamReader | None = None
+        self._writer: asyncio.StreamWriter | None = None
+        self._read_task: asyncio.Task | None = None  # type: ignore[type-arg]
+        self._connected = False
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    async def connect(self) -> None:
+        ssl_ctx: ssl.SSLContext | None = ssl.create_default_context() if self._tls else None
+
+        self._reader, self._writer = await asyncio.open_connection(
+            self._server, self._port, ssl=ssl_ctx
+        )
+        self._connected = True
+
+        # Authenticate
+        if self._sasl_user:
+            await self._send_raw("CAP REQ :sasl")
+        await self._send_raw(f"NICK {self._nick}")
+        await self._send_raw(f"USER {self._nick} 0 * :{self._realname}")
+
+        # Start reader loop
+        self._read_task = asyncio.create_task(self._read_loop())
+        logger.info(
+            "irc.connected server=%s port=%d tls=%s nick=%s",
+            self._server,
+            self._port,
+            self._tls,
+            self._nick,
+        )
+
+    async def disconnect(self) -> None:
+        self._connected = False
+        if self._writer:
+            try:
+                await self._send_raw("QUIT :CortexFlow disconnecting")
+                self._writer.close()
+                await self._writer.wait_closed()
+            except Exception:
+                pass
+            self._writer = None
+            self._reader = None
+
+        if self._read_task:
+            self._read_task.cancel()
+            try:
+                await self._read_task
+            except asyncio.CancelledError:
+                pass
+            self._read_task = None
+
+        logger.info("irc.disconnected")
+
+    async def send(
+        self,
+        target: str,
+        text: str,
+        *,
+        reply_to: str | None = None,
+        attachments: list | None = None,
+    ) -> str | None:
+        """Send *text* to *target* (channel name or nick)."""
+        if not self._writer or not self._connected:
+            return None
+        # Split long messages at the IRC limit
+        for chunk in _split_message(text, max_len=400):
+            await self._send_raw(f"PRIVMSG {target} :{chunk}")
+        return None  # IRC has no message IDs
+
+    def get_config_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "required": ["server", "nick"],
+            "properties": {
+                "server": {"type": "string", "description": "IRC server hostname."},
+                "port": {"type": "integer", "default": 6697},
+                "tls": {"type": "boolean", "default": True},
+                "nick": {"type": "string", "description": "Bot nickname."},
+                "channels": {"type": "array", "items": {"type": "string"}, "description": "Channels to join on connect."},
+                "sasl_user": {"type": "string", "description": "SASL PLAIN username (ENV:IRC_SASL_USER)."},
+                "sasl_password": {"type": "string", "description": "SASL PLAIN password (ENV:IRC_SASL_PASSWORD)."},
+            },
+        }
+
+    # ------------------------------------------------------------------
+    # Internal
+    # ------------------------------------------------------------------
+
+    async def _send_raw(self, line: str) -> None:
+        if not self._writer:
+            return
+        data = (line[:_MAX_LINE] + _CRLF).encode("utf-8", errors="replace")
+        self._writer.write(data)
+        await self._writer.drain()
+
+    async def _read_loop(self) -> None:
+        """Read and parse IRC lines indefinitely."""
+        if not self._reader:
+            return
+        try:
+            while self._connected:
+                raw = await self._reader.readline()
+                if not raw:
+                    break
+                line = raw.decode("utf-8", errors="replace").strip()
+                await self._process_line(line)
+        except asyncio.CancelledError:
+            pass
+        except Exception as exc:
+            logger.error("irc.read_loop error: %s", exc)
+
+    async def _process_line(self, line: str) -> None:
+        if not line:
+            return
+
+        # PING → PONG (keepalive)
+        if line.startswith("PING"):
+            token = line.split(" ", 1)[1] if " " in line else ""
+            await self._send_raw(f"PONG {token}")
+            return
+
+        parts = line.split(" ")
+        if len(parts) < 2:
+            return
+
+        # Numeric 001 = welcome → join configured channels
+        if parts[1] == "001":
+            for channel in self._channels:
+                await self._send_raw(f"JOIN {channel}")
+
+        # CAP ACK for SASL
+        elif parts[1] == "CAP" and len(parts) > 3 and "ACK" in parts[3]:
+            await self._send_raw("AUTHENTICATE PLAIN")
+
+        # AUTHENTICATE challenge
+        elif parts[0] == "AUTHENTICATE" and parts[1] == "+":
+            import base64
+            creds = f"\0{self._sasl_user}\0{self._sasl_password}"
+            encoded = base64.b64encode(creds.encode()).decode()
+            await self._send_raw(f"AUTHENTICATE {encoded}")
+            await self._send_raw("CAP END")
+
+        # PRIVMSG → message
+        elif parts[1] == "PRIVMSG" and len(parts) >= 4:
+            prefix = parts[0].lstrip(":")
+            sender = prefix.split("!")[0] if "!" in prefix else prefix
+            target = parts[2]
+            text = " ".join(parts[3:])[1:]  # strip leading ":"
+
+            # Strip CTCP ACTION wrappers (\x01ACTION ...\x01)
+            if text.startswith("\x01ACTION") and text.endswith("\x01"):
+                text = f"* {text[8:-1].strip()}"
+
+            thread_id = target if target.startswith("#") else None
+
+            msg = InboundMessage(
+                channel=self.channel_id,
+                sender_id=sender,
+                sender_name=sender,
+                text=text,
+                thread_id=thread_id,
+                raw={"prefix": prefix, "target": target},
+            )
+
+            if self._handler:
+                asyncio.create_task(self._handler(msg))
+
+            logger.debug("irc.message sender=%s target=%s len=%d", sender, target, len(text))
+
+    @staticmethod
+    def _resolve(value: str) -> str:
+        if isinstance(value, str) and value.startswith("ENV:"):
+            import os
+            return os.getenv(value[4:], "")
+        return value or ""
+
+
+def _split_message(text: str, max_len: int = 400) -> list[str]:
+    """Split a long message into chunks that fit within IRC limits."""
+    if len(text) <= max_len:
+        return [text]
+    chunks: list[str] = []
+    while text:
+        chunks.append(text[:max_len])
+        text = text[max_len:]
+    return chunks

cortexflow_ai/channels/mastodon_.py

@@ -0,0 +1,235 @@
+"""Mastodon channel adapter using Mastodon.py.
+
+Supports:
+- Receiving mentions via user streaming
+- Receiving direct messages (DMs)
+- Sending replies as public, unlisted, or direct posts
+- Mastodon bot commands: @bot !reset, @bot !memory, etc.
+
+Setup:
+    pip install Mastodon.py>=1.8.0
+
+    Steps:
+        1. Create a Mastodon app: mastodon.social → Settings → Development
+        2. Or use Mastodon.create_app() — see below
+
+    Required config:
+        channels.mastodon.instance_url  = "https://mastodon.social"
+        channels.mastodon.access_token  = "ENV:MASTODON_ACCESS_TOKEN"
+        channels.mastodon.bot_username  = "@cortexflow"  # your bot's username
+
+Usage::
+
+    adapter = MastodonAdapter({
+        "instance_url": "https://mastodon.social",
+        "access_token": "your-access-token",
+        "bot_username": "@mybot",
+    })
+    adapter.on_message(my_handler)
+    await adapter.connect()
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import re
+from typing import Any
+
+from cortexflow_ai.channels.base import Attachment, ChannelAdapter, InboundMessage
+
+logger = logging.getLogger(__name__)
+
+# Strip HTML tags from toot content
+_HTML_TAG = re.compile(r"<[^>]+>")
+
+
+def _strip_html(html: str) -> str:
+    return _HTML_TAG.sub("", html).strip()
+
+
+class MastodonAdapter(ChannelAdapter):
+    """Mastodon adapter — receives mentions via streaming, sends toots as replies.
+
+    Uses Mastodon.py's streaming listener in a background asyncio task.
+    Mastodon.py's streaming is synchronous, so it runs in a thread executor.
+    """
+
+    channel_id = "mastodon"
+
+    def __init__(self, config: dict[str, Any]) -> None:
+        super().__init__(config)
+        self._instance_url = str(config.get("instance_url", "https://mastodon.social"))
+        self._access_token = self._resolve(config.get("access_token", ""))
+        self._bot_username = str(config.get("bot_username", ""))
+        self._visibility = str(config.get("reply_visibility", "unlisted"))
+        self._client: Any | None = None
+        self._stream_task: asyncio.Task | None = None  # type: ignore[type-arg]
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    async def connect(self) -> None:
+        try:
+            from mastodon import Mastodon  # type: ignore[import]
+        except ImportError:
+            raise RuntimeError("pip install Mastodon.py>=1.8.0")
+
+        self._client = Mastodon(
+            access_token=self._access_token,
+            api_base_url=self._instance_url,
+        )
+
+        self._stream_task = asyncio.create_task(self._stream_mentions())
+        logger.info(
+            "mastodon.connected instance=%s bot=%s",
+            self._instance_url,
+            self._bot_username,
+        )
+
+    async def disconnect(self) -> None:
+        if self._stream_task:
+            self._stream_task.cancel()
+            try:
+                await self._stream_task
+            except asyncio.CancelledError:
+                pass
+            self._stream_task = None
+        self._client = None
+        logger.info("mastodon.disconnected")
+
+    async def send(
+        self,
+        target: str,
+        text: str,
+        *,
+        reply_to: str | None = None,
+        attachments: list | None = None,
+    ) -> str | None:
+        """Post a toot. *target* is the account to mention (e.g. '@user@instance').
+
+        Args:
+            target:   Account handle to @-mention in the reply.
+            text:     Message body (may be truncated to 500 chars).
+            reply_to: Status ID of the toot to reply to.
+        """
+        if not self._client:
+            return None
+
+        content = f"{target} {text}" if target else text
+        # Mastodon limit is typically 500 chars
+        content = content[:500]
+
+        try:
+            loop = asyncio.get_running_loop()
+            status = await loop.run_in_executor(
+                None,
+                lambda: self._client.status_post(
+                    content,
+                    in_reply_to_id=reply_to,
+                    visibility=self._visibility,
+                ),
+            )
+            status_id = str(status.get("id", ""))
+            logger.debug("mastodon.sent status_id=%s len=%d", status_id, len(content))
+            return status_id
+        except Exception as exc:
+            logger.error("mastodon.send failed target=%s: %s", target, exc)
+            return None
+
+    def get_config_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "required": ["instance_url", "access_token"],
+            "properties": {
+                "instance_url": {"type": "string", "description": "Mastodon instance URL (e.g. https://mastodon.social)."},
+                "access_token": {"type": "string", "description": "OAuth2 access token (ENV:MASTODON_ACCESS_TOKEN)."},
+                "bot_username": {"type": "string", "description": "@username of this bot (used to strip self-mentions)."},
+                "reply_visibility": {"type": "string", "enum": ["public", "unlisted", "private", "direct"], "default": "unlisted"},
+            },
+        }
+
+    # ------------------------------------------------------------------
+    # Streaming
+    # ------------------------------------------------------------------
+
+    async def _stream_mentions(self) -> None:
+        """Stream user notifications in a thread executor (Mastodon.py is sync)."""
+        loop = asyncio.get_running_loop()
+        try:
+            await loop.run_in_executor(None, self._blocking_stream)
+        except asyncio.CancelledError:
+            pass
+        except Exception as exc:
+            logger.error("mastodon.stream error: %s", exc)
+
+    def _blocking_stream(self) -> None:
+        """Blocking stream listener — runs in thread executor."""
+        try:
+            from mastodon import StreamListener  # type: ignore[import]
+        except ImportError:
+            return
+
+        adapter_ref = self
+
+        class _Listener(StreamListener):
+            def on_notification(self, notification: dict) -> None:
+                if notification.get("type") != "mention":
+                    return
+                status = notification.get("status", {})
+                account = status.get("account", {})
+                content_html = status.get("content", "")
+                text = _strip_html(content_html)
+
+                # Strip bot's own @-mention from the message
+                if adapter_ref._bot_username:
+                    text = text.replace(adapter_ref._bot_username, "").strip()
+
+                sender_id = account.get("acct", "unknown")
+                status_id = str(status.get("id", ""))
+
+                if not text:
+                    return
+
+                # Build attachments from media
+                attachments: list[Attachment] = []
+                for media in status.get("media_attachments", []):
+                    attachments.append(
+                        Attachment(
+                            type=media.get("type", "document"),
+                            url=media.get("url"),
+                        )
+                    )
+
+                msg = InboundMessage(
+                    channel=adapter_ref.channel_id,
+                    sender_id=sender_id,
+                    sender_name=account.get("display_name", sender_id),
+                    text=text,
+                    attachments=attachments,
+                    thread_id=status_id,  # use status ID as thread context
+                    raw=status,
+                )
+
+                if adapter_ref._handler:
+                    loop = asyncio.new_event_loop()
+                    loop.run_until_complete(adapter_ref._handler(msg))
+                    loop.close()
+
+                logger.debug(
+                    "mastodon.mention from=%s status=%s len=%d",
+                    sender_id,
+                    status_id,
+                    len(text),
+                )
+
+        if self._client:
+            self._client.stream_user(_Listener())
+
+    @staticmethod
+    def _resolve(value: str) -> str:
+        if isinstance(value, str) and value.startswith("ENV:"):
+            import os
+            return os.getenv(value[4:], "")
+        return value or ""

cortexflow_ai/channels/matrix.py

@@ -0,0 +1,196 @@
+"""Matrix channel adapter using matrix-nio (async).
+
+Supports:
+- Receiving messages from rooms the bot is joined to
+- Sending text and formatted (HTML) messages
+- Auto-joining rooms on invite
+- Commands: !reset, !memory, !status, !compact
+
+Setup:
+    pip install matrix-nio>=0.24.0
+
+    Required config:
+        channels.matrix.homeserver  = "https://matrix.org"
+        channels.matrix.user_id     = "@mybot:matrix.org"
+        channels.matrix.access_token = "ENV:MATRIX_ACCESS_TOKEN"
+        channels.matrix.device_name = "CortexFlow"        # optional
+
+Usage::
+
+    adapter = MatrixAdapter({
+        "homeserver": "https://matrix.org",
+        "user_id": "@mybot:matrix.org",
+        "access_token": "syt_...",
+    })
+    adapter.on_message(my_handler)
+    await adapter.connect()
+"""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any
+
+from cortexflow_ai.channels.base import ChannelAdapter, InboundMessage
+
+logger = logging.getLogger(__name__)
+
+_COMMANDS = {"!reset", "!memory", "!status", "!compact", "!voice", "!model"}
+
+
+class MatrixAdapter(ChannelAdapter):
+    """Matrix chat adapter using matrix-nio in async mode.
+
+    Connects to any Matrix homeserver. Handles room invites automatically
+    and dispatches all room text events to the registered handler.
+    """
+
+    channel_id = "matrix"
+
+    def __init__(self, config: dict[str, Any]) -> None:
+        super().__init__(config)
+        self._homeserver = str(config.get("homeserver", "https://matrix.org"))
+        self._user_id = str(config.get("user_id", ""))
+        self._access_token = self._resolve(config.get("access_token", ""))
+        self._device_name = str(config.get("device_name", "CortexFlow"))
+        self._client: Any | None = None
+        self._sync_task: asyncio.Task | None = None  # type: ignore[type-arg]
+
+    # ------------------------------------------------------------------
+    # Lifecycle
+    # ------------------------------------------------------------------
+
+    async def connect(self) -> None:
+        try:
+            from nio import (  # type: ignore[import]
+                AsyncClient,
+                InviteEvent,
+                RoomMessageText,
+            )
+        except ImportError:
+            raise RuntimeError("pip install matrix-nio>=0.24.0")
+
+        self._client = AsyncClient(self._homeserver, self._user_id)
+        self._client.access_token = self._access_token
+
+        # Register event callbacks
+        self._client.add_event_callback(self._on_message, RoomMessageText)
+        self._client.add_event_callback(self._on_invite, InviteEvent)
+
+        # Start background sync loop
+        self._sync_task = asyncio.create_task(self._sync_loop())
+        logger.info(
+            "matrix.connected homeserver=%s user=%s",
+            self._homeserver,
+            self._user_id,
+        )
+
+    async def disconnect(self) -> None:
+        if self._sync_task:
+            self._sync_task.cancel()
+            try:
+                await self._sync_task
+            except asyncio.CancelledError:
+                pass
+            self._sync_task = None
+
+        if self._client:
+            await self._client.close()
+            self._client = None
+
+        logger.info("matrix.disconnected")
+
+    async def send(
+        self,
+        target: str,
+        text: str,
+        *,
+        reply_to: str | None = None,
+        attachments: list | None = None,
+    ) -> str | None:
+        """Send a text message to *target* (Matrix room ID, e.g. !abc:matrix.org)."""
+        if not self._client:
+            return None
+        try:
+            response = await self._client.room_send(
+                room_id=target,
+                message_type="m.room.message",
+                content={"msgtype": "m.text", "body": text},
+            )
+            event_id = getattr(response, "event_id", None)
+            logger.debug("matrix.sent room=%s event_id=%s", target, event_id)
+            return event_id
+        except Exception as exc:
+            logger.error("matrix.send failed room=%s: %s", target, exc)
+            return None
+
+    def get_config_schema(self) -> dict[str, Any]:
+        return {
+            "type": "object",
+            "required": ["homeserver", "user_id", "access_token"],
+            "properties": {
+                "homeserver": {"type": "string", "description": "Matrix homeserver URL."},
+                "user_id": {"type": "string", "description": "Full Matrix user ID (@bot:homeserver)."},
+                "access_token": {"type": "string", "description": "Matrix access token (ENV:MATRIX_ACCESS_TOKEN)."},
+                "device_name": {"type": "string", "default": "CortexFlow"},
+            },
+        }
+
+    # ------------------------------------------------------------------
+    # Event handlers
+    # ------------------------------------------------------------------
+
+    async def _on_message(self, room: Any, event: Any) -> None:
+        # Skip own messages
+        if event.sender == self._user_id:
+            return
+
+        text = event.body.strip()
+
+        msg = InboundMessage(
+            channel=self.channel_id,
+            sender_id=event.sender,
+            sender_name=event.sender,
+            text=text,
+            thread_id=room.room_id,
+            raw={"room_id": room.room_id, "event_id": event.event_id},
+        )
+
+        if self._handler:
+            asyncio.create_task(self._handler(msg))
+
+        logger.debug(
+            "matrix.message room=%s sender=%s len=%d",
+            room.room_id,
+            event.sender,
+            len(text),
+        )
+
+    async def _on_invite(self, room: Any, event: Any) -> None:
+        """Auto-join rooms on invite."""
+        if not self._client:
+            return
+        try:
+            await self._client.join(room.room_id)
+            logger.info("matrix.joined room=%s", room.room_id)
+        except Exception as exc:
+            logger.warning("matrix.join failed room=%s: %s", room.room_id, exc)
+
+    async def _sync_loop(self) -> None:
+        """Run Matrix sync indefinitely."""
+        if not self._client:
+            return
+        try:
+            await self._client.sync_forever(timeout=30000, full_state=True)
+        except asyncio.CancelledError:
+            pass
+        except Exception as exc:
+            logger.error("matrix.sync_loop error: %s", exc)
+
+    @staticmethod
+    def _resolve(value: str) -> str:
+        if isinstance(value, str) and value.startswith("ENV:"):
+            import os
+            return os.getenv(value[4:], "")
+        return value or ""