raidlock 0.1.0__py3-none-any.whl

raidlock/treasury.py

@@ -0,0 +1,210 @@
+"""Treasury forecast: burn rate, a forecast to the end of the calendar month (UTC) and budget alerts.
+
+Spend is measured the way budget checks measure it: paid USD, plus the API-equivalent of plan usage unless
+`budget.count_plan_usage` is false. The forecast adds the trailing seven-day daily rate for the rest of the month.
+Alerts fire at ALERT_PCT of a cap, when a cap is reached, and when the forecast passes the monthly cap.
+"""
+
+import datetime
+import math
+
+from . import budgets
+from .core import RaidlockError, clock
+
+ALERT_PCT = 80
+TRAIL_DAYS = 7
+HISTORY_DAYS = 14
+
+
+def _period(now):
+    start = now.replace(day=1, hour=0, minute=0, second=0, microsecond=0)
+    end = (start + datetime.timedelta(days=32)).replace(day=1)
+    return start, end
+
+
+def _measure(rows, count_plan):
+    for r in rows:
+        for key in ("usd", "usd_equiv"):
+            value = r.get(key)
+            if value is not None and (not math.isfinite(float(value)) or float(value) < 0):
+                raise ValueError("invalid-data: nonfinite or negative money")
+    paid = sum(float(r.get("usd") or 0) for r in rows)
+    plan = sum(float(r.get("usd_equiv") or 0) for r in rows if r.get("key") == "plan")
+    equiv = sum(float(r.get("usd_equiv") or 0) for r in rows)
+    total = paid + (plan if count_plan else 0)
+    if not math.isfinite(total) or not math.isfinite(equiv):
+        raise ValueError("invalid-data: money aggregation overflow")
+    return round(total, 6), round(equiv, 6)
+
+
+def _spent(board, since, until, count_plan):
+    rows = board.spend(by="billing", since=clock.iso(since), until=clock.iso(until))["rows"]
+    return _measure(rows, count_plan)
+
+
+def _settings(board):
+    try:
+        return budgets._settings(board)
+    except (RaidlockError, ValueError, TypeError):
+        return {}
+
+
+def _alert(workspace, level, kind, text):
+    return {"workspace": workspace, "level": level, "kind": kind, "text": text}
+
+
+def forecast(board, now=None):
+    try:
+        return _forecast(board, now)
+    except (RaidlockError, ValueError, TypeError, OverflowError):
+        return {"workspace": board.name, "error": "invalid-data", "alerts": [], "by_day": []}
+
+
+def _forecast(board, now=None):
+    """Forecast for one workspace."""
+    now = now or clock.now()
+    start, end = _period(now)
+    settings = _settings(board)
+    count_plan = settings.get(budgets.COUNT_PLAN)
+    count_plan = True if count_plan is None else count_plan
+    day_start = now.replace(hour=0, minute=0, second=0, microsecond=0)
+    until = now + datetime.timedelta(seconds=1)
+    month, month_equiv = _spent(board, start, until, count_plan)
+    today, _ = _spent(board, day_start, until, count_plan)
+    trail, _ = _spent(board, now - datetime.timedelta(days=TRAIL_DAYS), until, count_plan)
+    elapsed = max((now - start).total_seconds() / 86400.0, 1 / 24)
+    remaining = max((end - now).total_seconds() / 86400.0, 0.0)
+    rate = trail / TRAIL_DAYS
+    projected = round(month + rate * remaining, 6)
+    history_from = clock.iso(day_start - datetime.timedelta(days=HISTORY_DAYS - 1))
+    by_day = {r["key"]: r for r in board.spend(by="day", since=history_from)["rows"]}
+    days = []
+    for i in range(HISTORY_DAYS):
+        key = (day_start - datetime.timedelta(days=HISTORY_DAYS - 1 - i)).strftime("%Y-%m-%d")
+        row = by_day.get(key) or {}
+        days.append({"day": key, "usd": round(float(row.get("usd") or 0), 6), "usd_equiv": row.get("usd_equiv") or 0})
+    daily_cap = settings.get(budgets.DAILY)
+    monthly_cap = settings.get(budgets.MONTHLY)
+    name = board.name
+    alerts = []
+    if daily_cap is not None:
+        if today >= daily_cap:
+            alerts.append(
+                _alert(name, "critical", "daily", f"today ${today:.2f} reached the daily cap ${daily_cap:.2f}")
+            )
+        elif daily_cap and today >= daily_cap * ALERT_PCT / 100:
+            alerts.append(
+                _alert(name, "warning", "daily", f"today ${today:.2f} is over {ALERT_PCT}% of ${daily_cap:.2f}")
+            )
+    if monthly_cap is not None:
+        if month >= monthly_cap:
+            alerts.append(
+                _alert(name, "critical", "monthly", f"month ${month:.2f} reached the monthly cap ${monthly_cap:.2f}")
+            )
+        elif projected > monthly_cap:
+            alerts.append(
+                _alert(
+                    name,
+                    "warning",
+                    "forecast",
+                    f"on track for ${projected:.2f} by {end.strftime('%Y-%m-%d')}, over the ${monthly_cap:.2f} cap",
+                )
+            )
+        elif monthly_cap and month >= monthly_cap * ALERT_PCT / 100:
+            alerts.append(
+                _alert(name, "warning", "monthly", f"month ${month:.2f} is over {ALERT_PCT}% of ${monthly_cap:.2f}")
+            )
+    return {
+        "workspace": name,
+        "now": clock.iso(now),
+        "period": {
+            "start": clock.iso(start),
+            "end": clock.iso(end),
+            "days_elapsed": round(elapsed, 3),
+            "days_left": round(remaining, 3),
+        },
+        "count_plan": count_plan,
+        "month": month,
+        "month_api_equiv": month_equiv,
+        "today": today,
+        "burn": {
+            "per_day_month": round(month / elapsed, 6),
+            "per_day_trailing": round(rate, 6),
+            "trail_days": TRAIL_DAYS,
+        },
+        "forecast": projected,
+        "caps": {"daily": daily_cap, "monthly": monthly_cap},
+        "by_day": days,
+        "alerts": alerts,
+    }
+
+
+def combine(items, now=None):
+    """Sum per-workspace forecasts into one view across workspaces."""
+    now = now or clock.now()
+    if any(f.get("error") for f in items):
+        return {"workspace": "*", "error": "invalid-data", "alerts": [], "by_day": []}
+    start, end = _period(now)
+    days = {}
+    for f in items:
+        for d in f["by_day"]:
+            row = days.setdefault(d["day"], {"day": d["day"], "usd": 0.0, "usd_equiv": 0.0})
+            row["usd"] = round(row["usd"] + d["usd"], 6)
+            row["usd_equiv"] = round(row["usd_equiv"] + float(d["usd_equiv"] or 0), 6)
+
+    def total(key):
+        return round(sum(f[key] for f in items), 6)
+
+    return {
+        "workspace": "*",
+        "now": clock.iso(now),
+        "period": {"start": clock.iso(start), "end": clock.iso(end)},
+        "month": total("month"),
+        "month_api_equiv": total("month_api_equiv"),
+        "today": total("today"),
+        "burn": {
+            "per_day_month": round(sum(f["burn"]["per_day_month"] for f in items), 6),
+            "per_day_trailing": round(sum(f["burn"]["per_day_trailing"] for f in items), 6),
+            "trail_days": TRAIL_DAYS,
+        },
+        "forecast": total("forecast"),
+        "by_day": [days[k] for k in sorted(days)],
+        "alerts": [a for f in items for a in f["alerts"]],
+        "workspaces": [{k: f[k] for k in ("workspace", "month", "today", "forecast", "caps", "alerts")} for f in items],
+    }
+
+
+def everywhere(now=None):
+    """Forecasts for every registered workspace, combined."""
+    from .core import Board, registry
+    from .core.db import Index
+
+    home = registry.home()
+    items = []
+    for w in registry.workspaces(Index(home)):
+        try:
+            items.append(forecast(Board.open(w["board"], home=home), now))
+        except (RaidlockError, OSError, ValueError):
+            continue
+    return combine(items, now)
+
+
+def _setup(parser):
+    parser.add_argument("--all", action="store_true", help="every registered workspace, with alerts per workspace")
+
+
+def _handle(ctx, args):
+    f = everywhere() if args.all else forecast(ctx.board)
+    if f.get("error"):
+        return f, "invalid-data: money could not be aggregated"
+    lines = [
+        f"{f['workspace']}: ${f['month']:.2f} this month, ${f['today']:.2f} today",
+        f"burn ${f['burn']['per_day_trailing']:.2f}/day over {TRAIL_DAYS} days; "
+        f"forecast ${f['forecast']:.2f} by {f['period']['end'][:10]}",
+    ]
+    lines += [f"{a['level'].upper()} {a['workspace']}: {a['text']}" for a in f["alerts"]]
+    return f, "\n".join(lines)
+
+
+def register_cli(add_command):
+    add_command("treasury", "burn rate, month-end forecast and budget alerts", _setup, _handle)

