telemux 1.0.1__py3-none-any.whl

telemux/__init__.py

@@ -0,0 +1,24 @@
+"""
+TeleMux - Bidirectional Telegram integration for tmux sessions
+"""
+
+__version__ = "1.0.1"
+__author__ = "Marco Almazan"
+
+from pathlib import Path
+
+# Package-level constants
+TELEMUX_DIR = Path.home() / ".telemux"
+MESSAGE_QUEUE_DIR = TELEMUX_DIR / "message_queue"
+CONFIG_FILE = TELEMUX_DIR / "telegram_config"
+LOG_FILE = TELEMUX_DIR / "telegram_listener.log"
+TMUX_SESSION = "telegram-listener"
+
+__all__ = [
+    "__version__",
+    "TELEMUX_DIR",
+    "MESSAGE_QUEUE_DIR",
+    "CONFIG_FILE",
+    "LOG_FILE",
+    "TMUX_SESSION",
+]

telemux/cleanup.py

@@ -0,0 +1,189 @@
+"""
+TeleMux Log Rotation and Cleanup
+Automatically rotates large log files and archives old data
+"""
+
+import sys
+import gzip
+import shutil
+import subprocess
+from pathlib import Path
+from datetime import datetime, timedelta
+
+from . import TELEMUX_DIR, MESSAGE_QUEUE_DIR, LOG_FILE
+
+
+# Configuration
+MAX_SIZE_MB = 10
+MAX_SIZE_BYTES = MAX_SIZE_MB * 1024 * 1024
+
+
+def log_info(message: str):
+    """Print info message."""
+    print(f"✓ {message}")
+
+
+def log_warning(message: str):
+    """Print warning message."""
+    print(f"⚠ {message}")
+
+
+def rotate_log(log_file: Path):
+    """Rotate a log file if it exceeds size limit."""
+    if not log_file.exists():
+        return
+
+    file_size = log_file.stat().st_size
+
+    if file_size > MAX_SIZE_BYTES:
+        # Create archive directory
+        archive_month = datetime.now().strftime("%Y-%m")
+        archive_dir = MESSAGE_QUEUE_DIR / "archive" / archive_month
+        archive_dir.mkdir(parents=True, exist_ok=True)
+
+        # Create archive filename
+        timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+        archive_file = archive_dir / f"{log_file.name}.{timestamp}"
+
+        size_mb = file_size / (1024 * 1024)
+        log_warning(f"Rotating {log_file.name} ({size_mb:.2f}MB > {MAX_SIZE_MB}MB)")
+
+        # Move to archive
+        shutil.move(str(log_file), str(archive_file))
+
+        # Compress archive
+        with open(archive_file, 'rb') as f_in:
+            with gzip.open(str(archive_file) + '.gz', 'wb') as f_out:
+                shutil.copyfileobj(f_in, f_out)
+
+        # Remove uncompressed archive
+        archive_file.unlink()
+
+        # Create new empty log file
+        log_file.touch()
+
+        log_info(f"Archived to {archive_file}.gz")
+    else:
+        size_mb = file_size / (1024 * 1024)
+        log_info(f"{log_file.name} is {size_mb:.2f}MB (under {MAX_SIZE_MB}MB limit)")
+
+
+def cleanup_old_archives():
+    """Remove archives older than 6 months."""
+    archive_base = MESSAGE_QUEUE_DIR / "archive"
+    if not archive_base.exists():
+        return
+
+    # Calculate cutoff date (6 months ago)
+    cutoff_date = datetime.now() - timedelta(days=180)
+    cutoff_str = cutoff_date.strftime("%Y-%m")
+
+    # Find and remove old archives
+    removed_count = 0
+    for archive_dir in archive_base.iterdir():
+        if archive_dir.is_dir() and archive_dir.name < cutoff_str:
+            log_warning(f"Removing {archive_dir.name}")
+            shutil.rmtree(archive_dir)
+            removed_count += 1
+
+    if removed_count > 0:
+        print("")
+
+
+def install_cron():
+    """Install cron job for monthly log rotation."""
+    print("")
+    print("Installing cron job for monthly log rotation...")
+
+    # Get the path to this script
+    import telemux.cleanup
+    cleanup_path = telemux.cleanup.__file__
+
+    cron_cmd = f"0 0 1 * * python3 -m telemux.cleanup"
+
+    try:
+        # Get current crontab
+        result = subprocess.run(
+            ['crontab', '-l'],
+            capture_output=True,
+            text=True,
+            check=False
+        )
+
+        # Filter out existing cleanup entries
+        existing_lines = []
+        if result.returncode == 0:
+            existing_lines = [
+                line for line in result.stdout.splitlines()
+                if 'telemux' not in line.lower() and 'cleanup' not in line.lower()
+            ]
+
+        # Add new cron job
+        new_crontab = '\n'.join(existing_lines + [cron_cmd]) + '\n'
+
+        # Install new crontab
+        subprocess.run(
+            ['crontab', '-'],
+            input=new_crontab,
+            text=True,
+            check=True
+        )
+
+        log_info("Cron job installed (runs 1st of each month at midnight)")
+        print("To remove: crontab -e")
+
+    except subprocess.CalledProcessError as e:
+        print(f"Failed to install cron job: {e}")
+    except FileNotFoundError:
+        print("crontab command not found (cron may not be available)")
+
+
+def main():
+    """Main cleanup entry point."""
+    print("TeleMux Log Rotation")
+    print("=" * 60)
+    print("")
+
+    # Log files to rotate
+    outgoing_log = MESSAGE_QUEUE_DIR / "outgoing.log"
+    incoming_log = MESSAGE_QUEUE_DIR / "incoming.log"
+
+    # Rotate logs if they exceed size limit
+    rotate_log(outgoing_log)
+    rotate_log(incoming_log)
+    rotate_log(LOG_FILE)
+
+    print("")
+
+    # Clean up old archives
+    cleanup_old_archives()
+
+    # Summary
+    print("Summary")
+    print("-" * 60)
+
+    archive_dir = MESSAGE_QUEUE_DIR / "archive"
+    if archive_dir.exists():
+        # Count archived files
+        archive_count = sum(1 for _ in archive_dir.rglob("*.gz"))
+
+        # Calculate total size
+        total_size = sum(f.stat().st_size for f in archive_dir.rglob("*.gz"))
+        size_mb = total_size / (1024 * 1024)
+
+        print(f"Archive directory: {archive_dir}")
+        print(f"Archived files: {archive_count}")
+        print(f"Total archive size: {size_mb:.2f} MB")
+    else:
+        print("No archives yet")
+
+    print("")
+    log_info("Log rotation complete!")
+
+    # Optional: Install cron job
+    if len(sys.argv) > 1 and sys.argv[1] == "--install-cron":
+        install_cron()
+
+
+if __name__ == "__main__":
+    main()

