lollmsbot 0.0.1__py3-none-any.whl

lollmsbot/channels/telegram.py

@@ -0,0 +1,272 @@
+"""
+Telegram channel implementation for LollmsBot.
+
+Uses shared Agent for all business logic.
+"""
+
+import logging
+from typing import Any, Awaitable, Callable, List, Optional, Set
+
+try:
+    from telegram import Update
+    from telegram.ext import (
+        Application,
+        ApplicationBuilder,
+        CommandHandler,
+        ContextTypes,
+        MessageHandler,
+        filters,
+    )
+    TELEGRAM_AVAILABLE = True
+except ImportError as e:
+    TELEGRAM_AVAILABLE = False
+    TELEGRAM_IMPORT_ERROR = str(e)
+    # Create dummy classes for type checking
+    class Update: pass
+    class Application: pass
+    class ApplicationBuilder: pass
+    class CommandHandler: pass
+    class ContextTypes:
+        DEFAULT_TYPE = Any
+    class MessageHandler: pass
+    class filters:
+        TEXT = None
+        COMMAND = None
+
+from lollmsbot.agent import Agent, PermissionLevel
+
+
+logger = logging.getLogger(__name__)
+
+
+class TelegramChannel:
+    """Telegram messaging channel using shared Agent.
+    
+    All business logic is delegated to the Agent. This class handles
+    only Telegram-specific protocol concerns.
+    """
+
+    def __init__(
+        self,
+        agent: Agent,
+        bot_token: str,
+        allowed_users: Optional[List[int]] = None,
+        blocked_users: Optional[List[int]] = None,
+    ):
+        if not TELEGRAM_AVAILABLE:
+            raise ImportError(
+                f"Telegram support requires 'python-telegram-bot'. "
+                f"Install with: pip install 'python-telegram-bot>=20.0' "
+                f"Original error: {TELEGRAM_IMPORT_ERROR}"
+            )
+        
+        self.agent = agent
+        self.bot_token = bot_token
+        self.allowed_users: Optional[Set[int]] = set(allowed_users) if allowed_users else None
+        self.blocked_users: Set[int] = set(blocked_users) if blocked_users else set()
+        self.application: Optional[Application] = None
+        self._is_running = False
+
+    def _can_interact(self, user_id: int) -> tuple[bool, str]:
+        """Check if user can interact with bot."""
+        if user_id in self.blocked_users:
+            return False, "user blocked"
+        
+        if self.allowed_users is not None:
+            if user_id not in self.allowed_users:
+                return False, "not in allowed users"
+        
+        return True, ""
+
+    def _get_user_id(self, tg_user_id: int) -> str:
+        """Generate consistent user ID for Agent."""
+        return f"telegram:{tg_user_id}"
+
+    async def start(self) -> None:
+        """Start the Telegram bot."""
+        if not TELEGRAM_AVAILABLE:
+            raise ImportError("python-telegram-bot is not installed")
+        
+        if self._is_running:
+            logger.warning("Telegram channel is already running")
+            return
+        
+        try:
+            self.application = (
+                ApplicationBuilder()
+                .token(self.bot_token)
+                .build()
+            )
+            
+            # Add handlers
+            self.application.add_handler(
+                CommandHandler("start", self._handle_start_command)
+            )
+            self.application.add_handler(
+                CommandHandler("help", self._handle_help_command)
+            )
+            self.application.add_handler(
+                MessageHandler(filters.TEXT & ~filters.COMMAND, self._handle_message)
+            )
+            self.application.add_error_handler(self._handle_error)
+            
+            # Start
+            await self.application.initialize()
+            await self.application.start()
+            await self.application.updater.start_polling(drop_pending_updates=True)
+            
+            self._is_running = True
+            logger.info("Telegram channel started successfully")
+            
+        except Exception as exc:
+            logger.error(f"Failed to start Telegram channel: {exc}")
+            self._is_running = False
+            raise
+
+    async def stop(self) -> None:
+        """Stop the Telegram bot."""
+        if not self._is_running:
+            return
+        
+        try:
+            if self.application:
+                await self.application.updater.stop()
+                await self.application.stop()
+                await self.application.shutdown()
+                self.application = None
+            
+            self._is_running = False
+            logger.info("Telegram channel stopped successfully")
+            
+        except Exception as exc:
+            logger.error(f"Error stopping Telegram channel: {exc}")
+            raise
+
+    async def _handle_start_command(
+        self,
+        update: Update,
+        context: ContextTypes.DEFAULT_TYPE,
+    ) -> None:
+        """Handle /start command."""
+        if not update.effective_chat or not update.message:
+            return
+        
+        user_id = update.effective_user.id if update.effective_user else 0
+        
+        # Check permissions
+        can_interact, reason = self._can_interact(user_id)
+        if not can_interact:
+            await update.message.reply_text("⛔ You don't have permission to use this bot.")
+            return
+        
+        # Get or create user permissions in agent
+        agent_user_id = self._get_user_id(user_id)
+        
+        welcome_text = (
+            f"👋 Hello! I'm {self.agent.name}.\n\n"
+            f"Send me any message and I'll respond using my AI backend.\n\n"
+            f"Your ID: `{user_id}`\n"
+            f"Use /help for more information."
+        )
+        
+        await update.message.reply_text(welcome_text, parse_mode="Markdown")
+
+    async def _handle_help_command(
+        self,
+        update: Update,
+        context: ContextTypes.DEFAULT_TYPE,
+    ) -> None:
+        """Handle /help command."""
+        help_text = (
+            f"*{self.agent.name} - Available Commands*\n\n"
+            "/start - Start the bot\n"
+            "/help - Show this help message\n\n"
+            "Just send any message to chat with me!"
+        )
+        await update.message.reply_text(help_text, parse_mode="Markdown")
+
+    async def _handle_message(
+        self,
+        update: Update,
+        context: ContextTypes.DEFAULT_TYPE,
+    ) -> None:
+        """Handle incoming text messages."""
+        if not update.effective_chat or not update.message or not update.message.text:
+            return
+        
+        user_id = update.effective_user.id if update.effective_user else 0
+        chat_id = update.effective_chat.id
+        
+        # Check permissions
+        can_interact, reason = self._can_interact(user_id)
+        if not can_interact:
+            logger.warning(f"Message from unauthorized user {user_id}: {reason}")
+            await update.message.reply_text("⛔ Access denied.")
+            return
+        
+        # Build context
+        agent_user_id = self._get_user_id(user_id)
+        context_data = {
+            "channel": "telegram",
+            "telegram_user_id": user_id,
+            "telegram_username": update.effective_user.username if update.effective_user else None,
+            "telegram_chat_id": chat_id,
+            "is_dm": update.effective_chat.type == "private",
+            "chat_type": update.effective_chat.type,
+        }
+        
+        message_text = update.message.text
+        
+        logger.info(f"Processing message from Telegram user {user_id}: {message_text[:50]}...")
+        
+        try:
+            # Use Agent for processing
+            result = await self.agent.chat(
+                user_id=agent_user_id,
+                message=message_text,
+                context=context_data,
+            )
+            
+            if result.get("permission_denied"):
+                await update.message.reply_text("⛔ You don't have permission to use this bot.")
+                return
+            
+            if not result.get("success"):
+                error_msg = result.get("error", "Unknown error")
+                await update.message.reply_text(f"❌ Error: {error_msg[:400]}")
+                return
+            
+            response = result.get("response", "No response")
+            # Telegram has 4096 char limit
+            if len(response) > 4000:
+                response = response[:4000] + "\n... (truncated)"
+            
+            await update.message.reply_text(response)
+            
+        except Exception as exc:
+            logger.error(f"Error processing Telegram message: {exc}")
+            try:
+                await update.message.reply_text("❌ An error occurred. Please try again.")
+            except Exception:
+                pass
+
+    async def _handle_error(
+        self,
+        update: Optional[Update],
+        context: ContextTypes.DEFAULT_TYPE,
+    ) -> None:
+        """Handle errors."""
+        logger.error(f"Telegram bot error: {context.error}")
+        
+        if update and update.effective_message:
+            try:
+                await update.effective_message.reply_text(
+                    "❌ An unexpected error occurred."
+                )
+            except Exception:
+                pass
+
+    def __repr__(self) -> str:
+        status = "running" if self._is_running else "stopped"
+        restricted = f", restricted={len(self.allowed_users)} users" if self.allowed_users else ""
+        return f"TelegramChannel({status}{restricted})"

