openvoiceui 1.0.0

package/routes/theme.py

@@ -0,0 +1,81 @@
+"""
+routes/theme.py — Theme API Blueprint (P4-T4)
+
+Provides server-side persistence for user theme preferences.
+
+GET  /api/theme          — return current saved theme colors
+POST /api/theme          — save theme colors (primary + accent)
+POST /api/theme/reset    — reset to default theme
+
+Theme is stored in config/theme.json
+"""
+
+import json
+import logging
+from pathlib import Path
+
+from flask import Blueprint, jsonify, request
+
+logger = logging.getLogger(__name__)
+
+theme_bp = Blueprint('theme', __name__)
+
+_PROJECT_ROOT = Path(__file__).parent.parent
+THEME_FILE = _PROJECT_ROOT / 'config' / 'theme.json'
+
+DEFAULT_THEME = {
+    'primary': '#0088ff',
+    'accent': '#00ffff',
+}
+
+
+def _load_theme():
+    """Load theme from file, returning defaults if not found."""
+    try:
+        if THEME_FILE.exists():
+            data = json.loads(THEME_FILE.read_text())
+            # Validate hex color format
+            if _valid_hex(data.get('primary')) and _valid_hex(data.get('accent')):
+                return data
+    except Exception as e:
+        logger.warning('Failed to load theme: %s', e)
+    return dict(DEFAULT_THEME)
+
+
+def _save_theme(theme):
+    """Save theme to file."""
+    THEME_FILE.parent.mkdir(parents=True, exist_ok=True)
+    THEME_FILE.write_text(json.dumps(theme, indent=2))
+
+
+def _valid_hex(color):
+    """Return True if color is a valid #rrggbb hex string."""
+    if not isinstance(color, str):
+        return False
+    import re
+    return bool(re.fullmatch(r'#[0-9a-fA-F]{6}', color))
+
+
+@theme_bp.get('/api/theme')
+def get_theme():
+    return jsonify(_load_theme())
+
+
+@theme_bp.post('/api/theme')
+def set_theme():
+    data = request.get_json(silent=True) or {}
+    primary = data.get('primary', '')
+    accent = data.get('accent', '')
+
+    if not _valid_hex(primary) or not _valid_hex(accent):
+        return jsonify({'error': 'Invalid color format. Use #rrggbb hex values.'}), 400
+
+    theme = {'primary': primary, 'accent': accent}
+    _save_theme(theme)
+    return jsonify(theme)
+
+
+@theme_bp.post('/api/theme/reset')
+def reset_theme():
+    _save_theme(dict(DEFAULT_THEME))
+    return jsonify(DEFAULT_THEME)

package/routes/transcripts.py

