mission-control-v2/backend/services/connect.py

"""
Connect: erzeugt saubere, getestete Konfig-Snippets für IDEs/Agenten auf dem
LOKALEN PC (separate Maschine im LAN). Alle zeigen auf den **Gateway** der Box
(reale Modelle coder/heavy/vision, Cockpit-Port :9001/v1).

Gedächtnis ist hier bewusst KEINE eigene Leitung mehr: bis August 2026 gab es dafür einen
Memory-MCP-Server gegen MC2s /api/memory; seit dessen Ablösung (docs/wissen/VERDIKTE.md,
07.08.2026) führt Hermes sein Gedächtnis
selbst — es hängt am Agenten, nicht am Gateway. check_health() prüft es weiterhin (Leitung 2),
es ist nur nichts mehr zu konfigurieren.

Wichtig: Host ist die LAN-IP der Box (NICHT eine Proxy-Domain) — das war in v1
die häufigste Fehlerquelle. Der Aufrufer übergibt den Host explizit.
"""

import json

import httpx
from config import HERMES_BUILTIN_UI_UPSTREAM, LLAMA_SWAP_URL, PORT, V1_UPSTREAM

DEFAULT_HOST = "192.168.178.151"

# IDEs/Agenten bekommen die ECHTEN Box-Modelle direkt (kein Lane-Routing): Coder (bauen), Planer (denken),
# Augen (Bilder, Vision). Der User wechselt im Modellwähler — spiegelt das reale Hermes-Desktop-Setup 1:1.
PRIMARY_MODEL = "coder"


def _caps(tools: bool = True, images: bool = False) -> dict:
    """Volle 7-Feld-Capabilities — braucht sie für die Modellwahl."""
    return {"tools": tools, "images": images, "parallel_tool_calls": False,
            "prompt_cache_key": False, "chat_completions": True,
            "interleaved_reasoning": False, "max_tokens_parameter": False}


# Reale Box-Modelle für die IDE-Welt (getrennt von Lucy): bauen · denken · sehen.
IDE_MODELS = [
    {"name": "coder", "display_name": "Box / Coder (bauen)", "max_tokens": 131072, "capabilities": _caps(True, False)},
    {"name": "heavy", "display_name": "Box / Planer (denken)", "max_tokens": 32768, "capabilities": _caps(True, False)},
    {"name": "vision", "display_name": "Box / Augen (Bilder)", "max_tokens": 32768, "capabilities": _caps(False, True)},
]


def _gw(host: str) -> str:
    # Client-Endpunkt bleibt :9001/v1 (MC2-Port) — seit UMBAU v3 P1 reicht MC2 dort
    # nur noch roh an den eigenständigen mc2-gateway (:9010) durch.
    return f"http://{host}:{PORT}/v1"