lollmsbot/cli.py

@@ -0,0 +1,217 @@
+#!/usr/bin/env python
+"""
+lollmsBot CLI - Gateway + Wizard + UI
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+from typing import List
+
+try:
+    from rich.console import Console
+    from rich.panel import Panel
+    from rich.table import Table
+    from rich.text import Text
+    from rich import box
+    console = Console()
+except ImportError:
+    print("Install dev deps: pip install -e .[dev]")
+    sys.exit(1)
+
+
+def print_ui_banner() -> None:
+    """Print beautiful UI launch banner."""
+    console.print()
+    
+    # Create ASCII art style banner
+    banner = Text()
+    banner.append("╭─────────╮\n", style="blue")
+    banner.append("│  🤖     │  ", style="blue")
+    banner.append("LollmsBot", style="bold cyan")
+    banner.append(" Web UI\n", style="bold blue")
+    banner.append("╰─────────╯\n", style="blue")
+    
+    panel = Panel(
+        banner,
+        box=box.DOUBLE_EDGE,
+        border_style="bright_cyan",
+        title="[bold]Starting Interface[/bold]",
+        subtitle="[dim]Real-time AI Chat[/dim]"
+    )
+    console.print(panel)
+
+
+def print_gateway_banner(host: str, port: int, ui_enabled: bool) -> None:
+    """Print gateway startup banner with status."""
+    
+    # For display purposes, use localhost if host is 0.0.0.0 or empty
+    # Browsers can't connect to 0.0.0.0, they need localhost/127.0.0.1
+    display_host = "localhost" if host in ("0.0.0.0", "") else host
+    
+    # Status indicators
+    status_table = Table(
+        show_header=False,
+        box=box.SIMPLE,
+        border_style="blue",
+        padding=(0, 2)
+    )
+    status_table.add_column("Service", style="cyan")
+    status_table.add_column("Status", style="green")
+    status_table.add_column("URL", style="dim")
+    
+    status_table.add_row(
+        "🔌 Gateway API",
+        "✅ Active",
+        f"http://{display_host}:{port}"
+    )
+    status_table.add_row(
+        "📚 API Docs",
+        "✅ Available",
+        f"http://{display_host}:{port}/docs"
+    )
+    
+    if ui_enabled:
+        status_table.add_row(
+            "🌐 Web UI",
+            "✅ Mounted",
+            f"http://{display_host}:{port}/ui"
+        )
+    else:
+        status_table.add_row(
+            "🌐 Web UI",
+            "⭕ Disabled",
+            "Use --ui to enable"
+        )
+    
+    panel = Panel(
+        status_table,
+        box=box.ROUNDED,
+        border_style="bright_green" if ui_enabled else "yellow",
+        title="[bold bright_green]🚀 Gateway Starting[/bold bright_green]",
+        subtitle=f"[dim]LoLLMS Agentic Bot | Host: {host}[/dim]"
+    )
+    console.print()
+    console.print(panel)
+    console.print()
+
+
+def main(argv: List[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(
+        prog="lollmsbot",
+        description="Agentic LoLLMS Assistant (Clawdbot-style)",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+┌─────────────────────────────────────────────────────────────┐
+│  Examples:                                                  │
+│    lollmsbot wizard          # Interactive setup            │
+│    lollmsbot gateway         # Run API server               │
+│    lollmsbot gateway --ui    # API + Web UI together        │
+│    lollmsbot ui              # Web UI only (standalone)     │
+│    lollmsbot ui --port 3000  # UI on custom port            │
+└─────────────────────────────────────────────────────────────┘
+        """
+    )
+    parser.add_argument("--version", action="version", version="lollmsBot 0.1.0")
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # Gateway command
+    gateway_parser = subparsers.add_parser(
+        "gateway", 
+        help="Run API gateway server",
+        description="Start the main API gateway with optional channels and UI"
+    )
+    gateway_parser.add_argument("--host", type=str, default="0.0.0.0", help="Bind address (default: 0.0.0.0)")
+    gateway_parser.add_argument("--port", type=int, default=8800, help="Port number (default: 8800)")
+    gateway_parser.add_argument("--ui", action="store_true", help="Also start web UI at /ui")
+
+    # UI command (standalone)
+    ui_parser = subparsers.add_parser(
+        "ui", 
+        help="Run web UI only (standalone mode)",
+        description="Start just the web interface without the full gateway"
+    )
+    ui_parser.add_argument("--host", type=str, default="127.0.0.1", help="Bind address (default: 127.0.0.1)")
+    ui_parser.add_argument("--port", type=int, default=8080, help="Port number (default: 8080)")
+    ui_parser.add_argument("--quiet", "-q", action="store_true", help="Minimal console output")
+
+    # Wizard command
+    wizard_parser = subparsers.add_parser(
+        "wizard", 
+        help="Interactive setup wizard",
+        description="Configure LoLLMS connection and bot settings interactively"
+    )
+
+    args = parser.parse_args(argv)
+
+    try:
+        if args.command == "gateway":
+            import uvicorn
+            from lollmsbot.config import GatewaySettings
+            from lollmsbot import gateway
+            
+            settings = GatewaySettings.from_env()
+            host = args.host or settings.host
+            port = args.port or settings.port
+            
+            # Print startup banner
+            print_gateway_banner(host, port, args.ui)
+            
+            # Enable UI if requested
+            if args.ui:
+                # Use localhost for UI server internally, gateway will mount it
+                gateway.enable_ui(host="127.0.0.1", port=8080)
+            
+            # Run server
+            uvicorn.run(
+                "lollmsbot.gateway:app",
+                host=host,
+                port=port,
+                reload=args.host == "127.0.0.1" and not args.ui,
+                log_level="info",
+            )
+            
+        elif args.command == "ui":
+            # Run standalone UI with full rich output
+            from lollmsbot.ui.app import WebUI
+            import uvicorn
+            
+            print_ui_banner()
+            
+            ui = WebUI(verbose=not args.quiet)
+            ui.print_server_ready(args.host, args.port)
+            
+            try:
+                uvicorn.run(
+                    ui.app,
+                    host=args.host,
+                    port=args.port,
+                    log_level="warning" if args.quiet else "info",
+                )
+            except KeyboardInterrupt:
+                ui._print_shutdown_message()
+            
+        elif args.command == "wizard":
+            from lollmsbot import wizard
+            wizard.run_wizard()
+            
+        else:
+            parser.print_help()
+            console.print("\n[bold cyan]💡 Need help? Try: lollmsbot wizard[/]")
+            
+    except KeyboardInterrupt:
+        console.print("\n[yellow]👋 Goodbye![/]")
+        sys.exit(130)
+    except ImportError as e:
+        console.print(f"[red]❌ Missing dependency: {e}[/]")
+        console.print("[cyan]💡 Run: pip install -e .[dev][/]")
+        sys.exit(1)
+    except Exception as e:
+        console.print(f"[red]💥 Error: {e}[/]")
+        console.print_exception(show_locals=True)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