telemux/cli.py

@@ -0,0 +1,76 @@
+"""
+Main CLI entry point for TeleMux
+"""
+
+import sys
+from . import control
+
+
+def main():
+    """Main CLI dispatcher."""
+    if len(sys.argv) < 2:
+        print("TeleMux - Bidirectional Telegram Integration for tmux")
+        print("")
+        print("Usage: telemux <command>")
+        print("")
+        print("Commands:")
+        print("  install  - Run interactive installer")
+        print("  start    - Start the listener daemon")
+        print("  stop     - Stop the listener daemon")
+        print("  restart  - Restart the listener daemon")
+        print("  status   - Check if listener is running")
+        print("  logs     - Tail the log file")
+        print("  attach   - Attach to the listener tmux session")
+        print("  cleanup  - Rotate and clean up log files")
+        print("  doctor   - Run health check and diagnose issues")
+        print("")
+        print("Shell Functions (available after installation):")
+        print("  tg_alert \"message\"         - Send notification to Telegram")
+        print("  tg_agent \"name\" \"message\"  - Send message and receive replies")
+        print("  tg_done                     - Alert when previous command completes")
+        print("")
+        print("Shortcuts:")
+        print("  tg-start, tg-stop, tg-status, tg-logs")
+        print("")
+        print("Examples:")
+        print("  telemux install              # Run installer")
+        print("  telemux start                # Start listener")
+        print("  tg_alert \"Build complete\"    # Send notification")
+        print("")
+        print("Documentation: https://github.com/malmazan/telemux")
+        sys.exit(0)
+
+    command = sys.argv[1]
+
+    if command == "install":
+        from .installer import main as installer_main
+        installer_main()
+    elif command == "start":
+        control.start()
+    elif command == "stop":
+        control.stop()
+    elif command == "restart":
+        control.restart()
+    elif command == "status":
+        control.status()
+    elif command == "logs":
+        control.logs()
+    elif command == "attach":
+        control.attach()
+    elif command == "cleanup":
+        from .cleanup import main as cleanup_main
+        cleanup_main()
+    elif command == "doctor":
+        control.doctor()
+    elif command in ["-h", "--help", "help"]:
+        # Remove command argument and show help
+        sys.argv.pop(1)
+        main()
+    else:
+        print(f"Unknown command: {command}")
+        print("Run 'telemux' with no arguments for usage information")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

