kyber-chat 1.0.0__py3-none-any.whl

kyber/channels/manager.py

@@ -0,0 +1,161 @@
+"""Channel manager for coordinating chat channels."""
+
+import asyncio
+from typing import Any
+
+from loguru import logger
+
+from kyber.bus.events import OutboundMessage
+from kyber.bus.queue import MessageBus
+from kyber.channels.base import BaseChannel
+from kyber.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 kyber.channels.telegram import TelegramChannel
+                self.channels["telegram"] = TelegramChannel(
+                    self.config.channels.telegram,
+                    self.bus,
+                    groq_api_key=self.config.providers.groq.api_key,
+                )
+                logger.info("Telegram channel enabled")
+            except ImportError as e:
+                logger.warning(f"Telegram channel not available: {e}")
+        
+        # WhatsApp channel
+        if self.config.channels.whatsapp.enabled:
+            try:
+                from kyber.channels.whatsapp import WhatsAppChannel
+                self.channels["whatsapp"] = WhatsAppChannel(
+                    self.config.channels.whatsapp, self.bus
+                )
+                logger.info("WhatsApp channel enabled")
+            except ImportError as e:
+                logger.warning(f"WhatsApp channel not available: {e}")
+        
+        # Feishu channel
+        if self.config.channels.feishu.enabled:
+            try:
+                from kyber.channels.feishu import FeishuChannel
+                self.channels["feishu"] = FeishuChannel(
+                    self.config.channels.feishu, self.bus
+                )
+                logger.info("Feishu channel enabled")
+            except ImportError as e:
+                logger.warning(f"Feishu channel not available: {e}")
+
+        # Discord channel
+        if self.config.channels.discord.enabled:
+            try:
+                from kyber.channels.discord import DiscordChannel
+                self.channels["discord"] = DiscordChannel(
+                    self.config.channels.discord, self.bus
+                )
+                logger.info("Discord channel enabled")
+            except ImportError as e:
+                logger.warning(f"Discord channel not available: {e}")
+    
+    async def start_all(self) -> None:
+        """Start WhatsApp channel 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 WhatsApp channel
+        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 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())

kyber/channels/telegram.py

@@ -0,0 +1,302 @@
+"""Telegram channel implementation using python-telegram-bot."""
+
+import asyncio
+import re
+
+from loguru import logger
+from telegram import Update
+from telegram.ext import Application, MessageHandler, filters, ContextTypes
+
+from kyber.bus.events import OutboundMessage
+from kyber.bus.queue import MessageBus
+from kyber.channels.base import BaseChannel
+from kyber.config.schema import TelegramConfig
+
+
+def _markdown_to_telegram_html(text: str) -> str:
+    """
+    Convert markdown to Telegram-safe HTML.
+    """
+    if not text:
+        return ""
+    
+    # 1. Extract and protect code blocks (preserve content from other processing)
+    code_blocks: list[str] = []
+    def save_code_block(m: re.Match) -> str:
+        code_blocks.append(m.group(1))
+        return f"\x00CB{len(code_blocks) - 1}\x00"
+    
+    text = re.sub(r'```[\w]*\n?([\s\S]*?)```', save_code_block, text)
+    
+    # 2. Extract and protect inline code
+    inline_codes: list[str] = []
+    def save_inline_code(m: re.Match) -> str:
+        inline_codes.append(m.group(1))
+        return f"\x00IC{len(inline_codes) - 1}\x00"
+    
+    text = re.sub(r'`([^`]+)`', save_inline_code, text)
+    
+    # 3. Headers # Title -> just the title text
+    text = re.sub(r'^#{1,6}\s+(.+)$', r'\1', text, flags=re.MULTILINE)
+    
+    # 4. Blockquotes > text -> just the text (before HTML escaping)
+    text = re.sub(r'^>\s*(.*)$', r'\1', text, flags=re.MULTILINE)
+    
+    # 5. Escape HTML special characters
+    text = text.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+    
+    # 6. Links [text](url) - must be before bold/italic to handle nested cases
+    text = re.sub(r'\[([^\]]+)\]\(([^)]+)\)', r'<a href="\2">\1</a>', text)
+    
+    # 7. Bold **text** or __text__
+    text = re.sub(r'\*\*(.+?)\*\*', r'<b>\1</b>', text)
+    text = re.sub(r'__(.+?)__', r'<b>\1</b>', text)
+    
+    # 8. Italic _text_ (avoid matching inside words like some_var_name)
+    text = re.sub(r'(?<![a-zA-Z0-9])_([^_]+)_(?![a-zA-Z0-9])', r'<i>\1</i>', text)
+    
+    # 9. Strikethrough ~~text~~
+    text = re.sub(r'~~(.+?)~~', r'<s>\1</s>', text)
+    
+    # 10. Bullet lists - item -> • item
+    text = re.sub(r'^[-*]\s+', '• ', text, flags=re.MULTILINE)
+    
+    # 11. Restore inline code with HTML tags
+    for i, code in enumerate(inline_codes):
+        # Escape HTML in code content
+        escaped = code.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+        text = text.replace(f"\x00IC{i}\x00", f"<code>{escaped}</code>")
+    
+    # 12. Restore code blocks with HTML tags
+    for i, code in enumerate(code_blocks):
+        # Escape HTML in code content
+        escaped = code.replace("&", "&amp;").replace("<", "&lt;").replace(">", "&gt;")
+        text = text.replace(f"\x00CB{i}\x00", f"<pre><code>{escaped}</code></pre>")
+    
+    return text
+
+
+class TelegramChannel(BaseChannel):
+    """
+    Telegram channel using long polling.
+    
+    Simple and reliable - no webhook/public IP needed.
+    """
+    
+    name = "telegram"
+    
+    def __init__(self, config: TelegramConfig, bus: MessageBus, groq_api_key: str = ""):
+        super().__init__(config, bus)
+        self.config: TelegramConfig = config
+        self.groq_api_key = groq_api_key
+        self._app: Application | None = None
+        self._chat_ids: dict[str, int] = {}  # Map sender_id to chat_id for replies
+    
+    async def start(self) -> None:
+        """Start the Telegram bot with long polling."""
+        if not self.config.token:
+            logger.error("Telegram bot token not configured")
+            return
+        
+        self._running = True
+        
+        # Build the application
+        self._app = (
+            Application.builder()
+            .token(self.config.token)
+            .build()
+        )
+        
+        # Add message handler for text, photos, voice, documents
+        self._app.add_handler(
+            MessageHandler(
+                (filters.TEXT | filters.PHOTO | filters.VOICE | filters.AUDIO | filters.Document.ALL) 
+                & ~filters.COMMAND, 
+                self._on_message
+            )
+        )
+        
+        # Add /start command handler
+        from telegram.ext import CommandHandler
+        self._app.add_handler(CommandHandler("start", self._on_start))
+        
+        logger.info("Starting Telegram bot (polling mode)...")
+        
+        # Initialize and start polling
+        await self._app.initialize()
+        await self._app.start()
+        
+        # Get bot info
+        bot_info = await self._app.bot.get_me()
+        logger.info(f"Telegram bot @{bot_info.username} connected")
+        
+        # Start polling (this runs until stopped)
+        await self._app.updater.start_polling(
+            allowed_updates=["message"],
+            drop_pending_updates=True  # Ignore old messages on startup
+        )
+        
+        # Keep running until stopped
+        while self._running:
+            await asyncio.sleep(1)
+    
+    async def stop(self) -> None:
+        """Stop the Telegram bot."""
+        self._running = False
+        
+        if self._app:
+            logger.info("Stopping Telegram bot...")
+            await self._app.updater.stop()
+            await self._app.stop()
+            await self._app.shutdown()
+            self._app = None
+    
+    async def send(self, msg: OutboundMessage) -> None:
+        """Send a message through Telegram."""
+        if not self._app:
+            logger.warning("Telegram bot not running")
+            return
+        
+        try:
+            # chat_id should be the Telegram chat ID (integer)
+            chat_id = int(msg.chat_id)
+            # Convert markdown to Telegram HTML
+            html_content = _markdown_to_telegram_html(msg.content)
+            await self._app.bot.send_message(
+                chat_id=chat_id,
+                text=html_content,
+                parse_mode="HTML"
+            )
+        except ValueError:
+            logger.error(f"Invalid chat_id: {msg.chat_id}")
+        except Exception as e:
+            # Fallback to plain text if HTML parsing fails
+            logger.warning(f"HTML parse failed, falling back to plain text: {e}")
+            try:
+                await self._app.bot.send_message(
+                    chat_id=int(msg.chat_id),
+                    text=msg.content
+                )
+            except Exception as e2:
+                logger.error(f"Error sending Telegram message: {e2}")
+    
+    async def _on_start(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        """Handle /start command."""
+        if not update.message or not update.effective_user:
+            return
+        
+        user = update.effective_user
+        await update.message.reply_text(
+            f"👋 Hi {user.first_name}! I'm kyber.\n\n"
+            "Send me a message and I'll respond!"
+        )
+    
+    async def _on_message(self, update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
+        """Handle incoming messages (text, photos, voice, documents)."""
+        if not update.message or not update.effective_user:
+            return
+        
+        message = update.message
+        user = update.effective_user
+        chat_id = message.chat_id
+        
+        # Use stable numeric ID, but keep username for allowlist compatibility
+        sender_id = str(user.id)
+        if user.username:
+            sender_id = f"{sender_id}|{user.username}"
+        
+        # Store chat_id for replies
+        self._chat_ids[sender_id] = chat_id
+        
+        # Build content from text and/or media
+        content_parts = []
+        media_paths = []
+        
+        # Text content
+        if message.text:
+            content_parts.append(message.text)
+        if message.caption:
+            content_parts.append(message.caption)
+        
+        # Handle media files
+        media_file = None
+        media_type = None
+        
+        if message.photo:
+            media_file = message.photo[-1]  # Largest photo
+            media_type = "image"
+        elif message.voice:
+            media_file = message.voice
+            media_type = "voice"
+        elif message.audio:
+            media_file = message.audio
+            media_type = "audio"
+        elif message.document:
+            media_file = message.document
+            media_type = "file"
+        
+        # Download media if present
+        if media_file and self._app:
+            try:
+                file = await self._app.bot.get_file(media_file.file_id)
+                ext = self._get_extension(media_type, getattr(media_file, 'mime_type', None))
+                
+                # Save to workspace/media/
+                from pathlib import Path
+                media_dir = Path.home() / ".kyber" / "media"
+                media_dir.mkdir(parents=True, exist_ok=True)
+                
+                file_path = media_dir / f"{media_file.file_id[:16]}{ext}"
+                await file.download_to_drive(str(file_path))
+                
+                media_paths.append(str(file_path))
+                
+                # Handle voice transcription
+                if media_type == "voice" or media_type == "audio":
+                    from kyber.providers.transcription import GroqTranscriptionProvider
+                    transcriber = GroqTranscriptionProvider(api_key=self.groq_api_key)
+                    transcription = await transcriber.transcribe(file_path)
+                    if transcription:
+                        logger.info(f"Transcribed {media_type}: {transcription[:50]}...")
+                        content_parts.append(f"[transcription: {transcription}]")
+                    else:
+                        content_parts.append(f"[{media_type}: {file_path}]")
+                else:
+                    content_parts.append(f"[{media_type}: {file_path}]")
+                    
+                logger.debug(f"Downloaded {media_type} to {file_path}")
+            except Exception as e:
+                logger.error(f"Failed to download media: {e}")
+                content_parts.append(f"[{media_type}: download failed]")
+        
+        content = "\n".join(content_parts) if content_parts else "[empty message]"
+        
+        logger.debug(f"Telegram message from {sender_id}: {content[:50]}...")
+        
+        # Forward to the message bus
+        await self._handle_message(
+            sender_id=sender_id,
+            chat_id=str(chat_id),
+            content=content,
+            media=media_paths,
+            metadata={
+                "message_id": message.message_id,
+                "user_id": user.id,
+                "username": user.username,
+                "first_name": user.first_name,
+                "is_group": message.chat.type != "private"
+            }
+        )
+    
+    def _get_extension(self, media_type: str, mime_type: str | None) -> str:
+        """Get file extension based on media type."""
+        if mime_type:
+            ext_map = {
+                "image/jpeg": ".jpg", "image/png": ".png", "image/gif": ".gif",
+                "audio/ogg": ".ogg", "audio/mpeg": ".mp3", "audio/mp4": ".m4a",
+            }
+            if mime_type in ext_map:
+                return ext_map[mime_type]
+        
+        type_map = {"image": ".jpg", "voice": ".ogg", "audio": ".mp3", "file": ""}
+        return type_map.get(media_type, "")

kyber/channels/whatsapp.py

@@ -0,0 +1,141 @@
+"""WhatsApp channel implementation using Node.js bridge."""
+
+import asyncio
+import json
+from typing import Any
+
+from loguru import logger
+
+from kyber.bus.events import OutboundMessage
+from kyber.bus.queue import MessageBus
+from kyber.channels.base import BaseChannel
+from kyber.config.schema import WhatsAppConfig
+
+
+class WhatsAppChannel(BaseChannel):
+    """
+    WhatsApp channel that connects to a Node.js bridge.
+    
+    The bridge uses @whiskeysockets/baileys to handle the WhatsApp Web protocol.
+    Communication between Python and Node.js is via WebSocket.
+    """
+    
+    name = "whatsapp"
+    
+    def __init__(self, config: WhatsAppConfig, bus: MessageBus):
+        super().__init__(config, bus)
+        self.config: WhatsAppConfig = config
+        self._ws = None
+        self._connected = False
+    
+    async def start(self) -> None:
+        """Start the WhatsApp channel by connecting to the bridge."""
+        import websockets
+        
+        bridge_url = self.config.bridge_url
+        
+        logger.info(f"Connecting to WhatsApp bridge at {bridge_url}...")
+        
+        self._running = True
+        
+        while self._running:
+            try:
+                async with websockets.connect(bridge_url) as ws:
+                    self._ws = ws
+                    self._connected = True
+                    logger.info("Connected to WhatsApp bridge")
+                    
+                    # Listen for messages
+                    async for message in ws:
+                        try:
+                            await self._handle_bridge_message(message)
+                        except Exception as e:
+                            logger.error(f"Error handling bridge message: {e}")
+                    
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                self._connected = False
+                self._ws = None
+                logger.warning(f"WhatsApp bridge connection error: {e}")
+                
+                if self._running:
+                    logger.info("Reconnecting in 5 seconds...")
+                    await asyncio.sleep(5)
+    
+    async def stop(self) -> None:
+        """Stop the WhatsApp channel."""
+        self._running = False
+        self._connected = False
+        
+        if self._ws:
+            await self._ws.close()
+            self._ws = None
+    
+    async def send(self, msg: OutboundMessage) -> None:
+        """Send a message through WhatsApp."""
+        if not self._ws or not self._connected:
+            logger.warning("WhatsApp bridge not connected")
+            return
+        
+        try:
+            payload = {
+                "type": "send",
+                "to": msg.chat_id,
+                "text": msg.content
+            }
+            await self._ws.send(json.dumps(payload))
+        except Exception as e:
+            logger.error(f"Error sending WhatsApp message: {e}")
+    
+    async def _handle_bridge_message(self, raw: str) -> None:
+        """Handle a message from the bridge."""
+        try:
+            data = json.loads(raw)
+        except json.JSONDecodeError:
+            logger.warning(f"Invalid JSON from bridge: {raw[:100]}")
+            return
+        
+        msg_type = data.get("type")
+        
+        if msg_type == "message":
+            # Incoming message from WhatsApp
+            sender = data.get("sender", "")
+            content = data.get("content", "")
+            
+            # sender is typically: <phone>@s.whatsapp.net
+            # Extract just the phone number as chat_id
+            chat_id = sender.split("@")[0] if "@" in sender else sender
+            
+            # Handle voice transcription if it's a voice message
+            if content == "[Voice Message]":
+                logger.info(f"Voice message received from {chat_id}, but direct download from bridge is not yet supported.")
+                content = "[Voice Message: Transcription not available for WhatsApp yet]"
+            
+            await self._handle_message(
+                sender_id=chat_id,
+                chat_id=sender,  # Use full JID for replies
+                content=content,
+                metadata={
+                    "message_id": data.get("id"),
+                    "timestamp": data.get("timestamp"),
+                    "is_group": data.get("isGroup", False)
+                }
+            )
+        
+        elif msg_type == "status":
+            # Connection status update
+            status = data.get("status")
+            logger.info(f"WhatsApp status: {status}")
+            
+            if status == "connected":
+                self._connected = True
+            elif status == "disconnected":
+                self._connected = False
+        
+        elif msg_type == "qr":
+            # QR code for authentication
+            logger.info("Scan QR code in the bridge terminal to connect WhatsApp")
+        
+        elif msg_type == "error":
+            logger.error(f"WhatsApp bridge error: {data.get('error')}")

kyber/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI module for kyber."""