feat: live action monitor + install themes from plain CSS

LIVE ACTIONS — you can now watch everything the agents do on this machine, as it
happens, from the dashboard. A 👁 toggle in the header turns streaming on or off
(persisted), and a Live Actions view shows the feed: every shell command, web
read, dashboard change, config write, skill install and blocked attempt, with the
actor that asked for it, colour-coded, filterable to commands only.

Two things made it actually useful rather than a log dump:

- Cursor-based streaming. GET /api/actions?since=<id> returns only rows newer
  than what the client holds, so polling never replays and switching views
  doesn't duplicate. brain.audit_since()/audit_max_id() back it.
- In-flight tracking. The audit log only records FINISHED actions, so a
  long-running command was invisible until it ended — exactly when you least
  want to be blind. tools.inflight() registers work as it starts, so a running
  command shows immediately with a live elapsed timer, and /api/exec and
  /api/web both register too.

Verified in-browser: toggle flips and persists, 26 rows rendered with blocked
attempts highlighted, a new action streamed in 26 -> 28 with no refresh, and a
`sleep 5` appeared in the running panel at 1.2s elapsed while still executing.

THEMES FROM CSS — the installer took a JSON blob of variables, but themes get
shared as CSS: people paste a `:root{--accent:…}` block from a gist, not JSON.
It now accepts either. CSS is parsed for custom properties, the name/label come
from `/* name: … */` comments, and light-vs-dark is derived from --bg's relative
luminance instead of asking. JSON keeps working unchanged.

Verified: an 11-variable `:root` block installed as "Neon Ice", applied instantly
(#caa63f -> #00e5ff), landed in the theme dropdown, dark correctly detected — and
the JSON path still installs.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: ZD Studios

aios_brain.py

@@ -199,6 +199,22 @@ def audit_tail(n: int = 100) -> list[dict]:
         return [dict(r) for r in rows]
 
 
+def audit_since(after_id: int = 0, limit: int = 200) -> list[dict]:
+    """Rows newer than a cursor, oldest-first — for a live stream that never
+    re-sends what the client already has. `id` is the cursor."""
+    with _lock:
+        rows = db().execute(
+            "SELECT * FROM audit WHERE id > ? ORDER BY id ASC LIMIT ?",
+            (int(after_id or 0), limit)).fetchall()
+        return [dict(r) for r in rows]
+
+
+def audit_max_id() -> int:
+    with _lock:
+        r = db().execute("SELECT COALESCE(MAX(id), 0) m FROM audit").fetchone()
+        return int(r["m"] if r else 0)
+
+
 # --------------------------------------------------------------------------- #
 # Task Brain — cron + interval + agent prompts + background CLI, one scheduler #
 # --------------------------------------------------------------------------- #

aios_hub.py

@@ -1500,6 +1500,17 @@ def do_GET(self):
         elif self.path == "/api/activity":
             self._send(200, activity(self._query.get("turn", [""])[0],
                                      int(self._query.get("since", ["0"])[0] or 0)))
+        elif self.path == "/api/actions":
+            # Cursor-based so the live monitor never re-sends what it already has.
+            since = int(self._query.get("since", ["0"])[0] or 0)
+            fresh = brain.audit_since(since, 300)
+            self._send(200, {
+                "actions": fresh,
+                "cursor": (fresh[-1]["id"] if fresh else max(since, brain.audit_max_id())),
+                "running": tools.inflight(),
+                "full_control": tools.full_control(),
+                "guardrails": tools.guardrails_on(),
+            })
         elif self.path == "/api/swarm":
             self._send(200, {**swarm_state(), "enabled": swarm_enabled()})
         elif self.path == "/api/dashboard":
@@ -1729,6 +1740,7 @@ def do_POST(self):
             # an agent never has to hand-roll scraping.
             op = (payload.get("op") or "fetch").lower()
             q = payload.get("url") or payload.get("query") or payload.get("target") or ""
+            _tr = tools._inflight_add(payload.get("by", "agent"), "web", f"{op} {q}"[:200])
             try:
                 if op in ("youtube", "yt"):
                     r = web.youtube(q, want_transcript=payload.get("transcript", True),
@@ -1745,6 +1757,8 @@ def do_POST(self):
                     r = web.fetch(q, max_chars=int(payload.get("max_chars", 20000)))
             except Exception as e:
                 r = {"ok": False, "error": f"{op} failed: {e}"}
+            finally:
+                tools._inflight_done(_tr)
             brain.audit(payload.get("by", "agent"), "web." + op,
                         f"{q[:120]} -> ok={r.get('ok')}")
             self._send(200, r)

aios_tools.py

@@ -21,6 +21,7 @@
 import platform
 import shutil
 import subprocess
+import threading
 import time
 from pathlib import Path
 
@@ -49,6 +50,35 @@ def exec_timeout() -> int:
 # --------------------------------------------------------------------------- #
 # Shell — the capability that makes "full control" mean something              #
 # --------------------------------------------------------------------------- #
+# What's executing right now. The audit log only records finished actions, so a
+# long-running command would be invisible in the live monitor until it ended —
+# which is exactly when you most want to see it.
+_INFLIGHT: dict[int, dict] = {}
+_INFLIGHT_LOCK = threading.Lock()
+_INFLIGHT_SEQ = [0]
+
+
+def inflight() -> list[dict]:
+    now = time.time()
+    with _INFLIGHT_LOCK:
+        return [{**v, "elapsed": round(now - v["started"], 1)}
+                for v in sorted(_INFLIGHT.values(), key=lambda x: x["started"])]
+
+
+def _inflight_add(actor: str, kind: str, detail: str) -> int:
+    with _INFLIGHT_LOCK:
+        _INFLIGHT_SEQ[0] += 1
+        i = _INFLIGHT_SEQ[0]
+        _INFLIGHT[i] = {"id": i, "actor": actor, "kind": kind,
+                        "detail": str(detail)[:400], "started": time.time()}
+        return i
+
+
+def _inflight_done(i: int):
+    with _INFLIGHT_LOCK:
+        _INFLIGHT.pop(i, None)
+
+
 def shell(cmd: str, actor: str = "brain", cwd: str | None = None,
           timeout: int | None = None) -> dict:
     """Run a command as the user who installed AIOS. Audited, guardrailed, bounded."""
@@ -70,6 +100,7 @@ def shell(cmd: str, actor: str = "brain", cwd: str | None = None,
     shell_cmd = (["powershell", "-NoProfile", "-NonInteractive", "-Command", cmd] if IS_WIN
                  else ["/bin/bash", "-lc", cmd])
     started = time.time()
+    tracker = _inflight_add(actor, "shell", cmd)   # visible while it runs
     try:
         p = subprocess.run(shell_cmd, cwd=cwd or str(ROOT), capture_output=True, text=True,
                            timeout=timeout or exec_timeout(), errors="replace")
@@ -81,6 +112,8 @@ def shell(cmd: str, actor: str = "brain", cwd: str | None = None,
     except Exception as e:
         brain.audit(actor, "shell.error", f"{cmd} :: {e}", ok=False)
         return {"ok": False, "code": -1, "out": "", "err": str(e), "blocked": False}
+    finally:
+        _inflight_done(tracker)
 
     brain.audit(actor, "shell", f"$ {cmd}\n(exit {code}, {time.time()-started:.1f}s)", ok=code == 0)
     return {"ok": code == 0, "code": code, "out": out[-8000:], "err": err[-4000:], "blocked": False}