kryten-cli 2.1.1__py3-none-any.whl

kryten_cli-2.1.1.dist-info/METADATA

@@ -0,0 +1,313 @@
+Metadata-Version: 2.4
+Name: kryten-cli
+Version: 2.1.1
+Summary: Command-line client for CyTube via kryten-py library
+Home-page: https://github.com/grobertson/kryten-cli
+Author: Kryten Robot Team
+Author-email: Kryten Robot Team <kryten@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/grobertson/kryten-cli
+Project-URL: Bug Tracker, https://github.com/grobertson/kryten-cli/issues
+Project-URL: Source Code, https://github.com/grobertson/kryten-cli
+Project-URL: Documentation, https://github.com/grobertson/kryten-cli/blob/main/README.md
+Keywords: cytube,nats,cli,command-line,microservices,bot
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Communications :: Chat
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: kryten-py>=0.5.7
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# Kryten CLI
+
+Command-line client for sending CyTube commands via the kryten-py library.
+
+## Overview
+
+This CLI provides a simple command-line interface to control CyTube channels through the Kryten bridge. It uses the high-level `kryten-py` library for all communication, making it a clean and maintainable reference implementation.
+
+## Installation
+
+Install the CLI tool:
+
+```bash
+pip install -e .
+```
+
+This will automatically install the `kryten-py` dependency.
+
+Or run directly:
+
+```bash
+python kryten_cli.py --help
+```
+
+## Configuration
+
+The CLI reads connection settings from `config.json` in the current directory. Create one with your NATS server and CyTube channel:
+
+```json
+{
+  "nats": {
+    "servers": ["nats://localhost:4222"]
+  },
+  "channels": [
+    {
+      "domain": "cytu.be",
+      "channel": "your-channel-name"
+    }
+  ]
+}
+```
+
+**Legacy Format Support:** The CLI also supports the older config format with `cytube.channel` for backward compatibility.
+
+You can also specify a different config file:
+
+```bash
+kryten --config /path/to/config.json say "Hello"
+```
+
+## Usage Examples
+
+### Chat Commands
+
+Send a chat message:
+```bash
+kryten say "Hello world"
+```
+
+Send a private message:
+```bash
+kryten pm UserName "Hi there!"
+```
+
+### Playlist Commands
+
+Add video to end of playlist:
+```bash
+kryten playlist add https://youtube.com/watch?v=xyz
+kryten playlist add yt:abc123
+```
+
+Add video to play next:
+```bash
+kryten playlist addnext https://youtube.com/watch?v=abc
+```
+
+Add as temporary (auto-deleted after playing):
+```bash
+kryten playlist add --temp https://youtube.com/watch?v=xyz
+```
+
+Delete video from playlist:
+```bash
+kryten playlist del video-uid-123
+```
+
+Move video in playlist:
+```bash
+kryten playlist move video-uid-5 after video-uid-3
+```
+
+Jump to specific video:
+```bash
+kryten playlist jump video-uid-7
+```
+
+Clear entire playlist:
+```bash
+kryten playlist clear
+```
+
+Shuffle playlist:
+```bash
+kryten playlist shuffle
+```
+
+Set video temporary status:
+```bash
+kryten playlist settemp video-uid-5 true
+kryten playlist settemp video-uid-5 false
+```
+
+### Playback Commands
+
+Pause current video:
+```bash
+kryten pause
+```
+
+Resume playback:
+```bash
+kryten play
+```
+
+Seek to timestamp (in seconds):
+```bash
+kryten seek 120.5
+```
+
+### Moderation Commands
+
+Kick user:
+```bash
+kryten kick UserName
+kryten kick UserName "Stop spamming"
+```
+
+Ban user:
+```bash
+kryten ban UserName
+kryten ban UserName "Banned for harassment"
+```
+
+Vote to skip current video:
+```bash
+kryten voteskip
+```
+
+## Command Reference
+
+| Command | Description |
+|---------|-------------|
+| `say <message>` | Send a chat message |
+| `pm <user> <message>` | Send a private message |
+| `playlist add <url>` | Add video to end of playlist |
+| `playlist addnext <url>` | Add video to play next |
+| `playlist del <uid>` | Delete video from playlist |
+| `playlist move <uid> after <uid>` | Move video in playlist |
+| `playlist jump <uid>` | Jump to specific video |
+| `playlist clear` | Clear entire playlist |
+| `playlist shuffle` | Shuffle playlist |
+| `playlist settemp <uid> <true\|false>` | Set temporary status |
+| `pause` | Pause playback |
+| `play` | Resume playback |
+| `seek <seconds>` | Seek to timestamp |
+| `kick <user> [reason]` | Kick user from channel |
+| `ban <user> [reason]` | Ban user from channel |
+| `voteskip` | Vote to skip current video |
+
+## Options
+
+| Option | Description |
+|--------|-------------|
+| `--config <path>` | Path to config file (default: config.json) |
+| `--channel <name>` | Override channel from config |
+| `--help` | Show help message |
+
+## NATS Message Format
+
+All commands are published to NATS subjects following this pattern:
+
+```
+cytube.commands.{channel}.{action}
+```
+
+Message payload:
+```json
+{
+  "action": "chat",
+  "data": {
+    "message": "Hello world"
+  }
+}
+```
+
+This format is compatible with the Kryten bidirectional bridge's `CommandSubscriber`.
+
+## Requirements
+
+- Python 3.11+
+- nats-py >= 2.9.0
+- Kryten bidirectional bridge running with `commands.enabled = true`
+
+## Examples
+
+### Automated DJ
+
+Add a list of videos:
+```bash
+for url in $(cat playlist.txt); do
+  kryten playlist add "$url"
+  sleep 1
+done
+```
+
+### Bot Integration
+
+Use in scripts to respond to events:
+```bash
+#!/bin/bash
+# Greet new users
+kryten say "Welcome to the channel!"
+```
+
+### Remote Moderation
+
+Quick moderation commands:
+```bash
+kryten kick TrollUser "Please follow the rules"
+kryten ban SpamBot "Automated spam detected"
+```
+
+## Troubleshooting
+
+### Connection refused
+
+Make sure NATS server is running:
+```bash
+# Start NATS server
+nats-server
+```
+
+### Command not found
+
+Make sure the CLI is installed:
+```bash
+pip install -e .
+```
+
+Or use the module directly:
+```bash
+python kryten_cli.py say "Hello"
+```
+
+### Commands not executing
+
+1. Check that Kryten bridge is running
+2. Verify `commands.enabled = true` in Kryten's config
+3. Check NATS connection settings match between CLI and Kryten
+4. Verify channel name is correct
+
+## Version 2.0 - Using kryten-py Library
+
+**Version 2.0** is a complete rewrite that uses the `kryten-py` library instead of direct NATS calls. This provides:
+
+- **Cleaner code**: High-level API instead of low-level NATS
+- **Type safety**: Typed interfaces and better IDE support
+- **Better maintenance**: Shares code with other kryten projects
+- **New features**: Automatic URL parsing for media commands
+
+For migration information from v1.x, see [MIGRATION.md](MIGRATION.md).
+
+For complete details about the refactor, see [REFACTOR_SUMMARY.md](REFACTOR_SUMMARY.md).
+
+## Contributing
+
+This project serves as a reference implementation for using kryten-py. Contributions are welcome!
+
+## License
+
+See LICENSE file for details.

