1643 lines
96 KiB
Python
Executable File
1643 lines
96 KiB
Python
Executable File
#!/usr/bin/env python3
|
||
from __future__ import annotations
|
||
|
||
import hashlib, html, json, math, os, re, shutil, sqlite3, subprocess, time, urllib.error, urllib.request, yaml
|
||
from collections import Counter
|
||
from datetime import datetime, timedelta, timezone
|
||
from pathlib import Path
|
||
from urllib.parse import urlparse
|
||
from zoneinfo import ZoneInfo
|
||
from typing import Any
|
||
|
||
ROOT=Path(__file__).resolve().parents[1]
|
||
DIGEST_ROOT=Path(os.environ.get('DORIS_DIGEST_DIR','/home/fizzlepoof/.openclaw/workspace/doris-digest'))
|
||
PUBLIC=ROOT/'public'; DATA=ROOT/'data'; LOGS=ROOT/'logs'
|
||
PAPERLESS_STATE_PATH=DATA/'paperless_review_state.json'
|
||
LAT=36.53; LON=-87.36
|
||
LOCAL_TZ=ZoneInfo('America/Chicago')
|
||
HERMES_HOME=Path.home()/'.hermes'
|
||
HERMES_STATE_DB=HERMES_HOME/'state.db'
|
||
HERMES_CONFIG=HERMES_HOME/'config.yaml'
|
||
DASHBOARD_JSON=DATA/'dashboard.json'
|
||
WIND_WATCHDOG_STATE_PATH=HERMES_HOME/'state'/'wind_alert_watchdog.json'
|
||
|
||
LABELS={
|
||
'astronomy':('🔭','Astronomy'),'homelab':('🏠','Homelab'),'smart_home':('🏡','Smart Home'),
|
||
'local':('📍','Local'),'radio':('📻','Ham Radio'),'security':('⚠️','Security'),
|
||
'tech':('🧰','Tech'),'us':('📰','News'),'world':('🌍','World'),'cooking':('🍳','Cooking'),'gaming':('🎮','Gaming')}
|
||
WEATHER_CODES={0:'Clear',1:'Mainly clear',2:'Partly cloudy',3:'Overcast',45:'Fog',48:'Rime fog',51:'Light drizzle',53:'Drizzle',55:'Heavy drizzle',61:'Light rain',63:'Rain',65:'Heavy rain',71:'Light snow',73:'Snow',75:'Heavy snow',80:'Rain showers',81:'Rain showers',82:'Heavy showers',95:'Thunderstorm'}
|
||
LOW_VALUE_LABELS={'shared','duesoon','submitted','waitingsubmission','notes'}
|
||
PRIORITY_COLORS={1:'#ff6b6b',2:'#ff9f1c',3:'#ffd166',4:'#8ecae6'}
|
||
|
||
SERVICE_DIRECTORY = [
|
||
{
|
||
'group': 'Portal',
|
||
'items': [
|
||
{'name': 'Doris Dashboard', 'url': 'index.html', 'health_url': 'http://127.0.0.1:8787/', 'purpose': 'Morning briefing, alerts, and operator homepage.', 'exposure': 'LAN', 'state': 'ok', 'host': 'NOMAD', 'port': '8787'},
|
||
{'name': 'Services Directory', 'url': 'services.html', 'health_url': 'http://127.0.0.1:8787/services.html', 'purpose': 'Front door into the rest of the stack.', 'exposure': 'LAN', 'state': 'ok', 'host': 'NOMAD', 'port': '8787'},
|
||
],
|
||
},
|
||
{
|
||
'group': 'Productivity / Workflow',
|
||
'items': [
|
||
{'name': 'Donetick', 'url': 'https://donetick.paccoco.com', 'purpose': 'Chores, recurring work, and household task coordination.', 'exposure': 'PUBLIC', 'state': 'ok', 'host': 'PD', 'port': '2021'},
|
||
{'name': 'Paperless', 'url': 'https://paperless.paccoco.com', 'purpose': 'Document archive, OCR intake, and household paperwork triage.', 'exposure': 'PUBLIC', 'state': 'ok', 'host': 'PD', 'port': '8083'},
|
||
{'name': 'n8n', 'url': 'https://n8n.paccoco.com', 'purpose': 'Automation bus for webhooks, alerts, and cross-service glue.', 'exposure': 'PUBLIC', 'state': 'ok', 'host': 'PD', 'port': '5678'},
|
||
{'name': 'Doris Schoolhouse', 'url': 'https://schoolhouse.paccoco.com', 'purpose': 'Class workflows, uploads, recordings, and school intake.', 'exposure': 'PUBLIC', 'state': 'ok', 'host': 'NOMAD', 'port': '8091'},
|
||
{'name': 'Doris Kitchen', 'url': 'http://10.5.1.16:8092', 'health_url': 'http://10.5.1.16:8092', 'purpose': 'Meal planning, grocery workflows, and kitchen-side operator tasks.', 'exposure': 'LAN', 'state': 'ok', 'host': 'NOMAD', 'port': '8092'},
|
||
],
|
||
},
|
||
{
|
||
'group': 'AI / Search',
|
||
'items': [
|
||
{'name': 'LiteLLM API', 'url': 'http://10.5.1.6:4000', 'health_url': 'http://10.5.1.6:4000/v1/models', 'purpose': 'Shared model gateway for automations, Schoolhouse, and local tools.', 'exposure': 'LAN', 'state': 'attention', 'host': 'PD', 'port': '4000'},
|
||
{'name': 'OpenWebUI', 'url': 'https://openwebui.paccoco.com', 'health_url': 'http://10.5.1.6:8282', 'purpose': 'Chat UI for the lab models, docs, and retrieval workflows.', 'exposure': 'PUBLIC', 'state': 'ok', 'host': 'PD', 'port': '8282'},
|
||
{'name': 'Qdrant', 'url': 'http://10.5.1.16:6333/dashboard', 'health_url': 'http://10.5.1.16:6333/healthz', 'purpose': 'Vector store for Project NOMAD and local retrieval systems.', 'exposure': 'LAN', 'state': 'ok', 'host': 'NOMAD', 'port': '6333/6334'},
|
||
{'name': 'Whisper API', 'url': 'http://10.5.1.16:8786/docs', 'health_url': 'http://10.5.1.16:8786/health', 'purpose': 'Fast local transcription endpoint for Schoolhouse and ad-hoc uploads.', 'exposure': 'LAN', 'state': 'ok', 'host': 'NOMAD', 'port': '8786'},
|
||
{'name': 'Ollama (NOMAD)', 'url': 'http://10.5.1.16:11434/api/tags', 'health_url': 'http://10.5.1.16:11434/api/tags', 'purpose': 'Project NOMAD local model runtime and admin surface.', 'exposure': 'LAN', 'state': 'ok', 'host': 'NOMAD', 'port': '11434'},
|
||
{'name': 'SearXNG', 'url': 'http://10.5.1.6:8888', 'health_url': 'http://10.5.1.6:8888', 'purpose': 'Private metasearch box for research and agent-side browsing.', 'exposure': 'LAN', 'state': 'ok', 'host': 'PD', 'port': '8888'},
|
||
],
|
||
},
|
||
{
|
||
'group': 'Homelab / Control Plane',
|
||
'items': [
|
||
{'name': 'Grafana', 'url': 'https://grafana.paccoco.com', 'purpose': 'Metrics, dashboards, and alert drill-down.', 'exposure': 'PUBLIC', 'state': 'ok', 'host': 'PD', 'port': '3000'},
|
||
{'name': 'Gitea', 'url': 'https://gitea.paccoco.com', 'purpose': 'Repos, issues, and source control.', 'exposure': 'PUBLIC', 'state': 'ok', 'host': 'PD', 'port': '3002 / 2222'},
|
||
{'name': 'Dockhand', 'url': 'http://10.5.1.6:3230', 'health_url': 'http://10.5.1.6:3230', 'purpose': 'Container housekeeping and image/update operations.', 'exposure': 'LAN', 'state': 'ok', 'host': 'PD', 'port': '3230'},
|
||
{'name': 'Uptime Kuma', 'url': 'http://10.5.1.6:3001', 'health_url': 'http://10.5.1.6:3001', 'purpose': 'Availability checks and service-watch status board.', 'exposure': 'LAN', 'state': 'ok', 'host': 'PD', 'port': '3001'},
|
||
{'name': 'MeshMonitor', 'url': 'https://meshmonitor.paccoco.com', 'health_url': 'http://10.5.1.6:8081', 'purpose': 'Meshtastic monitoring, node views, and map/radio telemetry.', 'exposure': 'PUBLIC', 'state': 'ok', 'host': 'PD', 'port': '8081'},
|
||
],
|
||
},
|
||
{
|
||
'group': 'Nomad Local Apps',
|
||
'items': [
|
||
{'name': 'Dozzle', 'url': 'http://10.5.1.16:9999', 'health_url': 'http://10.5.1.16:9999', 'purpose': 'Live Docker logs on NOMAD without opening a shell.', 'exposure': 'LAN', 'state': 'ok', 'host': 'NOMAD', 'port': '9999'},
|
||
{'name': 'Flatnotes', 'url': 'http://10.5.1.16:8200', 'health_url': 'http://10.5.1.16:8200', 'purpose': 'Quick notes and lightweight knowledge capture.', 'exposure': 'LAN', 'state': 'ok', 'host': 'NOMAD', 'port': '8200'},
|
||
{'name': 'Kiwix', 'url': 'http://10.5.1.16:8090', 'health_url': 'http://10.5.1.16:8090', 'purpose': 'Offline library / knowledge mirror for disconnected use.', 'exposure': 'LAN', 'state': 'ok', 'host': 'NOMAD', 'port': '8090'},
|
||
{'name': 'Home Assistant', 'url': '', 'purpose': 'Smart-home control hub documented on PD, but no operator-safe route is exposed from NOMAD yet.', 'exposure': 'PRIVATE', 'state': 'attention', 'host': 'PD', 'port': '8123', 'probe': False, 'badge': 'Manual', 'detail': 'documented active on PD; add a stable route before probing from Doris'},
|
||
],
|
||
},
|
||
]
|
||
|
||
|
||
SECTION_STATE_RANK={'ok':0,'attention':1,'warn':2}
|
||
|
||
def esc(v:Any)->str: return html.escape(str(v or ''),quote=True)
|
||
def load_json(p:Path,d:Any)->Any:
|
||
try: return json.loads(p.read_text()) if p.exists() else d
|
||
except Exception: return d
|
||
|
||
def strip_markup(text:str)->str:
|
||
text=re.sub(r'<[^>]+>',' ',text or '')
|
||
return re.sub(r'\s+',' ',html.unescape(text)).strip()
|
||
|
||
def parse_time(v:str)->datetime:
|
||
try: return datetime.fromisoformat((v or '').replace('Z','+00:00')).astimezone(timezone.utc)
|
||
except Exception: return datetime.now(timezone.utc)
|
||
|
||
def parse_dt(v:str|None)->datetime|None:
|
||
if not v: return None
|
||
try: return datetime.fromisoformat(v.replace('Z','+00:00'))
|
||
except Exception: return None
|
||
|
||
def c_to_f(c:float|int|None)->str:
|
||
if c is None: return '—'
|
||
return f"{round(c*9/5+32)}°F"
|
||
|
||
def kmh_to_mph(k:float|int|None)->str:
|
||
if k is None: return '—'
|
||
return f"{round(k*0.621371)} mph"
|
||
|
||
def compact_number(value:int|float|None)->str:
|
||
if value in (None,''): return '—'
|
||
try: n=float(value)
|
||
except Exception: return str(value)
|
||
abs_n=abs(n)
|
||
if abs_n >= 1_000_000_000: return f"{n/1_000_000_000:.1f}B"
|
||
if abs_n >= 1_000_000: return f"{n/1_000_000:.1f}M"
|
||
if abs_n >= 1_000: return f"{n/1_000:.1f}K"
|
||
if n.is_integer(): return f"{int(n):,}"
|
||
return f"{n:,.1f}"
|
||
|
||
def pct_text(value:float|int|None)->str:
|
||
if value in (None,''): return '—'
|
||
try: return f"{round(float(value))}%"
|
||
except Exception: return '—'
|
||
|
||
def percent_value(part:int|float|None,total:int|float|None)->float|None:
|
||
try:
|
||
numerator=float(part or 0)
|
||
denominator=float(total or 0)
|
||
except Exception:
|
||
return None
|
||
if denominator <= 0:
|
||
return None
|
||
return (numerator/denominator)*100.0
|
||
|
||
def usage_window_state(remaining_percent:float|int|None)->str:
|
||
if remaining_percent in (None,''): return 'attention'
|
||
try: remaining=float(remaining_percent)
|
||
except Exception: return 'attention'
|
||
if remaining <= 15: return 'warn'
|
||
if remaining <= 35: return 'attention'
|
||
return 'ok'
|
||
|
||
def find_usage_window(windows:list[dict[str,Any]], label_hint:str)->dict[str,Any] | None:
|
||
hint=(label_hint or '').strip().lower()
|
||
for window in windows:
|
||
label=str(window.get('label') or '').strip().lower()
|
||
if hint and hint in label:
|
||
return window
|
||
return windows[0] if windows else None
|
||
|
||
def total_tokens_value(row:dict[str,Any] | sqlite3.Row)->int:
|
||
keys=('input_tokens','output_tokens','cache_read_tokens','cache_write_tokens','reasoning_tokens')
|
||
total=0
|
||
for key in keys:
|
||
try: total += int((row[key] if isinstance(row, sqlite3.Row) else row.get(key,0)) or 0)
|
||
except Exception: pass
|
||
return total
|
||
|
||
def read_hermes_model_config()->dict[str,str]:
|
||
default='unknown'; provider='unknown'
|
||
try:
|
||
data=yaml.safe_load(HERMES_CONFIG.read_text(encoding='utf-8')) or {}
|
||
except Exception:
|
||
return {'default_model':default,'provider':provider}
|
||
model_cfg=data.get('model') if isinstance(data,dict) else {}
|
||
if isinstance(model_cfg,dict):
|
||
default=str(model_cfg.get('default') or default)
|
||
provider=str(model_cfg.get('provider') or provider)
|
||
return {'default_model':default or 'unknown','provider':provider or 'unknown'}
|
||
|
||
def moon_phase(dt:datetime)->dict[str,str]:
|
||
# Known new moon: 2000-01-06 18:14 UTC; synodic month 29.53058867 days.
|
||
known=datetime(2000,1,6,18,14,tzinfo=timezone.utc)
|
||
days=(dt.astimezone(timezone.utc)-known).total_seconds()/86400
|
||
age=days%29.53058867
|
||
illum=(1-math.cos(2*math.pi*age/29.53058867))/2
|
||
names=[(1.85,'New Moon','🌑'),(5.54,'Waxing Crescent','🌒'),(9.23,'First Quarter','🌓'),(12.92,'Waxing Gibbous','🌔'),(16.61,'Full Moon','🌕'),(20.30,'Waning Gibbous','🌖'),(23.99,'Last Quarter','🌗'),(27.68,'Waning Crescent','🌘'),(29.54,'New Moon','🌑')]
|
||
name,emoji='New Moon','🌑'
|
||
for limit,n,e in names:
|
||
if age<limit: name,emoji=n,e; break
|
||
return {'emoji':emoji,'name':name,'age':f'{age:.1f} days','illumination':f'{illum*100:.0f}%'}
|
||
|
||
def fetch_weather()->dict[str,Any]:
|
||
url=(f'https://api.open-meteo.com/v1/forecast?latitude={LAT}&longitude={LON}'
|
||
'¤t=temperature_2m,relative_humidity_2m,wind_speed_10m,weather_code,apparent_temperature'
|
||
'&hourly=temperature_2m,precipitation_probability'
|
||
'&daily=weather_code,temperature_2m_max,temperature_2m_min,precipitation_probability_max'
|
||
'&timezone=America/Chicago&forecast_days=4')
|
||
try:
|
||
with urllib.request.urlopen(url,timeout=12) as r: raw=json.load(r)
|
||
cur=raw.get('current',{}); daily=raw.get('daily',{}); hourly=raw.get('hourly',{})
|
||
probs=hourly.get('precipitation_probability') or []
|
||
daily_codes=daily.get('weather_code') or []
|
||
return {
|
||
'ok':True,
|
||
'current':cur,
|
||
'daily':daily,
|
||
'max_precip':max(probs[:24] or [0]),
|
||
'condition':WEATHER_CODES.get(cur.get('weather_code'),'Weather code '+str(cur.get('weather_code'))),
|
||
'today_condition':WEATHER_CODES.get(daily_codes[0], WEATHER_CODES.get(cur.get('weather_code'),'Weather code '+str(cur.get('weather_code')))) if daily_codes else WEATHER_CODES.get(cur.get('weather_code'),'Weather code '+str(cur.get('weather_code'))),
|
||
'source':'Open-Meteo'
|
||
}
|
||
except Exception as e:
|
||
return {'ok':False,'error':str(e),'source':'Open-Meteo'}
|
||
|
||
def decrypt_donetick()->dict[str,Any]|None:
|
||
secret=Path('/home/fizzlepoof/.openclaw/workspace/.secrets/donetick_secrets.json.enc')
|
||
keyfile=Path('/home/fizzlepoof/.openclaw/workspace/.secrets/encryption.key')
|
||
if not secret.exists() or not keyfile.exists(): return None
|
||
try:
|
||
res=subprocess.run(['openssl','enc','-aes-256-cbc','-d','-pbkdf2','-in',str(secret),'-k',keyfile.read_text().strip()],capture_output=True,text=True,timeout=8,check=True)
|
||
return json.loads(res.stdout).get('donetick')
|
||
except Exception:
|
||
return None
|
||
|
||
def donetick_headers()->dict[str,str]|None:
|
||
sec=decrypt_donetick()
|
||
if not sec: return None
|
||
try:
|
||
login=urllib.request.Request(sec['instance']+sec['jwt_endpoint'],data=json.dumps({'username':sec['service_account']['username'],'password':sec['service_account']['password']}).encode(),headers={'Content-Type':'application/json','Accept':'application/json'},method='POST')
|
||
with urllib.request.urlopen(login,timeout=12) as r: token=json.loads(r.read())['access_token']
|
||
return {'Authorization':'Bearer '+token,'Accept':'application/json','Content-Type':'application/json'}
|
||
except Exception:
|
||
return None
|
||
|
||
def combine_states(states:list[str])->str:
|
||
best='ok'
|
||
for state in states:
|
||
if SECTION_STATE_RANK.get(state,-1) > SECTION_STATE_RANK.get(best,-1):
|
||
best=state
|
||
return best
|
||
|
||
def fetch_donetick_todos()->list[dict[str,Any]]:
|
||
sec=decrypt_donetick(); headers=donetick_headers()
|
||
if not sec or not headers: return []
|
||
try:
|
||
req=urllib.request.Request(sec['instance']+'/api/v1/chores',headers=headers)
|
||
with urllib.request.urlopen(req,timeout=12) as r: chores=json.loads(r.read()).get('res',[])
|
||
users={}
|
||
try:
|
||
ureq=urllib.request.Request(sec['instance']+'/api/v1/users',headers=headers)
|
||
with urllib.request.urlopen(ureq,timeout=12) as r:
|
||
users={u.get('id'):u.get('displayName') or u.get('username') for u in json.loads(r.read()).get('res',[])}
|
||
except Exception: pass
|
||
out=[]
|
||
for c in chores:
|
||
if c.get('status') not in (0,None): continue
|
||
due=c.get('nextDueDate') or ''
|
||
assignee=users.get(c.get('assignedTo')) or ('Unassigned' if not c.get('assignedTo') else f"User {c.get('assignedTo')}")
|
||
due_title,state,due_local=due_title_and_state(due)
|
||
out.append({
|
||
'title':c.get('name','Untitled task'),
|
||
'time':due[:16].replace('T',' '),
|
||
'body':strip_markup(c.get('description','')),
|
||
'assignee':assignee,
|
||
'priority':priority_num(c.get('priority')) or 0,
|
||
'priority_text':priority_text(c.get('priority')) or '',
|
||
'due':due,
|
||
'due_title':due_title,
|
||
'state':state,
|
||
'subtitle':subtitle_text(c),
|
||
'chips':visible_label_chips(c),
|
||
'source':'Donetick',
|
||
'id':c.get('id'),
|
||
'_sort_overdue':0 if due_local and due_local < datetime.now().astimezone() else (2 if not due_local else 1),
|
||
'_sort_missing':0 if due_local else 1,
|
||
'_sort_due':due_local.timestamp() if due_local else 99999999999,
|
||
'_sort_name':str(c.get('name','')).lower(),
|
||
})
|
||
out.sort(key=lambda x:(x.get('_sort_overdue',9),x.get('_sort_missing',9),x.get('_sort_due',99999999999),x.get('_sort_name','')))
|
||
for item in out:
|
||
for k in ('_sort_overdue','_sort_missing','_sort_due','_sort_name'):
|
||
item.pop(k,None)
|
||
return out[:10]
|
||
except Exception:
|
||
return []
|
||
|
||
def priority_text(priority:Any)->str|None:
|
||
try:
|
||
p=int(priority)
|
||
return f'P{p}' if p in (1,2,3,4) else None
|
||
except Exception:
|
||
return None
|
||
|
||
def priority_num(priority:Any)->int|None:
|
||
try:
|
||
p=int(priority)
|
||
return p if p in (1,2,3,4) else None
|
||
except Exception:
|
||
return None
|
||
|
||
def recurrence_text(task:dict[str,Any])->str|None:
|
||
ftype=str(task.get('frequencyType','') or '').strip().lower()
|
||
freq=task.get('frequency')
|
||
try: freq_num=int(freq) if freq is not None else None
|
||
except Exception: freq_num=None
|
||
if not ftype: return None
|
||
if ftype=='daily': return 'Daily' if freq_num in (None,1) else f'Every {freq_num} days'
|
||
if ftype=='weekly': return 'Weekly' if freq_num in (None,1) else f'Every {freq_num} weeks'
|
||
if ftype=='monthly': return 'Monthly' if freq_num in (None,1) else f'Every {freq_num} months'
|
||
if ftype=='yearly': return 'Yearly' if freq_num in (None,1) else f'Every {freq_num} years'
|
||
if ftype=='once': return 'One-time'
|
||
return ftype.capitalize()
|
||
|
||
def due_title_and_state(due_raw:str|None)->tuple[str,str,datetime|None]:
|
||
dt=parse_dt(due_raw)
|
||
if not dt: return ('No due date','nodue',None)
|
||
local=dt.astimezone(LOCAL_TZ)
|
||
now=datetime.now(LOCAL_TZ)
|
||
days=(local.date()-now.date()).days
|
||
time_text=local.strftime('%-I:%M %p')
|
||
if days < 0:
|
||
if abs(days)==1: return (f'Overdue • Yesterday {time_text}','overdue',local)
|
||
return (f"Overdue • {local.strftime('%a, %b %-d')} {time_text}",'overdue',local)
|
||
if days == 0: return (f'Due today • {time_text}','today',local)
|
||
if days == 1: return (f'Due tomorrow • {time_text}','tomorrow',local)
|
||
if days <= 6: return (f"Due {local.strftime('%a')} • {time_text}",'upcoming',local)
|
||
return (f"Due {local.strftime('%b %-d')} • {time_text}",'upcoming',local)
|
||
|
||
def dedupe_parts(parts:list[str])->list[str]:
|
||
seen=set(); out=[]
|
||
for p in parts:
|
||
if not p: continue
|
||
key=p.strip().lower()
|
||
if key in seen: continue
|
||
seen.add(key); out.append(p)
|
||
return out
|
||
|
||
def subtitle_text(task:dict[str,Any])->str:
|
||
parts=[]
|
||
labels=task.get('labelsV2') or []
|
||
label_names=[str(lbl.get('name','')).strip() for lbl in labels if lbl.get('name')]
|
||
prominent=[x for x in label_names if x.strip().lower() not in LOW_VALUE_LABELS]
|
||
low=[x for x in label_names if x.strip().lower() in LOW_VALUE_LABELS]
|
||
parts.extend(prominent[:3])
|
||
ptxt=priority_text(task.get('priority'))
|
||
if ptxt: parts.append(ptxt)
|
||
rtxt=recurrence_text(task)
|
||
if rtxt:
|
||
label_keys={x.strip().lower() for x in label_names}
|
||
if rtxt.strip().lower() not in label_keys: parts.append(rtxt)
|
||
if not prominent and low: parts.extend(low[:1])
|
||
return ' • '.join(dedupe_parts(parts))
|
||
|
||
def visible_label_chips(task:dict[str,Any])->list[dict[str,str]]:
|
||
chips=[]
|
||
for lbl in task.get('labelsV2') or []:
|
||
name=str(lbl.get('name','')).strip()
|
||
if not name or name.lower() in LOW_VALUE_LABELS: continue
|
||
color=str(lbl.get('color','')).strip() or '#607d8b'
|
||
chips.append({'name':name,'color':color})
|
||
return chips[:4]
|
||
|
||
def run(cmd:list[str])->str:
|
||
try: return subprocess.check_output(cmd,stderr=subprocess.DEVNULL,text=True,timeout=8).strip()
|
||
except Exception: return ''
|
||
|
||
|
||
def dashboard_service_status()->dict[str,str]:
|
||
active=run(['systemctl','is-active','doris-dashboard.service'])
|
||
substate=run(['systemctl','show','-p','SubState','--value','doris-dashboard.service'])
|
||
pid=run(['systemctl','show','-p','ExecMainPID','--value','doris-dashboard.service'])
|
||
if active:
|
||
detail=active
|
||
if substate and substate != active:
|
||
detail=f'{active} ({substate})'
|
||
if active == 'active' and pid and pid != '0':
|
||
detail=f'{detail} · pid {pid}'
|
||
return {'value':detail,'state':'ok' if active == 'active' else 'warn'}
|
||
listener=run(['bash','-lc',"ss -ltn '( sport = :8787 )' | tail -n +2"])
|
||
if listener:
|
||
return {'value':'web listener up on :8787','state':'ok'}
|
||
return {'value':'no systemd state and nothing listening on :8787','state':'warn'}
|
||
|
||
|
||
def dashboard_cron_status()->dict[str,str]:
|
||
info=load_json(DASHBOARD_JSON,{}) if DASHBOARD_JSON.exists() else {}
|
||
generated_raw=info.get('generated_at_local') or info.get('generated_at') or ''
|
||
generated=parse_dt(generated_raw)
|
||
if not generated and DASHBOARD_JSON.exists():
|
||
try:
|
||
generated=datetime.fromtimestamp(DASHBOARD_JSON.stat().st_mtime, tz=timezone.utc).astimezone(LOCAL_TZ)
|
||
except Exception:
|
||
generated=None
|
||
if not generated:
|
||
return {'value':'no dashboard generation timestamp yet','state':'warn'}
|
||
local_generated=generated.astimezone(LOCAL_TZ)
|
||
now=datetime.now(LOCAL_TZ)
|
||
age_minutes=max(0,int((now-local_generated).total_seconds()//60))
|
||
next_run=local_generated.replace(second=0,microsecond=0)
|
||
slots=(5,35)
|
||
probe=now.replace(second=0,microsecond=0)
|
||
while True:
|
||
if probe.minute in slots and probe > now:
|
||
next_run=probe
|
||
break
|
||
probe += timedelta(minutes=1)
|
||
age_text='just now' if age_minutes < 1 else (f'{age_minutes}m ago' if age_minutes < 60 else f'{age_minutes//60}h {age_minutes%60}m ago')
|
||
value=f'updated {age_text} · next {next_run.strftime("%-I:%M %p")}'
|
||
state='ok' if age_minutes <= 45 else 'warn'
|
||
return {'value':value,'state':state}
|
||
|
||
|
||
def homelab_pulse(candidates:list[dict[str,Any]])->list[dict[str,str]]:
|
||
usage=shutil.disk_usage('/home/fizzlepoof/.openclaw/workspace')
|
||
disk=f'{usage.used/usage.total*100:.0f}% used ({usage.free/1024**3:.1f} GiB free)'
|
||
dash=dashboard_service_status()
|
||
cron=dashboard_cron_status()
|
||
newest=max((parse_time(i.get('collected_at') or i.get('published_at') or '') for i in candidates), default=datetime.now(timezone.utc))
|
||
age=(datetime.now(timezone.utc)-newest).total_seconds()/3600
|
||
return [
|
||
{'label':'Dashboard service','value':dash['value'],'state':dash['state']},
|
||
{'label':'Dashboard cron','value':cron['value'],'state':cron['state']},
|
||
{'label':'Digest freshness','value':f'{age:.1f}h since newest candidate','state':'ok' if age<8 else 'warn'},
|
||
{'label':'Workspace disk','value':disk,'state':'ok' if usage.free/usage.total>.15 else 'warn'},
|
||
]
|
||
|
||
|
||
def system_snapshot()->list[dict[str,str]]:
|
||
uptime_text='unknown'
|
||
try:
|
||
uptime_seconds=float(Path('/proc/uptime').read_text().split()[0])
|
||
hours=int(uptime_seconds//3600)
|
||
minutes=int((uptime_seconds%3600)//60)
|
||
uptime_text=(f'{hours}h {minutes}m' if hours else f'{minutes}m')
|
||
except Exception:
|
||
pass
|
||
load_text='unknown'
|
||
load_state='ok'
|
||
try:
|
||
load1,load5,load15=os.getloadavg()
|
||
load_text=f'{load1:.2f} / {load5:.2f} / {load15:.2f}'
|
||
cpu_count=os.cpu_count() or 1
|
||
if load1 > cpu_count*1.25:
|
||
load_state='warn'
|
||
elif load1 > cpu_count*0.85:
|
||
load_state='attention'
|
||
except Exception:
|
||
load_state='warn'
|
||
mem_text='unknown'
|
||
mem_state='ok'
|
||
try:
|
||
parts=Path('/proc/meminfo').read_text().splitlines()
|
||
raw={line.split(':',1)[0]: int(line.split(':',1)[1].strip().split()[0]) for line in parts if ':' in line}
|
||
total=raw.get('MemTotal',0)
|
||
avail=raw.get('MemAvailable',0)
|
||
used=max(total-avail,0)
|
||
pct=(used/total*100) if total else 0
|
||
mem_text=f'{pct:.0f}% used ({used/1024/1024:.1f} / {total/1024/1024:.1f} GiB)'
|
||
if pct >= 85:
|
||
mem_state='warn'
|
||
elif pct >= 70:
|
||
mem_state='attention'
|
||
except Exception:
|
||
mem_state='warn'
|
||
root_usage=shutil.disk_usage('/')
|
||
root_pct=root_usage.used/root_usage.total*100 if root_usage.total else 0
|
||
root_text=f'{root_pct:.0f}% used ({root_usage.free/1024**3:.1f} GiB free)'
|
||
return [
|
||
{'label':'Host','value':run(['hostname']) or 'nomad','state':'ok'},
|
||
{'label':'Uptime','value':uptime_text,'state':'ok'},
|
||
{'label':'Load avg','value':load_text,'state':load_state},
|
||
{'label':'Memory','value':mem_text,'state':mem_state},
|
||
{'label':'Root disk','value':root_text,'state':'warn' if root_pct >= 85 else ('attention' if root_pct >= 70 else 'ok')},
|
||
]
|
||
|
||
TOPIC_STOPWORDS={
|
||
'the','a','an','and','or','to','of','for','in','on','with','after','at','from','is','are','be','as','by','how','why','what','when','your','you','new','this','that','its','their','his','her','our','but','into','over','under','about','amid','through','during','just','says','say','will','can','could','should','would','has','have','had','was','were','not','than','more','less','look','looks','looking','likely'
|
||
}
|
||
TOPIC_TOKEN_ALIASES={
|
||
'spacex':'spacex','starship':'starship','psyche':'psyche','nasa':'nasa','mars':'mars','moon':'moon','artemis':'artemis','maven':'maven',
|
||
'filing':'ipo','paperwork':'ipo','public':'ipo','ipo':'ipo','s1':'ipo','s-1':'ipo',
|
||
'marshals':'marshals','marshal':'marshals','fugitive':'wanted','wanted':'wanted','alias':'alias','identity':'alias','captured':'arrested','custody':'arrested',
|
||
'homelab':'homelab','docker':'docker','truenas':'truenas','proxmox':'proxmox','opnsense':'opnsense','wireguard':'wireguard','zigbee':'zigbee','matter':'matter','radio':'radio'
|
||
}
|
||
|
||
|
||
def normalize_topic_tokens(item:dict[str,Any])->list[str]:
|
||
raw=' '.join(str(item.get(k,'') or '') for k in ('title','summary','url')).lower()
|
||
raw=raw.replace('u.s.','us').replace('u.s','us').replace('u k','uk')
|
||
words=re.findall(r"[a-z0-9]+", raw)
|
||
out=[]
|
||
for word in words:
|
||
if len(word) <= 2 or word in TOPIC_STOPWORDS:
|
||
continue
|
||
out.append(TOPIC_TOKEN_ALIASES.get(word, word))
|
||
return out
|
||
|
||
|
||
def explicit_topic_key(item:dict[str,Any])->str|None:
|
||
raw=' '.join(str(item.get(k,'') or '') for k in ('title','summary','url')).lower()
|
||
raw=raw.replace('u.s.','us').replace('u.s','us')
|
||
if 'spacex' in raw and any(term in raw for term in (' ipo', ' s-1', 's1', 'going public', 'going-public', 'paperwork', 'financial filing', 'finances', 'opens its books', 'sec.gov/archives/edgar')):
|
||
return 'spacex-ipo'
|
||
if 'psyche' in raw and 'mars' in raw:
|
||
return 'psyche-mars-flyby'
|
||
if 'psyche' in raw:
|
||
return 'psyche-mission'
|
||
if 'starship' in raw and 'spacex' in raw:
|
||
return 'spacex-starship'
|
||
if 'marshals' in raw and 'nashville' in raw and any(term in raw for term in ('wanted', 'fugitive', 'alias', 'false identity')):
|
||
return 'nashville-marshals-fugitive'
|
||
return None
|
||
|
||
|
||
def topic_key(item:dict[str,Any],docfreq:Counter[str]|None=None)->str:
|
||
explicit=explicit_topic_key(item)
|
||
if explicit:
|
||
return explicit
|
||
tokens=normalize_topic_tokens(item)
|
||
if not tokens:
|
||
return slugify(str(item.get('title') or item.get('url') or 'story'))
|
||
unique=[]
|
||
seen=set()
|
||
for tok in tokens:
|
||
if tok in seen:
|
||
continue
|
||
seen.add(tok)
|
||
unique.append(tok)
|
||
if docfreq is None:
|
||
return '-'.join(unique[:4])
|
||
unique.sort(key=lambda tok:(docfreq.get(tok,999999), -len(tok), tok))
|
||
return '-'.join(unique[:4])
|
||
|
||
|
||
def score_item(item:dict[str,Any],prefs:dict[str,Any])->float:
|
||
score=float(item.get('priority',1))
|
||
title=str(item.get('title',''))
|
||
summary=str(item.get('summary',''))
|
||
source=str(item.get('source',''))
|
||
category=str(item.get('category') or 'other')
|
||
text=f"{title} {summary}".lower()
|
||
if category in prefs.get('boost_categories',[]): score+=2
|
||
if category in prefs.get('quiet_categories',[]): score-=3
|
||
if source in prefs.get('boost_sources',[]): score+=1.5
|
||
for kw in prefs.get('boost_keywords',[]):
|
||
if kw.lower() in text: score+=1.5
|
||
for kw in prefs.get('mute_keywords',[]):
|
||
if kw.lower() in text: score-=3
|
||
practical_terms=(
|
||
'guide','explainer','explained','tutorial','comic','formula','study','scientists','mission',
|
||
'linux','self-hosted','open source','homelab','home assistant','radio','antenna','weather',
|
||
'budget','housing','school','schools','college','habit','learning','science'
|
||
)
|
||
if any(term in text for term in practical_terms):
|
||
score+=1.2
|
||
low_value_terms=(
|
||
'celebrity','singer','sexual assault','allegation','allegations','raped','rape','fugitive',
|
||
'arrested','on the run','heroin','gossip','lawsuit'
|
||
)
|
||
if any(term in text for term in low_value_terms):
|
||
score-=4
|
||
if category=='local':
|
||
civic_terms=('budget','tax','funding','school','schools','housing','storm','weather','traffic','road','county','city')
|
||
if any(term in text for term in civic_terms):
|
||
score+=1.4
|
||
if any(term in text for term in ('fugitive','arrested','shooting','murder','heroin')):
|
||
score-=4.5
|
||
if category in {'us','world'} and any(term in text for term in ('celebrity','singer','sexual assault','allegation','allegations','gossip')):
|
||
score-=5
|
||
if source=='CISA Alerts':
|
||
terms=[t.lower() for t in prefs.get('homelab_relevance_keywords',[])]
|
||
if terms and not any(t in text for t in terms): score-=8
|
||
return score
|
||
def select_items(items:list[dict[str,Any]],prefs:dict[str,Any],max_items:int=14)->list[dict[str,Any]]:
|
||
now=datetime.now(timezone.utc); recent=[]
|
||
for i in items:
|
||
if (now-parse_time(i.get('published_at',''))).total_seconds()<96*3600: recent.append(i)
|
||
docfreq=Counter()
|
||
for i in recent:
|
||
docfreq.update(set(normalize_topic_tokens(i)))
|
||
recent.sort(key=lambda i:(score_item(i,prefs),i.get('published_at','')),reverse=True)
|
||
|
||
out=[]; seen=set(); topic_seen=set(); sources=Counter(); categories=Counter()
|
||
|
||
def consider(limit_per_category:int|None, topic_budget:int=1)->None:
|
||
for i in recent:
|
||
if len(out)>=max_items: break
|
||
url=i.get('url',''); src=i.get('source',''); cat=(i.get('category') or 'other').strip() or 'other'; tkey=topic_key(i,docfreq)
|
||
if url in seen or sources[src]>=2: continue
|
||
if tkey in topic_seen and topic_budget <= 0: continue
|
||
if limit_per_category is not None and categories[cat] >= limit_per_category: continue
|
||
out.append(i); seen.add(url); sources[src]+=1; categories[cat]+=1
|
||
if tkey: topic_seen.add(tkey)
|
||
|
||
# First fill favors breadth across categories and unique topics, then allows a
|
||
# little more category depth while still suppressing same-topic clones.
|
||
consider(1, 0)
|
||
consider(2, 0)
|
||
consider(3, 0)
|
||
return out
|
||
|
||
|
||
def select_exploration_items(items:list[dict[str,Any]],prefs:dict[str,Any],exclude_urls:set[str]|None=None,max_items:int=4)->list[dict[str,Any]]:
|
||
now=datetime.now(timezone.utc)
|
||
exclude_urls=exclude_urls or set()
|
||
boosted={str(x).strip() for x in prefs.get('boost_categories',[])}
|
||
quiet={str(x).strip() for x in prefs.get('quiet_categories',[])}
|
||
preferred=['tech','radio','security','gaming','cooking']
|
||
recent=[i for i in items if (now-parse_time(i.get('published_at',''))).total_seconds()<96*3600]
|
||
docfreq=Counter()
|
||
for i in recent:
|
||
docfreq.update(set(normalize_topic_tokens(i)))
|
||
recent.sort(key=lambda i:(score_item(i,prefs),i.get('published_at','')),reverse=True)
|
||
|
||
seeded_topics={topic_key(i,docfreq) for i in recent if i.get('url','') in exclude_urls}
|
||
out=[]; seen=set(exclude_urls); topic_seen=set(seeded_topics); categories=Counter(); sources=Counter()
|
||
|
||
def consider(allowed_boosted:bool, only_categories:set[str]|None=None, per_category_limit:int=1)->None:
|
||
for i in recent:
|
||
if len(out)>=max_items: break
|
||
url=i.get('url',''); src=i.get('source',''); cat=(i.get('category') or 'other').strip() or 'other'; tkey=topic_key(i,docfreq)
|
||
if not url or url in seen or sources[src]>=1 or categories[cat]>=per_category_limit or tkey in topic_seen:
|
||
continue
|
||
if cat in quiet:
|
||
continue
|
||
if only_categories is not None and cat not in only_categories:
|
||
continue
|
||
if not allowed_boosted and cat in boosted:
|
||
continue
|
||
out.append(i); seen.add(url); topic_seen.add(tkey); categories[cat]+=1; sources[src]+=1
|
||
|
||
# Keep this lane genuinely exploratory: adjacent-interest categories first,
|
||
# then broader off-profile picks, all with one story per topic.
|
||
consider(False, set(preferred), 1)
|
||
consider(False, set(preferred), 2)
|
||
consider(False, None, 1)
|
||
consider(False, None, 2)
|
||
return out
|
||
|
||
def label(cat:str)->str:
|
||
e,n=LABELS.get(cat,('🧩',(cat or 'Other').title())); return f'{e} {n}'
|
||
|
||
def slugify(text:str)->str:
|
||
return re.sub(r'[^a-z0-9]+','-',(text or '').strip().lower()).strip('-') or 'section'
|
||
|
||
def why(i:dict[str,Any])->str:
|
||
cat=i.get('category'); src=i.get('source','')
|
||
if cat=='astronomy': return 'Space/astronomy signal from your YouTube + feed tuning.'
|
||
if cat=='homelab': return 'Practical self-hosting / infrastructure signal.'
|
||
if cat=='smart_home': return 'Smart-home/Home Assistant adjacent.'
|
||
if cat=='local': return 'Local or regional relevance.'
|
||
if cat=='radio': return 'Ham-radio interest signal.'
|
||
if cat=='security': return 'Kept only because it appears practically relevant.'
|
||
return f'Interesting signal from {src}.'
|
||
|
||
def card(i:dict[str,Any], compact:bool=False)->str:
|
||
summary=(i.get('summary') or '').strip()[:120 if compact else 260]
|
||
when=(i.get('published_at','')[:16].replace('T',' '))
|
||
cls='compact-card' if compact else 'card'
|
||
why_html='' if compact else f"<div class='why'>Why: {esc(why(i))}</div>"
|
||
topic=(i.get('category') or 'other').strip() or 'other'
|
||
source=(i.get('source') or '').strip()
|
||
domain=(urlparse(i.get('url') or '').netloc or '').lower().removeprefix('www.')
|
||
feedback_html='' if not compact else (
|
||
f"<div class='feedback'>"
|
||
f"<button type='button' class='feedback-btn' data-feedback='up' aria-pressed='false' title='Prefer more {esc(topic)} stories'>👍</button>"
|
||
f"<button type='button' class='feedback-btn' data-feedback='down' aria-pressed='false' title='Less like this — hide this story'>👎</button>"
|
||
f"</div>"
|
||
)
|
||
return f"""<article class='{cls} {esc(i.get('category',''))}' data-topic='{esc(topic)}' data-source='{esc(source)}' data-domain='{esc(domain)}'>
|
||
<div class='meta'><span>{esc(label(i.get('category','')))}</span><span>{esc(i.get('source'))}</span><span>{esc(when)} UTC</span></div>
|
||
<h3><a href='{esc(i.get('url'))}' target='_blank' rel='noreferrer'>{esc(i.get('title'))}</a></h3>
|
||
<p>{esc(summary)}</p>{feedback_html}{why_html}</article>"""
|
||
|
||
def section(title:str,sub:str,items:list[dict[str,Any]],empty:str,compact:bool=True)->str:
|
||
body=''.join(card(i,compact=compact) for i in items) if items else f"<p class='empty'>{esc(empty)}</p>"
|
||
style='news-list' if compact else 'grid'
|
||
return collapsible_section(title,sub,f"<div class='{style}'>{body}</div>",slugify(title),open_by_default=True)
|
||
|
||
def collapsible_section(title:str,sub:str,inner_html:str,key:str,open_by_default:bool=True,extra_class:str='',state:str='',smart:bool=False)->str:
|
||
open_attr=' open' if open_by_default else ''
|
||
sub_html=f"<p>{esc(sub)}</p>" if sub else ''
|
||
state_class=f' state-{state}' if state else ''
|
||
smart_attr=f" data-smart-state='{esc(state)}'" if smart and state else ''
|
||
return f"<details class='collapsible {esc(extra_class)}{state_class}' data-section-key='{esc(key)}'{smart_attr}{open_attr}><summary><div class='collapsible-heading'><h2>{esc(title)}</h2>{sub_html}</div><span class='collapse-indicator' aria-hidden='true'>▾</span></summary><div class='collapsible-body'>{inner_html}</div></details>"
|
||
|
||
def inject_dashboard_todos(items:list[dict[str,Any]])->list[dict[str,Any]]:
|
||
out=list(items or [])
|
||
title='Paperless notes/tags audit'
|
||
if not any((x.get('title') or '').strip().lower()==title.lower() for x in out):
|
||
out.insert(0,{"title":title,"time":"","body":"Review and correct all Paperless notes and tags. Keep this visible until the wider cleanup is actually done.","assignee":"fizzlepoof","priority":2,"priority_text":"P2","due":"","due_title":"Pinned follow-up","state":"today","subtitle":"Dashboard • P2","chips":[],"source":"Dashboard"})
|
||
return out
|
||
|
||
def load_paperless_review()->list[dict[str,Any]]:
|
||
p=DATA/'paperless_review.json'
|
||
remote=os.environ.get('PAPERLESS_TRIAGE_REMOTE_QUEUE','truenas_admin@10.5.1.6:/mnt/docker-ssd/docker/appdata/n8n/paperless-triage/paperless_review.json')
|
||
ssh_key=os.environ.get('PAPERLESS_TRIAGE_SSH_KEY','/home/fizzlepoof/.ssh/id_ed25519_andys')
|
||
if remote:
|
||
tmp=DATA/'paperless_review.remote.tmp'
|
||
try:
|
||
cmd=['scp','-q','-o','ConnectTimeout=8']
|
||
if ssh_key and Path(ssh_key).exists():
|
||
cmd.extend(['-i',ssh_key])
|
||
cmd.extend([remote,str(tmp)])
|
||
res=subprocess.run(cmd,capture_output=True,text=True,timeout=12)
|
||
if res.returncode==0 and tmp.exists(): tmp.replace(p)
|
||
elif tmp.exists(): tmp.unlink()
|
||
except Exception:
|
||
try: tmp.unlink()
|
||
except Exception: pass
|
||
try: return json.loads(p.read_text())
|
||
except Exception: return []
|
||
|
||
def load_paperless_state()->dict[str,Any]:
|
||
return load_json(PAPERLESS_STATE_PATH,{}) or {}
|
||
|
||
def paperless_focus_summary(items:list[dict[str,Any]]|None=None,state:dict[str,Any]|None=None)->dict[str,Any]:
|
||
items=items if items is not None else load_paperless_review()
|
||
state=state if state is not None else load_paperless_state()
|
||
active=[]; flagged=[]
|
||
for item in items:
|
||
status=((state.get(str(item.get('id'))) or {}).get('status') or '').lower()
|
||
if status in {'dismissed','good_to_go'}:
|
||
continue
|
||
if status in {'acknowledged','needs_attention'}:
|
||
flagged.append(item)
|
||
else:
|
||
active.append(item)
|
||
headline=(flagged[0] if flagged else (active[0] if active else {})).get('title') or 'No documents waiting'
|
||
return {'active_count':len(active),'flagged_count':len(flagged),'headline':headline}
|
||
|
||
def paperless_review_section()->str:
|
||
items=load_paperless_review()
|
||
state=load_paperless_state()
|
||
if not items: return collapsible_section('📄 Paperless Review','No documents waiting.','<p class="empty">No documents waiting.</p>','paperless-review',open_by_default=False,extra_class='panel')
|
||
urgency_class={'high':'warn','medium':'info','low':'ok','none':'ok'}
|
||
active=[]; needs_attention=[]
|
||
for item in items:
|
||
status=((state.get(str(item.get('id'))) or {}).get('status') or '').lower()
|
||
if status in {'dismissed','good_to_go'}:
|
||
continue
|
||
if status=='acknowledged':
|
||
status='needs_attention'
|
||
(needs_attention if status=='needs_attention' else active).append(item)
|
||
def render_card(item:dict[str,Any], needs_attention_card:bool=False)->str:
|
||
triage=item.get('triage',{}) or {}
|
||
current=item.get('current',{}) or {}
|
||
urgency=triage.get('urgency','none')
|
||
summary=strip_markup(triage.get('summary',''))
|
||
reason=strip_markup(triage.get('reason',''))
|
||
meta_parts=[x for x in [triage.get('document_type',''), current.get('correspondent','')] if x]
|
||
meta=' • '.join(str(x) for x in meta_parts)
|
||
status_class=' needs-attention' if needs_attention_card else ''
|
||
primary_label='Clear flag' if needs_attention_card else 'Needs attention'
|
||
primary_action='needs_attention'
|
||
return f"""<article class='paperless-card {urgency_class.get(urgency,'ok')}{status_class}' data-paperless-id='{esc(item.get('id'))}'>
|
||
<div class='paperless-head'><div class='meta'><span class='urgency {urgency_class.get(urgency,'ok')}' data-urgency='{esc(urgency)}'>{esc(str(urgency).upper())}</span><span>{esc(item.get('original_filename') or 'Document #'+str(item.get('id','')))}</span></div><div class='paperless-actions'><button type='button' class='paperless-btn' data-paperless-action='{primary_action}'>{primary_label}</button><button type='button' class='paperless-btn good' data-paperless-action='good_to_go'>Good to go</button>{f"<a href='{esc(item.get('archive_url',''))}' class='link' target='_blank' rel='noreferrer'>View in Paperless</a>" if item.get('archive_url') else ''}</div></div>
|
||
<h4>{esc(item.get('title') or triage.get('suggested_title','Untitled'))}</h4>
|
||
{f"<p class='summary'>{esc(summary)}</p>" if summary else ''}
|
||
{f"<p class='paperless-meta'>{esc(meta)}</p>" if meta else ''}
|
||
{f"<p class='paperless-reason'>{esc(reason)}</p>" if reason else ''}
|
||
</article>"""
|
||
visible_active=active[:3]
|
||
overflow_active=active[3:]
|
||
active_cards=''.join(render_card(item,False) for item in visible_active)
|
||
flagged_cards=''.join(render_card(item,True) for item in needs_attention[:8])
|
||
count=len(active)
|
||
flag_count=len(needs_attention)
|
||
empty_active="<p class='empty'>No active documents waiting.</p>"
|
||
body=f"<div class='paperless-grid'>{active_cards or empty_active}</div>"
|
||
if overflow_active:
|
||
body += f"<details class='paperless-more'><summary>Show {esc(str(len(overflow_active)))} more active items</summary><div class='paperless-grid overflow-grid'>{''.join(render_card(item,False) for item in overflow_active[:8])}</div></details>"
|
||
if flag_count:
|
||
body += f"<details class='paperless-acked' open><summary>Needs attention <span class='badge'>{esc(str(flag_count))}</span></summary><div class='paperless-grid acked-grid'>{flagged_cards}</div><p class='empty'>Flagged items stay here so I can revisit them later and, if needed, ask you about the issue.</p></details>"
|
||
if count+flag_count>3:
|
||
body += f"<p class='empty'>Showing {esc(str(min(count,3)))} active up front and keeping the rest tucked away to cut page bloat.</p>"
|
||
return collapsible_section(f'📄 Paperless Review ({count} active)',f'{flag_count} flagged for follow-up · review queue written by n8n paperless-intake-triage workflow.',body,'paperless-review',open_by_default=(count+flag_count)>0,extra_class='panel')
|
||
|
||
def list_panel(title:str,items:list[dict[str,Any]],empty:str)->str:
|
||
if not items:
|
||
body=f"<li class='empty'>{esc(empty)}</li>"
|
||
else:
|
||
rows=[]
|
||
for x in items[:8]:
|
||
kicker=x.get('time') or x.get('title') or x.get('label')
|
||
headline=x.get('title') if x.get('time') else ''
|
||
assignee=x.get('assignee') or ''
|
||
detail=x.get('body') or x.get('summary') or x.get('value') or ''
|
||
assignee_html=f"<span class='muted'>{esc(assignee)}</span>" if assignee else ''
|
||
headline_html=f"<div class='panel-item-title'>{esc(headline)}</div>" if headline else ''
|
||
detail_html=f"<div class='panel-item-body'>{esc(detail)}</div>" if detail else ''
|
||
rows.append(f"<li class='panel-item'><div class='panel-item-top'><strong>{esc(kicker)}</strong>{assignee_html}</div>{headline_html}{detail_html}</li>")
|
||
body=''.join(rows)
|
||
return f"<section class='panel'><h2>{esc(title)}</h2><ul>{body}</ul></section>"
|
||
|
||
def donetick_panel(items:list[dict[str,Any]],empty:str)->str:
|
||
if not items:
|
||
return f"<section class='panel donetick-panel'><h2>Donetick</h2><div class='empty'>{esc(empty)}</div></section>"
|
||
rows=[]
|
||
for x in items[:6]:
|
||
chips=''.join(f"<span class='task-chip' style='background:{esc(c.get('color','#607d8b'))};'>{esc(c.get('name',''))}</span>" for c in (x.get('chips') or []))
|
||
subtitle_text=(x.get('subtitle') or '').strip()
|
||
chip_names={str(c.get('name','')).strip().lower() for c in (x.get('chips') or []) if c.get('name')}
|
||
subtitle_parts=[]
|
||
for part in [p.strip() for p in subtitle_text.split('•') if p.strip()]:
|
||
if part.lower() in chip_names:
|
||
continue
|
||
subtitle_parts.append(part)
|
||
subtitle=' • '.join(subtitle_parts)
|
||
state=esc(x.get('state') or 'upcoming')
|
||
due_style=''
|
||
if state=='overdue': due_style=' style="color:#ff6b6b;"'
|
||
elif x.get('priority') in PRIORITY_COLORS: due_style=f' style="color:{esc(PRIORITY_COLORS[x.get("priority")])};"'
|
||
assignee_html=f"<span class='task-assignee'>{esc(x.get('assignee') or '')}</span>" if x.get('assignee') and x.get('assignee')!='Unassigned' else ''
|
||
chips_html=f"<div class='task-chips'>{chips}</div>" if chips else ''
|
||
subtitle_html=f"<div class='task-subtitle'>{esc(subtitle)}</div>" if subtitle else ''
|
||
done_button=f"<button type='button' class='task-done-btn' data-donetick-complete data-task-id='{esc(x.get('id') or '')}'>Mark done</button>" if x.get('id') else ''
|
||
rows.append(f"<article class='task-card {state}' data-task-id='{esc(x.get('id') or '')}'><div class='task-top'><div class='task-state-dot' aria-hidden='true'></div><div class='task-due'{due_style}>{esc(x.get('due_title') or x.get('time') or 'No due date')}</div>{assignee_html}</div><div class='task-name'>{esc(x.get('title') or 'Untitled task')}</div>{chips_html}{subtitle_html}{done_button}</article>")
|
||
return f"<section class='panel donetick-panel'><h2>Donetick</h2><div class='task-grid'>{''.join(rows)}</div></section>"
|
||
|
||
def feedback_bootstrap()->str:
|
||
return """<script>
|
||
(()=>{
|
||
const KEY='doris-dashboard-topic-prefs-v2';
|
||
const HIDDEN_CARD_KEY='doris-dashboard-hidden-cards-v1';
|
||
const COLLAPSE_KEY='doris-dashboard-collapsed-v1';
|
||
const safeRead=()=>{try{return JSON.parse(localStorage.getItem(KEY)||'{"hidden":[]}')}catch(e){return {hidden:[]}}};
|
||
const safeHiddenCards=()=>{try{return JSON.parse(localStorage.getItem(HIDDEN_CARD_KEY)||'[]')}catch(e){return []}};
|
||
const safeCollapse=()=>{try{return JSON.parse(localStorage.getItem(COLLAPSE_KEY)||'{}')}catch(e){return {}}};
|
||
const save=(prefs)=>localStorage.setItem(KEY, JSON.stringify({hidden:[...new Set(prefs.hidden||[])]}));
|
||
const saveHiddenCards=(ids)=>localStorage.setItem(HIDDEN_CARD_KEY, JSON.stringify([...new Set(ids||[])]));
|
||
const prefs=safeRead();
|
||
let hiddenCards=safeHiddenCards();
|
||
const collapsed=safeCollapse();
|
||
const cards=[...document.querySelectorAll('[data-topic]')];
|
||
const sections=[...document.querySelectorAll('details[data-section-key]')];
|
||
const toast=document.createElement('div');
|
||
toast.className='dashboard-toast';
|
||
toast.hidden=true;
|
||
document.body.appendChild(toast);
|
||
let lastAction=null;
|
||
let toastTimer=null;
|
||
const postJson=(url,payload)=>fetch(url,{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify(payload)}).then(r=>r.ok?r.json():r.json().catch(()=>({})).then(err=>Promise.reject(err)));
|
||
const getJson=(url)=>fetch(url,{headers:{'Accept':'application/json'}}).then(r=>r.ok?r.json():r.json().catch(()=>({})).then(err=>Promise.reject(err)));
|
||
const cardId=(card)=>card.querySelector('h3 a')?.getAttribute('href')||card.querySelector('h3 a')?.textContent||card.dataset.topic||Math.random().toString(36).slice(2);
|
||
cards.forEach(card=>{card.dataset.cardId=cardId(card);});
|
||
const setToast=(html)=>{
|
||
toast.innerHTML=html;
|
||
toast.hidden=false;
|
||
clearTimeout(toastTimer);
|
||
toastTimer=setTimeout(()=>{toast.hidden=true;},4500);
|
||
};
|
||
const sync=()=>{
|
||
cards.forEach(card=>{
|
||
const topic=card.dataset.topic||'other';
|
||
const hidden=(prefs.hidden||[]).includes(topic) || hiddenCards.includes(card.dataset.cardId||'');
|
||
card.style.display=hidden?'none':'';
|
||
card.classList.remove('topic-liked');
|
||
card.querySelectorAll('[data-feedback]').forEach(btn=>{
|
||
btn.setAttribute('aria-pressed', 'false');
|
||
btn.classList.toggle('active-up', false);
|
||
btn.classList.toggle('active-down', false);
|
||
});
|
||
});
|
||
const badge=document.querySelector('[data-hidden-topics-count]');
|
||
if (badge) badge.textContent=String(hiddenCards.length);
|
||
};
|
||
sections.forEach(sec=>{
|
||
const key=sec.dataset.sectionKey;
|
||
if(sec.dataset.smartState){
|
||
sec.open=sec.dataset.smartState==='warn';
|
||
} else if(Object.prototype.hasOwnProperty.call(collapsed,key)) sec.open=!collapsed[key];
|
||
sec.addEventListener('toggle',()=>{
|
||
collapsed[key]=!sec.open;
|
||
localStorage.setItem(COLLAPSE_KEY, JSON.stringify(collapsed));
|
||
});
|
||
});
|
||
document.addEventListener('click', (ev)=>{
|
||
const btn=ev.target.closest('[data-feedback]');
|
||
if(!btn) return;
|
||
const card=btn.closest('[data-topic]');
|
||
if(!card) return;
|
||
const topic=card.dataset.topic||'other';
|
||
const id=card.dataset.cardId||'';
|
||
if(btn.dataset.feedback==='down'){
|
||
lastAction={prefs:JSON.parse(JSON.stringify(prefs)), hiddenCards:[...hiddenCards]};
|
||
hiddenCards=hiddenCards.filter(x=>x!==id);
|
||
hiddenCards.push(id);
|
||
saveHiddenCards(hiddenCards);
|
||
setToast(`Right — less <strong>${topic}</strong> like this, and this story’s off the board. <button type="button" class="toast-action" data-undo-topic>Undo</button>`);
|
||
} else {
|
||
lastAction={prefs:JSON.parse(JSON.stringify(prefs)), hiddenCards:[...hiddenCards]};
|
||
hiddenCards=hiddenCards.filter(x=>x!==id);
|
||
hiddenCards.push(id);
|
||
saveHiddenCards(hiddenCards);
|
||
setToast(`Right — I’ll look for more <strong>${topic}</strong> like this, and I’ve cleared this story off the board. <button type="button" class="toast-action" data-undo-topic>Undo</button>`);
|
||
}
|
||
save(prefs); sync();
|
||
postJson('/api/topic-feedback',{term:topic,vote:btn.dataset.feedback==='down'?'down':'up',source:card.dataset.source||'',domain:card.dataset.domain||''}).catch(err=>console.warn('topic feedback failed',err));
|
||
});
|
||
document.addEventListener('click',(ev)=>{
|
||
const undo=ev.target.closest('[data-undo-topic]');
|
||
if(!undo || !lastAction) return;
|
||
prefs.hidden=[...(lastAction.prefs.hidden||[])];
|
||
hiddenCards=[...(lastAction.hiddenCards||[])];
|
||
save(prefs); saveHiddenCards(hiddenCards); sync();
|
||
setToast('Undid the last topic/story action.');
|
||
});
|
||
document.addEventListener('click',(ev)=>{
|
||
const btn=ev.target.closest('[data-donetick-complete]');
|
||
if(btn){
|
||
const taskId=btn.dataset.taskId || btn.closest('[data-task-id]')?.dataset.taskId || '';
|
||
if(!taskId) return;
|
||
btn.disabled=true;
|
||
btn.textContent='Completing…';
|
||
postJson('/api/donetick-complete',{id:taskId}).then(()=>{
|
||
setToast('Marked done in Donetick. Refreshing dashboard state…');
|
||
window.setTimeout(()=>window.location.reload(),350);
|
||
}).catch(err=>{
|
||
console.warn('donetick completion failed',err);
|
||
btn.disabled=false;
|
||
btn.textContent='Mark done';
|
||
setToast('Donetick completion failed. Try again in a moment.');
|
||
});
|
||
return;
|
||
}
|
||
});
|
||
document.addEventListener('click',(ev)=>{
|
||
const btn=ev.target.closest('[data-paperless-action]');
|
||
if(!btn) return;
|
||
const card=btn.closest('[data-paperless-id]');
|
||
if(!card) return;
|
||
const id=card.dataset.paperlessId;
|
||
const action=btn.dataset.paperlessAction;
|
||
btn.disabled=true;
|
||
postJson('/api/paperless-action',{id,action}).then(()=>{
|
||
window.location.reload();
|
||
}).catch(err=>{console.warn('paperless action failed',err); btn.disabled=false;});
|
||
});
|
||
const pollDonetickFocus=(()=>{
|
||
let inFlight=false;
|
||
return ()=>{
|
||
const current=document.body?.dataset?.donetickFocusSignature||'';
|
||
if(!current || document.hidden || inFlight) return;
|
||
inFlight=true;
|
||
getJson(`/api/donetick-focus-state?current=${encodeURIComponent(current)}`).then(data=>{
|
||
if(data && data.signature){
|
||
document.body.dataset.donetickFocusSignature=data.signature;
|
||
}
|
||
if(data && data.changed){
|
||
setToast('Donetick changed outside the dashboard. Reloading focus cards…');
|
||
window.setTimeout(()=>window.location.reload(),300);
|
||
}
|
||
}).catch(err=>{
|
||
console.warn('donetick focus poll failed',err);
|
||
}).finally(()=>{
|
||
inFlight=false;
|
||
});
|
||
};
|
||
})();
|
||
window.setInterval(pollDonetickFocus, 60000);
|
||
window.setTimeout(pollDonetickFocus, 60000);
|
||
const reset=document.querySelector('[data-reset-topic-prefs]');
|
||
if(reset){reset.addEventListener('click',()=>{prefs.hidden=[]; hiddenCards=[]; save(prefs); saveHiddenCards(hiddenCards); sync(); setToast('Reset hidden stories and local topic hides.'); postJson('/api/topic-feedback/reset',{}).catch(err=>console.warn('reset feedback failed',err));});}
|
||
sync();
|
||
})();
|
||
</script>"""
|
||
|
||
def metric_card(title:str,value:str,sub:str,cls:str='')->str:
|
||
severity=cls if cls in SECTION_STATE_RANK else ''
|
||
severity_attr=f" data-severity='{esc(severity)}'" if severity else ''
|
||
return f"<div class='metric {esc(cls)}'{severity_attr}><span>{esc(title)}</span><strong>{esc(value)}</strong><em>{esc(sub)}</em></div>"
|
||
|
||
def load_wind_watchdog_notice()->dict[str,Any]:
|
||
state=load_json(WIND_WATCHDOG_STATE_PATH,{}) or {}
|
||
notice=state.get('dashboard_notice') or {}
|
||
return notice if notice.get('active') else {}
|
||
|
||
def forecast_panel(weather:dict[str,Any])->str:
|
||
if not weather.get('ok'):
|
||
return ""
|
||
daily=weather.get('daily',{}) or {}
|
||
days=daily.get('time') or []
|
||
highs=daily.get('temperature_2m_max') or []
|
||
lows=daily.get('temperature_2m_min') or []
|
||
precip=daily.get('precipitation_probability_max') or []
|
||
codes=daily.get('weather_code') or []
|
||
cards=[]
|
||
day_slice=days[1:4] if len(days) > 1 else days[:3]
|
||
start_idx=1 if len(days) > 1 else 0
|
||
for offset, day in enumerate(day_slice):
|
||
idx=start_idx + offset
|
||
try:
|
||
dt=datetime.fromisoformat(day)
|
||
label=dt.strftime('%a')
|
||
full_label=dt.strftime('%A')
|
||
except Exception:
|
||
label=day
|
||
full_label=day
|
||
high=highs[idx] if idx < len(highs) else None
|
||
low=lows[idx] if idx < len(lows) else None
|
||
rain=precip[idx] if idx < len(precip) else '—'
|
||
condition=WEATHER_CODES.get(codes[idx],'Forecast') if idx < len(codes) else 'Forecast'
|
||
cards.append(f"""<article class='forecast-card'>
|
||
<span class='forecast-day'>{esc(label)}</span>
|
||
<strong>{esc(full_label)}</strong>
|
||
<div class='forecast-temps'>{esc(c_to_f(high))} <span>/ {esc(c_to_f(low))}</span></div>
|
||
<em>{esc(condition)}</em>
|
||
<div class='forecast-meta'>Rain chance {esc(str(rain))}%</div>
|
||
</article>""")
|
||
if not cards:
|
||
return ""
|
||
return collapsible_section('3-day forecast','Next three days: conditions, highs/lows, and rain chance.',f"<div class='forecast-grid'>{''.join(cards)}</div>",'forecast',open_by_default=True,extra_class='panel forecast-panel')
|
||
|
||
def weather_overview_panel(weather:dict[str,Any], wind_notice:dict[str,Any]|None=None)->str:
|
||
if not weather.get('ok'):
|
||
return collapsible_section('Weather','Current weather unavailable.',f"<section class='metrics metrics-compact'>{metric_card('Weather','Unavailable',weather.get('error','API issue'),'warn')}</section>",'weather-overview',open_by_default=True)
|
||
cur=weather.get('current',{}) or {}
|
||
daily=weather.get('daily',{}) or {}
|
||
highs=daily.get('temperature_2m_max') or []
|
||
lows=daily.get('temperature_2m_min') or []
|
||
precip=daily.get('precipitation_probability_max') or []
|
||
today_high=highs[0] if highs else None
|
||
today_low=lows[0] if lows else None
|
||
today_rain=precip[0] if precip else weather.get('max_precip',0)
|
||
notice=wind_notice or {}
|
||
notice_html=''
|
||
notice_state=''
|
||
if notice:
|
||
notice_state=str(notice.get('state') or 'attention')
|
||
notice_title=notice.get('title') or 'Weather heads-up'
|
||
notice_headline=notice.get('headline') or ''
|
||
notice_body=notice.get('body') or ''
|
||
notice_timing=notice.get('timing') or ''
|
||
lead_hours=notice.get('lead_hours')
|
||
lead_html=f"<span>Lead {esc(str(lead_hours))}h</span>" if lead_hours not in (None,'') else ''
|
||
timing_html=f"<span>{esc(notice_timing)}</span>" if notice_timing else ''
|
||
notice_html=f"""
|
||
<article class='weather-alert-card {esc(notice_state)}'>
|
||
<div class='weather-alert-top'>
|
||
<span class='weather-alert-kicker'>{esc(notice_title)}</span>
|
||
<span class='weather-alert-state'>{esc(notice_state.upper())}</span>
|
||
</div>
|
||
{f"<strong>{esc(notice_headline)}</strong>" if notice_headline else ''}
|
||
{f"<p>{esc(notice_body)}</p>" if notice_body else ''}
|
||
<div class='weather-alert-meta'>{lead_html}{timing_html}</div>
|
||
</article>"""
|
||
overview=f"""
|
||
<section class='weather-overview'>
|
||
<article class='weather-now-card'>
|
||
<div class='weather-now-top'>
|
||
<span class='weather-kicker'>Clarksville</span>
|
||
<span class='weather-source'>{esc(weather.get('source',''))}</span>
|
||
</div>
|
||
<div class='weather-now-main'>
|
||
<strong>{esc(c_to_f(cur.get('temperature_2m')))}</strong>
|
||
<div>
|
||
<div class='weather-condition'>{esc(weather.get('condition','Current conditions'))}</div>
|
||
<div class='weather-range'>Today {esc(c_to_f(today_high))} / {esc(c_to_f(today_low))}</div>
|
||
</div>
|
||
</div>
|
||
<div class='weather-detail-row'>
|
||
<span>Feels {esc(c_to_f(cur.get('apparent_temperature')))}</span>
|
||
<span>Humidity {esc(str(cur.get('relative_humidity_2m','—')))}%</span>
|
||
<span>Wind {esc(kmh_to_mph(cur.get('wind_speed_10m')))}</span>
|
||
<span>Rain {esc(str(today_rain))}%</span>
|
||
</div>
|
||
</article>
|
||
{notice_html}
|
||
</section>"""
|
||
sub='Today first, then the next three days.' if not notice else 'Weather first. Longer-range wind heads-up stays here until it is close enough to deserve a ping.'
|
||
return collapsible_section('Weather',sub,overview,'weather-overview',open_by_default=True,extra_class='panel weather-panel',state=notice_state,smart=bool(notice_state))
|
||
|
||
def fetch_hermes_usage(days:int=30)->dict[str,Any]:
|
||
config=read_hermes_model_config()
|
||
stats={
|
||
'ok':False,
|
||
'period_days':days,
|
||
'default_model':config.get('default_model','unknown'),
|
||
'provider':config.get('provider','unknown'),
|
||
'sessions':0,
|
||
'messages':0,
|
||
'tool_calls':0,
|
||
'user_messages':0,
|
||
'assistant_messages':0,
|
||
'total_tokens':0,
|
||
'input_tokens':0,
|
||
'output_tokens':0,
|
||
'cache_read_tokens':0,
|
||
'cache_write_tokens':0,
|
||
'reasoning_tokens':0,
|
||
'last_24h_tokens':0,
|
||
'last_24h_sessions':0,
|
||
'last_24h_tool_calls':0,
|
||
'last_7d_tokens':0,
|
||
'avg_tokens_per_session':0,
|
||
'avg_tool_calls_per_session':0,
|
||
'cache_share_percent':None,
|
||
'models':[],
|
||
'platforms':[],
|
||
'top_tools':[],
|
||
'recent_sessions':[],
|
||
'latest_session':None,
|
||
'account_windows':[],
|
||
'generated_at':datetime.now(LOCAL_TZ).isoformat(),
|
||
}
|
||
if not HERMES_STATE_DB.exists():
|
||
stats['error']='Hermes state DB not found'
|
||
return stats
|
||
now_ts=time.time()
|
||
cutoff=now_ts-(days*86400)
|
||
day_cutoff=now_ts-86400
|
||
week_cutoff=now_ts-(7*86400)
|
||
try:
|
||
conn=sqlite3.connect(f"file:{HERMES_STATE_DB}?mode=ro", uri=True)
|
||
conn.row_factory=sqlite3.Row
|
||
cur=conn.cursor()
|
||
overview=cur.execute("""
|
||
SELECT
|
||
count(*) AS sessions,
|
||
sum(coalesce(input_tokens,0)) AS input_tokens,
|
||
sum(coalesce(output_tokens,0)) AS output_tokens,
|
||
sum(coalesce(cache_read_tokens,0)) AS cache_read_tokens,
|
||
sum(coalesce(cache_write_tokens,0)) AS cache_write_tokens,
|
||
sum(coalesce(reasoning_tokens,0)) AS reasoning_tokens,
|
||
sum(coalesce(api_call_count,0)) AS api_calls
|
||
FROM sessions
|
||
WHERE started_at >= ?
|
||
""",(cutoff,)).fetchone()
|
||
stats.update({
|
||
'sessions':int((overview['sessions'] or 0) if overview else 0),
|
||
'input_tokens':int((overview['input_tokens'] or 0) if overview else 0),
|
||
'output_tokens':int((overview['output_tokens'] or 0) if overview else 0),
|
||
'cache_read_tokens':int((overview['cache_read_tokens'] or 0) if overview else 0),
|
||
'cache_write_tokens':int((overview['cache_write_tokens'] or 0) if overview else 0),
|
||
'reasoning_tokens':int((overview['reasoning_tokens'] or 0) if overview else 0),
|
||
})
|
||
stats['total_tokens']=stats['input_tokens']+stats['output_tokens']+stats['cache_read_tokens']+stats['cache_write_tokens']+stats['reasoning_tokens']
|
||
stats['cache_share_percent']=percent_value(stats['cache_read_tokens'], stats['total_tokens'])
|
||
stats['avg_tokens_per_session']=round(stats['total_tokens']/stats['sessions']) if stats['sessions'] else 0
|
||
row=cur.execute("SELECT count(*) AS c FROM messages WHERE role != 'session_meta' AND timestamp >= ?",(cutoff,)).fetchone()
|
||
stats['messages']=int((row['c'] or 0) if row else 0)
|
||
row=cur.execute("SELECT count(*) AS c FROM messages WHERE role='tool' AND timestamp >= ?",(cutoff,)).fetchone()
|
||
stats['tool_calls']=int((row['c'] or 0) if row else 0)
|
||
stats['avg_tool_calls_per_session']=round(stats['tool_calls']/stats['sessions'],1) if stats['sessions'] else 0
|
||
row=cur.execute("SELECT count(*) AS c FROM messages WHERE role='user' AND timestamp >= ?",(cutoff,)).fetchone()
|
||
stats['user_messages']=int((row['c'] or 0) if row else 0)
|
||
row=cur.execute("SELECT count(*) AS c FROM messages WHERE role='assistant' AND timestamp >= ?",(cutoff,)).fetchone()
|
||
stats['assistant_messages']=int((row['c'] or 0) if row else 0)
|
||
row=cur.execute("""
|
||
SELECT count(*) AS sessions,
|
||
sum(coalesce(input_tokens,0)+coalesce(output_tokens,0)+coalesce(cache_read_tokens,0)+coalesce(cache_write_tokens,0)+coalesce(reasoning_tokens,0)) AS total_tokens
|
||
FROM sessions
|
||
WHERE started_at >= ?
|
||
""",(day_cutoff,)).fetchone()
|
||
stats['last_24h_sessions']=int((row['sessions'] or 0) if row else 0)
|
||
stats['last_24h_tokens']=int((row['total_tokens'] or 0) if row else 0)
|
||
row=cur.execute("SELECT count(*) AS c FROM messages WHERE role='tool' AND timestamp >= ?",(day_cutoff,)).fetchone()
|
||
stats['last_24h_tool_calls']=int((row['c'] or 0) if row else 0)
|
||
row=cur.execute("""
|
||
SELECT sum(coalesce(input_tokens,0)+coalesce(output_tokens,0)+coalesce(cache_read_tokens,0)+coalesce(cache_write_tokens,0)+coalesce(reasoning_tokens,0)) AS total_tokens
|
||
FROM sessions
|
||
WHERE started_at >= ?
|
||
""",(week_cutoff,)).fetchone()
|
||
stats['last_7d_tokens']=int((row['total_tokens'] or 0) if row else 0)
|
||
stats['models']=[dict(r) for r in cur.execute("""
|
||
SELECT model, count(*) AS sessions,
|
||
sum(coalesce(input_tokens,0)+coalesce(output_tokens,0)+coalesce(cache_read_tokens,0)+coalesce(cache_write_tokens,0)+coalesce(reasoning_tokens,0)) AS total_tokens
|
||
FROM sessions
|
||
WHERE started_at >= ?
|
||
GROUP BY model
|
||
ORDER BY total_tokens DESC, sessions DESC
|
||
LIMIT 5
|
||
""",(cutoff,))]
|
||
stats['platforms']=[dict(r) for r in cur.execute("""
|
||
SELECT source, count(*) AS sessions,
|
||
sum(coalesce(input_tokens,0)+coalesce(output_tokens,0)+coalesce(cache_read_tokens,0)+coalesce(cache_write_tokens,0)+coalesce(reasoning_tokens,0)) AS total_tokens
|
||
FROM sessions
|
||
WHERE started_at >= ?
|
||
GROUP BY source
|
||
ORDER BY total_tokens DESC, sessions DESC
|
||
LIMIT 5
|
||
""",(cutoff,))]
|
||
stats['top_tools']=[dict(r) for r in cur.execute("""
|
||
SELECT tool_name, count(*) AS calls
|
||
FROM messages
|
||
WHERE role='tool' AND tool_name IS NOT NULL AND tool_name != '' AND timestamp >= ?
|
||
GROUP BY tool_name
|
||
ORDER BY calls DESC, tool_name ASC
|
||
LIMIT 8
|
||
""",(cutoff,))]
|
||
stats['recent_sessions']=[dict(r) for r in cur.execute("""
|
||
SELECT source, model, started_at,
|
||
(coalesce(input_tokens,0)+coalesce(output_tokens,0)+coalesce(cache_read_tokens,0)+coalesce(cache_write_tokens,0)+coalesce(reasoning_tokens,0)) AS total_tokens,
|
||
coalesce(api_call_count,0) AS api_calls
|
||
FROM sessions
|
||
WHERE started_at >= ?
|
||
ORDER BY started_at DESC
|
||
LIMIT 5
|
||
""",(cutoff,))]
|
||
for item in stats['recent_sessions']:
|
||
started=item.get('started_at')
|
||
try: item['started_local']=datetime.fromtimestamp(float(started), LOCAL_TZ).strftime('%a %-I:%M %p')
|
||
except Exception: item['started_local']='recent'
|
||
stats['latest_session']=stats['recent_sessions'][0] if stats['recent_sessions'] else None
|
||
try:
|
||
hermes_agent_root=HERMES_HOME/'hermes-agent'
|
||
hermes_agent_python=hermes_agent_root/'venv'/'bin'/'python'
|
||
if hermes_agent_python.exists():
|
||
script=(
|
||
"import importlib, json\n"
|
||
"from zoneinfo import ZoneInfo\n"
|
||
"fetch_account_usage=getattr(importlib.import_module('agent.account_usage'),'fetch_account_usage')\n"
|
||
"snapshot=fetch_account_usage('openai-codex')\n"
|
||
"windows=[]\n"
|
||
"if snapshot:\n"
|
||
" local_tz=ZoneInfo('America/Chicago')\n"
|
||
" for window in getattr(snapshot,'windows',()):\n"
|
||
" reset_at=getattr(window,'reset_at',None)\n"
|
||
" used=float(getattr(window,'used_percent',0.0) or 0.0)\n"
|
||
" windows.append({'label': str(getattr(window,'label','') or ''), 'used_percent': used, 'remaining_percent': max(0.0,100.0-used), 'reset_local': reset_at.astimezone(local_tz).strftime('%a %-I:%M %p') if reset_at else 'unknown'})\n"
|
||
"print(json.dumps(windows))\n"
|
||
)
|
||
res=subprocess.run([str(hermes_agent_python),'-c',script],capture_output=True,text=True,timeout=20,check=True,cwd=str(hermes_agent_root))
|
||
stats['account_windows']=json.loads(res.stdout or '[]')
|
||
except Exception:
|
||
stats['account_windows']=[]
|
||
stats['ok']=True
|
||
conn.close()
|
||
return stats
|
||
except Exception:
|
||
stats['error']='Hermes telemetry is temporarily unavailable.'
|
||
return stats
|
||
|
||
def focus_card(title:str,kicker:str,headline:str,body:str,tone:str='')->str:
|
||
severity=''
|
||
for token in str(tone).split():
|
||
if token in SECTION_STATE_RANK:
|
||
severity=token
|
||
break
|
||
severity_attr=f" data-severity='{esc(severity)}'" if severity else ''
|
||
return f"<article class='focus-card {esc(tone)}'{severity_attr}><span class='focus-kicker'>{esc(kicker)}</span><h3>{esc(title)}</h3><strong>{esc(headline)}</strong><p>{esc(body)}</p></article>"
|
||
|
||
|
||
def build_focus_cards(local_items:list[dict[str,Any]], todos:list[dict[str,Any]], pulse:list[dict[str,str]], paperless:dict[str,Any], hermes:dict[str,Any])->tuple[str,str]:
|
||
urgent_todos=[item for item in todos if (item.get('state') or '') in {'overdue','today'} and (item.get('source') or '') != 'Dashboard']
|
||
warn_items=[item for item in pulse if item.get('state')=='warn']
|
||
local_story=local_items[0] if local_items else None
|
||
session_window=find_usage_window(hermes.get('account_windows',[]), 'session') if hermes.get('ok') else None
|
||
session_remaining=session_window.get('remaining_percent') if session_window else None
|
||
session_reset=str(session_window.get('reset_local') or 'unknown') if session_window else 'unknown'
|
||
hermes_model=(hermes.get('models') or [{}])[0].get('model') or hermes.get('default_model') or 'your main model'
|
||
if urgent_todos:
|
||
chores_headline=f"{len(urgent_todos)} urgent / due today"
|
||
first_urgent=urgent_todos[0]
|
||
chores_body=(first_urgent.get('title') or 'You have work waiting') + (f" • {first_urgent.get('due_title')}" if first_urgent.get('due_title') else '')
|
||
else:
|
||
chores_headline='No urgent chores'
|
||
chores_body='Nothing due soon enough to nag you here.'
|
||
if hermes.get('ok'):
|
||
if session_remaining is not None:
|
||
hermes_headline=f"{hermes_model} · {pct_text(session_remaining)} session left"
|
||
hermes_body=f"{compact_number(hermes.get('last_24h_tokens',0))} tokens in 24h · {compact_number(hermes.get('last_24h_tool_calls',0))} tool calls · resets {session_reset}"
|
||
else:
|
||
hermes_headline=f"{hermes_model} · {compact_number(hermes.get('last_24h_tokens',0))} tokens today"
|
||
hermes_body=f"{compact_number(hermes.get('last_24h_sessions',0))} sessions in 24h · {compact_number(hermes.get('tool_calls',0))} tool calls in {hermes.get('period_days',30)} days"
|
||
else:
|
||
hermes_headline='Hermes telemetry unavailable'
|
||
hermes_body='Could not read local Hermes usage stats right now.'
|
||
local_state='attention' if local_story else 'ok'
|
||
chores_state='warn' if urgent_todos else 'ok'
|
||
paperless_state='warn' if paperless.get('flagged_count',0) else ('ok' if not paperless.get('active_count',0) else 'attention')
|
||
homelab_state='warn' if warn_items else 'ok'
|
||
hermes_state=usage_window_state(session_remaining) if hermes.get('ok') else 'attention'
|
||
cards=[
|
||
focus_card(
|
||
'Local watch',
|
||
'Useful nearby',
|
||
(local_story.get('title') if local_story else 'Local lane quiet'),
|
||
(f"{local_story.get('source','Local feed')} • {label(local_story.get('category','local'))}" if local_story else 'Nothing local survived filtering hard enough to earn the homepage.'),
|
||
f'local {local_state}'.strip()
|
||
),
|
||
focus_card(
|
||
'Chores with heat',
|
||
'Donetick',
|
||
chores_headline,
|
||
chores_body,
|
||
chores_state
|
||
),
|
||
focus_card(
|
||
'Hermes now',
|
||
'Usage / budget',
|
||
hermes_headline,
|
||
hermes_body,
|
||
hermes_state
|
||
),
|
||
focus_card(
|
||
'Paperless follow-up',
|
||
'Queue check',
|
||
(f"{paperless.get('active_count',0)} active · {paperless.get('flagged_count',0)} flagged" if paperless.get('active_count',0) or paperless.get('flagged_count',0) else 'No documents waiting'),
|
||
str(paperless.get('headline') or 'No documents waiting'),
|
||
paperless_state
|
||
),
|
||
focus_card(
|
||
'Homelab pulse',
|
||
'NOMAD checks',
|
||
('Stable' if not warn_items else f"{len(warn_items)} warning{'s' if len(warn_items)!=1 else ''}"),
|
||
('; '.join(f"{item.get('label')}: {item.get('value')}" for item in warn_items[:2]) if warn_items else 'Dashboard service, cron, digest freshness, and disk all look fine.'),
|
||
homelab_state
|
||
),
|
||
]
|
||
section_state=combine_states([local_state,chores_state,hermes_state,paperless_state,homelab_state])
|
||
return ("<section class='focus-grid'>" + ''.join(cards) + "</section>", section_state)
|
||
|
||
|
||
def build_hero_summary(local_items:list[dict[str,Any]], todos:list[dict[str,Any]], pulse:list[dict[str,str]], paperless:dict[str,Any], hermes:dict[str,Any])->str:
|
||
urgent_todos=len([item for item in todos if (item.get('state') or '') in {'overdue','today'} and (item.get('source') or '') != 'Dashboard'])
|
||
warn_count=len([item for item in pulse if item.get('state')=='warn'])
|
||
local_status='local lane has signal' if local_items else 'local lane is quiet'
|
||
paperless_text=f"{paperless.get('active_count',0)} Paperless item{'s' if paperless.get('active_count',0)!=1 else ''}"
|
||
hermes_model=(hermes.get('models') or [{}])[0].get('model') or hermes.get('default_model') or 'your main model'
|
||
session_window=find_usage_window(hermes.get('account_windows',[]), 'session') if hermes.get('ok') else None
|
||
if hermes.get('ok'):
|
||
if session_window and session_window.get('remaining_percent') is not None:
|
||
hermes_text=f"Hermes pushed {compact_number(hermes.get('last_24h_tokens',0))} tokens in the last day on {hermes_model} with {pct_text(session_window.get('remaining_percent'))} session quota left"
|
||
else:
|
||
hermes_text=f"Hermes pushed {compact_number(hermes.get('last_24h_tokens',0))} tokens in the last day on {hermes_model}"
|
||
else:
|
||
hermes_text='Hermes telemetry is unavailable right now'
|
||
return f"{urgent_todos} urgent chore{'s' if urgent_todos!=1 else ''}, {paperless_text}, {warn_count} homelab warning{'s' if warn_count!=1 else ''}, {hermes_text}, and the {local_status}."
|
||
|
||
|
||
def donetick_focus_signature(todos:list[dict[str,Any]])->str:
|
||
urgent=[{
|
||
'id': str(item.get('id') or ''),
|
||
'title': str(item.get('title') or ''),
|
||
'due_title': str(item.get('due_title') or ''),
|
||
'due': str(item.get('due') or ''),
|
||
'state': str(item.get('state') or ''),
|
||
} for item in todos if (item.get('state') or '') in {'overdue','today'} and (item.get('source') or '') != 'Dashboard']
|
||
payload=json.dumps(urgent,separators=(',',':'),sort_keys=True)
|
||
return hashlib.sha1(payload.encode('utf-8')).hexdigest()[:16]
|
||
|
||
|
||
def list_rows(rows:list[str])->str:
|
||
return ''.join(f"<li>{row}</li>" for row in rows) if rows else "<li class='empty'>Nothing to show.</li>"
|
||
|
||
|
||
def build_system_section(snapshot:list[dict[str,str]])->str:
|
||
metrics=''.join(metric_card(item.get('label','Metric'), item.get('value','—'), 'live host state', item.get('state','')) for item in snapshot)
|
||
subtitle='Live NOMAD host state: uptime, load, memory pressure, and root disk usage.'
|
||
state=combine_states([str(item.get('state') or 'ok') for item in snapshot])
|
||
return collapsible_section('System snapshot',subtitle,f"<section class='metrics metrics-compact'>{metrics}</section>",'system-snapshot',open_by_default=(state=='warn'),state=state,smart=True)
|
||
|
||
|
||
def build_hermes_section(hermes:dict[str,Any])->str:
|
||
if not hermes.get('ok'):
|
||
body="<section class='summary-grid'><article class='summary-card'><h3>Hermes telemetry unavailable</h3><p>Local Hermes usage stats could not be read right now.</p></article></section>"
|
||
return collapsible_section('Hermes usage',f"Could not read the last {hermes.get('period_days',30)} days of local Hermes state.",body,'hermes-usage',open_by_default=True)
|
||
session_window=find_usage_window(hermes.get('account_windows',[]), 'session')
|
||
weekly_window=find_usage_window(hermes.get('account_windows',[]), 'week')
|
||
account_cards=[]
|
||
for window in [session_window, weekly_window]:
|
||
if not window:
|
||
continue
|
||
label=str(window.get('label') or 'Usage window')
|
||
remaining_value=window.get('remaining_percent')
|
||
remaining=pct_text(remaining_value)
|
||
used=pct_text(window.get('used_percent'))
|
||
reset_local=str(window.get('reset_local') or 'unknown')
|
||
state=usage_window_state(remaining_value)
|
||
account_cards.append(metric_card(f"Codex {label}",remaining,f"{used} used · resets {reset_local}",state))
|
||
latest=hermes.get('latest_session') or {}
|
||
latest_summary='No recent session rows'
|
||
if latest:
|
||
latest_summary=f"{str(latest.get('source') or 'session').title()} · {str(latest.get('started_local') or 'recent')} · {compact_number(latest.get('total_tokens',0))} tokens"
|
||
metrics=''.join(account_cards + [
|
||
metric_card('Default model',str(hermes.get('default_model','unknown')),str(hermes.get('provider','unknown')),'space'),
|
||
metric_card('Last 24h',compact_number(hermes.get('last_24h_tokens',0)),f"{compact_number(hermes.get('last_24h_sessions',0))} sessions · {compact_number(hermes.get('last_24h_tool_calls',0))} tool calls",'space'),
|
||
metric_card('7-day tokens',compact_number(hermes.get('last_7d_tokens',0)),'rolling week','space'),
|
||
metric_card('Cache reuse',pct_text(hermes.get('cache_share_percent')),f"{compact_number(hermes.get('cache_read_tokens',0))} cached of {compact_number(hermes.get('total_tokens',0))}",'space'),
|
||
metric_card(f"{hermes.get('period_days',30)}-day tokens",compact_number(hermes.get('total_tokens',0)),'all session rows','space'),
|
||
metric_card('Avg session',compact_number(hermes.get('avg_tokens_per_session',0)),f"{compact_number(hermes.get('avg_tool_calls_per_session',0))} tool calls / session",'space'),
|
||
metric_card('Sessions / messages',f"{compact_number(hermes.get('sessions',0))} / {compact_number(hermes.get('messages',0))}",'state.db window','space'),
|
||
metric_card('Latest session',str(latest.get('model') or hermes.get('default_model','unknown')),latest_summary,'space'),
|
||
])
|
||
model_rows=[]
|
||
for item in hermes.get('models',[])[:5]:
|
||
model_rows.append(f"{esc(item.get('model') or 'unknown')} · {compact_number(item.get('sessions',0))} sessions · {compact_number(item.get('total_tokens',0))} tokens")
|
||
platform_rows=[]
|
||
for item in hermes.get('platforms',[])[:5]:
|
||
platform_rows.append(f"{esc((item.get('source') or 'unknown').title())} · {compact_number(item.get('sessions',0))} sessions · {compact_number(item.get('total_tokens',0))} tokens")
|
||
tool_rows=[]
|
||
for item in hermes.get('top_tools',[])[:8]:
|
||
tool_rows.append(f"{esc(item.get('tool_name') or 'tool')} · {compact_number(item.get('calls',0))} calls")
|
||
recent_rows=[]
|
||
for item in hermes.get('recent_sessions',[])[:5]:
|
||
source=(item.get('source') or 'session').title()
|
||
model=item.get('model') or 'unknown'
|
||
recent_rows.append(f"{esc(source)} · {esc(item.get('started_local') or 'recent')} · {esc(model)} · {compact_number(item.get('total_tokens',0))} tokens")
|
||
operator_rows=[
|
||
f"Last 24h burn: {compact_number(hermes.get('last_24h_tokens',0))} tokens across {compact_number(hermes.get('last_24h_sessions',0))} sessions",
|
||
f"Rolling 7-day burn: {compact_number(hermes.get('last_7d_tokens',0))} tokens",
|
||
f"Cache reuse: {pct_text(hermes.get('cache_share_percent'))}",
|
||
f"Average session size: {compact_number(hermes.get('avg_tokens_per_session',0))} tokens",
|
||
]
|
||
detail_html=f"""
|
||
<section class='summary-grid'>
|
||
<article class='summary-card'>
|
||
<h3>Operator read</h3>
|
||
<ul>{list_rows(operator_rows)}</ul>
|
||
</article>
|
||
<article class='summary-card'>
|
||
<h3>Model mix</h3>
|
||
<ul>{list_rows(model_rows)}</ul>
|
||
</article>
|
||
<article class='summary-card'>
|
||
<h3>Platform split</h3>
|
||
<ul>{list_rows(platform_rows)}</ul>
|
||
</article>
|
||
<article class='summary-card'>
|
||
<h3>Top tools</h3>
|
||
<ul>{list_rows(tool_rows)}</ul>
|
||
</article>
|
||
<article class='summary-card'>
|
||
<h3>Recent sessions</h3>
|
||
<ul>{list_rows(recent_rows)}</ul>
|
||
</article>
|
||
</section>
|
||
"""
|
||
body=f"<section class='metrics hermes-metrics'>{metrics}</section>{detail_html}"
|
||
subtitle=f"Live read from ~/.hermes/state.db over the last {hermes.get('period_days',30)} days, plus current Codex budget windows when available."
|
||
return collapsible_section('Hermes usage',subtitle,body,'hermes-usage',open_by_default=True)
|
||
|
||
|
||
def check_service_health(item:dict[str,Any])->dict[str,str]:
|
||
if item.get('probe') is False:
|
||
state=str(item.get('state') or 'attention')
|
||
badge=str(item.get('badge') or ('Healthy' if state=='ok' else 'Manual'))
|
||
detail=str(item.get('detail') or 'manual operator check only')
|
||
return {'state':state,'badge':badge,'detail':detail}
|
||
target=str(item.get('health_url') or item.get('url') or '').strip()
|
||
if not target:
|
||
return {'state':'warn','badge':'Down','detail':'no health URL configured'}
|
||
started=time.time()
|
||
req=urllib.request.Request(target,headers={'User-Agent':'DorisDashboard/1.0'})
|
||
final_url=target
|
||
try:
|
||
with urllib.request.urlopen(req,timeout=8) as r:
|
||
code=getattr(r,'status',200) or 200
|
||
final_url=r.geturl() or target
|
||
elapsed=max(1,int((time.time()-started)*1000))
|
||
detail_parts=[str(code), f'{elapsed} ms']
|
||
lower=final_url.lower()
|
||
if '/auth/resource/' in lower or '/accounts/login/' in lower:
|
||
detail_parts.append('auth gate')
|
||
elif final_url.rstrip('/') != target.rstrip('/'):
|
||
detail_parts.append('redirected')
|
||
return {'state':'ok','badge':'Healthy','detail':' · '.join(detail_parts)}
|
||
except urllib.error.HTTPError as e:
|
||
elapsed=max(1,int((time.time()-started)*1000))
|
||
code=e.code
|
||
if code in {401,403}:
|
||
return {'state':'ok','badge':'Healthy','detail':f'{code} · {elapsed} ms · auth required'}
|
||
if code in {404,429}:
|
||
return {'state':'attention','badge':'Degraded','detail':f'{code} · {elapsed} ms'}
|
||
if code >= 500:
|
||
return {'state':'warn','badge':'Down','detail':f'{code} · {elapsed} ms'}
|
||
return {'state':'attention','badge':'Degraded','detail':f'{code} · {elapsed} ms'}
|
||
except Exception as e:
|
||
elapsed=max(1,int((time.time()-started)*1000))
|
||
return {'state':'warn','badge':'Down','detail':f'{type(e).__name__} · {elapsed} ms'}
|
||
|
||
|
||
def service_group_state(items:list[dict[str,Any]])->str:
|
||
return combine_states([str(item.get('health',{}).get('state') or item.get('state') or 'attention') for item in items])
|
||
|
||
|
||
def top_nav(active:str='home')->str:
|
||
items=[
|
||
('Home','index.html','home'),
|
||
('Services','services.html','services'),
|
||
('Donetick','https://donetick.paccoco.com','external'),
|
||
('Paperless','https://paperless.paccoco.com','external'),
|
||
('n8n','https://n8n.paccoco.com','external'),
|
||
('Grafana','https://grafana.paccoco.com','external'),
|
||
('Gitea','https://gitea.paccoco.com','external'),
|
||
('Schoolhouse','https://schoolhouse.paccoco.com','external'),
|
||
]
|
||
links=[]
|
||
for label,url,key in items:
|
||
classes=['nav-link']
|
||
attrs=[]
|
||
if key==active:
|
||
classes.append('active')
|
||
attrs.append("aria-current='page'")
|
||
if url.startswith('http'):
|
||
attrs.append("target='_blank'")
|
||
attrs.append("rel='noreferrer'")
|
||
links.append(f"<a class='{' '.join(classes)}' href='{esc(url)}' {' '.join(attrs)}>{esc(label)}</a>")
|
||
return "<nav class='top-nav'><div class='nav-brand'><span class='nav-kicker'>Doris</span><strong>Operator Portal</strong></div><div class='nav-links'>" + ''.join(links) + "</div></nav>"
|
||
|
||
|
||
def build_services_inventory()->tuple[list[dict[str,Any]],list[dict[str,Any]]]:
|
||
groups=[]
|
||
flat=[]
|
||
for group in SERVICE_DIRECTORY:
|
||
items=[]
|
||
for entry in group.get('items',[]):
|
||
item=dict(entry)
|
||
item['health']=check_service_health(item)
|
||
item['health_state']=str(item.get('health',{}).get('state') or item.get('state') or 'ok')
|
||
items.append(item)
|
||
flat.append(item)
|
||
groups.append({'group':str(group.get('group') or 'Services'),'items':items,'state':service_group_state(items)})
|
||
return groups, flat
|
||
|
||
|
||
def build_services_directory(groups_data:list[dict[str,Any]])->str:
|
||
groups=[]
|
||
for group in groups_data:
|
||
cards=[]
|
||
for item in group.get('items',[]):
|
||
health=item.get('health',{})
|
||
state=str(item.get('health_state') or health.get('state') or item.get('state') or 'ok')
|
||
exposure=str(item.get('exposure') or 'local').upper()
|
||
url=str(item.get('url') or '').strip()
|
||
attrs="target='_blank' rel='noreferrer'" if url.startswith('http') else ''
|
||
facts=[]
|
||
if item.get('host'):
|
||
facts.append(f"<span class='service-fact'><strong>Host</strong>{esc(item.get('host'))}</span>")
|
||
if item.get('port'):
|
||
facts.append(f"<span class='service-fact'><strong>Port</strong>{esc(item.get('port'))}</span>")
|
||
facts.append(f"<span class='service-fact'><strong>Access</strong>{esc(exposure)}</span>")
|
||
note=str(item.get('note') or '').strip()
|
||
meta_text=esc(health.get('detail') or 'No live check')
|
||
if note:
|
||
meta_text += f" · {esc(note)}"
|
||
action_html=(f"<a href='{esc(url)}' class='service-open' {attrs}>Open</a>" if url else "<span class='service-open disabled'>No direct route</span>")
|
||
title_html=(f"<a href='{esc(url)}' {attrs}>{esc(item.get('name') or 'Service')}</a>" if url else esc(item.get('name') or 'Service'))
|
||
cards.append(
|
||
f"<article class='service-card {esc(state)}'>"
|
||
f"<div class='service-top'><div><span class='service-group-badge'>{esc(group.get('group','Service'))}</span>"
|
||
f"<h3>{title_html}</h3></div>"
|
||
f"<div class='service-badge-stack'><span class='service-health {esc(state)}'>{esc(health.get('badge') or state.title())}</span><span class='service-badge'>{esc(exposure)}</span></div></div>"
|
||
f"<p>{esc(item.get('purpose') or '')}</p>"
|
||
f"<div class='service-facts'>{''.join(facts)}</div>"
|
||
f"<div class='service-meta'>{meta_text}</div>"
|
||
f"<div class='service-actions'>{action_html}</div>"
|
||
f"</article>"
|
||
)
|
||
groups.append(collapsible_section(str(group.get('group') or 'Services'),'Direct links into the stack.',f"<div class='services-grid'>{''.join(cards)}</div>",slugify(str(group.get('group') or 'services')),open_by_default=(group.get('state')=='warn'),state=str(group.get('state') or 'ok'),smart=True))
|
||
return ''.join(groups)
|
||
|
||
|
||
def render_services_inventory(flat_items:list[dict[str,Any]])->str:
|
||
state_counts=Counter(str(item.get('health_state') or 'attention') for item in flat_items)
|
||
exposure_counts=Counter(str(item.get('exposure') or 'LOCAL').upper() for item in flat_items)
|
||
host_counts=Counter(str(item.get('host') or 'Unknown') for item in flat_items)
|
||
total=len(flat_items)
|
||
host_bits=''.join(f"<li><strong>{esc(host)}</strong><span>{count} services</span></li>" for host,count in host_counts.most_common())
|
||
exposure_bits=''.join(f"<li><strong>{esc(name)}</strong><span>{count}</span></li>" for name,count in exposure_counts.most_common())
|
||
return (
|
||
"<section class='summary-grid'>"
|
||
f"<article class='summary-card'><h3>Coverage</h3><ul><li><strong>{total}</strong><span>listed services</span></li><li><strong>{state_counts.get('ok',0)}</strong><span>healthy now</span></li><li><strong>{state_counts.get('attention',0)}</strong><span>manual/degraded</span></li><li><strong>{state_counts.get('warn',0)}</strong><span>down</span></li></ul></article>"
|
||
f"<article class='summary-card'><h3>Access split</h3><ul>{exposure_bits}</ul></article>"
|
||
f"<article class='summary-card'><h3>Host map</h3><ul>{host_bits}</ul></article>"
|
||
"<article class='summary-card'><h3>Operator rule</h3><p>Doris is the launchpad. Public apps can stay behind auth gates; LAN tools should still show a clean probe. Manual cards mean the docs say the service exists but Doris does not yet have a stable operator-safe route for it.</p></article>"
|
||
"</section>"
|
||
)
|
||
|
||
|
||
def render_services_page(hero_summary:str,candidate_count:int,source_count:int,hero_tokens:str,now:datetime)->str:
|
||
groups_data, flat_items=build_services_inventory()
|
||
services_html=build_services_directory(groups_data)
|
||
inventory_html=render_services_inventory(flat_items)
|
||
utility_html=collapsible_section('Portal notes','Keep Doris as the front door, not a monolith.',"<section class='summary-grid'><article class='summary-card'><h3>How to use this</h3><p>Use Home for today, alerts, and the briefing. Use Services when you want the rest of the stack quickly without hunting bookmarks.</p></article><article class='summary-card'><h3>Design rule</h3><p>Shared navigation and status live here; full workflows still stay in their own apps.</p></article></section>",'portal-notes',open_by_default=True)+collapsible_section('Inventory','Coverage, access model, and host distribution.',inventory_html,'services-inventory',open_by_default=True)
|
||
return f"<!doctype html><html lang='en'><head><meta charset='utf-8'><meta name='viewport' content='width=device-width,initial-scale=1'><title>Doris Services</title><link rel='stylesheet' href='style.css'></head><body><main>{top_nav('services')}<header class='hero'><div><p class='eyebrow'>PC Doris Thatcher</p><h1>Services Directory</h1><p class='sub'>Shared navigation across your sites, with Doris still acting as the operational front door. {esc(hero_summary)}</p></div><div class='status'><div><strong>{esc(now.strftime('%a %b %-d, %-I:%M %p'))}</strong><span>Central time</span></div><div><strong>{candidate_count}</strong><span>News candidates</span></div><div><strong>{source_count}</strong><span>Sources</span></div><div><strong>{esc(hero_tokens)}</strong><span>30-day Hermes tokens</span></div></div></header><div class='dashboard-shell services-shell'><section class='primary-column'>{services_html}</section><aside class='secondary-column'>{utility_html}</aside></div><footer><p>Operator portal links are curated from the homelab docs and current live dashboard context.</p><p>Local-only on NOMAD unless John says otherwise.</p></footer></main></body></html>"
|
||
|
||
def render()->str:
|
||
candidates=load_json(DIGEST_ROOT/'data/candidates.json',[]); prefs=load_json(DIGEST_ROOT/'data/preferences.json',{})
|
||
donetick_todos=fetch_donetick_todos(); todos=inject_dashboard_todos(donetick_todos or load_json(DATA/'todos.json',[])); calendar=load_json(DATA/'calendar.json',[]); notes=load_json(DATA/'notes.json',[])
|
||
selected=select_items(candidates,prefs); top_briefing=selected[:4]; top_urls={i.get('url','') for i in top_briefing if i.get('url')}; groups={'space':[],'homelab':[],'local':[],'signals':[]}
|
||
exploration=select_exploration_items(candidates,prefs,{i.get('url','') for i in selected if i.get('url')},4)
|
||
for i in selected:
|
||
if i.get('url','') in top_urls: continue
|
||
cat=i.get('category')
|
||
if cat=='astronomy': groups['space'].append(i)
|
||
elif cat in {'homelab','smart_home','radio'}: groups['homelab'].append(i)
|
||
elif cat=='local': groups['local'].append(i)
|
||
else: groups['signals'].append(i)
|
||
weather=fetch_weather(); moon=moon_phase(datetime.now(timezone.utc)); pulse=homelab_pulse(candidates); hermes=fetch_hermes_usage(30); system=system_snapshot()
|
||
wind_notice=load_wind_watchdog_notice()
|
||
paperless=paperless_focus_summary()
|
||
now=datetime.now(LOCAL_TZ); counts=Counter(i.get('category','other') for i in candidates)
|
||
weather_html=weather_overview_panel(weather,wind_notice)
|
||
moon_metrics=''.join([
|
||
metric_card('Moon',f"{moon['emoji']} {moon['name']}",f"{moon['illumination']} lit, age {moon['age']}",'space'),
|
||
metric_card('Sky note','Space feeds live','Moon phase is computed locally','space')])
|
||
pulse_metrics=''.join(metric_card(x['label'],x['value'],x['state'],x['state']) for x in pulse)
|
||
forecast_html=forecast_panel(weather)
|
||
hero_summary=build_hero_summary(groups['local'],todos,pulse,paperless,hermes)
|
||
focus_html,focus_state=build_focus_cards(groups['local'],todos,pulse,paperless,hermes)
|
||
focus_signature=donetick_focus_signature(todos)
|
||
hermes_html=build_hermes_section(hermes)
|
||
system_html=build_system_section(system)
|
||
hero_tokens=compact_number(hermes.get('total_tokens',0)) if hermes.get('ok') else '—'
|
||
primary_html=''.join([
|
||
section('Top briefing','Compact scan of what is worth your time.',top_briefing,'Nothing worth bothering you with.',compact=True),
|
||
weather_html,
|
||
forecast_html,
|
||
section('Homelab / Smart Home / Radio','Infrastructure, self-hosting, smart home, and ham radio.',groups['homelab'][:4],'No homelab signal right now.',compact=True),
|
||
section('Sky / Space','SpaceX, NASA, planetary science, and astronomy.',groups['space'][:4],'No sky signal right now.',compact=True),
|
||
section('Local','Clarksville / Middle Tennessee items that seem useful.',groups['local'][:3],'No local signal right now.',compact=True),
|
||
section('New to You','Intentional oddballs outside your usual top lanes, so you can see if any new categories deserve a slot.',exploration[:4],'No worthwhile experimental picks right now.',compact=True),
|
||
section('Other signals','Everything else that survived filtering.',groups['signals'][:3],'No extra signals.',compact=True),
|
||
])
|
||
secondary_html=''.join([
|
||
collapsible_section('Focus now','What actually deserves attention before you go wandering through feeds.',focus_html,'focus-now',open_by_default=(focus_state=='warn'),state=focus_state,smart=True),
|
||
system_html,
|
||
hermes_html,
|
||
collapsible_section('Agenda','Calendar, Donetick, and pinned notes.',f"<section class='today'>{list_panel('Calendar',calendar,'Calendar integration not wired yet.')}{donetick_panel(todos,'No open Donetick tasks found; JSON placeholder active.')}{list_panel('Notes',notes,'No notes.')}</section>",'today-overview',open_by_default=False),
|
||
collapsible_section('Sky','Moon and outside-the-window context that still matters.',f"<section class='metrics metrics-compact'>{moon_metrics}</section>",'at-a-glance',open_by_default=False),
|
||
paperless_review_section(),
|
||
collapsible_section('Homelab pulse','Safe local checks on NOMAD only.',f"<div class='metrics metrics-compact'>{pulse_metrics}</div>",'homelab-pulse',open_by_default=False),
|
||
])
|
||
return f"""<!doctype html><html lang='en'><head><meta charset='utf-8'><meta name='viewport' content='width=device-width,initial-scale=1'><meta http-equiv='refresh' content='1800'><title>Doris Dashboard</title><link rel='stylesheet' href='style.css'></head><body data-donetick-focus-signature='{esc(focus_signature)}'><main>{top_nav('home')}
|
||
<header class='hero'><div><p class='eyebrow'>PC Doris Thatcher</p><h1>Doris Dashboard</h1><p class='sub'>{esc(hero_summary)}</p><div class='hero-actions'><button type='button' class='reset-btn' data-reset-topic-prefs>Reset hidden stories</button><span class='muted'>Hidden stories: <strong data-hidden-topics-count>0</strong></span></div></div><div class='status'><div><strong>{esc(now.strftime('%a %b %-d, %-I:%M %p'))}</strong><span>Central time · refreshes every 30m</span></div><div><strong>{len(candidates)}</strong><span>Candidates</span></div><div><strong>{len(set(i.get('source','') for i in candidates))}</strong><span>Sources</span></div><div><strong>{esc(hero_tokens)}</strong><span>30-day Hermes tokens</span></div></div></header>
|
||
<div class='dashboard-shell'><section class='primary-column'>{primary_html}</section><aside class='secondary-column'>{secondary_html}</aside></div>
|
||
<footer><p>Category mix: {esc(', '.join(f'{k}: {v}' for k,v in counts.most_common(10)))}</p><p>Local-only on NOMAD unless John says otherwise. Weather from Open-Meteo; moon phase calculated locally. Hermes stats come from ~/.hermes/state.db.</p></footer></main>{feedback_bootstrap()}</body></html>"""
|
||
|
||
def main()->int:
|
||
PUBLIC.mkdir(parents=True,exist_ok=True); LOGS.mkdir(parents=True,exist_ok=True); DATA.mkdir(parents=True,exist_ok=True)
|
||
candidates=load_json(DIGEST_ROOT/'data/candidates.json',[]); prefs=load_json(DIGEST_ROOT/'data/preferences.json',{})
|
||
weather=fetch_weather(); moon=moon_phase(datetime.now(timezone.utc)); pulse=homelab_pulse(candidates); articles=select_items(candidates,prefs,20); todos=inject_dashboard_todos(fetch_donetick_todos()); hermes=fetch_hermes_usage(30); wind_notice=load_wind_watchdog_notice()
|
||
generated={'generated_at':datetime.now(timezone.utc).isoformat(),'generated_at_local':datetime.now(LOCAL_TZ).isoformat(),'timezone':'America/Chicago','candidate_count':len(candidates),'source_count':len(set(i.get('source','') for i in candidates))}
|
||
(DATA/'dashboard.json').write_text(json.dumps(generated,indent=2)+'\n')
|
||
(DATA/'weather.json').write_text(json.dumps(weather,indent=2)+'\n')
|
||
(DATA/'wind_alert.json').write_text(json.dumps(wind_notice or {'active':False},indent=2)+'\n')
|
||
(DATA/'sky.json').write_text(json.dumps({'moon':moon},indent=2)+'\n')
|
||
(DATA/'homelab.json').write_text(json.dumps(pulse,indent=2)+'\n')
|
||
(DATA/'articles.json').write_text(json.dumps(articles,indent=2)+'\n')
|
||
(DATA/'hermes_usage.json').write_text(json.dumps(hermes,indent=2)+'\n')
|
||
if todos: (DATA/'todos.json').write_text(json.dumps(todos,indent=2)+'\n')
|
||
(PUBLIC/'index.html').write_text(render(),encoding='utf-8')
|
||
services_summary=build_hero_summary([item for item in articles if item.get('category')=='local'], todos, pulse, paperless_focus_summary(), hermes)
|
||
(PUBLIC/'services.html').write_text(render_services_page(services_summary, len(candidates), len(set(i.get('source','') for i in candidates)), compact_number(hermes.get('total_tokens',0)) if hermes.get('ok') else '—', datetime.now(LOCAL_TZ)),encoding='utf-8')
|
||
return 0
|
||
if __name__=='__main__': raise SystemExit(main())
|