fleet_dashboard.py

#!/usr/bin/env python3
"""
fleet_dashboard.py — Live terminal dashboard for monitoring a LITCOIN mining fleet.
Shows balances, mining status, earnings, staking yields, and fleet totals in real-time.

Requires: pip install rich

Usage:
    python fleet_dashboard.py
    python fleet_dashboard.py --interval 10
    python fleet_dashboard.py --config path/to/config.json
"""
import json
import sys
import uuid
import time
import argparse
from pathlib import Path
from datetime import datetime, timezone, timedelta

try:
    from litcoin import Agent
    from litcoin.api import APIError
except ImportError:
    print("ERROR: litcoin package not installed. Run: pip install litcoin")
    sys.exit(1)

try:
    from rich.console import Console
    from rich.table import Table
    from rich.live import Live
    from rich.panel import Panel
    from rich.text import Text
    from rich import box
except ImportError:
    print("ERROR: rich package not installed. Run: pip install rich")
    sys.exit(1)


def load_config(path="config.json"):
    p = Path(path)
    if not p.exists():
        print(f"ERROR: Config file not found: {path}")
        print("Copy config.example.json to config.json and fill in your values.")
        sys.exit(1)
    with open(p) as f:
        return json.load(f)


# Cache agents to avoid re-auth every refresh
_agent_cache = {}

def get_agent(api_key):
    if api_key not in _agent_cache:
        _agent_cache[api_key] = Agent(api_key)
    return _agent_cache[api_key]


def fetch_bot_data(bot_cfg):
    """Fetch all data for a single bot."""
    result = {
        "name": bot_cfg["name"],
        "error": None,
        "free_lit": 0, "staked": 0, "total": 0,
        "tier": 0, "mining_status": "UNKNOWN",
        "earned_today": 0, "daily_cap": 0,
        "boost": 0, "daily_yield": 0, "apy": 0,
    }

    try:
        agent = get_agent(bot_cfg["api_key"])

        bal = agent.balance()
        result["free_lit"] = bal.get("litcoin", 0)

        try:
            stk = agent.stake_info()
            result["staked"] = stk.get("amount", 0)
        except Exception:
            pass

        result["total"] = result["free_lit"] + result["staked"]

        try:
            result["tier"] = agent.tier()
        except Exception:
            pass

        try:
            sy = agent.staking_yield()
            result["daily_yield"] = sy.get("dailyYield", 0)
            result["apy"] = sy.get("apy", 0)
        except Exception:
            pass

        try:
            result["boost"] = agent.mining_boost()
        except Exception:
            pass

        nonce = uuid.uuid4().hex[:32]
        try:
            ch = agent.api.get_challenge(nonce, agent.auth.token)
            result["earned_today"] = ch.get("earnedToday", 0)
            result["daily_cap"] = ch.get("dailyCap", 0)
            if ch.get("capped"):
                result["mining_status"] = "CAPPED"
            elif ch.get("poolExhausted"):
                result["mining_status"] = "POOL EMPTY"
            else:
                result["mining_status"] = "MINING"
        except APIError as e:
            if "Insufficient" in str(getattr(e, "message", e)):
                result["mining_status"] = "BLOCKED"
            else:
                result["mining_status"] = f"ERR"
        except Exception:
            result["mining_status"] = "ERROR"

    except Exception as e:
        result["error"] = str(e)[:40]

    return result


def format_lit(amount):
    if amount >= 1_000_000:
        return f"{amount / 1_000_000:.2f}M"
    elif amount >= 1_000:
        return f"{amount / 1_000:.1f}K"
    return f"{amount:,.0f}"


TIER_NAMES = {0: "None", 1: "Spark", 2: "Circuit", 3: "Core", 4: "Architect"}


