dashboard: auto-rules (thermal auto-throttle) + freeze screen snapshot + AI-Ops modules

Rules: background engine drops to Stock preset if temp stays over a settable limit; keeps a periodic desktop snapshot (last frame before a freeze) shown in the card. AI-Ops: feeds journal+freeze-log+telemetry to the local Ollama model for a diagnosis. 13 of 14 modules now functional (gamestream left).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: MTSistemi

apps/dashboard/skillfish-dashboardd

@@ -530,6 +530,111 @@ def power_schedule(action, minutes):
     return {"ok": False, "error": "azione sconosciuta"}
 
 
+# ---------------- auto rules + screen snapshot ----------------
+import urllib.request
+RULES_DEFAULT = {"enabled": True, "temp_limit": 92, "samples": 6}
+LASTFRAME = "/tmp/skillfish-lastframe.jpg"  # captured as the desktop user, so must be user-writable
+_RULES = {"hot": 0, "last_action": "", "snap_ts": 0}
+
+
+def save_conf():
+    try:
+        with open(CONF, "w") as f:
+            json.dump(CONFIG, f, indent=2)
+    except Exception:
+        pass
+
+
+def rules_cfg():
+    return {**RULES_DEFAULT, **(CONFIG.get("rules_cfg") or {})}
+
+
+def rules_loop():
+    while True:
+        try:
+            c = rules_cfg()
+            if CONFIG.get("modules", {}).get("rules") and c["enabled"]:
+                v = read_all()
+                temps = [x for x in (v.get("gpu_temp"), v.get("cpu_temp")) if isinstance(x, (int, float))]
+                t = max(temps) if temps else 0
+                if t >= c["temp_limit"]:
+                    _RULES["hot"] += 1
+                    if _RULES["hot"] >= c["samples"]:
+                        apply_preset("Stock")
+                        _RULES["hot"] = 0
+                        _RULES["last_action"] = "%s — %d°C ≥ %d°C → preset Stock applicato" % (
+                            time.strftime("%H:%M:%S"), round(t), c["temp_limit"])
+                else:
+                    _RULES["hot"] = 0
+        except Exception:
+            pass
+        time.sleep(2)
+
+
+def snapshot_loop():
+    u = CONFIG.get("user", "skillfish")
+    # keep the screen awake so the "last frame" is the real desktop, not a blanked one
+    for args in (["xset", "s", "off"], ["xset", "-dpms"]):
+        try:
+            subprocess.run(["sudo", "-u", u, "env", "DISPLAY=:0"] + args,
+                           stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=5)
+        except Exception:
+            pass
+    while True:
+        try:
+            if CONFIG.get("modules", {}).get("rules"):
+                subprocess.run(["sudo", "-u", u, "env", "DISPLAY=:0",
+                                "import", "-window", "root", "-resize", "960x", LASTFRAME],
+                               stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=12)
+                try:
+                    os.chmod(LASTFRAME, 0o644)
+                except Exception:
+                    pass
+                _RULES["snap_ts"] = int(time.time())
+        except Exception:
+            pass
+        time.sleep(20)
+
+
+# ---------------- AI-Ops (local LLM log diagnosis) ----------------
+def _ollama_models():
+    try:
+        r = subprocess.run(["docker", "exec", AI_CONTAINER, "ollama", "list"],
+                           capture_output=True, text=True, timeout=8).stdout
+        return [ln.split()[0] for ln in r.splitlines()[1:] if ln.strip()]
+    except Exception:
+        return []
+
+
+def aiops_diagnose(question):
+    if not _port_open(11434):
+        return {"ok": False, "error": "Motore AI spento: accendilo dal modulo AI."}
+    models = _ollama_models()
+    model = models[0] if models else "qwen3:14b"
+    jrn = subprocess.run(["journalctl", "-p", "warning", "-n", "60", "--no-pager", "-o", "short"],
+                         capture_output=True, text=True, timeout=8).stdout
+    try:
+        frz = open("/var/log/skillfish-freeze.log").read()[-1500:]
+    except Exception:
+        frz = "(nessun freeze registrato)"
+    v = read_all()
+    tele = "GPU %s°C / CPU %s°C, GPU %s MHz, %s W, ventola %s RPM" % (
+        v.get("gpu_temp"), v.get("cpu_temp"), v.get("gpu_freq"), v.get("gpu_power"), v.get("fan"))
+    q = question or "Analizza i log e lo stato: ci sono problemi? Causa probabile e come risolvere?"
+    prompt = ("Sei l'assistente di sistema di SkillFishOS su una scheda AMD BC-250. "
+              "Rispondi in italiano, conciso e pratico.\n\n=== Telemetria ===\n%s\n\n"
+              "=== Log freeze ===\n%s\n\n=== journalctl (warning+) ===\n%s\n\n=== Domanda ===\n%s\n" %
+              (tele, frz, jrn[-3000:], q))
+    try:
+        req = urllib.request.Request("http://127.0.0.1:11434/api/generate",
+                                     data=json.dumps({"model": model, "prompt": prompt, "stream": False}).encode(),
+                                     headers={"Content-Type": "application/json"})
+        out = json.loads(urllib.request.urlopen(req, timeout=120).read().decode())
+        return {"ok": True, "model": model, "answer": out.get("response", "").strip()}
+    except Exception as e:
+        return {"ok": False, "error": "Ollama: %s" % e}
+
+
 # ---------------- HTTP ----------------
 CONFIG = load_conf()
 _login_fails = {}  # ip -> (count, first_ts)
