V1

alfred/app/app.py

@@ -1,4 +1,6 @@
 import os, threading, hmac
+from datetime import datetime, timedelta
+from zoneinfo import ZoneInfo
 from flask import Flask, render_template, request, jsonify, Response
 from flask_socketio import SocketIO
 from dotenv import load_dotenv
@@ -7,6 +9,8 @@ from services.wakeword import WakeWordListener
 from services.hermes_client import ask_hermes
 from services import audio_settings  # ALFRED_AUDIO_SETTINGS_V1
 from services.camera import video_stream
+from services import ha_views, alfred_views_controller
+from services import camera_settings, ha_weather, weather_outfits
 
 load_dotenv()
 
@@ -25,6 +29,8 @@ conversation_lock=threading.Lock()
 mic_stop_event=threading.Event()
 audio_settings.initialize()
 audio_settings.update_settings({"mic_gain": 30})
+# Recharge les réglages V4L2 enregistrés, sans interrompre Alfred si la webcam est absente.
+camera_settings.restore_saved_settings()
 
 def emit_state(mode=None, **extra):
     with STATE_LOCK:
@@ -73,6 +79,28 @@ def conversation(score=1.0):
             content={"type": "text", "text": r.text}
         )
 
+        # Vue dynamique : commandes déterministes exécutées sans faire
+        # dépendre l'affichage des capacités ou sessions Hermes.
+        visual = None
+        try:
+            visual = alfred_views_controller.route(r.text, (STATE.get('content') or {}).get('type'))
+        except (ha_views.HAError, ValueError) as exc:
+            print(f"[ALFRED] Vue indisponible : {exc}", flush=True)
+            visual = ({"type":"text", "text":str(exc)}, str(exc))
+
+        if visual is not None:
+            content, speech = visual
+            with STATE_LOCK:
+                STATE["content"] = content
+                socketio.emit("alfred_render", content)
+            if speech and not audio_settings.speaker_muted():
+                emit_state("speaking")
+                done = threading.Event()
+                speak_async(speech, on_end=done.set)
+                done.wait(timeout=120)
+            emit_state("idle", partial="")
+            return
+
         print("[ALFRED] Envoi à Hermes", flush=True)
         # ComfyUI publie l'image pendant cet appel Hermes.
         with STATE_LOCK:
@@ -154,6 +182,41 @@ def set_audio_settings():
     socketio.emit('audio_settings', new)
     return jsonify(new)
 
+@app.get('/api/camera/settings')
+def get_camera_settings():
+    try:
+        return jsonify(camera_settings.get_settings())
+    except camera_settings.CameraSettingsError as exc:
+        return jsonify({'error': str(exc)}), 503
+
+@app.post('/api/camera/settings')
+def set_camera_settings():
+    # Même garde-fou que les commandes calendrier existantes.
+    if not _same_origin_json():
+        return jsonify({'error': 'Requête non autorisée.'}), 403
+    data = request.get_json(silent=True)
+    if not isinstance(data, dict):
+        return jsonify({'error': 'JSON invalide.'}), 400
+    try:
+        result = camera_settings.update_setting(data.get('control'), data.get('value'))
+        socketio.emit('camera_settings', result)
+        return jsonify(result)
+    except ValueError as exc:
+        return jsonify({'error': str(exc)}), 400
+    except camera_settings.CameraSettingsError as exc:
+        return jsonify({'error': str(exc)}), 503
+
+@app.post('/api/camera/reset')
+def reset_camera_settings():
+    if not _same_origin_json():
+        return jsonify({'error': 'Requête non autorisée.'}), 403
+    try:
+        result = camera_settings.reset_defaults()
+        socketio.emit('camera_settings', result)
+        return jsonify(result)
+    except camera_settings.CameraSettingsError as exc:
+        return jsonify({'error': str(exc)}), 503
+
 @app.get('/api/camera/stream')
 def camera_stream():
     # Flux MJPEG à la demande ; ne démarre jamais la webcam en arrière-plan.
@@ -208,6 +271,139 @@ def render_payload():
         STATE["content"] = data
         socketio.emit("alfred_render", data)
         return jsonify({"ok": True, "image_revision": IMAGE_REVISION})