def build_display(bot_data_list, refresh_count, interval):
    """Build the rich display."""
    now = datetime.now()
    utc_now = datetime.now(timezone.utc)

    # Time until midnight UTC
    midnight = utc_now.replace(hour=0, minute=0, second=0, microsecond=0) + timedelta(days=1)
    delta = midnight - utc_now
    hrs = int(delta.total_seconds() // 3600)
    mins = int((delta.total_seconds() % 3600) // 60)

    table = Table(
        box=box.ROUNDED,
        show_header=True,
        header_style="bold white on dark_blue",
        border_style="blue",
        expand=True,
    )
    table.add_column("Bot", style="bold", width=10)
    table.add_column("Free LIT", justify="right", width=10)
    table.add_column("Staked", justify="right", width=10)
    table.add_column("Total", justify="right", width=10)
    table.add_column("Tier", justify="center", width=10)
    table.add_column("Mining", justify="center", width=10)
    table.add_column("Earned", justify="right", width=14)
    table.add_column("Cap", justify="right", width=8)

    t_free = t_staked = t_earned = t_cap = t_yield = 0
    mining_count = 0

    for d in bot_data_list:
        t_free += d["free_lit"]
        t_staked += d["staked"]
        t_earned += d["earned_today"]
        t_cap += d["daily_cap"]
        t_yield += d["daily_yield"]

        ms = d["mining_status"]
        if ms == "MINING":
            mining_styled = "[bold green]MINING[/]"
            mining_count += 1
        elif ms == "CAPPED":
            mining_styled = "[bold yellow]CAPPED[/]"
            mining_count += 1
        elif ms == "BLOCKED":
            mining_styled = "[bold red]BLOCKED[/]"
        else:
            mining_styled = f"[red]{ms}[/]"

        tier_text = f"T{d['tier']} {TIER_NAMES.get(d['tier'], '?')}"

        if d["daily_cap"] > 0:
            pct = min(100, d["earned_today"] / d["daily_cap"] * 100)
            earned_text = f"{format_lit(d['earned_today'])} ({pct:.0f}%)"
        else:
            earned_text = format_lit(d["earned_today"])

        if d["error"]:
            table.add_row(d["name"], "[red]ERR[/]", "-", "-", "-", f"[red]{d['error'][:20]}[/]", "-", "-")
        else:
            table.add_row(
                d["name"], format_lit(d["free_lit"]), format_lit(d["staked"]),
                format_lit(d["total"]), tier_text, mining_styled,
                earned_text, format_lit(d["daily_cap"]),
            )

    # Fleet totals
    bot_count = len(bot_data_list)
    table.add_section()
    table.add_row(
        "[bold]FLEET[/]",
        f"[bold]{format_lit(t_free)}[/]", f"[bold]{format_lit(t_staked)}[/]",
        f"[bold]{format_lit(t_free + t_staked)}[/]", "",
        f"[bold]{mining_count}/{bot_count}[/]",
        f"[bold]{format_lit(t_earned)}[/]", f"[bold]{format_lit(t_cap)}[/]",
    )

    # Yield summary
    yield_table = Table(box=box.SIMPLE, show_header=True, header_style="bold", expand=True)
    yield_table.add_column("Bot", width=10)
    yield_table.add_column("Daily Yield", justify="right", width=12)
    yield_table.add_column("APY", justify="right", width=8)
    yield_table.add_column("Boost", justify="right", width=8)

    for d in bot_data_list:
        if not d["error"]:
            boost_pct = d["boost"] / 100 if d["boost"] else 0
            yield_table.add_row(
                d["name"],
                f"{d['daily_yield']:,.0f} LIT",
                f"{d['apy']:.1f}%",
                f"{boost_pct:.0f}%" if boost_pct else "-",
            )
    yield_table.add_section()
    yield_table.add_row("[bold]TOTAL[/]", f"[bold]{t_yield:,.0f} LIT[/]", "", "")

    header = Text()
    header.append("LITCOIN FLEET DASHBOARD", style="bold white")
    header.append(f"  |  {now.strftime('%H:%M:%S')}", style="bold cyan")
    header.append(f"  |  Cap reset in {hrs}h {mins}m", style="bold yellow")
    header.append(f"  |  Refresh #{refresh_count} (every {interval}s)", style="dim")

    return Panel(
        table,
        title=header,
        subtitle=f"Daily staking yield: {t_yield:,.0f} LIT",
        border_style="bright_blue",
    )


def main():
    parser = argparse.ArgumentParser(description="LITCOIN fleet dashboard")
    parser.add_argument("--config", default="config.json", help="Config file path")
    parser.add_argument("--interval", type=int, default=30, help="Refresh interval in seconds")
    args = parser.parse_args()

    config = load_config(args.config)
    bots = [b for b in config.get("bots", []) if b.get("enabled", True)]

    if not bots:
        print("No enabled bots found in config.")
        sys.exit(1)

    console = Console()
    count = 0

    try:
        with Live(console=console, refresh_per_second=1, screen=True) as live:
            while True:
                count += 1
                data = [fetch_bot_data(b) for b in bots]
                panel = build_display(data, count, args.interval)
                live.update(panel)
                time.sleep(args.interval)
    except KeyboardInterrupt:
        console.print("\n[bold]Dashboard stopped.[/]")


if __name__ == "__main__":
    main()