@@ -721,6 +826,21 @@ class Handler(BaseHTTPRequestHandler):
             if not self._guard("wol"):
                 return
             return self._json(200, wol_info())
+        if path == "/api/rules":
+            if not self._guard("rules"):
+                return
+            c = rules_cfg()
+            c["last_action"] = _RULES["last_action"]
+            c["snap_age"] = int(time.time()) - _RULES["snap_ts"] if _RULES["snap_ts"] else None
+            c["has_frame"] = os.path.isfile(LASTFRAME)
+            return self._json(200, c)
+        if path == "/api/rules/frame":
+            if not self._guard("rules"):
+                return
+            if os.path.isfile(LASTFRAME):
+                with open(LASTFRAME, "rb") as f:
+                    return self._send(200, f.read(), "image/jpeg")
+            return self._json(404, {"error": "no frame"})
         return self._json(404, {"error": "not found"})
 
     def do_POST(self):
@@ -812,6 +932,21 @@ class Handler(BaseHTTPRequestHandler):
             if not self._guard("wol"):
                 return
             return self._json(200, power_schedule(data.get("action"), data.get("minutes", 1)))
+        if path == "/api/rules":
+            if not self._guard("rules"):
+                return
+            cfg = rules_cfg()
+            if "enabled" in data:
+                cfg["enabled"] = bool(data["enabled"])
+            if "temp_limit" in data:
+                cfg["temp_limit"] = max(70, min(100, int(data["temp_limit"])))
+            CONFIG["rules_cfg"] = cfg
+            save_conf()
+            return self._json(200, {"ok": True, **cfg})
+        if path == "/api/aiops/diagnose":
+            if not self._guard("aiops"):
+                return
+            return self._json(200, aiops_diagnose(data.get("question")))
         return self._json(404, {"error": "not found"})
 
     def _login(self):
@@ -895,6 +1030,8 @@ def main():
     httpd.socket = ctx.wrap_socket(httpd.socket, server_side=True)
     sys.stderr.write("SkillFish Remote on https://%s:%d (PAM=%s)\n" % (bind, port, _PAM_OK))
     sys.stderr.flush()
+    threading.Thread(target=rules_loop, daemon=True).start()
+    threading.Thread(target=snapshot_loop, daemon=True).start()
     httpd.serve_forever()
 
 

apps/dashboard/skillfish-remote-manager