telemux/config.py

@@ -0,0 +1,78 @@
+"""
+Configuration management for TeleMux
+"""
+
+import os
+from pathlib import Path
+from typing import Optional, Tuple
+
+from . import TELEMUX_DIR, MESSAGE_QUEUE_DIR, CONFIG_FILE
+
+
+def ensure_directories() -> None:
+    """Create TeleMux directories if they don't exist."""
+    TELEMUX_DIR.mkdir(parents=True, exist_ok=True)
+    MESSAGE_QUEUE_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_config() -> Tuple[Optional[str], Optional[str]]:
+    """
+    Load Telegram configuration from config file.
+
+    Returns:
+        Tuple of (bot_token, chat_id) or (None, None) if not configured
+    """
+    if not CONFIG_FILE.exists():
+        return None, None
+
+    # Source the bash config file to extract env vars
+    bot_token = None
+    chat_id = None
+
+    try:
+        with open(CONFIG_FILE, 'r') as f:
+            for line in f:
+                line = line.strip()
+                if line.startswith('export TELEMUX_TG_BOT_TOKEN='):
+                    bot_token = line.split('=', 1)[1].strip('"').strip("'")
+                elif line.startswith('export TELEMUX_TG_CHAT_ID='):
+                    chat_id = line.split('=', 1)[1].strip('"').strip("'")
+    except Exception:
+        pass
+
+    # Also check environment variables (they take precedence)
+    bot_token = os.environ.get('TELEMUX_TG_BOT_TOKEN', bot_token)
+    chat_id = os.environ.get('TELEMUX_TG_CHAT_ID', chat_id)
+
+    return bot_token, chat_id
+
+
+def save_config(bot_token: str, chat_id: str) -> None:
+    """
+    Save Telegram configuration to config file.
+
+    Args:
+        bot_token: Telegram bot token
+        chat_id: Telegram chat ID
+    """
+    ensure_directories()
+
+    config_content = f"""#!/bin/bash
+# TeleMux Telegram Bot Configuration
+# Keep this file secure! (chmod 600)
+
+export TELEMUX_TG_BOT_TOKEN="{bot_token}"
+export TELEMUX_TG_CHAT_ID="{chat_id}"
+"""
+
+    with open(CONFIG_FILE, 'w') as f:
+        f.write(config_content)
+
+    # Secure the config file
+    os.chmod(CONFIG_FILE, 0o600)
+
+
+def is_configured() -> bool:
+    """Check if TeleMux is configured."""
+    bot_token, chat_id = load_config()
+    return bot_token is not None and chat_id is not None

telemux/control.py