raidlock/tui.py

@@ -0,0 +1,223 @@
+"""Live terminal board for supported Linux/macOS hosts; native Windows is unverified."""
+
+import argparse
+import math
+import os
+import selectors
+import sys
+import time
+from contextlib import contextmanager
+from datetime import datetime
+
+from raidlock.core import Board, Precondition, db
+
+LANES = ("todo", "doing", "review", "blocked", "done", "cancelled")
+STATUSES = {
+    "working": "Working",
+    "quiet": "Working",
+    "review": "Waiting",
+    "blocked": "Blocked",
+    "stalled": "Stalled",
+    "idle": "Idle",
+}
+
+
+def _text(value):
+    return "".join(c if c.isprintable() else " " for c in str(value))
+
+
+def _countdown(lease, now):
+    if not lease:
+        return "-"
+    if lease.get("expires") is None:
+        return "held"
+    expires = datetime.fromisoformat(lease["expires"].replace("Z", "+00:00"))
+    seconds = max(0, math.ceil((expires - now).total_seconds()))
+    if not seconds:
+        return "expired"
+    minutes, seconds = divmod(seconds, 60)
+    return f"{minutes:02d}:{seconds:02d}"
+
+
+def render(snapshot, color=False):
+    now = datetime.fromisoformat(snapshot["now"].replace("Z", "+00:00"))
+    color = color and "NO_COLOR" not in os.environ
+
+    def heading(text):
+        return f"\033[1;36m{text}\033[0m" if color else text
+
+    total = snapshot["costs"]["workspace"]
+    lines = [heading(f"Raidlock | {_text(snapshot['workspace'])} | Spend ${total['usd']:.4f}")]
+    if total.get("unpriced_runs"):
+        lines.append(f"Unpriced runs: {total['unpriced_runs']}")
+    for lane in LANES:
+        cards = sorted((c for c in snapshot["cards"] if c["lane"] == lane), key=lambda c: c["id"])
+        if lane == "cancelled" and not cards:
+            continue
+        lines.extend(["", heading(f"{lane.upper()} ({len(cards)})")])
+        for card in cards:
+            title = _text(card["title"])
+            title = title if len(title) <= 44 else title[:41] + "..."
+            lease = snapshot.get("leases", {}).get(card["id"], card.get("lease"))
+            lines.append(
+                f"  {_text(card['id'])} | {title} | {_text(card.get('owner') or '-')} | lock {_countdown(lease, now)}"
+            )
+        if not cards:
+            lines.append("  (empty)")
+    agents = snapshot["agents"]
+    lines.extend(["", heading(f"AGENTS ({len(agents)})")])
+    for name, agent in sorted(agents.items()):
+        status = STATUSES.get(agent.get("status"), "Idle")
+        lines.append(
+            f"  {_text(name)} | {status} | [{_text(agent.get('model') or 'unknown')}] | "
+            f"{_text(agent.get('card') or '-')}"
+        )
+    if not agents:
+        lines.append("  (none)")
+    lines.extend(["", "q / Ctrl-C to exit | countdowns sampled on board changes"])
+    return "\n".join(lines) + "\n"
+
+
+@contextmanager
+def _terminal(output):
+    enabled = output.isatty()
+    restore = None
+    if enabled and os.name == "nt":
+        import ctypes
+        import msvcrt
+
+        kernel = ctypes.windll.kernel32
+        handle = ctypes.c_void_p(msvcrt.get_osfhandle(output.fileno()))
+        mode = ctypes.c_ulong()
+        enabled = bool(kernel.GetConsoleMode(handle, ctypes.byref(mode)))
+        if enabled:
+            enabled = bool(kernel.SetConsoleMode(handle, mode.value | 4))
+            if enabled:
+
+                def restore():
+                    return kernel.SetConsoleMode(handle, mode.value)
+
+    try:
+        if enabled:
+            output.write("\033[?25l")
+        yield enabled
+    finally:
+        if enabled:
+            output.write("\033[0m\033[?25h")
+            output.flush()
+        if restore:
+            restore()
+
+
+@contextmanager
+def _keyboard(stream):
+    saved = None
+    if os.name != "nt" and stream.isatty():
+        import termios
+        import tty
+
+        saved = termios.tcgetattr(stream.fileno())
+        tty.setcbreak(stream.fileno())
+    try:
+        yield
+    finally:
+        if saved is not None:
+            termios.tcsetattr(stream.fileno(), termios.TCSADRAIN, saved)
+
+
+def _quit(stream, delay):
+    deadline = time.monotonic() + delay
+    while True:
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            return False
+        if os.name == "nt":
+            import msvcrt
+
+            if stream.isatty() and msvcrt.kbhit() and msvcrt.getwch() in ("q", "Q", "\x03"):
+                return True
+            time.sleep(min(0.05, remaining))
+        else:
+            try:
+                with selectors.DefaultSelector() as selector:
+                    selector.register(stream, selectors.EVENT_READ)
+                    ready = selector.select(remaining)
+            except (ValueError, OSError):
+                time.sleep(remaining)
+                return False
+            if not ready:
+                return False
+            char = os.read(stream.fileno(), 1)
+            if char in (b"q", b"Q", b"\x03"):
+                return True
+            if not char:
+                time.sleep(remaining)
+                return False
+
+
+def watch(board, interval=3, output=None, stdin=None):
+    if not math.isfinite(interval) or interval <= 0:
+        raise Precondition("interval must be a positive finite number")
+    output = sys.stdout if output is None else output
+    stdin = sys.stdin if stdin is None else stdin
+    version = None
+    try:
+        with _terminal(output) as ansi, _keyboard(stdin):
+            while True:
+                current = board.version()["workspace"]
+                if current != version:
+                    snapshot = board.snapshot(transcript_limit=0, messages_limit=0)
+                    output.write(("\033[H\033[2J" if ansi else "") + render(snapshot, color=ansi))
+                    output.flush()
+                    version = snapshot["version"]["workspace"]
+                db.close_all()
+                if _quit(stdin, interval):
+                    break
+    except KeyboardInterrupt:
+        pass
+    return 0
+
+
+def _open(workspace=None, path=None):
+    return Board.open(workspace if workspace is not None else path)
+
+
+def _interval(value):
+    try:
+        number = float(value)
+    except ValueError:
+        raise argparse.ArgumentTypeError("interval must be a positive finite number") from None
+    if not math.isfinite(number) or number <= 0:
+        raise argparse.ArgumentTypeError("interval must be a positive finite number")
+    return number
+
+
+def _setup(parser):
+    parser.add_argument("--workspace", metavar="NAME", help="workspace folder name or path")
+    parser.add_argument("--interval", type=_interval, default=3)
+
+
+def _command(ctx, args):
+    if args.json:
+        raise Precondition("watch does not support --json")
+    board = _open(args.workspace, args.board) if args.workspace else ctx.board
+    return {"_exit": watch(board, args.interval)}, ""
+
+
+def register_cli(add_command):
+    add_command("watch", "live terminal board", _setup, _command)
+
+
+def main(argv=None):
+    from raidlock.cli import add_command
+    from raidlock.cli import main as cli_main
+
+    register_cli(add_command)
+    args = list(sys.argv[1:] if argv is None else argv)
+    if not args or args[0] != "watch":
+        args.insert(0, "watch")
+    return cli_main(args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

raidlock/web/__init__.py

@@ -0,0 +1,5 @@
+"""Read-only local board UI and CLI entrypoint."""
+
+from .cli import register_cli
+
+__all__ = ["register_cli"]

raidlock/web/achievements/view.css

@@ -0,0 +1,19 @@
+.achs{display:grid;grid-template-columns:repeat(auto-fill,minmax(min(100%,260px),1fr));gap:10px}
+.ach{display:flex;gap:10px;align-items:flex-start;background:var(--panel);border:1px solid var(--edge);border-radius:12px;padding:10px;min-width:0}
+.ach.earned{border-color:var(--accent2)}
+.ach-body{display:flex;flex-direction:column;gap:3px;min-width:0;font-size:14px;overflow-wrap:anywhere}
+.ach-body b{font-size:14px;color:var(--accent)}
+.ach-body small{color:var(--muted)}
+.ach-art{flex:none}
+.ach-art .ring{fill:var(--pill);stroke:var(--edge);stroke-width:2}
+.ach-art .fillc{fill:var(--muted)}
+.ach-art .strokec{stroke:var(--muted);stroke-width:2.5;fill:none;stroke-linecap:round}
+.ach-art .cut{stroke:var(--pill);stroke-width:3;fill:none;stroke-linecap:round;stroke-linejoin:round}
+.ach.earned .ach-art .ring{stroke:var(--accent2)}
+.ach.earned .ach-art .fillc{fill:var(--accent)}
+.ach.earned .ach-art .strokec{stroke:var(--accent)}
+.ach.locked .ach-body b{color:var(--muted)}
+.ach-meter{height:8px;border-radius:4px;background:var(--pill);border:1px solid var(--edge);overflow:hidden}
+.ach-meter i{display:block;height:100%;background:var(--accent)}
+
+.titles{margin:0 0 14px}.titles h3{margin:0 0 6px;font-size:15px;color:var(--accent)}.titles ul{list-style:none;margin:0;padding:0;display:flex;flex-wrap:wrap;gap:6px 14px}.titles li{font-size:14px}.titles b{color:var(--ink)}

raidlock/web/achievements/view.js

@@ -0,0 +1,58 @@
+"use strict";
+(function () {
+  const views = window.RaidlockViews = window.RaidlockViews || [];
+
+  const ART = {
+    sun: s => [s("circle", {cx: 24, cy: 24, r: 9, class: "fillc"}),
+      ...[0, 45, 90, 135, 180, 225, 270, 315].map(a => s("line", {x1: 24, y1: 6, x2: 24, y2: 11, transform: `rotate(${a} 24 24)`, class: "strokec"}))],
+    seal: s => [s("path", {class: "fillc", d: "M24 6l4 3 5-1 2 5 5 2-1 5 3 4-3 4 1 5-5 2-2 5-5-1-4 3-4-3-5 1-2-5-5-2 1-5-3-4 3-4-1-5 5-2 2-5 5 1z"}),
+      s("path", {class: "cut", d: "M17 24l5 5 9-10"})],
+    eyes: s => [s("ellipse", {cx: 15, cy: 24, rx: 9, ry: 6, class: "strokec"}), s("ellipse", {cx: 33, cy: 24, rx: 9, ry: 6, class: "strokec"}),
+      s("circle", {cx: 16, cy: 24, r: 3, class: "fillc"}), s("circle", {cx: 34, cy: 24, r: 3, class: "fillc"})],
+    quill: s => [s("path", {class: "fillc", d: "M38 8C24 10 16 20 13 34l3 1c3-8 8-14 15-18-5 5-9 10-11 17 11-4 17-14 18-26z"}),
+      s("line", {x1: 13, y1: 34, x2: 10, y2: 41, class: "strokec"})],
+    chord: s => [10, 24, 38].flatMap((x, i) => [s("line", {x1: x, y1: 10, x2: x, y2: 34, class: "strokec"}), s("circle", {cx: x - 3, cy: 36 - i * 6, r: 4, class: "fillc"})]),
+    hands: s => [s("path", {class: "fillc", d: "M10 38V20a2 2 0 014 0v8V14a2 2 0 014 0v14V12a2 2 0 014 0v16-12a2 2 0 014 0v18c0 6-4 10-10 10h-1c-3 0-5-2-7-4z"}),
+      s("path", {class: "strokec", d: "M30 30l4-4a2 2 0 013 3l-6 7"})],
+    rune: s => [s("circle", {cx: 24, cy: 24, r: 15, class: "strokec"}), s("path", {class: "strokec", d: "M16 24l6 6 11-13"})],
+    shield: s => [s("path", {class: "fillc", d: "M24 6l15 5v11c0 10-7 17-15 20C16 39 9 32 9 22V11z"}), s("path", {class: "strokec", d: "M24 14v20M17 22h14"})],
+    blade: s => [s("path", {class: "fillc", d: "M34 6l8 0 0 8-18 18-8-8z"}), s("path", {class: "strokec", d: "M14 26l8 8M10 38l6-6"})],
+    moon: s => [s("path", {class: "fillc", d: "M30 8a16 16 0 1 0 10 26A13 13 0 0 1 30 8z"}), s("circle", {cx: 36, cy: 14, r: 2, class: "fillc"})]
+  };
+
+  function art(c, a) {
+    const draw = ART[a.art] || ART.sun;
+    return c.svg("svg", {viewBox: "0 0 48 48", width: "48", height: "48", class: "ach-art", "aria-hidden": "true"},
+      c.svg("circle", {cx: 24, cy: 24, r: 22, class: "ring"}), draw(c.svg));
+  }
+
+  function badge(c, a) {
+    const p = a.progress;
+    const status = a.earned ? `Earned${a.by ? " by " + a.by : ""}${a.at ? ", " + c.ago(a.at) + " ago" : ""}${a.detail ? " · " + a.detail : ""}`
+      : p ? `Locked · ${p.value}/${p.goal}` : "Locked";
+    let meter = null;
+    if (!a.earned && p) {
+      const fill = c.h("i");
+      fill.classList.add("width-" + Math.round(Math.max(0, Math.min(100, 100 * p.value / Math.max(1, p.goal)))));
+      meter = c.h("div", {class: "ach-meter", role: "meter", "aria-label": `${a.name} progress`, "aria-valuemin": "0", "aria-valuemax": String(p.goal), "aria-valuenow": String(p.value)}, fill);
+    }
+    return c.h("div", {class: "ach " + (a.earned ? "earned" : "locked"), "data-id": a.id},
+      art(c, a), c.h("div", {class: "ach-body"}, c.h("b", {text: a.name}), c.h("span", {text: a.description}), meter, c.h("small", {text: status})));
+  }
+
+  views.push({
+    id: "achievements",
+    endpoint: "achievements",
+    label: {raid: "Feats", plain: "Achievements"},
+    optIn: "achievements",
+    render(c, d, pane) {
+      const titles = Object.entries(d.titles || {});
+      c.setKids(pane, [
+        c.h("div", {class: "view-head"}, c.h("h2", null, c.raid ? "Feats" : "Achievements", c.raid && c.raidSub ? c.raidSub("Achievements") : null),
+          c.h("p", {class: "cls", text: `${d.incomplete_history ? "Incomplete history (latest sequence " + d.last + "). " : ""}${d.earned} of ${d.total} earned, from recorded events only. Turn them off in Settings.`})),
+        titles.length ? c.h("section", {class: "titles", "aria-label": "Titles earned"}, c.h("h3", {text: "Titles earned"}),
+          c.h("ul", null, titles.map(([who, title]) => c.h("li", null, c.h("b", {text: who}), " " + title)))) : null,
+        c.h("div", {class: "achs"}, (d.achievements || []).map(a => badge(c, a)))], JSON.stringify([d, c.theme, Math.floor(Date.now() / 60000)]));
+    }
+  });
+})();

raidlock/web/bosses/view.css

@@ -0,0 +1,19 @@
+.bosses,.bags,.drops{list-style:none;margin:0;padding:0}
+.bosses,.bags{display:grid;grid-template-columns:repeat(auto-fill,minmax(min(100%,280px),1fr));gap:10px}
+.boss,.bag{background:var(--panel);border:1px solid var(--edge);border-radius:12px;padding:10px;min-width:0;display:flex;flex-direction:column;gap:6px;overflow-wrap:anywhere;font-size:14px}
+.boss{border-left:5px solid var(--blocked)}
+.boss.slain{border-left-color:var(--done)}
+.boss-head{display:flex;flex-direction:column;gap:2px;min-width:0}
+.boss-head b{font-size:14px;color:var(--ink)}
+.boss.slain .boss-head b{text-decoration:line-through}
+.boss-hp{height:12px;border-radius:6px;background:var(--pill);border:1px solid var(--edge);overflow:hidden}
+.boss-hp i{display:block;height:100%;background:var(--blocked);transition:width .6s ease-out}
+.boss-note{margin:0;font-size:14px;color:var(--muted)}
+.loot-head{margin:16px 0 8px;font-size:15px;color:var(--accent)}
+.drops{display:flex;flex-direction:column;gap:6px}
+.drop{display:flex;flex-direction:column;gap:1px;padding:4px 8px;border-left:4px solid var(--muted);background:var(--pill);border-radius:6px}
+.drop-name{font-weight:700;color:var(--ink)}
+.drop.r1{border-left-color:var(--done)}
+.drop.r2{border-left-color:var(--todo)}
+.drop.r3{border-left-color:var(--review)}
+.drop.r4{border-left-color:var(--accent)}

raidlock/web/bosses/view.js

@@ -0,0 +1,46 @@
+"use strict";
+(function () {
+  const views = window.RaidlockViews = window.RaidlockViews || [];
+  const BAG_CAP = 12;
+
+  function boss(c, b) {
+    const fill = c.h("i");
+    fill.classList.add("width-" + Math.max(0, Math.min(100, b.hp)));
+    const left = b.slain ? "slain" : `${b.open} of ${b.total} quests still open`;
+    return c.h("li", {class: "boss" + (b.slain ? " slain" : ""), "data-id": b.id},
+      c.h("div", {class: "boss-head"}, c.h("b", {text: b.title}), c.h("span", {class: "cls", text: `${b.id} · ${b.dependents} quests wait on it`})),
+      c.h("div", {class: "boss-hp", role: "meter", "aria-label": `${b.title} HP`, "aria-valuemin": "0", "aria-valuemax": "100",
+        "aria-valuenow": String(b.hp), "aria-valuetext": `${b.hp}%, ${left}`}, fill),
+      b.slain ? c.h("p", {class: "boss-note slain-at"}, "Slain ", b.slain_at) : c.h("p", {class: "boss-note", text: `HP ${b.hp}% · ${left}`}));
+  }
+
+  function bag(c, g) {
+    return c.h("li", {class: "bag", "data-agent": g.agent}, c.h("b", {text: g.agent}),
+      c.h("ul", {class: "drops"}, g.items.map(i => c.h("li", {class: `drop r${i.tier}`, "data-card": i.card},
+        c.h("span", {class: "drop-name", text: i.item}), c.h("span", {class: "cls", text: `${i.rarity} · ${i.title}`})))));
+  }
+
+  views.push({
+    id: "bosses",
+    endpoint: "bosses",
+    label: {raid: "Boss board", plain: "Big quests"},
+    raidOnly: true,
+    render(c, d, pane) {
+      const bosses = d.bosses || [], bags = d.bags || [];
+      const drops = bags.reduce((n, g) => n + g.items.length, 0);
+      const best = g => Math.max(...g.items.map(i => i.tier));
+      const ranked = bags.slice().sort((a, b) => best(b) - best(a) || b.items.length - a.items.length || a.agent.localeCompare(b.agent));
+      c.setKids(pane, [
+        c.h("div", {class: "view-head"}, c.h("h2", null, "Boss board", c.raidSub ? c.raidSub("Big quests and loot") : null),
+          c.h("p", {class: "cls", text: `A quest that ${d.boss_dependents} or more others wait on is a boss. Its HP is the share of it and its dependents still open. Every finished quest drops one item for the agent who closed it.`})),
+        bosses.length ? c.h("ul", {class: "bosses"}, bosses.map(b => boss(c, b)))
+          : c.h("p", {class: "empty", text: `No bosses roam this realm yet. A quest becomes a boss once ${d.boss_dependents} others wait on it, or when the raid leader names it one.`}),
+        c.h("h3", {class: "loot-head", text: `Loot bags · ${drops} ${drops === 1 ? "drop" : "drops"}`}),
+        bags.length ? c.h("ul", {class: "bags"}, ranked.slice(0, BAG_CAP).map(g => bag(c, g)))
+          : c.h("p", {class: "empty", text: "The bags are empty. Turn in a quest to earn the first drop."}),
+        ranked.length > BAG_CAP ? c.h("details", {class: "more-bags"}, c.h("summary", {text: `Show all ${ranked.length} bags`}),
+          c.h("ul", {class: "bags"}, ranked.slice(BAG_CAP).map(g => bag(c, g)))) : null],
+        JSON.stringify([d, c.theme]));
+    }
+  });
+})();

raidlock/web/cli.py

@@ -0,0 +1,90 @@
+import os
+import webbrowser
+
+from raidlock.core import find_board_dir
+from raidlock.core.errors import Precondition
+
+HOSTS = ("127.0.0.1", "0.0.0.0")
+
+
+def check_host(host, env=None):
+    env = os.environ if env is None else env
+    if host != HOSTS[0] and env.get("RAIDLOCK_SANDBOX") != "container":
+        raise Precondition(
+            f"--host {host} is allowed only inside the raidlock container image",
+            hint="raidlock ui   (binds 127.0.0.1)",
+        )
+    return host
+
+
+def setup(parser):
+    parser.add_argument("--port", type=int, default=8765, help="port on 127.0.0.1 (default 8765)")
+    parser.add_argument(
+        "--host",
+        choices=HOSTS,
+        default=HOSTS[0],
+        help="bind address; 0.0.0.0 only inside the raidlock container image",
+    )
+    parser.add_argument("--only", action="store_true", help="show only this board, not every registered workspace")
+    parser.add_argument("--open", action="store_true", help="open the page in your browser")
+
+
+def handler(ctx, args):
+    from .server import make_server
+
+    host = check_host(getattr(args, "host", "127.0.0.1"))
+    here = None
+    try:
+        here = find_board_dir(args.board)
+    except Precondition:
+        if args.board or args.only:
+            raise
+    if here:
+        from raidlock.core.migrate import reject_legacy
+
+        reject_legacy(here)
+    single = here if (args.only or args.board) else None
+    try:
+        srv = make_server(port=args.port, single=single, extra=None if single else here, host=host)
+    except OSError as e:
+        raise Precondition(
+            f"port {args.port} is busy ({e.strerror})", hint=f"raidlock ui --port {args.port + 1}"
+        ) from e
+    if here:
+        caller = ctx.caller()
+        if caller.is_lead:
+            import time
+
+            previous = srv.service_actions
+            renewed = [time.monotonic()]
+
+            def heartbeat():
+                previous()
+                if time.monotonic() - renewed[0] >= 30:
+                    from raidlock.core.errors import RaidlockError
+
+                    try:
+                        ctx.board.lead_heartbeat(caller)
+                    except RaidlockError as exc:
+                        print(f"raidlock ui: lead heartbeat stopped: {exc}", flush=True)
+                        srv.service_actions = previous
+                    renewed[0] = time.monotonic()
+
+            srv.service_actions = heartbeat
+    port = srv.server_address[1]
+    url = f"http://127.0.0.1:{port}/"
+    where = os.path.basename(os.path.dirname(single)) if single else "every registered workspace"
+    print(f"raidlock ui: {where} at {url}\nNext: open {url} (Ctrl+C stops it)", flush=True)
+    if args.open:
+        webbrowser.open(url)
+    try:
+        srv.serve_forever()
+    except KeyboardInterrupt:
+        pass
+    finally:
+        srv.server_close()
+    return {"url": url}, ""
+
+
+def register_cli(add_command):
+    add_command("ui", "open the live board in your browser", setup, handler)