acc0dff4e5
- Thinker emits ACTIONS: JSON line with follow-up buttons
- UI node is now pure code (no LLM call) — renders actions as buttons,
extracts tables from pipe-separated tool output, labels for single values
- Controls only in workspace panel, not duplicated in chat
- Process cards only in awareness panel, failed auto-remove after 30s
- Auth expiry detection: 403/1006 shows login button, stops reconnect loop
- Sensor timezone fix: zoneinfo.ZoneInfo("Europe/Berlin") for proper DST
- Cache-Control: no-cache on index.html
- Markdown rendering in chat messages
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
134 lines
4.5 KiB
Python
134 lines
4.5 KiB
Python
"""Sensor Node: ticks independently, produces context for other nodes."""
|
|
|
|
import asyncio
|
|
import logging
|
|
import time
|
|
from datetime import datetime
|
|
from zoneinfo import ZoneInfo
|
|
|
|
from .base import Node
|
|
|
|
log = logging.getLogger("runtime")
|
|
|
|
BERLIN = ZoneInfo("Europe/Berlin")
|
|
|
|
|
|
class SensorNode(Node):
|
|
name = "sensor"
|
|
|
|
def __init__(self, send_hud):
|
|
super().__init__(send_hud)
|
|
self.tick_count = 0
|
|
self.running = False
|
|
self._task: asyncio.Task | None = None
|
|
self.interval = 5
|
|
self.readings: dict[str, dict] = {}
|
|
self._last_user_activity: float = time.time()
|
|
self._prev_memo_state: dict = {}
|
|
|
|
def _now(self) -> datetime:
|
|
return datetime.now(BERLIN)
|
|
|
|
def _read_clock(self) -> dict:
|
|
now = self._now()
|
|
current = now.strftime("%H:%M")
|
|
prev = self.readings.get("clock", {}).get("value")
|
|
if current != prev:
|
|
return {"value": current, "detail": now.strftime("%Y-%m-%d %H:%M:%S %A"), "changed_at": time.time()}
|
|
return {}
|
|
|
|
def _read_idle(self) -> dict:
|
|
idle_s = time.time() - self._last_user_activity
|
|
thresholds = [30, 60, 300, 600, 1800]
|
|
prev_idle = self.readings.get("idle", {}).get("_raw", 0)
|
|
for t in thresholds:
|
|
if prev_idle < t <= idle_s:
|
|
if idle_s < 60:
|
|
label = f"{int(idle_s)}s"
|
|
else:
|
|
label = f"{int(idle_s // 60)}m{int(idle_s % 60)}s"
|
|
return {"value": label, "_raw": idle_s, "changed_at": time.time()}
|
|
if "idle" in self.readings:
|
|
self.readings["idle"]["_raw"] = idle_s
|
|
return {}
|
|
|
|
def _read_memo_changes(self, memo_state: dict) -> dict:
|
|
changes = []
|
|
for k, v in memo_state.items():
|
|
prev = self._prev_memo_state.get(k)
|
|
if v != prev and prev is not None:
|
|
changes.append(f"{k}: {prev} -> {v}")
|
|
self._prev_memo_state = dict(memo_state)
|
|
if changes:
|
|
return {"value": "; ".join(changes), "changed_at": time.time()}
|
|
return {}
|
|
|
|
def note_user_activity(self):
|
|
self._last_user_activity = time.time()
|
|
self.readings["idle"] = {"value": "active", "_raw": 0, "changed_at": time.time()}
|
|
|
|
async def tick(self, memo_state: dict):
|
|
self.tick_count += 1
|
|
deltas = {}
|
|
|
|
for name, reader in [("clock", self._read_clock),
|
|
("idle", self._read_idle)]:
|
|
update = reader()
|
|
if update:
|
|
self.readings[name] = {**self.readings.get(name, {}), **update}
|
|
deltas[name] = update.get("value") or update.get("detail")
|
|
|
|
memo_update = self._read_memo_changes(memo_state)
|
|
if memo_update:
|
|
self.readings["memo_delta"] = memo_update
|
|
deltas["memo_delta"] = memo_update["value"]
|
|
|
|
if deltas:
|
|
await self.hud("tick", tick=self.tick_count, deltas=deltas)
|
|
|
|
async def _loop(self, get_memo_state):
|
|
self.running = True
|
|
await self.hud("started", interval=self.interval)
|
|
try:
|
|
while self.running:
|
|
await asyncio.sleep(self.interval)
|
|
try:
|
|
await self.tick(get_memo_state())
|
|
except Exception as e:
|
|
log.error(f"[sensor] tick error: {e}")
|
|
except asyncio.CancelledError:
|
|
pass
|
|
finally:
|
|
self.running = False
|
|
await self.hud("stopped")
|
|
|
|
def start(self, get_memo_state):
|
|
if self._task and not self._task.done():
|
|
return
|
|
self._task = asyncio.create_task(self._loop(get_memo_state))
|
|
|
|
def stop(self):
|
|
self.running = False
|
|
if self._task:
|
|
self._task.cancel()
|
|
|
|
def get_context_lines(self) -> list[str]:
|
|
if not self.readings:
|
|
return ["Sensors: (no sensor node running)"]
|
|
lines = [f"Sensors (tick #{self.tick_count}, {self.interval}s interval):"]
|
|
for name, r in self.readings.items():
|
|
if name.startswith("_"):
|
|
continue
|
|
val = r.get("value", "?")
|
|
detail = r.get("detail")
|
|
age = time.time() - r.get("changed_at", time.time())
|
|
if age < 10:
|
|
age_str = "just now"
|
|
elif age < 60:
|
|
age_str = f"{int(age)}s ago"
|
|
else:
|
|
age_str = f"{int(age // 60)}m ago"
|
|
line = f"- {name}: {detail or val} [{age_str}]"
|
|
lines.append(line)
|
|
return lines
|