def build_snippets(host: str = DEFAULT_HOST) -> dict:
    gw = _gw(host)
    mc_url = f"http://{host}:{PORT}"

    # Kilo Code = aktiver Nachfolger der Roo/Cline-Linie (Roo im April 2026 eingestellt).
    # Gleiche Provider-Settings-Struktur; Multi-Agent kommt aus dem Tool (Orchestrator-Modus).
    kilo = json.dumps({
        "apiProvider": "openai",
        "openAiBaseUrl": gw,
        "openAiApiKey": "local",
        "openAiModelId": PRIMARY_MODEL,
    }, indent=2)

    # Hermes Desktop = Remote-IDE, die auf dem Gateway läuft.
    # Anleitung: Browser aufweisen → Token aus Datei laden → loslegen.
    hermes_desktop = (
        f"# Hermes Desktop — Remote-IDE auf der Box\n"\
        f"#\n"\
        f"# 1. Browser öffnen: http://{host}:9001/hermes-ui\n"\
        f"#    (MC2-Proxy auf dem Gateway)\n"\
        f"#\n"\
        f"# 2. Session-Token: auf der Box liegen in\n"\
        f"#    ~/.hermes/desktop-gateway-token\n"\
        f"#    (den Dateiname kopieren, den TOKEN-WERT NICHT hardcoden!)\n"\
        f"#\n"\
        f"# 3. Token im Browser-Login einfügen — fertig.\n"\
        f"#\n"\
        f"# Modelle im Hermes Desktop: {PRIMARY_MODEL} (bauen), heavy (denken), vision (Bilder)."
    )

    # Claude Code spricht das Anthropic-Format; der Gateway ist OpenAI-kompatibel und
    # bietet KEIN /v1/messages (verifiziert). Daher braucht es einen kleinen Übersetzer
    # (Anthropic ⇄ OpenAI) als Aufsatz. Die env-Vars sind Claude Codes echte Schnittstelle.
    claude_code = (
        f"# Claude Code spricht das Anthropic-Format — der Gateway ist OpenAI-kompatibel ({gw})\n"
        f"# und hat kein /v1/messages. Dazwischen muss ein Übersetzer (Anthropic ⇄ OpenAI) laufen:\n"
        f"#   • claude-code-router   (leichtgewichtig, npm)\n"
        f"#   • oder LiteLLM mit /v1/messages-Bridge\n"
        f"# Den Übersetzer auf den Gateway zeigen lassen: baseURL={gw}, model=coder, apiKey=local.\n"
        f"# Dann Claude Code auf den lokalen Übersetzer richten (Beispiel-Port 3456):\n"
        f"\n"
        f'export ANTHROPIC_BASE_URL="http://localhost:3456"\n'
        f'export ANTHROPIC_AUTH_TOKEN="local"\n'
        f'export ANTHROPIC_MODEL="coder"'
    )

    return {
        "host": host,
        "gateway_url": gw,
        "mc_url": mc_url,
        # Leitung 1 — das MODELL. Bewusst NUR 3 Tools (Verdikt 09.07.2026): Hermes Desktop
        # (Remote-IDE im Browser), Kilo Code (VS-Code-Fallback mit Orchestrator-Modus),
        # Claude Code (starke Sessions).
        # Cursor/Continue/Roo/OpenCode entfernt — Roo eingestellt, Rest cloud-first, Terminal
        # oder von Kilo abgedeckt. Das Evolution-Radar (AUTONOMIE_PLAN E4) überwacht die Kategorie.
        "tools": {
            "hermes_desktop": {"label": "Hermes Desktop (empfohlen)", "lang": "bash", "snippet": hermes_desktop,
                    "note": "Remote-IDE im Browser — Gateway-URL + Token aus Datei laden. Drei Modelle: "
                            "Coder (bauen) · Planer (denken) · Augen (Bilder) — oben im Wähler umschalten."},
            "kilo": {"label": "Kilo Code", "lang": "json", "snippet": kilo,
                     "note": "VS Code/JetBrains (schwergewichtiger). OpenAI-Provider → Gateway. "
                             "API-Profile je Modus: Code→coder · Architect/Orchestrator→heavy · "
                             "Ask/Debug→Lane 'chat' (virtuelles Modell, wählt selbst fast oder heavy)."},
            "claude_code": {"label": "Claude Code", "lang": "bash", "snippet": claude_code,
                            "note": "Für die starken Sessions. Lokal-Betrieb bräuchte einen Anthropic⇄OpenAI-Übersetzer vor dem Gateway."},
        },
    }


def check_health() -> dict:
    """Live-Erreichbarkeit der drei Leitungen, aus Sicht der Box:
    Leitung 1 = der ECHTE Modell-Pfad, den Clients nutzen (mc2-gateway bei V1_UPSTREAM,
    sonst llama-swap direkt), Leitung 2 = Natives Hermes-Gedächtnis (hermes-gateway),
    Leitung 3 = Desktop-Gateway (Hermes-Builtin-UI)."""
    gateway = {"ok": False, "detail": "nicht erreichbar"}
    try:
        with httpx.Client(timeout=3.0) as c:
            r = c.get(f"{V1_UPSTREAM or LLAMA_SWAP_URL}/v1/models")
            if r.status_code == 200:
                n = len(r.json().get("data", []))
                gateway = {"ok": True, "detail": f"{n} Modelle verfügbar" if n else "bereit"}
            else:
                gateway = {"ok": False, "detail": f"HTTP {r.status_code}"}
    except Exception:
        pass

    memory = {"ok": False, "detail": "nicht erreichbar"}
    try:
        with httpx.Client(timeout=3.0) as c:
            # Hermes Gateway stellt das native Gedächtnis & Agent-Loop bereit
            r = c.get("http://127.0.0.1:8642/health")
            if r.status_code in (200, 404, 401):
                memory = {"ok": True, "detail": "Hermes-Nativ bereit"}
            else:
                memory = {"ok": False, "detail": f"HTTP {r.status_code}"}
    except Exception:
        pass

    desktop_gateway = {"ok": False, "detail": "nicht erreichbar"}
    try:
        with httpx.Client(timeout=3.0) as c:
            r = c.get(f"{HERMES_BUILTIN_UI_UPSTREAM}/api/status")
            desktop_gateway = ({"ok": True, "detail": "bereit"} if r.status_code == 200
                               else {"ok": False, "detail": f"HTTP {r.status_code}"})
    except Exception:
        pass

    return {"gateway": gateway, "memory": memory, "desktop_gateway": desktop_gateway}