feat(oauth): generische OAuth2-Pipeline ueber RVS-Callback (Spotify/Google/GitHub/Strava/MS)
Bisher musste Stefan bei OAuth-Flows manuell den Auth-Code aus der Browser-URL kopieren (redirect_uri war localhost). Jetzt: RVS hat einen HTTP-Listener auf demselben Port wie der WebSocket, Provider redirecten nach Auth zu https://{RVS_HOST}/oauth/callback/{service}, RVS broadcastet, aria-bridge forwarded, Brain matched state + tauscht code gegen Token. Token-Refresh laeuft automatisch. - rvs/server.js: hybrid http.createServer + WebSocketServer{noServer}. Route GET /oauth/callback/{service}, broadcast oauth_callback an alle Raeume, schoene Dark-Mode-HTML-Antwort an den Browser (Auto-Close 4s). - bridge/aria_bridge.py: empfaengt oauth_callback, POSTet an Brain /internal/oauth-callback. - aria-brain/oauth.py: neuer Manager. Pending-Store mit state+TTL, Token-Exchange (Basic-Auth oder Body je nach Provider), persistente Speicherung in /shared/config/oauth_tokens.json (mode 0600), Token-Refresh wenn <60s Restzeit. Vordefinierte Configs fuer Spotify, Google, GitHub, Strava, Microsoft. - aria-brain/agent.py: META-Tools oauth_authorize / oauth_get_token / oauth_revoke. - aria-brain/prompts.py: System-Prompt-Block zeigt ARIA die feste Callback-URL als Quelle der Wahrheit + aktuelle Service-States. - aria-brain/main.py: HTTP-Endpoints /oauth/services, /oauth/apps, /oauth/authorize, /oauth/{service}/revoke, /internal/oauth-callback. - diagnostic: neue Section "OAuth-Apps". Pro Service Karte mit Status, client_id + client_secret (Passwort-Toggle), Speichern + Autorisieren- Buttons. Authorize oeffnet Provider-Auth in neuem Tab. - docker-compose.yml: brain-env um RVS_HOST + RVS_PORT_PUBLIC + RVS_TLS ergaenzt (Brain braucht die Werte zum Bau der Callback-URL). - .env.example: RVS_PORT_PUBLIC + Brain-Timeout-Vars (PROXY_TIMEOUT_SEC + Connect/Write/Pool) dokumentiert. - README.md: OAuth-Pipeline + ARIA-Live-Mirror in Diagnostic-Section, OAuth-Apps in Einstellungen-Tab erwaehnt. - issue.md: OAuth-Pipeline + Brain-Timeout-Fix als erledigt dokumentiert. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
+143
-1
@@ -30,6 +30,7 @@ from proxy_client import ProxyClient, Message as ProxyMessage
|
||||
import skills as skills_mod
|
||||
import triggers as triggers_mod
|
||||
import watcher as watcher_mod
|
||||
import oauth as oauth_mod
|
||||
|
||||
BRIDGE_URL = os.environ.get("BRIDGE_URL", "http://aria-bridge:8090")
|
||||
# FLUX-Render kann bis ~90s dauern, beim ersten Render nach Container-Start
|
||||
@@ -245,6 +246,88 @@ META_TOOLS = [
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
"type": "function",
|
||||
"function": {
|
||||
"name": "oauth_authorize",
|
||||
"description": (
|
||||
"Startet einen OAuth2-Authorize-Flow fuer einen externen "
|
||||
"Service (Spotify, Google, GitHub, Strava, Microsoft, ...). "
|
||||
"Returnt eine URL die Stefan im Browser oeffnen muss — er "
|
||||
"loggt sich beim Provider ein und stimmt den Scopes zu, der "
|
||||
"Provider redirected zu unserem RVS-Callback, RVS forwarded "
|
||||
"an Brain, Token wird automatisch gespeichert.\n\n"
|
||||
"**Nutze das wenn:** Stefan moechte einen Service nutzen "
|
||||
"(z.B. \"verbinde mich mit Spotify\", \"baue einen Spotify-"
|
||||
"Skill\"), aber `oauth_get_token` wirft *Kein Token gespeichert*.\n\n"
|
||||
"**Workflow:**\n"
|
||||
"1. `oauth_authorize(service='spotify')` -> URL\n"
|
||||
"2. Gib Stefan die URL als anklickbaren Link\n"
|
||||
"3. Warte bis er sagt dass er autorisiert hat\n"
|
||||
"4. `oauth_get_token('spotify')` -> access_token, kannst Du im API-Call nutzen\n\n"
|
||||
"Voraussetzung: Stefan hat in Diagnostic > OAuth-Apps fuer den "
|
||||
"Service `client_id` + `client_secret` eingetragen. Falls nicht, "
|
||||
"wirft das Tool eine entsprechende Fehlermeldung — sage Stefan "
|
||||
"er soll das machen, NICHT versuchen die Credentials selbst zu "
|
||||
"raten oder zu generieren."
|
||||
),
|
||||
"parameters": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"service": {
|
||||
"type": "string",
|
||||
"description": "Service-Name. Vordefinierte: spotify, google, github, strava, microsoft. Custom-Services moeglich wenn Stefan sie in oauth_apps.json eingetragen hat (mit auth_url + token_url).",
|
||||
},
|
||||
"scopes": {
|
||||
"type": "array",
|
||||
"items": {"type": "string"},
|
||||
"description": "Optional: Provider-spezifische Scopes (z.B. fuer Spotify ['user-read-playback-state','playlist-modify-public']). Wenn weggelassen, werden die Default-Scopes des Services genutzt.",
|
||||
},
|
||||
},
|
||||
"required": ["service"],
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
"type": "function",
|
||||
"function": {
|
||||
"name": "oauth_get_token",
|
||||
"description": (
|
||||
"Liefert das aktuelle access_token fuer einen Service. "
|
||||
"Refresht automatisch wenn abgelaufen (oder < 60s Restzeit) "
|
||||
"und der Provider einen refresh_token mitgegeben hat.\n\n"
|
||||
"**Nutze das in Skills** wenn Du Provider-APIs callen willst — "
|
||||
"der token kommt als Bearer-Header in Deinen HTTP-Request, "
|
||||
"z.B. `Authorization: Bearer <token>`.\n\n"
|
||||
"Wirft wenn Service noch nicht authentifiziert ist oder der "
|
||||
"Refresh fehlschlaegt → dann erst `oauth_authorize` aufrufen."
|
||||
),
|
||||
"parameters": {
|
||||
"type": "object",
|
||||
"properties": {
|
||||
"service": {"type": "string", "description": "z.B. spotify, google, ..."},
|
||||
},
|
||||
"required": ["service"],
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
"type": "function",
|
||||
"function": {
|
||||
"name": "oauth_revoke",
|
||||
"description": (
|
||||
"Loescht das gespeicherte Token fuer einen Service (lokal). "
|
||||
"Stefan muss danach via `oauth_authorize` neu autorisieren wenn "
|
||||
"er den Service wieder nutzen will. Nutze das wenn Stefan sagt "
|
||||
"\"melde mich bei X ab\" oder \"vergiss meine Spotify-Anmeldung\"."
|
||||
),
|
||||
"parameters": {
|
||||
"type": "object",
|
||||
"properties": {"service": {"type": "string"}},
|
||||
"required": ["service"],
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
"type": "function",
|
||||
"function": {
|
||||
@@ -540,11 +623,24 @@ class Agent:
|
||||
|
||||
# 5. System-Prompt + Window-Messages
|
||||
flux_config = _load_flux_config()
|
||||
# OAuth-Block: aktuelle Service-States + Callback-URL fuer ARIA
|
||||
try:
|
||||
oauth_services = oauth_mod.list_services()
|
||||
except Exception as exc:
|
||||
logger.warning("oauth list_services fehlgeschlagen: %s", exc)
|
||||
oauth_services = None
|
||||
oauth_host = os.environ.get("RVS_HOST", "").strip()
|
||||
oauth_port = os.environ.get("RVS_PORT_PUBLIC", os.environ.get("RVS_PORT", "443")).strip()
|
||||
oauth_tls = os.environ.get("RVS_TLS", "true").strip().lower() != "false"
|
||||
system_prompt = build_system_prompt(hot, cold, skills=all_skills,
|
||||
triggers=all_triggers,
|
||||
condition_vars=condition_vars,
|
||||
condition_funcs=condition_funcs,
|
||||
flux_config=flux_config)
|
||||
flux_config=flux_config,
|
||||
oauth_services=oauth_services,
|
||||
oauth_callback_host=oauth_host,
|
||||
oauth_callback_port=oauth_port,
|
||||
oauth_callback_tls=oauth_tls)
|
||||
messages = [ProxyMessage(role="system", content=system_prompt)]
|
||||
for t in self.conversation.window():
|
||||
messages.append(ProxyMessage(role=t.role, content=t.content))
|
||||
@@ -730,6 +826,52 @@ class Agent:
|
||||
else:
|
||||
lines.append(f"- {t['name']} ({t['type']}, {state})")
|
||||
return "\n".join(lines)
|
||||
if name == "oauth_authorize":
|
||||
svc = (arguments.get("service") or "").strip()
|
||||
if not svc:
|
||||
return "FEHLER: service ist Pflicht (z.B. 'spotify')."
|
||||
scopes = arguments.get("scopes") if isinstance(arguments.get("scopes"), list) else None
|
||||
try:
|
||||
info = oauth_mod.build_authorize_url(svc, scopes=scopes)
|
||||
except RuntimeError as exc:
|
||||
return f"FEHLER: {exc}"
|
||||
except Exception as exc:
|
||||
logger.exception("oauth_authorize fehlgeschlagen")
|
||||
return f"FEHLER: {exc}"
|
||||
return (
|
||||
f"OK — Authorize-URL fuer {svc} bereit.\n"
|
||||
f"Sage Stefan: Klicke diesen Link um Dich bei {svc} anzumelden:\n\n"
|
||||
f"{info['url']}\n\n"
|
||||
f"Nach Zustimmung schickt Dich der Provider zu unserem Callback "
|
||||
f"({info['redirect_uri']}); RVS schnappt sich den code automatisch, "
|
||||
f"Brain tauscht ihn gegen ein Token. Du musst nichts copy-pasten.\n"
|
||||
f"Falls beim Provider 'redirect_uri_mismatch' auftaucht, muss Stefan "
|
||||
f"`{info['redirect_uri']}` einmalig im Provider-Dashboard als gueltige "
|
||||
f"Redirect-URI eintragen."
|
||||
)
|
||||
if name == "oauth_get_token":
|
||||
svc = (arguments.get("service") or "").strip()
|
||||
if not svc:
|
||||
return "FEHLER: service ist Pflicht."
|
||||
try:
|
||||
record = oauth_mod.get_token(svc)
|
||||
except RuntimeError as exc:
|
||||
return f"FEHLER: {exc}"
|
||||
tok = record.get("access_token", "")
|
||||
ttype = record.get("token_type", "Bearer")
|
||||
exp = record.get("expires_at", 0)
|
||||
remain = max(0, int(exp) - int(__import__("time").time()))
|
||||
return (
|
||||
f"OK — Token fuer {svc} (Typ: {ttype}, gueltig noch {remain}s).\n"
|
||||
f"access_token: {tok}\n"
|
||||
f"Nutze als HTTP-Header: Authorization: {ttype} {tok}"
|
||||
)
|
||||
if name == "oauth_revoke":
|
||||
svc = (arguments.get("service") or "").strip()
|
||||
if not svc:
|
||||
return "FEHLER: service ist Pflicht."
|
||||
ok = oauth_mod.revoke(svc)
|
||||
return f"OK — Token fuer {svc} entfernt." if ok else f"Kein Token fuer {svc} vorhanden."
|
||||
if name == "flux_generate":
|
||||
prompt = (arguments.get("prompt") or "").strip()
|
||||
if not prompt:
|
||||
|
||||
@@ -36,6 +36,7 @@ import metrics as metrics_mod
|
||||
import triggers as triggers_mod
|
||||
import watcher as watcher_mod
|
||||
import background as background_mod
|
||||
import oauth as oauth_mod
|
||||
|
||||
logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(name)s: %(message)s")
|
||||
logger = logging.getLogger("aria-brain")
|
||||
@@ -849,3 +850,118 @@ async def skills_import(request: Request, overwrite: bool = False):
|
||||
except ValueError as exc:
|
||||
raise HTTPException(400, str(exc))
|
||||
return {"imported": manifest}
|
||||
|
||||
|
||||
# ── OAuth ─────────────────────────────────────────────────────────
|
||||
|
||||
|
||||
@app.get("/oauth/services")
|
||||
async def oauth_services_list():
|
||||
"""Liste aller Services mit Status (configured/authenticated/expires)."""
|
||||
return {"services": oauth_mod.list_services()}
|
||||
|
||||
|
||||
@app.get("/oauth/apps")
|
||||
async def oauth_apps_get():
|
||||
"""Liefert die persistierte Provider-Config (client_id sichtbar, client_secret
|
||||
NICHT — wer den Wert braucht muss ihn neu eintragen). Fuer Diagnostic-UI."""
|
||||
apps = oauth_mod._load_json(oauth_mod.APPS_FILE)
|
||||
safe = {}
|
||||
for service, entry in apps.items():
|
||||
if not isinstance(entry, dict):
|
||||
continue
|
||||
safe[service] = {
|
||||
"client_id": entry.get("client_id", ""),
|
||||
"has_client_secret": bool(entry.get("client_secret")),
|
||||
"scopes": entry.get("scopes"),
|
||||
"auth_url": entry.get("auth_url"),
|
||||
"token_url": entry.get("token_url"),
|
||||
}
|
||||
return {"apps": safe, "defaults": list(oauth_mod.DEFAULT_PROVIDERS.keys())}
|
||||
|
||||
|
||||
class OAuthAppIn(BaseModel):
|
||||
service: str
|
||||
client_id: str = ""
|
||||
client_secret: str = ""
|
||||
scopes: Optional[List[str]] = None
|
||||
auth_url: Optional[str] = None
|
||||
token_url: Optional[str] = None
|
||||
|
||||
|
||||
@app.post("/oauth/apps")
|
||||
async def oauth_apps_set(body: OAuthAppIn):
|
||||
"""Speichert/aktualisiert eine Provider-Config. Leerer client_secret laesst
|
||||
den bestehenden Wert stehen (damit man die Form ohne Re-Eingabe absenden
|
||||
kann fuer reine scope-Aenderungen)."""
|
||||
service = (body.service or "").strip()
|
||||
if not service or not service.isidentifier() and not all(c.isalnum() or c in "_-" for c in service):
|
||||
raise HTTPException(400, "Ungueltiger service-Name (a-z0-9_- erlaubt)")
|
||||
apps = oauth_mod._load_json(oauth_mod.APPS_FILE)
|
||||
entry = apps.get(service) or {}
|
||||
if body.client_id:
|
||||
entry["client_id"] = body.client_id.strip()
|
||||
if body.client_secret:
|
||||
entry["client_secret"] = body.client_secret.strip()
|
||||
if body.scopes is not None:
|
||||
entry["scopes"] = body.scopes
|
||||
if body.auth_url:
|
||||
entry["auth_url"] = body.auth_url.strip()
|
||||
if body.token_url:
|
||||
entry["token_url"] = body.token_url.strip()
|
||||
apps[service] = entry
|
||||
oauth_mod._save_json(oauth_mod.APPS_FILE, apps)
|
||||
logger.info("OAuth-App %s gespeichert (client_id=%s, has_secret=%s)",
|
||||
service, entry.get("client_id", ""), bool(entry.get("client_secret")))
|
||||
return {"ok": True, "service": service}
|
||||
|
||||
|
||||
@app.delete("/oauth/apps/{service}")
|
||||
async def oauth_apps_delete(service: str):
|
||||
apps = oauth_mod._load_json(oauth_mod.APPS_FILE)
|
||||
if service in apps:
|
||||
apps.pop(service)
|
||||
oauth_mod._save_json(oauth_mod.APPS_FILE, apps)
|
||||
# Token auch wegwerfen
|
||||
oauth_mod.revoke(service)
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
@app.post("/oauth/{service}/revoke")
|
||||
async def oauth_revoke_endpoint(service: str):
|
||||
return {"ok": oauth_mod.revoke(service)}
|
||||
|
||||
|
||||
class OAuthAuthorizeIn(BaseModel):
|
||||
service: str
|
||||
scopes: Optional[List[str]] = None
|
||||
|
||||
|
||||
@app.post("/oauth/authorize")
|
||||
async def oauth_authorize_endpoint(body: OAuthAuthorizeIn):
|
||||
"""Baut eine Authorize-URL fuer einen Service. Diagnostic kann das nutzen
|
||||
um den Auth-Flow manuell anzustossen. ARIA selbst nutzt das Tool
|
||||
`oauth_authorize` (in agent._dispatch_tool gemapped auf die gleiche Logik)."""
|
||||
try:
|
||||
return oauth_mod.build_authorize_url(body.service, scopes=body.scopes)
|
||||
except RuntimeError as exc:
|
||||
raise HTTPException(400, str(exc))
|
||||
|
||||
|
||||
@app.post("/internal/oauth-callback")
|
||||
async def oauth_callback_internal(request: Request):
|
||||
"""Wird von aria-bridge gerufen wenn ein RVS oauth_callback ankommt.
|
||||
Macht den state-Match + token-exchange und persistiert."""
|
||||
try:
|
||||
body = await request.json()
|
||||
except Exception as exc:
|
||||
raise HTTPException(400, f"bad json: {exc}")
|
||||
service = (body.get("service") or "").strip()
|
||||
code = (body.get("code") or "").strip()
|
||||
state = (body.get("state") or "").strip()
|
||||
err = body.get("error") or None
|
||||
err_desc = body.get("errorDescription") or None
|
||||
if not service:
|
||||
raise HTTPException(400, "service erforderlich")
|
||||
result = oauth_mod.handle_callback(service, code, state, error=err, error_description=err_desc)
|
||||
return result
|
||||
|
||||
@@ -0,0 +1,425 @@
|
||||
"""
|
||||
OAuth-Manager fuer ARIA. Generischer OAuth2 Authorization-Code-Flow fuer
|
||||
Spotify, Google, GitHub, Strava, Microsoft etc.
|
||||
|
||||
Architektur:
|
||||
- Brain haelt einen Pending-Store: state-String → pending Auth-Request
|
||||
(mit timeout). Wenn ein Callback ankommt (via aria-bridge ueber RVS),
|
||||
matched der state und der code wird gegen access_token getauscht.
|
||||
- Token-Storage: /shared/config/oauth_tokens.json (pro Service ein Eintrag
|
||||
mit access_token, refresh_token, expires_at, scope).
|
||||
- Provider-Configs: /shared/config/oauth_apps.json — pro Service
|
||||
{client_id, client_secret, auth_url, token_url, scopes, ...}. Wird
|
||||
typischerweise via Diagnostic-UI gefuellt.
|
||||
- Token-Refresh: automatisch wenn access_token abgelaufen oder < 60s
|
||||
bis Ablauf bei get_token() Aufruf.
|
||||
|
||||
OAuth-Callback-URL: https://{RVS_HOST}:{RVS_PORT_PUBLIC}/oauth/callback/{service}
|
||||
RVS_PORT_PUBLIC ist nicht zwingend gleich RVS_PORT (port-mapping via TLS-Proxy).
|
||||
ARIA setzt die URL beim Auth-Request automatisch — Stefan muss sie EINMAL pro
|
||||
Service im Provider-Dashboard registrieren.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import base64
|
||||
import json
|
||||
import logging
|
||||
import os
|
||||
import secrets
|
||||
import time
|
||||
import urllib.parse
|
||||
import urllib.request
|
||||
from pathlib import Path
|
||||
from typing import Optional
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
CONFIG_DIR = Path("/shared/config")
|
||||
APPS_FILE = CONFIG_DIR / "oauth_apps.json"
|
||||
TOKENS_FILE = CONFIG_DIR / "oauth_tokens.json"
|
||||
|
||||
# Default-Provider-Configs. Werden von oauth_apps.json gemergt (User-Config
|
||||
# uebersteuert). Stefan muss nur client_id + client_secret eintragen.
|
||||
DEFAULT_PROVIDERS: dict[str, dict] = {
|
||||
"spotify": {
|
||||
"auth_url": "https://accounts.spotify.com/authorize",
|
||||
"token_url": "https://accounts.spotify.com/api/token",
|
||||
"scopes": ["user-read-playback-state", "user-modify-playback-state",
|
||||
"user-read-currently-playing", "playlist-read-private",
|
||||
"user-library-read"],
|
||||
"client_auth": "basic", # client_id:client_secret als Basic-Auth-Header
|
||||
},
|
||||
"google": {
|
||||
"auth_url": "https://accounts.google.com/o/oauth2/v2/auth",
|
||||
"token_url": "https://oauth2.googleapis.com/token",
|
||||
"scopes": ["openid", "email", "profile"],
|
||||
"client_auth": "body", # client_id+secret im Body
|
||||
"extra_auth_params": {"access_type": "offline", "prompt": "consent"},
|
||||
},
|
||||
"github": {
|
||||
"auth_url": "https://github.com/login/oauth/authorize",
|
||||
"token_url": "https://github.com/login/oauth/access_token",
|
||||
"scopes": ["read:user"],
|
||||
"client_auth": "body",
|
||||
"accept_header": "application/json", # GitHub returns form-urlencoded otherwise
|
||||
},
|
||||
"strava": {
|
||||
"auth_url": "https://www.strava.com/oauth/authorize",
|
||||
"token_url": "https://www.strava.com/oauth/token",
|
||||
"scopes": ["read", "activity:read_all"],
|
||||
"client_auth": "body",
|
||||
"extra_auth_params": {"approval_prompt": "auto"},
|
||||
},
|
||||
"microsoft": {
|
||||
"auth_url": "https://login.microsoftonline.com/common/oauth2/v2.0/authorize",
|
||||
"token_url": "https://login.microsoftonline.com/common/oauth2/v2.0/token",
|
||||
"scopes": ["User.Read", "offline_access"],
|
||||
"client_auth": "body",
|
||||
},
|
||||
}
|
||||
|
||||
# Pending Auth-Requests: state → {service, scopes, redirect_uri, created_at}
|
||||
_PENDING: dict[str, dict] = {}
|
||||
PENDING_TTL_SEC = 600 # 10 min — laenger nicht sinnvoll, OAuth-Codes sind eh kurzlebig
|
||||
|
||||
|
||||
# ── Helpers ─────────────────────────────────────────────────
|
||||
|
||||
|
||||
def _callback_url(service: str) -> str:
|
||||
"""Baut die Redirect-URL die wir bei der Provider-Auth angeben.
|
||||
Liest RVS_HOST / RVS_PORT_PUBLIC / RVS_TLS aus env."""
|
||||
host = os.environ.get("RVS_HOST", "").strip()
|
||||
if not host:
|
||||
raise RuntimeError("RVS_HOST nicht gesetzt — OAuth-Callbacks nicht moeglich")
|
||||
port = os.environ.get("RVS_PORT_PUBLIC", os.environ.get("RVS_PORT", "443")).strip()
|
||||
tls = os.environ.get("RVS_TLS", "true").strip().lower() != "false"
|
||||
scheme = "https" if tls else "http"
|
||||
# Default-Ports 443/80 nicht in URL anhaengen
|
||||
if (tls and port == "443") or (not tls and port == "80"):
|
||||
return f"{scheme}://{host}/oauth/callback/{service}"
|
||||
return f"{scheme}://{host}:{port}/oauth/callback/{service}"
|
||||
|
||||
|
||||
def _load_json(path: Path) -> dict:
|
||||
try:
|
||||
if path.exists():
|
||||
return json.loads(path.read_text(encoding="utf-8"))
|
||||
except Exception as exc:
|
||||
logger.warning("OAuth-Datei %s lesen fehlgeschlagen: %s", path, exc)
|
||||
return {}
|
||||
|
||||
|
||||
def _save_json(path: Path, data: dict) -> None:
|
||||
try:
|
||||
path.parent.mkdir(parents=True, exist_ok=True)
|
||||
tmp = path.with_suffix(path.suffix + ".tmp")
|
||||
tmp.write_text(json.dumps(data, indent=2, ensure_ascii=False), encoding="utf-8")
|
||||
tmp.replace(path)
|
||||
# 600 — enthaelt Secrets
|
||||
try: os.chmod(path, 0o600)
|
||||
except OSError: pass
|
||||
except Exception as exc:
|
||||
logger.error("OAuth-Datei %s speichern fehlgeschlagen: %s", path, exc)
|
||||
|
||||
|
||||
def _provider_config(service: str) -> dict:
|
||||
"""Mergt Default-Provider-Config mit User-Override aus oauth_apps.json."""
|
||||
defaults = DEFAULT_PROVIDERS.get(service, {}).copy()
|
||||
apps = _load_json(APPS_FILE)
|
||||
user = (apps.get(service) or {}).copy()
|
||||
# Tiefes Merge nicht noetig — die kollidierenden Felder sind alle scalar/list.
|
||||
merged = {**defaults, **user}
|
||||
return merged
|
||||
|
||||
|
||||
def _provider_credentials(service: str) -> tuple[str, str]:
|
||||
"""Liest client_id + client_secret aus oauth_apps.json. Wirft wenn nicht
|
||||
konfiguriert — der OAuth-Flow kann ohne nicht starten."""
|
||||
apps = _load_json(APPS_FILE)
|
||||
entry = apps.get(service) or {}
|
||||
cid = (entry.get("client_id") or "").strip()
|
||||
sec = (entry.get("client_secret") or "").strip()
|
||||
if not cid or not sec:
|
||||
raise RuntimeError(
|
||||
f"OAuth-App '{service}' nicht konfiguriert. Bitte in Diagnostic > "
|
||||
f"OAuth-Apps client_id + client_secret eintragen."
|
||||
)
|
||||
return cid, sec
|
||||
|
||||
|
||||
def _cleanup_pending() -> None:
|
||||
"""Entfernt abgelaufene Pending-Auths."""
|
||||
now = time.time()
|
||||
for state, info in list(_PENDING.items()):
|
||||
if now - info.get("created_at", 0) > PENDING_TTL_SEC:
|
||||
_PENDING.pop(state, None)
|
||||
|
||||
|
||||
# ── Authorize ───────────────────────────────────────────────
|
||||
|
||||
|
||||
def build_authorize_url(service: str, scopes: Optional[list[str]] = None,
|
||||
extra_params: Optional[dict] = None) -> dict:
|
||||
"""Baut die Authorize-URL fuer einen Provider. Speichert den state
|
||||
im Pending-Store. Returns {url, state, redirect_uri, service}.
|
||||
|
||||
Wird vom Brain-Tool oauth_authorize gerufen. ARIA gibt die url an Stefan,
|
||||
der oeffnet sie im Browser, autorisiert, Provider redirected zur
|
||||
redirect_uri (= RVS), RVS broadcasted, bridge forwarded, brain matched
|
||||
state → exchange.
|
||||
"""
|
||||
_cleanup_pending()
|
||||
cfg = _provider_config(service)
|
||||
if not cfg.get("auth_url") or not cfg.get("token_url"):
|
||||
raise RuntimeError(f"Provider '{service}' hat keine auth_url/token_url. "
|
||||
f"In oauth_apps.json eintragen oder einen der "
|
||||
f"vordefinierten Services nutzen ({', '.join(DEFAULT_PROVIDERS)}).")
|
||||
cid, _ = _provider_credentials(service)
|
||||
redirect_uri = _callback_url(service)
|
||||
state = secrets.token_urlsafe(32)
|
||||
use_scopes = scopes if scopes else cfg.get("scopes") or []
|
||||
|
||||
params = {
|
||||
"client_id": cid,
|
||||
"response_type": "code",
|
||||
"redirect_uri": redirect_uri,
|
||||
"state": state,
|
||||
}
|
||||
if use_scopes:
|
||||
params["scope"] = " ".join(use_scopes)
|
||||
params.update(cfg.get("extra_auth_params") or {})
|
||||
if extra_params:
|
||||
params.update(extra_params)
|
||||
|
||||
url = cfg["auth_url"] + "?" + urllib.parse.urlencode(params)
|
||||
|
||||
_PENDING[state] = {
|
||||
"service": service,
|
||||
"redirect_uri": redirect_uri,
|
||||
"scopes": use_scopes,
|
||||
"created_at": time.time(),
|
||||
}
|
||||
logger.info("[oauth] Authorize-URL fuer %s gebaut: state=%s redirect=%s",
|
||||
service, state[:8] + "...", redirect_uri)
|
||||
return {"url": url, "state": state, "redirect_uri": redirect_uri, "service": service}
|
||||
|
||||
|
||||
# ── Token-Exchange ──────────────────────────────────────────
|
||||
|
||||
|
||||
def _token_request(token_url: str, body_params: dict, cfg: dict,
|
||||
client_id: str, client_secret: str) -> dict:
|
||||
"""POST an provider /token endpoint. Returns parsed JSON oder wirft."""
|
||||
data = urllib.parse.urlencode(body_params).encode("utf-8")
|
||||
headers = {"Content-Type": "application/x-www-form-urlencoded"}
|
||||
if cfg.get("accept_header"):
|
||||
headers["Accept"] = cfg["accept_header"]
|
||||
# Client-Auth: 'basic' (Header) oder 'body' (im Form-Body)
|
||||
if cfg.get("client_auth") == "basic":
|
||||
auth_str = f"{client_id}:{client_secret}"
|
||||
b64 = base64.b64encode(auth_str.encode("utf-8")).decode("ascii")
|
||||
headers["Authorization"] = f"Basic {b64}"
|
||||
else:
|
||||
# bereits im body_params drin (siehe Caller)
|
||||
pass
|
||||
req = urllib.request.Request(token_url, data=data, method="POST", headers=headers)
|
||||
try:
|
||||
with urllib.request.urlopen(req, timeout=15) as resp:
|
||||
raw = resp.read().decode("utf-8", "ignore")
|
||||
try:
|
||||
return json.loads(raw)
|
||||
except json.JSONDecodeError:
|
||||
# GitHub default ist form-urlencoded — accept_header sollte
|
||||
# JSON anfordern, aber falls's doch mal kommt:
|
||||
parsed = urllib.parse.parse_qs(raw)
|
||||
return {k: v[0] if isinstance(v, list) and v else v for k, v in parsed.items()}
|
||||
except urllib.error.HTTPError as e:
|
||||
body = e.read().decode("utf-8", "ignore")[:500]
|
||||
raise RuntimeError(f"Token-Request HTTP {e.code}: {body}") from e
|
||||
|
||||
|
||||
def handle_callback(service: str, code: str, state: str,
|
||||
error: Optional[str] = None,
|
||||
error_description: Optional[str] = None) -> dict:
|
||||
"""Verarbeitet einen OAuth-Callback. Validiert state, tauscht code gegen
|
||||
Token, speichert. Returns {ok, service, message, ...}.
|
||||
|
||||
Wird von /internal/oauth-callback (HTTP, von aria-bridge) gerufen.
|
||||
"""
|
||||
_cleanup_pending()
|
||||
|
||||
if error:
|
||||
# Provider hat User-Abbruch oder Fehler gemeldet
|
||||
_PENDING.pop(state, None) if state else None
|
||||
logger.warning("[oauth] Provider-Error %s/%s: %s — %s",
|
||||
service, state[:8] + "..." if state else "?", error, error_description)
|
||||
return {"ok": False, "service": service, "error": error,
|
||||
"errorDescription": error_description}
|
||||
|
||||
pending = _PENDING.pop(state, None)
|
||||
if not pending:
|
||||
logger.warning("[oauth] Unknown state %s fuer %s — abgelaufen oder CSRF?", state[:8] + "...", service)
|
||||
return {"ok": False, "service": service,
|
||||
"error": "invalid_state",
|
||||
"errorDescription": "Unbekannter oder abgelaufener state (Auth-Anfrage muss erst per oauth_authorize neu gestartet werden)."}
|
||||
if pending.get("service") != service:
|
||||
logger.warning("[oauth] state-Service-Mismatch: pending=%s vs callback=%s",
|
||||
pending.get("service"), service)
|
||||
return {"ok": False, "service": service,
|
||||
"error": "service_mismatch",
|
||||
"errorDescription": "state gehoert zu einem anderen Service."}
|
||||
|
||||
if not code:
|
||||
return {"ok": False, "service": service, "error": "no_code"}
|
||||
|
||||
cfg = _provider_config(service)
|
||||
try:
|
||||
client_id, client_secret = _provider_credentials(service)
|
||||
except RuntimeError as exc:
|
||||
return {"ok": False, "service": service, "error": "no_credentials",
|
||||
"errorDescription": str(exc)}
|
||||
|
||||
body = {
|
||||
"grant_type": "authorization_code",
|
||||
"code": code,
|
||||
"redirect_uri": pending["redirect_uri"],
|
||||
}
|
||||
if cfg.get("client_auth") != "basic":
|
||||
body["client_id"] = client_id
|
||||
body["client_secret"] = client_secret
|
||||
|
||||
try:
|
||||
token_data = _token_request(cfg["token_url"], body, cfg, client_id, client_secret)
|
||||
except Exception as exc:
|
||||
logger.exception("[oauth] Token-Exchange fehlgeschlagen fuer %s", service)
|
||||
return {"ok": False, "service": service, "error": "exchange_failed",
|
||||
"errorDescription": str(exc)[:200]}
|
||||
|
||||
access = token_data.get("access_token")
|
||||
if not access:
|
||||
return {"ok": False, "service": service, "error": "no_access_token",
|
||||
"errorDescription": str(token_data)[:200]}
|
||||
|
||||
expires_in = int(token_data.get("expires_in") or 3600)
|
||||
refresh = token_data.get("refresh_token") or ""
|
||||
scope = token_data.get("scope") or " ".join(pending.get("scopes") or [])
|
||||
token_type = token_data.get("token_type") or "Bearer"
|
||||
|
||||
record = {
|
||||
"service": service,
|
||||
"access_token": access,
|
||||
"refresh_token": refresh,
|
||||
"token_type": token_type,
|
||||
"scope": scope,
|
||||
"expires_at": int(time.time()) + expires_in,
|
||||
"obtained_at": int(time.time()),
|
||||
}
|
||||
_persist_token(service, record)
|
||||
logger.info("[oauth] %s authentifiziert — expires in %ds, refresh=%s",
|
||||
service, expires_in, "ja" if refresh else "nein")
|
||||
return {"ok": True, "service": service, "expiresIn": expires_in,
|
||||
"hasRefresh": bool(refresh), "scope": scope}
|
||||
|
||||
|
||||
# ── Token-Storage / Refresh / Revoke ─────────────────────────
|
||||
|
||||
|
||||
def _persist_token(service: str, record: dict) -> None:
|
||||
tokens = _load_json(TOKENS_FILE)
|
||||
tokens[service] = record
|
||||
_save_json(TOKENS_FILE, tokens)
|
||||
|
||||
|
||||
def _load_token(service: str) -> Optional[dict]:
|
||||
return _load_json(TOKENS_FILE).get(service)
|
||||
|
||||
|
||||
def get_token(service: str, refresh_threshold_sec: int = 60) -> dict:
|
||||
"""Holt das aktuelle access_token fuer einen Service. Refresht automatisch
|
||||
wenn weniger als refresh_threshold_sec Restzeit. Returns das ganze
|
||||
record-dict — Caller nimmt sich access_token raus.
|
||||
|
||||
Wirft wenn nicht authentifiziert oder Refresh fehlschlaegt — Tool-Aufrufer
|
||||
soll dann oauth_authorize anbieten."""
|
||||
record = _load_token(service)
|
||||
if not record:
|
||||
raise RuntimeError(f"Kein Token fuer '{service}' gespeichert. Erst per "
|
||||
f"oauth_authorize authentifizieren.")
|
||||
exp = int(record.get("expires_at") or 0)
|
||||
remaining = exp - int(time.time())
|
||||
if remaining > refresh_threshold_sec:
|
||||
return record
|
||||
# Refresh noetig
|
||||
refresh_tok = (record.get("refresh_token") or "").strip()
|
||||
if not refresh_tok:
|
||||
raise RuntimeError(f"Token fuer '{service}' abgelaufen und kein refresh_token "
|
||||
f"vorhanden — bitte neu autorisieren mit oauth_authorize.")
|
||||
cfg = _provider_config(service)
|
||||
client_id, client_secret = _provider_credentials(service)
|
||||
body = {
|
||||
"grant_type": "refresh_token",
|
||||
"refresh_token": refresh_tok,
|
||||
}
|
||||
if cfg.get("client_auth") != "basic":
|
||||
body["client_id"] = client_id
|
||||
body["client_secret"] = client_secret
|
||||
try:
|
||||
new_data = _token_request(cfg["token_url"], body, cfg, client_id, client_secret)
|
||||
except Exception as exc:
|
||||
raise RuntimeError(f"Token-Refresh fuer '{service}' fehlgeschlagen: {exc}") from exc
|
||||
|
||||
new_access = new_data.get("access_token")
|
||||
if not new_access:
|
||||
raise RuntimeError(f"Refresh-Antwort ohne access_token: {new_data}")
|
||||
expires_in = int(new_data.get("expires_in") or 3600)
|
||||
# refresh_token kann (manche Provider) bei jedem Refresh rotieren
|
||||
new_refresh = (new_data.get("refresh_token") or refresh_tok).strip()
|
||||
record.update({
|
||||
"access_token": new_access,
|
||||
"refresh_token": new_refresh,
|
||||
"expires_at": int(time.time()) + expires_in,
|
||||
"obtained_at": int(time.time()),
|
||||
})
|
||||
if new_data.get("scope"):
|
||||
record["scope"] = new_data["scope"]
|
||||
_persist_token(service, record)
|
||||
logger.info("[oauth] %s Token refreshed — neue Restzeit %ds", service, expires_in)
|
||||
return record
|
||||
|
||||
|
||||
def revoke(service: str) -> bool:
|
||||
"""Entfernt das Token aus dem Storage (Best-Effort, kein Provider-Revoke-Call)."""
|
||||
tokens = _load_json(TOKENS_FILE)
|
||||
if service not in tokens:
|
||||
return False
|
||||
tokens.pop(service, None)
|
||||
_save_json(TOKENS_FILE, tokens)
|
||||
logger.info("[oauth] %s Token geloescht (lokal).", service)
|
||||
return True
|
||||
|
||||
|
||||
def list_services() -> list[dict]:
|
||||
"""Diagnostik: zeigt fuer jeden konfigurierten Service ob Token da ist
|
||||
+ Ablaufzeit. Wird von Diagnostic genutzt."""
|
||||
apps = _load_json(APPS_FILE)
|
||||
tokens = _load_json(TOKENS_FILE)
|
||||
out = []
|
||||
services = set(apps.keys()) | set(tokens.keys()) | set(DEFAULT_PROVIDERS.keys())
|
||||
now = int(time.time())
|
||||
for s in sorted(services):
|
||||
app = apps.get(s) or {}
|
||||
tok = tokens.get(s) or {}
|
||||
configured = bool(app.get("client_id") and app.get("client_secret"))
|
||||
out.append({
|
||||
"service": s,
|
||||
"configured": configured,
|
||||
"authenticated": bool(tok.get("access_token")),
|
||||
"expiresAt": tok.get("expires_at"),
|
||||
"expiresInSec": (tok.get("expires_at", 0) - now) if tok.get("expires_at") else None,
|
||||
"hasRefresh": bool(tok.get("refresh_token")),
|
||||
"scope": tok.get("scope", ""),
|
||||
"isDefault": s in DEFAULT_PROVIDERS,
|
||||
})
|
||||
return out
|
||||
+71
-1
@@ -240,6 +240,63 @@ def build_triggers_section(
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
def build_oauth_section(oauth_services: list[dict] | None,
|
||||
callback_host: str = "",
|
||||
callback_port: str = "443",
|
||||
callback_tls: bool = True) -> str:
|
||||
"""Block fuer den System-Prompt: zeigt ARIA welche externen Services
|
||||
via OAuth verfuegbar sind, welche schon authentifiziert sind, und welche
|
||||
Callback-URL beim Provider eingetragen werden muss."""
|
||||
scheme = "https" if callback_tls else "http"
|
||||
if callback_host:
|
||||
if (callback_tls and callback_port == "443") or (not callback_tls and callback_port == "80"):
|
||||
base = f"{scheme}://{callback_host}/oauth/callback/<SERVICE>"
|
||||
else:
|
||||
base = f"{scheme}://{callback_host}:{callback_port}/oauth/callback/<SERVICE>"
|
||||
else:
|
||||
base = "<nicht konfiguriert — RVS_HOST in brain env fehlt>"
|
||||
|
||||
lines = [
|
||||
"## OAuth externe Services",
|
||||
"",
|
||||
"Du kannst Spotify, Google, GitHub, Strava, Microsoft (und custom-konfigurierte) "
|
||||
"Services via OAuth2 ansprechen. Workflow ist IMMER:",
|
||||
"1. `oauth_get_token(service)` versuchen — Token vorhanden? → benutzen.",
|
||||
"2. Wirft 'Kein Token gespeichert'? → `oauth_authorize(service)` aufrufen, URL an Stefan, warten, dann nochmal `oauth_get_token`.",
|
||||
"",
|
||||
f"**Callback-URL (fest, NICHT raten):** `{base}`",
|
||||
"Diese URL muss Stefan EINMAL pro Service im Provider-Dashboard als gueltige "
|
||||
"Redirect-URI eintragen. Sie ist hardcoded an die RVS-Infrastruktur gebunden "
|
||||
"und aendert sich nicht — auch nicht wenn Du als Brain neu aufgesetzt wirst.",
|
||||
"",
|
||||
"**NICHT** versuchen client_id / client_secret selbst zu generieren oder zu "
|
||||
"raten. Wenn nicht eingetragen → Stefan sagen er soll es in Diagnostic > "
|
||||
"OAuth-Apps machen.",
|
||||
]
|
||||
if oauth_services:
|
||||
lines.append("")
|
||||
lines.append("**Aktuelle Service-Status:**")
|
||||
for s in oauth_services:
|
||||
name = s.get("service", "?")
|
||||
configured = s.get("configured", False)
|
||||
auth = s.get("authenticated", False)
|
||||
remain = s.get("expiresInSec")
|
||||
parts = []
|
||||
if not configured:
|
||||
parts.append("Credentials fehlen")
|
||||
elif not auth:
|
||||
parts.append("nicht authentifiziert")
|
||||
else:
|
||||
if remain is None:
|
||||
parts.append("authentifiziert")
|
||||
elif remain > 0:
|
||||
parts.append(f"authentifiziert, Token gueltig noch {remain}s")
|
||||
else:
|
||||
parts.append("Token abgelaufen (wird automatisch refresht)")
|
||||
lines.append(f"- `{name}`: {' / '.join(parts)}")
|
||||
return "\n".join(lines)
|
||||
|
||||
|
||||
def build_flux_section(flux_config: dict) -> str:
|
||||
"""Block fuer den System-Prompt: aktuelle Diagnostic-Settings fuer
|
||||
Bildgenerierung (Default-Modell + User-konfigurierbare Keywords).
|
||||
@@ -279,8 +336,12 @@ def build_system_prompt(
|
||||
condition_vars: List[dict] | None = None,
|
||||
condition_funcs: List[dict] | None = None,
|
||||
flux_config: dict | None = None,
|
||||
oauth_services: list[dict] | None = None,
|
||||
oauth_callback_host: str = "",
|
||||
oauth_callback_port: str = "443",
|
||||
oauth_callback_tls: bool = True,
|
||||
) -> str:
|
||||
"""Kompletter System-Prompt: Hot + Cold + Skills + Triggers + FLUX."""
|
||||
"""Kompletter System-Prompt: Hot + Cold + Skills + Triggers + FLUX + OAuth."""
|
||||
parts = [build_hot_memory_section(pinned), "", build_time_section()]
|
||||
if skills:
|
||||
parts.append("")
|
||||
@@ -291,6 +352,15 @@ def build_system_prompt(
|
||||
if flux_config is not None:
|
||||
parts.append("")
|
||||
parts.append(build_flux_section(flux_config))
|
||||
# OAuth-Block bauen wir nur wenn RVS_HOST konfiguriert ist (sonst hat
|
||||
# die Callback-URL keinen Sinn). Sonst lassen wir den Block weg statt
|
||||
# ARIA eine "<nicht konfiguriert>"-URL zu zeigen.
|
||||
if oauth_callback_host:
|
||||
parts.append("")
|
||||
parts.append(build_oauth_section(oauth_services,
|
||||
callback_host=oauth_callback_host,
|
||||
callback_port=oauth_callback_port,
|
||||
callback_tls=oauth_callback_tls))
|
||||
if cold:
|
||||
parts.append("")
|
||||
parts.append(build_cold_memory_section(cold))
|
||||
|
||||
Reference in New Issue
Block a user