openvoiceui 1.0.0

package/routes/onboarding.py

@@ -0,0 +1,43 @@
+"""
+Onboarding state blueprint.
+
+GET  /api/onboarding/state  → read onboarding state from runtime dir
+POST /api/onboarding/state  → write onboarding state to runtime dir
+
+State file lives at RUNTIME_DIR/onboarding-state.json (bind-mounted volume
+in JamBot — persists across containers and devices). Falls back to localStorage
+on the frontend when these endpoints return 404 or fail (safe for non-JamBot).
+"""
+
+import json
+import logging
+from flask import Blueprint, jsonify, request
+from services.paths import RUNTIME_DIR
+
+logger = logging.getLogger(__name__)
+
+onboarding_bp = Blueprint('onboarding', __name__)
+
+STATE_FILE = RUNTIME_DIR / 'onboarding-state.json'
+
+
+@onboarding_bp.route('/api/onboarding/state', methods=['GET'])
+def get_state():
+    try:
+        if STATE_FILE.exists():
+            return jsonify(json.loads(STATE_FILE.read_text()))
+        return jsonify(None)
+    except Exception as e:
+        logger.error('onboarding get_state error: %s', e)
+        return jsonify({'error': str(e)}), 500
+
+
+@onboarding_bp.route('/api/onboarding/state', methods=['POST'])
+def save_state():
+    try:
+        data = request.get_json(silent=True) or {}
+        STATE_FILE.write_text(json.dumps(data))
+        return jsonify({'ok': True})
+    except Exception as e:
+        logger.error('onboarding save_state error: %s', e)
+        return jsonify({'error': str(e)}), 500

package/routes/pi.py

@@ -0,0 +1,62 @@
+"""
+routes/pi.py — Raspberry Pi optimized page serving
+
+Purely additive — register with:
+    from routes.pi import pi_bp
+    app.register_blueprint(pi_bp)
+
+UA detection targets (ARM architecture strings in User-Agent):
+    aarch64 — Pi 4, Pi 5, Pi Zero 2 W (64-bit ARM)
+    armv7l  — Pi 3, Pi 2 (32-bit ARM)
+    armv6l  — Pi Zero, Pi 1 (ARMv6)
+
+The before_app_request hook fires on every request but only acts on
+GET / from ARM browsers, redirecting them transparently to /pi which
+serves index-pi.html — the performance-optimized variant.
+
+Desktop/non-ARM browsers are completely unaffected.
+"""
+
+import os
+import pathlib
+
+from flask import Blueprint, Response, redirect, request, url_for
+
+pi_bp = Blueprint('pi', __name__)
+
+BASE_DIR = pathlib.Path(__file__).parent.parent
+
+_PI_UA_MARKERS = ('aarch64', 'armv7l', 'armv6l')
+
+
+def _is_pi_ua(ua: str) -> bool:
+    """Return True if the User-Agent string indicates an ARM/Pi browser."""
+    return any(marker in (ua or '').lower() for marker in _PI_UA_MARKERS)
+
+
+@pi_bp.before_app_request
+def redirect_pi_browsers():
+    """Redirect ARM browsers visiting / to the Pi-optimized /pi page."""
+    if request.method == 'GET' and request.path == '/':
+        if _is_pi_ua(request.headers.get('User-Agent', '')):
+            return redirect(url_for('pi.serve_pi_index'), code=302)
+
+
+@pi_bp.route('/pi')
+def serve_pi_index():
+    """
+    Serve index-pi.html with the same AGENT_CONFIG injection used by
+    the main serve_index() in server.py.
+    """
+    html = (BASE_DIR / 'index-pi.html').read_text()
+
+    server_url = os.environ.get('AGENT_SERVER_URL', '').strip().rstrip('/')
+    if server_url:
+        config_block = f'<script>window.AGENT_CONFIG={{serverUrl:"{server_url}"}};</script>'
+    else:
+        config_block = '<script>window.AGENT_CONFIG={serverUrl:window.location.origin};</script>'
+
+    html = html.replace('</head>', f'  {config_block}\n</head>', 1)
+    resp = Response(html, mimetype='text/html')
+    resp.headers['Cache-Control'] = 'no-cache, no-store, must-revalidate'
+    return resp

package/routes/profiles.py

