kryten-robot 0.6.9__py3-none-any.whl

kryten/application_state.py

@@ -0,0 +1,98 @@
+"""Application State - Shared runtime state for system management.
+
+This module provides the ApplicationState class that holds references to all
+major components and runtime state needed for system management commands.
+"""
+
+import asyncio
+import time
+from typing import TYPE_CHECKING
+
+# Use TYPE_CHECKING to avoid circular imports
+if TYPE_CHECKING:
+    from .command_subscriber import CommandSubscriber
+    from .config import KrytenConfig
+    from .cytube_connector import CytubeConnector
+    from .event_publisher import EventPublisher
+    from .nats_client import NatsClient
+    from .service_registry import ServiceRegistry
+    from .state_manager import StateManager
+
+
+class ApplicationState:
+    """Shared application state for runtime operations and system management.
+
+    Holds references to all major components and runtime state needed for
+    stats collection, configuration reload, and graceful shutdown.
+
+    Attributes:
+        config_path: Path to the configuration file.
+        config: Loaded configuration object.
+        shutdown_event: Event to signal graceful shutdown.
+        start_time: Unix timestamp when application started.
+        event_publisher: EventPublisher instance (set after initialization).
+        command_subscriber: CommandSubscriber instance (set after initialization).
+        connector: CytubeConnector instance (set after initialization).
+        nats_client: NatsClient instance (set after initialization).
+        state_manager: StateManager instance (set after initialization).
+        service_registry: ServiceRegistry instance (set after initialization).
+
+    Examples:
+        >>> from .config import load_config
+        >>> config = load_config("config.json")
+        >>> app_state = ApplicationState("config.json", config)
+        >>>
+        >>> # Later, after component initialization
+        >>> app_state.connector = connector
+        >>> app_state.nats_client = nats_client
+        >>>
+        >>> # Check uptime
+        >>> uptime = time.time() - app_state.start_time
+    """
+
+    def __init__(self, config_path: str, config: 'KrytenConfig'):
+        """Initialize application state.
+
+        Args:
+            config_path: Path to configuration file.
+            config: Loaded configuration object.
+        """
+        self.config_path = config_path
+        self.config = config
+        self.shutdown_event = asyncio.Event()
+        self.start_time = time.time()
+
+        # Component references (set by main after initialization)
+        self.event_publisher: EventPublisher | None = None
+        self.command_subscriber: CommandSubscriber | None = None
+        self.connector: CytubeConnector | None = None
+        self.nats_client: NatsClient | None = None
+        self.state_manager: StateManager | None = None
+        self.service_registry: ServiceRegistry | None = None
+
+    def get_uptime(self) -> float:
+        """Get application uptime in seconds.
+
+        Returns:
+            Seconds since application started.
+
+        Examples:
+            >>> uptime = app_state.get_uptime()
+            >>> print(f"Uptime: {uptime / 3600:.1f} hours")
+        """
+        return time.time() - self.start_time
+
+    def request_shutdown(self, reason: str = "Unknown") -> None:
+        """Request graceful shutdown of the application.
+
+        Args:
+            reason: Reason for shutdown (for logging).
+
+        Examples:
+            >>> app_state.request_shutdown("User requested")
+        """
+        if not self.shutdown_event.is_set():
+            self.shutdown_event.set()
+
+
+__all__ = ["ApplicationState"]

kryten/audit_logger.py