kryten_cli-2.1.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+kryten_cli.py,sha256=n_8YWJ6EkMArTbKUs33-ywRfObmGtroZ7TsvqyDUxOE,27404
+kryten_cli-2.1.1.dist-info/licenses/LICENSE,sha256=cDh70BrUr55sIU4Zb-SrutuYGG5MhsxsTg16W4JYVAc,1074
+kryten_cli-2.1.1.dist-info/METADATA,sha256=BeSgwdCDQ4CA960Jgo6v_wvKxoCqeAZKqv55UuoYS-A,6900
+kryten_cli-2.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+kryten_cli-2.1.1.dist-info/entry_points.txt,sha256=SABWYXWT2Ma113grN0EXoxX0wkQYnKWVW_XgVwzGc1M,42
+kryten_cli-2.1.1.dist-info/top_level.txt,sha256=p6-vYVvHyL5r4ay2pYnkA6KyigDh-1pNglLoLNtKR40,11
+kryten_cli-2.1.1.dist-info/RECORD,,

kryten_cli-2.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

kryten_cli-2.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+kryten = kryten_cli:run

kryten_cli-2.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Kryten Robot Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kryten_cli-2.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+kryten_cli

kryten_cli.py

@@ -0,0 +1,731 @@
+#!/usr/bin/env python3
+"""Kryten CLI - Send CyTube commands via NATS.
+
+This command-line tool sends commands to a CyTube channel through NATS messaging.
+It provides a simple interface to all outbound commands supported by the Kryten
+bidirectional bridge.
+
+Examples:
+    Send a chat message:
+        $ kryten say "Hello world"
+    
+    Send a private message:
+        $ kryten pm UserName "Hi there!"
+    
+    Add video to playlist:
+        $ kryten playlist add https://youtube.com/watch?v=xyz
+        $ kryten playlist addnext https://youtube.com/watch?v=abc
+    
+    Delete from playlist:
+        $ kryten playlist del 5
+    
+    Playlist management:
+        $ kryten playlist move 3 after 7
+        $ kryten playlist jump 5
+        $ kryten playlist clear
+        $ kryten playlist shuffle
+        $ kryten playlist settemp 5 true
+    
+    Playback control:
+        $ kryten pause
+        $ kryten play
+        $ kryten seek 120.5
+    
+    Moderation:
+        $ kryten kick UserName "Stop spamming"
+        $ kryten ban UserName "Banned for harassment"
+        $ kryten voteskip
+
+Configuration:
+    The CLI reads NATS connection settings from config.json in the current
+    directory or from a path specified with --config.
+"""
+
+import argparse
+import asyncio
+import json
+import re
+import sys
+from pathlib import Path
+from typing import Optional
+
+from kryten import KrytenClient
+
+
+class KrytenCLI:
+    """Command-line interface for Kryten CyTube commands."""
+    
+    def __init__(self, config_path: str = "config.json"):
+        """Initialize CLI with configuration.
+        
+        Args:
+            config_path: Path to configuration file.
+        """
+        self.config_path = Path(config_path)
+        self.config_dict = self._load_config()
+        self.client: Optional[KrytenClient] = None
+        
+        # Extract channel and domain from config
+        channels = self.config_dict.get("channels", [])
+        if not channels:
+            # Legacy config format support
+            cytube = self.config_dict.get("cytube", {})
+            self.channel = cytube.get("channel", "")
+            self.domain = cytube.get("domain", "cytu.be")
+        else:
+            self.channel = channels[0]["channel"]
+            self.domain = channels[0].get("domain", "cytu.be")
+    
+    def _load_config(self) -> dict:
+        """Load configuration from JSON file.
+        
+        Returns:
+            Configuration dictionary.
+        
+        Raises:
+            SystemExit: If config file not found or invalid.
+        """
+        if not self.config_path.exists():
+            print(f"Error: Configuration file not found: {self.config_path}", file=sys.stderr)
+            print("Create a config.json file with NATS and CyTube settings.", file=sys.stderr)
+            sys.exit(1)
+        
+        try:
+            with self.config_path.open("r", encoding="utf-8") as f:
+                config = json.load(f)
+                
+            # Ensure channels list exists for kryten-py
+            if "channels" not in config and "cytube" in config:
+                # Convert legacy format
+                cytube = config["cytube"]
+                config["channels"] = [{
+                    "domain": cytube.get("domain", "cytu.be"),
+                    "channel": cytube["channel"]
+                }]
+                
+            return config
+        except json.JSONDecodeError as e:
+            print(f"Error: Invalid JSON in config file: {e}", file=sys.stderr)
+            sys.exit(1)
+    
+    async def connect(self) -> None:
+        """Connect to NATS server using kryten-py client."""
+        try:
+            self.client = KrytenClient(self.config_dict)
+            await self.client.connect()
+        except OSError as e:
+            # Network/hostname errors
+            servers = self.config_dict.get("nats", {}).get("servers", [])
+            print(f"Error: Cannot connect to NATS server {servers}", file=sys.stderr)
+            print(f"  {e}", file=sys.stderr)
+            print("  Check that:", file=sys.stderr)
+            print("    1. NATS server is running", file=sys.stderr)
+            print("    2. Hostname/IP is correct", file=sys.stderr)
+            print("    3. Port is accessible", file=sys.stderr)
+            sys.exit(1)
+        except Exception as e:
+            print(f"Error: Failed to connect: {e}", file=sys.stderr)
+            sys.exit(1)
+    
+    async def disconnect(self) -> None:
+        """Disconnect from NATS server."""
+        if self.client:
+            await self.client.disconnect()
+    
+    def _parse_media_url(self, url: str) -> tuple[str, str]:
+        """Parse media URL to extract type and ID.
+        
+        Args:
+            url: Media URL or ID
+            
+        Returns:
+            Tuple of (media_type, media_id)
+        """
+        # YouTube patterns
+        yt_patterns = [
+            r'(?:youtube\.com/watch\?v=|youtu\.be/)([a-zA-Z0-9_-]{11})',
+            r'^([a-zA-Z0-9_-]{11})$'  # Direct ID
+        ]
+        
+        for pattern in yt_patterns:
+            match = re.search(pattern, url)
+            if match:
+                return ("yt", match.group(1))
+        
+        # Vimeo
+        vimeo_match = re.search(r'vimeo\.com/(\d+)', url)
+        if vimeo_match:
+            return ("vm", vimeo_match.group(1))
+        
+        # Dailymotion
+        dm_match = re.search(r'dailymotion\.com/video/([a-zA-Z0-9]+)', url)
+        if dm_match:
+            return ("dm", dm_match.group(1))
+        
+        # CyTube Custom Media JSON manifest (must end with .json)
+        if url.lower().endswith('.json') or '.json?' in url.lower():
+            return ("cm", url)
+        
+        # Default: custom URL (for direct video files, custom embeds, etc.)
+        return ("cu", url)
+    
+    # ========================================================================
+    # Chat Commands
+    # ========================================================================
+    
+    async def cmd_say(self, message: str) -> None:
+        """Send a chat message.
+        
+        Args:
+            message: Message text.
+        """
+        await self.client.send_chat(self.channel, message, domain=self.domain)
+        print(f"✓ Sent chat message to {self.channel}")
+    
+    async def cmd_pm(self, username: str, message: str) -> None:
+        """Send a private message.
+        
+        Args:
+            username: Target username.
+            message: Message text.
+        """
+        await self.client.send_pm(self.channel, username, message, domain=self.domain)
+        print(f"✓ Sent PM to {username} in {self.channel}")
+    
+    # ========================================================================
+    # Playlist Commands
+    # ========================================================================
+    
+    async def cmd_playlist_add(self, url: str) -> None:
+        """Add video to end of playlist.
+        
+        Args:
+            url: Video URL or ID.
+        """
+        media_type, media_id = self._parse_media_url(url)
+        await self.client.add_media(
+            self.channel, media_type, media_id, position="end", domain=self.domain
+        )
+        print(f"✓ Added {media_type}:{media_id} to end of playlist in {self.channel}")
+    
+    async def cmd_playlist_addnext(self, url: str) -> None:
+        """Add video to play next.
+        
+        Args:
+            url: Video URL or ID.
+        """
+        media_type, media_id = self._parse_media_url(url)
+        await self.client.add_media(
+            self.channel, media_type, media_id, position="next", domain=self.domain
+        )
+        print(f"✓ Added {media_type}:{media_id} to play next in {self.channel}")
+    
+    async def cmd_playlist_del(self, uid: str) -> None:
+        """Delete video from playlist.
+        
+        Args:
+            uid: Video UID or position number (1-based).
+        """
+        uid_int = int(uid)
+        
+        # If uid looks like a position (small number), fetch playlist and map position to UID
+        # CyTube UIDs are typically 4+ digits, positions are 1-based small numbers
+        if uid_int < 1000:  # Assume this is a position, not a UID
+            bucket_name = f"cytube_{self.channel.lower()}_playlist"
+            try:
+                playlist = await self.client.kv_get(bucket_name, "items", default=None, parse_json=True)
+                
+                if playlist is None or not isinstance(playlist, list):
+                    print(f"Cannot resolve position {uid_int}: playlist not available", file=sys.stderr)
+                    sys.exit(1)
+                
+                if uid_int < 1 or uid_int > len(playlist):
+                    print(f"Position {uid_int} out of range (playlist has {len(playlist)} items)", file=sys.stderr)
+                    sys.exit(1)
+                
+                # Get the actual UID from the playlist item
+                item = playlist[uid_int - 1]  # Convert 1-based to 0-based
+                actual_uid = item.get("uid")
+                
+                if actual_uid is None:
+                    print(f"Could not find UID for position {uid_int}", file=sys.stderr)
+                    sys.exit(1)
+                
+                await self.client.delete_media(self.channel, actual_uid, domain=self.domain)
+                title = item.get("media", {}).get("title", "Unknown")
+                print(f"✓ Deleted position {uid_int} (UID {actual_uid}): {title}")
+            
+            except Exception as e:
+                print(f"Error resolving position {uid_int}: {e}", file=sys.stderr)
+                sys.exit(1)
+        else:
+            # Large number, treat as direct UID
+            await self.client.delete_media(self.channel, uid_int, domain=self.domain)
+            print(f"✓ Deleted media UID {uid} from {self.channel}")
+    
+    async def cmd_playlist_move(self, uid: str, after: str) -> None:
+        """Move video in playlist.
+        
+        Args:
+            uid: Video UID or position to move.
+            after: UID or position to place after.
+        """
+        uid_int = int(uid)
+        after_int = int(after)
+        
+        # Map positions to UIDs if needed (same logic as delete)
+        bucket_name = f"cytube_{self.channel.lower()}_playlist"
+        
+        try:
+            playlist = await self.client.kv_get(bucket_name, "items", default=None, parse_json=True)
+            
+            if playlist is None or not isinstance(playlist, list):
+                print(f"Cannot resolve positions: playlist not available", file=sys.stderr)
+                sys.exit(1)
+            
+            # Resolve 'from' position to UID if it's a position number
+            actual_uid = uid_int
+            if uid_int < 1000:  # Position number
+                if uid_int < 1 or uid_int > len(playlist):
+                    print(f"Position {uid_int} out of range (playlist has {len(playlist)} items)", file=sys.stderr)
+                    sys.exit(1)
+                actual_uid = playlist[uid_int - 1].get("uid")
+                if actual_uid is None:
+                    print(f"Could not find UID for position {uid_int}", file=sys.stderr)
+                    sys.exit(1)
+            
+            # Resolve 'after' position to UID if it's a position number
+            actual_after = after_int
+            if after_int < 1000:  # Position number
+                if after_int < 1 or after_int > len(playlist):
+                    print(f"Position {after_int} out of range (playlist has {len(playlist)} items)", file=sys.stderr)
+                    sys.exit(1)
+                actual_after = playlist[after_int - 1].get("uid")
+                if actual_after is None:
+                    print(f"Could not find UID for position {after_int}", file=sys.stderr)
+                    sys.exit(1)
+            
+            await self.client.move_media(self.channel, actual_uid, actual_after, domain=self.domain)
+            print(f"✓ Moved media {uid} after {after} in {self.channel}")
+        
+        except Exception as e:
+            print(f"Error moving media: {e}", file=sys.stderr)
+            sys.exit(1)
+    
+    async def cmd_playlist_jump(self, uid: str) -> None:
+        """Jump to video in playlist.
+        
+        Args:
+            uid: Video UID to jump to.
+        """
+        uid_int = int(uid)
+        await self.client.jump_to(self.channel, uid_int, domain=self.domain)
+        print(f"✓ Jumped to media {uid} in {self.channel}")
+    
+    async def cmd_playlist_clear(self) -> None:
+        """Clear entire playlist."""
+        await self.client.clear_playlist(self.channel, domain=self.domain)
+        print(f"✓ Cleared playlist in {self.channel}")
+    
+    async def cmd_playlist_shuffle(self) -> None:
+        """Shuffle playlist."""
+        await self.client.shuffle_playlist(self.channel, domain=self.domain)
+        print(f"✓ Shuffled playlist in {self.channel}")
+    
+    async def cmd_playlist_settemp(self, uid: str, temp: bool) -> None:
+        """Set video temporary status.
+        
+        Args:
+            uid: Video UID.
+            temp: Temporary status (true/false).
+        """
+        uid_int = int(uid)
+        await self.client.set_temp(self.channel, uid_int, temp, domain=self.domain)
+        print(f"✓ Set temp={temp} for media {uid} in {self.channel}")
+    
+    # ========================================================================
+    # Playback Commands
+    # ========================================================================
+    
+    async def cmd_pause(self) -> None:
+        """Pause playback."""
+        await self.client.pause(self.channel, domain=self.domain)
+        print(f"✓ Paused playback in {self.channel}")
+    
+    async def cmd_play(self) -> None:
+        """Resume playback."""
+        await self.client.play(self.channel, domain=self.domain)
+        print(f"✓ Resumed playback in {self.channel}")
+    
+    async def cmd_seek(self, time: float) -> None:
+        """Seek to timestamp.
+        
+        Args:
+            time: Target time in seconds.
+        """
+        await self.client.seek(self.channel, time, domain=self.domain)
+        print(f"✓ Seeked to {time}s in {self.channel}")
+    
+    # ========================================================================
+    # Moderation Commands
+    # ========================================================================
+    
+    async def cmd_kick(self, username: str, reason: Optional[str] = None) -> None:
+        """Kick user from channel.
+        
+        Args:
+            username: Username to kick.
+            reason: Optional kick reason.
+        """
+        await self.client.kick_user(self.channel, username, reason, domain=self.domain)
+        print(f"✓ Kicked {username} from {self.channel}")
+    
+    async def cmd_ban(self, username: str, reason: Optional[str] = None) -> None:
+        """Ban user from channel.
+        
+        Args:
+            username: Username to ban.
+            reason: Optional ban reason.
+        """
+        await self.client.ban_user(self.channel, username, reason, domain=self.domain)
+        print(f"✓ Banned {username} from {self.channel}")
+    
+    async def cmd_voteskip(self) -> None:
+        """Vote to skip current video."""
+        await self.client.voteskip(self.channel, domain=self.domain)
+        print(f"✓ Voted to skip in {self.channel}")
+    
+    # ========================================================================
+    # List Commands
+    # ========================================================================
+    
+    async def cmd_list_queue(self) -> None:
+        """Display current playlist queue."""
+        try:
+            # Query state via unified command pattern
+            request = {
+                "service": "robot",
+                "command": "state.playlist"
+            }
+            response = await self.client.nats_request(
+                "kryten.robot.command",
+                request,
+                timeout=5.0
+            )
+            
+            if not response.get("success"):
+                print(f"Error: {response.get('error', 'Unknown error')}")
+                print(f"Is Kryten-Robot running for channel '{self.channel}'?")
+                return
+            
+            playlist = response.get("data", {}).get("playlist", [])
+            
+            if not playlist:
+                print("Playlist is empty.")
+                return
+            
+            print(f"\n{self.channel} Playlist ({len(playlist)} items):")
+            print("=" * 80)
+            
+            for i, item in enumerate(playlist, 1):
+                media = item.get("media", {})
+                title = media.get("title", "Unknown")
+                duration = media.get("duration", "--:--")
+                media_type = media.get("type", "??")
+                uid = item.get("uid", "")
+                temp = " [TEMP]" if item.get("temp") else ""
+                queueby = item.get("queueby", "")
+                
+                print(f"{i:3}. [{media_type}] {title}")
+                print(f"     Duration: {duration} | UID: {uid}{temp}")
+                if queueby:
+                    print(f"     Queued by: {queueby}")
+                print()
+        
+        except Exception as e:
+            print(f"Error retrieving playlist: {e}", file=sys.stderr)
+            sys.exit(1)
+    
+    async def cmd_list_users(self) -> None:
+        """Display current user list."""
+        try:
+            # Query state via unified command pattern
+            request = {
+                "service": "robot",
+                "command": "state.userlist"
+            }
+            response = await self.client.nats_request(
+                "kryten.robot.command",
+                request,
+                timeout=5.0
+            )
+            
+            if not response.get("success"):
+                print(f"Error: {response.get('error', 'Unknown error')}")
+                print(f"Is Kryten-Robot running for channel '{self.channel}'?")
+                return
+            
+            users = response.get("data", {}).get("userlist", [])
+            
+            if not users:
+                print("No users online.")
+                return
+            
+            # Sort by rank (descending) then name
+            users_sorted = sorted(users, key=lambda u: (-u.get("rank", 0), u.get("name", "").lower()))
+            
+            print(f"\n{self.channel} Users ({len(users)} online):")
+            print("=" * 80)
+            
+            rank_names = {
+                0: "Guest",
+                1: "Registered",
+                2: "Moderator",
+                3: "Channel Admin",
+                4: "Site Admin",
+            }
+            
+            for user in users_sorted:
+                name = user.get("name", "Unknown")
+                rank = user.get("rank", 0)
+                rank_name = rank_names.get(rank, f"Rank {rank}")
+                afk = " [AFK]" if user.get("meta", {}).get("afk") else ""
+                
+                print(f"  [{rank}] {name} - {rank_name}{afk}")
+        
+        except Exception as e:
+            print(f"Error retrieving user list: {e}", file=sys.stderr)
+            sys.exit(1)
+    
+    async def cmd_list_emotes(self) -> None:
+        """Display channel emotes."""
+        try:
+            # Query state via unified command pattern
+            request = {
+                "service": "robot",
+                "command": "state.emotes"
+            }
+            response = await self.client.nats_request(
+                "kryten.robot.command",
+                request,
+                timeout=5.0
+            )
+            
+            if not response.get("success"):
+                print(f"Error: {response.get('error', 'Unknown error')}")
+                print(f"Is Kryten-Robot running for channel '{self.channel}'?")
+                return
+            
+            emotes = response.get("data", {}).get("emotes", [])
+            
+            if not emotes:
+                print("No custom emotes configured.")
+                return
+            
+            print(f"\n{self.channel} Custom Emotes ({len(emotes)} total):")
+            print("=" * 80)
+            
+            for emote in emotes:
+                name = emote.get("name", "Unknown")
+                image = emote.get("image", "")
+                
+                # Truncate long URLs for display
+                if len(image) > 60:
+                    image_display = image[:57] + "..."
+                else:
+                    image_display = image
+                
+                print(f"  {name:30} {image_display}")
+        
+        except Exception as e:
+            print(f"Error retrieving emotes: {e}", file=sys.stderr)
+            sys.exit(1)
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create command-line argument parser.
+    
+    Returns:
+        Configured ArgumentParser.
+    """
+    parser = argparse.ArgumentParser(
+        prog="kryten",
+        description="Send commands to CyTube channel via NATS",
+        epilog="See 'kryten <command> --help' for command-specific help."
+    )
+    
+    parser.add_argument(
+        "--config",
+        default="config.json",
+        help="Path to configuration file (default: config.json)"
+    )
+    
+    parser.add_argument(
+        "--channel",
+        help="Override channel from config"
+    )
+    
+    subparsers = parser.add_subparsers(dest="command", help="Command to execute")
+    
+    # Chat commands
+    say_parser = subparsers.add_parser("say", help="Send a chat message")
+    say_parser.add_argument("message", help="Message text")
+    
+    pm_parser = subparsers.add_parser("pm", help="Send a private message")
+    pm_parser.add_argument("username", help="Target username")
+    pm_parser.add_argument("message", help="Message text")
+    
+    # Playlist commands
+    playlist_parser = subparsers.add_parser("playlist", help="Playlist management")
+    playlist_subparsers = playlist_parser.add_subparsers(dest="playlist_cmd")
+    
+    add_parser = playlist_subparsers.add_parser("add", help="Add video to end")
+    add_parser.add_argument("url", help="Video URL or ID")
+    
+    addnext_parser = playlist_subparsers.add_parser("addnext", help="Add video to play next")
+    addnext_parser.add_argument("url", help="Video URL or ID")
+    
+    del_parser = playlist_subparsers.add_parser("del", help="Delete video")
+    del_parser.add_argument("uid", help="Video UID or position")
+    
+    move_parser = playlist_subparsers.add_parser("move", help="Move video")
+    move_parser.add_argument("uid", help="Video UID to move")
+    move_parser.add_argument("after", help="UID to place after")
+    
+    jump_parser = playlist_subparsers.add_parser("jump", help="Jump to video")
+    jump_parser.add_argument("uid", help="Video UID")
+    
+    playlist_subparsers.add_parser("clear", help="Clear playlist")
+    playlist_subparsers.add_parser("shuffle", help="Shuffle playlist")
+    
+    settemp_parser = playlist_subparsers.add_parser("settemp", help="Set temp status")
+    settemp_parser.add_argument("uid", help="Video UID")
+    settemp_parser.add_argument("temp", choices=["true", "false"], help="Temporary status")
+    
+    # Playback commands
+    subparsers.add_parser("pause", help="Pause playback")
+    subparsers.add_parser("play", help="Resume playback")
+    
+    seek_parser = subparsers.add_parser("seek", help="Seek to timestamp")
+    seek_parser.add_argument("time", type=float, help="Time in seconds")
+    
+    # Moderation commands
+    kick_parser = subparsers.add_parser("kick", help="Kick user")
+    kick_parser.add_argument("username", help="Username to kick")
+    kick_parser.add_argument("reason", nargs="?", help="Kick reason")
+    
+    ban_parser = subparsers.add_parser("ban", help="Ban user")
+    ban_parser.add_argument("username", help="Username to ban")
+    ban_parser.add_argument("reason", nargs="?", help="Ban reason")
+    
+    subparsers.add_parser("voteskip", help="Vote to skip current video")
+    
+    # List commands
+    list_parser = subparsers.add_parser("list", help="List channel information")
+    list_subparsers = list_parser.add_subparsers(dest="list_cmd")
+    
+    list_subparsers.add_parser("queue", help="Show current playlist")
+    list_subparsers.add_parser("users", help="Show online users")
+    list_subparsers.add_parser("emotes", help="Show channel emotes")
+    
+    return parser
+
+
+async def main() -> None:
+    """Main entry point for CLI."""
+    parser = create_parser()
+    args = parser.parse_args()
+    
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+    
+    # Initialize CLI
+    cli = KrytenCLI(args.config)
+    
+    # Override channel if specified
+    if args.channel:
+        cli.channel = args.channel
+    
+    # Connect to NATS
+    await cli.connect()
+    
+    try:
+        # Route to appropriate command handler
+        if args.command == "say":
+            await cli.cmd_say(args.message)
+        
+        elif args.command == "pm":
+            await cli.cmd_pm(args.username, args.message)
+        
+        elif args.command == "playlist":
+            if args.playlist_cmd == "add":
+                await cli.cmd_playlist_add(args.url)
+            elif args.playlist_cmd == "addnext":
+                await cli.cmd_playlist_addnext(args.url)
+            elif args.playlist_cmd == "del":
+                await cli.cmd_playlist_del(args.uid)
+            elif args.playlist_cmd == "move":
+                await cli.cmd_playlist_move(args.uid, args.after)
+            elif args.playlist_cmd == "jump":
+                await cli.cmd_playlist_jump(args.uid)
+            elif args.playlist_cmd == "clear":
+                await cli.cmd_playlist_clear()
+            elif args.playlist_cmd == "shuffle":
+                await cli.cmd_playlist_shuffle()
+            elif args.playlist_cmd == "settemp":
+                temp_bool = args.temp == "true"
+                await cli.cmd_playlist_settemp(args.uid, temp_bool)
+            else:
+                parser.parse_args(["playlist", "--help"])
+        
+        elif args.command == "pause":
+            await cli.cmd_pause()
+        
+        elif args.command == "play":
+            await cli.cmd_play()
+        
+        elif args.command == "seek":
+            await cli.cmd_seek(args.time)
+        
+        elif args.command == "kick":
+            await cli.cmd_kick(args.username, args.reason)
+        
+        elif args.command == "ban":
+            await cli.cmd_ban(args.username, args.reason)
+        
+        elif args.command == "voteskip":
+            await cli.cmd_voteskip()
+        
+        elif args.command == "list":
+            if args.list_cmd == "queue":
+                await cli.cmd_list_queue()
+            elif args.list_cmd == "users":
+                await cli.cmd_list_users()
+            elif args.list_cmd == "emotes":
+                await cli.cmd_list_emotes()
+            else:
+                parser.parse_args(["list", "--help"])
+        
+        else:
+            print(f"Error: Unknown command '{args.command}'", file=sys.stderr)
+            sys.exit(1)
+    
+    finally:
+        await cli.disconnect()
+
+
+def run() -> None:
+    """Entry point wrapper for setuptools."""
+    try:
+        asyncio.run(main())
+    except KeyboardInterrupt:
+        print("\nAborted.", file=sys.stderr)
+        sys.exit(130)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    run()