lonoboard 0.1.0__py3-none-any.whl

lonoboard/__init__.py

@@ -0,0 +1,3 @@
+"""lonoboard: a live dashboard for the machines running your AI models, drawn like a 1990s ANSI BBS."""
+
+__version__ = "0.1.0"

lonoboard/__main__.py

@@ -0,0 +1,3 @@
+from lonoboard.cli import main
+
+main()

lonoboard/board/__init__.py

@@ -0,0 +1,2 @@
+"""The board: lonoboard's text-mode application, served over telnet and to the web terminal."""
+from lonoboard.board.session import Board, Session  # noqa: F401

lonoboard/board/hub.py

@@ -0,0 +1,290 @@
+"""Shared data for sessions.
+
+A hub holds what every session on a board renders from: the latest snapshot, telemetry history,
+recent requests, usage, the event log and fleet summaries. Hub is fed by this machine's
+collector; RemoteHub by another machine's lonoboard API, so a session can view any board in the fleet
+just by switching hubs.
+"""
+import threading
+import time
+from collections import deque
+
+from lonoboard.board.model import expected, healthy, status
+from lonoboard.board.render import SVC_COLORS, dur
+from lonoboard.util import get_json, stream_chat
+
+HISTORY_LEN = 450
+
+
+class BaseHub:
+    remote = False
+    label = None
+
+    def __init__(self):
+        self.cond = threading.Condition()
+        self.sessions = set()
+        self.data = None
+        self.history = deque(maxlen=HISTORY_LEN)
+        self.callers, self.usage, self.fleet = [], None, {}
+        self.events = deque(maxlen=300)
+        self.colors = {}
+        self.busy_prev, self.busy_start = {}, {}
+        self.last_t = 0
+        self.wake = threading.Event()
+        self.force = False
+        self.started = time.time()
+        self.thread = None
+        self.error = None
+        self.auth = {}                      # Authorization header for password-protected peers
+
+    @property
+    def hist(self):
+        return list(self.history)
+
+    def color(self, name):
+        if name not in self.colors:
+            self.colors[name] = SVC_COLORS[len(self.colors) % len(SVC_COLORS)]
+        return self.colors[name]
+
+    def join(self, sess):
+        with self.cond:
+            self.sessions.add(sess)
+        self.force = True
+        self.wake.set()
+        self.ensure_running()
+
+    def leave(self, sess):
+        with self.cond:
+            self.sessions.discard(sess)
+
+    def notify(self):
+        with self.cond:
+            for s in self.sessions:
+                s.dirty.set()
+
+    def ensure_running(self):
+        if not self.thread or not self.thread.is_alive():
+            self.thread = threading.Thread(target=self.run, daemon=True, name=f"lonoboard-{type(self).__name__}")
+            self.thread.start()
+
+    def log(self, segs, t=None):
+        self.events.append((t or time.time(), segs))
+
+    def events_json(self):
+        return [[t, [list(s) for s in segs]] for t, segs in self.events]
+
+    # --- turning snapshots into events ---
+    def ingest(self, d, extend_history=True):
+        for s in d["services"]:
+            self.color(s["name"])
+        pts = d.pop("history", [])
+        if extend_history:
+            self.history.extend(pts)
+        for p in pts:
+            names = set(p.get("busy", {})) | set(self.busy_prev)
+            for n in sorted(names):
+                b, was = p.get("busy", {}).get(n, 0), self.busy_prev.get(n, 0)
+                if not was and b:
+                    self.busy_start[n] = p["t"]
+                    self.log([(n, self.color(n)), (f" started generating · {b} slot{'s' if b > 1 else ''} busy", 7)], p["t"])
+                elif was and not b:
+                    self.log([(n, self.color(n)), (f' finished after {dur(p["t"] - self.busy_start.get(n, p["t"]))}', 7)], p["t"])
+                elif b > was:
+                    self.log([(n, self.color(n)), (f" now {b} slots busy", 7)], p["t"])
+                self.busy_prev[n] = b
+        if pts:
+            self.last_t = pts[-1]["t"]
+        if self.data is None:
+            self.log([("monitoring started", 10), (f' on {d["host"]["board"]["name"]} · {len(healthy(d))} of {len(expected(d))} services healthy', 7)])
+        else:
+            self.diff(self.data, d)
+        self.data = d
+
+    def diff(self, a, b):
+        hist = self.hist
+        prev = {s["name"]: s for s in a["services"]}
+        bucket = lambda k: "ok" if k == "busy" else k
+        for s in b["services"]:
+            p = prev.get(s["name"])
+            n = (s["name"], self.color(s["name"]))
+            if not p:
+                self.log([("new service ", 7), n, (f' on :{s["port"]}', 7)])
+                continue
+            k0, k1 = status(p, hist), status(s, hist)
+            if bucket(k0[0]) != bucket(k1[0]):
+                if k1[0] in ("ok", "busy"):
+                    self.log([n, (" is back online", 10)])
+                else:
+                    self.log([n, (f' is {k1[1] or "down"}', 12)])
+            if (s["run"].get("restarts") or 0) > (p["run"].get("restarts") or 0):
+                self.log([n, (f' restarted (#{s["run"]["restarts"]})', 14)])
+        for name in set(prev) - {s["name"] for s in b["services"]}:
+            self.log([("service ", 7), (name, self.color(name)), (" went away", 12)])
+
+
+class Hub(BaseHub):
+    """This machine's board, fed by the collector (or the demo)."""
+
+    def __init__(self, collector):
+        super().__init__()
+        self.collector = collector
+
+    @property
+    def hist(self):
+        return list(self.collector.history)
+
+    def run(self):
+        due = {"snap": 0, "callers": 0, "usage": 0, "fleet": 0}
+        every = {"callers": 10, "usage": 60, "fleet": 15}
+        while True:
+            now = time.time()
+            watching = bool(self.sessions)
+            if self.force:
+                due = dict.fromkeys(due, 0)
+                self.force = False
+            snap_every = 2.5 if watching else 15
+            try:
+                if now >= due["snap"]:
+                    self.ingest(self.collector.snapshot(since=self.last_t, max_age=1.0), extend_history=False)
+                    due["snap"] = now + snap_every
+                if watching:
+                    for k, fn in (("callers", self.load_callers), ("usage", self.load_usage), ("fleet", self.load_fleet)):
+                        if now >= due[k]:
+                            fn()
+                            due[k] = now + every[k]
+            except Exception as e:  # noqa: BLE001 - keep the board alive whatever a source does
+                self.log([("collector error: ", 12), (str(e)[:80], 7)])
+            self.notify()
+            self.wake.wait(max(0.2, min(due.values()) - time.time()) if watching else snap_every)
+            self.wake.clear()
+
+    def load_callers(self):
+        self.callers = self.collector.callers(30)
+
+    def load_usage(self):
+        self.usage = self.collector.usage_summary(24)
+
+    def load_fleet(self):
+        for p in (self.data or {}).get("fleet", []):
+            before = self.fleet.get(p["name"])
+            auth = self.auth if p.get("source") == "config" else {}      # the password only goes to listed peers
+            summary = get_json(f"{p['url']}/api/summary", 3, auth)
+            self.fleet[p["name"]] = dict(summary, ok=True) if isinstance(summary, dict) else {"ok": False}
+            after = self.fleet[p["name"]]
+            if before is not None and before.get("ok") != after.get("ok"):
+                self.log([(p["name"], 15), (" is reachable", 10) if after.get("ok") else (" is unreachable", 12)])
+
+    def logs(self, name, n=30):
+        return self.collector.logs(name, n)
+
+    def chat_stream(self, service, model, messages, cancelled):
+        return self.collector.chat_stream(service, model, messages, cancelled)
+
+
+class RemoteHub(BaseHub):
+    """Another machine's board, read through its lonoboard API."""
+    remote = True
+
+    def __init__(self, url, name):
+        super().__init__()
+        self.url, self.label = url.rstrip("/"), name
+
+    def run(self):
+        due = {"snap": 0, "callers": 0, "usage": 0, "events": 0}
+        every = {"snap": 2.5, "callers": 10, "usage": 60, "events": 5}
+        idle_since = None
+        while True:
+            if not self.sessions:                  # nobody's looking: stop after a while
+                idle_since = idle_since or time.time()
+                if time.time() - idle_since > 60:
+                    return
+            else:
+                idle_since = None
+            if self.force:
+                due = dict.fromkeys(due, 0)
+                self.force = False
+            now = time.time()
+            try:
+                if now >= due["snap"]:
+                    d = get_json(f"{self.url}/api?since={self.last_t}", 5, self.auth)
+                    self.error = None if d is not None else f"can't reach {self.label}"
+                    if d is not None:
+                        for s in d["services"]:
+                            self.color(s["name"])
+                        pts = d.pop("history", [])
+                        self.history.extend(pts)
+                        self.last_t = pts[-1]["t"] if pts else self.last_t
+                        self.data = d
+                    due["snap"] = now + every["snap"]
+                if now >= due["callers"]:
+                    self.callers = (get_json(f"{self.url}/api/callers", 5, self.auth) or {}).get("callers") or self.callers
+                    due["callers"] = now + every["callers"]
+                if now >= due["usage"]:
+                    self.usage = get_json(f"{self.url}/api/usage", 5, self.auth) or self.usage
+                    due["usage"] = now + every["usage"]
+                if now >= due["events"]:
+                    ev = (get_json(f"{self.url}/api/events", 5, self.auth) or {}).get("events")
+                    if ev is not None:
+                        self.events = deque(((t, [tuple(s) for s in segs]) for t, segs in ev), maxlen=300)
+                    due["events"] = now + every["events"]
+            except Exception as e:  # noqa: BLE001
+                self.error = str(e)[:80]
+            self.notify()
+            self.wake.wait(max(0.2, min(due.values()) - time.time()))
+            self.wake.clear()
+
+    def logs(self, name, n=30):
+        return (get_json(f"{self.url}/api/logs/{name}?n={n}", 5, self.auth) or {}).get("lines") or []
+
+    def chat_stream(self, service, model, messages, cancelled):
+        sv = next((s for s in (self.data or {}).get("services", []) if s["name"] == service), None)
+        urls = [u for u in ((sv or {}).get("urls") or {}).get("remote", []) if u.startswith("http")]
+        if not sv or not sv.get("chat") or not urls:
+            return iter([("error", f"{service} on {self.label} isn't reachable for chat from here")])
+        return stream_chat(urls[0], model, messages, cancelled=cancelled)
+
+
+class Chat:
+    """One conversation with one model, streamed through a hub."""
+
+    def __init__(self, service, model):
+        self.service, self.model = service, model
+        self.msgs = []          # {'role', 'content', 'reasoning', 'stats', 'error', 't0', 'think_s'}
+        self.busy = False
+        self.cancel = False
+        self.scroll = 0         # lines up from the bottom
+
+    @property
+    def name(self):
+        return self.service if not self.model or self.model == self.service else f"{self.service} · {self.model}"
+
+    def send(self, text, sess):
+        self.msgs.append({"role": "user", "content": text})
+        reply = {"role": "assistant", "content": "", "reasoning": "", "stats": None, "error": None,
+                 "t0": time.time(), "think_s": None}
+        self.msgs.append(reply)
+        self.busy, self.cancel, self.scroll = True, False, 0
+        threading.Thread(target=self._stream, args=(reply, sess.hub, sess), daemon=True).start()
+
+    def _stream(self, reply, hub, sess):
+        history = [{"role": m["role"], "content": m["content"]} for m in self.msgs[:-1] if m["content"]]
+        last_paint = 0
+        for kind, value in hub.chat_stream(self.service, self.model, history, lambda: self.cancel or not sess.alive):
+            if kind == "reasoning":
+                reply["reasoning"] += value
+            elif kind == "content":
+                if reply["think_s"] is None and reply["reasoning"]:
+                    reply["think_s"] = time.time() - reply["t0"]
+                reply["content"] += value
+            elif kind == "stats":
+                reply["stats"] = value
+            elif kind == "error":
+                reply["error"] = value
+                break
+            if time.time() - last_paint > 0.06:
+                sess.dirty.set()
+                last_paint = time.time()
+        if reply["think_s"] is None and reply["reasoning"]:
+            reply["think_s"] = time.time() - reply["t0"]
+        self.busy = False
+        sess.dirty.set()