@@ -0,0 +1,237 @@
+"""Audit logging for admin, playlist, chat, and command operations.
+
+This module provides specialized loggers for tracking CyTube operations:
+- Admin operations (rank changes, bans, filters, emotes, etc.)
+- Playlist operations (queue, delete, move, shuffle, etc.)
+- Chat messages (timestamped chat log)
+- Command audit (all received commands with username and arguments)
+
+All logs are written in UTF-8 encoding.
+"""
+
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+
+class AuditLogger:
+    """Manages specialized audit loggers for different operation types.
+
+    Creates and manages file handlers for:
+    - Admin operations
+    - Playlist operations
+    - Chat messages
+    - Command audit
+
+    All log files are UTF-8 encoded and use append mode.
+    """
+
+    def __init__(self, base_path: str, filenames: dict[str, str]):
+        """Initialize audit logger.
+
+        Args:
+            base_path: Base directory for all log files.
+            filenames: Dictionary mapping log types to filenames:
+                - admin_operations
+                - playlist_operations
+                - chat_messages
+                - command_audit
+        """
+        self.base_path = Path(base_path)
+        self.filenames = filenames
+
+        # Create log directory if it doesn't exist
+        self.base_path.mkdir(parents=True, exist_ok=True)
+
+        # Create specialized loggers
+        self.admin_logger = self._create_logger("admin", filenames["admin_operations"])
+        self.playlist_logger = self._create_logger("playlist", filenames["playlist_operations"])
+        self.chat_logger = self._create_logger("chat", filenames["chat_messages"])
+        self.command_logger = self._create_logger("command", filenames["command_audit"])
+
+    def _create_logger(self, name: str, filename: str) -> logging.Logger:
+        """Create a specialized logger with file handler.
+
+        Args:
+            name: Logger name (used as suffix).
+            filename: Log filename.
+
+        Returns:
+            Configured logger instance.
+        """
+        logger_name = f"bot.kryten.audit.{name}"
+        logger = logging.getLogger(logger_name)
+        logger.setLevel(logging.INFO)
+        logger.propagate = False  # Don't propagate to root logger
+
+        # Remove existing handlers to avoid duplicates
+        logger.handlers.clear()
+
+        # Create file handler with UTF-8 encoding
+        log_path = self.base_path / filename
+        handler = logging.FileHandler(log_path, mode='a', encoding='utf-8')
+        handler.setLevel(logging.INFO)
+
+        # Simple format: timestamp + message
+        formatter = logging.Formatter('%(asctime)s %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
+        handler.setFormatter(formatter)
+
+        logger.addHandler(handler)
+
+        return logger
+
+    def log_admin_operation(
+        self,
+        operation: str,
+        username: str | None = None,
+        target: str | None = None,
+        details: dict[str, Any] | None = None
+    ) -> None:
+        """Log an admin operation.
+
+        Args:
+            operation: Operation type (e.g., "setMotd", "ban", "setChannelRank").
+            username: User who performed the operation (bot username).
+            target: Target of the operation (username, filter name, etc.).
+            details: Additional operation details.
+
+        Example:
+            >>> audit.log_admin_operation("ban", "BotAdmin", "SpamUser", {"duration": 3600})
+        """
+        parts = [f"[{operation}]"]
+        if username:
+            parts.append(f"by={username}")
+        if target:
+            parts.append(f"target={target}")
+        if details:
+            detail_str = " ".join(f"{k}={v}" for k, v in details.items())
+            parts.append(detail_str)
+
+        message = " ".join(parts)
+        self.admin_logger.info(message)
+
+    def log_playlist_operation(
+        self,
+        operation: str,
+        username: str | None = None,
+        media_title: str | None = None,
+        details: dict[str, Any] | None = None
+    ) -> None:
+        """Log a playlist operation.
+
+        Args:
+            operation: Operation type (e.g., "queue", "delete", "moveMedia").
+            username: User who performed the operation.
+            media_title: Title of media item.
+            details: Additional operation details (position, duration, etc.).
+
+        Example:
+            >>> audit.log_playlist_operation("queue", "Alice", "Cool Video", {"duration": 300})
+        """
+        parts = [f"[{operation}]"]
+        if username:
+            parts.append(f"user={username}")
+        if media_title:
+            # Truncate long titles
+            title = media_title[:100]
+            parts.append(f"title=\"{title}\"")
+        if details:
+            detail_str = " ".join(f"{k}={v}" for k, v in details.items())
+            parts.append(detail_str)
+
+        message = " ".join(parts)
+        self.playlist_logger.info(message)
+
+    def log_chat_message(self, username: str, message: str, timestamp: datetime | None = None) -> None:
+        """Log a chat message in IRC-style format.
+
+        Args:
+            username: Username of the message sender.
+            message: Chat message text.
+            timestamp: Optional timestamp (defaults to now).
+
+        Format: HH:MM:SS <username>: message
+
+        Example:
+            >>> audit.log_chat_message("Alice", "Hello everyone!")
+            # Output: 14:35:22 <Alice>: Hello everyone!
+        """
+        if timestamp is None:
+            timestamp = datetime.now()
+
+        time_str = timestamp.strftime("%H:%M:%S")
+        formatted = f"{time_str} <{username}>: {message}"
+
+        # Use a plain handler without timestamp prefix (we're adding it manually)
+        # Remove all handlers temporarily
+        handlers = self.chat_logger.handlers[:]
+        self.chat_logger.handlers.clear()
+
+        # Add handler without timestamp
+        log_path = self.base_path / self.filenames["chat_messages"]
+        handler = logging.FileHandler(log_path, mode='a', encoding='utf-8')
+        formatter = logging.Formatter('%(message)s')
+        handler.setFormatter(formatter)
+        self.chat_logger.addHandler(handler)
+
+        self.chat_logger.info(formatted)
+
+        # Restore original handlers
+        self.chat_logger.handlers.clear()
+        self.chat_logger.handlers.extend(handlers)
+
+    def log_command(
+        self,
+        command: str,
+        username: str | None = None,
+        arguments: dict[str, Any] | None = None,
+        source: str = "NATS"
+    ) -> None:
+        """Log a received command.
+
+        Args:
+            command: Command name (e.g., "sendChat", "setMotd").
+            username: Username associated with the command.
+            arguments: Command arguments.
+            source: Source of the command (e.g., "NATS", "internal").
+
+        Example:
+            >>> audit.log_command("sendChat", "bot", {"message": "Hello"}, "NATS")
+        """
+        parts = [f"[{source}]", f"command={command}"]
+        if username:
+            parts.append(f"user={username}")
+        if arguments:
+            # Sanitize sensitive data
+            safe_args = {k: "***" if "password" in k.lower() else v for k, v in arguments.items()}
+            args_str = " ".join(f"{k}={v}" for k, v in safe_args.items())
+            parts.append(f"args=({args_str})")
+
+        message = " ".join(parts)
+        self.command_logger.info(message)
+
+
+def create_audit_logger(base_path: str, filenames: dict[str, str]) -> AuditLogger:
+    """Factory function to create audit logger.
+
+    Args:
+        base_path: Base directory for log files.
+        filenames: Dictionary mapping log types to filenames.
+
+    Returns:
+        Configured AuditLogger instance.
+
+    Example:
+        >>> filenames = {
+        ...     "admin_operations": "admin-ops.log",
+        ...     "playlist_operations": "playlist-ops.log",
+        ...     "chat_messages": "chat.log",
+        ...     "command_audit": "commands.log"
+        ... }
+        >>> audit = create_audit_logger("/var/log/kryten", filenames)
+    """
+    return AuditLogger(base_path, filenames)
+
+
+__all__ = ["AuditLogger", "create_audit_logger"]

kryten/command_subscriber.py

@@ -0,0 +1,341 @@
+"""NATS Command Subscriber - Listen for commands and execute on CyTube.
+
+This module subscribes to NATS command subjects and routes them to the
+CytubeEventSender to execute on CyTube channels.
+"""
+
+import json
+import logging
+from typing import Any
+
+from .cytube_event_sender import CytubeEventSender
+from .nats_client import NatsClient
+from .stats_tracker import StatsTracker
+
+
+class CommandSubscriber:
+    """Subscribe to NATS commands and execute them on CyTube.
+
+    Routes commands from NATS to CytubeEventSender methods, handling
+    JSON parsing, validation, and error logging.
+
+    Attributes:
+        sender: CyTube event sender instance.
+        nats_client: NATS client for subscriptions.
+        logger: Logger instance.
+        channel: CyTube channel name for subject filtering.
+
+    Examples:
+        >>> subscriber = CommandSubscriber(sender, nats_client, logger, "cytu.be", "mychannel")
+        >>> await subscriber.start()
+        >>> # Commands sent to cytube.commands.cytu.be.mychannel.* will be executed
+        >>> await subscriber.stop()
+    """
+
+    def __init__(
+        self,
+        sender: CytubeEventSender,
+        nats_client: NatsClient,
+        logger: logging.Logger,
+        domain: str,
+        channel: str,
+        audit_logger=None,
+    ):
+        """Initialize command subscriber.
+
+        Args:
+            sender: CyTube event sender instance.
+            nats_client: NATS client for subscriptions.
+            logger: Logger for structured output.
+            domain: CyTube domain name.
+            channel: CyTube channel name.
+            audit_logger: Optional AuditLogger for command tracking.
+        """
+        self._sender = sender
+        self._nats = nats_client
+        self._logger = logger
+        self._domain = domain
+        self._channel = channel
+        self._audit_logger = audit_logger
+        self._running = False
+        self._subscription = None
+
+        # Metrics tracking
+        self._commands_processed = 0
+        self._commands_succeeded = 0
+        self._commands_failed = 0
+
+        # Rate tracking
+        self._stats_tracker = StatsTracker()
+
+    @property
+    def stats(self) -> dict[str, Any]:
+        """Get command processing statistics.
+
+        Returns:
+            Dictionary with commands_processed, commands_succeeded,
+            commands_failed counts, and rate information.
+
+        Examples:
+            >>> stats = subscriber.stats
+            >>> print(f"Processed: {stats['commands_processed']}")
+            >>> print(f"Success rate: {stats['commands_succeeded'] / stats['commands_processed']}")
+            >>> print(f"Rate (1m): {stats['rate_1min']:.2f}/sec")
+        """
+        last_time, last_type = self._stats_tracker.get_last()
+
+        return {
+            "commands_processed": self._commands_processed,
+            "commands_succeeded": self._commands_succeeded,
+            "commands_failed": self._commands_failed,
+            "rate_1min": self._stats_tracker.get_rate(60),
+            "rate_5min": self._stats_tracker.get_rate(300),
+            "last_command_time": last_time,
+            "last_command_type": last_type,
+        }
+
+    @property
+    def is_running(self) -> bool:
+        """Check if subscriber is running.
+
+        Returns:
+            True if subscribed and processing commands, False otherwise.
+        """
+        return self._running
+
+    async def start(self) -> None:
+        """Start subscribing to command subjects.
+
+        Subscribes to kryten.commands.cytube.{channel}.> to receive all commands
+        for this channel.
+        """
+        if self._running:
+            self._logger.warning("Command subscriber already running")
+            return
+
+        self._running = True
+
+        # Import here to use the updated function
+        from .subject_builder import normalize_token
+
+        # Subscribe to all commands for this channel (domain normalized out)
+        channel_normalized = normalize_token(self._channel)
+        subject = f"kryten.commands.cytube.{channel_normalized}.>"
+        self._subscription = await self._nats.subscribe(subject, self._handle_command)
+
+        self._logger.info(f"Command subscriber started on subject: {subject}")
+
+    async def stop(self) -> None:
+        """Stop command subscriptions."""
+        if not self._running:
+            return
+
+        self._running = False
+
+        if self._subscription:
+            await self._nats.unsubscribe(self._subscription)
+            self._subscription = None
+
+        self._logger.info("Command subscriber stopped")
+
+    async def _handle_command(self, subject: str, data: bytes) -> None:
+        """Handle incoming command message.
+
+        Args:
+            subject: NATS subject the command was received on.
+            data: Message payload (JSON).
+        """
+        try:
+            # Parse command JSON
+            command = json.loads(data.decode())
+            action = command.get("action")
+            params = command.get("data", {})
+
+            if not action:
+                self._logger.warning(f"Command missing 'action' field on {subject}")
+                return
+
+            self._logger.info(f"Received command '{action}' on {subject}")
+
+            # Audit log the command
+            if self._audit_logger:
+                # Extract username from params if available
+                username = params.get("username") or params.get("name") or "system"
+                self._audit_logger.log_command(
+                    command=action,
+                    username=username,
+                    arguments=params,
+                    source="NATS"
+                )
+
+            # Route to appropriate sender method
+            success = await self._route_command(action, params)
+
+            # Update metrics
+            self._commands_processed += 1
+            if success:
+                self._commands_succeeded += 1
+                self._stats_tracker.record(action)
+                self._logger.debug(f"Command '{action}' executed successfully")
+            else:
+                self._commands_failed += 1
+                self._logger.warning(f"Command '{action}' execution failed")
+
+        except json.JSONDecodeError as e:
+            self._commands_failed += 1
+            self._logger.error(f"Invalid JSON in command on {subject}: {e}")
+        except Exception as e:
+            self._commands_failed += 1
+            self._logger.error(f"Error handling command on {subject}: {e}", exc_info=True)
+
+    async def _route_command(self, action: str, params: dict[str, Any]) -> bool:
+        """Route command to appropriate sender method.
+
+        Args:
+            action: Action name (e.g., "chat", "queue", "kick").
+            params: Action parameters.
+
+        Returns:
+            True if command executed successfully, False otherwise.
+        """
+        try:
+            # Chat actions
+            if action == "chat":
+                return await self._sender.send_chat(**params)
+            elif action == "pm":
+                return await self._sender.send_pm(**params)
+
+            # Playlist actions
+            elif action == "queue" or action == "add_video":
+                # Handle both old format (url) and new format (type + id)
+                if "type" in params and "id" in params:
+                    # New format from kryten-py: {"type": "yt", "id": "abc123", "pos": "end"}
+                    # Check if this is a grindhouse URL that needs transformation
+                    media_id = params.get("id")
+                    media_type = params.get("type")
+
+                    # If type is "cu" and id looks like a grindhouse view URL, transform it
+                    if media_type == "cu" and isinstance(media_id, str) and "420grindhouse.com/view?m=" in media_id:
+                        # Transform to custom media format with JSON API URL
+                        import re
+                        pattern = r'https?://(?:www\.)?420grindhouse\.com/view\?m=([A-Za-z0-9_-]+)'
+                        match = re.match(pattern, media_id)
+                        if match:
+                            media_id_code = match.group(1)
+                            media_id = f"https://www.420grindhouse.com/api/v1/media/cytube/{media_id_code}.json?format=json"
+                            media_type = "cm"
+                            self._logger.info(f"Transformed grindhouse URL in command subscriber: type={media_type}, id={media_id}")
+
+                    return await self._sender.add_video(
+                        media_type=media_type,
+                        media_id=media_id,
+                        position=params.get("pos", "end"),
+                        temp=params.get("temp", False)
+                    )
+                else:
+                    # Old format: {"url": "yt:abc123", "position": "end", "temp": False}
+                    return await self._sender.add_video(**params)
+            elif action == "delete" or action == "delete_video":
+                # CyTube expects UID as raw number, not wrapped in object
+                # The event sender will handle conversion to int
+                return await self._sender.delete_video(**params)
+            elif action == "move" or action == "move_video":
+                # Map 'from' to 'uid' if needed (event sender expects 'uid' parameter)
+                if "from" in params and "uid" not in params:
+                    params["uid"] = params.pop("from")
+                # Event sender will handle UID type conversions
+                return await self._sender.move_video(**params)
+            elif action == "jump" or action == "jump_to":
+                # Event sender will handle UID type conversion
+                return await self._sender.jump_to(**params)
+            elif action == "clear" or action == "clear_playlist":
+                return await self._sender.clear_playlist()
+            elif action == "shuffle" or action == "shuffle_playlist":
+                return await self._sender.shuffle_playlist()
+            elif action == "set_temp" or action == "setTemp":
+                # Event sender expects uid parameter and handles type conversion
+                return await self._sender.set_temp(**params)
+
+            # Playback actions
+            elif action == "pause":
+                return await self._sender.pause()
+            elif action == "play":
+                return await self._sender.play()
+            elif action == "seek" or action == "seek_to":
+                return await self._sender.seek_to(**params)
+
+            # Moderation actions
+            elif action == "kick" or action == "kick_user":
+                return await self._sender.kick_user(**params)
+            elif action == "ban" or action == "ban_user":
+                return await self._sender.ban_user(**params)
+            elif action == "voteskip":
+                return await self._sender.voteskip()
+            elif action == "assignLeader" or action == "assign_leader":
+                return await self._sender.assign_leader(**params)
+            elif action == "mute" or action == "mute_user":
+                return await self._sender.mute_user(**params)
+            elif action == "smute" or action == "shadow_mute" or action == "shadow_mute_user":
+                return await self._sender.shadow_mute_user(**params)
+            elif action == "unmute" or action == "unmute_user":
+                return await self._sender.unmute_user(**params)
+            elif action == "playNext" or action == "play_next":
+                return await self._sender.play_next()
+
+            # Phase 2: Admin commands (rank 3+)
+            elif action == "setMotd" or action == "set_motd":
+                return await self._sender.set_motd(**params)
+            elif action == "setChannelCSS" or action == "set_channel_css":
+                return await self._sender.set_channel_css(**params)
+            elif action == "setChannelJS" or action == "set_channel_js":
+                return await self._sender.set_channel_js(**params)
+            elif action == "setOptions" or action == "set_options":
+                return await self._sender.set_options(**params)
+            elif action == "setPermissions" or action == "set_permissions":
+                return await self._sender.set_permissions(**params)
+            elif action == "updateEmote" or action == "update_emote":
+                return await self._sender.update_emote(**params)
+            elif action == "removeEmote" or action == "remove_emote":
+                return await self._sender.remove_emote(**params)
+            elif action == "addFilter" or action == "add_filter":
+                return await self._sender.add_filter(**params)
+            elif action == "updateFilter" or action == "update_filter":
+                return await self._sender.update_filter(**params)
+            elif action == "removeFilter" or action == "remove_filter":
+                return await self._sender.remove_filter(**params)
+
+            # Phase 3: Advanced admin commands (rank 2-4+)
+            elif action == "newPoll" or action == "new_poll":
+                return await self._sender.new_poll(**params)
+            elif action == "vote":
+                return await self._sender.vote(**params)
+            elif action == "closePoll" or action == "close_poll":
+                return await self._sender.close_poll()
+            elif action == "setChannelRank" or action == "set_channel_rank":
+                return await self._sender.set_channel_rank(**params)
+            elif action == "requestChannelRanks" or action == "request_channel_ranks":
+                return await self._sender.request_channel_ranks()
+            elif action == "requestBanlist" or action == "request_banlist":
+                return await self._sender.request_banlist()
+            elif action == "unban":
+                return await self._sender.unban(**params)
+            elif action == "readChanLog" or action == "read_chan_log":
+                return await self._sender.read_chan_log(**params)
+            elif action == "searchLibrary" or action == "search_library":
+                return await self._sender.search_library(**params)
+            elif action == "deleteFromLibrary" or action == "delete_from_library":
+                return await self._sender.delete_from_library(**params)
+
+            else:
+                self._logger.warning(f"Unknown action: {action}")
+                return False
+
+        except TypeError as e:
+            self._logger.error(f"Invalid parameters for action '{action}': {e}")
+            return False
+        except Exception as e:
+            self._logger.error(f"Error executing action '{action}': {e}", exc_info=True)
+            return False
+
+
+__all__ = ["CommandSubscriber"]