@@ -0,0 +1,305 @@
+"""
+Control commands for TeleMux listener daemon
+"""
+
+import sys
+import time
+import subprocess
+import requests
+from pathlib import Path
+
+from . import TELEMUX_DIR, LOG_FILE, TMUX_SESSION
+from .config import load_config
+
+
+def is_listener_running() -> bool:
+    """Check if the listener tmux session is running."""
+    try:
+        result = subprocess.run(
+            ['tmux', 'has-session', '-t', TMUX_SESSION],
+            capture_output=True,
+            check=False
+        )
+        return result.returncode == 0
+    except FileNotFoundError:
+        print("Error: tmux is not installed")
+        sys.exit(1)
+
+
+def start():
+    """Start the Telegram listener daemon."""
+    if is_listener_running():
+        print("Telegram listener is already running")
+        print(f"   Use: telemux-status")
+        sys.exit(1)
+
+    print("Starting Telegram listener...")
+
+    # Start tmux session with the listener module
+    # Use -m flag to run as module, which handles imports correctly
+    subprocess.run(
+        ['tmux', 'new-session', '-d', '-s', TMUX_SESSION, 'python3', '-m', 'telemux.listener'],
+        check=False
+    )
+    time.sleep(1)
+
+    if is_listener_running():
+        print("Telegram listener started successfully")
+        print(f"   Session: {TMUX_SESSION}")
+        print(f"   Log: {LOG_FILE}")
+        print("")
+        print("Commands:")
+        print("   telemux-status   - Check status")
+        print("   telemux-logs     - View logs")
+        print("   telemux-attach   - Attach to session")
+        print("   telemux-stop     - Stop listener")
+    else:
+        print("Failed to start listener")
+        sys.exit(1)
+
+
+def stop():
+    """Stop the Telegram listener daemon."""
+    if not is_listener_running():
+        print("Telegram listener is not running")
+        sys.exit(0)
+
+    print("Stopping Telegram listener...")
+    subprocess.run(['tmux', 'kill-session', '-t', TMUX_SESSION], check=False)
+    print("Telegram listener stopped")
+
+
+def restart():
+    """Restart the Telegram listener daemon."""
+    stop()
+    time.sleep(2)
+    start()
+
+
+def status():
+    """Check the status of the listener daemon."""
+    if is_listener_running():
+        print("Telegram listener is RUNNING")
+        print(f"   Session: {TMUX_SESSION}")
+        print(f"   Log: {LOG_FILE}")
+        print("")
+        print("Recent activity:")
+
+        if LOG_FILE.exists():
+            try:
+                with open(LOG_FILE, 'r') as f:
+                    lines = f.readlines()
+                    recent = lines[-10:] if len(lines) >= 10 else lines
+                    for line in recent:
+                        print(line.rstrip())
+            except Exception as e:
+                print(f"Error reading log: {e}")
+        else:
+            print("No logs yet")
+    else:
+        print("Telegram listener is NOT running")
+        print("   Start with: telemux-start")
+
+
+def logs():
+    """Tail the log file."""
+    if LOG_FILE.exists():
+        try:
+            subprocess.run(['tail', '-f', str(LOG_FILE)])
+        except KeyboardInterrupt:
+            print("\nLog streaming stopped")
+    else:
+        print(f"No log file found at {LOG_FILE}")
+
+
+def attach():
+    """Attach to the listener tmux session."""
+    if is_listener_running():
+        subprocess.run(['tmux', 'attach-session', '-t', TMUX_SESSION])
+    else:
+        print("Telegram listener is not running")
+        sys.exit(1)
+
+
+def doctor():
+    """Run health check and diagnose issues."""
+    print("TeleMux Health Check")
+    print("=" * 60)
+    print("")
+
+    # Check tmux
+    print("Checking tmux...")
+    try:
+        result = subprocess.run(['tmux', '-V'], capture_output=True, text=True, check=False)
+        if result.returncode == 0:
+            print(f"   tmux is installed ({result.stdout.strip()})")
+        else:
+            print("   tmux is NOT installed")
+    except FileNotFoundError:
+        print("   tmux is NOT installed")
+    print("")
+
+    # Check Python
+    print("Checking Python...")
+    result = subprocess.run(['python3', '--version'], capture_output=True, text=True, check=False)
+    if result.returncode == 0:
+        print(f"   Python is installed ({result.stdout.strip()})")
+    else:
+        print("   Python3 is NOT installed")
+    print("")
+
+    # Check dependencies
+    print("Checking Python dependencies...")
+    try:
+        import requests
+        print(f"   requests library is installed (v{requests.__version__})")
+    except ImportError:
+        print("   requests library is NOT installed")
+        print("   Install with: pip install telemux")
+    print("")
+
+    # Check config file
+    print("Checking configuration...")
+    from . import CONFIG_FILE
+    if CONFIG_FILE.exists():
+        print(f"   Config file exists: {CONFIG_FILE}")
+
+        # Check permissions
+        import stat
+        perms = oct(CONFIG_FILE.stat().st_mode)[-3:]
+        if perms == "600":
+            print(f"   Config file permissions are secure (600)")
+        else:
+            print(f"   Config file permissions: {perms} (should be 600)")
+            print(f"   Fix with: chmod 600 {CONFIG_FILE}")
+
+        # Check if credentials are set
+        bot_token, chat_id = load_config()
+        if bot_token:
+            print("   Bot token is set")
+        else:
+            print("   Bot token is NOT set")
+
+        if chat_id:
+            print("   Chat ID is set")
+            # Validate format
+            if chat_id.lstrip('-').isdigit():
+                if chat_id.startswith('-'):
+                    print(f"   (Group chat: {chat_id})")
+                else:
+                    print(f"   (Personal chat: {chat_id})")
+            else:
+                print("   Chat ID format may be invalid")
+        else:
+            print("   Chat ID is NOT set")
+    else:
+        print(f"   Config file NOT found: {CONFIG_FILE}")
+        print("   Run: telemux-install")
+    print("")
+
+    # Test bot connection
+    print("Testing Telegram bot connection...")
+    bot_token, chat_id = load_config()
+    if bot_token:
+        try:
+            response = requests.get(f"https://api.telegram.org/bot{bot_token}/getMe", timeout=10)
+            data = response.json()
+            if data.get("ok"):
+                bot_name = data["result"].get("first_name", "")
+                bot_username = data["result"].get("username", "")
+                print("   Bot connection successful!")
+                print(f"   Bot name: {bot_name}")
+                print(f"   Username: @{bot_username}")
+            else:
+                print("   Bot connection failed")
+                print(f"   Response: {data}")
+                print("   Check your bot token")
+        except Exception as e:
+            print(f"   Connection failed: {e}")
+    else:
+        print("   Skipping (no bot token configured)")
+    print("")
+
+    # Check listener process
+    print("Checking listener daemon...")
+    if is_listener_running():
+        print(f"   Listener is RUNNING (session: {TMUX_SESSION})")
+    else:
+        print("   Listener is NOT running")
+        print("   Start with: telemux-start")
+    print("")
+
+    # Check log files
+    print("Checking log files...")
+    if LOG_FILE.exists():
+        size = LOG_FILE.stat().st_size
+        size_mb = size / (1024 * 1024)
+        with open(LOG_FILE, 'r') as f:
+            line_count = sum(1 for _ in f)
+        print(f"   Listener log exists: {LOG_FILE}")
+        print(f"   Size: {size_mb:.2f} MB ({line_count} lines)")
+    else:
+        print("   No listener log file yet")
+
+    from . import MESSAGE_QUEUE_DIR
+    outgoing_log = MESSAGE_QUEUE_DIR / "outgoing.log"
+    if outgoing_log.exists():
+        with open(outgoing_log, 'r') as f:
+            count = sum(1 for _ in f)
+        print(f"   Outgoing message log exists ({count} messages)")
+    else:
+        print("   No outgoing messages yet")
+
+    incoming_log = MESSAGE_QUEUE_DIR / "incoming.log"
+    if incoming_log.exists():
+        with open(incoming_log, 'r') as f:
+            count = sum(1 for _ in f)
+        print(f"   Incoming message log exists ({count} messages)")
+    else:
+        print("   No incoming messages yet")
+    print("")
+
+    # Summary
+    print("=" * 60)
+    print("Health Check Complete")
+    print("=" * 60)
+
+
+def main():
+    """Main control CLI entry point."""
+    if len(sys.argv) < 2:
+        print("TeleMux Control")
+        print("")
+        print(f"Usage: telemux <command>")
+        print("")
+        print("Commands:")
+        print("  start    - Start the listener daemon")
+        print("  stop     - Stop the listener daemon")
+        print("  restart  - Restart the listener daemon")
+        print("  status   - Check if listener is running")
+        print("  logs     - Tail the log file")
+        print("  attach   - Attach to the tmux session")
+        print("  doctor   - Run health check and diagnose issues")
+        print("")
+        print("You can also use:")
+        print("  telemux-start, telemux-stop, telemux-status, telemux-logs, etc.")
+        sys.exit(1)
+
+    command = sys.argv[1]
+    if command == "start":
+        start()
+    elif command == "stop":
+        stop()
+    elif command == "restart":
+        restart()
+    elif command == "status":
+        status()
+    elif command == "logs":
+        logs()
+    elif command == "attach":
+        attach()
+    elif command == "doctor":
+        doctor()
+    else:
+        print(f"Unknown command: {command}")
+        sys.exit(1)