+# --- Agenda / capteurs / caméras Home Assistant ---
+def _calendar_range():
+    tz = ZoneInfo(os.getenv('ALFRED_TIMEZONE', 'Europe/Paris'))
+    now = datetime.now(tz)
+    def parse(name, default):
+        raw = request.args.get(name)
+        if not raw:return default
+        value = datetime.fromisoformat(raw.replace('Z','+00:00'))
+        if value.tzinfo is None: value = value.replace(tzinfo=tz)
+        return value.astimezone(tz)
+    start = parse('start',now.replace(hour=0,minute=0,second=0,microsecond=0))
+    end = parse('end',start+timedelta(days=7))
+    return start,end
+
+def _json_error(exc):
+    code = 400 if isinstance(exc,ValueError) else 502
+    return jsonify({'error':str(exc)}),code
+
+def _writes_enabled():
+    return os.getenv('ALFRED_ALLOW_CALENDAR_WRITES','false').lower() in ('1','true','yes')
+
+def _same_origin_json():
+    # POSTs require a custom header and same-origin browser requests.
+    if request.headers.get('X-Alfred-Request') != '1':return False
+    origin=request.headers.get('Origin')
+    if origin and origin.rstrip('/') != request.host_url.rstrip('/'):return False
+    return True
+
+@app.get('/api/calendar/calendars')
+def calendars_list():
+    try:return jsonify({'calendars':ha_views.list_calendars(),'writes_enabled':_writes_enabled()})
+    except (ha_views.HAError,ValueError) as exc:return _json_error(exc)
+
+@app.get('/api/calendar/events')
+def calendar_events():
+    try:
+        start,end=_calendar_range()
+        selected=request.args.getlist('calendar_id')
+        return jsonify(ha_views.get_events(start,end,selected or None))
+    except (ha_views.HAError,ValueError) as exc:return _json_error(exc)
+
+@app.post('/api/calendar/create')
+def calendar_create():
+    if not _same_origin_json():return jsonify({'error':'Requête non autorisée.'}),403
+    if not _writes_enabled():return jsonify({'error':'Écriture calendrier désactivée (ALFRED_ALLOW_CALENDAR_WRITES).'}),403
+    data=request.get_json(silent=True)
+    if not isinstance(data,dict):return jsonify({'error':'JSON invalide.'}),400
+    try:
+        tz=ZoneInfo(os.getenv('ALFRED_TIMEZONE','Europe/Paris'))
+        def read_dt(key):
+            dt=datetime.fromisoformat(str(data[key]).replace('Z','+00:00'))
+            return dt.replace(tzinfo=tz) if dt.tzinfo is None else dt.astimezone(tz)
+        result=ha_views.create_event(str(data.get('calendar_id','')),str(data.get('title','')),
+            read_dt('start'),read_dt('end'),str(data.get('description') or ''),
+            str(data.get('location') or ''),bool(data.get('all_day',False)))
+        from services import alfred_intents
+        alfred_intents.clear_create()
+        socketio.emit('calendar_changed', {'type':'created'})
+        return jsonify(result)
+    except (ha_views.HAError,ValueError,KeyError) as exc:return _json_error(exc)
+
+@app.post('/api/calendar/delete')
+def calendar_delete():
+    if not _same_origin_json():return jsonify({'error':'Requête non autorisée.'}),403
+    if not _writes_enabled():return jsonify({'error':'Écriture calendrier désactivée.'}),403
+    data=request.get_json(silent=True)
+    if not isinstance(data,dict):return jsonify({'error':'JSON invalide.'}),400
+    try:
+        eid=str(data.get('calendar_id',''));uid=str(data.get('uid',''))
+        start=datetime.fromisoformat(str(data['start']))
+        end=datetime.fromisoformat(str(data['end']))
+        if start.tzinfo is None or end.tzinfo is None:raise ValueError('Date avec fuseau requise.')
+        matches=ha_views.get_events(start-timedelta(days=1),end+timedelta(days=1),[eid])['events']
+        rid=str(data.get('recurrence_id') or '')
+        if not any(e['id']==uid and e['start']==start.isoformat() and e['recurrence_id']==rid for e in matches):
+            return jsonify({'error':'Événement introuvable ou modifié ; actualise le planning.'}),409
+        result=ha_views.delete_event(eid,uid,rid or None)
+        from services import alfred_intents
+        alfred_intents.clear_delete()
+        socketio.emit('calendar_changed',{'type':'deleted'})
+        return jsonify(result)
+    except (ha_views.HAError,ValueError,KeyError) as exc:return _json_error(exc)
+
+@app.get('/api/ha/weather')
+def ha_weather_data():
+    # Read-only route, token always stays on the Alfred server.
+    try:
+        q = request.args.get('q', '')
+        return jsonify(ha_weather.get_weather(q))
+    except (ha_views.HAError, ValueError) as exc:
+        return _json_error(exc)
+
+@app.get('/api/ha/weather/outfits')
+def ha_weather_outfits_data():
+    try:
+        q = request.args.get('q', '')
+        refresh = request.args.get('refresh_illustration', '').lower() in ('1','true','yes','on')
+        return jsonify(weather_outfits.build_payload(q=q, date=request.args.get('date', ''), label=request.args.get('label', ''), refresh=refresh))
+    except (ha_views.HAError, ValueError, RuntimeError) as exc:
+        return _json_error(exc)
+
+@app.get('/api/ha/temperatures')
+def ha_temperatures():
+    try:return jsonify({'items':ha_views.get_temperatures()})
+    except (ha_views.HAError,ValueError) as exc:return _json_error(exc)
+
+@app.get('/api/ha/temperature/history')
+def ha_temperature_history():
+    try:
+        eid=request.args.get('entity_id','')
+        hours=int(request.args.get('hours','24'))
+        return jsonify({'items':ha_views.temperature_history(eid,hours)})
+    except (ha_views.HAError,ValueError) as exc:return _json_error(exc)
+
+@app.get('/api/ha/cameras')
+def ha_cameras():
+    try:return jsonify({'items':ha_views.list_cameras()})
+    except (ha_views.HAError,ValueError) as exc:return _json_error(exc)
+
+@app.get('/api/ha/camera/<path:entity_id>/snapshot')
+def ha_camera_snapshot(entity_id):
+    try:
+        binary,mime=ha_views.camera_snapshot(entity_id)
+        return Response(binary,mimetype=mime,headers={'Cache-Control':'no-store','X-Content-Type-Options':'nosniff'})
+    except (ha_views.HAError,ValueError) as exc:return _json_error(exc)
+
+@app.post('/api/ui/home')
+def ui_home():
+    with STATE_LOCK:
+        STATE['content']={'type':'home','text':'À ton écoute.'}
+        socketio.emit('alfred_render',STATE['content'])
+    return jsonify({'ok':True})
+
 @app.post("/api/audio-level")
 def api_audio_level(): audio_level((request.get_json(force=True) or {}).get("level",0)); return jsonify({"ok":True})
 @app.get("/api/wake/status")