flowly-code 1.0.0__py3-none-any.whl

flowly_code/channels/manager.py

@@ -0,0 +1,135 @@
+"""Channel manager for coordinating chat channels."""
+
+import asyncio
+from typing import Any
+
+from loguru import logger
+
+from flowly_code.bus.events import OutboundMessage
+from flowly_code.bus.queue import MessageBus
+from flowly_code.channels.base import BaseChannel
+from flowly_code.config.schema import Config
+
+
+class ChannelManager:
+    """
+    Manages chat channels and coordinates message routing.
+
+    Responsibilities:
+    - Initialize enabled channels (Telegram, WhatsApp, etc.)
+    - Start/stop channels
+    - Route outbound messages
+    """
+
+    def __init__(self, config: Config, bus: MessageBus):
+        self.config = config
+        self.bus = bus
+        self.channels: dict[str, BaseChannel] = {}
+        self._dispatch_task: asyncio.Task | None = None
+
+        self._init_channels()
+
+    def _init_channels(self) -> None:
+        """Initialize channels based on config."""
+
+        # Telegram channel
+        if self.config.channels.telegram.enabled:
+            try:
+                from flowly_code.channels.telegram import TelegramChannel
+                self.channels["telegram"] = TelegramChannel(
+                    self.config.channels.telegram,
+                    self.bus,
+                    groq_api_key=self.config.providers.groq.api_key,
+                    dispatch_config=self.config.integrations.dispatch,
+                )
+                logger.info("Telegram channel enabled")
+            except ImportError as e:
+                logger.warning(f"Telegram channel not available: {e}")
+
+    async def start_all(self) -> None:
+        """Start all channels and the outbound dispatcher."""
+        if not self.channels:
+            logger.warning("No channels enabled")
+            return
+
+        # Start outbound dispatcher
+        self._dispatch_task = asyncio.create_task(self._dispatch_outbound())
+
+        # Start channels
+        tasks = []
+        for name, channel in self.channels.items():
+            logger.info(f"Starting {name} channel...")
+            tasks.append(asyncio.create_task(channel.start()))
+
+        # Wait for all to complete (they should run forever)
+        await asyncio.gather(*tasks, return_exceptions=True)
+
+    async def stop_all(self) -> None:
+        """Stop all channels and the dispatcher."""
+        logger.info("Stopping all channels...")
+
+        # Stop dispatcher
+        if self._dispatch_task:
+            self._dispatch_task.cancel()
+            try:
+                await self._dispatch_task
+            except asyncio.CancelledError:
+                pass
+
+        # Stop all channels
+        for name, channel in self.channels.items():
+            try:
+                await channel.stop()
+                logger.info(f"Stopped {name} channel")
+            except Exception as e:
+                logger.error(f"Error stopping {name}: {e}")
+
+    async def _dispatch_outbound(self) -> None:
+        """Dispatch outbound messages to the appropriate channel."""
+        logger.info("Outbound dispatcher started")
+
+        while True:
+            try:
+                msg = await asyncio.wait_for(
+                    self.bus.consume_outbound(),
+                    timeout=1.0
+                )
+
+                channel = self.channels.get(msg.channel)
+                if channel:
+                    try:
+                        await channel.send(msg)
+                    except Exception as e:
+                        logger.error(f"Error sending to {msg.channel}: {e}")
+                else:
+                    logger.warning(f"Unknown channel: {msg.channel}")
+
+            except asyncio.TimeoutError:
+                continue
+            except asyncio.CancelledError:
+                break
+
+    def get_channel(self, name: str) -> BaseChannel | None:
+        """Get a channel by name."""
+        return self.channels.get(name)
+
+    def set_compact_callback(self, callback: callable) -> None:
+        """Set the compaction callback for all channels that support it."""
+        for channel in self.channels.values():
+            if hasattr(channel, "set_compact_callback"):
+                channel.set_compact_callback(callback)
+
+    def get_status(self) -> dict[str, Any]:
+        """Get status of all channels."""
+        return {
+            name: {
+                "enabled": True,
+                "running": channel.is_running
+            }
+            for name, channel in self.channels.items()
+        }
+
+    @property
+    def enabled_channels(self) -> list[str]:
+        """Get list of enabled channel names."""
+        return list(self.channels.keys())