@@ -0,0 +1,215 @@
+"""
+routes/profiles.py — Agent Profile API Blueprint (P5-T4)
+
+Endpoints:
+  GET    /api/profiles            — list all profiles (summary)
+  GET    /api/profiles/active     — get the currently active profile (full)
+  GET    /api/profiles/<id>       — get a single profile by id (full)
+  POST   /api/profiles            — create a new profile
+  POST   /api/profiles/activate   — activate a profile by id
+  PUT    /api/profiles/<id>       — partial-update an existing profile
+  DELETE /api/profiles/<id>       — delete a profile (default profile protected)
+
+ADR-002: Profile storage as JSON files.
+"""
+
+import logging
+from pathlib import Path
+
+from flask import Blueprint, jsonify, request
+
+from profiles.manager import get_profile_manager, Profile
+
+logger = logging.getLogger(__name__)
+
+profiles_bp = Blueprint("profiles", __name__)
+
+_DEFAULT_PROFILE = "default"
+from services.paths import ACTIVE_PROFILE_FILE as _ACTIVE_PROFILE_FILE
+
+
+def _load_active_profile_id() -> str:
+    """Read persisted active profile from disk, fall back to default."""
+    try:
+        if _ACTIVE_PROFILE_FILE.exists():
+            saved = _ACTIVE_PROFILE_FILE.read_text().strip()
+            if saved:
+                return saved
+    except Exception as exc:
+        logger.warning("Could not read .active-profile: %s", exc)
+    return _DEFAULT_PROFILE
+
+
+def _save_active_profile_id(profile_id: str) -> None:
+    """Persist active profile to disk so it survives service restarts."""
+    try:
+        _ACTIVE_PROFILE_FILE.write_text(profile_id)
+    except Exception as exc:
+        logger.warning("Could not save .active-profile: %s", exc)
+
+
+# Load persisted selection on startup (survives service restarts)
+_active_profile_id = _load_active_profile_id()
+
+
+# ---------------------------------------------------------------------------
+# GET /api/profiles
+# ---------------------------------------------------------------------------
+
+@profiles_bp.route("/api/profiles", methods=["GET"])
+def list_profiles():
+    """Return summary list of all profiles plus the active profile id."""
+    manager = get_profile_manager()
+    return jsonify({
+        "profiles": manager.list_profiles(),
+        "active": _active_profile_id,
+    })
+
+
+# ---------------------------------------------------------------------------
+# GET /api/profiles/active
+# ---------------------------------------------------------------------------
+
+@profiles_bp.route("/api/profiles/active", methods=["GET"])
+def get_active_profile():
+    """Return the full currently active profile object."""
+    manager = get_profile_manager()
+    profile = manager.get_profile(_active_profile_id)
+    if not profile:
+        return jsonify({"error": f"Active profile '{_active_profile_id}' not found"}), 404
+    return jsonify(profile.to_dict())
+
+
+# ---------------------------------------------------------------------------
+# GET /api/profiles/<profile_id>
+# ---------------------------------------------------------------------------
+
+@profiles_bp.route("/api/profiles/<profile_id>", methods=["GET"])
+def get_profile(profile_id):
+    """Return a single profile by id."""
+    manager = get_profile_manager()
+    profile = manager.get_profile(profile_id)
+    if not profile or profile.id != profile_id:
+        return jsonify({"error": f"Profile '{profile_id}' not found"}), 404
+    return jsonify(profile.to_dict())
+
+
+# ---------------------------------------------------------------------------
+# POST /api/profiles  — create
+# ---------------------------------------------------------------------------
+
+@profiles_bp.route("/api/profiles", methods=["POST"])
+def create_profile():
+    """
+    Create a new profile from a JSON body.
+
+    Required fields: id, name, system_prompt, llm.provider, voice.tts_provider
+    Returns 201 with the created profile on success, 400 on validation error,
+    409 if a profile with the same id already exists.
+    """
+    manager = get_profile_manager()
+    data = request.get_json(silent=True)
+    if not data:
+        return jsonify({"error": "Request body must be JSON"}), 400
+
+    errors = manager.validate_profile(data)
+    if errors:
+        return jsonify({"errors": errors}), 400
+
+    profile_id = data["id"]
+    if manager.profile_exists(profile_id):
+        return jsonify({"error": f"Profile '{profile_id}' already exists. Use PUT to update."}), 409
+
+    profile = Profile.from_dict(data)
+    if not manager.save_profile(profile):
+        return jsonify({"error": "Failed to save profile"}), 500
+
+    logger.info("Created profile: %s", profile_id)
+    return jsonify(profile.to_dict()), 201
+
+
+# ---------------------------------------------------------------------------
+# POST /api/profiles/activate
+# ---------------------------------------------------------------------------
+
+@profiles_bp.route("/api/profiles/activate", methods=["POST"])
+def activate_profile():
+    """
+    Activate a profile.
+
+    Request body: {"profile_id": "default"}
+    Response:     {"ok": true, "active": "default", "profile": {...}}
+    """
+    global _active_profile_id
+
+    data = request.get_json(silent=True) or {}
+    profile_id = data.get("profile_id", "").strip()
+
+    if not profile_id:
+        return jsonify({"ok": False, "error": "Missing 'profile_id'"}), 400
+
+    manager = get_profile_manager()
+    profile = manager.get_profile(profile_id)
+    if not profile or profile.id != profile_id:
+        return jsonify({"ok": False, "error": f"Profile '{profile_id}' not found"}), 404
+
+    _active_profile_id = profile_id
+    _save_active_profile_id(profile_id)
+    logger.info("Profile activated: %s", profile_id)
+
+    return jsonify({
+        "ok": True,
+        "active": _active_profile_id,
+        "profile": profile.to_dict(),
+    })
+
+
+# ---------------------------------------------------------------------------
+# PUT /api/profiles/<profile_id>  — partial update
+# ---------------------------------------------------------------------------
+
+@profiles_bp.route("/api/profiles/<profile_id>", methods=["PUT"])
+def update_profile(profile_id):
+    """
+    Partially update an existing profile.  Only the supplied fields are changed.
+    Sub-objects (llm, voice, etc.) are merged one level deep.
+    Returns 200 with the updated profile on success.
+    """
+    manager = get_profile_manager()
+    if not manager.profile_exists(profile_id):
+        return jsonify({"error": f"Profile '{profile_id}' not found"}), 404
+
+    data = request.get_json(silent=True)
+    if not data:
+        return jsonify({"error": "Request body must be JSON"}), 400
+
+    # Prevent changing the id via update body
+    data.pop("id", None)
+
+    updated = manager.apply_partial_update(profile_id, data)
+    if updated is None:
+        return jsonify({"error": "Failed to update profile"}), 500
+
+    logger.info("Updated profile: %s", profile_id)
+    return jsonify(updated.to_dict())
+
+
+# ---------------------------------------------------------------------------
+# DELETE /api/profiles/<profile_id>
+# ---------------------------------------------------------------------------
+
+@profiles_bp.route("/api/profiles/<profile_id>", methods=["DELETE"])
+def delete_profile(profile_id):
+    """
+    Delete a profile.  The default profile ('default') cannot be deleted.
+    Returns 204 on success, 400 if protected, 404 if not found.
+    """
+    manager = get_profile_manager()
+    if not manager.profile_exists(profile_id):
+        return jsonify({"error": f"Profile '{profile_id}' not found"}), 404
+
+    if not manager.delete_profile(profile_id):
+        return jsonify({"error": f"Cannot delete profile '{profile_id}' (protected)"}), 400
+
+    logger.info("Deleted profile: %s", profile_id)
+    return "", 204