@@ -30,8 +30,8 @@ MODULES = [
     ("terminal", "⌨️", L("Terminale", "Terminal"), True),
     ("ai", "🧠", "AI / OpenWebUI", True),
     ("gamestream", "🎮", "Game streaming", False),
-    ("aiops", "🩺", "AI-Ops", False),
-    ("rules", "⚙️", L("Regole auto", "Auto rules"), False),
+    ("aiops", "🩺", "AI-Ops", True),
+    ("rules", "⚙️", L("Regole auto", "Auto rules"), True),
     ("wol", "🔋", L("Power schedule", "Power schedule"), True),
 ]
 

apps/dashboard/web/app.js

@@ -244,6 +244,36 @@ const RENDER = {
     };
     refresh();
   },
+  rules(card) {
+    card.classList.add("span2");
+    card.innerHTML = '<h3>⚙️ Regole auto</h3><div id="ru">…</div>';
+    const refresh = async () => {
+      let s; try { s = await (await api("/api/rules")).json(); } catch (e) { return; }
+      $("#ru", card).innerHTML =
+        '<div class="rows"><div class="r"><span>Auto-throttle a Stock se troppo caldo</span><span>' + (s.enabled ? "● attivo" : "○ spento") + '</span></div>' +
+        '<div class="r"><span>Soglia</span><span>' + s.temp_limit + ' °C</span></div>' +
+        (s.last_action ? '<div class="r"><span>Ultima azione</span><span>' + s.last_action + '</span></div>' : "") + '</div>' +
+        '<div class="brow" style="margin-top:10px"><button class="dbtn" id="rtog">' + (s.enabled ? "Disattiva" : "Attiva") + '</button>' +
+        '<input id="rlim" class="dsel" type="number" min="70" max="100" value="' + s.temp_limit + '" style="width:64px"> °C <button class="dbtn" id="rset">Imposta</button></div>' +
+        '<div class="gl" style="margin-top:12px">Ultimo fotogramma dello schermo' + (s.snap_age != null ? " (" + s.snap_age + "s fa)" : "") + '</div>' +
+        (s.has_frame ? '<img src="/api/rules/frame?t=' + Date.now() + '" style="width:100%;border-radius:10px;border:1px solid var(--line);margin-top:6px">' : '<div class="stub">Nessun fotogramma ancora (attiva il modulo e attendi ~20s).</div>');
+      $("#rtog", card).onclick = async () => { await action("/api/rules", { enabled: !s.enabled }, "Regola aggiornata"); setTimeout(refresh, 500); };
+      $("#rset", card).onclick = async () => { await action("/api/rules", { temp_limit: +$("#rlim", card).value }, "Soglia impostata"); setTimeout(refresh, 500); };
+    };
+    refresh(); card._iv = setInterval(refresh, 15000);
+  },
+  aiops(card) {
+    card.classList.add("span2");
+    card.innerHTML = '<h3>🩺 AI-Ops</h3><div class="brow"><input id="aq" class="dsel" placeholder="Domanda (opzionale): perché si è bloccata?" style="flex:1"><button class="dbtn" id="adg">Diagnostica</button></div>' +
+      '<div class="logbox" id="aout" style="margin-top:8px;display:none"></div>' +
+      '<div class="stub" style="margin-top:8px">Il modello locale (Ollama) legge log e telemetria e spiega cosa succede. Richiede il motore AI acceso.</div>';
+    $("#adg", card).onclick = async () => {
+      const out = $("#aout", card); out.style.display = "block";
+      out.textContent = "Analisi in corso col modello locale… (può richiedere un minuto)";
+      const j = await (await post("/api/aiops/diagnose", { question: $("#aq", card).value })).json().catch(() => ({}));
+      out.textContent = j.ok ? (j.answer || "(nessuna risposta)") : ("Errore: " + (j.error || ""));
+    };
+  },
   _stub(card, mod) {
     card.innerHTML = `<h3>${mod.icon} ${mod.name}</h3><div class="stub">Modulo attivo — interfaccia in arrivo.</div>`;
   },