@@ -0,0 +1,199 @@
+"""
+Transcript storage — saves listen-mode transcriptions to disk.
+
+Files are organized as:
+  transcripts/
+    YYYY-MM-DD/
+      HH-MM-SS_<slug>.txt
+
+POST /api/transcripts/save   — save a transcript
+GET  /api/transcripts        — list saved transcripts (newest first)
+GET  /api/transcripts/<date>/<filename>  — read one transcript
+"""
+
+import os
+import re
+import json
+from datetime import datetime
+from pathlib import Path
+from flask import Blueprint, jsonify, request
+
+transcripts_bp = Blueprint('transcripts', __name__)
+
+from services.paths import TRANSCRIPTS_DIR as _TRANSCRIPTS_DIR_PATH
+
+TRANSCRIPTS_DIR = str(_TRANSCRIPTS_DIR_PATH)
+
+
+def _slug(title: str) -> str:
+    """Turn a title into a safe filename slug."""
+    s = title.strip().lower()
+    s = re.sub(r'[^\w\s-]', '', s)
+    s = re.sub(r'[\s_]+', '-', s)
+    s = s.strip('-')
+    return s[:60] or 'untitled'
+
+
+@transcripts_bp.route('/api/transcripts/save', methods=['POST'])
+def save_transcript():
+    data = request.get_json(force=True, silent=True) or {}
+    title = (data.get('title') or 'Untitled').strip()
+    text  = (data.get('text') or '').strip()
+
+    if not text:
+        return jsonify({'error': 'No transcript text provided'}), 400
+
+    now = datetime.now()
+    date_dir  = now.strftime('%Y-%m-%d')
+    time_part = now.strftime('%H-%M-%S')
+    slug      = _slug(title)
+    filename  = f'{time_part}_{slug}.txt'
+
+    save_dir = os.path.join(TRANSCRIPTS_DIR, date_dir)
+    os.makedirs(save_dir, exist_ok=True)
+
+    filepath = os.path.join(save_dir, filename)
+
+    word_count = len(text.split())
+    content = (
+        f'Title: {title}\n'
+        f'Date:  {now.strftime("%Y-%m-%d %H:%M:%S")}\n'
+        f'Words: {word_count}\n'
+        f'\n---\n\n'
+        f'{text}\n'
+    )
+
+    with open(filepath, 'w', encoding='utf-8') as f:
+        f.write(content)
+
+    return jsonify({
+        'saved': True,
+        'path':  f'transcripts/{date_dir}/{filename}',
+        'date':  date_dir,
+        'filename': filename,
+        'words': word_count,
+    })
+
+
+@transcripts_bp.route('/api/transcripts', methods=['GET'])
+def list_transcripts():
+    entries = []
+    if not os.path.isdir(TRANSCRIPTS_DIR):
+        return jsonify([])
+
+    for date_dir in sorted(os.listdir(TRANSCRIPTS_DIR), reverse=True):
+        day_path = os.path.join(TRANSCRIPTS_DIR, date_dir)
+        if not os.path.isdir(day_path):
+            continue
+        for fname in sorted(os.listdir(day_path), reverse=True):
+            if not fname.endswith('.txt'):
+                continue
+            fpath = os.path.join(day_path, fname)
+            # Read first few lines for metadata
+            meta = {'title': fname, 'date': date_dir, 'filename': fname, 'words': 0}
+            try:
+                with open(fpath, 'r', encoding='utf-8') as f:
+                    for line in f:
+                        if line.startswith('Title:'):
+                            meta['title'] = line[6:].strip()
+                        elif line.startswith('Date:'):
+                            meta['timestamp'] = line[5:].strip()
+                        elif line.startswith('Words:'):
+                            meta['words'] = int(line[6:].strip())
+                        elif line.strip() == '---':
+                            break
+            except Exception:
+                pass
+            entries.append(meta)
+
+    return jsonify(entries)
+
+
+@transcripts_bp.route('/api/transcripts/<date_dir>/<filename>', methods=['GET'])
+def get_transcript(date_dir, filename):
+    # Resolve and verify path stays within TRANSCRIPTS_DIR
+    base = Path(TRANSCRIPTS_DIR).resolve()
+    try:
+        resolved = (base / date_dir / filename).resolve()
+    except (ValueError, OSError):
+        return jsonify({'error': 'Invalid path'}), 400
+    if base not in resolved.parents and resolved != base:
+        return jsonify({'error': 'Invalid path'}), 400
+    if not resolved.is_file():
+        return jsonify({'error': 'Not found'}), 404
+    return resolved.read_text(encoding='utf-8'), 200, {'Content-Type': 'text/plain; charset=utf-8'}
+
+
+import logging as _transcript_logger
+
+def save_conversation_turn(
+    user_msg: str,
+    ai_response: str,
+    session_id: str = 'default',
+    session_key: str = None,
+    tts_provider: str = None,
+    voice: str = None,
+    duration_ms: int = None,
+    actions: list = None,
+    identified_person: dict = None,
+) -> 'str | None':
+    """Save one conversation turn as a JSON transcript file.
+
+    Organized as: transcripts/YYYY-MM-DD/HH-MM-SS_<session_key>_<session_id>.json
+
+    Returns the relative file path on success, or None on failure.
+    Never raises — errors are logged at debug level so callers are never broken.
+    """
+    try:
+        now = datetime.now()
+        date_str = now.strftime('%Y-%m-%d')
+        time_str = now.strftime('%H-%M-%S')
+        ms_str = f'{now.microsecond // 1000:03d}'
+        ts_iso = f'{now.strftime("%Y-%m-%dT%H:%M:%S")}.{ms_str}Z'
+
+        # Extract brief tool summaries from captured actions (phase=result only)
+        tools = []
+        if actions:
+            for action in actions:
+                if action.get('type') == 'tool' and action.get('phase') == 'result':
+                    name = action.get('name', 'unknown')
+                    result = action.get('result', '')
+                    summary = str(result)[:120] if result else ''
+                    tools.append({'name': name, 'phase': 'result', 'summary': summary})
+
+        user_words = len(user_msg.split()) if user_msg else 0
+        ai_words = len(ai_response.split()) if ai_response else 0
+        key = session_key or 'unknown'
+
+        payload = {
+            'schema': 'v1',
+            'session_id': session_id,
+            'session_key': key,
+            'timestamp': ts_iso,
+            'date': date_str,
+            'time': now.strftime('%H:%M:%S'),
+            'tts_provider': tts_provider,
+            'voice': voice,
+            'duration_ms': duration_ms,
+            'user': user_msg,
+            'assistant': ai_response,
+            'tools': tools,
+            'identified_person': identified_person,
+            'word_count': {'user': user_words, 'assistant': ai_words},
+        }
+
+        save_dir = os.path.join(TRANSCRIPTS_DIR, date_str)
+        os.makedirs(save_dir, exist_ok=True)
+        filename = f'{time_str}_{key}_{session_id}.json'
+        filepath = os.path.join(save_dir, filename)
+
+        with open(filepath, 'w', encoding='utf-8') as f:
+            json.dump(payload, f, ensure_ascii=False, indent=2)
+
+        return f'transcripts/{date_str}/{filename}'
+
+    except Exception as exc:
+        _transcript_logger.getLogger(__name__).debug(
+            f'save_conversation_turn failed (non-critical): {exc}'
+        )
+        return None