lonoboard/board/logo.py

@@ -0,0 +1,109 @@
+"""The board's logo: hand-drawn 8x10 pixel glyphs rendered as half-block cells, with
+dithered shading and an outside-only drop shadow."""
+
+# Logo: per-pixel ramps (used where a cell holds one lit pixel) and per-cell ramps with
+# ░▒▓ shading (used where both pixels of a cell are lit) - the dithered blends ANSI
+# artists used between colours, instead of hard bands.
+PX_A = [15, 15, 11, 11, 11, 3, 3, 9, 9, 1]
+CELL_A = [('█', 15, 0), ('▓', 11, 15), ('▒', 3, 11), ('▒', 9, 3), ('▓', 1, 9)]
+PX_B = [15, 15, 14, 14, 14, 12, 12, 4, 4, 4]
+CELL_B = [('█', 15, 0), ('▓', 14, 15), ('▒', 12, 14), ('▓', 4, 12), ('█', 4, 0)]
+PX_D = [7, 7, 7, 7, 7, 7, 8, 8, 8, 8]
+CELL_D = [('█', 7, 0), ('█', 7, 0), ('▓', 8, 7), ('█', 8, 0), ('█', 8, 0)]
+SHADOW = 8
+
+# 8x10 glyphs, two-pixel strokes; every hostname character gets one (lowercase is drawn as upper)
+G = {
+    'A': ['.######.', '########', '##....##', '##....##', '########', '########', '##....##', '##....##', '##....##', '##....##'],
+    'B': ['#######.', '########', '##....##', '##....##', '#######.', '#######.', '##....##', '##....##', '########', '#######.'],
+    'C': ['.######.', '########', '##......', '##......', '##......', '##......', '##......', '##......', '########', '.######.'],
+    'D': ['######..', '#######.', '##...###', '##....##', '##....##', '##....##', '##....##', '##...###', '#######.', '######..'],
+    'E': ['########', '########', '##......', '##......', '######..', '######..', '##......', '##......', '########', '########'],
+    'F': ['########', '########', '##......', '##......', '######..', '######..', '##......', '##......', '##......', '##......'],
+    'G': ['.######.', '########', '##......', '##......', '##..####', '##..####', '##....##', '##....##', '########', '.######.'],
+    'H': ['##....##', '##....##', '##....##', '##....##', '########', '########', '##....##', '##....##', '##....##', '##....##'],
+    'I': ['######', '######', '..##..', '..##..', '..##..', '..##..', '..##..', '..##..', '######', '######'],
+    'J': ['......##', '......##', '......##', '......##', '......##', '......##', '##....##', '##....##', '########', '.######.'],
+    'K': ['##...###', '##..###.', '##.###..', '#####...', '####....', '#####...', '##.###..', '##..###.', '##...###', '##....##'],
+    'L': ['##......', '##......', '##......', '##......', '##......', '##......', '##......', '##......', '########', '########'],
+    'M': ['##....##', '###..###', '########', '##.##.##', '##.##.##', '##....##', '##....##', '##....##', '##....##', '##....##'],
+    'N': ['##....##', '###...##', '####..##', '##.##.##', '##..####', '##...###', '##....##', '##....##', '##....##', '##....##'],
+    'O': ['.######.', '########', '##....##', '##....##', '##....##', '##....##', '##....##', '##....##', '########', '.######.'],
+    'P': ['#######.', '########', '##....##', '##....##', '########', '#######.', '##......', '##......', '##......', '##......'],
+    'Q': ['.######.', '########', '##....##', '##....##', '##....##', '##....##', '##..####', '##...###', '########', '.#######'],
+    'R': ['#######.', '########', '##....##', '##....##', '########', '#######.', '##..##..', '##...##.', '##....##', '##....##'],
+    'S': ['.######.', '########', '##......', '##......', '#######.', '.#######', '......##', '......##', '########', '.######.'],
+    'T': ['########', '########', '...##...', '...##...', '...##...', '...##...', '...##...', '...##...', '...##...', '...##...'],
+    'U': ['##....##', '##....##', '##....##', '##....##', '##....##', '##....##', '##....##', '##....##', '########', '.######.'],
+    'V': ['##....##', '##....##', '##....##', '##....##', '##....##', '###..###', '.##..##.', '.######.', '..####..', '...##...'],
+    'W': ['##....##', '##....##', '##....##', '##....##', '##.##.##', '##.##.##', '########', '########', '###..###', '##....##'],
+    'X': ['##....##', '###..###', '.######.', '..####..', '...##...', '...##...', '..####..', '.######.', '###..###', '##....##'],
+    'Y': ['##....##', '##....##', '###..###', '.######.', '..####..', '...##...', '...##...', '...##...', '...##...', '...##...'],
+    'Z': ['########', '########', '.....###', '....###.', '...###..', '..###...', '.###....', '###.....', '########', '########'],
+    '-': ['......', '......', '......', '......', '######', '######', '......', '......', '......', '......'],
+    '.': ['..', '..', '..', '..', '..', '..', '..', '..', '##', '##'],
+    '_': ['........', '........', '........', '........', '........', '........', '........', '........', '########', '########'],
+    '0': ['.######.', '########', '##...###', '##..####', '##.##.##', '####..##', '###...##', '##....##', '########', '.######.'],
+    '1': ['...##...', '.####...', '#####...', '...##...', '...##...', '...##...', '...##...', '...##...', '########', '########'],
+    '2': ['.######.', '########', '##....##', '......##', '.######.', '#######.', '##......', '##......', '########', '########'],
+    '3': ['#######.', '########', '......##', '......##', '.######.', '.#######', '......##', '......##', '########', '#######.'],
+    '4': ['##....##', '##....##', '##....##', '##....##', '########', '.#######', '......##', '......##', '......##', '......##'],
+    '5': ['########', '########', '##......', '##......', '#######.', '.#######', '......##', '......##', '########', '#######.'],
+    '6': ['.######.', '#######.', '##......', '##......', '#######.', '########', '##....##', '##....##', '########', '.######.'],
+    '7': ['########', '########', '......##', '.....##.', '....##..', '...##...', '...##...', '...##...', '...##...', '...##...'],
+    '8': ['.######.', '########', '##....##', '##....##', '.######.', '########', '##....##', '##....##', '########', '.######.'],
+    '9': ['.######.', '########', '##....##', '##....##', '########', '.#######', '......##', '......##', '.#######', '.######.'],
+}
+
+# ---------- the logo ----------
+
+def logo(parts, gap=2):
+    """Hand-drawn 8x10 glyphs -> pixel grid with an outside-only drop shadow."""
+    glyphs = [(G[ch], ramp) for text, ramp in parts for ch in text.upper()]
+    w = sum(len(g[0]) + gap for g, _ in glyphs) - gap + 1
+    h = 11
+    P = [[None] * w for _ in range(h + 1)]
+    x = 0
+    for g, ramp in glyphs:
+        for y, row in enumerate(g):
+            for i, c in enumerate(row):
+                if c == '#':
+                    P[y][x + i] = ('L', ramp, y)
+        x += len(g[0]) + gap
+    # flood-fill the background from the edges so closed counters (P, A, R...) stay unshaded
+    outside = [[False] * w for _ in range(h + 1)]
+    stack = [(0, i) for i in range(w)] + [(h, i) for i in range(w)] + [(y, 0) for y in range(h + 1)] + [(y, w - 1) for y in range(h + 1)]
+    while stack:
+        y, i = stack.pop()
+        if 0 <= y <= h and 0 <= i < w and not outside[y][i] and P[y][i] is None:
+            outside[y][i] = True
+            stack += [(y + 1, i), (y - 1, i), (y, i + 1), (y, i - 1)]
+    for y in range(h):
+        for i in range(w - 1):
+            if P[y][i] and P[y][i][0] == 'L' and P[y + 1][i + 1] is None and outside[y + 1][i + 1]:
+                P[y + 1][i + 1] = ('S',)
+    return w, h + 1, P
+
+
+RAMPS = {'A': (PX_A, CELL_A), 'B': (PX_B, CELL_B), 'D': (PX_D, CELL_D)}
+
+
+def draw_logo(s, x0, y0, px):
+    w, h, P = px
+    for cy in range(h // 2):
+        for cx in range(w):
+            t, b = P[cy * 2][cx], P[cy * 2 + 1][cx]
+            if t is None and b is None:
+                continue
+            if t and b and t[0] == 'L' and b[0] == 'L' and t[1] == b[1]:
+                ch, f, bg = RAMPS[t[1]][1][cy]            # fully lit cell: dithered blend
+                s.put(x0 + cx, y0 + cy, ch, f, bg)
+                continue
+            # a lone lit pixel takes the dominant colour of its row's blend, so edges match the fill
+            col = lambda p: SHADOW if p[0] == 'S' else RAMPS[p[1]][1][p[2] // 2][1]
+            if t and b:
+                s.put(x0 + cx, y0 + cy, '▀', col(t), col(b))
+            elif t:
+                s.put(x0 + cx, y0 + cy, '▀', col(t))
+            else:
+                s.put(x0 + cx, y0 + cy, '▄', col(b))

lonoboard/board/model.py

@@ -0,0 +1,48 @@
+"""Rules over a snapshot: what state a service is in and which ones should be up."""
+
+
+def busy_of(sv, hist):
+    b = (sv.get("model") or {}).get("slots_busy")
+    if b is None and hist:
+        b = hist[-1].get("busy", {}).get(sv["name"], 0)
+    return b or 0
+
+
+def status(sv, hist):
+    """(kind, text): kind is busy | ok | warn | starting | bad | off."""
+    run, health = sv.get("run") or {}, sv.get("health")
+    st = run.get("state")
+    if health == "ok":
+        return ("busy", None) if busy_of(sv, hist) > 0 else ("ok", None)
+    if st in ("activating", "reloading") or health == "loading":
+        return "starting", None
+    if st == "failed":
+        return "bad", "failed"
+    if st == "active":
+        return "warn", "not responding" if health in (None, "unreachable") else str(health).lower()
+    if not run.get("manager"):            # something we only know by its URL
+        return "bad", "unreachable"
+    return ("bad", "down") if run.get("enabled") else ("off", None)
+
+
+def expected(d):
+    """Services that should be running: enabled, active, or simply listed (no manager to ask)."""
+    return [s for s in d["services"]
+            if s["run"].get("enabled") or s["run"].get("state") == "active" or not s["run"].get("manager")]
+
+
+def healthy(d):
+    return [s for s in expected(d) if s.get("health") == "ok"]
+
+
+def chat_capable(sv):
+    return bool((sv.get("chat") or {}).get("models"))
+
+
+def chat_targets(d):
+    """[(service, model)] that can be chatted with."""
+    return [(s["name"], m) for s in d["services"] for m in (s.get("chat") or {}).get("models") or []]
+
+
+def requests_today(d):
+    return sum((s.get("model") or {}).get("requests_today") or 0 for s in d["services"])