lollmsbot/config.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python
+from __future__ import annotations
+import os
+from pathlib import Path
+from typing import Dict, Any, Optional
+from dataclasses import dataclass, field
+from dotenv import load_dotenv
+import json
+
+load_dotenv()
+
+console = None  # Forward ref
+
+def _get_bool(name: str, default: bool = False) -> bool:
+    val = os.getenv(name)
+    if val is None:
+        return default
+    return val.lower() in ("1", "true", "yes", "on")
+
+@dataclass
+class BotConfig:
+    """Bot behavior configuration settings."""
+    name: str = field(default="LollmsBot")
+    max_history: int = field(default=10)
+    
+    @classmethod
+    def from_env(cls) -> "BotConfig":
+        """Load from environment variables."""
+        return cls(
+            name=os.getenv("LOLLMSBOT_NAME", "LollmsBot"),
+            max_history=int(os.getenv("LOLLMSBOT_MAX_HISTORY", "10")),
+        )
+
+@dataclass
+class LollmsSettings:
+    """LoLLMS connection settings."""
+    host_address: str = field(default="http://localhost:9600")
+    api_key: Optional[str] = field(default=None)
+    verify_ssl: bool = field(default=True)
+    binding_name: Optional[str] = field(default=None)
+    model_name: Optional[str] = field(default=None)
+    context_size: Optional[int] = field(default=None)
+
+    @classmethod
+    def from_env(cls) -> "LollmsSettings":
+        """Load from environment variables."""
+        global console
+        return cls(
+            host_address=os.getenv("LOLLMS_HOST_ADDRESS", "http://localhost:9600"),
+            api_key=os.getenv("LOLLMS_API_KEY"),
+            verify_ssl=_get_bool("LOLLMS_VERIFY_SSL", True),
+            binding_name=os.getenv("LOLLMS_BINDING_NAME"),
+            model_name=os.getenv("LOLLMS_MODEL_NAME"),
+            context_size=int(os.getenv("LOLLMS_CONTEXT_SIZE", "32000")) or None,
+        )
+
+    @classmethod
+    def from_wizard(cls) -> "LollmsSettings":
+        """Load from wizard config."""
+        wizard_path = Path.home() / ".lollmsbot" / "config.json"
+        if not wizard_path.exists():
+            return cls.from_env()
+        
+        try:
+            wizard_data = json.loads(wizard_path.read_text())
+            lollms_data = wizard_data.get("lollms", {})
+            if lollms_data.get("host_address"):
+                console.print("[green]📡 Using wizard config![/]" if console else "Using wizard config")
+                return cls(
+                    host_address=lollms_data.get("host_address", "http://localhost:9600"),
+                    api_key=lollms_data.get("api_key"),
+                    verify_ssl=_get_bool(str(lollms_data.get("verify_ssl", True))),
+                    binding_name=lollms_data.get("binding_name"),
+                )
+        except:
+            pass
+        return cls.from_env()
+
+@dataclass
+class GatewaySettings:
+    """Gateway server settings."""
+    host: str = field(default="localhost")
+    port: int = field(default=8800)
+
+    @classmethod
+    def from_env(cls) -> "GatewaySettings":
+        return cls(
+            host=os.getenv("LOLLMSBOT_HOST", "localhost"),
+            port=int(os.getenv("LOLLMSBOT_PORT", "8800")),
+        )