package/routes/vision.py

@@ -0,0 +1,348 @@
+"""
+routes/vision.py — Camera / Vision / Facial Recognition Blueprint
+
+Endpoints:
+  POST /api/vision              — analyze camera frame with vision LLM
+  POST /api/frame               — receive live frame (stored as latest_frame)
+  POST /api/identify            — identify person from camera frame (DeepFace)
+  GET  /api/faces               — list registered faces
+  POST /api/faces/<name>        — register a face photo
+  DELETE /api/faces/<name>      — delete a registered face
+
+Face recognition: DeepFace (local, free, runs on-server — no API calls).
+Vision analysis ("look at"): configurable vision LLM (default: glm-4.6v).
+"""
+
+import base64
+import json
+import logging
+import os
+import re
+import tempfile
+import threading
+import time
+from pathlib import Path
+
+import requests
+from flask import Blueprint, jsonify, request
+
+logger = logging.getLogger(__name__)
+
+vision_bp = Blueprint('vision', __name__)
+
+# ---------------------------------------------------------------------------
+# Storage
+# ---------------------------------------------------------------------------
+
+from services.paths import KNOWN_FACES_DIR as FACES_DIR
+
+FACES_DIR.mkdir(parents=True, exist_ok=True)
+
+# Latest frame received from browser (in-memory, ephemeral)
+_latest_frame: dict = {'image': None, 'ts': 0}
+
+# ---------------------------------------------------------------------------
+# DeepFace — lazy load (heavy import, downloads models on first use)
+# Serialize all face recognition calls — concurrent TF/h5py calls crash the process.
+# ---------------------------------------------------------------------------
+
+_deepface = None
+_deepface_lock = threading.Lock()
+
+def _get_deepface():
+    global _deepface
+    if _deepface is None:
+        from deepface import DeepFace
+        _deepface = DeepFace
+    return _deepface
+
+
+def _clear_deepface_cache():
+    """Delete DeepFace's cached face index so newly registered/deleted faces are picked up."""
+    for pkl in FACES_DIR.glob('*.pkl'):
+        try:
+            pkl.unlink()
+        except OSError:
+            pass
+
+# ---------------------------------------------------------------------------
+# Vision model config
+# ---------------------------------------------------------------------------
+
+# Known vision-capable models (shown in admin UI dropdown)
+VISION_MODELS = [
+    {'id': 'glm-4.6v',      'label': 'GLM-4.6V (128K · Paid)',          'provider': 'zai'},
+    {'id': 'glm-4v-plus',   'label': 'GLM-4V Plus (Legacy · Paid)',     'provider': 'zai'},
+]
+
+DEFAULT_VISION_MODEL    = os.environ.get('VISION_MODEL', 'glm-4.6v')
+DEFAULT_VISION_PROVIDER = 'zai'
+
+
+def _get_vision_model() -> tuple[str, str]:
+    """Return (model_id, provider) from active profile or env defaults."""
+    try:
+        from profiles.manager import get_profile_manager
+        mgr = get_profile_manager()
+        p   = mgr.get_active_profile()
+        if p:
+            d = p.to_dict()
+            model    = d.get('vision', {}).get('model')    or DEFAULT_VISION_MODEL
+            provider = d.get('vision', {}).get('provider') or DEFAULT_VISION_PROVIDER
+            return model, provider
+    except Exception as exc:
+        logger.debug('Could not read vision config from profile: %s', exc)
+    return DEFAULT_VISION_MODEL, DEFAULT_VISION_PROVIDER
+
+
+def _call_vision(image_b64: str, prompt: str, model: str | None = None) -> str:
+    """
+    Send an image + prompt to the configured vision model and return the text response.
+
+    Uses Groq's Llama 4 Scout vision model — fast, free, and accurate.
+    Z.AI/GLM vision through api.z.ai is broken (returns hallucinated descriptions).
+
+    image_b64 may be a raw base64 string or a data-URI (data:image/jpeg;base64,...).
+    """
+    # Strip data-URI prefix if present
+    if image_b64.startswith('data:'):
+        image_b64 = image_b64.split(',', 1)[1]
+
+    api_key = os.environ.get('GROQ_API_KEY', '')
+    if not api_key:
+        raise ValueError('GROQ_API_KEY is not set — cannot call vision model')
+
+    vision_model = 'meta-llama/llama-4-scout-17b-16e-instruct'
+
+    payload = {
+        'model': vision_model,
+        'messages': [{
+            'role': 'user',
+            'content': [
+                {'type': 'image_url',
+                 'image_url': {'url': f'data:image/png;base64,{image_b64}'}},
+                {'type': 'text', 'text': prompt},
+            ],
+        }],
+        'max_tokens': 600,
+    }
+
+    resp = requests.post(
+        'https://api.groq.com/openai/v1/chat/completions',
+        headers={
+            'Authorization': f'Bearer {api_key}',
+            'Content-Type': 'application/json',
+        },
+        json=payload,
+        timeout=30,
+    )
+    resp.raise_for_status()
+    return resp.json()['choices'][0]['message']['content'].strip()
+
+
+# ---------------------------------------------------------------------------
+# POST /api/vision  — agent "look at" tool
+# ---------------------------------------------------------------------------
+
+@vision_bp.route('/api/vision', methods=['POST'])
+def vision_analyze():
+    """Analyze a camera frame with the configured vision model."""
+    data   = request.get_json(silent=True) or {}
+    image  = data.get('image', '')
+    prompt = data.get('prompt', 'Describe what you see in this image in detail.')
+    model  = data.get('model')  # optional override
+
+    if not image:
+        return jsonify({'error': 'No image provided'}), 400
+
+    try:
+        description = _call_vision(image, prompt, model)
+        return jsonify({'description': description, 'model': model or _get_vision_model()[0]})
+    except Exception as exc:
+        logger.error('Vision analysis failed: %s', exc)
+        return jsonify({'error': 'Internal server error'}), 500
+
+
+# ---------------------------------------------------------------------------
+# POST /api/frame  — receive live frame stream from browser
+# ---------------------------------------------------------------------------
+
+_FRAME_MAX_BYTES = 5 * 1024 * 1024  # 5 MB max per frame
+
+@vision_bp.route('/api/frame', methods=['POST'])
+def receive_frame():
+    """Store the latest camera frame in memory for use by other endpoints."""
+    if request.content_length and request.content_length > _FRAME_MAX_BYTES:
+        return jsonify({'ok': False, 'error': 'Frame too large'}), 413
+    data  = request.get_json(silent=True) or {}
+    image = data.get('image', '')
+    if image:
+        if len(image) > _FRAME_MAX_BYTES:
+            return jsonify({'ok': False, 'error': 'Frame too large'}), 413
+        _latest_frame['image'] = image
+        _latest_frame['ts']    = time.time()
+    return jsonify({'ok': True})
+
+
+# ---------------------------------------------------------------------------
+# POST /api/identify  — facial recognition
+# ---------------------------------------------------------------------------
+
+@vision_bp.route('/api/identify', methods=['POST'])
+def identify_face():
+    """
+    Identify who is in the camera frame using DeepFace (local, free, no API calls).
+
+    Uses the SFace model — fast on CPU, ~100ms after first load.
+    Face database: known_faces/<PersonName>/*.jpg
+    """
+    data  = request.get_json(silent=True) or {}
+    image = data.get('image', '')
+    if not image:
+        image = _latest_frame.get('image', '')
+    if not image:
+        return jsonify({'name': 'unknown', 'confidence': 0, 'message': 'No image'}), 200
+
+    # Check if any faces are registered
+    known_people = [d.name for d in FACES_DIR.iterdir()
+                    if d.is_dir() and any(d.iterdir())]
+    if not known_people:
+        return jsonify({'name': 'unknown', 'confidence': 0,
+                        'message': 'No faces registered yet'}), 200
+
+    # Decode and save to temp file (DeepFace needs a file path)
+    image_data = image
+    if ',' in image_data:
+        image_data = image_data.split(',', 1)[1]
+    image_bytes = base64.b64decode(image_data)
+
+    tmp_path = None
+    try:
+        with tempfile.NamedTemporaryFile(suffix='.jpg', delete=False) as tmp:
+            tmp.write(image_bytes)
+            tmp_path = tmp.name
+
+        DeepFace = _get_deepface()
+        with _deepface_lock:
+            results = DeepFace.find(
+                img_path=tmp_path,
+                db_path=str(FACES_DIR),
+                model_name='SFace',
+                enforce_detection=False,
+                silent=True,
+            )
+
+        if results and len(results) > 0 and len(results[0]) > 0:
+            df           = results[0]
+            best         = df.iloc[0]
+            identity_path = best['identity']
+            distance     = float(best['distance'])
+            person_name  = Path(identity_path).parent.name
+
+            # SFace cosine distance threshold ~0.5; convert to confidence %
+            confidence = max(0, round((1 - distance / 0.7) * 100, 1))
+
+            if distance < 0.5:
+                return jsonify({'name': person_name, 'confidence': confidence})
+            else:
+                return jsonify({'name': 'unknown', 'confidence': confidence,
+                                'message': 'Face detected but not recognized'})
+        else:
+            return jsonify({'name': 'unknown', 'confidence': 0,
+                            'message': 'No face detected in frame'})
+
+    except Exception as exc:
+        logger.error('Face identification failed: %s', exc)
+        return jsonify({'name': 'unknown', 'confidence': 0, 'message': 'Face identification failed'}), 200
+    finally:
+        if tmp_path:
+            try:
+                os.unlink(tmp_path)
+            except OSError:
+                pass
+
+
+# ---------------------------------------------------------------------------
+# GET /api/faces  — list registered faces
+# ---------------------------------------------------------------------------
+
+def _list_faces_data():
+    entries = []
+    for face_dir in sorted(FACES_DIR.iterdir()):
+        if not face_dir.is_dir():
+            continue
+        photos = list(face_dir.glob('*.jpg')) + list(face_dir.glob('*.jpeg')) + \
+                 list(face_dir.glob('*.png'))
+        entries.append({'name': face_dir.name, 'photo_count': len(photos)})
+    return entries
+
+
+@vision_bp.route('/api/faces', methods=['GET'])
+def list_faces():
+    return jsonify({'faces': _list_faces_data()})
+
+
+# ---------------------------------------------------------------------------
+# POST /api/faces/<name>  — register a face photo
+# ---------------------------------------------------------------------------
+
+@vision_bp.route('/api/faces/<name>', methods=['POST'])
+def register_face(name):
+    """Save a face photo for a named person."""
+    # Sanitize name
+    safe_name = re.sub(r'[^a-zA-Z0-9_\- ]', '', name).strip()
+    if not safe_name:
+        return jsonify({'error': 'Invalid name'}), 400
+
+    data       = request.get_json(silent=True) or {}
+    image_data = data.get('image', '')
+    if not image_data:
+        return jsonify({'error': 'No image provided'}), 400
+
+    face_dir = FACES_DIR / safe_name
+    face_dir.mkdir(exist_ok=True)
+
+    # Strip data-URI prefix
+    if image_data.startswith('data:'):
+        image_data = image_data.split(',', 1)[1]
+
+    # Save with incrementing filename
+    idx      = len(list(face_dir.glob('*.jpg'))) + 1
+    out_path = face_dir / f'photo_{idx:03d}.jpg'
+    out_path.write_bytes(base64.b64decode(image_data))
+
+    logger.info('Registered face photo: %s (%s)', safe_name, out_path.name)
+
+    # Clear DeepFace's cached index so the new face is picked up immediately
+    with _deepface_lock:
+        _clear_deepface_cache()
+
+    return jsonify({'ok': True, 'name': safe_name, 'file': out_path.name})
+
+
+# ---------------------------------------------------------------------------
+# DELETE /api/faces/<name>  — remove a registered face
+# ---------------------------------------------------------------------------
+
+@vision_bp.route('/api/faces/<name>', methods=['DELETE'])
+def delete_face(name):
+    safe_name = re.sub(r'[^a-zA-Z0-9_\- ]', '', name).strip()
+    face_dir  = FACES_DIR / safe_name
+    if not face_dir.exists():
+        return jsonify({'error': 'Face not found'}), 404
+
+    import shutil
+    shutil.rmtree(face_dir)
+    with _deepface_lock:
+        _clear_deepface_cache()
+    return jsonify({'ok': True, 'deleted': safe_name})
+
+
+# ---------------------------------------------------------------------------
+# GET /api/vision/models  — list available vision models (for admin UI)
+# ---------------------------------------------------------------------------
+
+@vision_bp.route('/api/vision/models', methods=['GET'])
+def list_vision_models():
+    active_model, _ = _get_vision_model()
+    return jsonify({'models': VISION_MODELS, 'active': active_model})