package/routes/report_issue.py

@@ -0,0 +1,68 @@
+"""
+Issue reporting — user-submitted bug/feedback reports saved to disk.
+
+POST /api/report-issue   — save an issue report
+GET  /api/report-issues  — list recent reports
+"""
+
+import json
+from datetime import datetime
+from pathlib import Path
+
+from flask import Blueprint, jsonify, request
+
+from services.paths import RUNTIME_DIR
+
+report_issue_bp = Blueprint('report_issue', __name__)
+
+REPORTS_DIR = RUNTIME_DIR / 'issue-reports'
+
+
+@report_issue_bp.route('/api/report-issue', methods=['POST'])
+def submit_issue():
+    data = request.get_json(force=True, silent=True) or {}
+
+    issue_type = (data.get('type') or 'other').strip()[:50]
+    description = (data.get('description') or '').strip()[:2000]
+    context = data.get('context') or {}
+
+    if not description:
+        return jsonify({'error': 'Description required'}), 400
+
+    now = datetime.now()
+    report = {
+        'ts': now.isoformat(),
+        'type': issue_type,
+        'description': description,
+        'context': context,
+        'ua': request.headers.get('User-Agent', ''),
+    }
+
+    REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+
+    date_str = now.strftime('%Y-%m-%d')
+    time_str = now.strftime('%H-%M-%S')
+    filename = f'{date_str}_{time_str}_{issue_type}.json'
+    filepath = REPORTS_DIR / filename
+
+    # Handle the (unlikely) same-second collision
+    if filepath.exists():
+        filepath = REPORTS_DIR / f'{date_str}_{time_str}_{issue_type}_2.json'
+
+    filepath.write_text(json.dumps(report, indent=2))
+
+    return jsonify({'ok': True, 'saved': filename})
+
+
+@report_issue_bp.route('/api/report-issues', methods=['GET'])
+def list_issues():
+    """Return last N issue reports, newest first."""
+    REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+    files = sorted(REPORTS_DIR.glob('*.json'), reverse=True)[:50]
+    reports = []
+    for f in files:
+        try:
+            reports.append(json.loads(f.read_text()))
+        except Exception:
+            pass
+    return jsonify(reports)