Files
devplacepy/devplacepy/routers/admin/services.py
T
retoorandClaude Sonnet 5 569f1dcc64 Add OpenCode Zen support, model health/stats dashboard, and gateway fallback fixes
AI gateway:
- Add a generic, admin-selectable `client_profile` field on gateway_providers
  (e.g. "opencode") so a provider needing special request headers (OpenCode
  Zen's client-identity spoofing) is configured like any other provider, not
  hardcoded by name.
- Track per-(provider, model) reliability/speed/latency health in memory,
  seeded from the existing gateway_usage_ledger at startup - purely
  observational, never influences routing.
- New Stats tab on /admin/gateway: request volume, latency, per-model
  breakdowns, and reliability weight, charted with a vendored Chart.js and
  devplace's own theme tokens.
- Record which model a failed request actually fell back to
  (fallback_used_route), surfaced in the Recent Failures table.
- Stop excluding context_length errors from fallback, and skip a primary
  attempt outright when its known context window is already too small for
  the estimated request size, going straight to the fallback.
- gateway_usage_ledger's provider/fallback_used_route columns and indexes
  are ensured centrally in database/schema.py's init_db(), the single point
  of truth for this table's schema.
- Non-OpenAI upstream routing and client-model passthrough; trust only the
  upstream's own X-Gateway-Model header for served-model attribution.

Devii agent:
- Fix a real lockup: plan/verify tools could be individually disabled via
  the admin tool toggles while still being required by the protocol gate,
  permanently bricking any task that needed tools. They can no longer be
  disabled, and the gate now also checks the tool is actually offered.
- Fix compaction being silently calibrated for a 1M-token model while
  running a much smaller one: context budget is now percentage-based and
  the summarizer's own request is sized to fit the real model.
- Give a specific, actionable retry message when plan()'s own arguments get
  cut off by the output limit, and tighten its schema to discourage
  overlong plans.

Other:
- Backup service: offload completed backups to a remote Hetzner Storage Box.
- Container manager: fix orphan blob leaks from sync races, add a two-phase
  plan/execute `system prune` CLI command.
- Admin gateway UI: replace the JS-rendered model/provider tables with
  server-rendered forms and pages.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DhmEkvutuwtzFVcLbTrhdo
2026-09-09 07:38:24 +02:00

221 lines
7.5 KiB
Python

# retoor <retoor@molodetz.nl>
import logging
from typing import Any
from fastapi import APIRouter, Request
from fastapi.responses import HTMLResponse, JSONResponse
from devplacepy.templating import templates
from devplacepy.utils import require_admin, not_found
from devplacepy.services.manager import service_manager
from devplacepy.seo import base_seo_context, site_url, website_schema
from devplacepy.services.audit import record as audit
from devplacepy.services.devii import tool_prefs
logger = logging.getLogger(__name__)
router = APIRouter()
@router.get("", response_class=HTMLResponse)
async def services_page(request: Request):
admin = require_admin(request)
services = service_manager.describe_all()
base = site_url(request)
seo_ctx = base_seo_context(
request,
title="Services - Admin",
description="Monitor and configure background services on DevPlace.",
robots="noindex,nofollow",
breadcrumbs=[
{"name": "Home", "url": "/feed"},
{"name": "Admin", "url": "/admin"},
{"name": "Services", "url": "/admin/services"},
],
schemas=[website_schema(base)],
)
return templates.TemplateResponse(
request,
"services.html",
{
**seo_ctx,
"request": request,
"user": admin,
"services": services,
"admin_section": "services",
},
)
@router.get("/data")
async def services_json(request: Request):
require_admin(request)
return JSONResponse({"services": service_manager.describe_all()})
@router.get("/{name}", response_class=HTMLResponse)
async def service_detail(request: Request, name: str):
admin = require_admin(request)
svc = service_manager.get_service(name)
if svc is None:
raise not_found("Service not found")
info = svc.describe()
base = site_url(request)
seo_ctx = base_seo_context(
request,
title=f"{info['title']} - Services",
description=info["description"] or f"Configure the {info['title']} service.",
robots="noindex,nofollow",
breadcrumbs=[
{"name": "Home", "url": "/feed"},
{"name": "Admin", "url": "/admin"},
{"name": "Services", "url": "/admin/services"},
{"name": info["title"], "url": f"/admin/services/{name}"},
],
schemas=[website_schema(base)],
)
tool_groups = tool_prefs.group_overview() if name == "devii" else None
return templates.TemplateResponse(
request,
"service_detail.html",
{
**seo_ctx,
"request": request,
"user": admin,
"service": info,
"tool_groups": tool_groups,
"admin_section": "services",
},
)
@router.get("/{name}/data")
async def service_detail_json(request: Request, name: str):
require_admin(request)
svc = service_manager.get_service(name)
if svc is None:
return JSONResponse({"error": "unknown service"}, status_code=404)
return JSONResponse({"service": svc.describe()})
def _audit_service(request: Request, admin: dict, name: str, event_key: str, summary: str, **kwargs: Any) -> None:
audit.record(
request,
event_key,
user=admin,
target_type="service",
target_uid=name,
target_label=name,
summary=summary,
links=[audit.service_link(name)],
**kwargs,
)
@router.post("/{name}/start")
async def service_start(request: Request, name: str):
admin = require_admin(request)
if not service_manager.set_enabled(name, True):
return JSONResponse({"ok": False, "error": "unknown service"}, status_code=404)
_audit_service(
request, admin, name, "service.start",
f"admin {admin['username']} started service {name}", new_value="enabled",
)
return JSONResponse({"ok": True})
@router.post("/{name}/stop")
async def service_stop(request: Request, name: str):
admin = require_admin(request)
if not service_manager.set_enabled(name, False):
return JSONResponse({"ok": False, "error": "unknown service"}, status_code=404)
_audit_service(
request, admin, name, "service.stop",
f"admin {admin['username']} stopped service {name}", new_value="disabled",
)
return JSONResponse({"ok": True})
@router.post("/{name}/run")
async def service_run(request: Request, name: str):
admin = require_admin(request)
if not service_manager.send_command(name, "run"):
return JSONResponse({"ok": False, "error": "unknown service"}, status_code=404)
_audit_service(
request, admin, name, "service.run_now",
f"admin {admin['username']} triggered an immediate run of service {name}",
)
return JSONResponse({"ok": True})
@router.post("/{name}/clear-logs")
async def service_clear_logs(request: Request, name: str):
admin = require_admin(request)
if not service_manager.send_command(name, "clear"):
return JSONResponse({"ok": False, "error": "unknown service"}, status_code=404)
_audit_service(
request, admin, name, "service.logs.clear",
f"admin {admin['username']} cleared logs for service {name}",
)
return JSONResponse({"ok": True})
@router.post("/{name}/config")
async def service_config(request: Request, name: str):
admin = require_admin(request)
svc = service_manager.get_service(name)
before = svc.get_config() if svc is not None else {}
form = await request.form()
result = service_manager.save_config(name, dict(form))
if result is None:
return JSONResponse({"ok": False, "error": "unknown service"}, status_code=404)
after = svc.get_config() if svc is not None else {}
for key, new_value in after.items():
old_value = before.get(key)
if old_value == new_value:
continue
audit.record(
request,
"service.config.update",
user=admin,
target_type="service",
target_uid=name,
target_label=name,
old_value=old_value,
new_value=new_value,
summary=f"admin {admin['username']} updated {key} of service {name}",
links=[audit.service_link(name), audit.setting(key)],
)
if not result["ok"]:
return JSONResponse(result, status_code=400)
return JSONResponse(result)
@router.post("/devii/tools")
async def devii_tools_config(request: Request):
admin = require_admin(request)
before = tool_prefs.disabled_tool_names()
form = await request.form()
enabled = set(form.getlist("enabled"))
known = set(tool_prefs.GROUPS_BY_TOOL_NAME)
after = known - enabled
tool_prefs.set_disabled_tool_names(after)
newly_disabled = sorted(after - before)
newly_enabled = sorted(before - after)
if newly_disabled or newly_enabled:
audit.record(
request,
"service.devii_tools.update",
user=admin,
target_type="service",
target_uid="devii",
target_label="devii",
old_value=f"{len(before)} disabled",
new_value=f"{len(after)} disabled",
summary=(
f"admin {admin['username']} updated the Devii tool catalog "
f"({len(newly_disabled)} disabled, {len(newly_enabled)} re-enabled)"
),
metadata={"disabled": newly_disabled, "enabled": newly_enabled},
links=[audit.service_link("devii")],
)
return JSONResponse({"ok": True, "disabled_count": len(after), "total_count": len(known)})